shadow-claw 1.29.0 → 1.30.0

package/src/components/shadow-claw-chat/shadow-claw-chat.ts

@@ -6,6 +6,7 @@ import {
   DEFAULT_PROMPT_API_FALLBACK_MODEL,
   DEFAULT_PROVIDER,
 } from "../../config/config.js";
+import { decodePathSegment } from "../../core/app-routes.js";
 
 import { shouldInstallE2eBridge } from "../../testing/e2e-bridge.js";
 
@@ -1160,7 +1161,10 @@ export class ShadowClawChat extends ShadowClawElement {
       return null;
     }
 
-    const parts = normalized.split("/").filter(Boolean);
+    const parts = normalized
+      .split("/")
+      .filter(Boolean)
+      .map((part) => decodePathSegment(part));
     if (parts.some((part) => part === "..")) {
       return null;
     }

package/src/components/shadow-claw-file-viewer/shadow-claw-file-viewer.test.ts

@@ -1445,6 +1445,31 @@ describe("shadow-claw-file-viewer", () => {
       );
     });
 
+    it("rewrites relative asset hrefs with spaces in markdown preview HTML", () => {
+      const component = new ShadowClawFileViewer();
+      const inputHtml =
+        '<p><a href="./My%20File%20With%20Spaces%20In%20The%20Name.md">file</a></p>';
+      const rewritten = component.rewriteWorkspacePreviewHtml(
+        inputHtml,
+        "index.md",
+      );
+      expect(rewritten).toContain(
+        'href="/files/test-group/My%20File%20With%20Spaces%20In%20The%20Name.md"',
+      );
+    });
+
+    it("rewrites relative asset hrefs in subfolders with spaces in markdown preview HTML", () => {
+      const component = new ShadowClawFileViewer();
+      const inputHtml = '<p><a href="sub%20folder/My%20File.md">file</a></p>';
+      const rewritten = component.rewriteWorkspacePreviewHtml(
+        inputHtml,
+        "index.md",
+      );
+      expect(rewritten).toContain(
+        'href="/files/test-group/sub%20folder/My%20File.md"',
+      );
+    });
+
     it("rewrites relative asset hrefs when subpath base path is active", () => {
       document.querySelectorAll("base").forEach((el) => el.remove());
       const baseEl = document.createElement("base");
@@ -1530,6 +1555,59 @@ describe("shadow-claw-file-viewer", () => {
       ).toBe("weather/README.md");
     });
 
+    it("resolves files and subfolders with spaces (both literal and percent-encoded)", () => {
+      const component = new ShadowClawFileViewer();
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "My File With Spaces In The Name.md",
+          "README.md",
+        ),
+      ).toBe("My File With Spaces In The Name.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "./My File With Spaces In The Name.md",
+          "README.md",
+        ),
+      ).toBe("My File With Spaces In The Name.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "./My%20File%20With%20Spaces%20In%20The%20Name.md",
+          "README.md",
+        ),
+      ).toBe("My File With Spaces In The Name.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "sub folder/My File With Spaces In The Name.md",
+          "README.md",
+        ),
+      ).toBe("sub folder/My File With Spaces In The Name.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "sub%20folder/My%20File%20With%20Spaces%20In%20The%20Name.md",
+          "README.md",
+        ),
+      ).toBe("sub folder/My File With Spaces In The Name.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "./child note.md",
+          "my sub folder/README.md",
+        ),
+      ).toBe("my sub folder/child note.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "../other folder/doc.md",
+          "my sub folder/README.md",
+        ),
+      ).toBe("other folder/doc.md");
+    });
+
     it("rejects external and root-escape links", () => {
       const component = new ShadowClawFileViewer();
 

package/src/components/shadow-claw-file-viewer/shadow-claw-file-viewer.ts

@@ -6,6 +6,7 @@ import { splitFrontmatter } from "../../common/utils/frontmatter.mjs";
 import { CONFIG_KEYS } from "../../config/config.js";
 import {
   applyBasePath,
+  decodePathSegment,
   getFileRouteDirPath,
   getWorkspaceRouteRequestPath,
   isPossibleAppRoute,
@@ -1068,7 +1069,10 @@ export class ShadowClawFileViewer extends ShadowClawElement {
 
     if (!isAbsolute) {
       const baseNormalized = basePath.replace(/\\/g, "/").replace(/^\/+/, "");
-      const baseParts = baseNormalized.split("/").filter(Boolean);
+      const baseParts = baseNormalized
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => decodePathSegment(segment));
       baseParts.pop();
       stack.push(...baseParts);
     }
@@ -1088,7 +1092,7 @@ export class ShadowClawFileViewer extends ShadowClawElement {
         continue;
       }
 
-      stack.push(part);
+      stack.push(decodePathSegment(part));
     }
 
     return stack.length > 0 ? stack.join("/") : null;

package/src/components/shadow-claw-pages/utils/resolveWorkspaceLinkPath.test.ts

@@ -76,4 +76,60 @@ describe("resolveWorkspaceLinkPath", () => {
     );
     expect(result).toBeNull();
   });
+
+  it("resolves files and subfolders with spaces (both literal and percent-encoded)", () => {
+    expect(
+      resolveWorkspaceLinkPath(
+        "My File With Spaces In The Name.md",
+        "index.md",
+        groupId,
+        origin,
+      ),
+    ).toBe("My File With Spaces In The Name.md");
+
+    expect(
+      resolveWorkspaceLinkPath(
+        "./My File With Spaces In The Name.md",
+        "index.md",
+        groupId,
+        origin,
+      ),
+    ).toBe("My File With Spaces In The Name.md");
+
+    expect(
+      resolveWorkspaceLinkPath(
+        "./My%20File%20With%20Spaces%20In%20The%20Name.md",
+        "index.md",
+        groupId,
+        origin,
+      ),
+    ).toBe("My File With Spaces In The Name.md");
+
+    expect(
+      resolveWorkspaceLinkPath(
+        "sub folder/My File With Spaces In The Name.md",
+        "index.md",
+        groupId,
+        origin,
+      ),
+    ).toBe("sub folder/My File With Spaces In The Name.md");
+
+    expect(
+      resolveWorkspaceLinkPath(
+        "sub%20folder/My%20File%20With%20Spaces%20In%20The%20Name.md",
+        "index.md",
+        groupId,
+        origin,
+      ),
+    ).toBe("sub folder/My File With Spaces In The Name.md");
+
+    expect(
+      resolveWorkspaceLinkPath(
+        "./child.md",
+        "sub folder/index.md",
+        groupId,
+        origin,
+      ),
+    ).toBe("sub folder/child.md");
+  });
 });

package/src/components/shadow-claw-tasks/shadow-claw-tasks.test.ts

@@ -137,6 +137,28 @@ describe("shadow-claw-tasks", () => {
       ).toBe("weather/archive/index.md");
     });
 
+    it("resolves workspace links with spaces and percent-encoded spaces", () => {
+      const component = new ShadowClawTasks();
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "My File With Spaces In The Name.md",
+        ),
+      ).toBe("My File With Spaces In The Name.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "./My%20File%20With%20Spaces%20In%20The%20Name.md",
+        ),
+      ).toBe("My File With Spaces In The Name.md");
+
+      expect(
+        component.resolveWorkspaceLinkPath(
+          "sub%20folder/My%20File%20With%20Spaces.md",
+        ),
+      ).toBe("sub folder/My File With Spaces.md");
+    });
+
     it("rejects external links and parent traversal", () => {
       const component = new ShadowClawTasks();
 

package/src/components/shadow-claw-tasks/shadow-claw-tasks.ts

@@ -1,6 +1,7 @@
 import { renderMarkdown } from "../../content/markdown.js";
 import { CONFIG_KEYS } from "../../config/config.js";
 import { effect } from "../../core/effect.js";
+import { decodePathSegment } from "../../core/app-routes.js";
 
 import { getDb, ShadowClawDatabase } from "../../db/db.js";
 import { getConfig } from "../../db/getConfig.js";
@@ -629,7 +630,10 @@ export class ShadowClawTasks extends ShadowClawElement {
       return null;
     }
 
-    const parts = normalized.split("/").filter(Boolean);
+    const parts = normalized
+      .split("/")
+      .filter(Boolean)
+      .map((part) => decodePathSegment(part));
     if (parts.some((part) => part === "..")) {
       return null;
     }

package/src/content/markdown-links.test.ts

@@ -0,0 +1,109 @@
+import { normalizeMarkdownLinks } from "./markdown-links.js";
+
+describe("normalizeMarkdownLinks", () => {
+  it("wraps relative link destinations with spaces in angle brackets", () => {
+    const input =
+      "[My File With Spaces In The Name.md](./My File With Spaces In The Name.md)";
+    const expected =
+      "[My File With Spaces In The Name.md](<./My File With Spaces In The Name.md>)";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("wraps bare filename destinations with spaces in angle brackets", () => {
+    const input =
+      "[My File With Spaces In The Name.md](My File With Spaces In The Name.md)";
+    const expected =
+      "[My File With Spaces In The Name.md](<My File With Spaces In The Name.md>)";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("wraps subfolder paths with spaces in angle brackets", () => {
+    const input =
+      "[My File](folder with spaces/My File With Spaces In The Name.md)";
+    const expected =
+      "[My File](<folder with spaces/My File With Spaces In The Name.md>)";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("wraps relative parent paths with spaces in angle brackets", () => {
+    const input =
+      "[My File](../parent folder/sub folder/My File With Spaces In The Name.md)";
+    const expected =
+      "[My File](<../parent folder/sub folder/My File With Spaces In The Name.md>)";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("wraps HTTP/HTTPS URLs with spaces in angle brackets", () => {
+    const input =
+      "[My File With Spaces In The Name.md](https://karlherrick.com/What About This)";
+    const expected =
+      "[My File With Spaces In The Name.md](<https://karlherrick.com/What About This>)";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("wraps image destinations with spaces in angle brackets", () => {
+    const input = "![My Image](./sub folder/My Image With Spaces.png)";
+    const expected = "![My Image](<./sub folder/My Image With Spaces.png>)";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("supports link titles when destination contains spaces", () => {
+    const input = '[My File](./My File With Spaces.md "File Title")';
+    const expected = '[My File](<./My File With Spaces.md> "File Title")';
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("supports single-quoted link titles when destination contains spaces", () => {
+    const input = "[My File](./My File With Spaces.md 'File Title')";
+    const expected = "[My File](<./My File With Spaces.md> 'File Title')";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("does not modify links that are already wrapped in angle brackets", () => {
+    const input = "[My File](<./My File With Spaces.md>)";
+    expect(normalizeMarkdownLinks(input)).toBe(input);
+  });
+
+  it("does not modify links that have no spaces", () => {
+    const input = "[My File](./MyFile.md)";
+    expect(normalizeMarkdownLinks(input)).toBe(input);
+  });
+
+  it("preserves fenced code blocks without modifying link-like text inside them", () => {
+    const input = [
+      "Here is some code:",
+      "```markdown",
+      "[My File With Spaces In The Name.md](./My File With Spaces In The Name.md)",
+      "```",
+      "And a real link outside:",
+      "[My Real File](./Real File.md)",
+    ].join("\n");
+
+    const expected = [
+      "Here is some code:",
+      "```markdown",
+      "[My File With Spaces In The Name.md](./My File With Spaces In The Name.md)",
+      "```",
+      "And a real link outside:",
+      "[My Real File](<./Real File.md>)",
+    ].join("\n");
+
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("preserves inline code spans without modifying link-like text inside them", () => {
+    const input =
+      "Inline: `[My File](./My File.md)` and link: [My Link](./My Link.md)";
+    const expected =
+      "Inline: `[My File](./My File.md)` and link: [My Link](<./My Link.md>)";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+
+  it("handles multiple links on the same line", () => {
+    const input =
+      "See [File 1](File 1.md) and [File 2](File 2.md) for details.";
+    const expected =
+      "See [File 1](<File 1.md>) and [File 2](<File 2.md>) for details.";
+    expect(normalizeMarkdownLinks(input)).toBe(expected);
+  });
+});

package/src/content/markdown-links.ts

@@ -0,0 +1,187 @@
+/**
+ * ShadowClaw — Markdown link destination normalizer
+ *
+ * CommonMark / Marked specifications require link destinations containing spaces
+ * to be enclosed in angle brackets `<...>` (e.g. `[text](<path with spaces.md>)`).
+ *
+ * This utility allows users to write natural Markdown links and image tags with spaces
+ * in filenames and URLs without manually typing `%20` or `<...>`:
+ *   [Doc](./My File With Spaces.md)       -> [Doc](<./My File With Spaces.md>)
+ *   [Doc](folder/My File With Spaces.md)  -> [Doc](<folder/My File With Spaces.md>)
+ *   [Link](https://example.com/My Page)   -> [Link](<https://example.com/My Page>)
+ *   ![Img](./My Image.png)                -> ![Img](<./My Image.png>)
+ *
+ * Code blocks and inline code spans are strictly preserved.
+ */
+
+function normalizeDestination(rawInsideParens: string): string {
+  const trimmed = rawInsideParens.trim();
+  if (!trimmed) {
+    return rawInsideParens;
+  }
+
+  // Check for an optional quoted title at the end: "title" or 'title'
+  const titleMatch = trimmed.match(/\s+("[^"]*"|'[^']*')\s*$/);
+  let dest: string;
+  let titlePart = "";
+
+  if (titleMatch && typeof titleMatch.index === "number") {
+    dest = trimmed.slice(0, titleMatch.index).trim();
+    titlePart = ` ${titleMatch[1]}`;
+  } else {
+    dest = trimmed;
+  }
+
+  // If already wrapped in angle brackets or has no spaces, do not modify
+  if ((dest.startsWith("<") && dest.endsWith(">")) || !/[\s]/.test(dest)) {
+    return rawInsideParens;
+  }
+
+  return `<${dest}>${titlePart}`;
+}
+
+/**
+ * Normalizes link and image destinations containing spaces by enclosing them in CommonMark `<...>`.
+ */
+export function normalizeMarkdownLinks(markdown: string): string {
+  if (typeof markdown !== "string" || !markdown.includes("[")) {
+    return markdown;
+  }
+
+  const length = markdown.length;
+  let result = "";
+  let i = 0;
+
+  while (i < length) {
+    // 1. Check for fenced code blocks at start of line: ``` or ~~~
+    const isStartOfLine = i === 0 || markdown[i - 1] === "\n";
+    if (isStartOfLine && (markdown[i] === "`" || markdown[i] === "~")) {
+      const char = markdown[i];
+      let fenceLen = 1;
+      while (i + fenceLen < length && markdown[i + fenceLen] === char) {
+        fenceLen++;
+      }
+
+      if (fenceLen >= 3) {
+        const fenceStr = char.repeat(fenceLen);
+        const endOfOpeningLine = markdown.indexOf("\n", i + fenceLen);
+        const searchStart =
+          endOfOpeningLine === -1 ? length : endOfOpeningLine + 1;
+        const closeIdx = markdown.indexOf(`\n${fenceStr}`, searchStart - 1);
+
+        if (closeIdx !== -1) {
+          const endOfClosingLine = markdown.indexOf(
+            "\n",
+            closeIdx + 1 + fenceLen,
+          );
+          const endIdx =
+            endOfClosingLine === -1 ? length : endOfClosingLine + 1;
+          result += markdown.slice(i, endIdx);
+          i = endIdx;
+          continue;
+        } else {
+          // Unclosed fence runs to the end
+          result += markdown.slice(i);
+          break;
+        }
+      }
+    }
+
+    // 2. Check for inline code spans: ` or `` etc.
+    if (markdown[i] === "`") {
+      let backtickCount = 1;
+      while (
+        i + backtickCount < length &&
+        markdown[i + backtickCount] === "`"
+      ) {
+        backtickCount++;
+      }
+      const backticks = "`".repeat(backtickCount);
+      const closeIdx = markdown.indexOf(backticks, i + backtickCount);
+
+      if (closeIdx !== -1) {
+        const endIdx = closeIdx + backtickCount;
+        result += markdown.slice(i, endIdx);
+        i = endIdx;
+        continue;
+      }
+    }
+
+    // 3. Check for link or image: ![...](...) or [...](...)
+    const isImage =
+      markdown[i] === "!" && i + 1 < length && markdown[i + 1] === "[";
+    const isLink = markdown[i] === "[";
+
+    if (isImage || isLink) {
+      const labelStart = isImage ? i + 2 : i + 1;
+      let depth = 1;
+      let j = labelStart;
+
+      while (j < length && depth > 0) {
+        if (markdown[j] === "\\") {
+          j += 2; // Skip escaped character
+          continue;
+        }
+        if (markdown[j] === "[") {
+          depth++;
+        } else if (markdown[j] === "]") {
+          depth--;
+        }
+        if (depth > 0) {
+          j++;
+        }
+      }
+
+      // If we found the matching ']' and the next non-whitespace or immediate char is '('
+      if (depth === 0 && j < length && markdown[j] === "]") {
+        const labelEnd = j;
+        const nextCharIdx = j + 1;
+
+        if (nextCharIdx < length && markdown[nextCharIdx] === "(") {
+          // Find matching ')'
+          let parenDepth = 1;
+          let k = nextCharIdx + 1;
+
+          while (k < length && parenDepth > 0) {
+            if (markdown[k] === "\\") {
+              k += 2;
+              continue;
+            }
+            if (markdown[k] === "(") {
+              parenDepth++;
+            } else if (markdown[k] === ")") {
+              parenDepth--;
+            }
+            if (parenDepth > 0) {
+              k++;
+            }
+          }
+
+          if (parenDepth === 0 && k < length && markdown[k] === ")") {
+            const rawInsideLabel = markdown.slice(labelStart, labelEnd);
+            const rawInsideParens = markdown.slice(nextCharIdx + 1, k);
+
+            // Recursively normalize label in case there are nested links/images
+            const normalizedLabel = rawInsideLabel.includes("[")
+              ? normalizeMarkdownLinks(rawInsideLabel)
+              : rawInsideLabel;
+
+            const normalizedInsideParens =
+              normalizeDestination(rawInsideParens);
+            const prefix = isImage ? "![" : "[";
+
+            result += `${prefix}${normalizedLabel}](${normalizedInsideParens})`;
+            i = k + 1;
+            continue;
+          }
+        }
+      }
+    }
+
+    // Default: append current character
+    result += markdown[i];
+    i++;
+  }
+
+  return result;
+}

package/src/content/markdown.test.ts

@@ -115,4 +115,37 @@ describe("renderMarkdown", () => {
     expect(html).not.toContain("<iframe");
     expect(html).not.toContain("phishing-site.example.com");
   });
+
+  it("renders markdown links with spaces in relative filenames and URLs", async () => {
+    const markdown = [
+      "[My File With Spaces In The Name.md](./My File With Spaces In The Name.md)",
+      "[My File With Spaces In The Name.md](My File With Spaces In The Name.md)",
+      "[Subfolder Doc](sub folder/My File With Spaces In The Name.md)",
+      "[External](https://karlherrick.com/What About This)",
+    ].join("\n\n");
+
+    const html = await renderMarkdown(markdown);
+
+    expect(html).toContain(
+      '<a href="./My%20File%20With%20Spaces%20In%20The%20Name.md">My File With Spaces In The Name.md</a>',
+    );
+    expect(html).toContain(
+      '<a href="My%20File%20With%20Spaces%20In%20The%20Name.md">My File With Spaces In The Name.md</a>',
+    );
+    expect(html).toContain(
+      '<a href="sub%20folder/My%20File%20With%20Spaces%20In%20The%20Name.md">Subfolder Doc</a>',
+    );
+    expect(html).toContain(
+      '<a href="https://karlherrick.com/What%20About%20This">External</a>',
+    );
+  });
+
+  it("renders markdown images with spaces in relative filenames", async () => {
+    const markdown = "![My Image](./sub folder/My Image With Spaces.png)";
+    const html = await renderMarkdown(markdown);
+
+    expect(html).toContain(
+      '<img src="./sub%20folder/My%20Image%20With%20Spaces.png" alt="My Image">',
+    );
+  });
 });

package/src/content/markdown.ts

@@ -9,6 +9,8 @@
 import hljs from "highlight.js";
 import { marked } from "marked";
 
+import { normalizeMarkdownLinks } from "./markdown-links.js";
+
 import {
   createFrontmatterDetailsElement,
   PostFrontmatter,
@@ -164,9 +166,12 @@ export async function renderMarkdown(
     const parsed: { data: PostFrontmatter; content: string } =
       splitFrontmatter(src);
 
+    // Normalize links and images with spaces in URLs
+    const normalizedContent = normalizeMarkdownLinks(parsed.content);
+
     // Parse markdown to HTML
     const headingCounts = new Map<string, number>();
-    const html = await marked.parse(parsed.content, {
+    const html = await marked.parse(normalizedContent, {
       gfm: true,
       breaks: options?.breaks ?? false,
       headingCounts,

package/src/core/app-routes.test.ts

@@ -1,6 +1,7 @@
 import {
   applyBasePath,
   buildRoutePath,
+  decodePathSegment,
   getAppBasePath,
   getDeploymentNamespace,
   getFileRouteDirPath,
@@ -146,6 +147,70 @@ describe("app-routes", () => {
     });
   });
 
+  it("decodes percent-encoded segments in getWorkspaceRouteRequestPath", () => {
+    expect(
+      getWorkspaceRouteRequestPath(
+        "/files/main/My%20File%20With%20Spaces%20In%20The%20Name.md",
+      ),
+    ).toEqual({
+      groupId: "br:main",
+      path: "My File With Spaces In The Name.md",
+    });
+
+    expect(
+      getWorkspaceRouteRequestPath(
+        "/files/main/sub%20folder/My%20File%20With%20Spaces%20In%20The%20Name.md",
+      ),
+    ).toEqual({
+      groupId: "br:main",
+      path: "sub folder/My File With Spaces In The Name.md",
+    });
+  });
+
+  describe("decodePathSegment", () => {
+    it("decodes percent-encoded strings", () => {
+      expect(decodePathSegment("My%20File.md")).toBe("My File.md");
+      expect(decodePathSegment("folder%20name")).toBe("folder name");
+    });
+
+    it("leaves unencoded strings untouched", () => {
+      expect(decodePathSegment("simple.md")).toBe("simple.md");
+      expect(decodePathSegment("already has spaces.md")).toBe(
+        "already has spaces.md",
+      );
+    });
+
+    it("safely handles malformed percent encoding without throwing", () => {
+      expect(decodePathSegment("100%real")).toBe("100%real");
+    });
+  });
+
+  it("parses route URLs with spaces in filenames and subfolders", () => {
+    const route = parseRouteFromUrl(
+      new URL(
+        "http://localhost:8888/files/main/My%20File%20With%20Spaces%20In%20The%20Name.md",
+      ),
+    );
+    expect(route).toEqual({
+      page: "files",
+      groupId: "br:main",
+      path: "My File With Spaces In The Name.md",
+      anchor: undefined,
+    });
+
+    const nestedRoute = parseRouteFromUrl(
+      new URL(
+        "http://localhost:8888/files/main/sub%20folder/My%20File%20With%20Spaces%20In%20The%20Name.md",
+      ),
+    );
+    expect(nestedRoute).toEqual({
+      page: "files",
+      groupId: "br:main",
+      path: "sub folder/My File With Spaces In The Name.md",
+      anchor: undefined,
+    });
+  });
+
   describe("applyBasePath", () => {
     // Reset cached base path between tests
     beforeEach(() => {