@reckona/mreact-router 0.0.202 → 0.0.204

package/src/cache.ts

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { responseHeadersContainCspNonce } from "./csp.js";
 
 /**
  * Describes the cache lifetime assigned to a rendered route response.
@@ -73,7 +74,6 @@ export interface MemoryRouteCacheOptions {
 
 interface AppRouterCacheState {
   activeContexts: RouteCacheContext[];
-  invalidatedPaths: Set<string>;
   memoryCache: AppRouterCache;
   storage: AsyncLocalStorage<RouteCacheContext>;
 }
@@ -82,18 +82,42 @@ interface RouteCacheContext {
   cache: AppRouterCache;
   cachePolicy?: RouteCachePolicy | undefined;
   closed?: boolean | undefined;
+  externalInvalidationOverflowed: boolean;
+  externallyInvalidatedPaths: Set<string>;
   revalidatedPaths: Set<string>;
 }
 
+interface AppRouterCacheInvalidationState {
+  activeContexts: WeakMap<AppRouterCache, Set<RouteCacheContext>>;
+  disabledCaches: WeakSet<AppRouterCache>;
+  finalizer: FinalizationRegistry<WeakRef<AppRouterCache>>;
+  liveReferences: Set<WeakRef<AppRouterCache>>;
+  pendingPaths: WeakMap<AppRouterCache, Set<string>>;
+  registeredCaches: WeakSet<AppRouterCache>;
+  running: WeakMap<AppRouterCache, Promise<void>>;
+  storesBeingInvalidated: WeakMap<AppRouterCache, number>;
+}
+
+const MAX_PENDING_ROUTE_INVALIDATIONS = 1024;
+
+const cacheInvalidationState = ((
+  globalThis as {
+    __mreactAppRouterCacheInvalidation?: AppRouterCacheInvalidationState;
+  }
+).__mreactAppRouterCacheInvalidation ??= createCacheInvalidationState());
+cacheInvalidationState.activeContexts ??= new WeakMap();
+cacheInvalidationState.disabledCaches ??= new WeakSet();
+cacheInvalidationState.storesBeingInvalidated ??= new WeakMap();
+
 const cacheState = ((
   globalThis as { __mreactAppRouterCache?: AppRouterCacheState }
 ).__mreactAppRouterCache ??= {
   activeContexts: [],
-  invalidatedPaths: new Set(),
   memoryCache: createMemoryRouteCache(),
   storage: new AsyncLocalStorage<RouteCacheContext>(),
 });
 cacheState.storage ??= new AsyncLocalStorage<RouteCacheContext>();
+registerRouteCache(cacheState.memoryCache);
 
 /**
  * Creates an in-memory route response cache for app-router rendering.
@@ -164,7 +188,7 @@ export function createMemoryRouteCache(options: MemoryRouteCacheOptions = {}): A
     }
   }
 
-  return {
+  const cache: AppRouterCache = {
     deleteByPath(path) {
       const normalizedPath = normalizeRevalidationPath(path);
       const keys = keysByPath.get(normalizedPath);
@@ -212,6 +236,8 @@ export function createMemoryRouteCache(options: MemoryRouteCacheOptions = {}): A
       }
     },
   };
+  registerRouteCache(cache);
+  return cache;
 }
 
 function positiveIntegerOrDefault(value: number | undefined, fallback: number): number {
@@ -296,6 +322,10 @@ export function cachedRouteResponse(options: {
 
     const cache = options.cache ?? cacheState.memoryCache;
 
+    registerRouteCache(cache);
+    if (routeCacheIsUnavailable(cache)) {
+      return undefined;
+    }
     await consumeInvalidations(cache);
     const now = options.now ?? Date.now();
     const cached = await cache.get(options.key, now);
@@ -310,6 +340,9 @@ export function cachedRouteResponse(options: {
     }
 
     const headers = new Headers(cached.headers ?? {});
+    if (responseHeadersContainCspNonce(headers)) {
+      return undefined;
+    }
     headers.set("cache-control", cached.cacheControl);
     if (!headers.has("content-type")) {
       headers.set("content-type", "text/html; charset=utf-8");
@@ -367,6 +400,10 @@ export async function cacheRouteResponse(options: {
   const cacheControl = options.policy.cacheControl;
   const status = options.response.status;
   const contentType = options.response.headers.get("content-type") ?? "text/html; charset=utf-8";
+  const cache = options.cache ?? cacheState.memoryCache;
+  const normalizedPath = normalizeRevalidationPath(options.path);
+  registerRouteCache(cache);
+  const invalidatedBeforeStore = routeCachePathWasInvalidatedDuringActiveContext(normalizedPath);
 
   // A render that read a request header only produced HTML that is correct for
   // that header value. The cache key covers the path and query alone, so the
@@ -374,15 +411,23 @@ export async function cacheRouteResponse(options: {
   // shared caches too, which are keyed the same way.
   if (
     options.headerDependent === true ||
+    invalidatedBeforeStore ||
+    routeCacheIsUnavailable(cache) ||
     requestCarriesCredentials(options.request) ||
-    options.response.headers.has("set-cookie")
+    options.response.headers.has("set-cookie") ||
+    responseHeadersContainCspNonce(options.response.headers)
   ) {
     const headers = new Headers(options.response.headers);
     headers.set("cache-control", "private, no-store");
     if (!headers.has("content-type")) {
       headers.set("content-type", contentType);
     }
-    if (options.headerDependent === true) {
+    if (
+      options.headerDependent === true ||
+      invalidatedBeforeStore ||
+      routeCacheIsUnavailable(cache) ||
+      responseHeadersContainCspNonce(options.response.headers)
+    ) {
       headers.set("x-mreact-cache", "DYNAMIC");
     }
 
@@ -410,17 +455,57 @@ export async function cacheRouteResponse(options: {
   // from every later secure visitor.
   const hsts = options.strictTransportSecurity;
 
-  await (options.cache ?? cacheState.memoryCache).set(options.key, {
+  await cache.set(options.key, {
     body,
     cacheControl,
     expiresAt: (options.now ?? Date.now()) + options.policy.revalidateSeconds * 1000,
     headers: storedHeaders,
     ...(hsts === undefined ? {} : { strictTransportSecurity: hsts }),
-    path: normalizeRevalidationPath(options.path),
+    path: normalizedPath,
     schemaVersion: ROUTE_CACHE_ENTRY_SCHEMA_VERSION,
     status,
   });
 
+  if (
+    routeCachePathWasInvalidatedDuringActiveContext(normalizedPath) ||
+    routeCacheIsUnavailable(cache)
+  ) {
+    beginRouteCacheStoreInvalidation(cache);
+    try {
+      await cache.deleteByPath(normalizedPath);
+      endRouteCacheStoreInvalidation(cache);
+    } catch (error) {
+      // The invalidation may have completed before this asynchronous set did.
+      // If deleting the late write now fails, replace its exact key with an
+      // expired entry so another adapter object backed by the same persistent
+      // store cannot replay the stale current-schema value.
+      try {
+        await cache.set(options.key, {
+          body: "",
+          cacheControl: "no-store",
+          expiresAt: 0,
+          headers: {},
+          path: normalizedPath,
+          schemaVersion: ROUTE_CACHE_ENTRY_SCHEMA_VERSION,
+          status: 500,
+        });
+      } catch {
+        // The originating cache object still fails closed below even when the
+        // persistent backend rejects both deletion and the tombstone write.
+      }
+      cacheInvalidationState.disabledCaches.add(cache);
+      endRouteCacheStoreInvalidation(cache);
+      throw error;
+    }
+    const headers = new Headers(storedHeaders);
+    headers.set("cache-control", "private, no-store");
+    headers.set("x-mreact-cache", "DYNAMIC");
+    if (!headers.has("content-type")) {
+      headers.set("content-type", contentType);
+    }
+    return new Response(body, { headers, status });
+  }
+
   const headers = new Headers(storedHeaders);
   headers.set("cache-control", cacheControl);
   if (!headers.has("content-type")) {
@@ -541,7 +626,7 @@ const PUBLIC_ROUTE_CACHE_REQUEST_HEADERS = new Set([
 /**
  * Invalidates cached route responses for a normalized app-router path.
  *
- * During a request the invalidation is scoped to that route cache context; outside a request it is queued for the next cache access.
+ * During a request the invalidation is scoped to that route cache context. Outside a request it is broadcast to every live route cache registered in this process, and later reads wait for their cache's invalidation to finish.
  */
 export function revalidatePath(path: string): void {
   const normalizedPath = normalizeRevalidationPath(path);
@@ -552,31 +637,186 @@ export function revalidatePath(path: string): void {
     return;
   }
 
-  cacheState.invalidatedPaths.add(normalizedPath);
+  for (const reference of cacheInvalidationState.liveReferences) {
+    const cache = reference.deref();
+    if (cache === undefined) {
+      cacheInvalidationState.liveReferences.delete(reference);
+      continue;
+    }
+
+    const pendingPaths = cacheInvalidationState.pendingPaths.get(cache);
+    if (
+      pendingPaths !== undefined &&
+      !cacheInvalidationState.disabledCaches.has(cache) &&
+      !pendingPaths.has(normalizedPath)
+    ) {
+      if (pendingPaths.size >= MAX_PENDING_ROUTE_INVALIDATIONS) {
+        pendingPaths.clear();
+        cacheInvalidationState.disabledCaches.add(cache);
+      } else {
+        pendingPaths.add(normalizedPath);
+      }
+    }
+    markActiveRouteCacheContextsInvalidated(cache, normalizedPath);
+    void startPendingInvalidations(cache).catch(() => {});
+  }
 }
 
 export async function consumeInvalidations(
   cache: AppRouterCache = cacheState.memoryCache,
 ): Promise<void> {
-  if (cacheState.invalidatedPaths.size === 0) {
+  registerRouteCache(cache);
+  await startPendingInvalidations(cache);
+}
+
+function registerRouteCache(cache: AppRouterCache): void {
+  if (cacheInvalidationState.registeredCaches.has(cache)) {
     return;
   }
 
-  for (const path of cacheState.invalidatedPaths) {
-    await cache.deleteByPath(path);
+  cacheInvalidationState.registeredCaches.add(cache);
+  cacheInvalidationState.pendingPaths.set(cache, new Set());
+  const reference = new WeakRef(cache);
+  cacheInvalidationState.liveReferences.add(reference);
+  cacheInvalidationState.finalizer.register(cache, reference, reference);
+}
+
+function startPendingInvalidations(cache: AppRouterCache): Promise<void> {
+  const running = cacheInvalidationState.running.get(cache);
+  if (running !== undefined) {
+    return running;
   }
 
-  cacheState.invalidatedPaths.clear();
+  const paths = cacheInvalidationState.pendingPaths.get(cache);
+  if (paths === undefined || paths.size === 0) {
+    return Promise.resolve();
+  }
+
+  const task = drainPendingInvalidations(cache, paths);
+  cacheInvalidationState.running.set(cache, task);
+  void task
+    .finally(() => {
+      if (cacheInvalidationState.running.get(cache) === task) {
+        cacheInvalidationState.running.delete(cache);
+      }
+    })
+    .catch(() => {});
+  return task;
+}
+
+function createCacheInvalidationState(): AppRouterCacheInvalidationState {
+  const liveReferences = new Set<WeakRef<AppRouterCache>>();
+  return {
+    activeContexts: new WeakMap(),
+    disabledCaches: new WeakSet(),
+    finalizer: new FinalizationRegistry((reference) => {
+      liveReferences.delete(reference);
+    }),
+    liveReferences,
+    pendingPaths: new WeakMap(),
+    registeredCaches: new WeakSet(),
+    running: new WeakMap(),
+    storesBeingInvalidated: new WeakMap(),
+  };
+}
+
+function routeCacheIsUnavailable(cache: AppRouterCache): boolean {
+  return (
+    cacheInvalidationState.disabledCaches.has(cache) ||
+    (cacheInvalidationState.storesBeingInvalidated.get(cache) ?? 0) > 0
+  );
+}
+
+function beginRouteCacheStoreInvalidation(cache: AppRouterCache): void {
+  cacheInvalidationState.storesBeingInvalidated.set(
+    cache,
+    (cacheInvalidationState.storesBeingInvalidated.get(cache) ?? 0) + 1,
+  );
+}
+
+function endRouteCacheStoreInvalidation(cache: AppRouterCache): void {
+  const remaining = (cacheInvalidationState.storesBeingInvalidated.get(cache) ?? 1) - 1;
+  if (remaining <= 0) {
+    cacheInvalidationState.storesBeingInvalidated.delete(cache);
+  } else {
+    cacheInvalidationState.storesBeingInvalidated.set(cache, remaining);
+  }
+}
+
+function routeCachePathWasInvalidatedDuringActiveContext(path: string): boolean {
+  const context = activeRouteCacheContext();
+  return (
+    context !== undefined &&
+    (context.externalInvalidationOverflowed || context.externallyInvalidatedPaths.has(path))
+  );
+}
+
+function markActiveRouteCacheContextsInvalidated(
+  cache: AppRouterCache,
+  normalizedPath: string,
+): void {
+  for (const context of cacheInvalidationState.activeContexts.get(cache) ?? []) {
+    if (cacheInvalidationState.disabledCaches.has(cache)) {
+      context.externalInvalidationOverflowed = true;
+      context.externallyInvalidatedPaths.clear();
+    } else if (
+      !context.externallyInvalidatedPaths.has(normalizedPath) &&
+      context.externallyInvalidatedPaths.size >= MAX_PENDING_ROUTE_INVALIDATIONS
+    ) {
+      context.externalInvalidationOverflowed = true;
+      context.externallyInvalidatedPaths.clear();
+    } else {
+      context.externallyInvalidatedPaths.add(normalizedPath);
+    }
+  }
+}
+
+function registerActiveRouteCacheContext(context: RouteCacheContext): void {
+  const contexts = cacheInvalidationState.activeContexts.get(context.cache);
+  if (contexts === undefined) {
+    cacheInvalidationState.activeContexts.set(context.cache, new Set([context]));
+    return;
+  }
+
+  contexts.add(context);
+}
+
+function unregisterActiveRouteCacheContext(context: RouteCacheContext): void {
+  const contexts = cacheInvalidationState.activeContexts.get(context.cache);
+  contexts?.delete(context);
+  if (contexts?.size === 0) {
+    cacheInvalidationState.activeContexts.delete(context.cache);
+  }
+}
+
+async function drainPendingInvalidations(
+  cache: AppRouterCache,
+  paths: Set<string>,
+): Promise<void> {
+  while (paths.size > 0) {
+    const path = paths.values().next().value;
+    if (path === undefined) {
+      return;
+    }
+
+    await cache.deleteByPath(path);
+    paths.delete(path);
+  }
 }
 
 export async function withRouteCacheContext<T>(
   cache: AppRouterCache | undefined,
   fn: () => T | Promise<T>,
 ): Promise<{ cachePolicy: RouteCachePolicy | undefined; revalidatedPaths: string[]; value: T }> {
+  const routeCache = cache ?? cacheState.memoryCache;
+  registerRouteCache(routeCache);
   const context: RouteCacheContext = {
-    cache: cache ?? cacheState.memoryCache,
+    cache: routeCache,
+    externalInvalidationOverflowed: false,
+    externallyInvalidatedPaths: new Set(),
     revalidatedPaths: new Set(),
   };
+  registerActiveRouteCacheContext(context);
 
   return cacheState.storage.run(context, async () => {
     try {
@@ -592,6 +832,7 @@ export async function withRouteCacheContext<T>(
       return { cachePolicy, revalidatedPaths, value };
     } finally {
       context.closed = true;
+      unregisterActiveRouteCacheContext(context);
     }
   });
 }
@@ -600,12 +841,17 @@ export function beginRouteCacheContext(cache: AppRouterCache | undefined): {
   readonly cachePolicy: RouteCachePolicy | undefined;
   dispose(): Promise<{ revalidatedPaths: string[] }>;
 } {
+  const routeCache = cache ?? cacheState.memoryCache;
+  registerRouteCache(routeCache);
   const context: RouteCacheContext = {
-    cache: cache ?? cacheState.memoryCache,
+    cache: routeCache,
+    externalInvalidationOverflowed: false,
+    externallyInvalidatedPaths: new Set(),
     revalidatedPaths: new Set(),
   };
 
   cacheState.activeContexts.push(context);
+  registerActiveRouteCacheContext(context);
 
   return {
     get cachePolicy() {
@@ -623,6 +869,7 @@ export function beginRouteCacheContext(cache: AppRouterCache | undefined): {
         if (index !== -1) {
           cacheState.activeContexts.splice(index, 1);
         }
+        unregisterActiveRouteCacheContext(context);
       }
 
       return { revalidatedPaths };
@@ -650,10 +897,16 @@ export function activeRouteCacheContext(): RouteCacheContext | undefined {
 
 // Host is excluded from the cache key to prevent attacker-supplied Host
 // headers from fragmenting / poisoning the cache (Issue 068). The Vary
-// dimension is the request path + query; same-origin reverse proxies are
-// expected to handle vhost separation at their layer.
-export function routeCacheKey(appDir: string, routePath: string, url: URL): string {
-  return `${appDir}\0${normalizeRevalidationPath(routePath)}\0${url.pathname}${url.search}`;
+// dimensions are the request path + query and the document/navigation HTML
+// shape; same-origin reverse proxies are expected to handle vhost separation
+// at their layer.
+export function routeCacheKey(
+  appDir: string,
+  routePath: string,
+  url: URL,
+  responseVariant: "document" | "navigation" = "document",
+): string {
+  return `${appDir}\0${normalizeRevalidationPath(routePath)}\0${url.pathname}${url.search}\0${responseVariant}`;
 }
 
 export function stripRevalidateExport(code: string): string {

package/src/cli-options.ts

@@ -335,6 +335,7 @@ export function formatCliHelp(command?: string | undefined): string {
       "",
       "Options:",
       "  --host <host>  Bind address. Default: 127.0.0.1. Use 0.0.0.0 inside containers behind explicit port publishing or a reverse proxy.",
+      "  --port <port>  TCP port. Overrides PORT. Default: 3001.",
       "  --host-policy=strict|trusted-proxy",
       "      Control Host header trust for request origin reconstruction.",
       "  --allowed-hosts <host[,host...]>",
@@ -469,6 +470,18 @@ export function resolveCliDevPort(
   return envValue === undefined || envValue === "" ? viteConfigPort : parseCliPort(envValue);
 }
 
+export function resolveCliStartPort(
+  flagValue: number | undefined,
+  env: { PORT?: string | undefined },
+): number {
+  if (flagValue !== undefined) {
+    return flagValue;
+  }
+
+  const envValue = env.PORT;
+  return envValue === undefined || envValue === "" ? 3001 : parseCliPort(envValue, "PORT");
+}
+
 export function resolveCliHostPolicy(
   flagValue: RequestHostPolicy | undefined,
   env: { MREACT_ROUTER_HOST_POLICY?: string | undefined },
@@ -527,7 +540,7 @@ function parseCliRequestLogMode(value: string): CliRequestLogMode {
   throw new Error(`Unsupported log mode ${JSON.stringify(value)}. Expected "requests".`);
 }
 
-function parseCliPort(value: string): number {
+function parseCliPort(value: string, source = "port"): number {
   const port = Number(value);
 
   if (Number.isInteger(port) && port >= 0 && port <= 65535) {
@@ -535,7 +548,7 @@ function parseCliPort(value: string): number {
   }
 
   throw new Error(
-    `Unsupported port ${JSON.stringify(value)}. Expected an integer from 0 to 65535.`,
+    `Unsupported ${source} ${JSON.stringify(value)}. Expected an integer from 0 to 65535.`,
   );
 }
 

package/src/cli.ts

@@ -25,6 +25,7 @@ import {
   resolveCliHost,
   resolveCliHostPolicy,
   resolveCliRequestLogMode,
+  resolveCliStartPort,
   resolveCliTrustForwardedProto,
 } from "./cli-options.js";
 import { startDevServer } from "./dev-server.js";
@@ -63,7 +64,16 @@ if (parsed !== undefined) {
         const loaded =
           routeArg === undefined
             ? await loadMreactRouterViteConfigDetails({ command: "build", cwd: process.cwd() })
-            : { project: { appDir: resolve(routeArg) }, viteConfig: undefined };
+            : {
+                dehydrateOptions: undefined,
+                project: { appDir: resolve(routeArg) },
+                viteConfig: undefined,
+              };
+        if (loaded.dehydrateOptions !== undefined) {
+          throw new Error(
+            "Production builds must configure dehydratePolicyModule instead of an inline dehydrateOptions callback so generated runtimes use the same policy as prerendering.",
+          );
+        }
         try {
           const result = await buildApp({
             ...loaded.project,
@@ -150,12 +160,16 @@ if (parsed !== undefined) {
           routeArg === undefined
             ? await loadMreactRouterViteConfigDetails({ command: "serve", cwd: process.cwd() })
             : {
+                dehydrateOptions: undefined,
                 project: { appDir: resolve(routeArg) },
                 serverPort: undefined,
                 viteConfig: undefined,
               };
         const server = await startDevServer({
           ...loaded.project,
+          ...(loaded.dehydrateOptions === undefined
+            ? {}
+            : { dehydrateOptions: loaded.dehydrateOptions }),
           hostname: resolveCliHost(parsed.host, process.env),
           logger,
           port: resolveCliDevPort(parsed.port, process.env, loaded.serverPort),
@@ -169,7 +183,7 @@ if (parsed !== undefined) {
           hostname: resolveCliHost(parsed.host, process.env),
           logger,
           outDir: resolve(routeArg ?? ".mreact"),
-          port: Number(process.env.PORT ?? 3001),
+          port: resolveCliStartPort(parsed.port, process.env),
           trustForwardedProto: resolveCliTrustForwardedProto(
             parsed.trustForwardedProto,
             process.env,

package/src/client.ts

@@ -78,6 +78,7 @@ export interface BuildClientRouteOutputOptions {
   filename: string;
   minify?: boolean | undefined;
   routePath: string;
+  restoreRequestUrl?: boolean | undefined;
   sourceMap?: boolean | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
   clientNavigation?: boolean | undefined;
@@ -2632,9 +2633,18 @@ export function withHydrationMarkers(options: {
 }
 
 export function withRouteMarkers(options: { html: string; routePath: string }): string {
-  const routeId = routeIdForPath(options.routePath);
+  const marker = routeMarkerParts(options.routePath);
 
-  return `<div ${routeHydrationContract.routeMarkerAttribute}="${escapeHtmlAttribute(routeId)}">${options.html}</div>`;
+  return `${marker.prefix}${options.html}${marker.suffix}`;
+}
+
+export function routeMarkerParts(routePath: string): { prefix: string; suffix: string } {
+  const routeId = routeIdForPath(routePath);
+
+  return {
+    prefix: `<div ${routeHydrationContract.routeMarkerAttribute}="${escapeHtmlAttribute(routeId)}">`,
+    suffix: "</div>",
+  };
 }
 
 export function hydrationMarkerParts(options: {
@@ -2872,6 +2882,8 @@ export async function buildClientRouteEntrySource(
   );
 
   const routeId = routeIdForPath(options.routePath);
+  const restoreRequestUrl =
+    options.restoreRequestUrl ?? (options.debugLabels === true || /\brequest\b/.test(options.code));
   const routeUsesCells = detectRouteCellStateHint(compiled.code);
   const routeUsesReactiveEffect = detectRouteReactiveEffectHint(compiled.code);
   const routeUsesDomRefs = compiled.metadata.imports.some(
@@ -3401,6 +3413,7 @@ ${routeOutOfOrderFragmentHydration}  const __mreactMarker = document.querySelect
   const __mreactProps = __mreactPropsText === undefined
     ? {}
     : JSON.parse(__mreactPropsText);
+${restoreRequestUrl ? "  if (__mreactProps.request) __mreactProps.request.url = document.URL;\n" : ""}
   const __mreactClientReferences = __mreactClientReferencesElement?.textContent === undefined
     ? []
     : JSON.parse(__mreactClientReferencesElement.textContent);
@@ -3924,7 +3937,7 @@ function __mreactFetchNavigationHtml(href) {
     ? { "x-mreact-navigation": "1", "x-mreact-navigation-cache": "reload" }
     : { "x-mreact-navigation": "1" };
 
-  return fetch(href, {
+  return fetch(__mreactStaticNavigationRequestHref(href), {
     headers,
   }).then((response) => {
     __mreactApplyRevalidationHeader(response);
@@ -3936,6 +3949,37 @@ function __mreactFetchNavigationHtml(href) {
   });
 }
 
+function __mreactStaticNavigationRequestHref(href) {
+  if (typeof document === "undefined" || typeof location === "undefined") {
+    return href;
+  }
+
+  const base = document
+    .querySelector('meta[name="mreact-static-navigation"]')
+    ?.getAttribute("content")
+    ?.trim();
+  if (base === undefined || base === "") {
+    return href;
+  }
+
+  try {
+    const destination = new URL(href, location.href);
+    if (destination.origin !== location.origin) {
+      return href;
+    }
+    const routePath = destination.pathname.replace(/^\\/+|\\/+$/g, "");
+    const artifactPath = routePath === "" ? "index.html" : routePath + "/index.html";
+    const artifact = new URL(
+      base.replace(/\\/+$/g, "") + "/" + artifactPath,
+      location.origin,
+    );
+    artifact.search = destination.search;
+    return artifact.href;
+  } catch {
+    return href;
+  }
+}
+
 function __mreactNavigationResponseRequiresDocumentReload(response) {
   return response.status === 204 || response.headers.get("x-mreact-navigation") === "reload";
 }