@rangojs/router 0.1.0 → 0.1.1

package/src/server/context.ts

@@ -298,6 +298,10 @@ interface HelperContext {
   counters: Record<string, number>;
   forRoute?: string;
   mountIndex?: number;
+  /** Owning router id, when known (threaded by generateManifestFull). Scopes
+   *  the search-schema/root-scope registries so same-named routes in
+   *  different routers don't clobber each other (route-map-builder.ts). */
+  routerId?: string;
   metrics?: MetricsStore;
   /** True when rendering for SSR (document requests) */
   isSSR?: boolean;
@@ -491,6 +495,7 @@ export const getContext = (): {
           counters: store.counters,
           forRoute: store.forRoute,
           mountIndex: store.mountIndex,
+          routerId: store.routerId,
           metrics: store.metrics,
           isSSR: store.isSSR,
           patterns: store.patterns,
@@ -533,6 +538,7 @@ export const getContext = (): {
           counters,
           forRoute: store?.forRoute,
           mountIndex: store?.mountIndex,
+          routerId: store?.routerId,
           metrics: store?.metrics,
           isSSR: store?.isSSR,
           patterns,
@@ -666,6 +672,28 @@ export function getRootScoped(): boolean {
   return store?.rootScoped ?? true;
 }
 
+/**
+ * Stamp build-time scope identity onto a Static() definition at mount time.
+ * The bake collector (prerender-collection.ts) renders defs OUTSIDE any
+ * evaluation scope and used to iterate the registry first-non-null, so these
+ * are the ONLY reliable carriers of the def's owning router, root-scope, and
+ * full route name — a name-keyed registry lookup at bake time reproduces the
+ * cross-router collision #757/#762 fixed (and the collector's historical
+ * `$$routePrefix` argument is a name PREFIX, which the root-scope registry
+ * never contains, silently degrading to the dot-heuristic).
+ * A definition mounted more than once is stamped each time; the last mount wins.
+ */
+export function stampStaticDefScope(
+  handler: unknown,
+  routeName?: string,
+): void {
+  const store = RangoContext.getStore();
+  const def = handler as Record<string, unknown>;
+  if (routeName !== undefined) def.$$routeName = routeName;
+  def.$$rootScoped = getRootScoped();
+  if (store?.routerId !== undefined) def.$$routerId = store.routerId;
+}
+
 // Export HelperContext type for use in other modules
 export type { HelperContext };
 

package/src/server/request-context.ts

@@ -254,21 +254,28 @@ export interface RequestContext<
   >;
 
   /**
-   * @internal Shell fast-path marker: makes the NEXT full match treat the whole
-   * matched route as an implicit doc-level cache() boundary (see
+   * @internal Shell fast-path marker: makes the next eligible match treat the
+   * whole matched route as an implicit doc-level cache() boundary (see
    * resolveShellImplicitCacheScope in cache/cache-scope.ts). Set ONLY on
    * (a) the capture's derived context — with a record-only store so the
    * capture's cacheRoute write lands in the snapshot, never the real store —
-   * and (b) a HIT tail's seeded context when the entry is eligible
-   * (!handlerLiveHoles), where the SeededShellStore serves the recorded doc
-   * entry and the match skips handler execution entirely. Routes with their
-   * own cache() config (including cache(false)) are never overridden: the
-   * marker only applies when the route tree derived NO cache scope.
+   * (b) a HIT tail's seeded context, and (c) an eligible normal-route partial
+   * replay, where `store` is a request-local segment overlay. Handler-live holes
+   * and conditional transitions decline replay.
+   * Routes with their own cache() config (including cache(false)) are never
+   * overridden: the marker only applies when the route tree derived NO cache
+   * scope.
    */
   _shellImplicitCache?: {
     ttl?: number;
     swr?: number;
     store?: SegmentCacheStore;
+    /**
+     * @internal Override the implicit scope's default cache namespace. Shell
+     * captures and navigation replay both consume the canonical document
+     * segment record even when the triggering request is partial.
+     */
+    keyPrefix?: "doc";
   };
 
   /**
@@ -606,6 +613,10 @@ export interface RequestContext<
   /** @internal Router basename for this request (used by redirect()) */
   _basename?: string;
 
+  /** @internal Owning router id; scopes the search-schema/root-scope registry
+   *  lookups per router (route-map-builder.ts) */
+  _routerId?: string;
+
   /**
    * @internal RouteSnapshot from classifyRequest, reused by match/matchPartial
    * to avoid a second resolveRoute call. Cleared on HMR invalidation.
@@ -641,12 +652,19 @@ export type PublicRequestContext<
   | "_transitionWhen"
   | "_cacheStore"
   | "_shellCaptureRun"
+  | "_shellImplicitCache"
+  | "_shellLoaderSeed"
+  | "_shellCaptureLoaderRecords"
+  | "_shellCaptureHandleLiveness"
+  | "_shellCaptureLoaderHandleValues"
   | "_shellFragmentPayload"
+  | "_shellCaptureGuardTripped"
   | "_shellCaptureGuardTrippedLoaderId"
   | "_explicitTaggedStores"
   | "_requestTags"
   | "_cacheProfiles"
   | "_onResponseCallbacks"
+  | "_pendingBackgroundTasks"
   | "_themeConfig"
   | "_locationState"
   | "_routeName"
@@ -673,7 +691,9 @@ export type PublicRequestContext<
   | "_renderForeground"
   | "_renderDiagnosticsEnabled"
   | "_handlerStart"
+  | "_tracing"
   | "_basename"
+  | "_routerId"
   | "_setStatus"
   | "_rotateStateCookie"
   | "_setKeepCacheDirective"
@@ -765,7 +785,7 @@ export function setRequestContextParams(
       routeMap ?? getGlobalRouteMap(),
       routeName,
       params,
-      routeName ? isRouteRootScoped(routeName) : undefined,
+      routeName ? isRouteRootScoped(routeName, ctx._routerId) : undefined,
     );
   }
 }
@@ -1496,7 +1516,7 @@ export function createUseFunction<TEnv>(
     // RequestContext carries no `search` field, so reading `(ctx as any).search`
     // here always yielded {} — dropping typed search for action/dispatch loaders.
     const searchSchema = ctx._routeName
-      ? getSearchSchema(ctx._routeName)
+      ? getSearchSchema(ctx._routeName, ctx._routerId)
       : undefined;
     const loaderSearch = searchSchema
       ? parseSearchParams(ctx.searchParams, searchSchema)
@@ -1526,7 +1546,9 @@ export function createUseFunction<TEnv>(
         getGlobalRouteMap(),
         ctx._routeName,
         ctx.params as Record<string, string>,
-        ctx._routeName ? isRouteRootScoped(ctx._routeName) : undefined,
+        ctx._routeName
+          ? isRouteRootScoped(ctx._routeName, ctx._routerId)
+          : undefined,
       ),
       rendered: () => {
         throw new Error(

package/src/server.ts

@@ -25,8 +25,6 @@ export {
   clearAllRouterData,
   getGlobalRouteMap,
   getRouterManifest,
-  setPrecomputedEntries,
-  setRouteTrie,
   setManifestReadyPromise,
   setRouterManifest,
   setRouterTrie,

package/src/testing/dispatch.ts

@@ -413,6 +413,7 @@ export async function dispatch<TEnv = any>(
   // with it. Mirror it so basename-redirect tests behave as they do in a real
   // mounted app instead of always seeing no prefix.
   requestContext._basename = router.basename;
+  requestContext._routerId = routerId;
 
   // Match production's response-route reverse EXACTLY: the real handler builds
   // it from the route map alone (response-route-handler.ts), with NO matched

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/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.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(),