@rangojs/router 0.0.0-experimental.9 → 0.0.0-experimental.b9cb8739

package/src/router/match-middleware/cache-lookup.ts

@@ -92,38 +92,178 @@
 import type { ResolvedSegment } from "../../types.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
 import { getRouterContext } from "../router-context.js";
-import type { PrerenderStore } from "../../prerender/store.js";
+import { resolveSink, safeEmit } from "../telemetry.js";
+import { pushRevalidationTraceEntry, isTraceActive } from "../logging.js";
+import type { PrerenderStore, PrerenderEntry } from "../../prerender/store.js";
+import type { HandleStore } from "../../server/handle-store.js";
+import {
+  getRequestContext,
+  _getRequestContext,
+} from "../../server/request-context.js";
 
 // Lazily initialized prerender store singleton and dynamically imported deps.
 // Dynamic imports prevent pulling in @vitejs/plugin-rsc/rsc virtual module at
 // top-level, which breaks vitest (only URLs with file:, data:, node: schemes).
 let prerenderStoreInstance: PrerenderStore | null | undefined;
-let _deserializeSegments: typeof import("../../cache/cache-scope.js").deserializeSegments | undefined;
-let _hashParams: typeof import("../../prerender/param-hash.js").hashParams | undefined;
-let _getRequestContext: typeof import("../../server/request-context.js").getRequestContext | undefined;
+let _deserializeSegments:
+  | typeof import("../../cache/segment-codec.js").deserializeSegments
+  | undefined;
+let _restoreHandles:
+  | typeof import("../../cache/handle-snapshot.js").restoreHandles
+  | undefined;
+let _hashParams:
+  | typeof import("../../prerender/param-hash.js").hashParams
+  | undefined;
+let _lazyGetRequestContext:
+  | typeof import("../../server/request-context.js").getRequestContext
+  | undefined;
+
+function paramsEqual(
+  a: Record<string, string>,
+  b: Record<string, string>,
+): boolean {
+  if (a === b) return true;
+
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) return false;
+
+  for (const key of keysA) {
+    if (a[key] !== b[key]) return false;
+  }
+
+  return true;
+}
 
 async function ensurePrerenderDeps() {
   if (!_deserializeSegments) {
-    const [cache, paramHash, reqCtx, store] = await Promise.all([
-      import("../../cache/cache-scope.js"),
+    const [codec, snapshot, paramHash, reqCtx, store] = await Promise.all([
+      import("../../cache/segment-codec.js"),
+      import("../../cache/handle-snapshot.js"),
       import("../../prerender/param-hash.js"),
       import("../../server/request-context.js"),
       import("../../prerender/store.js"),
     ]);
-    _deserializeSegments = cache.deserializeSegments;
+    _deserializeSegments = codec.deserializeSegments;
+    _restoreHandles = snapshot.restoreHandles;
     _hashParams = paramHash.hashParams;
-    _getRequestContext = reqCtx.getRequestContext;
+    _lazyGetRequestContext = reqCtx.getRequestContext;
     if (prerenderStoreInstance === undefined) {
       prerenderStoreInstance = store.createPrerenderStore();
     }
   }
 }
 
+/**
+ * Shared yield logic for prerender and static handler store entries.
+ * Deserializes segments, replays handle data, yields segments with partial
+ * navigation nullification, and resolves fresh loaders.
+ */
+async function* yieldFromStore<TEnv>(
+  entry: PrerenderEntry,
+  ctx: MatchContext<TEnv>,
+  state: MatchPipelineState,
+  pipelineStart: number,
+  handleStoreRef?: HandleStore,
+): AsyncGenerator<ResolvedSegment> {
+  const { resolveLoadersOnlyWithRevalidation, resolveLoadersOnly } =
+    getRouterContext<TEnv>();
+
+  if (
+    !_deserializeSegments ||
+    !_restoreHandles ||
+    !_hashParams ||
+    !_lazyGetRequestContext
+  ) {
+    throw new Error("yieldFromStore called before ensurePrerenderDeps");
+  }
+
+  const segments = await _deserializeSegments(entry.segments);
+
+  // Replay handle data (same as runtime cache hit path).
+  // Prefer the eagerly-captured handleStoreRef to avoid ALS disruption in workerd.
+  const handleStore = handleStoreRef ?? _lazyGetRequestContext()?._handleStore;
+  if (handleStore) {
+    _restoreHandles(entry.handles, handleStore);
+  }
+
+  state.cacheHit = true;
+  state.cacheSource = "prerender";
+  state.cachedSegments = segments;
+  state.cachedMatchedIds = segments.map((s) => s.id);
+
+  // For partial navigation, nullify components the client already has
+  // so parent layouts stay live (client keeps its existing versions).
+  // When params changed (e.g., different guide slug), the segments have
+  // different content, so we must NOT nullify.
+  const paramsChanged =
+    !ctx.isFullMatch && !paramsEqual(ctx.matched.params, ctx.prevParams);
+  for (const segment of segments) {
+    if (
+      !ctx.isFullMatch &&
+      !paramsChanged &&
+      ctx.clientSegmentSet.has(segment.id)
+    ) {
+      segment.component = null;
+      segment.loading = undefined;
+    }
+    yield segment;
+  }
+
+  // Resolve loaders fresh (loaders are never pre-rendered/cached)
+  if (ctx.isFullMatch) {
+    if (resolveLoadersOnly) {
+      const loaderSegments = await ctx.Store.run(() =>
+        resolveLoadersOnly(ctx.entries, ctx.handlerContext),
+      );
+      state.matchedIds = state.cachedMatchedIds!;
+      for (const segment of loaderSegments) {
+        yield segment;
+      }
+    } else {
+      state.matchedIds = state.cachedMatchedIds!;
+    }
+  } else {
+    if (resolveLoadersOnlyWithRevalidation) {
+      const loaderResult = await ctx.Store.run(() =>
+        resolveLoadersOnlyWithRevalidation(
+          ctx.entries,
+          ctx.handlerContext,
+          ctx.clientSegmentSet,
+          ctx.prevParams,
+          ctx.request,
+          ctx.prevUrl,
+          ctx.url,
+          ctx.routeKey,
+          ctx.actionContext,
+        ),
+      );
+      state.matchedIds = [
+        ...state.cachedMatchedIds!,
+        ...loaderResult.matchedIds,
+      ];
+      for (const segment of loaderResult.segments) {
+        yield segment;
+      }
+    } else {
+      state.matchedIds = state.cachedMatchedIds!;
+    }
+  }
+
+  const ms = ctx.metricsStore;
+  if (ms) {
+    ms.metrics.push({
+      label: "pipeline:cache-lookup",
+      duration: performance.now() - pipelineStart,
+      startTime: pipelineStart - ms.requestStart,
+    });
+  }
+}
+
 /**
  * Async generator middleware type
  */
 export type GeneratorMiddleware<T> = (
-  source: AsyncGenerator<T>
+  source: AsyncGenerator<T>,
 ) => AsyncGenerator<T>;
 
 /**
@@ -141,14 +281,21 @@ export type GeneratorMiddleware<T> = (
  */
 export function withCacheLookup<TEnv>(
   ctx: MatchContext<TEnv>,
-  state: MatchPipelineState
+  state: MatchPipelineState,
 ): GeneratorMiddleware<ResolvedSegment> {
   return async function* (
-    source: AsyncGenerator<ResolvedSegment>
+    source: AsyncGenerator<ResolvedSegment>,
   ): AsyncGenerator<ResolvedSegment> {
     const pipelineStart = performance.now();
     const ms = ctx.metricsStore;
 
+    // Eagerly capture the HandleStore before any async operations.
+    // In workerd/Cloudflare, dynamic imports and fetch() inside the pipeline
+    // can disrupt AsyncLocalStorage, causing getRequestContext() to return
+    // undefined afterward. Capturing the reference early ensures handle replay
+    // and handler handle-push work regardless of ALS state.
+    const handleStoreRef = _getRequestContext()?._handleStore;
+
     const {
       evaluateRevalidation,
       buildEntryRevalidateMap,
@@ -162,79 +309,124 @@ export function withCacheLookup<TEnv>(
       await ensurePrerenderDeps();
       if (prerenderStoreInstance) {
         const paramHash = _hashParams!(ctx.matched.params);
-        const entry = prerenderStoreInstance.get(ctx.matched.routeKey, paramHash);
-        if (entry) {
-          const segments = await _deserializeSegments!(entry.segments);
-
-          // Replay handle data (same as runtime cache hit path)
-          const handleStore = _getRequestContext!()?._handleStore;
-          if (handleStore) {
-            for (const [segId, segHandles] of Object.entries(entry.handles)) {
-              if (Object.keys(segHandles).length > 0) {
-                handleStore.replaySegmentData(segId, segHandles);
-              }
-            }
-          }
+        const isPassthroughPrerenderRoute = ctx.entries.some(
+          (entry) =>
+            entry.type === "route" &&
+            entry.prerenderDef?.options?.passthrough === true,
+        );
 
-          state.cacheHit = true;
-          state.cachedSegments = segments;
-          state.cachedMatchedIds = segments.map((s) => s.id);
-
-          // Yield prerendered segments (same flow as cache hit)
-          // For partial navigation, nullify components the client already has
-          // so parent layouts stay live (client keeps its existing versions).
-          for (const segment of segments) {
-            if (!ctx.isFullMatch && ctx.clientSegmentSet.has(segment.id)) {
-              segment.component = null;
-              segment.loading = undefined;
-            }
-            yield segment;
+        if (ctx.isIntercept) {
+          // Intercept navigation: try intercept-specific prerender entry
+          const entry = await prerenderStoreInstance.get(
+            ctx.matched.routeKey,
+            paramHash + "/i",
+            {
+              pathname: ctx.pathname,
+              isPassthroughRoute: isPassthroughPrerenderRoute,
+            },
+          );
+          if (entry) {
+            yield* yieldFromStore(
+              entry,
+              ctx,
+              state,
+              pipelineStart,
+              handleStoreRef,
+            );
+            return;
           }
+          // No intercept prerender -- fall through to normal pipeline
+          // (skip non-intercept prerender to let intercept-resolution run)
+        } else {
+          // Normal navigation: existing behavior
+          const entry = await prerenderStoreInstance.get(
+            ctx.matched.routeKey,
+            paramHash,
+            {
+              pathname: ctx.pathname,
+              isPassthroughRoute: isPassthroughPrerenderRoute,
+            },
+          );
+          if (entry) {
+            yield* yieldFromStore(
+              entry,
+              ctx,
+              state,
+              pipelineStart,
+              handleStoreRef,
+            );
+            return;
+          }
+        }
+      }
+    }
+
+    // Dev-mode static handler interception for non-Node.js runtimes.
+    // __PRERENDER_DEV_URL is set by the Vite plugin when the RSC environment
+    // lacks a Node.js module runner (e.g. workerd, Deno workers). In those
+    // runtimes, handlers that depend on Node APIs like node:fs can't run
+    // in-process. We redirect them to the /__rsc_prerender endpoint which
+    // resolves segments in a Node.js temp server, same as prerender routes.
+    // In Node.js dev mode this variable is undefined -- handlers run
+    // in-process where Node APIs work, so no interception is needed.
+    if (!ctx.isAction && !ctx.matched.pr && globalThis.__PRERENDER_DEV_URL) {
+      const hasStatic = ctx.entries.some(
+        (e) =>
+          (e.type === "layout" ||
+            e.type === "route" ||
+            e.type === "parallel") &&
+          e.isStaticPrerender,
+      );
+      if (hasStatic) {
+        await ensurePrerenderDeps();
+        if (prerenderStoreInstance) {
+          const paramHash = _hashParams!(ctx.matched.params);
+          const isPassthroughPrerenderRoute = ctx.entries.some(
+            (entry) =>
+              entry.type === "route" &&
+              entry.prerenderDef?.options?.passthrough === true,
+          );
 
-          // Resolve loaders fresh (loaders are never pre-rendered)
-          if (ctx.isFullMatch) {
-            if (resolveLoadersOnly) {
-              const loaderSegments = await ctx.Store.run(() =>
-                resolveLoadersOnly(ctx.entries, ctx.handlerContext),
+          if (ctx.isIntercept) {
+            const entry = await prerenderStoreInstance.get(
+              ctx.matched.routeKey,
+              paramHash + "/i",
+              {
+                pathname: ctx.pathname,
+                isPassthroughRoute: isPassthroughPrerenderRoute,
+              },
+            );
+            if (entry) {
+              yield* yieldFromStore(
+                entry,
+                ctx,
+                state,
+                pipelineStart,
+                handleStoreRef,
               );
-              state.matchedIds = state.cachedMatchedIds!;
-              for (const segment of loaderSegments) {
-                yield segment;
-              }
-            } else {
-              state.matchedIds = state.cachedMatchedIds!;
+              return;
             }
+            // No intercept prerender -- fall through to normal pipeline
           } else {
-            if (resolveLoadersOnlyWithRevalidation) {
-              const loaderResult = await ctx.Store.run(() =>
-                resolveLoadersOnlyWithRevalidation(
-                  ctx.entries,
-                  ctx.handlerContext,
-                  ctx.clientSegmentSet,
-                  ctx.prevParams,
-                  ctx.request,
-                  ctx.prevUrl,
-                  ctx.url,
-                  ctx.routeKey,
-                  ctx.actionContext,
-                ),
+            const entry = await prerenderStoreInstance.get(
+              ctx.matched.routeKey,
+              paramHash,
+              {
+                pathname: ctx.pathname,
+                isPassthroughRoute: isPassthroughPrerenderRoute,
+              },
+            );
+            if (entry) {
+              yield* yieldFromStore(
+                entry,
+                ctx,
+                state,
+                pipelineStart,
+                handleStoreRef,
               );
-              state.matchedIds = [
-                ...state.cachedMatchedIds!,
-                ...loaderResult.matchedIds,
-              ];
-              for (const segment of loaderResult.segments) {
-                yield segment;
-              }
-            } else {
-              state.matchedIds = state.cachedMatchedIds!;
+              return;
             }
           }
-
-          if (ms) {
-            ms.metrics.push({ label: "pipeline:cache-lookup", duration: performance.now() - pipelineStart, startTime: pipelineStart - ms.requestStart });
-          }
-          return;
         }
       }
     }
@@ -244,7 +436,11 @@ export function withCacheLookup<TEnv>(
       // Cache miss - pass through to segment resolution
       yield* source;
       if (ms) {
-        ms.metrics.push({ label: "pipeline:cache-lookup", duration: performance.now() - pipelineStart, startTime: pipelineStart - ms.requestStart });
+        ms.metrics.push({
+          label: "pipeline:cache-lookup",
+          duration: performance.now() - pipelineStart,
+          startTime: pipelineStart - ms.requestStart,
+        });
       }
       return;
     }
@@ -253,30 +449,54 @@ export function withCacheLookup<TEnv>(
     const cacheResult = await ctx.cacheScope.lookupRoute(
       ctx.pathname,
       ctx.matched.params,
-      ctx.isIntercept
+      ctx.isIntercept,
     );
 
     if (!cacheResult) {
       // Cache miss - pass through to segment resolution
       yield* source;
       if (ms) {
-        ms.metrics.push({ label: "pipeline:cache-lookup", duration: performance.now() - pipelineStart, startTime: pipelineStart - ms.requestStart });
+        ms.metrics.push({
+          label: "pipeline:cache-lookup",
+          duration: performance.now() - pipelineStart,
+          startTime: pipelineStart - ms.requestStart,
+        });
       }
       return;
     }
 
     // Cache HIT
     state.cacheHit = true;
+    state.cacheSource = "runtime";
     state.shouldRevalidate = cacheResult.shouldRevalidate;
     state.cachedSegments = cacheResult.segments;
     state.cachedMatchedIds = cacheResult.segments.map((s) => s.id);
 
-    // Apply revalidation to cached segments
-    const entryRevalidateMap = buildEntryRevalidateMap?.(ctx.entries);
+    // Apply revalidation to cached segments.
+    // For full matches or empty client segment sets, this map is unnecessary:
+    // we never run segment-level revalidation and can stream segments directly.
+    const canCheckSegmentRevalidation =
+      !ctx.isFullMatch &&
+      ctx.clientSegmentSet.size > 0 &&
+      !!buildEntryRevalidateMap;
+    const entryRevalidateMap = canCheckSegmentRevalidation
+      ? buildEntryRevalidateMap(ctx.entries)
+      : undefined;
 
     for (const segment of cacheResult.segments) {
       // Skip segments client doesn't have - they need their component
       if (!ctx.clientSegmentSet.has(segment.id)) {
+        if (isTraceActive()) {
+          pushRevalidationTraceEntry({
+            segmentId: segment.id,
+            segmentType: segment.type,
+            belongsToRoute: segment.belongsToRoute ?? false,
+            source: "cache-hit",
+            defaultShouldRevalidate: true,
+            finalShouldRevalidate: true,
+            reason: "new-segment",
+          });
+        }
         yield segment;
         continue;
       }
@@ -291,6 +511,17 @@ export function withCacheLookup<TEnv>(
       const entryInfo = entryRevalidateMap?.get(segment.id);
       if (!entryInfo || entryInfo.revalidate.length === 0) {
         // No revalidation rules, use default behavior (skip if client has)
+        if (isTraceActive()) {
+          pushRevalidationTraceEntry({
+            segmentId: segment.id,
+            segmentType: segment.type,
+            belongsToRoute: segment.belongsToRoute ?? false,
+            source: "cache-hit",
+            defaultShouldRevalidate: false,
+            finalShouldRevalidate: false,
+            reason: "cached-no-rules",
+          });
+        }
         segment.component = null;
         segment.loading = undefined;
         yield segment;
@@ -312,8 +543,24 @@ export function withCacheLookup<TEnv>(
         routeKey: ctx.routeKey,
         context: ctx.handlerContext,
         actionContext: ctx.actionContext,
+        stale: cacheResult.shouldRevalidate || undefined,
+        traceSource: "cache-hit",
       });
 
+      const routerCtx = getRouterContext<TEnv>();
+      if (routerCtx.telemetry) {
+        const tSink = resolveSink(routerCtx.telemetry);
+        safeEmit(tSink, {
+          type: "revalidation.decision",
+          timestamp: performance.now(),
+          requestId: routerCtx.requestId,
+          segmentId: segment.id,
+          pathname: ctx.pathname,
+          routeKey: ctx.routeKey,
+          shouldRevalidate,
+        });
+      }
+
       if (!shouldRevalidate) {
         // Client has it, no revalidation needed
         segment.component = null;
@@ -331,7 +578,7 @@ export function withCacheLookup<TEnv>(
       // Full match (document request) - simple loader resolution without revalidation
       if (resolveLoadersOnly) {
         const loaderSegments = await Store.run(() =>
-          resolveLoadersOnly(ctx.entries, ctx.handlerContext)
+          resolveLoadersOnly(ctx.entries, ctx.handlerContext),
         );
 
         // Update state - full match doesn't track matchedIds separately
@@ -357,8 +604,9 @@ export function withCacheLookup<TEnv>(
             ctx.prevUrl,
             ctx.url,
             ctx.routeKey,
-            ctx.actionContext
-          )
+            ctx.actionContext,
+            cacheResult.shouldRevalidate || undefined,
+          ),
         );
 
         // Update state with fresh loader matchedIds
@@ -376,7 +624,11 @@ export function withCacheLookup<TEnv>(
       }
     }
     if (ms) {
-      ms.metrics.push({ label: "pipeline:cache-lookup", duration: performance.now() - pipelineStart, startTime: pipelineStart - ms.requestStart });
+      ms.metrics.push({
+        label: "pipeline:cache-lookup",
+        duration: performance.now() - pipelineStart,
+        startTime: pipelineStart - ms.requestStart,
+      });
     }
   };
 }

package/src/router/match-middleware/cache-store.ts

@@ -104,6 +104,7 @@ import type { ResolvedSegment } from "../../types.js";
 import { getRequestContext } from "../../server/request-context.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
 import { getRouterContext } from "../router-context.js";
+import { debugLog, debugWarn } from "../logging.js";
 import type { GeneratorMiddleware } from "./cache-lookup.js";
 
 /**
@@ -141,16 +142,21 @@ export function withCacheStore<TEnv>(
       ctx.request.method !== "GET"
     ) {
       if (ms) {
-        ms.metrics.push({ label: "pipeline:cache-store", duration: performance.now() - pipelineStart, startTime: pipelineStart - ms.requestStart });
+        ms.metrics.push({
+          label: "pipeline:cache-store",
+          duration: performance.now() - pipelineStart,
+          startTime: pipelineStart - ms.requestStart,
+        });
       }
       return;
     }
 
     const {
       createHandlerContext,
-      setupLoaderAccessSilent,
+      setupLoaderAccess,
       resolveAllSegments,
       resolveInterceptEntry,
+      createHandleStore,
     } = getRouterContext<TEnv>();
 
     // Combine main segments with intercept segments
@@ -172,9 +178,10 @@ export function withCacheStore<TEnv>(
     requestCtx.onResponse((response) => {
       // Only cache successful responses
       if (response.status !== 200) {
-        console.log(
-          `[CacheStore] Skipping cache: non-200 status ${response.status} for ${ctx.pathname}`,
-        );
+        debugLog("cacheStore", "skipping cache for non-200 response", {
+          status: response.status,
+          pathname: ctx.pathname,
+        });
         return response;
       }
 
@@ -182,29 +189,34 @@ export function withCacheStore<TEnv>(
         // Proactive caching: render all segments fresh in background
         // This ensures cache has complete components for future requests
         requestCtx.waitUntil(async () => {
-          console.log(
-            `[Router.matchPartial] Proactive caching: ${ctx.pathname} (rendering null-component segments)`,
-          );
+          debugLog("cacheStore", "proactive caching started", {
+            pathname: ctx.pathname,
+          });
+          // Swap to a fresh HandleStore so handle.push() calls from
+          // proactive resolution are captured (not silenced). The original
+          // store's stream is already sent by waitUntil time.
+          // cacheRoute reads from requestCtx._handleStore, so this ensures
+          // complete handle data (e.g. breadcrumbs) is cached.
+          const originalHandleStore = requestCtx._handleStore;
+          requestCtx._handleStore = createHandleStore();
           try {
             // Create fresh context for proactive caching
-            // This prevents handle data from polluting the response stream
             const proactiveHandlerContext = createHandlerContext(
               ctx.matched.params,
               ctx.request,
               ctx.url.searchParams,
               ctx.pathname,
               ctx.url,
-              ctx.bindings,
+              ctx.env,
               ctx.routeMap,
-              ctx.matched.routeKey
+              ctx.matched.routeKey,
+              ctx.matched.responseType,
+              ctx.matched.pt === true,
             );
             const proactiveLoaderPromises = new Map<string, Promise<any>>();
 
-            // Set up loader access that ignores handle pushes
-            setupLoaderAccessSilent(
-              proactiveHandlerContext,
-              proactiveLoaderPromises,
-            );
+            // Use normal loader access so handle data is captured
+            setupLoaderAccess(proactiveHandlerContext, proactiveLoaderPromises);
 
             // Re-resolve ALL segments without revalidation
             const Store = ctx.Store;
@@ -237,20 +249,23 @@ export function withCacheStore<TEnv>(
               ...freshSegments,
               ...freshInterceptSegments,
             ];
+            requestCtx._handleStore.seal();
             await cacheScope.cacheRoute(
               ctx.pathname,
               ctx.matched.params,
               completeSegments,
               ctx.isIntercept,
             );
-            console.log(
-              `[Router.matchPartial] Proactive caching complete: ${ctx.pathname}`,
-            );
+            debugLog("cacheStore", "proactive caching complete", {
+              pathname: ctx.pathname,
+            });
           } catch (error) {
-            console.error(
-              `[Router.matchPartial] Proactive caching failed:`,
-              error,
-            );
+            debugWarn("cacheStore", "proactive caching failed", {
+              pathname: ctx.pathname,
+              error: String(error),
+            });
+          } finally {
+            requestCtx._handleStore = originalHandleStore;
           }
         });
       } else {
@@ -270,7 +285,11 @@ export function withCacheStore<TEnv>(
     });
 
     if (ms) {
-      ms.metrics.push({ label: "pipeline:cache-store", duration: performance.now() - pipelineStart, startTime: pipelineStart - ms.requestStart });
+      ms.metrics.push({
+        label: "pipeline:cache-store",
+        duration: performance.now() - pipelineStart,
+        startTime: pipelineStart - ms.requestStart,
+      });
     }
   };
 }