@rshono/core 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/runtime/server.js

@@ -1,24 +1,29 @@
 /**
- * `@rshono/core/server` — the request-scoped surface, for use inside server components
- * and `'use server'` action modules: {@link getContext} for the URL, cookies,
- * params, env and middleware variables, the {@link redirect} and {@link notFound}
- * control-flow helpers, and {@link onServerError} for reporting the errors the
- * framework catches.
+ * `@rshono/core/server` — the request-scoped surface, for server components and `'use server'` action
+ * modules: `getRequestContext()` for the URL, cookies, params, env and middleware variables, the
+ * `redirect()` and `notFound()` control-flow helpers, and `onServerError()` for reporting the errors
+ * the framework catches. Plus `publicUrl(c)` for middleware, which is handed Hono's `c` rather than a
+ * request context.
  *
- * Server-only. Importing this from a `'use client'` module is a mistake — those
- * run in the browser (and are SSR'd without a bound context). Read what you need
- * on the server and pass it down as props, or use `useNavigation()` from
- * `@rshono/core/client` for URL data.
+ * Server-only: a `'use client'` module runs in the browser, with no bound context. Read what you need
+ * on the server and pass it down as props, or use `useNavigation()` from `@rshono/core/client`.
  *
- * A barrel rather than `./context.js` itself, which is where all of this is
- * implemented: that module also exports the plumbing the framework's own entry
- * points need (`runWithContext`, `readParams`, `publicUrl`, `reportServerError`),
- * and pointing the `./server` subpath straight at it published every one of them —
- * `@internal` in the docs, but present in a consumer's autocomplete and pinned by
- * semver all the same. They stay reachable by relative import, which is the only
- * way the framework itself ever reaches them.
+ * @example
+ * ```ts
+ * 'use server';
+ * import { getRequestContext, redirect } from '@rshono/core/server';
+ *
+ * export async function logout() {
+ *   getRequestContext().cookies.delete('session', { path: '/' });
+ *   redirect('/');
+ * }
+ * ```
+ *
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreserver | Docs — `@rshono/core/server`}
  *
  * @packageDocumentation
  */
-export { getContext, notFound, onServerError, redirect, } from './context.js';
+// A barrel rather than pointing the subpath at `./context.js`, which also exports the framework's own
+// plumbing — that would put `runWithContext` and friends in a consumer's autocomplete and under semver.
+export { getRequestContext, notFound, onServerError, publicUrl, redirect, } from './context.js';
 //# sourceMappingURL=server.js.map

package/dist/runtime/server.js.map

@@ -1 +1 @@
-{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/runtime/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EACL,UAAU,EACV,QAAQ,EACR,aAAa,EACb,QAAQ,GAST,MAAM,cAAc,CAAC","sourcesContent":["/**\n * `@rshono/core/server` — the request-scoped surface, for use inside server components\n * and `'use server'` action modules: {@link getContext} for the URL, cookies,\n * params, env and middleware variables, the {@link redirect} and {@link notFound}\n * control-flow helpers, and {@link onServerError} for reporting the errors the\n * framework catches.\n *\n * Server-only. Importing this from a `'use client'` module is a mistake — those\n * run in the browser (and are SSR'd without a bound context). Read what you need\n * on the server and pass it down as props, or use `useNavigation()` from\n * `@rshono/core/client` for URL data.\n *\n * A barrel rather than `./context.js` itself, which is where all of this is\n * implemented: that module also exports the plumbing the framework's own entry\n * points need (`runWithContext`, `readParams`, `publicUrl`, `reportServerError`),\n * and pointing the `./server` subpath straight at it published every one of them —\n * `@internal` in the docs, but present in a consumer's autocomplete and pinned by\n * semver all the same. They stay reachable by relative import, which is the only\n * way the framework itself ever reaches them.\n *\n * @packageDocumentation\n */\n\nexport {\n  getContext,\n  notFound,\n  onServerError,\n  redirect,\n  // A type, not a value: `Ctx` is handed to you by `getContext()` or the `ctx` page\n  // prop — one instance per request — and is never constructed by application code.\n  type Ctx,\n  type EnvVars,\n  type RedirectStatus,\n  type ServerErrorContext,\n  type ServerErrorHandler,\n  type ServerErrorSource,\n} from './context.js';\n"]}
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/runtime/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,sGAAsG;AACtG,wGAAwG;AACxG,OAAO,EACL,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,SAAS,EACT,QAAQ,GAOT,MAAM,cAAc,CAAC","sourcesContent":["/**\n * `@rshono/core/server` — the request-scoped surface, for server components and `'use server'` action\n * modules: `getRequestContext()` for the URL, cookies, params, env and middleware variables, the\n * `redirect()` and `notFound()` control-flow helpers, and `onServerError()` for reporting the errors\n * the framework catches. Plus `publicUrl(c)` for middleware, which is handed Hono's `c` rather than a\n * request context.\n *\n * Server-only: a `'use client'` module runs in the browser, with no bound context. Read what you need\n * on the server and pass it down as props, or use `useNavigation()` from `@rshono/core/client`.\n *\n * @example\n * ```ts\n * 'use server';\n * import { getRequestContext, redirect } from '@rshono/core/server';\n *\n * export async function logout() {\n *   getRequestContext().cookies.delete('session', { path: '/' });\n *   redirect('/');\n * }\n * ```\n *\n * @see {@link https://www.rshono.com/docs/api#rshonocoreserver | Docs — `@rshono/core/server`}\n *\n * @packageDocumentation\n */\n\n// A barrel rather than pointing the subpath at `./context.js`, which also exports the framework's own\n// plumbing — that would put `runWithContext` and friends in a consumer's autocomplete and under semver.\nexport {\n  getRequestContext,\n  notFound,\n  onServerError,\n  publicUrl,\n  redirect,\n  type EnvVars,\n  type RedirectStatus,\n  type RequestContext,\n  type ServerErrorContext,\n  type ServerErrorHandler,\n  type ServerErrorSource,\n} from './context.js';\n"]}

package/dist/runtime/validate-entries.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The two modules an app hands the framework — `src/routes.ts` and `src/server.ts` — checked before
+ * anything is built on them.
+ *
+ * Both arrive through a build-time alias that carries no type the compiler can hold on to, so they used to
+ * be cast and the mistake found later, somewhere else: a `routes` array that skipped `defineRoutes` surfaced
+ * as `TypeError: nN is not iterable` from a minified bundle, and a `src/server.ts` exporting the wrong thing
+ * as `Cannot read properties of undefined (reading 'map')` from inside Hono. Neither names the file to open.
+ * The mistakes that produced no error at all were worse: a duplicated `path` whose second entry silently
+ * never ran, a `staticPaths` on a route that renders per request.
+ *
+ * The route *table* is checked at module load — during `rshono build`, which imports the server bundle for
+ * the prerender pass; at `rshono dev` startup; and when a deployed server boots. The modules the table points
+ * *at* cannot be, because they load lazily: {@link assertPageModule} and {@link assertEndpointModule} run on
+ * first request, and {@link assertRouteModules} runs both against every route during `rshono build`.
+ */
+import type { Handler, Hono } from 'hono';
+import type { ServerEntry } from 'react-server-dom-rspack/server';
+import { type PageComponent, type RouteConfig } from '../router.js';
+/**
+ * Normalises and checks what `src/routes.ts` exported as `routes`.
+ *
+ * A bare array is accepted alongside a {@link RouteConfig}, because the docs present both and
+ * `defineRoutes` is an identity function over the array form — which makes leaving it off look equivalent
+ * right up to the point the build fails somewhere unrelated.
+ */
+export declare function validateRoutesModule(exported: unknown): RouteConfig;
+/**
+ * The Hono app `src/server.ts` default-exports, or `null` for an app that has no `src/server.ts` — the
+ * fallback module the alias resolves to instead default-exports exactly that.
+ *
+ * Duck-typed rather than `instanceof Hono`: what the framework does with the value is `app.route('/', …)`,
+ * which reads `routes` off it and mounts the handlers, so those are what have to be there.
+ */
+export declare function validateServerApp(exported: unknown): Hono | null;
+/**
+ * The server component a page module must default-export, checked rather than cast.
+ *
+ * Two structural mistakes land here, and neither can serve *any* request, which is why they are also checked
+ * at build time by {@link assertRouteModules}:
+ *
+ * - no default export at all — a named `export function Page`, or a file that exports its layout instead;
+ * - a `'use client'` page. That module's default export is a client reference, so it carries no
+ *   `entryJsFiles` — the list of scripts the document has to boot, recorded only for a *server* entry.
+ *   Rendering it anyway would produce a page with no client runtime, which is worse than a message.
+ */
+export declare function assertPageModule(mod: {
+    default?: unknown;
+}, label: string): ServerEntry<PageComponent>;
+/**
+ * The Hono handler an endpoint module must export as `handler`.
+ *
+ * The page half of this fork has been checked since it existed; this half used to destructure and call, which
+ * turns the one mistake people actually make — a method-named export, the shape other frameworks ask for —
+ * into `TypeError: r is not a function` from a minified frame. That is verbatim the failure mode this file's
+ * header names as the reason it exists.
+ */
+export declare function assertEndpointModule(mod: {
+    handler?: unknown;
+}, label: string): Handler;
+/**
+ * Resolves every route's own module once and runs the two checks above against it — what `rshono build` does
+ * once the bundle exists, so a route that cannot serve *any* request fails the build instead of exiting 0 and
+ * answering 500 in production for the life of the deployment.
+ *
+ * Every route is checked, not just the first that fails: these are all fixed by editing a file, and a build
+ * that names one of four broken routes costs three more builds to get through.
+ *
+ * A module that throws while *evaluating* is warned about rather than raised. Checking a module's shape means
+ * importing it, and whether an import succeeds is a question about the environment, not about the module: a
+ * page whose module scope reads a secret, opens a connection or touches a file that only exists in production
+ * fails here and works per request. Failing the build on that would make "every route module must be
+ * importable during the build" a new requirement on apps, to catch a mistake this cannot tell from a
+ * deliberate one. A `render: 'static'` route is the exception, and needs nothing here: it promised to render
+ * at build time, so the prerender pass demands the import and fails the build when it throws.
+ */
+export declare function assertRouteModules(config: RouteConfig): Promise<void>;

package/dist/runtime/validate-entries.js

@@ -0,0 +1,405 @@
+/**
+ * The two modules an app hands the framework — `src/routes.ts` and `src/server.ts` — checked before
+ * anything is built on them.
+ *
+ * Both arrive through a build-time alias that carries no type the compiler can hold on to, so they used to
+ * be cast and the mistake found later, somewhere else: a `routes` array that skipped `defineRoutes` surfaced
+ * as `TypeError: nN is not iterable` from a minified bundle, and a `src/server.ts` exporting the wrong thing
+ * as `Cannot read properties of undefined (reading 'map')` from inside Hono. Neither names the file to open.
+ * The mistakes that produced no error at all were worse: a duplicated `path` whose second entry silently
+ * never ran, a `staticPaths` on a route that renders per request.
+ *
+ * The route *table* is checked at module load — during `rshono build`, which imports the server bundle for
+ * the prerender pass; at `rshono dev` startup; and when a deployed server boots. The modules the table points
+ * *at* cannot be, because they load lazily: {@link assertPageModule} and {@link assertEndpointModule} run on
+ * first request, and {@link assertRouteModules} runs both against every route during `rshono build`.
+ */
+import { isPageRoute } from '../router.js';
+/** Every method an endpoint route can name, `'all'` aside — which is also what `'all'` is expanded to below. */
+const CONCRETE_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options'];
+const METHODS = new Set([...CONCRETE_METHODS, 'all']);
+/** What a page route's `render` accepts. */
+const RENDER_MODES = ['static', 'dynamic'];
+/**
+ * The one path prefix the framework claims on every deploy target: the hashed client bundle, mounted by
+ * `runtime.mountStaticAssets` ahead of the route table, ending in a terminal 404 — so nothing under it
+ * reaches a page. Written out here rather than imported, because the mounts live in the deploy runtimes
+ * (`deploy/filesystem.ts`, `deploy/cloudflare/runtime.ts`) and in `cli/dev.ts`, none of which this module
+ * can pull in.
+ *
+ * It is the only one. `/_rshono/hmr` is dev-only and an exact path rather than a prefix, and Cloudflare's
+ * `__ssg` is an asset path no app would name.
+ */
+const RESERVED_PREFIX = '/_static';
+function fail(message) {
+    throw new Error(`[rshono] ${message}`);
+}
+/**
+ * How a route is named in a message. Always by position, because that is what a duplicate `path` needs to be
+ * told apart, and by path as well wherever there is one.
+ */
+function label(route, index) {
+    const path = route?.path;
+    return typeof path === 'string' ? `routes[${index}] ("${path}")` : `routes[${index}]`;
+}
+/** Refuses a key that belongs to the *other* kind of route — see {@link validateRoute}. */
+function refuseForeignKeys(route, name, keys, advice) {
+    for (const key of keys) {
+        if (route[key] !== undefined)
+            fail(`src/routes.ts: ${name} has \`${key}\`, which ${advice}`);
+    }
+}
+/**
+ * Checks one entry of the route table.
+ *
+ * The cross-kind key checks are the ones TypeScript cannot make: excess-property checking against a union
+ * accepts any key present in *some* member, so `staticPaths` on an `{ type: 'endpoint' }` route type-checks
+ * and is then ignored at runtime — which is indistinguishable from prerendering that quietly does nothing.
+ */
+function validateRoute(route, index) {
+    if (route === null || typeof route !== 'object') {
+        fail(`src/routes.ts: routes[${index}] is ${route === null ? 'null' : typeof route}, not a route object.`);
+    }
+    const entry = route;
+    const name = label(route, index);
+    if (typeof entry.path !== 'string' || !entry.path.startsWith('/')) {
+        fail(`src/routes.ts: ${name} needs a \`path\` starting with "/".`);
+    }
+    if (entry.type !== undefined && entry.type !== 'endpoint') {
+        fail(`src/routes.ts: ${name} has type ${JSON.stringify(entry.type)} — the only \`type\` is 'endpoint', and a page route omits it.`);
+    }
+    if (entry.type === 'endpoint') {
+        if (typeof entry.server !== 'function') {
+            fail(`src/routes.ts: ${name} is an endpoint, so it needs \`server\` — a function importing the module that exports \`handler\`.`);
+        }
+        if (entry.method !== undefined)
+            validateMethod(entry.method, name);
+        refuseForeignKeys(entry, name, ['component', 'render', 'staticPaths'], "only a page route has — an endpoint's `server` handler decides its own response.");
+    }
+    else {
+        if (typeof entry.component !== 'function') {
+            fail(`src/routes.ts: ${name} needs \`component\` — a function importing the page module, e.g. \`() => import('./pages/home')\`.`);
+        }
+        if (entry.render !== undefined && (typeof entry.render !== 'string' || !RENDER_MODES.includes(entry.render))) {
+            fail(`src/routes.ts: ${name} has render ${JSON.stringify(entry.render)} — it is 'static' or 'dynamic'.`);
+        }
+        if (entry.staticPaths !== undefined) {
+            if (typeof entry.staticPaths !== 'function')
+                fail(`src/routes.ts: ${name} has a \`staticPaths\` that is not a function.`);
+            if (entry.render !== 'static') {
+                fail(`src/routes.ts: ${name} has \`staticPaths\` but is not \`render: 'static'\`, so it renders per request and the paths are never built.`);
+            }
+        }
+        refuseForeignKeys(entry, name, ['server', 'method'], "only an endpoint route has — add `type: 'endpoint'` if that is what this is.");
+    }
+}
+/**
+ * Checks an endpoint's `method`, which is one method or a list of them.
+ *
+ * A list is checked member by member so the message names the bad one rather than printing the array, and
+ * `'all'` is refused inside one: a list meaning every method is a list its author did not mean to write.
+ */
+function validateMethod(method, name) {
+    if (Array.isArray(method)) {
+        if (method.length === 0)
+            fail(`src/routes.ts: ${name} has an empty \`method\` list — omit it to answer every method.`);
+        for (const entry of method) {
+            if (entry === 'all') {
+                fail(`src/routes.ts: ${name} has 'all' inside a \`method\` list — use \`method: 'all'\`, or list the methods it answers.`);
+            }
+            validateMethod(entry, name);
+        }
+        return;
+    }
+    if (typeof method !== 'string' || !METHODS.has(method)) {
+        const meantHead = typeof method === 'string' && method.toLowerCase() === 'head';
+        fail(`src/routes.ts: ${name} has method ${JSON.stringify(method)}, which is not one of ${[...METHODS].join(', ')}.` +
+            (meantHead ? " A HEAD is dispatched as a GET, so use 'get' — a route registered for HEAD alone answers neither." : ''));
+    }
+}
+/** The methods a route answers, with `'all'` expanded and a list flattened, so two can be compared. */
+function methodsOf(route) {
+    // A page is registered for GET and POST: the POST is how a `<form action={serverAction}>` reaches it.
+    if (isPageRoute(route))
+        return ['get', 'post'];
+    const methods = [route.method ?? 'all'].flat();
+    return methods.includes('all') ? CONCRETE_METHODS : methods;
+}
+/**
+ * A parameter's *name*, which is not part of the pattern Hono matches on. Anchored to a segment boundary so
+ * a `:` inside a `{regex}` constraint is not mistaken for one, and stopped by `{` and `?` — both of which
+ * *are* part of the pattern and have to survive into the key.
+ */
+const PARAM_NAME = /(?<=\/):[^/{?]+/g;
+/**
+ * What Hono matches on, rather than what was typed — so two spellings of one pattern hash alike.
+ *
+ * - **A parameter's name is not part of it.** `/u/:id` and `/u/:name` are one route, and whichever is
+ *   registered second never runs. A `{regex}` constraint is kept, because that one *is* part of the
+ *   pattern: `/a/:id{[0-9]+}` and `/a/:name` are genuinely different routes and both can answer.
+ * - **A `*` before the last segment matches exactly one non-empty segment** — the same thing an
+ *   unconstrained parameter matches. Checked against Hono 4.13: `/a/[*]/c` and `/a/:id/c` both answer
+ *   `/a/b/c`, both 404 `/a//c`, and both 404 `/a/b/x/c`.
+ *
+ * A *trailing* `*` is left alone: it claims a whole subtree rather than one segment, which is
+ * {@link subtreeOf}'s half of the job.
+ */
+function patternKey(path) {
+    const segments = path.replace(PARAM_NAME, ':').split('/');
+    return segments.map((segment, index) => (segment === '*' && index < segments.length - 1 ? ':' : segment)).join('/');
+}
+/**
+ * Every key a route answers. More than one only for a trailing optional parameter: `/a/:id?` answers
+ * `/a/x` *and* `/a`, and — checked — neither `/a/` nor `/a/x/y`. Both have to be spoken for before it is
+ * dead, which is why this is a list rather than a key.
+ */
+function keysFor(path) {
+    const key = patternKey(path);
+    if (!key.endsWith('/:?'))
+        return [key];
+    return [key.slice(0, -1), key.slice(0, -3) || '/'];
+}
+/**
+ * The subtree a trailing `*` claims, or `null` for a path without one. `/a/*` answers `/a/b` and
+ * `/a/b/c/d`, and the bare `/a` as well — but not `/ab`, so the boundary is the `/` and a prefix test has
+ * to respect it.
+ */
+function subtreeOf(key) {
+    return key.endsWith('/*') ? key.slice(0, -2) : null;
+}
+/** Whether the subtree claimed by a trailing `*` at `prefix` contains `key`. */
+function covers(prefix, key) {
+    return key === prefix || key.startsWith(`${prefix}/`);
+}
+/**
+ * Whether a path sits inside {@link RESERVED_PREFIX}'s subtree, which is the prefix and everything below
+ * it. The boundary is the `/`: `/_staticky` is an ordinary path and answers normally.
+ */
+function isReserved(path) {
+    return path === RESERVED_PREFIX || path.startsWith(`${RESERVED_PREFIX}/`);
+}
+/**
+ * Refuses a route the table already answers in full, or that the framework's own mount already answers.
+ * Hono matches in registration order, so a later entry whose every method and path is spoken for is dead
+ * code — and the build that produced it exits 0 with nothing to say, which is how a duplicated `path`
+ * survives.
+ *
+ * The framework's mount is checked first and by name. The rest of this function compares the app's routes
+ * with *each other*, so the prefixes the framework registers ahead of them were invisible to it: a route at
+ * `/_static/thing` built clean and then 404'd, on every target and in dev. Only a literal path is refused —
+ * a parameterised route that happens to match under the prefix, `/:section/thing` or a root `/*`, still
+ * answers everything else and is none of this rule's business.
+ *
+ * Method by method, and only when *all* of them are taken: one path split between a `'get'` endpoint and a
+ * `'post'` one shadows nothing, and neither does a catch-all registered behind a route that claims one
+ * method of it — that one still answers the rest.
+ *
+ * Keyed on the *pattern* rather than on the path as written, because a dead route need not be a duplicated
+ * string. Two shapes reached a build this way: `/u/:id` followed by `/u/:name`, which is the same route
+ * twice under two spellings, and a wildcard registered *ahead* of a concrete path — `/a/*` then `/a/b` —
+ * where the second can never be reached. The doc comment above used to discuss only the opposite order, a
+ * catch-all registered behind a route, which is the case that is fine.
+ *
+ * **Where the line is drawn**, for whoever widens this next. A `{regex}` constraint is kept in the key and
+ * compared as text, so `/a/:id{[0-9]+}` then `/a/:n{[0-9]+}` is caught and `/a/:id{[0-9]+}` then
+ * `/a/:id{\d+}` is not — the second pair is equivalent, and the later route is dead, and this accepts it.
+ * Deciding regex equivalence in general is undecidable-adjacent and not a route validator's job. The same
+ * goes for a constraint containing a `/`, which the key carries through unchanged rather than interpreting.
+ * Both leave the error on the safe side: an unreachable route slips through, and a route that can still
+ * answer is never refused. Anything added here should keep that asymmetry — a false refusal fails a build
+ * that was correct, which is much worse than the hole it would close.
+ */
+function assertNothingIsShadowed(routes) {
+    /** `"<method> <key>"` → the first route answering it. */
+    const claimed = new Map();
+    /** The trailing-`*` routes already registered, which claim a whole subtree rather than single keys. */
+    const subtrees = [];
+    const claimantOf = (method, key) => claimed.get(`${method} ${key}`) ?? subtrees.find((subtree) => subtree.method === method && covers(subtree.prefix, key));
+    routes.forEach((route, index) => {
+        const name = label(route, index);
+        if (isReserved(route.path)) {
+            fail(`src/routes.ts: ${name} would never run — the framework serves the client bundle at ${RESERVED_PREFIX}, ` +
+                `mounted ahead of the route table and answering that whole subtree, so ${RESERVED_PREFIX} is reserved on every ` +
+                'deploy target and under `rshono dev`. Give the route a path of its own.');
+        }
+        const methods = methodsOf(route);
+        const keys = keysFor(route.path);
+        const claimants = methods.flatMap((method) => keys.map((key) => claimantOf(method, key)));
+        if (claimants.every((claimant) => claimant !== undefined)) {
+            const by = [...new Set(claimants.map((claimant) => claimant.name))].join(' and ');
+            const verbs = methods.map((method) => method.toUpperCase()).join(', ');
+            // Only when the two are spelled differently, which is the part that reads as a false alarm: an exact
+            // duplicate needs no explaining, and this sentence would only get in its way.
+            const why = claimants.some((claimant) => claimant.path === route.path)
+                ? ''
+                : ' Hono matches on the pattern, not the spelling — a parameter’s name is not part of it, and a trailing `*` answers its whole subtree, the bare prefix included.';
+            fail(`src/routes.ts: ${name} would never run — ${by} already answers ${verbs} ${route.path}, and Hono matches in registration order.${why}`);
+        }
+        for (const method of methods) {
+            for (const key of keys) {
+                if (!claimed.has(`${method} ${key}`))
+                    claimed.set(`${method} ${key}`, { name, path: route.path });
+            }
+            const prefix = subtreeOf(patternKey(route.path));
+            if (prefix !== null)
+                subtrees.push({ method, prefix, name, path: route.path });
+        }
+    });
+}
+function validateFallbackPage(page, field) {
+    if (page === undefined || page === null)
+        return;
+    if (typeof page !== 'object' || typeof page.component !== 'function') {
+        fail(`src/routes.ts: \`${field}\` must be a page — \`{ component: () => import('./pages/${field}') }\`.`);
+    }
+}
+/**
+ * Normalises and checks what `src/routes.ts` exported as `routes`.
+ *
+ * A bare array is accepted alongside a {@link RouteConfig}, because the docs present both and
+ * `defineRoutes` is an identity function over the array form — which makes leaving it off look equivalent
+ * right up to the point the build fails somewhere unrelated.
+ */
+export function validateRoutesModule(exported) {
+    const config = (Array.isArray(exported) ? { routes: exported } : exported);
+    if (config === null || config === undefined || typeof config !== 'object' || !Array.isArray(config.routes)) {
+        fail('src/routes.ts must export `routes` as a route array, or as a { routes, notFound?, error? } object — ' +
+            'wrap it in `defineRoutes(…)` to have TypeScript check it for you.');
+    }
+    config.routes.forEach(validateRoute);
+    assertNothingIsShadowed(config.routes);
+    validateFallbackPage(config.notFound, 'notFound');
+    validateFallbackPage(config.error, 'error');
+    return config;
+}
+/**
+ * The Hono app `src/server.ts` default-exports, or `null` for an app that has no `src/server.ts` — the
+ * fallback module the alias resolves to instead default-exports exactly that.
+ *
+ * Duck-typed rather than `instanceof Hono`: what the framework does with the value is `app.route('/', …)`,
+ * which reads `routes` off it and mounts the handlers, so those are what have to be there.
+ */
+export function validateServerApp(exported) {
+    const app = exported?.default;
+    if (app === null || app === undefined)
+        return null;
+    if (typeof app !== 'object' || typeof app.fetch !== 'function' || !Array.isArray(app.routes)) {
+        fail('src/server.ts must `export default` a Hono app — `const server = new Hono(); … export default server;`.');
+    }
+    return app;
+}
+/**
+ * The server component a page module must default-export, checked rather than cast.
+ *
+ * Two structural mistakes land here, and neither can serve *any* request, which is why they are also checked
+ * at build time by {@link assertRouteModules}:
+ *
+ * - no default export at all — a named `export function Page`, or a file that exports its layout instead;
+ * - a `'use client'` page. That module's default export is a client reference, so it carries no
+ *   `entryJsFiles` — the list of scripts the document has to boot, recorded only for a *server* entry.
+ *   Rendering it anyway would produce a page with no client runtime, which is worse than a message.
+ */
+export function assertPageModule(mod, label) {
+    const Page = mod.default;
+    if (typeof Page !== 'function') {
+        fail(`The page module for ${label} must default-export a server component.`);
+    }
+    if (!Page.entryJsFiles) {
+        fail(`The page component for ${label} is missing its client-asset info ('use server-entry'). ` +
+            "The directive is added automatically for inline `component: () => import('…')` thunks in routes.ts. " +
+            "If this page is wired up another way, put 'use server-entry' on the first line of the page module yourself — " +
+            "and make sure the page is a server component (a 'use client' page must be wrapped by a server component instead).");
+    }
+    return Page;
+}
+/**
+ * The Hono handler an endpoint module must export as `handler`.
+ *
+ * The page half of this fork has been checked since it existed; this half used to destructure and call, which
+ * turns the one mistake people actually make — a method-named export, the shape other frameworks ask for —
+ * into `TypeError: r is not a function` from a minified frame. That is verbatim the failure mode this file's
+ * header names as the reason it exists.
+ */
+export function assertEndpointModule(mod, label) {
+    const handler = mod.handler;
+    if (typeof handler !== 'function') {
+        fail(`The endpoint module for ${label} must export \`handler\` — \`export const handler: Handler = (c) => c.json({ ok: true });\`. ` +
+            'One `handler` answers every method the route declares, so a method-named export (`GET`, `POST`) is never read.');
+    }
+    return handler;
+}
+/**
+ * Resolves every route's own module once and runs the two checks above against it — what `rshono build` does
+ * once the bundle exists, so a route that cannot serve *any* request fails the build instead of exiting 0 and
+ * answering 500 in production for the life of the deployment.
+ *
+ * Every route is checked, not just the first that fails: these are all fixed by editing a file, and a build
+ * that names one of four broken routes costs three more builds to get through.
+ *
+ * A module that throws while *evaluating* is warned about rather than raised. Checking a module's shape means
+ * importing it, and whether an import succeeds is a question about the environment, not about the module: a
+ * page whose module scope reads a secret, opens a connection or touches a file that only exists in production
+ * fails here and works per request. Failing the build on that would make "every route module must be
+ * importable during the build" a new requirement on apps, to catch a mistake this cannot tell from a
+ * deliberate one. A `render: 'static'` route is the exception, and needs nothing here: it promised to render
+ * at build time, so the prerender pass demands the import and fails the build when it throws.
+ */
+export async function assertRouteModules(config) {
+    const failures = [];
+    /**
+     * Loads one route's module, or reports why it could not be checked. `null` — never a silent skip: the
+     * whole point of running at build time is saying what was and was not looked at.
+     */
+    const load = async (thunk, label) => {
+        try {
+            return await thunk();
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            console.warn(`  ⚠ ${label} could not be loaded at build time, so its module was not checked — ${reason}`);
+            return null;
+        }
+    };
+    /** Keeps a check's message instead of raising it, so every broken route is named rather than the first. */
+    const check = (assert) => {
+        try {
+            assert();
+        }
+        catch (error) {
+            failures.push(error instanceof Error ? error.message : String(error));
+        }
+    };
+    for (const route of config.routes) {
+        const label = `"${route.path}"`;
+        if (isPageRoute(route)) {
+            const mod = await load(route.component, label);
+            if (mod)
+                check(() => assertPageModule(mod, label));
+        }
+        else {
+            const mod = await load(route.server, label);
+            if (mod)
+                check(() => assertEndpointModule(mod, label));
+        }
+    }
+    for (const [page, label] of [
+        [config.notFound, 'the notFound page'],
+        [config.error, 'the error page'],
+    ]) {
+        if (!page)
+            continue;
+        const mod = await load(page.component, label);
+        if (mod)
+            check(() => assertPageModule(mod, label));
+    }
+    // One failure — overwhelmingly the common case — is raised as itself, so the message reads the way it
+    // does on the request path. Several are gathered under a count, each stripped of the prefix the whole
+    // list now carries once.
+    if (failures.length === 1)
+        throw new Error(failures[0]);
+    if (failures.length > 1) {
+        fail(`${failures.length} route modules cannot serve a request:\n` +
+            failures.map((message) => `      • ${message.replace(/^\[rshono\] /, '')}`).join('\n'));
+    }
+}
+//# sourceMappingURL=validate-entries.js.map

package/dist/runtime/validate-entries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-entries.js","sourceRoot":"","sources":["../../src/runtime/validate-entries.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The two modules an app hands the framework — `src/routes.ts` and `src/server.ts` — checked before\n * anything is built on them.\n *\n * Both arrive through a build-time alias that carries no type the compiler can hold on to, so they used to\n * be cast and the mistake found later, somewhere else: a `routes` array that skipped `defineRoutes` surfaced\n * as `TypeError: nN is not iterable` from a minified bundle, and a `src/server.ts` exporting the wrong thing\n * as `Cannot read properties of undefined (reading 'map')` from inside Hono. Neither names the file to open.\n * The mistakes that produced no error at all were worse: a duplicated `path` whose second entry silently\n * never ran, a `staticPaths` on a route that renders per request.\n *\n * The route *table* is checked at module load — during `rshono build`, which imports the server bundle for\n * the prerender pass; at `rshono dev` startup; and when a deployed server boots. The modules the table points\n * *at* cannot be, because they load lazily: {@link assertPageModule} and {@link assertEndpointModule} run on\n * first request, and {@link assertRouteModules} runs both against every route during `rshono build`.\n */\n\nimport type { Handler, Hono } from 'hono';\nimport type { ServerEntry } from 'react-server-dom-rspack/server';\nimport { isPageRoute, type PageComponent, type Route, type RouteConfig } from '../router.js';\n\n/** Every method an endpoint route can name, `'all'` aside — which is also what `'all'` is expanded to below. */\nconst CONCRETE_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options'];\nconst METHODS = new Set([...CONCRETE_METHODS, 'all']);\n\n/** What a page route's `render` accepts. */\nconst RENDER_MODES = ['static', 'dynamic'];\n\n/**\n * The one path prefix the framework claims on every deploy target: the hashed client bundle, mounted by\n * `runtime.mountStaticAssets` ahead of the route table, ending in a terminal 404 — so nothing under it\n * reaches a page. Written out here rather than imported, because the mounts live in the deploy runtimes\n * (`deploy/filesystem.ts`, `deploy/cloudflare/runtime.ts`) and in `cli/dev.ts`, none of which this module\n * can pull in.\n *\n * It is the only one. `/_rshono/hmr` is dev-only and an exact path rather than a prefix, and Cloudflare's\n * `__ssg` is an asset path no app would name.\n */\nconst RESERVED_PREFIX = '/_static';\n\nfunction fail(message: string): never {\n  throw new Error(`[rshono] ${message}`);\n}\n\n/**\n * How a route is named in a message. Always by position, because that is what a duplicate `path` needs to be\n * told apart, and by path as well wherever there is one.\n */\nfunction label(route: unknown, index: number): string {\n  const path = (route as { path?: unknown } | null)?.path;\n  return typeof path === 'string' ? `routes[${index}] (\"${path}\")` : `routes[${index}]`;\n}\n\n/** Refuses a key that belongs to the *other* kind of route — see {@link validateRoute}. */\nfunction refuseForeignKeys(route: Record<string, unknown>, name: string, keys: readonly string[], advice: string): void {\n  for (const key of keys) {\n    if (route[key] !== undefined) fail(`src/routes.ts: ${name} has \\`${key}\\`, which ${advice}`);\n  }\n}\n\n/**\n * Checks one entry of the route table.\n *\n * The cross-kind key checks are the ones TypeScript cannot make: excess-property checking against a union\n * accepts any key present in *some* member, so `staticPaths` on an `{ type: 'endpoint' }` route type-checks\n * and is then ignored at runtime — which is indistinguishable from prerendering that quietly does nothing.\n */\nfunction validateRoute(route: unknown, index: number): void {\n  if (route === null || typeof route !== 'object') {\n    fail(`src/routes.ts: routes[${index}] is ${route === null ? 'null' : typeof route}, not a route object.`);\n  }\n  const entry = route as Record<string, unknown>;\n  const name = label(route, index);\n\n  if (typeof entry.path !== 'string' || !entry.path.startsWith('/')) {\n    fail(`src/routes.ts: ${name} needs a \\`path\\` starting with \"/\".`);\n  }\n  if (entry.type !== undefined && entry.type !== 'endpoint') {\n    fail(`src/routes.ts: ${name} has type ${JSON.stringify(entry.type)} — the only \\`type\\` is 'endpoint', and a page route omits it.`);\n  }\n\n  if (entry.type === 'endpoint') {\n    if (typeof entry.server !== 'function') {\n      fail(`src/routes.ts: ${name} is an endpoint, so it needs \\`server\\` — a function importing the module that exports \\`handler\\`.`);\n    }\n    if (entry.method !== undefined) validateMethod(entry.method, name);\n    refuseForeignKeys(\n      entry,\n      name,\n      ['component', 'render', 'staticPaths'],\n      \"only a page route has — an endpoint's `server` handler decides its own response.\",\n    );\n  } else {\n    if (typeof entry.component !== 'function') {\n      fail(`src/routes.ts: ${name} needs \\`component\\` — a function importing the page module, e.g. \\`() => import('./pages/home')\\`.`);\n    }\n    if (entry.render !== undefined && (typeof entry.render !== 'string' || !RENDER_MODES.includes(entry.render))) {\n      fail(`src/routes.ts: ${name} has render ${JSON.stringify(entry.render)} — it is 'static' or 'dynamic'.`);\n    }\n    if (entry.staticPaths !== undefined) {\n      if (typeof entry.staticPaths !== 'function') fail(`src/routes.ts: ${name} has a \\`staticPaths\\` that is not a function.`);\n      if (entry.render !== 'static') {\n        fail(`src/routes.ts: ${name} has \\`staticPaths\\` but is not \\`render: 'static'\\`, so it renders per request and the paths are never built.`);\n      }\n    }\n    refuseForeignKeys(entry, name, ['server', 'method'], \"only an endpoint route has — add `type: 'endpoint'` if that is what this is.\");\n  }\n}\n\n/**\n * Checks an endpoint's `method`, which is one method or a list of them.\n *\n * A list is checked member by member so the message names the bad one rather than printing the array, and\n * `'all'` is refused inside one: a list meaning every method is a list its author did not mean to write.\n */\nfunction validateMethod(method: unknown, name: string): void {\n  if (Array.isArray(method)) {\n    if (method.length === 0) fail(`src/routes.ts: ${name} has an empty \\`method\\` list — omit it to answer every method.`);\n    for (const entry of method as unknown[]) {\n      if (entry === 'all') {\n        fail(`src/routes.ts: ${name} has 'all' inside a \\`method\\` list — use \\`method: 'all'\\`, or list the methods it answers.`);\n      }\n      validateMethod(entry, name);\n    }\n    return;\n  }\n  if (typeof method !== 'string' || !METHODS.has(method)) {\n    const meantHead = typeof method === 'string' && method.toLowerCase() === 'head';\n    fail(\n      `src/routes.ts: ${name} has method ${JSON.stringify(method)}, which is not one of ${[...METHODS].join(', ')}.` +\n        (meantHead ? \" A HEAD is dispatched as a GET, so use 'get' — a route registered for HEAD alone answers neither.\" : ''),\n    );\n  }\n}\n\n/** The methods a route answers, with `'all'` expanded and a list flattened, so two can be compared. */\nfunction methodsOf(route: Route): readonly string[] {\n  // A page is registered for GET and POST: the POST is how a `<form action={serverAction}>` reaches it.\n  if (isPageRoute(route)) return ['get', 'post'];\n  const methods = [route.method ?? 'all'].flat();\n  return methods.includes('all') ? CONCRETE_METHODS : methods;\n}\n\n/**\n * A parameter's *name*, which is not part of the pattern Hono matches on. Anchored to a segment boundary so\n * a `:` inside a `{regex}` constraint is not mistaken for one, and stopped by `{` and `?` — both of which\n * *are* part of the pattern and have to survive into the key.\n */\nconst PARAM_NAME = /(?<=\\/):[^/{?]+/g;\n\n/**\n * What Hono matches on, rather than what was typed — so two spellings of one pattern hash alike.\n *\n * - **A parameter's name is not part of it.** `/u/:id` and `/u/:name` are one route, and whichever is\n *   registered second never runs. A `{regex}` constraint is kept, because that one *is* part of the\n *   pattern: `/a/:id{[0-9]+}` and `/a/:name` are genuinely different routes and both can answer.\n * - **A `*` before the last segment matches exactly one non-empty segment** — the same thing an\n *   unconstrained parameter matches. Checked against Hono 4.13: `/a/[*]/c` and `/a/:id/c` both answer\n *   `/a/b/c`, both 404 `/a//c`, and both 404 `/a/b/x/c`.\n *\n * A *trailing* `*` is left alone: it claims a whole subtree rather than one segment, which is\n * {@link subtreeOf}'s half of the job.\n */\nfunction patternKey(path: string): string {\n  const segments = path.replace(PARAM_NAME, ':').split('/');\n  return segments.map((segment, index) => (segment === '*' && index < segments.length - 1 ? ':' : segment)).join('/');\n}\n\n/**\n * Every key a route answers. More than one only for a trailing optional parameter: `/a/:id?` answers\n * `/a/x` *and* `/a`, and — checked — neither `/a/` nor `/a/x/y`. Both have to be spoken for before it is\n * dead, which is why this is a list rather than a key.\n */\nfunction keysFor(path: string): readonly string[] {\n  const key = patternKey(path);\n  if (!key.endsWith('/:?')) return [key];\n  return [key.slice(0, -1), key.slice(0, -3) || '/'];\n}\n\n/**\n * The subtree a trailing `*` claims, or `null` for a path without one. `/a/*` answers `/a/b` and\n * `/a/b/c/d`, and the bare `/a` as well — but not `/ab`, so the boundary is the `/` and a prefix test has\n * to respect it.\n */\nfunction subtreeOf(key: string): string | null {\n  return key.endsWith('/*') ? key.slice(0, -2) : null;\n}\n\n/** Whether the subtree claimed by a trailing `*` at `prefix` contains `key`. */\nfunction covers(prefix: string, key: string): boolean {\n  return key === prefix || key.startsWith(`${prefix}/`);\n}\n\n/**\n * Whether a path sits inside {@link RESERVED_PREFIX}'s subtree, which is the prefix and everything below\n * it. The boundary is the `/`: `/_staticky` is an ordinary path and answers normally.\n */\nfunction isReserved(path: string): boolean {\n  return path === RESERVED_PREFIX || path.startsWith(`${RESERVED_PREFIX}/`);\n}\n\n/**\n * Refuses a route the table already answers in full, or that the framework's own mount already answers.\n * Hono matches in registration order, so a later entry whose every method and path is spoken for is dead\n * code — and the build that produced it exits 0 with nothing to say, which is how a duplicated `path`\n * survives.\n *\n * The framework's mount is checked first and by name. The rest of this function compares the app's routes\n * with *each other*, so the prefixes the framework registers ahead of them were invisible to it: a route at\n * `/_static/thing` built clean and then 404'd, on every target and in dev. Only a literal path is refused —\n * a parameterised route that happens to match under the prefix, `/:section/thing` or a root `/*`, still\n * answers everything else and is none of this rule's business.\n *\n * Method by method, and only when *all* of them are taken: one path split between a `'get'` endpoint and a\n * `'post'` one shadows nothing, and neither does a catch-all registered behind a route that claims one\n * method of it — that one still answers the rest.\n *\n * Keyed on the *pattern* rather than on the path as written, because a dead route need not be a duplicated\n * string. Two shapes reached a build this way: `/u/:id` followed by `/u/:name`, which is the same route\n * twice under two spellings, and a wildcard registered *ahead* of a concrete path — `/a/*` then `/a/b` —\n * where the second can never be reached. The doc comment above used to discuss only the opposite order, a\n * catch-all registered behind a route, which is the case that is fine.\n *\n * **Where the line is drawn**, for whoever widens this next. A `{regex}` constraint is kept in the key and\n * compared as text, so `/a/:id{[0-9]+}` then `/a/:n{[0-9]+}` is caught and `/a/:id{[0-9]+}` then\n * `/a/:id{\\d+}` is not — the second pair is equivalent, and the later route is dead, and this accepts it.\n * Deciding regex equivalence in general is undecidable-adjacent and not a route validator's job. The same\n * goes for a constraint containing a `/`, which the key carries through unchanged rather than interpreting.\n * Both leave the error on the safe side: an unreachable route slips through, and a route that can still\n * answer is never refused. Anything added here should keep that asymmetry — a false refusal fails a build\n * that was correct, which is much worse than the hole it would close.\n */\nfunction assertNothingIsShadowed(routes: readonly Route[]): void {\n  /** `\"<method> <key>\"` → the first route answering it. */\n  const claimed = new Map<string, { name: string; path: string }>();\n  /** The trailing-`*` routes already registered, which claim a whole subtree rather than single keys. */\n  const subtrees: { method: string; prefix: string; name: string; path: string }[] = [];\n\n  const claimantOf = (method: string, key: string) =>\n    claimed.get(`${method} ${key}`) ?? subtrees.find((subtree) => subtree.method === method && covers(subtree.prefix, key));\n\n  routes.forEach((route, index) => {\n    const name = label(route, index);\n    if (isReserved(route.path)) {\n      fail(\n        `src/routes.ts: ${name} would never run — the framework serves the client bundle at ${RESERVED_PREFIX}, ` +\n          `mounted ahead of the route table and answering that whole subtree, so ${RESERVED_PREFIX} is reserved on every ` +\n          'deploy target and under `rshono dev`. Give the route a path of its own.',\n      );\n    }\n    const methods = methodsOf(route);\n    const keys = keysFor(route.path);\n    const claimants = methods.flatMap((method) => keys.map((key) => claimantOf(method, key)));\n    if (claimants.every((claimant) => claimant !== undefined)) {\n      const by = [...new Set(claimants.map((claimant) => claimant.name))].join(' and ');\n      const verbs = methods.map((method) => method.toUpperCase()).join(', ');\n      // Only when the two are spelled differently, which is the part that reads as a false alarm: an exact\n      // duplicate needs no explaining, and this sentence would only get in its way.\n      const why = claimants.some((claimant) => claimant.path === route.path)\n        ? ''\n        : ' Hono matches on the pattern, not the spelling — a parameter’s name is not part of it, and a trailing `*` answers its whole subtree, the bare prefix included.';\n      fail(`src/routes.ts: ${name} would never run — ${by} already answers ${verbs} ${route.path}, and Hono matches in registration order.${why}`);\n    }\n    for (const method of methods) {\n      for (const key of keys) {\n        if (!claimed.has(`${method} ${key}`)) claimed.set(`${method} ${key}`, { name, path: route.path });\n      }\n      const prefix = subtreeOf(patternKey(route.path));\n      if (prefix !== null) subtrees.push({ method, prefix, name, path: route.path });\n    }\n  });\n}\n\nfunction validateFallbackPage(page: unknown, field: 'notFound' | 'error'): void {\n  if (page === undefined || page === null) return;\n  if (typeof page !== 'object' || typeof (page as { component?: unknown }).component !== 'function') {\n    fail(`src/routes.ts: \\`${field}\\` must be a page — \\`{ component: () => import('./pages/${field}') }\\`.`);\n  }\n}\n\n/**\n * Normalises and checks what `src/routes.ts` exported as `routes`.\n *\n * A bare array is accepted alongside a {@link RouteConfig}, because the docs present both and\n * `defineRoutes` is an identity function over the array form — which makes leaving it off look equivalent\n * right up to the point the build fails somewhere unrelated.\n */\nexport function validateRoutesModule(exported: unknown): RouteConfig {\n  const config = (Array.isArray(exported) ? { routes: exported as Route[] } : exported) as RouteConfig | null | undefined;\n  if (config === null || config === undefined || typeof config !== 'object' || !Array.isArray(config.routes)) {\n    fail(\n      'src/routes.ts must export `routes` as a route array, or as a { routes, notFound?, error? } object — ' +\n        'wrap it in `defineRoutes(…)` to have TypeScript check it for you.',\n    );\n  }\n\n  config.routes.forEach(validateRoute);\n  assertNothingIsShadowed(config.routes);\n  validateFallbackPage(config.notFound, 'notFound');\n  validateFallbackPage(config.error, 'error');\n  return config;\n}\n\n/**\n * The Hono app `src/server.ts` default-exports, or `null` for an app that has no `src/server.ts` — the\n * fallback module the alias resolves to instead default-exports exactly that.\n *\n * Duck-typed rather than `instanceof Hono`: what the framework does with the value is `app.route('/', …)`,\n * which reads `routes` off it and mounts the handlers, so those are what have to be there.\n */\nexport function validateServerApp(exported: unknown): Hono | null {\n  const app = (exported as { default?: unknown } | null)?.default;\n  if (app === null || app === undefined) return null;\n  if (typeof app !== 'object' || typeof (app as Hono).fetch !== 'function' || !Array.isArray((app as Hono).routes)) {\n    fail('src/server.ts must `export default` a Hono app — `const server = new Hono(); … export default server;`.');\n  }\n  return app as Hono;\n}\n\n/**\n * The server component a page module must default-export, checked rather than cast.\n *\n * Two structural mistakes land here, and neither can serve *any* request, which is why they are also checked\n * at build time by {@link assertRouteModules}:\n *\n * - no default export at all — a named `export function Page`, or a file that exports its layout instead;\n * - a `'use client'` page. That module's default export is a client reference, so it carries no\n *   `entryJsFiles` — the list of scripts the document has to boot, recorded only for a *server* entry.\n *   Rendering it anyway would produce a page with no client runtime, which is worse than a message.\n */\nexport function assertPageModule(mod: { default?: unknown }, label: string): ServerEntry<PageComponent> {\n  const Page = mod.default as ServerEntry<PageComponent> | undefined;\n  if (typeof Page !== 'function') {\n    fail(`The page module for ${label} must default-export a server component.`);\n  }\n  if (!Page.entryJsFiles) {\n    fail(\n      `The page component for ${label} is missing its client-asset info ('use server-entry'). ` +\n        \"The directive is added automatically for inline `component: () => import('…')` thunks in routes.ts. \" +\n        \"If this page is wired up another way, put 'use server-entry' on the first line of the page module yourself — \" +\n        \"and make sure the page is a server component (a 'use client' page must be wrapped by a server component instead).\",\n    );\n  }\n  return Page;\n}\n\n/**\n * The Hono handler an endpoint module must export as `handler`.\n *\n * The page half of this fork has been checked since it existed; this half used to destructure and call, which\n * turns the one mistake people actually make — a method-named export, the shape other frameworks ask for —\n * into `TypeError: r is not a function` from a minified frame. That is verbatim the failure mode this file's\n * header names as the reason it exists.\n */\nexport function assertEndpointModule(mod: { handler?: unknown }, label: string): Handler {\n  const handler = mod.handler;\n  if (typeof handler !== 'function') {\n    fail(\n      `The endpoint module for ${label} must export \\`handler\\` — \\`export const handler: Handler = (c) => c.json({ ok: true });\\`. ` +\n        'One `handler` answers every method the route declares, so a method-named export (`GET`, `POST`) is never read.',\n    );\n  }\n  return handler as Handler;\n}\n\n/**\n * Resolves every route's own module once and runs the two checks above against it — what `rshono build` does\n * once the bundle exists, so a route that cannot serve *any* request fails the build instead of exiting 0 and\n * answering 500 in production for the life of the deployment.\n *\n * Every route is checked, not just the first that fails: these are all fixed by editing a file, and a build\n * that names one of four broken routes costs three more builds to get through.\n *\n * A module that throws while *evaluating* is warned about rather than raised. Checking a module's shape means\n * importing it, and whether an import succeeds is a question about the environment, not about the module: a\n * page whose module scope reads a secret, opens a connection or touches a file that only exists in production\n * fails here and works per request. Failing the build on that would make \"every route module must be\n * importable during the build\" a new requirement on apps, to catch a mistake this cannot tell from a\n * deliberate one. A `render: 'static'` route is the exception, and needs nothing here: it promised to render\n * at build time, so the prerender pass demands the import and fails the build when it throws.\n */\nexport async function assertRouteModules(config: RouteConfig): Promise<void> {\n  const failures: string[] = [];\n\n  /**\n   * Loads one route's module, or reports why it could not be checked. `null` — never a silent skip: the\n   * whole point of running at build time is saying what was and was not looked at.\n   */\n  const load = async <T>(thunk: () => Promise<T>, label: string): Promise<T | null> => {\n    try {\n      return await thunk();\n    } catch (error) {\n      const reason = error instanceof Error ? error.message : String(error);\n      console.warn(`  ⚠ ${label} could not be loaded at build time, so its module was not checked — ${reason}`);\n      return null;\n    }\n  };\n\n  /** Keeps a check's message instead of raising it, so every broken route is named rather than the first. */\n  const check = (assert: () => void): void => {\n    try {\n      assert();\n    } catch (error) {\n      failures.push(error instanceof Error ? error.message : String(error));\n    }\n  };\n\n  for (const route of config.routes) {\n    const label = `\"${route.path}\"`;\n    if (isPageRoute(route)) {\n      const mod = await load(route.component, label);\n      if (mod) check(() => assertPageModule(mod, label));\n    } else {\n      const mod = await load(route.server, label);\n      if (mod) check(() => assertEndpointModule(mod, label));\n    }\n  }\n  for (const [page, label] of [\n    [config.notFound, 'the notFound page'],\n    [config.error, 'the error page'],\n  ] as const) {\n    if (!page) continue;\n    const mod = await load(page.component, label);\n    if (mod) check(() => assertPageModule(mod, label));\n  }\n\n  // One failure — overwhelmingly the common case — is raised as itself, so the message reads the way it\n  // does on the request path. Several are gathered under a count, each stripped of the prefix the whole\n  // list now carries once.\n  if (failures.length === 1) throw new Error(failures[0]);\n  if (failures.length > 1) {\n    fail(\n      `${failures.length} route modules cannot serve a request:\\n` +\n        failures.map((message) => `      • ${message.replace(/^\\[rshono\\] /, '')}`).join('\\n'),\n    );\n  }\n}\n"]}