@rangojs/router 0.0.0-experimental.tapabs3 → 0.1.0

package/src/build/route-trie.ts

@@ -2,8 +2,7 @@
  * Build-time Route Trie Construction
  *
  * Builds a serializable trie from the route manifest for O(path_length)
- * route matching at runtime. Each trie leaf embeds the route's ancestry
- * shortCodes for layout pruning.
+ * route matching at runtime.
  */
 
 import {
@@ -33,8 +32,6 @@ export interface TrieLeaf {
   n: string;
   /** Static prefix of the entry (e.g., "/site") */
   sp: string;
-  /** Ancestry shortCodes from root to route [M0L0, M0L0L0, M0L0L0R499] */
-  a: string[];
   /** Constraint validation: paramName -> allowed values */
   cv?: Record<string, string[]>;
   /** Ordered param names for this route (positional) */
@@ -75,7 +72,6 @@ export interface TrieNode {
  * Build a route trie from build-time manifest data.
  *
  * @param routeManifest - Map of route name to full URL pattern
- * @param routeAncestry - Map of route name to ancestry shortCodes
  * @param routeToStaticPrefix - Map of route name to its entry's staticPrefix
  * @param routeTrailingSlash - Optional map of route name to trailing slash mode
  * @param prerenderRouteNames - Optional set of prerendered route names (sets leaf.pr)
@@ -84,7 +80,6 @@ export interface TrieNode {
  */
 export function buildRouteTrie(
   routeManifest: Record<string, string>,
-  routeAncestry: Record<string, string[]>,
   routeToStaticPrefix: Record<string, string>,
   routeTrailingSlash?: Record<string, string>,
   prerenderRouteNames?: Set<string>,
@@ -94,7 +89,6 @@ export function buildRouteTrie(
   const root: TrieNode = {};
 
   for (const [routeName, pattern] of Object.entries(routeManifest)) {
-    const ancestry = routeAncestry[routeName] || [];
     const staticPrefix = routeToStaticPrefix[routeName] || "";
     const trailingSlash = routeTrailingSlash?.[routeName];
     const responseType = responseTypeRoutes?.[routeName];
@@ -107,7 +101,6 @@ export function buildRouteTrie(
     insertRoute(root, segments, 0, {
       n: routeName,
       sp: staticPrefix,
-      a: ancestry,
       ...(trailingSlash ? { ts: trailingSlash } : {}),
       ...(prerenderRouteNames?.has(routeName) ? { pr: true } : {}),
       ...(passthroughRouteNames?.has(routeName) ? { pt: true } : {}),
@@ -161,15 +154,13 @@ function sortSuffixParams(node: TrieNode): void {
  * construction path shared by build/discovery (discover-routers.ts, serialized
  * into the production chunk) and the dev/HMR runtime rebuild
  * (rsc/manifest-init.ts). Keeping one code path is what guarantees the dev
- * runtime trie and the production serialized trie are byte-for-byte identical
- * (modulo `leaf.a` ancestry, which embeds the mount index and is debug-only).
+ * runtime trie and the production serialized trie are byte-for-byte identical.
  *
- * Returns null when the manifest has no route ancestry (no routes), matching
- * the prior guard at both call sites.
+ * Returns null when the manifest has no routes, matching the prior guard at
+ * both call sites.
  */
 export function buildPerRouterTrie(manifest: FullManifest): TrieNode | null {
-  const ancestry = manifest._routeAncestry;
-  if (!ancestry || Object.keys(ancestry).length === 0) {
+  if (Object.keys(manifest.routeManifest).length === 0) {
     return null;
   }
 
@@ -186,7 +177,6 @@ export function buildPerRouterTrie(manifest: FullManifest): TrieNode | null {
 
   return buildRouteTrie(
     manifest.routeManifest,
-    ancestry,
     routeToStaticPrefix,
     manifest.routeTrailingSlash,
     manifest.prerenderRoutes ? new Set(manifest.prerenderRoutes) : undefined,
@@ -233,41 +223,6 @@ function insertRoute(
   insertSegments(node, segments, index, leafBase, []);
 }
 
-/**
- * Extract ancestry map from a built trie by visiting all leaf nodes.
- * Returns { routeName: ancestryShortCodes[] } for every route in the trie.
- */
-export function extractAncestryFromTrie(
-  root: TrieNode,
-): Record<string, string[]> {
-  const result: Record<string, string[]> = {};
-
-  function visit(node: TrieNode): void {
-    if (node.r) {
-      result[node.r.n] = node.r.a;
-    }
-    if (node.w) {
-      result[node.w.n] = node.w.a;
-    }
-    if (node.s) {
-      for (const child of Object.values(node.s)) {
-        visit(child);
-      }
-    }
-    if (node.xp) {
-      for (const child of Object.values(node.xp)) {
-        visit(child.c);
-      }
-    }
-    if (node.p) {
-      visit(node.p.c);
-    }
-  }
-
-  visit(root);
-  return result;
-}
-
 /**
  * Merge a new leaf with an existing leaf, handling content negotiation.
  * When an RSC route and response-type routes share the same URL pattern,

package/src/cache/cache-key-utils.ts

@@ -23,7 +23,6 @@ const RESERVED_SEARCH_PARAMS = new Set([
   "__no_cache",
   "__rsc",
   "__html",
-  "__debug_manifest",
   "__prerender_collect",
 ]);
 

package/src/cache/cache-scope.ts

@@ -285,10 +285,19 @@ export class CacheScope {
       // partial: evict the entry (self-heal - the re-render re-caches under the
       // same key) and report it as corruption, distinct from a transient infra
       // error (handled by the outer catch).
+      //
+      // Shell-HIT tail (_shellFragmentPayload, issue #700): skip the decode and
+      // carry the stored fragment strings verbatim — the payload consumers
+      // expand them (segment-fragments.ts). Read off the ambient context at the
+      // same point the cache key was resolved (getDefaultRouteCacheKey), so the
+      // flag shares fate with the key: a disrupted ALS already missed the
+      // seeded record and degraded to the full tail.
       let segments: ResolvedSegment[];
       try {
-        const { deserializeSegments } = await import("./segment-codec.js");
-        segments = await deserializeSegments(cached.segments);
+        const codec = await import("./segment-codec.js");
+        segments = _getRequestContext()?._shellFragmentPayload
+          ? await codec.fragmentSegments(cached.segments)
+          : await codec.deserializeSegments(cached.segments);
       } catch (error) {
         reportCacheError(
           error,
@@ -452,7 +461,11 @@ export class CacheScope {
       }
 
       // Collect handle data for non-loader segments only
-      const handles = captureHandles(nonLoaderSegments, handleStore);
+      const handles = captureHandles(
+        nonLoaderSegments,
+        handleStore,
+        requestCtx._shellCaptureLoaderHandleValues,
+      );
 
       try {
         if (INTERNAL_RANGO_DEBUG) {
@@ -512,3 +525,28 @@ export function createCacheScope(
   if (!config) return parent; // No config, inherit parent
   return new CacheScope(config.options, parent);
 }
+
+/**
+ * Shell fast path: when the route tree derived NO cache scope and the current
+ * request context carries the `_shellImplicitCache` marker (a shell capture,
+ * or a HIT tail serving an eligible entry), substitute an implicit doc-level
+ * scope so withCacheLookup/withCacheStore treat the WHOLE matched route as a
+ * cache() boundary — the shell entry IS a cache() of the handler layer, with
+ * loaders as the live carve-outs (resolveFreshLoadersAndYield).
+ *
+ * An existing scope — including an explicit cache(false) opt-out — always
+ * wins: the consumer's cache() semantics (their ttl/swr/store/condition) are
+ * never overridden, and cache(false) keeps the tail on the full handler
+ * re-run path.
+ */
+export function resolveShellImplicitCacheScope(
+  scope: CacheScope | null,
+): CacheScope | null {
+  if (scope) return scope;
+  const marker = getRequestContext()?._shellImplicitCache;
+  if (!marker) return null;
+  return new CacheScope(
+    { ttl: marker.ttl, swr: marker.swr, store: marker.store },
+    null,
+  );
+}