@rangojs/router 0.1.0 → 0.2.0

package/src/testing/shell-status.ts

@@ -2,7 +2,8 @@
  * PPR shell-status testing primitives for @rangojs/router consumers.
  *
  * Companion to `cache-status.ts` (segment/document cache): this module covers
- * the **shell axis** (`ppr` path option → `x-rango-shell: HIT | MISS`).
+ * the **shell axis** (`ppr` path option → `x-rango-shell: HIT | MISS`) and
+ * partial-navigation segment replay (`x-rango-ppr-replay: HIT`).
  *
  * ## Spike conclusions (plan 009)
  *
@@ -11,8 +12,9 @@
  *    + `ppr: true` on a response route is a no-op for shell serve/capture. The
  *    production path lives in `rsc/rsc-rendering.ts` + `rsc/shell-capture.ts`.
  *
- * 2. **Smallest HIT signal:** response header `x-rango-shell` (`HIT` | `MISS`),
- *    always on document GETs to a ppr route that the serve path considered.
+ * 2. **Smallest status signals:** `x-rango-shell` (`HIT` | `MISS`) on document
+ *    GETs, and `x-rango-ppr-replay` on partial requests to ppr routes. A replay
+ *    HIT is reported only when matching consumes the captured segment record.
  *    Secondary unit signal: `store.getShell(shellCacheKey(url))` after a real
  *    capture flush (background `putShell`). There is no Flight flag for shell HIT.
  *
@@ -31,9 +33,37 @@ import { sortedSearchString } from "../cache/cache-key-utils.js";
 /** Production header name (`rsc/shell-serve.ts` `SHELL_STATUS_HEADER`). */
 export const SHELL_STATUS_HEADER: string = "x-rango-shell";
 
+/** Partial-navigation replay decision header from `rsc/rsc-rendering.ts`. */
+export const PPR_REPLAY_STATUS_HEADER: string = "x-rango-ppr-replay";
+
 /** Values the serve path writes on `x-rango-shell`. */
 export type ShellStatus = "HIT" | "MISS";
 
+const PPR_REPLAY_BYPASS_REASONS = [
+  "method",
+  "dynamic",
+  "nonce",
+  "store-unavailable",
+  "passive-read-unsupported",
+  "read-error",
+  "no-entry",
+  "invalid-version",
+  "corrupt-entry",
+  "handler-live-holes",
+  "transition-when",
+  "no-segment-snapshot",
+  "snapshot-miss",
+  "stale-build-entry",
+] as const;
+
+/** Bounded reasons a PPR partial request can fall open to ordinary matching. */
+export type PprReplayBypassReason = (typeof PPR_REPLAY_BYPASS_REASONS)[number];
+
+/** Parsed `x-rango-ppr-replay` value. */
+export type PprReplayStatus =
+  | { outcome: "HIT"; freshness: "fresh" | "stale" }
+  | { outcome: "BYPASS"; reason: PprReplayBypassReason };
+
 /** A target carrying response headers (a Response or a `{ headers }` object). */
 export type ShellStatusTarget = Response | { headers: Headers };
 
@@ -58,6 +88,8 @@ function getHeaders(target: ShellStatusTarget): Headers {
   return target.headers;
 }
 
+const PPR_REPLAY_BYPASS_REASON_SET = new Set<string>(PPR_REPLAY_BYPASS_REASONS);
+
 /**
  * Read `x-rango-shell` from a response. Returns `null` when the header is
  * absent (axis-1 / non-ppr / ineligible request).
@@ -98,3 +130,60 @@ export function assertShellStatus(
     );
   }
 }
+
+/** Parse the dedicated PPR partial-navigation replay decision header. */
+export function parsePprReplayStatus(
+  target: ShellStatusTarget,
+): PprReplayStatus | null {
+  const raw = getHeaders(target).get(PPR_REPLAY_STATUS_HEADER)?.trim();
+  if (!raw) return null;
+
+  const [outcome, detail, ...extra] = raw.split(";").map((part) => part.trim());
+  if (extra.length > 0 || !detail) return null;
+
+  if (outcome === "HIT") {
+    const freshness = detail.match(/^freshness=(fresh|stale)$/)?.[1];
+    if (freshness === "fresh" || freshness === "stale") {
+      return { outcome, freshness };
+    }
+    return null;
+  }
+
+  if (outcome === "BYPASS") {
+    const reason = detail.match(/^reason=(.+)$/)?.[1] as
+      | PprReplayBypassReason
+      | undefined;
+    if (reason && PPR_REPLAY_BYPASS_REASON_SET.has(reason)) {
+      return { outcome, reason };
+    }
+  }
+
+  return null;
+}
+
+/** Assert a partial response's PPR replay outcome and freshness/reason. */
+export function assertPprReplayStatus(
+  target: ShellStatusTarget,
+  expected: PprReplayStatus,
+): void {
+  const raw = getHeaders(target).get(PPR_REPLAY_STATUS_HEADER);
+  if (raw === null) {
+    throw new Error(
+      `assertPprReplayStatus: response has no ${PPR_REPLAY_STATUS_HEADER} header. ` +
+        "The header is set on partial requests to ppr-declared routes.",
+    );
+  }
+
+  const actual = parsePprReplayStatus(target);
+  if (!actual) {
+    throw new Error(
+      `assertPprReplayStatus: unrecognized ${PPR_REPLAY_STATUS_HEADER} value "${raw}".`,
+    );
+  }
+
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(
+      `assertPprReplayStatus: expected ${JSON.stringify(expected)} but got ${JSON.stringify(actual)}.`,
+    );
+  }
+}

package/src/types/route-entry.ts

@@ -13,6 +13,9 @@ export interface LazyIncludeContext {
   >;
   /** Root scope flag for dot-local reverse resolution */
   rootScoped?: boolean;
+  /** Owning router id; scopes search-schema/root-scope registration during
+   *  lazy include evaluation (route-map-builder.ts registries) */
+  routerId?: string;
   /**
    * Positional include scope token composed from the parent scope plus this
    * include's sibling index (`${parentScope}I${idx}`). Applied to direct-

package/src/types/segments.ts

@@ -14,11 +14,12 @@ export type ViewTransitionClass = Record<string, string> | string;
  *
  * It mirrors the {@link ShouldRevalidateFn} args a `revalidate()` predicate
  * gets — the same navigation/action metadata — so the two read the same shape,
- * plus `get`/`env` for post-handler reads. There is no full `HandlerContext`
+ * plus `get`/`env` for request-context reads. There is no full `HandlerContext`
  * here: the gate runs at the RSC-payload layer with the request context, not a
  * handler context, so handler-only sugar (`search`/`build`/`dev`/`headers`) is
- * absent by design. `get` is the way to read what the handler/middleware set
- * via `ctx.set(...)` this request.
+ * absent by design. On ordinary routes, `get` can read what handlers or
+ * middleware set via `ctx.set(...)`. On `ppr` routes the gate runs before route
+ * handlers, so only middleware-established values are available.
  *
  * Field availability (all source fields are optional — never fabricated):
  * - `currentUrl` / `currentParams` / `fromRouteName` (the navigation SOURCE) are
@@ -43,11 +44,12 @@ export type ViewTransitionClass = Record<string, string> | string;
  * time, so `currentUrl`/`currentParams`/`fromRouteName` reflect the page the
  * prefetch fired from, NOT necessarily the page the user actually navigates from
  * — the decision is baked into the stored Flight payload and replayed verbatim.
- * A `cache()`/prerender hit replays the stored transition with the predicate NOT
- * re-run at all. So a source-sensitive predicate can be frozen to prefetch-time
- * or store-time state. This is accepted (~99% of navigations match), but if your
- * gate must reflect the exact click-time source, source-scope the prefetch
- * (`<Link prefetchKey=":source">`) and do not `cache()` that segment.
+ * A non-PPR `cache()`/prerender hit replays the stored transition with the
+ * predicate NOT re-run. A `ppr` route instead evaluates the predicate before
+ * handlers on every match, including cache, prerender, and PPR replay. Prefetch
+ * still freezes the server decision into its Flight payload. If the gate must
+ * reflect the exact click-time source, source-scope the prefetch
+ * (`<Link prefetchKey=":source">`).
  */
 export type TransitionWhenContext<
   TParams = Record<string, string>,
@@ -74,17 +76,19 @@ export type TransitionWhenContext<
 /**
  * Predicate that gates whether a transition() applies for the current request.
  *
- * Evaluated server-side AFTER the route's handler runs (so `get(...)` can read
- * handler/middleware-set state) and outside any cache scope. Return false to
- * drop this segment's transition for the request; return true to apply it. The
+ * Evaluated server-side outside any cache scope. On ordinary routes it runs
+ * AFTER the route's handler, so `get(...)` can read handler/middleware state. A
+ * route with `ppr` automatically hoists it before route handlers and reevaluates
+ * it on every cache/prerender/PPR replay; there `get(...)` can read middleware
+ * state, but not values set by route handlers. Return false to drop this
+ * segment's transition for the request; return true to apply it. The
  * context ({@link TransitionWhenContext}) carries the same navigation/action
  * metadata a `revalidate()` predicate sees plus `get`/`env`. If it throws, the
  * error is reported to the router's onError (phase "rendering") and the
  * transition is dropped (the navigation does not hold).
  *
  * Distinct from intercept()'s `when` config selector, which runs at MATCH time
- * over `{ from, to, params, segments, … }`; a transition `when` runs
- * post-handler over the resolved payload.
+ * over `{ from, to, params, segments, … }`.
  *
  * Scope: dropping a transition removes only THIS segment's contribution to the
  * navigation's hold. The startTransition hold is navigation-wide — it engages if
@@ -92,10 +96,10 @@ export type TransitionWhenContext<
  * navigation stream its loading fallback only when no other matched segment
  * keeps a transition (the common case: a single transition on the route).
  *
- * Evaluated on every fresh (cache-miss) resolution; it is NOT re-run when a
- * segment is replayed from the runtime cache or a build-time prerender, and a
- * prefetched navigation freezes it to prefetch-time state — see the caveat on
- * {@link TransitionWhenContext}.
+ * On non-PPR routes it runs only during fresh resolution. On PPR routes it runs
+ * before handlers for every match, including runtime cache, build-time
+ * prerender, and PPR segment replay. A prefetched navigation still freezes the
+ * result to prefetch time; see {@link TransitionWhenContext}.
  */
 export type TransitionWhenFn = (ctx: TransitionWhenContext) => boolean;
 
@@ -129,11 +133,12 @@ export interface TransitionConfig {
   viewTransition?: "auto" | false;
   /**
    * Optional server-side predicate that gates this transition per request. When
-   * present and it returns false (evaluated post-handler), the router drops this
-   * segment's transition for the request, so the navigation streams its loading
-   * fallback instead of holding. The predicate is server-only and never
-   * serialized to the client; only its resolved effect (transition kept or
-   * dropped) crosses. See {@link TransitionWhenFn}.
+   * present and it returns false, the router drops this segment's transition for
+   * the request, so the navigation streams its loading fallback instead of
+   * holding. PPR routes evaluate it before route handlers and on every replay;
+   * other routes evaluate it after handlers on fresh resolution. The predicate
+   * is server-only and never serialized to the client; only its resolved effect
+   * crosses. See {@link TransitionWhenFn}.
    */
   when?: TransitionWhenFn;
 }

package/src/urls/include-helper.ts

@@ -155,6 +155,7 @@ export function createIncludeHelper<TEnv>(): IncludeFn<TEnv> {
         counters: capturedCounters,
         cacheProfiles: ctx.cacheProfiles,
         rootScoped: capturedRootScoped,
+        routerId: ctx.routerId,
         includeScope,
       },
     } as IncludeItem;

package/src/urls/path-helper-types.ts

@@ -394,9 +394,10 @@ export type PathHelpers<TEnv> = {
    * transition cannot fire without a startTransition. See
    * skills/view-transitions for the startTransition x ViewTransition matrix.
    *
-   * Pass `when: (ctx) => boolean` to gate the transition per request: it runs
-   * server-side after the route handler (can read `ctx.get(...)`), and returning
-   * false drops the transition so the navigation streams its loading() skeleton.
+   * Pass `when: (ctx) => boolean` to gate the transition per request. It normally
+   * runs after the route handler; `ppr` routes automatically run it before route
+   * handlers and on every replay, where `ctx.get(...)` sees middleware state but
+   * not handler-set values.
    */
   transition: {
     (): TransitionItem;

package/src/urls/path-helper.ts

@@ -6,6 +6,7 @@ import {
   getNamePrefix,
   getRootScoped,
   requireDslContext,
+  stampStaticDefScope,
 } from "../server/context";
 import { invariant, DataNotFoundError } from "../errors";
 import { validateUserRouteName } from "../route-name.js";
@@ -182,8 +183,11 @@ export function createPathHelper<TEnv>(): PathFn<TEnv> {
         : {}),
     };
 
-    if (isStaticHandler(handler) && handler.$$id && ctx.namePrefix) {
-      (handler as any).$$routePrefix = ctx.namePrefix;
+    if (isStaticHandler(handler) && handler.$$id) {
+      if (ctx.namePrefix) {
+        (handler as any).$$routePrefix = ctx.namePrefix;
+      }
+      stampStaticDefScope(handler, routeName);
     }
 
     invariant(
@@ -193,7 +197,7 @@ export function createPathHelper<TEnv>(): PathFn<TEnv> {
 
     ctx.manifest.set(routeName, entry);
 
-    registerRouteRootScope(routeName, getRootScoped());
+    registerRouteRootScope(routeName, getRootScoped(), ctx.routerId);
 
     if (ctx.patterns) {
       ctx.patterns.set(routeName, prefixedPattern);
@@ -215,7 +219,7 @@ export function createPathHelper<TEnv>(): PathFn<TEnv> {
       if (ctx.searchSchemas) {
         ctx.searchSchemas.set(routeName, options.search);
       }
-      registerSearchSchema(routeName, options.search);
+      registerSearchSchema(routeName, options.search, ctx.routerId);
     }
 
     if (mergedUse) {

package/src/vite/discovery/bundle-postprocess.ts

@@ -133,7 +133,7 @@ export function postprocessBundle(state: DiscoveryState): void {
   }
 
   // 3. Write static handler data as separate importable asset modules
-  // and inject a __STATIC_MANIFEST import into the RSC entry.
+  // and inject a lazy loader thunk into the RSC entry.
   if (hasStaticData && existsSync(rscEntryPath)) {
     const rscCode = readFileSync(rscEntryPath, "utf-8");
     if (!rscCode.includes("__static-manifest.js")) {
@@ -152,9 +152,10 @@ export function postprocessBundle(state: DiscoveryState): void {
           );
         }
 
-        // Set the global inside the manifest module so it is assigned
-        // during module evaluation (before dependent modules like
-        // segment-resolution.ts run their top-level initializers).
+        // The module assigns the global on evaluation; evaluation itself is
+        // DEFERRED behind the loader thunk below (mirroring the prerender and
+        // shell manifests), so the thunk table stays off the worker's eager
+        // cold-start path (issue #760) — it grows O(#Static handlers).
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;\n`;
         const manifestPath = resolve(
           state.projectRoot,
@@ -163,9 +164,11 @@ export function postprocessBundle(state: DiscoveryState): void {
         writeFileSync(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
 
-        // The import ensures the manifest module is evaluated early.
-        // The global is already set inside the module itself.
-        const injection = `import "./__static-manifest.js";\n`;
+        // Lazy thunk, NOT an eager import: static-store.ts resolves it on the
+        // first Static() lookup (a first-call latch — the entry body assigning
+        // this global runs after hoisted imports, so an eval-time read in
+        // static-store.ts could never see it).
+        const injection = `globalThis.__loadStaticManifestModule = () => import("./__static-manifest.js");\n`;
         writeFileSync(rscEntryPath, injection + rscCode);
 
         const totalKB = (totalBytes / 1024).toFixed(1);

package/src/vite/discovery/discover-routers.ts

@@ -19,12 +19,9 @@ import {
 // boundary tree regardless of which realm imported the walker. Only
 // generateManifestFull must stay on the runner (it invokes user handlers via
 // RangoContext from the runner realm) — see the runner.import below.
-import { buildRouteTrie, buildPerRouterTrie } from "../../build/route-trie.js";
+import { buildPerRouterTrie } from "../../build/route-trie.js";
 import { collectFallbackClientRefs } from "../../build/collect-fallback-refs.js";
-import {
-  flattenLeafEntries,
-  buildRouteToStaticPrefix,
-} from "../utils/manifest-utils.js";
+import { flattenLeafEntries } from "../utils/manifest-utils.js";
 import type { DiscoveryState, PrecomputedEntry } from "./state.js";
 import {
   expandPrerenderRoutes,
@@ -145,12 +142,10 @@ export async function discoverRouters(
   // full pass succeeds, so a failed re-discovery preserves the last
   // known-good state instead of leaving it partially wiped.
   const newMergedRouteManifest: Record<string, string> = {};
-  const newMergedPrecomputedEntries: PrecomputedEntry[] = [];
   const newPerRouterManifests: typeof state.perRouterManifests = [];
   const newPerRouterManifestDataMap = new Map<string, any>();
   const newPerRouterPrecomputedMap = new Map<string, PrecomputedEntry[]>();
   const newPerRouterTrieMap = new Map<string, any>();
-  let mergedRouteTrailingSlash: Record<string, string> = {};
 
   let routerMountIndex = 0;
   // Collect all manifests for trie building (avoid re-running generateManifest)
@@ -189,6 +184,7 @@ export async function discoverRouters(
       router.urlpatterns,
       routerMountIndex,
       {
+        routerId: id,
         ...(router.__basename ? { urlPrefix: router.__basename } : {}),
         ...(collectClientFallbackRef ? { collectClientFallbackRef } : {}),
       },
@@ -239,29 +235,21 @@ export async function discoverRouters(
     newPerRouterManifests.push({
       id,
       routeManifest: manifest.routeManifest,
+      routeTrailingSlash: manifest.routeTrailingSlash,
       routeSearchSchemas: manifest.routeSearchSchemas,
       sourceFile: router.__sourceFile,
       factoryOnlyPrefixes,
     });
 
-    // Merge trailing slash config
-    if (manifest.routeTrailingSlash) {
-      Object.assign(mergedRouteTrailingSlash, manifest.routeTrailingSlash);
-    }
-
     // Flatten prefix tree leaf nodes into precomputed entries.
     // Leaf nodes (no children) can have their routes used directly by
     // evaluateLazyEntry() without running the handler at runtime.
-    // Walk once into a per-router array, then fold it into the merged array;
-    // the merged and per-router entries are identical, so a second walk is
-    // redundant. Append order is preserved within and across routers.
     const routerPrecomputed: PrecomputedEntry[] = [];
     flattenLeafEntries(
       manifest.prefixTree,
       manifest.routeManifest,
       routerPrecomputed,
     );
-    newMergedPrecomputedEntries.push(...routerPrecomputed);
 
     // Store per-router manifest and precomputed entries for isolated virtual modules.
     newPerRouterManifestDataMap.set(id, manifest.routeManifest);
@@ -298,53 +286,11 @@ export async function discoverRouters(
     (performance.now() - manifestGenStart).toFixed(1),
   );
 
-  // Build route trie from merged manifest
-  let newMergedRouteTrie: any = null;
+  // No merged trie is built: find-match.ts consumes per-router tries only
+  // (getRouterTrie(routerId)), falling back to regex over live routes on a
+  // gap — the global merged trie was never read by any matcher.
   const trieStart = debug ? performance.now() : 0;
   if (Object.keys(newMergedRouteManifest).length > 0) {
-    // Build routeToStaticPrefix from saved manifests
-    const routeToStaticPrefix: Record<string, string> = {};
-    for (const { manifest } of allManifests) {
-      // Root-level routes have empty static prefix
-      for (const name of Object.keys(manifest.routeManifest)) {
-        if (!(name in routeToStaticPrefix)) {
-          routeToStaticPrefix[name] = "";
-        }
-      }
-      buildRouteToStaticPrefix(manifest.prefixTree, routeToStaticPrefix);
-    }
-
-    // Collect prerender route names and response type routes from all manifests
-    const prerenderRouteNames = new Set<string>();
-    const passthroughRouteNames = new Set<string>();
-    const mergedResponseTypeRoutes: Record<string, string> = {};
-    for (const { manifest } of allManifests) {
-      if (manifest.prerenderRoutes) {
-        for (const name of manifest.prerenderRoutes) {
-          prerenderRouteNames.add(name);
-        }
-      }
-      if (manifest.passthroughRoutes) {
-        for (const name of manifest.passthroughRoutes) {
-          passthroughRouteNames.add(name);
-        }
-      }
-      if (manifest.responseTypeRoutes) {
-        Object.assign(mergedResponseTypeRoutes, manifest.responseTypeRoutes);
-      }
-    }
-
-    // buildRouteTrie reads these via ?.has / ?.[] — empty is observationally
-    // identical to undefined, so no empty->undefined coercion is needed.
-    newMergedRouteTrie = buildRouteTrie(
-      newMergedRouteManifest,
-      routeToStaticPrefix,
-      mergedRouteTrailingSlash,
-      prerenderRouteNames,
-      passthroughRouteNames,
-      mergedResponseTypeRoutes,
-    );
-
     // Build per-router tries for multi-router isolation. Uses the single
     // shared buildPerRouterTrie so the production serialized trie is built by
     // exactly the same code as the dev/HMR runtime rebuild (manifest-init.ts).
@@ -366,12 +312,10 @@ export async function discoverRouters(
   // This ensures a failed re-discovery (e.g. from a transient module
   // evaluation error) preserves the last known-good state.
   state.mergedRouteManifest = newMergedRouteManifest;
-  state.mergedPrecomputedEntries = newMergedPrecomputedEntries;
   state.perRouterManifests = newPerRouterManifests;
   state.perRouterManifestDataMap = newPerRouterManifestDataMap;
   state.perRouterPrecomputedMap = newPerRouterPrecomputedMap;
   state.perRouterTrieMap = newPerRouterTrieMap;
-  state.mergedRouteTrie = newMergedRouteTrie;
 
   // Install the route tries into the RSC realm BEFORE prerender collection.
   // matchForPrerender resolves each enumerated URL via findMatch, and without
@@ -386,9 +330,6 @@ export async function discoverRouters(
   // collection was the one findMatch consumer running trieless. Mirrors the
   // dev perRouterSetters loop; deliberately does NOT markRouterTrieAuthoritative
   // so a genuine trie gap keeps the regex fallback, exactly as in dev.
-  if (serverMod.setRouteTrie && newMergedRouteTrie) {
-    serverMod.setRouteTrie(newMergedRouteTrie);
-  }
   const perRouterSetters: Array<[Map<string, unknown>, string]> = [
     [newPerRouterManifestDataMap, "setRouterManifest"],
     [newPerRouterTrieMap, "setRouterTrie"],

package/src/vite/discovery/prerender-collection.ts

@@ -415,15 +415,26 @@ export async function renderStaticHandlers(
 
       const startHandler = performance.now();
       let handled = false;
-      for (const [, routerInstance] of registry) {
+      // Owner-first: path() stamped the mounting router's id on the def
+      // ($$routerId). Sweeping the whole registry hands the FIRST router's
+      // id and route map to every static handler — wrong scoping in
+      // multi-router apps. The full sweep remains only as the fallback for
+      // an unstamped def (evaluated outside a router scope).
+      const owner = (def as any).$$routerId as string | undefined;
+      const owned = owner !== undefined ? registry.get(owner) : undefined;
+      const candidates = owned ? [owned] : [...registry.values()];
+      for (const routerInstance of candidates) {
         if (!routerInstance.renderStaticSegment) continue;
         try {
           const result = await routerInstance.renderStaticSegment(
             def.handler,
             def.$$id,
-            (def as any).$$routePrefix,
+            // Full route name when stamped; the historical $$routePrefix is a
+            // name PREFIX (never in the root-scope registry) kept as fallback.
+            (def as any).$$routeName ?? (def as any).$$routePrefix,
             state.resolvedBuildEnv,
             !state.isBuildMode,
+            (def as any).$$rootScoped,
           );
           if (result) {
             // result.handles is the pre-encoded handle string ("" when none).

package/src/vite/discovery/state.ts

@@ -59,6 +59,7 @@ export interface ChunkInfo {
 export interface PerRouterManifestEntry {
   id: string;
   routeManifest: Record<string, string>;
+  routeTrailingSlash?: Record<string, string>;
   routeSearchSchemas?: Record<string, Record<string, string>>;
   sourceFile?: string;
   factoryOnlyPrefixes?: Set<string>;
@@ -104,8 +105,6 @@ export interface DiscoveryState {
 
   mergedRouteManifest: Record<string, string> | null;
   perRouterManifests: PerRouterManifestEntry[];
-  mergedPrecomputedEntries: PrecomputedEntry[] | null;
-  mergedRouteTrie: any;
 
   perRouterTrieMap: Map<string, any>;
   perRouterPrecomputedMap: Map<string, PrecomputedEntry[]>;
@@ -141,6 +140,8 @@ export interface DiscoveryState {
   resolvedStaticModules: Map<string, string[]> | undefined;
 
   discoveryDone: Promise<void> | null;
+  /** Monotonic Cloudflare-dev generation installed by the routes manifest. */
+  devDiscoveryEpoch?: number;
   devServerOrigin: string | null;
   devServer: any;
   selfWrittenGenFiles: Map<string, { at: number; hash: string }>;
@@ -177,8 +178,6 @@ export function createDiscoveryState(
 
     mergedRouteManifest: null,
     perRouterManifests: [],
-    mergedPrecomputedEntries: null,
-    mergedRouteTrie: null,
 
     perRouterTrieMap: new Map(),
     perRouterPrecomputedMap: new Map(),
@@ -196,6 +195,7 @@ export function createDiscoveryState(
     resolvedStaticModules: undefined,
 
     discoveryDone: null,
+    devDiscoveryEpoch: opts?.preset === "cloudflare" ? Date.now() : undefined,
     devServerOrigin: null,
     devServer: null,
     selfWrittenGenFiles: new Map(),