fix(web): images and file links render when a Windows path has a space

packages/shared/src/markdownLinks.test.ts

@@ -99,6 +99,10 @@ describe("extractMarkdownLinkHrefs", () => {
     ["[".repeat(32_000), []],
     ["[a](<foo)bar> invalid [b](ok)", ["<foo", "ok"]],
     ["[[[nested](src/main.ts) [unfinished", ["src/main.ts"]],
+    [
+      String.raw`[a](C:\Users\Jo Doe\.t3\a.png) [b](C:\Jo Doe\b.html "B")`,
+      [String.raw`C:\Users\Jo Doe\.t3\a.png`, String.raw`C:\Jo Doe\b.html`],
+    ],
   ])("extracts links from incomplete and nested text", (markdown, hrefs) => {
     expect(extractMarkdownLinkHrefs(markdown)).toEqual(hrefs);
   });

packages/shared/src/markdownLinks.ts

@@ -380,8 +380,66 @@ function markdownLinkDestinationScanner(markdown: string) {
   };
 }
 
-export function extractMarkdownLinkHrefs(markdown: string): string[] {
+// Stands in for a space inside a drive path destination while CommonMark parses it. One UTF-16
+// unit, so every source offset the renderers read stays where it was.
+const DESTINATION_SPACE = "\uE020";
+
+// `](C:\Users\Jo Doe\shot.png)` or with a title. Parentheses inside the path must balance.
+const SPACED_DRIVE_DESTINATION =
+  /\]\([ \t]*([A-Za-z]:[\\/](?:[^()\n]|\([^()\n]*\))*?)(?=(?:[ \t]+"[^"\n]*")?[ \t]*\))/g;
+const HAS_SPACED_DRIVE_DESTINATION = /\]\([ \t]*[A-Za-z]:[\\/][^)\n]* [^)\n]*\)/;
+const CODE_FENCE = /^ {0,3}(`{3,}|~{3,})/;
+const INLINE_CODE = /(`+)[^`]*?\1/g;
+
+function protectDestinationsOutsideInlineCode(line: string): string {
+  let result = "";
+  let cursor = 0;
+  const protect = (segment: string) =>
+    segment.replace(
+      SPACED_DRIVE_DESTINATION,
+      (match: string, destination: string) =>
+        match.slice(0, match.length - destination.length) +
+        destination.replaceAll(" ", DESTINATION_SPACE),
+    );
+  for (const code of line.matchAll(INLINE_CODE)) {
+    result += protect(line.slice(cursor, code.index)) + code[0];
+    cursor = code.index + code[0].length;
+  }
+  return result + protect(line.slice(cursor));
+}
+
+/**
+ * CommonMark ends a bare destination at its first space, so `![shot](C:\Users\Jo Doe\a.png)`
+ * renders as text. Agents write Windows paths that way, so a drive path destination keeps its
+ * spaces until the parser has read it. Code stays as written.
+ */
+export function protectSpacedWindowsDestinations(markdown: string): string {
+  if (!HAS_SPACED_DRIVE_DESTINATION.test(markdown)) return markdown;
+  let fence: string | null = null;
+  return markdown
+    .split("\n")
+    .map((line) => {
+      const marker = CODE_FENCE.exec(line)?.[1];
+      if (fence !== null) {
+        if (marker && marker[0] === fence[0] && marker.length >= fence.length) fence = null;
+        return line;
+      }
+      if (marker) {
+        fence = marker;
+        return line;
+      }
+      return line.includes("](") ? protectDestinationsOutsideInlineCode(line) : line;
+    })
+    .join("\n");
+}
+
+export function restoreWindowsDestinationSpaces(value: string): string {
+  return value.includes(DESTINATION_SPACE) ? value.replaceAll(DESTINATION_SPACE, " ") : value;
+}
+
+export function extractMarkdownLinkHrefs(source: string): string[] {
   const hrefs: string[] = [];
+  const markdown = protectSpacedWindowsDestinations(source);
   const scanDestination = markdownLinkDestinationScanner(markdown);
   let cursor = 0;
   while (cursor < markdown.length) {
@@ -396,7 +454,7 @@ export function extractMarkdownLinkHrefs(markdown: string): string[] {
     if (!destination) continue;
     cursor = destination.end;
     const href = markdown.slice(destination.hrefStart, destination.hrefEnd).trim();
-    if (href) hrefs.push(href);
+    if (href) hrefs.push(restoreWindowsDestinationSpaces(href));
   }
   return hrefs;
 }

packages/shared/src/markdownPipeline.test.ts

@@ -118,6 +118,42 @@ it("keeps backslashes that CommonMark would read as escapes in prose Windows pat
   );
 });
 
+it("reads Windows drive path destinations that contain spaces", () => {
+  const processor = unified()
+    .use(remarkParse)
+    .use(CHAT_MARKDOWN_REMARK_PLUGINS)
+    .use(remarkRehype, { allowDangerousHtml: true })
+    .use(CHAT_MARKDOWN_REHYPE_PLUGINS);
+  type Node = {
+    type: string;
+    value?: string;
+    tagName?: string;
+    properties?: { href?: string; dataLocalSrc?: string };
+    children?: Node[];
+  };
+  const shape = (node: Node): string =>
+    node.type === "text"
+      ? (node.value ?? "")
+      : node.tagName === "img"
+        ? `<img ${decodeURIComponent(node.properties?.dataLocalSrc ?? "")}>`
+        : node.tagName === "a"
+          ? `<a ${decodeURIComponent(node.properties?.href ?? "")}>`
+          : (node.children ?? []).map(shape).join("");
+  const render = (markdown: string) => shape(processor.runSync(processor.parse(markdown)) as Node);
+
+  expect(render(String.raw`![Nell's line](C:\Users\Jo Doe\.claude\shot.png)`)).toBe(
+    String.raw`<img C:\Users\Jo Doe\.claude\shot.png>`,
+  );
+  expect(render(String.raw`[balance.html](C:\Program Files (x86)\a b\balance.html "Run")`)).toBe(
+    "<a file:///C:/Program Files (x86)/a b/balance.html>",
+  );
+  expect(
+    render(
+      "`[a](C:\\Jo Doe\\a.png)`\n\n```md\n![a](C:\\Jo Doe\\a.png)\n```\n\n[a](C:\\Jo Doe\\a.png",
+    ),
+  ).toBe("[a](C:\\Jo Doe\\a.png)\n![a](C:\\Jo Doe\\a.png)\n\n[a](C:\\Jo Doe\\a.png");
+});
+
 it("keeps an image on its own line under a label but leaves inline images inline", () => {
   const processor = unified()
     .use(remarkParse)

packages/shared/src/markdownWindowsPaths.ts

@@ -1,6 +1,22 @@
 import type { Processor } from "unified";
+import {
+  protectSpacedWindowsDestinations,
+  restoreWindowsDestinationSpaces,
+} from "./markdownLinks.ts";
 import { isWindowsAbsolutePath } from "./path.ts";
 
+interface RestorableNode {
+  value?: unknown;
+  url?: unknown;
+  children?: RestorableNode[];
+}
+
+function restoreTreeDestinationSpaces(node: RestorableNode) {
+  if (typeof node.url === "string") node.url = restoreWindowsDestinationSpaces(node.url);
+  if (typeof node.value === "string") node.value = restoreWindowsDestinationSpaces(node.value);
+  node.children?.forEach(restoreTreeDestinationSpaces);
+}
+
 interface DestinationCompileContext {
   readonly stack: ReadonlyArray<{ readonly type: string; url?: string }>;
   resume(): string;
@@ -64,4 +80,13 @@ export function remarkKeepWindowsPaths(this: Processor) {
       characterEscape: keepWindowsPathEscape,
     },
   });
+  const parse = this.parser;
+  if (!parse) return;
+  // Restore before returning, so parsers that cache this tree (streaming) keep the real spaces.
+  this.parser = (document, file) => {
+    const protectedDocument = protectSpacedWindowsDestinations(document);
+    const tree = parse(protectedDocument, file);
+    if (protectedDocument !== document) restoreTreeDestinationSpaces(tree as RestorableNode);
+    return tree;
+  };
 }