@rangojs/router 0.0.0-experimental.124 → 0.0.0-experimental.126

package/src/router/match-context.ts

@@ -242,25 +242,3 @@ export function createPipelineState(): MatchPipelineState {
     slots: {},
   };
 }
-
-/**
- * Input parameters for createMatchContext
- */
-export interface CreateMatchContextInput<TEnv = any> {
-  request: Request;
-  env: TEnv;
-  actionContext?: ActionContext;
-}
-
-/**
- * Result from createMatchContext - either a context or null (fall back to full match)
- */
-export type CreateMatchContextResult<TEnv = any> =
-  | { type: "context"; ctx: MatchContext<TEnv> }
-  | { type: "fallback"; reason: string }
-  | { type: "error"; error: Error };
-
-// Note: createMatchContext() will be implemented in Step J10 when we wire everything together.
-// It requires access to RouterContext (findMatch, loadManifest, etc.) which are closure
-// functions from createRouter(). The implementation will live in router.ts initially
-// and call getRouterContext() to access these dependencies.

package/src/router/match-handlers.ts

@@ -89,20 +89,6 @@ export interface MatchHandlers<TEnv = any> {
     negotiated?: boolean;
     manifestEntry?: EntryData;
   } | null>;
-  createMatchContextForFull: (
-    request: Request,
-    env: TEnv,
-  ) => Promise<MatchContext<TEnv> | { type: "redirect"; redirectUrl: string }>;
-  createMatchContextForPartial: (
-    request: Request,
-    env: TEnv,
-    actionContext?: {
-      actionId?: string;
-      actionUrl?: URL;
-      actionResult?: any;
-      formData?: FormData;
-    },
-  ) => Promise<MatchContext<TEnv> | null>;
 }
 
 /**
@@ -123,9 +109,6 @@ export function createMatchHandlers<TEnv = any>(
   const hasTelemetry = !!deps.telemetry;
   const telemetry = resolveSink(deps.telemetry);
   const cacheSignalEnabled = !!deps.cacheSignalEnabled;
-  // Compute the coarse cache signal when EITHER telemetry needs it (for the
-  // cache.decision event) OR the debug header gate is on. When neither is set,
-  // this is never called — zero extra work on the hot path.
   const buildSignal = (
     routeKey: string,
     state: {
@@ -134,8 +117,6 @@ export function createMatchHandlers<TEnv = any>(
       shouldRevalidate?: boolean;
     },
   ): CacheSegmentSignal[] => buildCacheSignalSegments(routeKey, state);
-  // Stash the signal on the request context for the response path to emit as
-  // the X-Rango-Cache header. Only when the debug gate is on.
   const recordSignalIfEnabled = (segments: CacheSegmentSignal[]): void => {
     if (!cacheSignalEnabled) return;
     const reqCtx = _getRequestContext();
@@ -173,15 +154,6 @@ export function createMatchHandlers<TEnv = any>(
     );
   }
 
-  /**
-   * Match request and return segments (document/SSR requests)
-   *
-   * Uses generator middleware pipeline for clean separation of concerns:
-   * - cache-lookup: Check cache first
-   * - segment-resolution: Resolve segments on cache miss
-   * - cache-store: Store results in cache
-   * - background-revalidation: SWR revalidation
-   */
   async function match(request: Request, env: TEnv): Promise<MatchResult> {
     const requestId = hasTelemetry ? getRequestId(request) : undefined;
     return runWithRouterLogContext({ request, transaction: "match" }, () => {
@@ -205,7 +177,6 @@ export function createMatchHandlers<TEnv = any>(
 
           const result = await createMatchContextForFull(request, env);
 
-          // Handle redirect case
           if ("type" in result && result.type === "redirect") {
             if (hasTelemetry) {
               safeEmit(telemetry, {
@@ -284,7 +255,6 @@ export function createMatchHandlers<TEnv = any>(
               });
             }
             if (error instanceof Response) throw error;
-            // Report unhandled errors during full match pipeline
             callOnError(error, "routing", {
               request,
               url: ctx.url,
@@ -319,16 +289,6 @@ export function createMatchHandlers<TEnv = any>(
     );
   }
 
-  /**
-   * Match partial request with revalidation
-   *
-   * Uses generator middleware pipeline for clean separation of concerns:
-   * - cache-lookup: Check cache first
-   * - segment-resolution: Resolve segments on cache miss
-   * - intercept-resolution: Handle intercept routes
-   * - cache-store: Store results in cache
-   * - background-revalidation: SWR revalidation
-   */
   async function matchPartial(
     request: Request,
     context: TEnv,
@@ -448,7 +408,6 @@ export function createMatchHandlers<TEnv = any>(
                 });
               }
               if (error instanceof Response) throw error;
-              // Report unhandled errors during partial match pipeline
               callOnError(error, actionContext ? "action" : "revalidation", {
                 request,
                 url: ctx.url,
@@ -477,7 +436,5 @@ export function createMatchHandlers<TEnv = any>(
     matchPartial: matchPartial,
     matchError: matchError,
     previewMatch: previewMatch,
-    createMatchContextForFull: createMatchContextForFull,
-    createMatchContextForPartial: createMatchContextForPartial,
   };
 }

package/src/router/match-middleware/background-revalidation.ts

@@ -168,8 +168,6 @@ export function withBackgroundRevalidation<TEnv>(
       requestCtx._handleStore = createHandleStore();
 
       try {
-        // Create fresh handler context and loader promises to avoid
-        // reusing memoized results from the foreground pass
         const freshHandlerContext = createHandlerContext(
           ctx.matched.params,
           ctx.request,
@@ -185,10 +183,6 @@ export function withBackgroundRevalidation<TEnv>(
         const freshLoaderPromises = new Map<string, Promise<any>>();
         setupLoaderAccess(freshHandlerContext, freshLoaderPromises);
 
-        // Resolve all segments fresh (without revalidation logic)
-        // to ensure complete components for caching.
-        // Skip DSL loaders — they are never cached (cacheRoute filters them)
-        // and are always resolved fresh on each request.
         const freshSegments = await ctx.Store.run(() =>
           resolveAllSegments(
             ctx.entries,
@@ -200,7 +194,6 @@ export function withBackgroundRevalidation<TEnv>(
           ),
         );
 
-        // Also resolve intercept segments fresh if applicable
         let freshInterceptSegments: ResolvedSegment[] = [];
         if (ctx.interceptResult) {
           freshInterceptSegments = await ctx.Store.run(() =>

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

@@ -93,7 +93,7 @@
  */
 import type { ResolvedSegment } from "../../types.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
-import { getRouterContext } from "../router-context.js";
+import { getRouterContext, type RouterContext } from "../router-context.js";
 import { resolveSink, safeEmit } from "../telemetry.js";
 import { pushRevalidationTraceEntry, isTraceActive } from "../logging.js";
 import { treeHasStreaming } from "./segment-resolution.js";
@@ -103,6 +103,7 @@ import {
   getRequestContext,
   _getRequestContext,
 } from "../../server/request-context.js";
+import { paramsEqual } from "../params-util.js";
 
 // Lazily initialized prerender store singleton and dynamically imported deps.
 // Dynamic imports prevent pulling in @vitejs/plugin-rsc/rsc virtual module at
@@ -124,22 +125,6 @@ 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 [codec, snapshot, paramHash, reqCtx, store] = await Promise.all([
@@ -165,6 +150,81 @@ async function ensurePrerenderDeps() {
  * Deserializes segments, replays handle data, yields segments with partial
  * navigation nullification, and resolves fresh loaders.
  */
+// Resolve loaders fresh on a cache hit (loaders are NEVER cached) and yield
+// the loader segments, updating state.matchedIds and pushing the loader-resolve
+// + cache-hit metrics. Shared verbatim by the prerender-store path
+// (yieldFromStore) and the runtime cache-hit path (withCacheLookup). The router
+// resolve fns are passed in (captured early by the callers) rather than re-read
+// from getRouterContext() here, because that is ALS-backed and the callers run
+// awaits before reaching this point (workerd can disrupt ALS mid-pipeline).
+async function* resolveFreshLoadersAndYield<TEnv>(
+  ctx: MatchContext<TEnv>,
+  state: MatchPipelineState,
+  pipelineStart: number,
+  ms: MatchContext<TEnv>["metricsStore"],
+  resolveLoadersOnly: RouterContext<TEnv>["resolveLoadersOnly"],
+  resolveLoadersOnlyWithRevalidation: RouterContext<TEnv>["resolveLoadersOnlyWithRevalidation"],
+): AsyncGenerator<ResolvedSegment> {
+  const loaderStart = performance.now();
+
+  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,
+          // Loaders are never cached in the segment cache, so segment staleness
+          // must not propagate; browser-sent staleness (ctx.stale) still must.
+          ctx.stale || undefined,
+        ),
+      );
+      state.matchedIds = [
+        ...state.cachedMatchedIds!,
+        ...loaderResult.matchedIds,
+      ];
+      for (const segment of loaderResult.segments) {
+        yield segment;
+      }
+    } else {
+      state.matchedIds = state.cachedMatchedIds!;
+    }
+  }
+
+  if (ms) {
+    const loaderEnd = performance.now();
+    ms.metrics.push({
+      label: "pipeline:loader-resolve",
+      duration: loaderEnd - loaderStart,
+      startTime: loaderStart - ms.requestStart,
+      depth: 1,
+    });
+    ms.metrics.push({
+      label: "pipeline:cache-hit",
+      duration: loaderEnd - pipelineStart,
+      startTime: pipelineStart - ms.requestStart,
+    });
+  }
+}
+
 async function* yieldFromStore<TEnv>(
   entry: PrerenderEntry,
   ctx: MatchContext<TEnv>,
@@ -231,64 +291,15 @@ async function* yieldFromStore<TEnv>(
     yield segment;
   }
 
-  // Resolve loaders fresh (loaders are never pre-rendered/cached)
-  const ms = ctx.metricsStore;
-  const loaderStart = performance.now();
-
-  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,
-          ctx.stale || undefined,
-        ),
-      );
-      state.matchedIds = [
-        ...state.cachedMatchedIds!,
-        ...loaderResult.matchedIds,
-      ];
-      for (const segment of loaderResult.segments) {
-        yield segment;
-      }
-    } else {
-      state.matchedIds = state.cachedMatchedIds!;
-    }
-  }
-
-  if (ms) {
-    const loaderEnd = performance.now();
-    ms.metrics.push({
-      label: "pipeline:loader-resolve",
-      duration: loaderEnd - loaderStart,
-      startTime: loaderStart - ms.requestStart,
-      depth: 1,
-    });
-    ms.metrics.push({
-      label: "pipeline:cache-hit",
-      duration: loaderEnd - pipelineStart,
-      startTime: pipelineStart - ms.requestStart,
-    });
-  }
+  // Resolve loaders fresh (loaders are never pre-rendered/cached).
+  yield* resolveFreshLoadersAndYield(
+    ctx,
+    state,
+    pipelineStart,
+    ctx.metricsStore,
+    resolveLoadersOnly,
+    resolveLoadersOnlyWithRevalidation,
+  );
 }
 
 /**
@@ -367,10 +378,6 @@ export function withCacheLookup<TEnv>(
       resolveLoadersOnly,
     } = getRouterContext<TEnv>();
 
-    // Prerender lookup: check build-time cached data before runtime cache.
-    // Prerender data is available regardless of runtime cache configuration.
-    // Skip for HMR requests — the dev prerender endpoint reads from a stale
-    // RouterRegistry snapshot; rendering fresh ensures edits are visible.
     const isHmr = !!ctx.request.headers.get("X-RSC-HMR");
     if (!ctx.isAction && !isHmr && ctx.matched.pr) {
       await ensurePrerenderDeps();
@@ -385,14 +392,6 @@ export function withCacheLookup<TEnv>(
       }
     }
 
-    // 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) =>
@@ -415,9 +414,7 @@ export function withCacheLookup<TEnv>(
       }
     }
 
-    // Skip cache during actions
     if (ctx.isAction || !ctx.cacheScope?.enabled) {
-      // Cache miss - pass through to segment resolution
       yield* source;
       if (ms) {
         ms.metrics.push({
@@ -429,7 +426,6 @@ export function withCacheLookup<TEnv>(
       return;
     }
 
-    // Lookup cache
     const cacheResult = await ctx.cacheScope.lookupRoute(
       ctx.pathname,
       ctx.matched.params,
@@ -437,7 +433,6 @@ export function withCacheLookup<TEnv>(
     );
 
     if (!cacheResult) {
-      // Cache miss - pass through to segment resolution
       yield* source;
       if (ms) {
         ms.metrics.push({
@@ -449,16 +444,12 @@ export function withCacheLookup<TEnv>(
       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.
-    // 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 &&
@@ -468,7 +459,6 @@ export function withCacheLookup<TEnv>(
       : 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({
@@ -485,19 +475,13 @@ export function withCacheLookup<TEnv>(
         continue;
       }
 
-      // Skip intercept segments - they're handled separately
       if (segment.namespace?.startsWith("intercept:")) {
         yield segment;
         continue;
       }
 
-      // Look up revalidation rules for this segment
       const entryInfo = entryRevalidateMap?.get(segment.id);
 
-      // Even without explicit revalidation rules, route segments and their
-      // children must re-render when params or search params change — the
-      // handler reads ctx.params/ctx.searchParams so different values produce
-      // different content. Matches evaluateRevalidation's default logic.
       const searchChanged = ctx.prevUrl.search !== ctx.url.search;
       const routeParamsChanged = !paramsEqual(
         ctx.matched.params,
@@ -511,7 +495,6 @@ export function withCacheLookup<TEnv>(
 
       if (!entryInfo || entryInfo.revalidate.length === 0) {
         if (shouldDefaultRevalidate) {
-          // Params or search params changed — must re-render even without custom rules
           if (isTraceActive()) {
             pushRevalidationTraceEntry({
               segmentId: segment.id,
@@ -528,7 +511,6 @@ export function withCacheLookup<TEnv>(
           yield segment;
           continue;
         }
-        // No revalidation rules, use default behavior (skip if client has)
         if (isTraceActive()) {
           pushRevalidationTraceEntry({
             segmentId: segment.id,
@@ -546,7 +528,6 @@ export function withCacheLookup<TEnv>(
         continue;
       }
 
-      // Evaluate revalidation rules
       const shouldRevalidate = await evaluateRevalidation({
         segment,
         prevParams: ctx.prevParams,
@@ -580,7 +561,6 @@ export function withCacheLookup<TEnv>(
       }
 
       if (!shouldRevalidate) {
-        // Client has it, no revalidation needed
         segment.component = null;
         segment.loading = undefined;
       }
@@ -588,7 +568,6 @@ export function withCacheLookup<TEnv>(
       yield segment;
     }
 
-    // Set streaming flag (once) and resolve render barrier.
     const barrierReqCtx = _getRequestContext();
     if (barrierReqCtx) {
       if (barrierReqCtx._treeHasStreaming === undefined) {
@@ -597,77 +576,15 @@ export function withCacheLookup<TEnv>(
       barrierReqCtx._resolveRenderBarrier(cacheResult.segments);
     }
 
-    // Resolve loaders fresh (loaders are NOT cached by default)
-    // This ensures fresh data even on cache hit
-    const Store = ctx.Store;
-    const loaderStart = performance.now();
-
-    if (ctx.isFullMatch) {
-      // Full match (document request) - simple loader resolution without revalidation
-      if (resolveLoadersOnly) {
-        const loaderSegments = await Store.run(() =>
-          resolveLoadersOnly(ctx.entries, ctx.handlerContext),
-        );
-
-        // Update state - full match doesn't track matchedIds separately
-        state.matchedIds = state.cachedMatchedIds!;
-
-        // Yield fresh loader segments
-        for (const segment of loaderSegments) {
-          yield segment;
-        }
-      } else {
-        state.matchedIds = state.cachedMatchedIds!;
-      }
-    } else {
-      // Partial match (navigation) - loader resolution with revalidation
-      if (resolveLoadersOnlyWithRevalidation) {
-        const loaderResult = await Store.run(() =>
-          resolveLoadersOnlyWithRevalidation(
-            ctx.entries,
-            ctx.handlerContext,
-            ctx.clientSegmentSet,
-            ctx.prevParams,
-            ctx.request,
-            ctx.prevUrl,
-            ctx.url,
-            ctx.routeKey,
-            ctx.actionContext,
-            // Loaders are never cached in the segment cache, so segment
-            // staleness (cacheResult.shouldRevalidate) must not propagate.
-            // But browser-sent staleness (ctx.stale) — indicating an action
-            // happened in this or another tab — must still reach loaders.
-            ctx.stale || undefined,
-          ),
-        );
-
-        // Update state with fresh loader matchedIds
-        state.matchedIds = [
-          ...state.cachedMatchedIds!,
-          ...loaderResult.matchedIds,
-        ];
-
-        // Yield fresh loader segments
-        for (const segment of loaderResult.segments) {
-          yield segment;
-        }
-      } else {
-        state.matchedIds = state.cachedMatchedIds!;
-      }
-    }
-    if (ms) {
-      const loaderEnd = performance.now();
-      ms.metrics.push({
-        label: "pipeline:loader-resolve",
-        duration: loaderEnd - loaderStart,
-        startTime: loaderStart - ms.requestStart,
-        depth: 1,
-      });
-      ms.metrics.push({
-        label: "pipeline:cache-hit",
-        duration: loaderEnd - pipelineStart,
-        startTime: pipelineStart - ms.requestStart,
-      });
-    }
+    // Resolve loaders fresh (loaders are never cached). Shared with the
+    // prerender-store path via resolveFreshLoadersAndYield.
+    yield* resolveFreshLoadersAndYield(
+      ctx,
+      state,
+      pipelineStart,
+      ms,
+      resolveLoadersOnly,
+      resolveLoadersOnlyWithRevalidation,
+    );
   };
 }

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

@@ -123,21 +123,14 @@ export function withCacheStore<TEnv>(
   ): AsyncGenerator<ResolvedSegment> {
     const ms = ctx.metricsStore;
 
-    // Collect all segments while passing them through
     const allSegments: ResolvedSegment[] = [];
     for await (const segment of source) {
       allSegments.push(segment);
       yield segment;
     }
 
-    // Measure own work only (after source iteration completes)
     const ownStart = performance.now();
 
-    // Skip caching if:
-    // 1. Cache miss but cache scope is disabled
-    // 2. This is an action (actions don't cache)
-    // 3. Cache was already hit (no need to re-cache)
-    // 4. Non-GET request (only cache GET requests)
     if (
       !ctx.cacheScope?.enabled ||
       ctx.isAction ||
@@ -162,13 +155,8 @@ export function withCacheStore<TEnv>(
       createHandleStore,
     } = getRouterContext<TEnv>();
 
-    // Combine main segments with intercept segments
     const allSegmentsToCache = [...allSegments, ...state.interceptSegments];
 
-    // Check if any non-loader segments have null components from revalidation
-    // skip (client already had them). Segments where the handler intentionally
-    // returned null are not revalidation skips — re-rendering them will still
-    // produce null, so proactive caching would be wasted work.
     const hasNullComponents = allSegmentsToCache.some(
       (s) =>
         s.component === null &&
@@ -184,10 +172,7 @@ export function withCacheStore<TEnv>(
       ? getOrCreateRequestId(ctx.request)
       : undefined;
 
-    // Register onResponse callback to skip caching for non-200 responses
-    // Note: error/notFound status codes are set elsewhere (not caching-specific)
     requestCtx.onResponse((response) => {
-      // Only cache successful responses
       if (response.status !== 200) {
         debugLog("cacheStore", "skipping cache for non-200 response", {
           status: response.status,
@@ -197,10 +182,7 @@ export function withCacheStore<TEnv>(
       }
 
       if (hasNullComponents) {
-        // Proactive caching: render all segments fresh in background
-        // This ensures cache has complete components for future requests
         requestCtx.waitUntil(async () => {
-          // Prevent background metrics from polluting foreground timeline.
           const savedMetrics = ctx.Store.metrics;
           ctx.Store.metrics = undefined;
 
@@ -208,15 +190,9 @@ export function withCacheStore<TEnv>(
           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
             const proactiveHandlerContext = createHandlerContext(
               ctx.matched.params,
               ctx.request,
@@ -231,12 +207,8 @@ export function withCacheStore<TEnv>(
             );
             const proactiveLoaderPromises = new Map<string, Promise<any>>();
 
-            // Use normal loader access so handle data is captured
             setupLoaderAccess(proactiveHandlerContext, proactiveLoaderPromises);
 
-            // Re-resolve ALL segments without revalidation.
-            // Skip DSL loaders — they are never cached (cacheRoute filters them)
-            // and are always resolved fresh on each request.
             const Store = ctx.Store;
             const freshSegments = await Store.run(() =>
               resolveAllSegments(
@@ -249,7 +221,6 @@ export function withCacheStore<TEnv>(
               ),
             );
 
-            // Also resolve intercept segments fresh if applicable
             let freshInterceptSegments: ResolvedSegment[] = [];
             if (ctx.interceptResult) {
               freshInterceptSegments = await Store.run(() =>
@@ -301,8 +272,6 @@ export function withCacheStore<TEnv>(
           }
         });
       } else {
-        // All segments have components - cache directly
-        // Schedule caching in waitUntil since cacheRoute is now async (key resolution)
         if (INTERNAL_RANGO_DEBUG) {
           console.log(
             `[RSC CacheStore][req:${reqId}] Direct cache path: scheduling cacheRoute for ${ctx.pathname} (${allSegmentsToCache.length} segments, hasNullComponents=${hasNullComponents})`,