shadow-claw 1.54.0 → 1.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadow-claw",
-  "version": "1.54.0",
+  "version": "1.55.0",
   "type": "module",
   "license": "AGPL-3.0",
   "description": "ShadowClaw - multi-runtime AI assistant.",
@@ -144,8 +144,7 @@
     "writer-rewriter-polyfills": "^1.0.1"
   },
   "devDependencies": {
-    "@mcp-b/webmcp-polyfill": "^5.1.0",
-    "@mcp-b/webmcp-types": "^5.1.0",
+    "@mcp-b/webmcp-polyfill": "^6.0.3",
     "@playwright/test": "^1.64.0",
     "@storybook/addon-docs": "^10.6.1",
     "@storybook/web-components-vite": "^10.6.1",
@@ -192,6 +191,7 @@
     "util": "^0.12.5",
     "v86": "^0.5.470",
     "vite": "^6.4.4",
+    "webmcp-types": "^0.1.10",
     "workbox-cli": "^7.4.1",
     "workbox-window": "^7.4.0"
   },

package/src/cli/prerender/dsd-shell/prerender-dsd-shell.test.ts

@@ -139,6 +139,22 @@ describe("renderPageHtml frontmatter", () => {
     expect(rendered).toContain("<h1>Heading</h1>");
     expect(rendered).not.toContain('slug: "on-developing-loops"');
   });
+
+  it("preserves custom element blocks containing blank lines without wrapping in <p> or splitting <pre>", async () => {
+    const markdown = [
+      '<x-postpress-code type="javascript"><pre>(async () => {',
+      "  const a = 1;",
+      "",
+      "  const b = 2;",
+      "})();</pre></x-postpress-code>",
+    ].join("\n");
+
+    const rendered = await renderPageHtml(markdown, "page.md");
+    expect(rendered).not.toContain("<p><x-postpress-code");
+    expect(rendered).toContain(
+      '<x-postpress-code type="javascript"><pre>(async () => {\n  const a = 1;\n\n  const b = 2;\n})();</pre></x-postpress-code>',
+    );
+  });
 });
 
 describe("pages DSD prerender parity", () => {

package/src/cli/prerender/dsd-shell/prerender-dsd-shell.ts

@@ -15,6 +15,37 @@ import { DOMImplementation, XMLSerializer } from "@xmldom/xmldom";
 import matter from "gray-matter";
 import { marked } from "marked";
 
+// Configure marked with a custom tokenizer for custom elements
+marked.use({
+  tokenizer: {
+    html(src: string) {
+      // Treat custom elements (tags with a hyphen like <x-postpress-code>, <x-hook-component>)
+      // as block-level HTML so marked does not wrap them in <p> tags or split them on blank lines.
+      // Wrapping in <p> causes the browser's HTML parser to eject <pre> or other block children
+      // out of the custom element into sibling position, breaking web component light DOM slots.
+      const match =
+        src.match(
+          /^ {0,3}<([a-zA-Z][a-zA-Z0-9]*-[a-zA-Z0-9_-]*)(?:\s+[^>]*)?>[\s\S]*?<\/\1>(?:[ \t]*(?:\n+|$))?/i,
+        ) ||
+        src.match(
+          /^ {0,3}<([a-zA-Z][a-zA-Z0-9]*-[a-zA-Z0-9_-]*)(?:\s+[^>]*)?\s*\/>(?:[ \t]*(?:\n+|$))?/i,
+        );
+
+      if (match) {
+        return {
+          type: "html",
+          block: true,
+          raw: match[0],
+          text: match[0],
+          pre: false,
+        };
+      }
+
+      return false;
+    },
+  },
+});
+
 import {
   createFrontmatterDetailsElement,
   renderFrontmatterMarkup,
@@ -29,6 +60,8 @@ import { normalizePrerenderPagesOption } from "../utils/normalize-prerender-page
 import { insertBeforeClosingHead } from "../utils/insert-before-closing-head.js";
 import { injectStaticManifestScript } from "../utils/inject-static-manifest-script.js";
 import { isPagePathAllowed } from "../../../utils/is-page-path-allowed.js";
+import { resolvePageScriptDependencies } from "../../../utils/resolve-page-script-dependencies.js";
+import { buildCustomElementScriptTags } from "../../site-config/custom-elements/build-custom-element-script-tags.js";
 
 export { escapeHtml };
 export { sanitizeRenderedHtml };
@@ -1316,7 +1349,35 @@ export async function prerenderDsdShell(
   const embeddedManifestJson = JSON.stringify(embeddedManifest);
 
   const nextHtml = injectStaticManifestScript(markedHtml, embeddedManifestJson);
-  const minifiedHtml = minifyDsdTemplateHtml(nextHtml);
+
+  const rawScripts = siteConfig?.customElements?.scripts || [];
+  const defaultPageParsed = filteredPageSources[0]?.content
+    ? splitFrontmatterWithGrayMatter(filteredPageSources[0].content)
+    : { data: {} };
+  const resolvedScripts = resolvePageScriptDependencies(
+    rawScripts,
+    defaultPageParsed.data,
+    filteredPageSources[0]?.content,
+  );
+  let htmlWithScripts = nextHtml;
+  if (resolvedScripts.length > 0) {
+    const headMatch = htmlWithScripts.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+    const headContent = headMatch ? headMatch[1] : "";
+    const scriptsToInject = resolvedScripts.filter(
+      (s) =>
+        !headContent.includes(`src="${s.src}"`) &&
+        !headContent.includes(`src='${s.src}'`),
+    );
+    if (scriptsToInject.length > 0) {
+      const scriptTags = buildCustomElementScriptTags(scriptsToInject);
+      htmlWithScripts = insertBeforeClosingHead(
+        htmlWithScripts,
+        `  ${scriptTags.trim()}`,
+      );
+    }
+  }
+
+  const minifiedHtml = minifyDsdTemplateHtml(htmlWithScripts);
   const finalHtml = await inlineCriticalAssets(minifiedHtml, publicDir);
   await writeFile(indexPath, finalHtml, "utf8");
   const isSilent = options.silent ?? process.env.NODE_ENV === "test";

package/src/cli/prerender/pretty-paths/prerender-pretty-paths.test.ts

@@ -1,3 +1,4 @@
+import { jest } from "@jest/globals";
 import {
   injectStaticRoutingScript,
   prerenderPrettyPaths,
@@ -958,4 +959,280 @@ Body content paragraph for auto description.`;
       '<link rel="canonical" href="https://xt-ml.github.io/shadow-claw/custom-url/" />',
     );
   });
+
+  it("injects global scripts and page frontmatter script dependencies into head of pretty path pages", async () => {
+    const publicDir = path.join(tmpDir, "dist/public-deps");
+    const indexPath = path.join(publicDir, "index.html");
+    const sourcePath = path.join(tmpDir, "pages/main-deps");
+    const routesPath = path.join(tmpDir, "pages/routes-deps.json");
+    const siteConfigPath = path.join(tmpDir, "shadow-claw.config.json");
+
+    await mkdir(path.join(publicDir, "components/shadow-claw"), {
+      recursive: true,
+    });
+    await mkdir(path.join(publicDir, "components/shadow-claw-pages"), {
+      recursive: true,
+    });
+    await mkdir(path.join(publicDir, "components/shadow-claw-page-header"), {
+      recursive: true,
+    });
+    await mkdir(sourcePath, { recursive: true });
+    await mkdir(path.dirname(routesPath), { recursive: true });
+
+    await writeFile(
+      indexPath,
+      '<!doctype html><html><head><base href="/"><title>ShadowClaw</title></head><body><shadow-claw></shadow-claw></body></html>',
+      "utf8",
+    );
+    await writeFile(
+      path.join(publicDir, "components/shadow-claw/shadow-claw.html"),
+      '<template><div class="app"><shadow-claw-pages></shadow-claw-pages></div></template>',
+      "utf8",
+    );
+    await writeFile(
+      path.join(
+        publicDir,
+        "components/shadow-claw-pages/shadow-claw-pages.html",
+      ),
+      '<template><div class="pages__list" data-pages-list role="list"></div><div class="pages__rendered" data-pages-rendered hidden></div><div class="pages__empty" data-pages-empty></div><shadow-claw-page-header title="Pages"></shadow-claw-page-header></template>',
+      "utf8",
+    );
+    await writeFile(
+      path.join(
+        publicDir,
+        "components/shadow-claw-page-header/shadow-claw-page-header.html",
+      ),
+      '<template><header class="header"><h2 class="header__title"></h2><details class="header__actions-disclosure"></details><div class="header__actions" id="header-actions-panel"></div></header></template>',
+      "utf8",
+    );
+
+    const siteConfigJson = {
+      site: { title: "ShadowClaw" },
+      customElements: {
+        scripts: [
+          {
+            id: "feed-scroller",
+            src: "/pages/main/assets/feed-scroller.js",
+            global: true,
+            hasInit: true,
+          },
+          {
+            id: "x-hook-component",
+            src: "/pages/main/assets/x-hook-component.js",
+            hasInit: true,
+          },
+          {
+            name: "x-postpress-code",
+            src: "/pages/main/assets/x-postpress-code.js",
+            hasInit: true,
+          },
+        ],
+      },
+    };
+    await writeFile(
+      siteConfigPath,
+      JSON.stringify(siteConfigJson, null, 2),
+      "utf8",
+    );
+
+    const page1Content = [
+      "---",
+      'title: "The Web Is Dynamic"',
+      'slug: "the-web-is-dynamic"',
+      "dependencies:",
+      '  - "x-hook-component"',
+      "---",
+      "# The Web Is Dynamic",
+      "",
+      "Content using hook component.",
+      '<script type="module" src="/pages/main/assets/x-hook-component.js"></script>',
+    ].join("\n");
+
+    const page2Content = [
+      "---",
+      'title: "Unknown Script Page"',
+      'slug: "unknown-script-page"',
+      "dependencies:",
+      '  - "missing-non-existent-script"',
+      "---",
+      "# Unknown Script Page",
+      "",
+      "Content with unresolvable script.",
+    ].join("\n");
+
+    await writeFile(
+      path.join(sourcePath, "2021-02-27-the-web-is-dynamic.md"),
+      page1Content,
+      "utf8",
+    );
+    await writeFile(path.join(sourcePath, "unknown.md"), page2Content, "utf8");
+
+    const routesJson = {
+      routes: {
+        "/pages/main-deps/2021-02-27-the-web-is-dynamic.md": {
+          prettyPath: "/2021/02/27/the-web-is-dynamic/",
+        },
+        "/pages/main-deps/unknown.md": {
+          prettyPath: "/unknown-page/",
+        },
+      },
+    };
+    await writeFile(routesPath, JSON.stringify(routesJson, null, 2), "utf8");
+
+    const result = await prerenderPrettyPaths({
+      publicDir,
+      routesPath,
+      sourcePath,
+      siteConfigPath,
+      indexPath,
+      prerenderPages: 1,
+    });
+
+    expect(result.count).toBe(2);
+
+    const page1Html = await readFile(
+      path.join(publicDir, "2021/02/27/the-web-is-dynamic/index.html"),
+      "utf8",
+    );
+
+    // Should contain both the global script and the frontmatter-requested dependency in <head>
+    expect(page1Html).toMatch(
+      /<head>[\s\S]*<script type="module" src="\/pages\/main\/assets\/feed-scroller\.js"><\/script>[\s\S]*<\/head>/,
+    );
+    expect(page1Html).toMatch(
+      /<head>[\s\S]*<script type="module" src="\/pages\/main\/assets\/x-hook-component\.js"><\/script>[\s\S]*<\/head>/,
+    );
+    // Should NOT contain the unrequested x-postpress-code
+    expect(page1Html).not.toContain("/pages/main/assets/x-postpress-code.js");
+
+    const page2Html = await readFile(
+      path.join(publicDir, "unknown-page/index.html"),
+      "utf8",
+    );
+    // Should still have the global script and render cleanly despite missing dependency
+    expect(page2Html).toMatch(
+      /<head>[\s\S]*<script type="module" src="\/pages\/main\/assets\/feed-scroller\.js"><\/script>[\s\S]*<\/head>/,
+    );
+    expect(page2Html).not.toMatch(/<script\b[^>]*missing-non-existent-script/);
+  });
+
+  it("injects dependencies when existing config does not specify an id and fails gracefully", async () => {
+    const publicDir = path.join(tmpDir, "dist/public");
+    const indexPath = path.join(publicDir, "index.html");
+    const sourcePath = path.join(tmpDir, "pages/main-legacy");
+    const routesPath = path.join(tmpDir, "pages/routes-legacy.json");
+    const siteConfigPath = path.join(tmpDir, "shadow-claw.config.json");
+
+    await mkdir(path.join(publicDir, "components/shadow-claw"), {
+      recursive: true,
+    });
+    await mkdir(path.join(publicDir, "components/shadow-claw-pages"), {
+      recursive: true,
+    });
+    await mkdir(path.join(publicDir, "components/shadow-claw-page-header"), {
+      recursive: true,
+    });
+    await mkdir(sourcePath, { recursive: true });
+
+    await mkdir(path.dirname(routesPath), { recursive: true });
+
+    await writeFile(
+      indexPath,
+      '<!doctype html><html><head><base href="/"><title>Legacy Config Site</title></head><body><shadow-claw></shadow-claw></body></html>',
+      "utf8",
+    );
+    await writeFile(
+      path.join(publicDir, "components/shadow-claw/shadow-claw.html"),
+      '<template><div class="app"><shadow-claw-pages></shadow-claw-pages></div></template>',
+      "utf8",
+    );
+    await writeFile(
+      path.join(
+        publicDir,
+        "components/shadow-claw-pages/shadow-claw-pages.html",
+      ),
+      '<template><div class="pages__list" data-pages-list role="list"></div><div class="pages__rendered" data-pages-rendered hidden></div><div class="pages__empty" data-pages-empty></div><shadow-claw-page-header title="Pages"></shadow-claw-page-header></template>',
+      "utf8",
+    );
+    await writeFile(
+      path.join(
+        publicDir,
+        "components/shadow-claw-page-header/shadow-claw-page-header.html",
+      ),
+      '<template><header class="header"><h2 class="header__title"></h2><details class="header__actions-disclosure"></details><div class="header__actions" id="header-actions-panel"></div></header></template>',
+      "utf8",
+    );
+
+    // Existing legacy config without 'id' fields
+    const legacySiteConfig = {
+      site: { title: "Legacy Config Site" },
+      customElements: {
+        scripts: [
+          { src: "/pages/main/assets/feed-scroller.js", global: true },
+          { src: "/pages/main/assets/x-hook-component.js" },
+        ],
+      },
+    };
+    await writeFile(
+      siteConfigPath,
+      JSON.stringify(legacySiteConfig, null, 2),
+      "utf8",
+    );
+
+    const postContent = [
+      "---",
+      'title: "Legacy Config Page"',
+      "dependencies:",
+      '  - "x-hook-component"',
+      '  - "unrecognized-missing-id"',
+      "---",
+      "# Legacy Config Page",
+      "",
+      "Content rendered best effort.",
+    ].join("\n");
+
+    await writeFile(
+      path.join(sourcePath, "legacy-page.md"),
+      postContent,
+      "utf8",
+    );
+
+    const routesJson = {
+      routes: {
+        "/pages/main-legacy/legacy-page.md": {
+          prettyPath: "/legacy-page/",
+        },
+      },
+    };
+    await writeFile(routesPath, JSON.stringify(routesJson, null, 2), "utf8");
+
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const result = await prerenderPrettyPaths({
+      publicDir,
+      routesPath,
+      sourcePath,
+      siteConfigPath,
+      indexPath,
+      prerenderPages: 1,
+    });
+    warnSpy.mockRestore();
+
+    expect(result.count).toBe(1);
+
+    const pageHtml = await readFile(
+      path.join(publicDir, "legacy-page/index.html"),
+      "utf8",
+    );
+
+    // Global script injected
+    expect(pageHtml).toMatch(
+      /<head>[\s\S]*<script type="module" src="\/pages\/main\/assets\/feed-scroller\.js"><\/script>[\s\S]*<\/head>/,
+    );
+    // Matched by stem even without id in config
+    expect(pageHtml).toMatch(
+      /<head>[\s\S]*<script type="module" src="\/pages\/main\/assets\/x-hook-component\.js"><\/script>[\s\S]*<\/head>/,
+    );
+    // Unrecognized id has no script tag injected and does not cause a failure
+    expect(pageHtml).not.toMatch(/<script\b[^>]*unrecognized-missing-id/);
+  });
 });

package/src/cli/prerender/pretty-paths/prerender-pretty-paths.ts

@@ -32,6 +32,8 @@ import { injectStaticRoutingScript } from "../utils/inject-static-routing-script
 import { insertBeforeClosingHead } from "../utils/insert-before-closing-head.js";
 import { trimSlashes } from "../../../utils/normalize-workspace-path.js";
 import { isPagePathAllowed } from "../../../utils/is-page-path-allowed.js";
+import { resolvePageScriptDependencies } from "../../../utils/resolve-page-script-dependencies.js";
+import { buildCustomElementScriptTags } from "../../site-config/custom-elements/build-custom-element-script-tags.js";
 import {
   extractMarkdownDescription,
   formatSeoTitle,
@@ -544,8 +546,33 @@ export async function prerenderPrettyPaths(
       type: isHome ? "website" : "article",
     });
 
+    const rawScripts = siteConfig?.customElements?.scripts || [];
+    const resolvedScripts = resolvePageScriptDependencies(
+      rawScripts,
+      parsed.data,
+      matchedPage.content,
+    );
+
+    let htmlWithScripts = htmlWithSeo;
+    if (resolvedScripts.length > 0) {
+      const headMatch = htmlWithScripts.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+      const headContent = headMatch ? headMatch[1] : "";
+      const scriptsToInject = resolvedScripts.filter(
+        (s) =>
+          !headContent.includes(`src="${s.src}"`) &&
+          !headContent.includes(`src='${s.src}'`),
+      );
+      if (scriptsToInject.length > 0) {
+        const scriptTags = buildCustomElementScriptTags(scriptsToInject);
+        htmlWithScripts = insertBeforeClosingHead(
+          htmlWithScripts,
+          `  ${scriptTags.trim()}`,
+        );
+      }
+    }
+
     const minifiedHtml = minifyDsdTemplateHtml(
-      injectStaticRoutingScript(htmlWithSeo, embeddedRoutingJson),
+      injectStaticRoutingScript(htmlWithScripts, embeddedRoutingJson),
     );
     const finalHtml = await inlineCriticalAssets(minifiedHtml, publicDir);
 

package/src/cli/site-config/custom-elements/build-custom-element-script-tags.ts

@@ -2,6 +2,10 @@ import { normalizeCustomElementScriptSrc } from "./normalize-custom-element-scri
 
 export interface CustomElementScriptDescriptor {
   src: string;
+  id?: string;
+  name?: string;
+  global?: boolean;
+  autoload?: boolean;
   type?: string;
   async?: boolean;
   defer?: boolean;
@@ -10,9 +14,17 @@ export interface CustomElementScriptDescriptor {
 
 export type CustomElementScriptEntry = string | CustomElementScriptDescriptor;
 
+function defaultEscapeHtml(str: string): string {
+  return str
+    .replace(/&/g, "&")
+    .replace(/"/g, """)
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
 export function buildCustomElementScriptTags(
   approvedEntries: CustomElementScriptEntry[] | any,
-  escapeHtml: (str: string) => string,
+  escapeHtml: (str: string) => string = defaultEscapeHtml,
 ): string {
   if (!Array.isArray(approvedEntries) || approvedEntries.length === 0) {
     return "";

package/src/components/shadow-claw/shadow-claw.css

@@ -632,6 +632,18 @@ shadow-claw-conversations {
   margin-top: 0.5rem;
 }
 
+form:tool-form-active,
+.app-confirm-dialog__form:tool-form-active,
+.app-prompt-dialog__form:tool-form-active {
+  outline: 2px dashed var(--shadow-claw-accent-primary, #3b82f6);
+  outline-offset: 4px;
+}
+
+button:tool-submit-active {
+  outline: 2px dashed var(--shadow-claw-warning, #f59e0b);
+  outline-offset: 2px;
+}
+
 .chat-page {
   flex-direction: column;
 }

package/src/components/shadow-claw/shadow-claw.html

@@ -254,7 +254,12 @@
       dialog-class="app-dialog"
       dialog-aria-labelledby="appDialogTitle"
     >
-      <form method="dialog" class="app-confirm-dialog__form">
+      <form
+        method="dialog"
+        class="app-confirm-dialog__form"
+        toolname="app_dialog_confirm"
+        tooldescription="Confirm or cancel an application modal dialog prompt"
+      >
         <h2 id="appDialogTitle" class="app-dialog__title">Confirm</h2>
         <p class="app-dialog__message"></p>
         <ul class="app-dialog__details" hidden></ul>
@@ -289,7 +294,12 @@
       dialog-class="app-dialog app-prompt-dialog"
       dialog-aria-labelledby="appPromptTitle"
     >
-      <form method="dialog" class="app-prompt-dialog__form">
+      <form
+        method="dialog"
+        class="app-prompt-dialog__form"
+        toolname="app_dialog_prompt"
+        tooldescription="Submit user response or selection to an interactive dialog prompt"
+      >
         <h2 id="appPromptTitle" class="app-prompt-dialog__title">
           Agent Question
         </h2>

package/src/components/shadow-claw/utils/bind-event-listeners.test.ts

@@ -778,6 +778,24 @@ describe("bindEventListeners", () => {
         "popstate",
         expect.any(Function),
       );
+
+      // Verify win.history.replaceState was hooked
+      const origReplace = jest.fn();
+      (win as any).history = { replaceState: origReplace };
+      (win as any).history.__scReplaceStateTracked = false;
+      bindEventListeners(
+        win,
+        doc,
+        shadow,
+        shadowClaw,
+        db,
+        oStore,
+        fStore,
+        tStore,
+        url,
+      );
+      (win as any).history.replaceState({ inFeedScroll: true }, "", "/");
+      expect(origReplace).toHaveBeenCalledWith({ inFeedScroll: true }, "", "/");
     });
 
     it("should attach popstate and click listeners when navigation API not supported", () => {

package/src/components/shadow-claw/utils/bind-event-listeners.ts

@@ -1,5 +1,6 @@
 import { Themes } from "../../../stores/theme.js";
 import { applyRouteFromCurrentLocation } from "./apply-route-from-current-location.js";
+import { recordHistoryReplaceState } from "./get-route.js";
 import { getDefaultSidebarPage } from "./get-default-sidebar-page.js";
 import { initSidebarResize } from "./init-sidebar-resize.js";
 import { requestDialog } from "./request-dialog.js";
@@ -269,6 +270,19 @@ export function bindEventListeners(
   doc.addEventListener("shadow-claw-navigate", shadowClaw.shadowClawNav);
 
   if (supportsNavigationApi()) {
+    if (win.history && !(win.history as any).__scReplaceStateTracked) {
+      const origReplaceState = win.history.replaceState;
+      win.history.replaceState = function (
+        data: any,
+        unused: string,
+        url?: string | URL | null,
+      ) {
+        recordHistoryReplaceState(data);
+        return origReplaceState.call(this, data, unused, url);
+      };
+      (win.history as any).__scReplaceStateTracked = true;
+    }
+
     const nav = (win as any).navigation;
     nav.addEventListener("navigate", shadowClaw.handleNavigationApiNavigate);
 

package/src/components/shadow-claw/utils/get-route.test.ts

@@ -126,6 +126,41 @@ describe("getRoute", () => {
     }
   });
 
+  it("returns undefined if navigateEvent.info indicates an in-feed scroll", () => {
+    const navigateEvent = new Event("navigate") as any;
+    navigateEvent.navigationType = "replace";
+    navigateEvent.info = { inFeedScroll: true };
+    navigateEvent.destination = {
+      url: `${window.location.origin}/test`,
+      getState: () => undefined,
+    };
+
+    const result = getRoute(db, navigateEvent);
+    expect(result).toBeUndefined();
+    expect(isPossibleAppRouteMock).not.toHaveBeenCalled();
+  });
+
+  it("returns undefined if recorded history replaceState indicates inFeedScroll even when getState() is undefined and history.state is null", async () => {
+    const { recordHistoryReplaceState, clearLastHistoryReplaceState } =
+      await import("./get-route.js");
+    recordHistoryReplaceState({ inFeedScroll: true });
+
+    try {
+      const navigateEvent = new Event("navigate") as any;
+      navigateEvent.navigationType = "replace";
+      navigateEvent.destination = {
+        url: `${window.location.origin}/test`,
+        getState: () => undefined,
+      };
+
+      const result = getRoute(db, navigateEvent);
+      expect(result).toBeUndefined();
+      expect(isPossibleAppRouteMock).not.toHaveBeenCalled();
+    } finally {
+      clearLastHistoryReplaceState();
+    }
+  });
+
   it("does not ignore push navigation even if window.history.state has inFeedScroll: true", () => {
     const origState = window.history.state;
     try {

package/src/components/shadow-claw/utils/get-route.ts

@@ -1,6 +1,20 @@
 import { isPossibleAppRoute } from "../../../core/app-routes.js";
 import type { ShadowClawDatabase } from "../../../db/types.js";
 
+let lastHistoryReplaceState: any = null;
+
+export function recordHistoryReplaceState(state: any): void {
+  lastHistoryReplaceState = state;
+}
+
+export function getLastHistoryReplaceState(): any {
+  return lastHistoryReplaceState;
+}
+
+export function clearLastHistoryReplaceState(): void {
+  lastHistoryReplaceState = null;
+}
+
 export function getRoute(db: ShadowClawDatabase, ev: Event) {
   if (!db) {
     return;
@@ -15,8 +29,12 @@ export function getRoute(db: ShadowClawDatabase, ev: Event) {
     typeof navigateEvent?.destination?.getState === "function"
       ? navigateEvent.destination.getState()
       : null;
+  const recordedState =
+    navigateEvent.navigationType === "replace" ? lastHistoryReplaceState : null;
   const navState =
     destinationState ||
+    navigateEvent?.info ||
+    recordedState ||
     (navigateEvent.navigationType === "replace" &&
     typeof history !== "undefined"
       ? history.state