@rangojs/router 0.2.0 → 0.4.1

package/src/rsc/rsc-rendering.ts

@@ -61,14 +61,28 @@ import {
   type DevShellLookup,
 } from "./shell-build-manifest.js";
 import { contextGet } from "../context-var.js";
+import {
+  getNavigationContextHeader,
+  prerenderStoreShortCircuits,
+} from "../router/navigation-snapshot.js";
+import {
+  ensureFullRouteSnapshot,
+  type RouteSnapshot,
+} from "../router/route-snapshot.js";
+import { prerenderEntryExists } from "../router/match-middleware/cache-lookup.js";
 import {
   resolveSameOriginRedirect,
   safeSameOriginLanding,
 } from "../redirect-origin.js";
 import { nonce as nonceToken } from "./nonce.js";
 import { reportCacheError } from "../cache/cache-error.js";
+import type { SearchParamsFilter } from "../cache/search-params-filter.js";
 import { INTERNAL_RANGO_DEBUG } from "../internal-debug.js";
-import type { ShellCacheEntry, ShellSnapshotRecord } from "../cache/types.js";
+import type {
+  SegmentCacheStore,
+  ShellCacheEntry,
+  ShellSnapshotRecord,
+} from "../cache/types.js";
 
 type PprReplayBypassReason =
   | "method"
@@ -76,6 +90,10 @@ type PprReplayBypassReason =
   | "nonce"
   | "store-unavailable"
   | "passive-read-unsupported"
+  | "no-navigation-context"
+  | "prerender-store"
+  | "intercept"
+  | "cache-disabled"
   | "read-error"
   | "no-entry"
   | "invalid-version"
@@ -84,6 +102,7 @@ type PprReplayBypassReason =
   | "transition-when"
   | "no-segment-snapshot"
   | "snapshot-miss"
+  | "explicit-cache-hit"
   | "stale-build-entry";
 
 type PprReplayStatus =
@@ -106,6 +125,66 @@ function describePprReplayStatus(status: PprReplayStatus): string {
     : `bypass:${status.reason}`;
 }
 
+function buildNavigationShellKey(
+  url: URL,
+  filter?: SearchParamsFilter,
+): string {
+  return `${buildShellKey(url, filter)}:navigation`;
+}
+
+function createShellCaptureDescriptor(
+  ctx: HandlerContext<any>,
+  key: string,
+  pprConfig: ResolvedPprConfig,
+  store: SegmentCacheStore<any>,
+  navigationOnly?: true,
+): ShellCaptureDescriptor {
+  return {
+    key,
+    buildVersion: ctx.version,
+    ttl: pprConfig.ttl,
+    swr: pprConfig.swr,
+    tags: pprConfig.tags,
+    captureTimeout: pprConfig.captureTimeout,
+    store,
+    debug: INTERNAL_RANGO_DEBUG,
+    maxSnapshotBytes: pprConfig.maxSnapshotBytes,
+    debugSink: resolveShellCaptureDebugSink(ctx.router.debugShellCapture),
+    navigationOnly,
+  };
+}
+
+function shouldHealReplayMiss(
+  reason: PprReplayBypassReason | undefined,
+): boolean {
+  return (
+    reason === undefined ||
+    reason === "invalid-version" ||
+    reason === "corrupt-entry" ||
+    reason === "stale-build-entry"
+  );
+}
+
+/**
+ * Post-match truth override for a pre-match BYPASS classification. The gate
+ * decides before matchPartial runs, but two facts only the match can settle:
+ * whether the prerender store ACTUALLY served (either artifact variant — the
+ * gate's probe reads only the non-intercept one), and whether the navigation
+ * resolved to an intercept (findInterceptForRoute runs during the match; the
+ * intercept-source header proves nothing in either direction). The resulting
+ * reason is stamped on the request context by withCacheLookup. A replay HIT is
+ * never overridden — the seeded record was demonstrably consumed, so neither
+ * fact can be true.
+ */
+function reclassifyReplayStatus(
+  reqCtx: RequestContext<any>,
+  status: PprReplayStatus,
+): PprReplayStatus {
+  if (status.outcome === "HIT") return status;
+  const reason = reqCtx._pprReplayPostMatchReason;
+  return reason ? { outcome: "BYPASS", reason } : status;
+}
+
 function resolveDevShellLookup(
   reqCtx: RequestContext<any>,
   pprConfig: ResolvedPprConfig,
@@ -132,21 +211,32 @@ function replayableShellSnapshot(
   if (!hasIntactShellPayload(entry)) return { reason: "corrupt-entry" };
   if (entry.handlerLiveHoles) return { reason: "handler-live-holes" };
   if (entry.transitionWhen) return { reason: "transition-when" };
+  // Eligibility requires the CANONICAL doc segment record (`docKey`), not just
+  // any segment record: captures under an explicit cache() scope also record
+  // that tier's reads/writes under keys a partial lookup can never resolve,
+  // and counting those declared entries "replayable" that then always missed
+  // (a timing-dependent snapshot-miss/no-segment-snapshot flip-flop). Entries
+  // captured before the field existed read as no-segment-snapshot and heal on
+  // recapture (pre-release, same treatment as the buildVersion field).
+  const docKey = entry.docKey;
   const snapshot = entry.snapshot;
-  const hasSegments = snapshot?.some((record) => {
-    if (
-      !record ||
-      typeof record !== "object" ||
-      record.family !== "segment" ||
-      typeof record.value !== "object" ||
-      record.value === null
-    ) {
-      return false;
-    }
-    const segments = (record.value as { segments?: unknown }).segments;
-    return Array.isArray(segments) && segments.length > 0;
-  });
-  return hasSegments && snapshot
+  const hasDocRecord =
+    docKey !== undefined &&
+    snapshot?.some((record) => {
+      if (
+        !record ||
+        typeof record !== "object" ||
+        record.family !== "segment" ||
+        record.key !== docKey ||
+        typeof record.value !== "object" ||
+        record.value === null
+      ) {
+        return false;
+      }
+      const segments = (record.value as { segments?: unknown }).segments;
+      return Array.isArray(segments) && segments.length > 0;
+    });
+  return hasDocRecord && snapshot
     ? { snapshot }
     : { reason: "no-segment-snapshot" };
 }
@@ -194,6 +284,7 @@ async function handleRscRenderingInner<TEnv>(
   let payload: RscPayload;
   let hasInterceptSlots = false;
   let pprReplayStatus: PprReplayStatus | undefined;
+  let partialCaptureNeeded = false;
 
   // --- Axis 2: integrated PPR shell serve (docs/design/ppr-shell-resume.md) ---
   //
@@ -221,7 +312,7 @@ async function handleRscRenderingInner<TEnv>(
       // the provider-only check missed the latter (issue #656).
       const activeNonce = nonce ?? contextGet(reqCtx._variables, nonceToken);
       const store = reqCtx._cacheStore;
-      const key = buildShellKey(url);
+      const key = buildShellKey(url, reqCtx._searchParamsFilter);
       // Dev Server-Timing mirror (issue #651): a capture completes AFTER its
       // triggering response committed, so its outcome can only ride a LATER
       // response's header. Read-and-clear keeps one capture = one report;
@@ -280,23 +371,12 @@ async function handleRscRenderingInner<TEnv>(
           ssrModule.resumeShellHTML &&
           ssrModule.captureShellHTML
         ) {
-          const descriptor: ShellCaptureDescriptor = {
+          const descriptor = createShellCaptureDescriptor(
+            ctx,
             key,
-            buildVersion: ctx.version,
-            ttl: pprConfig.ttl,
-            swr: pprConfig.swr,
-            tags: pprConfig.tags,
-            captureTimeout: pprConfig.captureTimeout,
+            pprConfig,
             store,
-            debug: INTERNAL_RANGO_DEBUG,
-            maxSnapshotBytes: pprConfig.maxSnapshotBytes,
-            // The resolver owns the whole policy: option wins, the
-            // INTERNAL_RANGO_DEBUG env flag lights the events up when no
-            // option is set, an explicit `false` stays off.
-            debugSink: resolveShellCaptureDebugSink(
-              ctx.router.debugShellCapture,
-            ),
-          };
+          );
           // One serve funnel for BOTH entry sources (runtime store hit below,
           // build-manifest hit further down): schedule the background
           // recapture when asked, then commit the composed response.
@@ -347,7 +427,11 @@ async function handleRscRenderingInner<TEnv>(
               cached ? "hit" : "miss",
             );
           }
-          if (cached && isValidShellHit(cached.entry, ctx.version)) {
+          if (
+            cached &&
+            !cached.entry.navigationOnly &&
+            isValidShellHit(cached.entry, ctx.version)
+          ) {
             if (!hasIntactShellPayload(cached.entry)) {
               // Corrupt stored payload (undecodable prelude / unparseable
               // postponed): a store-layer fault worth a diagnostic, unlike the
@@ -382,6 +466,7 @@ async function handleRscRenderingInner<TEnv>(
             // only (production's exact candidate set). Folded away in
             // production builds (NODE_ENV is a compile-time constant).
             resolveDevShellLookup(reqCtx, pprConfig),
+            reqCtx._searchParamsFilter,
           );
           if (buildHit) {
             // Past ppr.ttl: still serve the baked entry, recapture upgrades it.
@@ -407,6 +492,8 @@ async function handleRscRenderingInner<TEnv>(
     );
     const result = replay.result;
     pprReplayStatus = replay.status;
+    partialCaptureNeeded =
+      "captureNeeded" in replay && replay.captureNeeded === true;
 
     if (!result) {
       // Fall back to full render
@@ -462,6 +549,7 @@ async function handleRscRenderingInner<TEnv>(
           prefetchCacheTTL: ctx.router.prefetchCacheTTL,
           prefetchCacheSize: ctx.router.prefetchCacheSize,
           prefetchConcurrency: ctx.router.prefetchConcurrency,
+          defaultPrefetch: ctx.router.defaultPrefetch,
           stateCookieName: ctx.router.resolvedStateCookieName,
         },
       };
@@ -607,6 +695,40 @@ async function handleRscRenderingInner<TEnv>(
     response.headers.set(SHELL_STATUS_HEADER, "MISS");
   }
 
+  if (
+    isPartial &&
+    partialCaptureNeeded &&
+    !reqCtx._dynamic &&
+    response.status === 200
+  ) {
+    const pprConfig = resolvePprConfig(reqCtx._classifiedRoute?.manifestEntry)!;
+    const store = reqCtx._cacheStore!;
+    scheduleShellCapture(
+      ctx,
+      request,
+      env,
+      url,
+      reqCtx,
+      async (captureRequest, captureUrl) => {
+        const [ssrModule, streamMode] = await getSSRSetup(
+          ctx,
+          captureRequest,
+          env,
+          captureUrl,
+          undefined,
+        );
+        return streamMode === "allReady" ? null : ssrModule;
+      },
+      createShellCaptureDescriptor(
+        ctx,
+        buildNavigationShellKey(url, reqCtx._searchParamsFilter),
+        pprConfig,
+        store,
+        true,
+      ),
+    );
+  }
+
   return response;
 }
 
@@ -638,10 +760,17 @@ async function matchPartialWithPprReplay<TEnv>(
       describePprReplayStatus(status),
     );
   };
+  const finalizeReplayStatus = (status: PprReplayStatus): PprReplayStatus => {
+    const finalStatus = reclassifyReplayStatus(reqCtx, status);
+    recordReplayStatus(finalStatus);
+    return finalStatus;
+  };
   const runMatch = async (status?: PprReplayStatus) => {
     const result = await ctx.router.matchPartial(request, { env });
-    if (status) recordReplayStatus(status);
-    return { result, status };
+    // The match may have settled a fact the pre-match gate could only guess
+    // at (prerender serve, intercept resolution) — report the truth.
+    const finalStatus = status ? finalizeReplayStatus(status) : undefined;
+    return { result, status: finalStatus };
   };
   const pprConfig = resolvePprConfig(reqCtx._classifiedRoute?.manifestEntry);
   const activeNonce = nonce ?? contextGet(reqCtx._variables, nonceToken);
@@ -666,8 +795,64 @@ async function matchPartialWithPprReplay<TEnv>(
       reason: "passive-read-unsupported",
     });
   }
+  // A partial without navigation context (curl probes, synthetic monitors)
+  // can never produce a partial match — createMatchContextForPartial returns
+  // null and the seeded record could not have been consulted, which used to
+  // read as a misleading `snapshot-miss` AFTER two wasted getShell reads.
+  // Same predicate as resolveNavigation, decided before any store I/O.
+  if (!getNavigationContextHeader(request)) {
+    return runMatch({ outcome: "BYPASS", reason: "no-navigation-context" });
+  }
+  // The prerender probe and the cache-opt-out gate below both need the
+  // classified snapshot; resolve (and persist) it once.
+  const routeSnapshot = classifiedRouteSnapshot(reqCtx);
+  // Prerender routes short-circuit in withCacheLookup and serve the partial
+  // from build-time segments — a better-than-HIT outcome. Their captures
+  // record no doc segment record (withCacheStore skips on the prerender hit),
+  // so seeding could never succeed; skip the reads and report the store that
+  // actually serves instead of blaming a "broken" capture. Bypass ONLY when
+  // the baked artifact actually exists — the trie's pr flag alone is not a
+  // serve guarantee: a Passthrough(Prerender()) route with an unbaked or
+  // ctx.passthrough()-skipped param misses the store and renders live, and
+  // replay (including its heal capture) must stay available for it. The
+  // probe goes through the same memoized store the middleware serves from.
+  // Shared predicate with the middleware (it declines on dev HMR — such
+  // partials fall through to the ordinary replay decision here too).
+  //
+  // The probe is a PRE-match fast path, not the truth: it reads only the
+  // non-intercept artifact, and whether the navigation IS an intercept (and
+  // therefore whether tryPrerenderLookup reads `paramHash` or
+  // `paramHash + "/i"`) is resolved during the match by match-api's
+  // findInterceptForRoute — an intercept-source header proves nothing in
+  // either direction. runMatch reclassifies every BYPASS from the stamped
+  // post-match facts (reclassifyReplayStatus), so a wrong guess here can
+  // skip the two getShell reads but never mis-report or mis-heal.
+  if (
+    prerenderStoreShortCircuits(routeSnapshot?.matched?.pr, request) &&
+    (await prerenderEntryExists(
+      routeSnapshot?.matched?.routeKey,
+      routeSnapshot?.params ?? {},
+      url.pathname,
+      routeSnapshot?.entries ?? [],
+    ))
+  ) {
+    return runMatch({ outcome: "BYPASS", reason: "prerender-store" });
+  }
+  // Consumer cache opt-outs are absolute: a STATICALLY disabled scope
+  // (cache(false)) bypasses before any shell read — no heal capture (its
+  // snapshot would be equally unusable). A `condition()` predicate is
+  // request-time state and must NOT be pre-decided here: evaluating it at the
+  // gate and again at the lookup lets a false-then-true flap report
+  // cache-disabled while the explicit tier serves. The lookup's own
+  // evaluation governs (withCacheLookup fires the marker's onExplicitBypass,
+  // reported as cache-disabled post-match).
+  const routeCacheScope = routeSnapshot?.cacheScope ?? null;
+  if (routeCacheScope && !routeCacheScope.enabled) {
+    return runMatch({ outcome: "BYPASS", reason: "cache-disabled" });
+  }
 
-  const key = buildShellKey(url);
+  const key = buildShellKey(url, reqCtx._searchParamsFilter);
+  const navigationKey = `${key}:navigation`;
   let cached: Awaited<ReturnType<typeof store.getShell>> = null;
   try {
     cached = await store.getShell(key, { claimRevalidation: false });
@@ -689,11 +874,45 @@ async function matchPartialWithPprReplay<TEnv>(
     }
   }
 
+  if (
+    !snapshot &&
+    bypassReason !== "handler-live-holes" &&
+    bypassReason !== "transition-when"
+  ) {
+    let navigationCached: Awaited<ReturnType<typeof store.getShell>> = null;
+    try {
+      navigationCached = await store.getShell(navigationKey, {
+        claimRevalidation: false,
+      });
+    } catch (error) {
+      reportCacheError(error, "cache-read", "[NavigationPPR] getShell");
+      return runMatch({ outcome: "BYPASS", reason: "read-error" });
+    }
+    if (navigationCached) {
+      const decision = replayableShellSnapshot(
+        navigationCached.entry,
+        ctx.version,
+      );
+      if ("snapshot" in decision) {
+        snapshot = decision.snapshot;
+        freshness = navigationCached.shouldRevalidate ? "stale" : "fresh";
+      } else {
+        bypassReason = decision.reason;
+      }
+    }
+  }
+
   if (!snapshot) {
     // Production build manifests are local module data. In dev, resolving a
     // missing build shell would foreground-fetch /__rsc_shell and block an
     // otherwise ordinary navigation on capture, so replay remains runtime-only.
-    const buildHit = await lookupBuildShell(url, ctx.version, store);
+    const buildHit = await lookupBuildShell(
+      url,
+      ctx.version,
+      store,
+      undefined,
+      reqCtx._searchParamsFilter,
+    );
     if (buildHit?.stale) {
       bypassReason ??= "stale-build-entry";
     } else if (buildHit) {
@@ -710,14 +929,78 @@ async function matchPartialWithPprReplay<TEnv>(
   }
 
   if (!snapshot) {
-    return runMatch({
+    // Report-only marker for routes with an ENABLED route-derived scope: the
+    // lookup's own outcome must stay reportable even without a replayable
+    // snapshot. An always-false condition() route never produces a doc
+    // record (the consumer's write refusal is absolute — see
+    // recordShellCaptureDocRecord), so without this its lookup-time refusal
+    // would be misreported as the eligibility reason and heal captures would
+    // be scheduled for snapshots that can never become consumable. The
+    // marker carries NO store: the seeded fallback in withCacheLookup
+    // requires one, so nothing can be served through it — it only reports.
+    // Bare routes never see it (an installed marker would otherwise mint an
+    // implicit scope over the REAL doc: partition in
+    // resolveShellImplicitCacheScope).
+    if (routeCacheScope?.enabled) {
+      let explicitCacheHit = false;
+      let explicitCacheBypass = false;
+      const previousImplicitCache = reqCtx._shellImplicitCache;
+      reqCtx._shellImplicitCache = {
+        onExplicitHit: () => {
+          explicitCacheHit = true;
+        },
+        onExplicitBypass: () => {
+          explicitCacheBypass = true;
+        },
+      };
+      try {
+        const result = await ctx.router.matchPartial(request, { env });
+        const provisionalStatus: PprReplayStatus = explicitCacheBypass
+          ? { outcome: "BYPASS", reason: "cache-disabled" }
+          : explicitCacheHit
+            ? { outcome: "BYPASS", reason: "explicit-cache-hit" }
+            : { outcome: "BYPASS", reason: bypassReason ?? "no-entry" };
+        const status = finalizeReplayStatus(provisionalStatus);
+        return {
+          result,
+          status,
+          // A lookup-time opt-out makes every heal snapshot unusable
+          // (recordShellCaptureDocRecord refuses under the same predicate),
+          // and a prerender-served or intercept match never consults a heal
+          // snapshot at all. Otherwise heal the shouldHealReplayMiss set PLUS
+          // `no-segment-snapshot`: an entry captured while condition() was
+          // false legitimately lacks a snapshot, and a later request whose
+          // lookup did NOT refuse (condition true now) can heal it — the
+          // capture derives from THIS request's context, so its doc record
+          // records. Excluding it left replay dead until the document
+          // recaptured. The always-false route stays protected: its every
+          // lookup refuses, so explicitCacheBypass suppresses the heal.
+          captureNeeded:
+            !explicitCacheBypass &&
+            reqCtx._pprReplayPostMatchReason === undefined &&
+            (shouldHealReplayMiss(bypassReason) ||
+              bypassReason === "no-segment-snapshot"),
+        };
+      } finally {
+        reqCtx._shellImplicitCache = previousImplicitCache;
+      }
+    }
+    const match = await runMatch({
       outcome: "BYPASS",
       reason: bypassReason ?? "no-entry",
     });
+    return {
+      ...match,
+      captureNeeded:
+        reqCtx._pprReplayPostMatchReason === undefined &&
+        shouldHealReplayMiss(bypassReason),
+    };
   }
 
   const previousImplicitCache = reqCtx._shellImplicitCache;
   let segmentReplayHit = false;
+  let explicitCacheHit = false;
+  let explicitCacheBypass = false;
   reqCtx._shellImplicitCache = {
     ttl: pprConfig.ttl,
     swr: pprConfig.swr,
@@ -728,20 +1011,64 @@ async function matchPartialWithPprReplay<TEnv>(
     onHit: () => {
       segmentReplayHit = true;
     },
+    // Arms the explicit-scope composition in withCacheLookup: a route-derived
+    // cache() scope stays authoritative, the seeded doc record supplies the
+    // match only on its miss. An explicit-tier hit must NOT report a replay
+    // HIT — it served under the consumer's own semantics.
+    onExplicitHit: () => {
+      explicitCacheHit = true;
+    },
+    // Lookup-time condition() refusal (or a scope with no store): the gate
+    // deliberately does not pre-decide predicates, so the truthful
+    // cache-disabled report comes from the lookup that actually refused.
+    onExplicitBypass: () => {
+      explicitCacheBypass = true;
+    },
   };
 
   try {
     const result = await ctx.router.matchPartial(request, { env });
-    const status: PprReplayStatus = segmentReplayHit
+    const provisionalStatus: PprReplayStatus = segmentReplayHit
       ? { outcome: "HIT", freshness }
-      : { outcome: "BYPASS", reason: "snapshot-miss" };
-    recordReplayStatus(status);
+      : explicitCacheHit
+        ? { outcome: "BYPASS", reason: "explicit-cache-hit" }
+        : explicitCacheBypass
+          ? { outcome: "BYPASS", reason: "cache-disabled" }
+          : { outcome: "BYPASS", reason: "snapshot-miss" };
+    // A prerender serve or intercept resolution leaves the seeded record
+    // unconsulted (prerender short-circuits before the scope; intercepts
+    // keep snapshot.cacheScope) — the "snapshot-miss" guess would blame the
+    // capture for a lane that was never in play.
+    const status = finalizeReplayStatus(provisionalStatus);
     return { result, status };
   } finally {
     reqCtx._shellImplicitCache = previousImplicitCache;
   }
 }
 
+/**
+ * The full route snapshot for the classified route, or null when
+ * classification is unavailable (the gates then fall open to the ordinary
+ * replay decision). Persists the enriched snapshot back onto
+ * `_classifiedRoute` so the manifest-chain walk runs once per request:
+ * matchPartial's createMatchContextForPartial re-reads `_classifiedRoute` and
+ * calls ensureFullRouteSnapshot again, and the write-back lets that call hit
+ * the entries-already-built fast path and reuse this same scope chain instead
+ * of rebuilding it.
+ */
+function classifiedRouteSnapshot(
+  reqCtx: RequestContext<any>,
+): RouteSnapshot<any> | null {
+  const classified = reqCtx._classifiedRoute;
+  if (!classified?.manifestEntry) return null;
+  const full = ensureFullRouteSnapshot({
+    ...classified,
+    entries: classified.entries ?? [],
+  });
+  reqCtx._classifiedRoute = full;
+  return full;
+}
+
 /**
  * Neutralize the shell-HIT degradation redirect target. The inline
  * `location.replace` in a committed 200 body bypasses the 3xx chokepoint

package/src/rsc/shell-build-manifest.ts

@@ -27,6 +27,7 @@
 
 import type { SegmentCacheStore, ShellCacheEntry } from "../cache/types.js";
 import { sortedSearchString } from "../cache/cache-key-utils.js";
+import type { SearchParamsFilter } from "../cache/search-params-filter.js";
 import {
   DEV_SHELL_PROBE_TIMEOUT_MS,
   hasIntactShellPayload,
@@ -252,12 +253,18 @@ async function fetchDevShellEntry(
  * version validity, payload integrity, and tag-invalidation markers. Returns
  * null on any gate failure — the caller degrades to the ordinary MISS path
  * (axis 1 + runtime capture), never a broken serve.
+ *
+ * "Search-less" is evaluated AFTER the request's `cache.searchParams` filter:
+ * a URL whose only params are excluded ones (`?fbclid=…` under a tracking
+ * exclusion) matches the baked shell — ad-click traffic is exactly the
+ * traffic the shell was prerendered for.
  */
 export async function lookupBuildShell(
   url: URL,
   buildVersion: string,
   store: SegmentCacheStore,
   dev?: DevShellLookup,
+  filter?: SearchParamsFilter,
 ): Promise<BuildShellHit | null> {
   try {
     // Source-presence first: with no manifest and no dev context this is the
@@ -265,7 +272,7 @@ export async function lookupBuildShell(
     // the searchParams sort/allocation below.
     const hasManifest = globalThis.__loadShellManifestModule !== undefined;
     if (!hasManifest && !dev) return null;
-    if (sortedSearchString(url.searchParams) !== "") return null;
+    if (sortedSearchString(url.searchParams, filter) !== "") return null;
     let record: BuildShellEntry | undefined;
     if (hasManifest) {
       const mod = await loadManifest();