@hienlh/ppm 0.22.4 → 0.22.5

package/src/web/components/layout/command-palette.tsx

@@ -35,6 +35,7 @@ import { usePanelStore } from "@/stores/panel-store";
 import { api } from "@/lib/api-client";
 import { basename } from "@/lib/utils";
 import { scoreFileSearchFast, compareScores, getFilename, type FileSearchScore } from "@/lib/score-file-search";
+import { splitSourceLocation, type SourceLine } from "@/lib/source-location";
 import { CommandPaletteFilterChips } from "@/components/layout/command-palette-filter-chips";
 import { dispatchExtCommand } from "@/lib/ext-command-dispatch";
 import { fileIconElement } from "@/lib/file-icons";
@@ -122,6 +123,7 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
   const listRef = useRef<HTMLDivElement>(null);
 
   const openTab = useTabStore((s) => s.openTab);
+  const updateTab = useTabStore((s) => s.updateTab);
   const activeProject = useProjectStore((s) => s.activeProject);
   const fileIndex = useFileStore((s) => s.fileIndex);
   const indexStatus = useFileStore((s) => s.indexStatus);
@@ -136,6 +138,38 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
   const isTouchOnly = useIsTouchOnly();
   const lspEnabled = useSettingsStore((s) => s.lspEnabled);
 
+  /**
+   * A query may name one place in a file — `app.ts:120`, `app.ts:120-140`, `app.ts#L120` —
+   * which is what a Markdown file link falls back to when its path resolves to nothing.
+   * The suffix has to come off before searching, or it is matched against filenames that
+   * never contain it and the query finds nothing at all.
+   */
+  const typed = useMemo(() => splitSourceLocation(query) ?? { path: query }, [query]);
+  const searchPath = useMemo(
+    () => splitSourceLocation(deferredQuery)?.path ?? deferredQuery,
+    [deferredQuery],
+  );
+
+  /**
+   * Read when an item is actually picked, rather than closed over per command: the file
+   * commands are built from the entire project index, and rebuilding thousands of them on
+   * each keystroke of `:120` costs far more than carrying the line this way.
+   */
+  const lineTargetRef = useRef<SourceLine | undefined>(undefined);
+  useEffect(() => { lineTargetRef.current = typed.line; }, [typed.line]);
+
+  /** Open a file as an editor tab, jumping to the line the query named. */
+  const openFileTab = useCallback((path: string, title: string, projectId: string | null, meta?: { projectName: string }) => {
+    const line = lineTargetRef.current;
+    const metadata: Record<string, unknown> = { ...meta, filePath: path };
+    if (line) Object.assign(metadata, { lineNumber: line.start, endLine: line.end, revealAt: Date.now() });
+    const id = openTab({ type: "editor", title, projectId, metadata, closable: true });
+    // A tab already open on this file is deduped by filePath and keeps the metadata it was
+    // opened with, so the new line has to be pushed onto it for the reveal effect to fire.
+    if (line && id) updateTab(id, { metadata });
+    onClose();
+  }, [openTab, updateTab, onClose]);
+
   // Fetch filesystem files when path query changes directory
   const fetchFsFiles = useCallback(async (dir: string) => {
     if (fsCache.has(dir)) {
@@ -156,13 +190,13 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
 
   // When query changes and looks like a path, fetch files
   useEffect(() => {
-    if (!isPathQuery(query)) {
+    if (!isPathQuery(typed.path)) {
       setFsFiles([]);
       return;
     }
-    const dir = extractDir(query);
+    const dir = extractDir(typed.path);
     fetchFsFiles(dir);
-  }, [query, fetchFsFiles]);
+  }, [typed.path, fetchFsFiles]);
 
   // Debounced DB table search
   useEffect(() => {
@@ -310,18 +344,9 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
       keywords: f.path,
       // Propagate gitignore flag for muted rendering (only present on /files/index entries)
       isIgnored: ("isIgnored" in f ? f.isIgnored : undefined) as boolean | undefined,
-      action: () => {
-        openTab({
-          type: "editor",
-          title: f.name,
-          projectId,
-          metadata: { ...meta, filePath: f.path },
-          closable: true,
-        });
-        onClose();
-      },
+      action: () => openFileTab(f.path, f.name, projectId, meta),
     }));
-  }, [indexStatus, fileIndex, fileTree, activeProject, openTab, onClose]);
+  }, [indexStatus, fileIndex, fileTree, activeProject, openFileTab]);
 
   // Filesystem commands — from cached API results
   const fsCommands = useMemo<CommandItem[]>(() => {
@@ -337,19 +362,10 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
         icon: FolderOpen,
         group: "fs" as const,
         keywords: fp,
-        action: () => {
-          openTab({
-            type: "editor",
-            title: name,
-            projectId,
-            metadata: { ...meta, filePath: fp },
-            closable: true,
-          });
-          onClose();
-        },
+        action: () => openFileTab(fp, name, projectId, meta),
       };
     });
-  }, [fsFiles, activeProject, openTab, onClose]);
+  }, [fsFiles, activeProject, openFileTab]);
 
   const dbCommands = useMemo<CommandItem[]>(() => dbResults.map((r) => ({
     id: `db:${r.connectionId}:${r.schemaName}.${r.tableName}`,
@@ -395,9 +411,9 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
 
   const filtered = useMemo(() => {
     // Path mode — search filesystem results using filename portion only
-    if (isPathQuery(deferredQuery)) {
-      const lastSlash = deferredQuery.lastIndexOf("/");
-      const fileFilter = lastSlash >= 0 ? deferredQuery.slice(lastSlash + 1).toLowerCase() : "";
+    if (isPathQuery(searchPath)) {
+      const lastSlash = searchPath.lastIndexOf("/");
+      const fileFilter = lastSlash >= 0 ? searchPath.slice(lastSlash + 1).toLowerCase() : "";
       if (!fileFilter) return fsCommands.slice(0, 50);
       return fsCommands.filter((c) => {
         const name = c.label.toLowerCase();
@@ -407,9 +423,9 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
     }
 
     // Normal mode
-    if (!deferredQuery.trim()) return actionCommands;
+    if (!searchPath.trim()) return actionCommands;
     // Strip leading ./ or ../ — index paths are relative without dot prefix
-    const qLower = deferredQuery.toLowerCase().replace(/^\.\.?\//, "");
+    const qLower = searchPath.toLowerCase().replace(/^\.\.?\//, "");
     const scored: Array<{ cmd: CommandItem; score: FileSearchScore }> = [];
     for (const entry of searchIndex) {
       const s = scoreFileSearchFast(qLower, entry.filenameLower, entry.pathLower, entry.labelLen, entry.depth);
@@ -419,7 +435,7 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
     const matched = scored.slice(0, MAX_RESULTS).map((s) => s.cmd);
     // Prepend DB results (already filtered server-side) when query is 2+ chars
     return deferredQuery.trim().length >= 2 ? [...dbCommands, ...matched] : matched;
-  }, [searchIndex, actionCommands, fsCommands, dbCommands, deferredQuery]);
+  }, [searchIndex, actionCommands, fsCommands, dbCommands, deferredQuery, searchPath]);
 
   // Stable set of groups that have data (pre-query) — prevents chip flashing
   const availableGroups = useMemo(() => {
@@ -527,7 +543,7 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
 
   if (!open) return null;
 
-  const pathMode = isPathQuery(query);
+  const pathMode = isPathQuery(typed.path);
 
   return (
     <div className="fixed inset-0 z-50 flex items-end md:items-start justify-center md:pt-[20vh]" onClick={onClose}>

package/src/web/components/shared/markdown-context.ts

@@ -1,5 +1,6 @@
 import { createContext, useContext } from "react";
 import { defaultUrlTransform } from "react-markdown";
+import { splitSourceLocation, type SourceLine } from "@/lib/source-location";
 
 /** Common text file extensions that PPM can open as editor tabs */
 const FILE_EXTS = "ts|tsx|js|jsx|mjs|cjs|py|json|md|mdx|yaml|yml|toml|css|scss|less|html|htm|sh|bash|zsh|go|rs|sql|rb|java|kt|swift|c|cpp|h|hpp|cs|vue|svelte|txt|env|cfg|conf|ini|xml|csv|log|dockerfile|makefile|gradle|output";
@@ -9,9 +10,31 @@ export const GLOB_CHARS_RE = /[*?{}\[\]]/;
 /** Detect local absolute file paths (Unix or Windows) */
 export const LOCAL_PATH_RE = /^(\/|[A-Za-z]:[/\\])/;
 
-/** Keep Windows absolute file links intact; defer all other URL safety filtering to react-markdown. */
+/** Preserve local destinations; keep react-markdown's safety filter for other schemes. */
 export function markdownUrlTransform(url: string): string {
-  return LOCAL_PATH_RE.test(url) ? url : defaultUrlTransform(url);
+  return LOCAL_PATH_RE.test(url) || parseMarkdownFileTarget(url) ? url : defaultUrlTransform(url);
+}
+
+/** Parse local links independently of file extensions; the host determines file vs folder. */
+export function parseMarkdownFileTarget(href: string) {
+  if (!href || href.startsWith("#") || /[?*\u0000-\u001f]/.test(href)) return null;
+  let destination = href;
+  if (/^file:/i.test(destination)) {
+    const local = destination.match(/^file:\/\/(?:localhost)?(\/.*)$/i);
+    if (!local) return null; // Remote file authorities/UNC are unsupported by the host API.
+    destination = local[1]!;
+  }
+  const located = splitSourceLocation(destination);
+  if (!located) return null; // A suffix naming an impossible line is a broken reference, not line 1.
+  // A document heading still opens the document; a pure anchor stays in the page.
+  let path = located.line ? located.path : located.path.split("#")[0]!;
+  try { path = decodeURIComponent(path); } catch { return null; }
+  // Check schemes after separating line numbers: config.ts:136 is a file reference.
+  if (!path || /[\u0000-\u001f\u007f]/.test(path) || /^[\\/]{2}/.test(path)
+    || (/^[a-z][a-z\d+.-]*:/i.test(path) && !/^[a-z]:[/\\]/i.test(path))) return null;
+  // Codex prefixes Windows drive paths with a slash in Markdown destinations.
+  path = path.replace(/^\/([a-z]:[/\\])/i, "$1");
+  return { path, line: located.line };
 }
 
 export interface MdContextValue {
@@ -19,7 +42,7 @@ export interface MdContextValue {
   codeActions: boolean;
   /** True while the message is still streaming — defer async Shiki highlight until done. */
   isStreaming: boolean;
-  openFileOrSearch: (path: string, line?: { start: number; end?: number }) => void;
+  openFileOrSearch: (path: string, line?: SourceLine) => void;
   openImageOverlay: (url: string, alt: string, gallery?: { src: string; alt: string }[]) => void;
   openDiagramOverlay: (svg: string) => void;
 }

package/src/web/components/shared/markdown-renderer.tsx

@@ -1,20 +1,18 @@
-import { useMemo, useCallback, useState, useEffect } from "react";
+import { useMemo, useState, useEffect } from "react";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
 import remarkBreaks from "remark-breaks";
 import rehypeRaw from "rehype-raw";
 import rehypeKatex from "rehype-katex";
-import { useTabStore } from "@/stores/tab-store";
-import { useFileStore, type FileNode } from "@/stores/file-store";
 import { useImageOverlay } from "@/stores/image-overlay-store";
 import { collectGallery, GALLERY_ITEM_ATTR } from "@/lib/image-gallery";
 import { useDiagramOverlay } from "@/stores/diagram-overlay-store";
-import { openCommandPalette } from "@/hooks/use-global-keybindings";
-import { useBackgroundOutputStore } from "@/stores/background-output-store";
-import { api, projectUrl, getAuthToken } from "@/lib/api-client";
+import { getAuthToken } from "@/lib/api-client";
 import { basename } from "@/lib/utils";
-import { MdContext, useMdContext, FILE_EXT_RE, GLOB_CHARS_RE, LOCAL_PATH_RE, markdownUrlTransform } from "./markdown-context";
+import { normalizeMathDelimiters } from "@/lib/markdown-math-delimiters";
+import { MdContext, useMdContext, LOCAL_PATH_RE, markdownUrlTransform, parseMarkdownFileTarget } from "./markdown-context";
+import { useMarkdownFileNavigation } from "./use-markdown-file-navigation";
 import { MdPre, MdCode } from "./markdown-code-block";
 
 interface MarkdownRendererProps {
@@ -31,74 +29,13 @@ const rehypePlugins = [rehypeRaw, rehypeKatex] as any;
 /** Component map — stable references; dynamic state flows through MdContext */
 const mdComponents = { a: MdLink, img: MdImage, pre: MdPre, code: MdCode, table: MdTable };
 
-function findInTree(nodes: FileNode[], name: string): string[] {
-  const results: string[] = [];
-  for (const n of nodes) {
-    if (n.type === "file" && n.name === name) results.push(n.path);
-    if (n.children) results.push(...findInTree(n.children, name));
-  }
-  return results;
-}
-
 export function MarkdownRenderer({ content, projectName, className = "", codeActions = false, isStreaming = false }: MarkdownRendererProps) {
-  const openTab = useTabStore((s) => s.openTab);
-  const updateTab = useTabStore((s) => s.updateTab);
-  const fileTree = useFileStore((s) => s.tree);
   const openImageOverlayFn = useImageOverlay((s) => s.open);
   const openDiagramOverlayFn = useDiagramOverlay((s) => s.open);
-
-  const openFileOrSearch = useCallback((filePath: string, line?: { start: number; end?: number }) => {
-    if (!filePath) return;
-
-    // Background command .output reference → open the live output panel (resolves the
-    // bare basename to the tracked shell's absolute outputPath; opened via /api/fs/read).
-    if (/\.output$/.test(filePath)) {
-      const store = useBackgroundOutputStore.getState();
-      const shell = store.findByOutput(filePath);
-      if (shell) { store.openPanel(shell.shellId); return; }
-    }
-
-    const isAbsolute = /^(\/|[A-Za-z]:[/\\])/.test(filePath);
-    const isRelative = /^(\.\/|\.\.\/)/.test(filePath);
-    const fileName = basename(filePath);
-
-    // Open editor tab; when a line target is given, also updateTab so an already-open
-    // tab (deduped by filePath) jumps to the new line. revealAt forces the editor's
-    // reveal effect to fire even when the same line is clicked again.
-    const openAt = (meta: Record<string, unknown>, title: string, projectId: string | null) => {
-      const full = { ...meta };
-      if (line) { full.lineNumber = line.start; full.endLine = line.end; full.revealAt = Date.now(); }
-      const id = openTab({ type: "editor", title, metadata: full, projectId, closable: true });
-      if (line && id) updateTab(id, { metadata: full });
-    };
-
-    const searchAndOpen = (fp: string) => {
-      const matches = findInTree(fileTree, basename(fp));
-      if (matches.length === 1) {
-        openAt({ filePath: matches[0], projectName }, basename(fp), projectName ?? null);
-      } else {
-        openCommandPalette(fp);
-      }
-    };
-
-    if (isAbsolute) {
-      const meta: Record<string, unknown> = { filePath };
-      if (projectName) meta.projectName = projectName;
-      api.get(`/api/fs/read?path=${encodeURIComponent(filePath)}`).then(() => {
-        openAt(meta, fileName, null);
-      }).catch(() => openCommandPalette(filePath));
-      return;
-    }
-
-    if (isRelative && projectName) {
-      api.get(`${projectUrl(projectName)}/files/read?path=${encodeURIComponent(filePath)}`)
-        .then(() => openAt({ filePath, projectName }, fileName, projectName))
-        .catch(() => searchAndOpen(filePath));
-      return;
-    }
-
-    searchAndOpen(filePath);
-  }, [openTab, updateTab, fileTree, projectName]);
+  const openFileOrSearch = useMarkdownFileNavigation(projectName);
+  // Before parsing, because Markdown reads `\[` as an escaped bracket and the backslash is
+  // gone by the time there is a tree to walk.
+  const source = useMemo(() => normalizeMathDelimiters(content), [content]);
 
   const ctx = useMemo(() => ({
     projectName, codeActions, isStreaming, openFileOrSearch,
@@ -115,7 +52,7 @@ export function MarkdownRenderer({ content, projectName, className = "", codeAct
           urlTransform={markdownUrlTransform}
           components={mdComponents}
         >
-          {content}
+          {source}
         </ReactMarkdown>
       </div>
     </MdContext.Provider>
@@ -125,11 +62,12 @@ export function MarkdownRenderer({ content, projectName, className = "", codeAct
 /** Link — external links open in new tab; file paths open in editor */
 function MdLink({ href, children, node, ...props }: any) {
   const { openFileOrSearch } = useMdContext();
-  if (href?.match(/^https?:\/\//)) {
+  if (href?.match(/^(https?:)?\/\//i)) {
     return <a href={href} target="_blank" rel="noopener noreferrer" {...props}>{children}</a>;
   }
-  if (href && !GLOB_CHARS_RE.test(href) && FILE_EXT_RE.test(href)) {
-    return <a href={href} onClick={(e: React.MouseEvent) => { e.preventDefault(); openFileOrSearch(href); }} {...props}>{children}</a>;
+  const target = href ? parseMarkdownFileTarget(href) : null;
+  if (target) {
+    return <a href={href} onClick={(e: React.MouseEvent) => { e.preventDefault(); openFileOrSearch(target.path, target.line); }} {...props}>{children}</a>;
   }
   return <a href={href} {...props}>{children}</a>;
 }

package/src/web/components/shared/use-markdown-file-navigation.ts

@@ -0,0 +1,71 @@
+import { useCallback } from "react";
+import { useTabStore } from "@/stores/tab-store";
+import { useFileStore, absoluteProjectPath, relativeProjectPath, type FileNode } from "@/stores/file-store";
+import { useProjectStore } from "@/stores/project-store";
+import { useBackgroundOutputStore } from "@/stores/background-output-store";
+import { openCommandPalette } from "@/hooks/use-global-keybindings";
+import { formatSourceLocation, type SourceLine } from "@/lib/source-location";
+import { openExplorer } from "@/components/os-explorer/open-explorer";
+import { fsApi } from "@/lib/fs-api";
+import { basename } from "@/lib/utils";
+
+function findInTree(nodes: FileNode[], name: string): string[] {
+  return nodes.flatMap((node) => [
+    ...(node.name === name ? [node.path] : []),
+    ...findInTree(node.children ?? [], name),
+  ]);
+}
+
+/** Resolve against the host/project, never against the browser's OS or URL. */
+export function useMarkdownFileNavigation(projectName?: string) {
+  const openTab = useTabStore((s) => s.openTab);
+  const updateTab = useTabStore((s) => s.updateTab);
+  return useCallback(async (filePath: string, line?: SourceLine) => {
+    if (!filePath) return;
+    // Hand the line to the palette too, so picking a candidate there still lands on it.
+    const search = () => openCommandPalette(formatSourceLocation(filePath, line));
+    if (/\.output$/.test(filePath)) {
+      const store = useBackgroundOutputStore.getState();
+      const shell = store.findByOutput(filePath);
+      if (shell) { store.openPanel(shell.shellId); return; }
+    }
+
+    const root = useProjectStore.getState().projects.find((p) => p.name === projectName)?.path;
+    const absolute = /^(\/|[a-z]:[/\\]|~(?:[/\\]|$))/i.test(filePath);
+    const candidate = absolute ? filePath : root ? absoluteProjectPath(root, filePath) : null;
+    if (!candidate) { search(); return; }
+
+    const openPath = async (path: string) => {
+      let entry = await fsApi.stat(path);
+      // Follow links through the guarded API, with a bound for cycles/broken links.
+      for (let depth = 0; entry.kind === "symlink" && entry.target && depth < 8; depth++) {
+        const target = entry.target;
+        const parent = entry.path.slice(0, entry.path.length - entry.name.length);
+        entry = await fsApi.stat(/^(\/|[a-z]:[/\\])/i.test(target) ? target : absoluteProjectPath(parent, target));
+      }
+      if (entry.kind === "directory") { await openExplorer(entry.path); return; }
+      if (entry.kind !== "file") { search(); return; }
+      // Keep project-relative identity so Explorer tabs dedupe and editor LSP stays enabled.
+      const relative = root ? relativeProjectPath(root, entry.path) : null;
+      const metadata: Record<string, unknown> = { filePath: relative ?? entry.path };
+      if (projectName) metadata.projectName = projectName;
+      if (line) Object.assign(metadata, { lineNumber: line.start, endLine: line.end, revealAt: Date.now() });
+      const id = openTab({ type: "editor", title: entry.name, metadata, projectId: relative !== null ? projectName ?? null : null, closable: true });
+      if (line && id) updateTab(id, { metadata });
+    };
+
+    try {
+      await openPath(candidate);
+    } catch {
+      // Only bare names may use basename search. An explicit missing path must not
+      // silently open an unrelated same-named file elsewhere in the project.
+      if (!absolute && !/[/\\]/.test(filePath) && root) {
+        const matches = findInTree(useFileStore.getState().tree, basename(filePath));
+        if (matches.length === 1) {
+          try { await openPath(absoluteProjectPath(root, matches[0]!)); return; } catch { /* search below */ }
+        }
+      }
+      search();
+    }
+  }, [projectName, openTab, updateTab]);
+}

package/src/web/lib/markdown-math-delimiters.ts

@@ -0,0 +1,127 @@
+/**
+ * `\[ … \]` and `\( … \)` are how most models write display and inline maths, and
+ * `remark-math` understands neither — it knows `$` and `$$` only.
+ *
+ * The result is worse than an unrendered formula. Markdown reads `\[` as an *escaped
+ * bracket*, so a Codex answer came out as a lone `[`, its body as plain prose
+ * (`\text{Ngân sách} = \frac{950}{1{,}10}`) and a lone `]`, one line per `<br>`.
+ *
+ * Rewriting the delimiters to `$$` before parsing is the whole fix. Both forms become `$$`
+ * rather than the inline form taking a single `$`: single-dollar text maths is off on
+ * purpose, because a sentence pricing two things in dollars would otherwise be swallowed
+ * whole between them.
+ */
+
+type Range = readonly [start: number, end: number];
+
+/** `$$` is what remark-math reads, as flow when it sits on its own line and inline otherwise. */
+const MATH_FENCE = "$$";
+
+const FORMS = [
+  /** Display maths, which is written across lines as often as not. */
+  { open: "\\[", close: "\\]", allowNewline: true },
+  /**
+   * Inline maths, and the one that has to be bounded to a single line. A Windows path in
+   * prose — `app\(tabs)\_layout.tsx` — opens with the same two characters, and without the
+   * bound it would pair with a `\)` somewhere further down the message and eat everything
+   * between. Inline maths never spans a line break, so the bound costs nothing.
+   */
+  { open: "\\(", close: "\\)", allowNewline: false },
+] as const;
+
+/** Fenced code blocks, including one still unclosed because the message is mid-stream. */
+function fencedRanges(markdown: string): Range[] {
+  const ranges: Range[] = [];
+  let openChar = "";
+  let openLength = 0;
+  let openAt = -1;
+  let offset = 0;
+  for (const line of markdown.split("\n")) {
+    const end = offset + line.length;
+    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+    if (openAt >= 0) {
+      // A closing fence carries nothing but its own run of markers.
+      if (marker && marker[1]![0] === openChar && marker[1]!.length >= openLength && /^ {0,3}[`~]+[ \t]*$/.test(line)) {
+        ranges.push([openAt, end]);
+        openAt = -1;
+      }
+    } else if (marker) {
+      openChar = marker[1]![0]!;
+      openLength = marker[1]!.length;
+      openAt = offset;
+    }
+    offset = end + 1;
+  }
+  if (openAt >= 0) ranges.push([openAt, markdown.length]);
+  return ranges;
+}
+
+/** Backtick spans outside the fenced blocks — where a path or a regex is usually written. */
+function inlineCodeRanges(markdown: string, fenced: Range[]): Range[] {
+  const ranges: Range[] = [];
+  let i = 0;
+  while (i < markdown.length) {
+    const fence = fenced.find(([start, end]) => i >= start && i < end);
+    if (fence) { i = fence[1]; continue; }
+    if (markdown[i] !== "`") { i++; continue; }
+    let run = 0;
+    while (markdown[i + run] === "`") run++;
+    let j = i + run;
+    let closed = -1;
+    while (j < markdown.length) {
+      if (markdown[j] !== "`") { j++; continue; }
+      let candidate = 0;
+      while (markdown[j + candidate] === "`") candidate++;
+      if (candidate === run) { closed = j + candidate; break; }
+      j += candidate;
+    }
+    // An unmatched run is ordinary text, so only the run itself is stepped over.
+    if (closed < 0) { i += run; continue; }
+    ranges.push([i, closed]);
+    i = closed;
+  }
+  return ranges;
+}
+
+/**
+ * Rewrite LaTeX delimiters to the ones `remark-math` reads, leaving code alone.
+ *
+ * Anything without a closing delimiter is left exactly as it was — which is also what keeps
+ * a half-streamed formula from being rewritten into a broken one and back again.
+ */
+export function normalizeMathDelimiters(markdown: string): string {
+  // Free for the overwhelming majority of messages, which contain no maths at all.
+  if (!markdown.includes("\\[") && !markdown.includes("\\(")) return markdown;
+
+  const fenced = fencedRanges(markdown);
+  const code = [...fenced, ...inlineCodeRanges(markdown, fenced)];
+  const inCode = (index: number) => code.some(([start, end]) => index >= start && index < end);
+
+  let out = "";
+  let i = 0;
+  while (i < markdown.length) {
+    const skip = code.find(([start, end]) => i >= start && i < end);
+    if (skip) { out += markdown.slice(i, skip[1]); i = skip[1]; continue; }
+
+    const form = FORMS.find((f) => markdown.startsWith(f.open, i));
+    // `\\[` is an escaped backslash next to a bracket, not an opening delimiter.
+    if (!form || markdown[i - 1] === "\\") { out += markdown[i]; i++; continue; }
+
+    const bodyStart = i + form.open.length;
+    const limit = form.allowNewline ? markdown.length : indexOrEnd(markdown, "\n", bodyStart);
+    let close = -1;
+    for (let j = bodyStart; j <= limit - form.close.length; j++) {
+      if (markdown.startsWith(form.close, j) && !inCode(j)) { close = j; break; }
+    }
+    if (close < 0) { out += markdown[i]; i++; continue; }
+
+    out += MATH_FENCE + markdown.slice(bodyStart, close) + MATH_FENCE;
+    i = close + form.close.length;
+  }
+  return out;
+}
+
+function indexOrEnd(text: string, needle: string, from: number): number {
+  const found = text.indexOf(needle, from);
+  return found < 0 ? text.length : found;
+}

package/src/web/lib/source-location.ts

@@ -0,0 +1,47 @@
+/**
+ * The `:120` / `#L120` suffix a tool writes after a path to point at one place in a file.
+ *
+ * Shared because two callers have to agree on it: a Markdown link's destination
+ * (`[label](src/app.ts:120)`) and a command palette query, which is the fallback when that
+ * link resolves to nothing. Parsing it in one place is also what keeps the palette's search
+ * text and the line it jumps to from disagreeing.
+ */
+export interface SourceLine {
+  start: number;
+  /** Inclusive last line of a range; absent for a single line. */
+  end?: number;
+}
+
+/**
+ * `:120`, `:120:5` (column, discarded), `:120-140`, `#L120`, `#L120-L140`.
+ * Lazy head so the *last* suffix wins: `C:/src/app.ts:120` keeps the drive letter.
+ */
+const SOURCE_LOCATION_RE = /^(.*?)(?::(\d+)(?::\d+|-(\d+))?|#L(\d+)(?:-L?(\d+))?)$/;
+
+/**
+ * Split a trailing source location off `text`.
+ *
+ * Returns `null` when a suffix is present but names an impossible line, so a caller can
+ * reject the reference outright. Silently dropping it would be worse than useless: it opens
+ * line 1 of a file while the text still promises line 0, and nothing on screen says the
+ * number was ignored.
+ */
+export function splitSourceLocation(text: string): { path: string; line?: SourceLine } | null {
+  const match = text.match(SOURCE_LOCATION_RE);
+  if (!match) return { path: text };
+  const start = Number(match[2] ?? match[4]);
+  const rawEnd = match[3] ?? match[5];
+  if (!Number.isSafeInteger(start) || start < 1) return null;
+  if (rawEnd !== undefined) {
+    const end = Number(rawEnd);
+    if (!Number.isSafeInteger(end) || end < start) return null;
+    return { path: match[1]!, line: { start, end } };
+  }
+  return { path: match[1]!, line: { start } };
+}
+
+/** Render a location back into a query string the palette can parse again. */
+export function formatSourceLocation(path: string, line?: SourceLine): string {
+  if (!line) return path;
+  return `${path}:${line.start}${line.end ? `-${line.end}` : ""}`;
+}