@reckona/mreact-router 0.0.210 → 0.0.211

package/src/client.ts

@@ -61,6 +61,7 @@ export interface ClientRouteManifestEntry {
   clientReferenceManifest?: readonly ClientReferenceMetadata[] | undefined;
   devScript?: string;
   imports?: readonly string[];
+  modulePreloads?: readonly string[];
   navigation?: boolean;
   navigationScript?: string;
   routeId?: string;
@@ -3013,6 +3014,7 @@ export async function buildClientRouteEntrySource(
   const navigationStateDeclaration = inlineClientNavigation
     ? `const __mreactNavigationState = __mreactGlobal.__mreactNavigationState ??= {
   cache: new Map(),
+  cacheTokens: new Map(),
   current: {
     from: null,
     pending: false,
@@ -3021,6 +3023,7 @@ export async function buildClientRouteEntrySource(
   },
   fetchRevalidationInstalled: false,
   installed: false,
+  navigationFetchInits: new WeakSet(),
   pendingHtmlFetches: new Map(),
   prefetchedUrls: new Set(),
   prefetchedScripts: new Set(),
@@ -3029,7 +3032,9 @@ export async function buildClientRouteEntrySource(
   routePrefetchManifestText: undefined,
   viewportAnchors: new WeakSet(),
   viewportObserver: undefined,
-};`
+};
+__mreactNavigationState.cacheTokens ??= new Map();
+__mreactNavigationState.navigationFetchInits ??= new WeakSet();`
     : "";
   const deferredNavigationRuntime = deferredClientNavigation
     ? `
@@ -3192,10 +3197,10 @@ export async function __mreactNavigate(url, options = {}) {
     : false;
 }
 
-export async function __mreactPrefetch(url) {
+export async function __mreactPrefetch(url, options = {}) {
   const runtime = await __mreactLoadNavigationRuntime();
   return typeof runtime?.__mreactPrefetch === "function"
-    ? runtime.__mreactPrefetch(url)
+    ? runtime.__mreactPrefetch(url, options)
     : false;
 }
 
@@ -3241,13 +3246,16 @@ __mreactGlobal.__mreactRouteCell = (nativeCell, initial) => {
   const stateCell = nativeCell(record.value);
   const setStateCell = stateCell.set;
 
-  stateCell.set = (next) => {
+  const setRouteStateCell = (next) => {
     setStateCell((previous) => {
       const resolved = typeof next === "function" ? next(previous) : next;
       record.value = resolved;
       return resolved;
     });
   };
+  stateCell.set = setRouteStateCell;
+  stateCell.setValue = (next) => stateCell.set(() => next);
+  stateCell.update = (updater) => stateCell.set(updater);
 
   __mreactActiveCellRecords.set(cellKey, record);
   return stateCell;
@@ -3674,7 +3682,7 @@ function __mreactRouteAnnouncementElement() {
   return announcement;
 }
 
-export async function __mreactPrefetch(url) {
+export async function __mreactPrefetch(url, options = {}) {
   if (!__mreactCanPrefetch()) {
     return false;
   }
@@ -3693,10 +3701,6 @@ export async function __mreactPrefetch(url) {
     return false;
   }
 
-  if (__mreactNavigationState.prefetchedUrls.has(href)) {
-    return true;
-  }
-
   __mreactRememberPrefetchedUrl(href);
 
   const script = __mreactRouteScriptForNavigationUrl(href);
@@ -3705,21 +3709,30 @@ export async function __mreactPrefetch(url) {
     return __mreactPrefetchNavigationHtml(href);
   }
 
-  return __mreactPrefetchRouteScript(script);
+  const scriptPrefetched = __mreactPrefetchRouteScript(script);
+
+  if (options?.trigger === "viewport") {
+    return scriptPrefetched;
+  }
+
+  return Promise.resolve(__mreactPrefetchNavigationHtml(href))
+    .then(() => scriptPrefetched)
+    .catch(() => scriptPrefetched);
 }
 
 function __mreactPrefetchNavigationHtml(href) {
-  if (__mreactNavigationState.cache.has(href)) {
+  if (__mreactCachedNavigationHtml(href) !== undefined) {
     return true;
   }
 
-  return __mreactFetchNavigationHtmlOnce(href)
-    .then((html) => typeof html === "string")
+  return __mreactFetchNavigationHtmlOnce(href, { speculative: true })
+    .then((result) => result.cacheable && typeof result.html === "string")
     .catch(() => false);
 }
 
 const __mreactNavigationHtmlCacheMaxEntries = 64;
 const __mreactNavigationPrefetchHistoryMaxEntries = 64;
+const __mreactNavigationHtmlCacheTtlMs = 30_000;
 
 function __mreactRememberPrefetchedUrl(href) {
   __mreactRememberPrefetchHistory(__mreactNavigationState.prefetchedUrls, href);
@@ -3748,23 +3761,49 @@ function __mreactRememberPrefetchHistory(history, href) {
 }
 
 function __mreactCachedNavigationHtml(href) {
-  const html = __mreactNavigationState.cache.get(href);
+  const entry = __mreactNavigationState.cache.get(href);
 
-  if (html === undefined) {
+  if (entry === undefined) {
+    return undefined;
+  }
+
+  if (
+    entry.token !== __mreactNavigationState.cacheTokens.get(href) ||
+    entry.token.valid !== true ||
+    entry.cacheContext !== __mreactNavigationCacheContext() ||
+    Date.now() - entry.fetchedAt >= __mreactNavigationHtmlCacheTtlMs
+  ) {
+    __mreactNavigationState.cache.delete(href);
+    __mreactNavigationState.prefetchedUrls.delete(href);
+    __mreactReleaseNavigationCacheToken(href, entry.token);
     return undefined;
   }
 
   __mreactNavigationState.cache.delete(href);
-  __mreactNavigationState.cache.set(href, html);
-  return html;
+  __mreactNavigationState.cache.set(href, entry);
+  return entry.html;
 }
 
-function __mreactRememberNavigationHtml(href, html) {
+function __mreactRememberNavigationHtml(href, html, token, cacheContext) {
+  if (
+    token === undefined ||
+    token.valid !== true ||
+    __mreactNavigationState.cacheTokens.get(href) !== token ||
+    cacheContext !== __mreactNavigationCacheContext()
+  ) {
+    return;
+  }
+
   if (__mreactNavigationState.cache.has(href)) {
     __mreactNavigationState.cache.delete(href);
   }
 
-  __mreactNavigationState.cache.set(href, html);
+  __mreactNavigationState.cache.set(href, {
+    cacheContext,
+    fetchedAt: Date.now(),
+    html,
+    token,
+  });
 
   while (__mreactNavigationState.cache.size > __mreactNavigationHtmlCacheMaxEntries) {
     const oldestHref = __mreactNavigationState.cache.keys().next().value;
@@ -3775,37 +3814,100 @@ function __mreactRememberNavigationHtml(href, html) {
 
     __mreactNavigationState.cache.delete(oldestHref);
     __mreactNavigationState.prefetchedUrls.delete(oldestHref);
+    __mreactReleaseNavigationCacheToken(oldestHref);
   }
 }
 
-function __mreactPrefetchRouteScript(script) {
-  if (typeof document === "undefined") {
-    return false;
+function __mreactNavigationCacheContext() {
+  const authSession = typeof document === "undefined"
+    ? undefined
+    : document.getElementById("__mreact_auth_session")?.textContent ?? undefined;
+  const cookies = __mreactNavigationCookies();
+
+  return JSON.stringify([authSession, cookies]);
+}
+
+function __mreactNavigationCookies() {
+  return typeof document === "undefined" ? "" : document.cookie;
+}
+
+function __mreactNavigationResponseCacheContext(html, requestCookies) {
+  let authSession;
+
+  if (typeof document !== "undefined") {
+    const template = document.createElement("template");
+    template.innerHTML = html;
+    authSession = template.content.querySelector("#__mreact_auth_session")?.textContent ?? undefined;
   }
 
-  const href = __mreactNormalizeAssetUrl(script);
+  return JSON.stringify([authSession, requestCookies]);
+}
 
-  if (href === undefined) {
-    return false;
+function __mreactReleaseNavigationCacheToken(href, token) {
+  if (
+    __mreactNavigationState.cache.get(href) === undefined &&
+    __mreactNavigationState.pendingHtmlFetches.get(href) === undefined &&
+    (token === undefined || __mreactNavigationState.cacheTokens.get(href) === token)
+  ) {
+    __mreactNavigationState.cacheTokens.delete(href);
   }
+}
 
-  if (__mreactNavigationState.prefetchedScripts.has(href)) {
-    return true;
+function __mreactNavigationCacheToken(href) {
+  const existing = __mreactNavigationState.cacheTokens.get(href);
+
+  if (existing !== undefined) {
+    return existing;
   }
 
-  for (const link of Array.from(document.querySelectorAll('link[rel="modulepreload"][href]'))) {
-    if (link.href === href) {
-      __mreactRememberPrefetchedScript(href);
-      return true;
+  const token = { valid: true };
+  __mreactNavigationState.cacheTokens.set(href, token);
+  return token;
+}
+
+function __mreactPrefetchRouteScript(route) {
+  if (typeof document === "undefined") {
+    return false;
+  }
+
+  const files = [route.script, ...(route.modulePreloads ?? [])];
+  let valid = true;
+
+  for (const file of files) {
+    const href = __mreactNormalizeAssetUrl(file);
+
+    if (
+      href === undefined ||
+      !__mreactIsSupportedModulePreloadUrl(file) ||
+      !__mreactModulePreloadMatchesRouteScript(file, route.script)
+    ) {
+      valid = false;
+      continue;
+    }
+
+    if (__mreactNavigationState.prefetchedScripts.has(href)) {
+      continue;
+    }
+
+    let found = false;
+    for (const link of Array.from(document.querySelectorAll('link[rel="modulepreload"][href]'))) {
+      if (link.href === href) {
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      const link = document.createElement("link");
+      link.rel = "modulepreload";
+      link.href = href;
+      document.head.appendChild(link);
     }
+
+    __mreactRememberPrefetchedScript(href);
   }
 
-  const link = document.createElement("link");
-  link.rel = "modulepreload";
-  link.href = href;
-  document.head.appendChild(link);
-  __mreactRememberPrefetchedScript(href);
-  return true;
+  return valid;
 }
 
 export async function __mreactNavigate(url, options = {}) {
@@ -3818,19 +3920,46 @@ export async function __mreactNavigate(url, options = {}) {
   __mreactSetNavigationState(__mreactPendingNavigationState(href, options.type ?? "push"));
 
   try {
-    const cachedHtml = __mreactCachedNavigationHtml(href);
-    const script = __mreactRouteScriptForNavigationUrl(href);
-    if (script !== undefined) {
-      void __mreactPrefetchRouteScript(script);
-    }
-    const html = cachedHtml ?? await __mreactFetchNavigationHtmlOnce(href);
+    let forceReload = __mreactNavigationState.reloadNextNavigationFetch === true;
 
-    if (typeof html !== "string") {
-      return false;
-    }
+    for (;;) {
+      const cachedHtml = forceReload ? undefined : __mreactCachedNavigationHtml(href);
+      const script = __mreactRouteScriptForNavigationUrl(href);
+      if (script !== undefined) {
+        void __mreactPrefetchRouteScript(script);
+      }
+      const result = cachedHtml === undefined
+        ? await __mreactFetchNavigationHtmlOnce(href, { force: forceReload })
+        : {
+            cacheable: true,
+            cacheContext: __mreactNavigationCacheContext(),
+            cacheContextMatches: true,
+            html: cachedHtml,
+            reusable: true,
+            speculative: false,
+            token: undefined,
+          };
+
+      if (result.token !== undefined && result.token.valid !== true) {
+        forceReload = __mreactNavigationState.reloadNextNavigationFetch === true;
+        continue;
+      }
 
-    __mreactRememberNavigationHtml(href, html);
-    return await __mreactApplyNavigationHtmlWithOptionalTransition(html, href, options);
+      if (result.speculative === true && result.cacheable !== true) {
+        forceReload = true;
+        continue;
+      }
+
+      if (result.reusable === true && result.cacheContextMatches !== true) {
+        return false;
+      }
+
+      if (typeof result.html !== "string") {
+        return false;
+      }
+
+      return await __mreactApplyNavigationHtmlWithOptionalTransition(result.html, href, options);
+    }
   } finally {
     __mreactSetNavigationState(__mreactIdleNavigationState());
   }
@@ -3965,7 +4094,7 @@ function __mreactViewTransitionsAllowed(transition) {
   }
 }
 
-export function __mreactInvalidateNavigationCache(path) {
+export function __mreactInvalidateNavigationCache(path, excludedRequest) {
   const normalizedPath = __mreactNormalizeNavigationPath(path);
 
   if (normalizedPath === undefined) {
@@ -3979,66 +4108,160 @@ export function __mreactInvalidateNavigationCache(path) {
 
   for (const href of hrefs) {
     if (__mreactNormalizeNavigationPath(href) === normalizedPath) {
+      const token = __mreactNavigationState.cacheTokens.get(href);
+      if (
+        excludedRequest?.href === href &&
+        excludedRequest.token === token &&
+        token?.valid === true
+      ) {
+        continue;
+      }
+      if (token !== undefined) {
+        token.valid = false;
+      }
       __mreactNavigationState.cache.delete(href);
       __mreactNavigationState.prefetchedUrls.delete(href);
       __mreactNavigationState.pendingHtmlFetches.delete(href);
+      __mreactNavigationState.cacheTokens.delete(href);
     }
   }
 }
 
 function __mreactInvalidateAllNavigationCache() {
+  for (const entry of __mreactNavigationState.cache.values()) {
+    entry.token.valid = false;
+  }
+  for (const request of __mreactNavigationState.pendingHtmlFetches.values()) {
+    request.token.valid = false;
+  }
   __mreactNavigationState.cache.clear();
+  __mreactNavigationState.cacheTokens.clear();
   __mreactNavigationState.prefetchedUrls.clear();
   __mreactNavigationState.pendingHtmlFetches.clear();
 }
 
-function __mreactFetchNavigationHtmlOnce(href) {
+function __mreactFetchNavigationHtmlOnce(href, options = {}) {
   const pending = __mreactNavigationState.pendingHtmlFetches.get(href);
 
+  if (pending !== undefined && options.force !== true) {
+    return pending.promise;
+  }
+
   if (pending !== undefined) {
-    return pending;
+    pending.token.valid = false;
+    __mreactNavigationState.pendingHtmlFetches.delete(href);
+    __mreactNavigationState.cacheTokens.delete(href);
   }
 
-  const request = __mreactFetchNavigationHtml(href)
-    .then((html) => {
+  const token = __mreactNavigationCacheToken(href);
+  const pendingRequest = {
+    promise: undefined,
+    token,
+  };
+  const request = __mreactFetchNavigationHtml(href, options, pendingRequest)
+    .then((result) => {
+      const enriched = {
+        ...result,
+        speculative: options.speculative === true,
+        token,
+      };
       if (
-        typeof html === "string" &&
-        __mreactNavigationState.pendingHtmlFetches.get(href) === request
+        enriched.cacheable === true &&
+        typeof enriched.html === "string" &&
+        __mreactNavigationState.pendingHtmlFetches.get(href) === pendingRequest &&
+        token.valid === true &&
+        __mreactNavigationState.cacheTokens.get(href) === token
       ) {
-        __mreactRememberNavigationHtml(href, html);
+        __mreactRememberNavigationHtml(href, enriched.html, token, enriched.cacheContext);
       }
 
-      return html;
+      return enriched;
     })
     .finally(() => {
-      if (__mreactNavigationState.pendingHtmlFetches.get(href) === request) {
+      if (__mreactNavigationState.pendingHtmlFetches.get(href) === pendingRequest) {
         __mreactNavigationState.pendingHtmlFetches.delete(href);
+        __mreactReleaseNavigationCacheToken(href, token);
       }
     });
 
-  __mreactNavigationState.pendingHtmlFetches.set(href, request);
+  pendingRequest.promise = request;
+  __mreactNavigationState.pendingHtmlFetches.set(href, pendingRequest);
   return request;
 }
 
-function __mreactFetchNavigationHtml(href) {
-  const reloadRouteCache = __mreactNavigationState.reloadNextNavigationFetch === true;
-  __mreactNavigationState.reloadNextNavigationFetch = false;
+function __mreactFetchNavigationHtml(href, options = {}, pendingRequest) {
+  const speculative = options.speculative === true;
+  const reloadRouteCache = !speculative && __mreactNavigationState.reloadNextNavigationFetch === true;
+  if (!speculative) {
+    __mreactNavigationState.reloadNextNavigationFetch = false;
+  }
   const headers = reloadRouteCache
     ? { "x-mreact-navigation": "1", "x-mreact-navigation-cache": "reload" }
     : { "x-mreact-navigation": "1" };
-
-  return fetch(__mreactStaticNavigationRequestHref(href), {
-    headers,
-  }).then((response) => {
-    __mreactApplyRevalidationHeader(response);
-    if (__mreactNavigationResponseRequiresDocumentReload(response)) {
-      return undefined;
+  const requestCacheContext = __mreactNavigationCacheContext();
+  const requestCookies = __mreactNavigationCookies();
+  const navigationRequestInit = { headers };
+  __mreactNavigationState.navigationFetchInits.add(navigationRequestInit);
+
+  return fetch(__mreactStaticNavigationRequestHref(href), navigationRequestInit).then((response) => {
+    const currentRequest =
+      pendingRequest !== undefined &&
+      __mreactNavigationState.pendingHtmlFetches.get(href) === pendingRequest &&
+      __mreactNavigationState.cacheTokens.get(href) === pendingRequest.token &&
+      pendingRequest.token.valid === true
+        ? { href, token: pendingRequest.token }
+        : undefined;
+    if (pendingRequest === undefined || currentRequest !== undefined) {
+      __mreactApplyRevalidationHeader(response, currentRequest);
+    }
+    const requiresDocumentReload = __mreactNavigationResponseRequiresDocumentReload(response);
+    const responseIsSuccessful =
+      response.ok === true ||
+      (response.ok === undefined && response.status >= 200 && response.status < 300);
+    const responseIsRedirected = response.redirected === true;
+    const cacheControl = (response.headers.get("cache-control") ?? "").toLowerCase();
+    const responseDisallowsCache = /(?:^|,)\\s*(?:no-store|no-cache)(?:\\s*=|\\s*(?:,|$))/.test(
+      cacheControl,
+    );
+    const reusable =
+      !requiresDocumentReload &&
+      responseIsSuccessful &&
+      !responseIsRedirected &&
+      !responseDisallowsCache;
+
+    if (requiresDocumentReload || responseIsRedirected || speculative && !reusable) {
+      __mreactDiscardNavigationResponse(response);
+      return { cacheable: false, html: undefined };
     }
 
-    return response.text();
+    return response.text().then((html) => {
+      const cacheContext = __mreactNavigationResponseCacheContext(html, requestCookies);
+      const currentCacheContext = __mreactNavigationCacheContext();
+      const cacheContextMatches =
+        cacheContext === currentCacheContext && requestCacheContext === currentCacheContext;
+
+      return {
+        cacheContext,
+        cacheContextMatches,
+        cacheable: reusable && cacheContextMatches,
+        html,
+        reusable,
+      };
+    });
   });
 }
 
+function __mreactDiscardNavigationResponse(response) {
+  try {
+    const result = response?.body?.cancel?.();
+    if (result !== undefined && typeof result.catch === "function") {
+      void result.catch(() => {});
+    }
+  } catch {
+    // Ignore body cancellation failures while falling back to a document navigation.
+  }
+}
+
 function __mreactStaticNavigationRequestHref(href) {
   if (typeof document === "undefined" || typeof location === "undefined") {
     return href;
@@ -4074,7 +4297,7 @@ function __mreactNavigationResponseRequiresDocumentReload(response) {
   return response.status === 204 || response.headers.get("x-mreact-navigation") === "reload";
 }
 
-function __mreactApplyRevalidationHeader(response) {
+function __mreactApplyRevalidationHeader(response, currentRequest) {
   const header = typeof response?.headers?.get === "function"
     ? response.headers.get("x-mreact-revalidate")
     : null;
@@ -4083,18 +4306,34 @@ function __mreactApplyRevalidationHeader(response) {
     return;
   }
 
+  const currentPath = __mreactNormalizeNavigationPath(currentRequest?.href);
+
   for (const path of header.split(",")) {
-    __mreactInvalidateNavigationCache(path.trim());
+    const trimmedPath = path.trim();
+    const normalizedPath = __mreactNormalizeNavigationPath(trimmedPath);
+    const excludedRequest =
+      currentRequest !== undefined && normalizedPath === currentPath ? currentRequest : undefined;
+    __mreactInvalidateNavigationCache(trimmedPath, excludedRequest);
   }
 }
 
+function __mreactIsNavigationFetchRequest(_input, init) {
+  return init !== null && typeof init === "object" && __mreactNavigationState.navigationFetchInits.has(init);
+}
+
 function __mreactNormalizeNavigationPath(path) {
+  if (typeof path !== "string" || path.trim() === "") {
+    return undefined;
+  }
+
+  const normalizedInput = path.trim();
+
   if (typeof location === "undefined") {
-    return typeof path === "string" && path.length > 0 ? path : undefined;
+    return normalizedInput;
   }
 
   try {
-    const url = new URL(path, location.href);
+    const url = new URL(normalizedInput, location.href);
     const pathname = url.pathname.replace(/\\/+$/, "");
 
     return pathname === "" ? "/" : pathname;
@@ -4110,7 +4349,7 @@ export function __mreactRestoreHistoryState(state) {
 
   const html = typeof state.html === "string"
     ? state.html
-    : typeof state.url === "string" ? __mreactNavigationState.cache.get(state.url) : undefined;
+    : typeof state.url === "string" ? __mreactCachedNavigationHtml(state.url) : undefined;
 
   if (typeof html !== "string") {
     return false;
@@ -4486,7 +4725,7 @@ function __mreactRouteScriptForNavigationUrl(url) {
 
   for (const route of __mreactClientRoutePrefetchManifest()) {
     if (__mreactRoutePathMatches(route.path, nextUrl.pathname)) {
-      return route.script;
+      return route;
     }
   }
 
@@ -4516,12 +4755,28 @@ function __mreactClientRoutePrefetchManifest() {
   try {
     const parsed = JSON.parse(text);
     __mreactNavigationState.routePrefetchManifest = Array.isArray(parsed)
-      ? parsed.filter((route) =>
-          route !== null &&
-          typeof route === "object" &&
-          typeof route.path === "string" &&
-          typeof route.script === "string"
-        )
+      ? parsed.flatMap((route) => {
+          if (
+            route === null ||
+            typeof route !== "object" ||
+            typeof route.path !== "string" ||
+            typeof route.script !== "string" ||
+            !__mreactIsSupportedModulePreloadUrl(route.script)
+          ) {
+            return [];
+          }
+
+          const modulePreloads = Array.isArray(route.modulePreloads)
+            ? route.modulePreloads.filter(
+                (file) =>
+                  typeof file === "string" &&
+                  __mreactIsSupportedModulePreloadUrl(file) &&
+                  __mreactModulePreloadMatchesRouteScript(file, route.script),
+              )
+            : [];
+
+          return [{ ...route, modulePreloads }];
+        })
       : [];
   } catch {
     __mreactNavigationState.routePrefetchManifest = [];
@@ -4530,6 +4785,29 @@ function __mreactClientRoutePrefetchManifest() {
   return __mreactNavigationState.routePrefetchManifest;
 }
 
+function __mreactIsSupportedModulePreloadUrl(value) {
+  if (typeof value !== "string" || value === "" || value.startsWith("javascript:")) {
+    return false;
+  }
+
+  try {
+    const resolved = new URL(value, typeof location === "undefined" ? undefined : location.href);
+    return resolved.protocol === "http:" || resolved.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function __mreactModulePreloadMatchesRouteScript(value, script) {
+  try {
+    const scriptUrl = new URL(__mreactNormalizeAssetUrl(script), location.href);
+    const dependencyUrl = new URL(__mreactNormalizeAssetUrl(value), location.href);
+    return scriptUrl.origin === dependencyUrl.origin;
+  } catch {
+    return false;
+  }
+}
+
 function __mreactRoutePathMatches(routePath, pathname) {
   const routeSegments = __mreactNormalizeRoutePath(routePath);
   const pathSegments = __mreactNormalizeRoutePath(pathname);
@@ -4827,9 +5105,12 @@ function __mreactInstallNavigationFetchRevalidation() {
   const fetchImpl = globalThis.fetch;
   globalThis.fetch = function(input, init) {
     const mutating = __mreactIsMutatingFetchRequest(input, init);
+    const navigation = __mreactIsNavigationFetchRequest(input, init);
 
     return Promise.resolve(fetchImpl.call(this, input, init)).then((response) => {
-      __mreactApplyRevalidationHeader(response);
+      if (!navigation) {
+        __mreactApplyRevalidationHeader(response);
+      }
 
       if (mutating) {
         __mreactInvalidateAllNavigationCache();
@@ -4901,7 +5182,7 @@ function __mreactObserveViewportPrefetchAnchors(root) {
         }
 
         __mreactNavigationState.viewportObserver?.unobserve(entry.target);
-        void __mreactPrefetch(entry.target.href);
+        void __mreactPrefetch(entry.target.href, { trigger: "viewport" });
       }
     });
   }