@rangojs/router 0.0.0-experimental.61 → 0.0.0-experimental.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.0.0-experimental.61",
+  "version": "0.0.0-experimental.63",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",
@@ -132,15 +132,6 @@
     "access": "public",
     "tag": "experimental"
   },
-  "scripts": {
-    "build": "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && pnpm dlx esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node' && chmod +x dist/bin/rango.js",
-    "prepublishOnly": "pnpm build",
-    "typecheck": "tsc --noEmit",
-    "test": "playwright test",
-    "test:ui": "playwright test --ui",
-    "test:unit": "vitest run",
-    "test:unit:watch": "vitest"
-  },
   "dependencies": {
     "@vitejs/plugin-rsc": "^0.5.19",
     "magic-string": "^0.30.17",
@@ -150,12 +141,12 @@
   "devDependencies": {
     "@playwright/test": "^1.49.1",
     "@types/node": "^24.10.1",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "esbuild": "^0.27.0",
     "jiti": "^2.6.1",
-    "react": "catalog:",
-    "react-dom": "catalog:",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
     "tinyexec": "^0.3.2",
     "typescript": "^5.3.0",
     "vitest": "^4.0.0"
@@ -173,5 +164,13 @@
     "vite": {
       "optional": true
     }
+  },
+  "scripts": {
+    "build": "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && pnpm dlx esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node' && chmod +x dist/bin/rango.js",
+    "typecheck": "tsc --noEmit",
+    "test": "playwright test",
+    "test:ui": "playwright test --ui",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest"
   }
-}
+}

package/skills/prerender/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: prerender
-description: Pre-render route segments at build time with Prerender and passthrough fallback
+description: Pre-render route segments at build time with Prerender and Passthrough live fallback
 argument-hint: [passthrough]
 ---
 
@@ -54,8 +54,14 @@ path("/blog/:slug", BlogPost, { name: "blog.post" })
 
 ### With Passthrough (live fallback for unknown params)
 
+Wrap a `Prerender` definition with `Passthrough()` to add a separate live handler
+for unknown params at runtime. The build handler runs at build time, the live
+handler runs at request time.
+
 ```typescript
-export const ProductPage = Prerender(
+import { Prerender, Passthrough } from "@rangojs/router";
+
+export const ProductPageDef = Prerender(
   async () => {
     const top = await db.query("SELECT id FROM products WHERE featured");
     return top.map(p => ({ id: p.id }));
@@ -64,32 +70,41 @@ export const ProductPage = Prerender(
     const product = await db.query("SELECT * FROM products WHERE id = ?", ctx.params.id);
     return <Product data={product} />;
   },
-  { passthrough: true, concurrency: 4 }
+  { concurrency: 4 }
 );
+
+// In route definition:
+path("/products/:id", Passthrough(ProductPageDef, async (ctx) => {
+  const product = await ctx.env.DB.query("SELECT * FROM products WHERE id = ?", ctx.params.id);
+  return <Product data={product} />;
+}), { name: "product" })
 ```
 
-## Passthrough Mode
+## Passthrough Wrapper
 
-Controls whether the handler stays in the RSC server bundle after build:
+`Passthrough(prerenderDef, liveHandler)` wraps a `Prerender` definition with a
+separate handler for runtime fallback. The build and live handlers are separate
+functions — no `ctx.build` branching needed.
 
-|                     | `passthrough: false` (default)          | `passthrough: true`                     |
-| ------------------- | --------------------------------------- | --------------------------------------- |
-| Known params        | Served from pre-rendered Flight payload | Served from pre-rendered Flight payload |
-| Unknown params      | Handler evicted, no live fallback       | Handler runs live at request time       |
-| `ctx.passthrough()` | Throws (not allowed)                    | Skips artifact, defers to live fallback |
-| Bundle size         | Handler code + imports removed          | Handler code kept in RSC bundle         |
-| `revalidate()`      | Not allowed (handler gone)              | Allowed (handler can re-render)         |
-| `loading()`         | Ignored (segments fully resolved)       | Works for live fallback renders         |
+|                     | Plain `Prerender` (no wrapper)          | `Passthrough(def, liveHandler)`          |
+| ------------------- | --------------------------------------- | ---------------------------------------- |
+| Known params        | Served from pre-rendered Flight payload | Served from pre-rendered Flight payload  |
+| Unknown params      | Handler evicted, no live fallback       | Live handler runs at request time        |
+| `ctx.passthrough()` | Throws (not on Passthrough route)       | Skips artifact, defers to live handler   |
+| Bundle size         | Build handler code + imports removed    | Build handler evicted, live handler kept |
+| `revalidate()`      | Not allowed (handler gone)              | Allowed (live handler can re-render)     |
+| `loading()`         | Ignored (segments fully resolved)       | Works for live fallback renders          |
 
-### When to use passthrough
+### When to use Passthrough
 
-Use `passthrough: true` when:
+Use `Passthrough()` when:
 
 - The route has a large or open-ended param space (e.g., user profiles, product pages)
 - You want to pre-render popular/known params for speed but still serve unknown params live
 - You need `revalidate()` on the route
+- The live handler needs runtime bindings (e.g., `ctx.env.DB`)
 
-Use `passthrough: false` (default) when:
+Use plain `Prerender` (no wrapper) when:
 
 - All possible params are known at build time (e.g., markdown files, config-driven pages)
 - You want maximum bundle size reduction (handler code + node:fs imports removed)
@@ -103,6 +118,7 @@ Handlers receive `BuildContext` at build time, a subset of the runtime `HandlerC
 interface BuildContext<TParams> {
   params: TParams; // From getParams
   build: true; // Always true at build time
+  dev: boolean; // true in Vite dev mode, false during production build
   use: <T>(handle: Handle<T>) => (data: T) => void; // Push handle data
   url: URL; // Synthetic URL from pattern + params
   pathname: string; // Pathname from synthetic URL
@@ -115,8 +131,9 @@ interface BuildContext<TParams> {
     params?: Record<string, string>,
     search?: Record<string, unknown>,
   ): string; // URL generation
-  passthrough(): PrerenderPassthroughResult; // Skip local artifact (passthrough routes only)
-  // NOT available: req, headers, cookies, env (throws descriptive errors)
+  passthrough(): PrerenderPassthroughResult; // Skip local artifact (Passthrough routes only)
+  env: DefaultEnv; // Available when buildEnv is configured in rango() (throws otherwise)
+  // NOT available: request, headers, cookies (always throw)
 }
 ```
 
@@ -183,18 +200,17 @@ In production builds, `Prerender` exports are replaced with stubs:
 // Original
 export const BlogPost = Prerender(getParams, handler);
 
-// Stubbed (ships to server bundle when passthrough: false)
+// Stubbed (all Prerender handlers are evicted)
 export const BlogPost = {
   __brand: "prerenderHandler",
   $$id: "abc123#BlogPost",
 };
 ```
 
-The original module and its imports (node:fs, markdown libs) are excluded from
-the bundle. With `passthrough: true`, the handler code stays in the RSC bundle.
+All Prerender handlers are evicted in production. The live handler for
+`Passthrough()` routes lives in the urls module and is not evicted.
 
-In client and SSR environments, ALL prerender handlers are always stubbed
-(passthrough only affects the RSC server bundle).
+In client and SSR environments, ALL prerender handlers are always stubbed.
 
 ## Sub-use Semantics
 
@@ -231,15 +247,15 @@ path("/blog/:slug", BlogPost, { name: "blog.post" }, () => [
 | DSL item       | Behavior with Prerender                                                                                                                                                                                                                                             |
 | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `loader()`     | Live at runtime, bundled normally. Use `cache()` for caching.                                                                                                                                                                                                       |
-| `revalidate()` | Not allowed without passthrough. Allowed with passthrough.                                                                                                                                                                                                          |
+| `revalidate()` | Not allowed without Passthrough. Allowed with Passthrough.                                                                                                                                                                                                          |
 | `cache()`      | Orthogonal -- use on parent layouts and loaders.                                                                                                                                                                                                                    |
 | `layout()`     | Child layouts inside path are pre-rendered. Parent layouts are live.                                                                                                                                                                                                |
 | `parallel()`   | Parallel slots inside path are pre-rendered.                                                                                                                                                                                                                        |
 | `middleware()` | Skipped during pre-render (no request). Runs at request time for loaders.                                                                                                                                                                                           |
-| `loading()`    | Ignored without passthrough. Works for live fallback with passthrough.                                                                                                                                                                                              |
+| `loading()`    | Ignored without Passthrough. Works for live fallback with Passthrough.                                                                                                                                                                                              |
 | `intercept()`  | Pre-rendered at build time. Intercept variant stored under `/i` key alongside main segments. At runtime, the correct variant is served based on `ctx.isIntercept`. `when()` conditions are skipped at build time (all intercepts are pre-rendered unconditionally). |
 
-When passthrough revalidation is enabled, remember that revalidation is
+When Passthrough revalidation is enabled, remember that revalidation is
 still partial: opting a child segment into revalidation does not
 implicitly re-run outer prerender-derived handlers/layouts.
 
@@ -304,12 +320,19 @@ export const BlogPost = Prerender(
     }
     return <PostPage slug={ctx.params.slug} />;
   },
-  { passthrough: true },
 );
+
+// Wrap with Passthrough to serve skipped params live at runtime
+export const BlogPost = Passthrough(BlogPostDef, async (ctx) => {
+  if (ctx.params.slug === "draft") {
+    throw new Skip("Draft articles are not pre-rendered");
+  }
+  return <PostPage slug={ctx.params.slug} />;
+});
 ```
 
-Skipped entries are excluded from the build output. With `passthrough: true`,
-the handler stays in the bundle and serves skipped params live at request time.
+Skipped entries are excluded from the build output. With `Passthrough()`,
+the live handler serves skipped params at request time.
 
 `Skip` also works in `Static` handlers:
 
@@ -326,7 +349,7 @@ export const TocSidebar = Static(() => {
 | Handler outcome             | Effect                                                |
 | --------------------------- | ----------------------------------------------------- |
 | JSX / `null`                | Normal prerender entry, log OK                        |
-| `return ctx.passthrough()`  | Skip entry, log PASS, continue (passthrough routes)   |
+| `return ctx.passthrough()`  | Skip entry, log PASS, continue (Passthrough routes)   |
 | `throw new Skip("reason")`  | Skip entry, log SKIP, continue with remaining entries |
 | `throw new Error("reason")` | Log FAIL, stop ALL pre-rendering, fail the build      |
 
@@ -366,56 +389,59 @@ falls back according to normal dev/runtime behavior.
 
 ## Per-Param Passthrough with ctx.passthrough()
 
-On `{ passthrough: true }` routes, a handler can return `ctx.passthrough()`
-to skip writing a local prerender artifact for a specific param set. At
-runtime, the missing entry falls through to the live handler.
+On routes wrapped with `Passthrough()`, the build handler can return
+`ctx.passthrough()` to skip writing a local prerender artifact for a specific
+param set. At runtime, the missing entry falls through to the live handler.
 
 ```typescript
-export const BlogPost = Prerender(
+export const BlogPostDef = Prerender(
   async () => [{ slug: "a" }, { slug: "b" }, { slug: "c" }],
   async (ctx) => {
     const post = await getPost(ctx.params.slug);
     if (!post) return ctx.passthrough();
     return <article>{post.content}</article>;
   },
-  { passthrough: true },
 );
+
+export const BlogPost = Passthrough(BlogPostDef, async (ctx) => {
+  const post = await getPost(ctx.params.slug);
+  return <article>{post.content}</article>;
+});
 ```
 
 ### Semantics
 
-- JSX or `null` from the handler produces a normal prerender entry.
+- JSX or `null` from the build handler produces a normal prerender entry.
 - `ctx.passthrough()` returns a sentinel that signals "no local artifact".
   The build skips the manifest entry for that param set.
-- `ctx.passthrough()` on a non-passthrough route throws an invariant error.
+- `ctx.passthrough()` on a route not wrapped with `Passthrough()` throws.
 - `ctx.passthrough()` at runtime (`ctx.build === false`) also throws.
   It is a build-time-only control flow.
-- `getParams()` still enumerates the param set; the handler decides per-param
-  whether to produce an artifact or defer to runtime.
+- `getParams()` still enumerates the param set; the build handler decides
+  per-param whether to produce an artifact or defer to the live handler.
 
 ### Difference from Skip
 
-| Mechanism           | Effect on build        | Runtime behavior                                     |
-| ------------------- | ---------------------- | ---------------------------------------------------- |
-| `throw new Skip()`  | Skips entry, logs SKIP | No artifact, no live fallback unless passthrough     |
-| `ctx.passthrough()` | Skips entry, logs PASS | Always defers to live handler (requires passthrough) |
+| Mechanism           | Effect on build        | Runtime behavior                                       |
+| ------------------- | ---------------------- | ------------------------------------------------------ |
+| `throw new Skip()`  | Skips entry, logs SKIP | No artifact, no live fallback unless Passthrough route |
+| `ctx.passthrough()` | Skips entry, logs PASS | Always defers to live handler (requires Passthrough)   |
 
-Use `ctx.passthrough()` when you want the handler to run live at request time
+Use `ctx.passthrough()` when you want the live handler to run at request time
 for specific params. Use `Skip` when you want to exclude params entirely.
 
 ### Use case: Remote storage
 
 `ctx.passthrough()` enables a pattern where build-time data is stored in a
-remote KV store instead of the local prerender manifest. The handler
+remote KV store instead of the local prerender manifest. The build handler
 pre-computes data during `getParams`, pushes it to KV, then calls
 `ctx.passthrough()` so the local build skips the artifact. At runtime,
-the live handler reads from KV:
+the Passthrough live handler reads from KV:
 
 ```typescript
-export const Product = Prerender(
+export const ProductDef = Prerender(
   async () => {
     const products = await db.getFeaturedProducts();
-    // Pre-compute and store in remote KV during build
     for (const p of products) {
       await kv.put(`product:${p.id}`, await renderProduct(p));
     }
@@ -423,14 +449,16 @@ export const Product = Prerender(
   },
   async (ctx) => {
     // At build time: skip local artifact, data is in KV
-    if (ctx.build) return ctx.passthrough();
-    // At runtime: read from KV
-    const cached = await kv.get(`product:${ctx.params.id}`);
-    if (cached) return cached;
-    return <Product data={await db.getProduct(ctx.params.id)} />;
+    return ctx.passthrough();
   },
-  { passthrough: true },
 );
+
+export const Product = Passthrough(ProductDef, async (ctx) => {
+  // At runtime: read from KV, fall back to DB
+  const cached = await kv.get(`product:${ctx.params.id}`);
+  if (cached) return cached;
+  return <Product data={await ctx.env.DB.getProduct(ctx.params.id)} />;
+});
 ```
 
 ### Build logs
@@ -458,8 +486,8 @@ Flight payload. They do not update at request time.
 ### Server actions work normally
 
 Actions do not re-render the B segment. The pre-rendered handler output stays
-frozen. Loaders are live and can be revalidated by actions. With `passthrough: true`
-and `revalidate()`, the handler itself can re-render live.
+frozen. Loaders are live and can be revalidated by actions. With `Passthrough()`
+and `revalidate()`, the live handler can re-render.
 
 ### Empty getParams
 
@@ -470,21 +498,21 @@ If `getParams` returns an empty array, no Flight payloads are written. No error.
 Routes using `Prerender` must have a `name` in path options.
 The name is used as the storage key for Flight payloads.
 
-### No revalidate without passthrough
+### No revalidate without Passthrough
 
-Using `revalidate()` with `passthrough: false` produces a build-time warning.
+Using `revalidate()` without `Passthrough()` produces a build-time warning.
 The handler is evicted -- there is nothing to re-render.
 
-### loading() is ignored without passthrough
+### loading() is ignored without Passthrough
 
 Pre-rendered segments are fully resolved at build time and never suspend.
-With `passthrough: true`, `loading()` works for live fallback renders.
+With `Passthrough()`, `loading()` works for live fallback renders.
 
 ## Complete Example
 
 ```typescript
 // pages/guides-handler.tsx
-import { Prerender } from "@rangojs/router";
+import { Prerender, Passthrough } from "@rangojs/router";
 import { Link } from "@rangojs/router/client";
 import { href } from "../router.js";
 
@@ -493,7 +521,7 @@ const knownGuides: Record<string, string> = {
   caching: "Caching Guide",
 };
 
-export const GuidesDetail = Prerender<{ slug: string }>(
+export const GuidesDetailDef = Prerender<{ slug: string }>(
   async () => Object.keys(knownGuides).map((slug) => ({ slug })),
   async (ctx) => {
     const title = knownGuides[ctx.params.slug] ?? `Guide: ${ctx.params.slug}`;
@@ -509,9 +537,23 @@ export const GuidesDetail = Prerender<{ slug: string }>(
       </div>
     );
   },
-  { passthrough: true },
 );
 
+export const GuidesDetail = Passthrough(GuidesDetailDef, async (ctx) => {
+  const title = knownGuides[ctx.params.slug] ?? `Guide: ${ctx.params.slug}`;
+  return (
+    <div>
+      <h1>{title}</h1>
+      <p>Slug: {ctx.params.slug}</p>
+      <nav>
+        <Link to={href("guides.detail", { slug: "routing" })}>Routing</Link>
+        {" | "}
+        <Link to={href("guides.detail", { slug: "dynamic-test" })}>Dynamic</Link>
+      </nav>
+    </div>
+  );
+});
+
 // pages/guides.tsx
 import { urls } from "@rangojs/router";
 import { GuidesDetail } from "./guides-handler.js";
@@ -588,12 +630,12 @@ Loaders run fresh at request time for both variants.
 Pre-rendered routes set flags on the route trie leaf at build time:
 
 - `pr: true` -- route has pre-rendered B segment data
-- `pt: true` -- passthrough mode (handler available for live fallback)
+- `pt: true` -- route wrapped with `Passthrough()` (live handler available)
 
 At runtime, the cache-lookup middleware uses these flags:
 
 - `pr + hit` -- serve pre-rendered Flight payload
-- `pr + pt + miss` -- fall through to live handler (handler kept in bundle)
+- `pr + pt + miss` -- fall through to Passthrough live handler
 - `pr + miss` (no pt) -- fall through (handler stubbed, no live render)
 
 ## Contributor Checklist
@@ -603,7 +645,7 @@ Before changing prerender behavior, read these docs and run these tests.
 ### Docs to re-read
 
 - [Prerender API design](../../docs/prerender-api-design.md) -- canonical
-  architecture: build-time flow, runtime flow, storage, passthrough, intercept
+  architecture: build-time flow, runtime flow, storage, Passthrough, intercept
 - [Execution model](../../docs/internal/execution-model.md) -- handler-first
   ordering, middleware scope, context visibility rules
 - [Semantic change checklist](../../docs/internal/semantic-change-checklist.md)
@@ -612,7 +654,7 @@ Before changing prerender behavior, read these docs and run these tests.
 ### Tests to run
 
 ```bash
-# Core prerender e2e (passthrough, eviction, loaders, sub-use, intercept)
+# Core prerender e2e (Passthrough, eviction, loaders, sub-use, intercept)
 pnpm --filter @rangojs/router exec playwright test prerender
 
 # Prerender-specific unit test
@@ -632,7 +674,7 @@ pnpm --filter @rangojs/router exec playwright test handler-first
   `/__rsc_prerender` endpoint tests and node.js dev-server fallback.
 - Log-based assertions (build output lines, debug cache logs) are inherently
   dev/build-only and do not need a production counterpart.
-- Behavioral assertions (rendered content, loader freshness, passthrough
+- Behavioral assertions (rendered content, loader freshness, Passthrough
   fallback, intercept variant selection) must work in the production build.
 
 ## Maintenance References

package/src/__internal.ts

@@ -225,7 +225,7 @@ export type {
  * @internal
  * Type guard for prerender handler definitions.
  */
-export { isPrerenderHandler } from "./prerender.js";
+export { isPrerenderHandler, isPassthroughHandler } from "./prerender.js";
 
 /**
  * @internal

package/src/build/generate-manifest.ts

@@ -45,7 +45,7 @@ export interface GeneratedManifest {
   routeTrailingSlash?: Record<string, string>;
   /** Route names using Prerender (for dev-mode Node.js delegation) */
   prerenderRoutes?: string[];
-  /** Route names with passthrough: true (handler kept in bundle for live fallback) */
+  /** Route names wrapped with Passthrough() (live handler for runtime fallback) */
   passthroughRoutes?: string[];
   /** Route name → response type for non-RSC routes */
   responseTypeRoutes?: Record<string, string>;
@@ -150,10 +150,7 @@ function buildPrefixTreeNode(
         if (prerenderDefs && entry.prerenderDef) {
           prerenderDefs[name] = entry.prerenderDef;
         }
-        if (
-          passthroughRoutes &&
-          entry.prerenderDef?.options?.passthrough === true
-        ) {
+        if (passthroughRoutes && entry.isPassthrough === true) {
           passthroughRoutes.push(name);
         }
       }
@@ -350,7 +347,7 @@ export function generateManifestFull<TEnv>(
       if (entry.prerenderDef) {
         prerenderDefs[name] = entry.prerenderDef;
       }
-      if (entry.prerenderDef?.options?.passthrough === true) {
+      if (entry.isPassthrough === true) {
         passthroughRoutes.push(name);
       }
     }

package/src/build/route-types/scan-filter.ts

@@ -61,7 +61,14 @@ export function findTsFiles(dir: string, filter?: ScanFilter): string[] {
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      if (
+        entry.name === "node_modules" ||
+        entry.name.startsWith(".") ||
+        entry.name === "dist" ||
+        entry.name === "build" ||
+        entry.name === "coverage"
+      )
+        continue;
       results.push(...findTsFiles(fullPath, filter));
     } else if (
       (entry.name.endsWith(".ts") ||

package/src/index.rsc.ts

@@ -100,6 +100,7 @@ export type {
   LayoutUseItem,
   AllUseItems,
   UseItems,
+  HandlerUseItem,
 } from "./route-types.js";
 
 // Handle API
@@ -114,8 +115,9 @@ export { nonce } from "./rsc/nonce.js";
 // Pre-render handler API
 export {
   Prerender,
+  Passthrough,
   type PrerenderHandlerDefinition,
-  type PrerenderPassthroughContext,
+  type PassthroughHandlerDefinition,
   type PrerenderOptions,
   type BuildContext,
   type StaticBuildContext,

package/src/index.ts

@@ -88,6 +88,7 @@ export type {
   LayoutUseItem,
   AllUseItems,
   UseItems,
+  HandlerUseItem,
 } from "./route-types.js";
 
 // Response route types (usable in both server and client contexts)
@@ -152,6 +153,13 @@ export function Prerender(): never {
   throw serverOnlyStubError("Prerender");
 }
 
+/**
+ * Error-throwing stub for server-only `Passthrough` function.
+ */
+export function Passthrough(): never {
+  throw serverOnlyStubError("Passthrough");
+}
+
 /**
  * Error-throwing stub for server-only `Static` function.
  */

package/src/prerender/store.ts

@@ -121,10 +121,11 @@ export function createPrerenderStore(): PrerenderStore | null {
         if (!mod) return null;
         const specifier = mod.default[key];
         if (!specifier) return null;
-        return mod
-          .loadPrerenderAsset(specifier)
-          .then((asset) => asset.default)
-          .catch(() => null);
+        // Let asset load errors propagate — a missing/corrupted artifact
+        // for a key that exists in the manifest is a build/deploy error
+        // and should surface as a 500, not be silently swallowed as null
+        // (which the handler stub would misreport as a 404).
+        return mod.loadPrerenderAsset(specifier).then((asset) => asset.default);
       });
       cache.set(key, promise);
       return promise;