fix: parse file url anchors without re-parsing paths

Author: Reekin

src/features/messages/components/Markdown.test.tsx

@@ -566,4 +566,26 @@ describe("Markdown file-like href behavior", () => {
     expect(clickEvent.defaultPrevented).toBe(true);
     expect(onOpenFileLink).toHaveBeenCalledWith("//server/share/100%.tsx:12");
   });
+
+  it("keeps encoded #L-like filenames intact when opening file URLs", () => {
+    const onOpenFileLink = vi.fn();
+    render(
+      <Markdown
+        value="See [report](file:///tmp/report%23L12.md)"
+        className="markdown"
+        onOpenFileLink={onOpenFileLink}
+      />,
+    );
+
+    const link = screen.getByText("report").closest("a");
+    expect(link?.getAttribute("href")).toBe("file:///tmp/report%23L12.md");
+
+    const clickEvent = createEvent.click(link as Element, {
+      bubbles: true,
+      cancelable: true,
+    });
+    fireEvent(link as Element, clickEvent);
+    expect(clickEvent.defaultPrevented).toBe(true);
+    expect(onOpenFileLink).toHaveBeenCalledWith("/tmp/report#L12.md");
+  });
 });

src/features/messages/components/Markdown.tsx

@@ -836,6 +836,8 @@ export function Markdown({
         remarkPlugins={[remarkGfm, remarkFileLinks]}
         urlTransform={(url) => {
           const hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(url);
+          // Keep file-like hrefs intact before scheme sanitization runs, otherwise
+          // Windows absolute paths such as C:/repo/file.ts look like unknown schemes.
           if (resolveHrefFilePath(url)) {
             return url;
           }

src/utils/fileLinks.test.ts

@@ -25,6 +25,18 @@ function withThrowingUrlConstructor(run: () => void) {
 }
 
 describe("fromFileUrl", () => {
+  it("keeps encoded #L-like path segments as part of the decoded filename", () => {
+    expect(fromFileUrl("file:///tmp/%23L12")).toBe("/tmp/#L12");
+    expect(fromFileUrl("file:///tmp/report%23L12C3.md")).toBe("/tmp/report#L12C3.md");
+  });
+
+  it("uses only the real URL fragment as a line anchor", () => {
+    expect(fromFileUrl("file:///tmp/report%23L12.md#L34")).toBe("/tmp/report#L12.md:34");
+    expect(fromFileUrl("file:///tmp/report%23L12C3.md#L34C2")).toBe(
+      "/tmp/report#L12C3.md:34:2",
+    );
+  });
+
   it("keeps Windows drive paths when decoding a file URL with an unescaped percent", () => {
     expect(fromFileUrl("file:///C:/repo/100%.tsx#L12")).toBe("C:/repo/100%.tsx:12");
   });
@@ -51,4 +63,11 @@ describe("fromFileUrl", () => {
       );
     });
   });
+
+  it("keeps encoded #L-like path segments when the URL constructor fallback is used", () => {
+    withThrowingUrlConstructor(() => {
+      expect(fromFileUrl("file:///tmp/%23L12")).toBe("/tmp/#L12");
+      expect(fromFileUrl("file:///tmp/report%23L12.md#L34")).toBe("/tmp/report#L12.md:34");
+    });
+  });
 });

src/utils/fileLinks.ts

@@ -7,6 +7,7 @@ export type ParsedFileLocation = {
 const FILE_LOCATION_SUFFIX_PATTERN = /^(.*?):(\d+)(?::(\d+))?$/;
 const FILE_LOCATION_RANGE_SUFFIX_PATTERN = /^(.*?):(\d+)-(\d+)$/;
 const FILE_LOCATION_HASH_PATTERN = /^(.*?)#L(\d+)(?:C(\d+))?$/i;
+const FILE_URL_LOCATION_HASH_PATTERN = /^#L(\d+)(?:C(\d+))?$/i;
 
 export const FILE_LINK_SUFFIX_SOURCE =
   "(?:(?::\\d+(?::\\d+)?|:\\d+-\\d+)|(?:#L\\d+(?:C\\d+)?))?";
@@ -27,8 +28,21 @@ function decodeURIComponentSafely(value: string) {
   }
 }
 
-function normalizeRecognizedFileUrlHash(hash: string) {
-  return FILE_LOCATION_HASH_PATTERN.test(hash) ? hash : "";
+function parseRecognizedFileUrlHash(hash: string) {
+  const match = hash.match(FILE_URL_LOCATION_HASH_PATTERN);
+  if (!match) {
+    return {
+      line: null,
+      column: null,
+    };
+  }
+
+  const [, lineValue, columnValue] = match;
+  const line = parsePositiveInteger(lineValue);
+  return {
+    line,
+    column: line === null ? null : parsePositiveInteger(columnValue),
+  };
 }
 
 function buildLocalPathFromFileUrl(host: string, pathname: string) {
@@ -272,15 +286,15 @@ export function fromFileUrl(url: string) {
     }
 
     const path = buildLocalPathFromFileUrl(parsed.host, parsed.pathname);
-    const normalizedHash = normalizeRecognizedFileUrlHash(parsed.hash);
-    return normalizeFileLinkPath(`${path}${normalizedHash}`);
+    const { line, column } = parseRecognizedFileUrlHash(parsed.hash);
+    return formatFileLocation(path, line, column);
   } catch {
     const manualParts = parseManualFileUrl(url);
     if (!manualParts) {
       return null;
     }
     const path = buildLocalPathFromFileUrl(manualParts.host, manualParts.pathname);
-    const normalizedHash = normalizeRecognizedFileUrlHash(manualParts.hash);
-    return normalizeFileLinkPath(`${path}${normalizedHash}`);
+    const { line, column } = parseRecognizedFileUrlHash(manualParts.hash);
+    return formatFileLocation(path, line, column);
   }
 }