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

package/dist/deploy/public-paths.d.ts

@@ -0,0 +1,42 @@
+import { type Route } from '../router.js';
+/**
+ * The request paths a `public/` tree answers, and the collisions with the route table that only show up
+ * after a deploy.
+ *
+ * `DeployRuntime.mountPublicFallback` registers `public/` **after** every route, so it answers only what no
+ * route claimed. That is the whole story on `node` and `aws-lambda`, where the app owns the URL surface. On
+ * the two targets with a CDN in front, `public/` is part of the static output and the platform answers from
+ * it **before** the app is invoked:
+ *
+ * - **vercel** — `{ handle: 'filesystem' }` sits ahead of the catch-all in `config.json`, by construction.
+ * - **cloudflare** — Workers Assets is checked first, which the generated `wrangler.jsonc` says out loud.
+ *
+ * So an app with `public/about.html` and a page route at `/about.html` renders the page under `rshono dev`
+ * and `rshono start`, and serves the file on those two — a behaviour difference discovered by deploying. A
+ * `public/index.html` beside a page route at `/` is the same collision, on the one path every app has.
+ *
+ * The framework cannot reorder either platform, so this is a build-time warning: the build knows both sides
+ * and comparing them is a set lookup.
+ */
+/** `.html` files are also reachable without the extension where the platform's HTML handling does that. */
+export interface PublicPathOptions {
+    /**
+     * Whether `public/about.html` also answers `/about`. True on Cloudflare, whose Workers Assets defaults to
+     * `auto-trailing-slash` HTML handling; false on Vercel, which serves the file at its own path unless the
+     * project turns `cleanUrls` on. Getting this wrong in the permissive direction is a warning about a
+     * collision the platform does not have, which is the noise that gets a check ignored.
+     */
+    htmlExtensionless: boolean;
+}
+/**
+ * The literal route paths a `public/` file would answer instead, on a target whose platform serves the
+ * static output first — `[]` when there is no `public/` directory or nothing collides.
+ *
+ * Literal paths only. A `public/` file landing inside a parameterised route's pattern is a real collision
+ * too, but deciding it needs the router rather than a set, and the paths every app actually writes files
+ * beside — `/`, `/about`, `/favicon.ico` — are literal. The limit is here rather than in the message
+ * because a reader of the message can do nothing with it.
+ */
+export declare function publicRouteCollisions(publicDir: string | null, routes: readonly Route[], options: PublicPathOptions): string[];
+/** The warning both CDN presets print, so the two say the same thing about the same problem. */
+export declare function warnAboutPublicCollisions(collisions: string[], target: string): void;

package/dist/deploy/public-paths.js

@@ -0,0 +1,66 @@
+import { readdirSync } from 'node:fs';
+import { join, posix } from 'node:path';
+import { isPageRoute } from '../router.js';
+/** Every file in a directory tree, as a `/`-separated path relative to its root. */
+function filesUnder(root, prefix = '') {
+    const found = [];
+    for (const entry of readdirSync(join(root, prefix), { withFileTypes: true })) {
+        const rel = prefix ? posix.join(prefix, entry.name) : entry.name;
+        if (entry.isDirectory())
+            found.push(...filesUnder(root, rel));
+        else if (entry.isFile())
+            found.push(rel);
+    }
+    return found;
+}
+/**
+ * The request paths one `public/` file is served at — its own, plus the extra ones a platform's HTML
+ * handling adds. The same normalisation `ssgFilePath` does for a prerendered page, in the other direction:
+ * a check keyed on raw filenames would miss `/` for `index.html` and would be wrong about the rest.
+ *
+ * Deliberately not exhaustive. It lists what a file is *certainly* reachable at, because a false warning
+ * about a route that works is worse than the collision it would have caught — the same asymmetry
+ * `assertNothingIsShadowed` keeps.
+ */
+function pathsFor(file, options) {
+    const paths = [`/${file}`];
+    const index = file === 'index.html' ? '' : file.endsWith('/index.html') ? file.slice(0, -'/index.html'.length) : null;
+    if (index !== null)
+        paths.push(`/${index}`, `/${index}/`);
+    else if (options.htmlExtensionless && file.endsWith('.html'))
+        paths.push(`/${file.slice(0, -'.html'.length)}`);
+    return [...new Set(paths)];
+}
+/**
+ * The literal route paths a `public/` file would answer instead, on a target whose platform serves the
+ * static output first — `[]` when there is no `public/` directory or nothing collides.
+ *
+ * Literal paths only. A `public/` file landing inside a parameterised route's pattern is a real collision
+ * too, but deciding it needs the router rather than a set, and the paths every app actually writes files
+ * beside — `/`, `/about`, `/favicon.ico` — are literal. The limit is here rather than in the message
+ * because a reader of the message can do nothing with it.
+ */
+export function publicRouteCollisions(publicDir, routes, options) {
+    if (publicDir === null)
+        return [];
+    const claimed = new Map(routes.filter((route) => !route.path.includes(':') && !route.path.includes('*')).map((route) => [route.path, route]));
+    const collisions = [];
+    for (const file of filesUnder(publicDir)) {
+        for (const path of pathsFor(file, options)) {
+            const route = claimed.get(path);
+            if (route)
+                collisions.push(`public/${file} answers ${path}, which ${isPageRoute(route) ? 'a page' : 'an endpoint'} route claims`);
+        }
+    }
+    return collisions;
+}
+/** The warning both CDN presets print, so the two say the same thing about the same problem. */
+export function warnAboutPublicCollisions(collisions, target) {
+    if (collisions.length === 0)
+        return;
+    console.warn(`  ⚠ ${collisions.length} public/ file(s) shadow a route on ${target}, where the CDN answers before the app is invoked:`);
+    for (const line of collisions)
+        console.warn(`    ${line}`);
+    console.warn(`    Under \`rshono dev\` and \`rshono start\` the route wins instead, so this only appears once deployed.`);
+}
+//# sourceMappingURL=public-paths.js.map

package/dist/deploy/public-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-paths.js","sourceRoot":"","sources":["../../src/deploy/public-paths.ts"],"names":[],"mappings":"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","sourcesContent":["import { readdirSync } from 'node:fs';\nimport { join, posix } from 'node:path';\nimport { isPageRoute, type Route } from '../router.js';\n\n/**\n * The request paths a `public/` tree answers, and the collisions with the route table that only show up\n * after a deploy.\n *\n * `DeployRuntime.mountPublicFallback` registers `public/` **after** every route, so it answers only what no\n * route claimed. That is the whole story on `node` and `aws-lambda`, where the app owns the URL surface. On\n * the two targets with a CDN in front, `public/` is part of the static output and the platform answers from\n * it **before** the app is invoked:\n *\n * - **vercel** — `{ handle: 'filesystem' }` sits ahead of the catch-all in `config.json`, by construction.\n * - **cloudflare** — Workers Assets is checked first, which the generated `wrangler.jsonc` says out loud.\n *\n * So an app with `public/about.html` and a page route at `/about.html` renders the page under `rshono dev`\n * and `rshono start`, and serves the file on those two — a behaviour difference discovered by deploying. A\n * `public/index.html` beside a page route at `/` is the same collision, on the one path every app has.\n *\n * The framework cannot reorder either platform, so this is a build-time warning: the build knows both sides\n * and comparing them is a set lookup.\n */\n\n/** `.html` files are also reachable without the extension where the platform's HTML handling does that. */\nexport interface PublicPathOptions {\n  /**\n   * Whether `public/about.html` also answers `/about`. True on Cloudflare, whose Workers Assets defaults to\n   * `auto-trailing-slash` HTML handling; false on Vercel, which serves the file at its own path unless the\n   * project turns `cleanUrls` on. Getting this wrong in the permissive direction is a warning about a\n   * collision the platform does not have, which is the noise that gets a check ignored.\n   */\n  htmlExtensionless: boolean;\n}\n\n/** Every file in a directory tree, as a `/`-separated path relative to its root. */\nfunction filesUnder(root: string, prefix = ''): string[] {\n  const found: string[] = [];\n  for (const entry of readdirSync(join(root, prefix), { withFileTypes: true })) {\n    const rel = prefix ? posix.join(prefix, entry.name) : entry.name;\n    if (entry.isDirectory()) found.push(...filesUnder(root, rel));\n    else if (entry.isFile()) found.push(rel);\n  }\n  return found;\n}\n\n/**\n * The request paths one `public/` file is served at — its own, plus the extra ones a platform's HTML\n * handling adds. The same normalisation `ssgFilePath` does for a prerendered page, in the other direction:\n * a check keyed on raw filenames would miss `/` for `index.html` and would be wrong about the rest.\n *\n * Deliberately not exhaustive. It lists what a file is *certainly* reachable at, because a false warning\n * about a route that works is worse than the collision it would have caught — the same asymmetry\n * `assertNothingIsShadowed` keeps.\n */\nfunction pathsFor(file: string, options: PublicPathOptions): string[] {\n  const paths = [`/${file}`];\n  const index = file === 'index.html' ? '' : file.endsWith('/index.html') ? file.slice(0, -'/index.html'.length) : null;\n  if (index !== null) paths.push(`/${index}`, `/${index}/`);\n  else if (options.htmlExtensionless && file.endsWith('.html')) paths.push(`/${file.slice(0, -'.html'.length)}`);\n  return [...new Set(paths)];\n}\n\n/**\n * The literal route paths a `public/` file would answer instead, on a target whose platform serves the\n * static output first — `[]` when there is no `public/` directory or nothing collides.\n *\n * Literal paths only. A `public/` file landing inside a parameterised route's pattern is a real collision\n * too, but deciding it needs the router rather than a set, and the paths every app actually writes files\n * beside — `/`, `/about`, `/favicon.ico` — are literal. The limit is here rather than in the message\n * because a reader of the message can do nothing with it.\n */\nexport function publicRouteCollisions(publicDir: string | null, routes: readonly Route[], options: PublicPathOptions): string[] {\n  if (publicDir === null) return [];\n  const claimed = new Map(routes.filter((route) => !route.path.includes(':') && !route.path.includes('*')).map((route) => [route.path, route]));\n  const collisions: string[] = [];\n  for (const file of filesUnder(publicDir)) {\n    for (const path of pathsFor(file, options)) {\n      const route = claimed.get(path);\n      if (route) collisions.push(`public/${file} answers ${path}, which ${isPageRoute(route) ? 'a page' : 'an endpoint'} route claims`);\n    }\n  }\n  return collisions;\n}\n\n/** The warning both CDN presets print, so the two say the same thing about the same problem. */\nexport function warnAboutPublicCollisions(collisions: string[], target: string): void {\n  if (collisions.length === 0) return;\n  console.warn(`  ⚠ ${collisions.length} public/ file(s) shadow a route on ${target}, where the CDN answers before the app is invoked:`);\n  for (const line of collisions) console.warn(`    ${line}`);\n  console.warn(`    Under \\`rshono dev\\` and \\`rshono start\\` the route wins instead, so this only appears once deployed.`);\n}\n"]}

package/dist/deploy/vercel/build.d.ts

@@ -1,3 +1,2 @@
 import type { DeployBuildContext } from '../presets.js';
 export declare function finalizeVercelBuild(ctx: DeployBuildContext): Promise<void>;
-//# sourceMappingURL=build.d.ts.map

package/dist/deploy/vercel/build.js

@@ -1,24 +1,22 @@
 import { cpSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { rm } from 'node:fs/promises';
 import { join } from 'node:path';
+import { publicRouteCollisions, warnAboutPublicCollisions } from '../public-paths.js';
 /**
- * The Build Output API v3 layout, which is what `vercel deploy --prebuilt` uploads verbatim. Producing
- * it directly means Vercel runs no build of its own — everything it needs already exists.
+ * The Build Output API v3 layout, which `vercel deploy --prebuilt` uploads verbatim — producing it directly
+ * means Vercel runs no build of its own.
  */
 const OUTPUT_DIR = join('.vercel', 'output');
 const FUNCTION_DIR = join('functions', 'index.func');
 /**
- * The function's own view of the build.
- *
- * `dist/server/main.mjs` is kept at that exact path inside the function because the runtime derives the
- * project root from where the bundle sits (see `deploy/filesystem.ts`) — so `dist/ssg` and `dist/public`
- * land where it already looks for them, and no runtime code needs to know it is on Vercel.
+ * The bundle keeps this exact path inside the function because the runtime derives the project root from where
+ * it sits (see `deploy/filesystem.ts`), so `dist/ssg` and `dist/public` land where it already looks — and no
+ * runtime code needs to know it is on Vercel.
  */
 const HANDLER = 'dist/server/main.mjs';
 /**
- * Routes, in the order Vercel evaluates them: hashed assets get the immutable header the CDN cannot
- * infer, then anything present in the static output is served from it, and whatever is left is the
- * app's to render.
+ * Routes, in the order Vercel evaluates them: hashed assets get the immutable header the CDN cannot infer,
+ * then anything in the static output is served from it, and whatever is left is the app's to render.
  */
 const ROUTES = [
     { src: '^/_static/(.*)$', headers: { 'cache-control': 'public, max-age=31536000, immutable' }, continue: true },
@@ -29,7 +27,7 @@ export async function finalizeVercelBuild(ctx) {
     const outputDir = join(ctx.rootDir, OUTPUT_DIR);
     const staticOut = join(outputDir, 'static');
     const functionDir = join(outputDir, FUNCTION_DIR);
-    // Rebuilt from scratch, so a deleted page or asset cannot survive in the uploaded output.
+    // From scratch, so a deleted page or asset cannot survive in the uploaded output.
     await rm(outputDir, { recursive: true, force: true });
     mkdirSync(staticOut, { recursive: true });
     mkdirSync(functionDir, { recursive: true });
@@ -37,17 +35,28 @@ export async function finalizeVercelBuild(ctx) {
     cpSync(ctx.staticDir, join(staticOut, '_static'), { recursive: true });
     if (ctx.publicDir)
         cpSync(ctx.publicDir, staticOut, { recursive: true });
-    // Shipped inside the function: the bundle, plus the two things it reads from disk at request time.
+    // `{ handle: 'filesystem' }` is ahead of the function by construction, so a `public/` file on a route's
+    // path answers instead of the route here — and only here, which is what makes it worth saying at build
+    // time. `htmlExtensionless: false`: Vercel serves `about.html` at `/about.html` and adds `/about` only
+    // with `cleanUrls`, which is the project's setting and not something this build can read.
+    warnAboutPublicCollisions(publicRouteCollisions(ctx.publicDir, ctx.routes, { htmlExtensionless: false }), 'vercel');
+    // Shipped inside the function: the bundle, and the one thing it reads from disk at request time.
+    //
+    // `public/` is deliberately *not* among them, though it is on the filesystem targets. It went into the
+    // static output above, and `{ handle: 'filesystem' }` sits ahead of the catch-all route, so the platform
+    // answers those paths before the function is invoked — a copy here is bytes uploaded and unpacked on every
+    // cold start that nothing can ever read. `vercel/runtime.ts` turns the matching mount off to say so.
     cpSync(join(ctx.distDir, 'server'), join(functionDir, 'dist', 'server'), { recursive: true });
     if (existsSync(ctx.ssgDir))
         cpSync(ctx.ssgDir, join(functionDir, 'dist', 'ssg'), { recursive: true });
-    if (ctx.publicDir)
-        cpSync(ctx.publicDir, join(functionDir, 'dist', 'public'), { recursive: true });
     writeFileSync(join(functionDir, '.vc-config.json'), `${JSON.stringify({
-        runtime: 'nodejs22.x',
+        // The Node the build ran on, so the function runs the runtime the app was tested against — and so
+        // this does not become a hard-coded version the platform retires on a date the framework does not
+        // control. A major Vercel does not offer is an explicit error from the deploy rather than a mismatch.
+        runtime: `nodejs${process.versions.node.split('.')[0]}.x`,
         handler: HANDLER,
         launcherType: 'Nodejs',
-        // Without this the platform buffers the whole response, which would undo streamed SSR.
+        // Without this the platform buffers the whole response, undoing streamed SSR.
         supportsResponseStreaming: true,
     }, null, 2)}\n`);
     writeFileSync(join(outputDir, 'config.json'), `${JSON.stringify({ version: 3, routes: ROUTES }, null, 2)}\n`);

package/dist/deploy/vercel/build.js.map

@@ -1 +1 @@
-{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../src/deploy/vercel/build.ts"],"names":[],"mappings":"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","sourcesContent":["import { cpSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { DeployBuildContext } from '../presets.js';\n\n/**\n * The Build Output API v3 layout, which is what `vercel deploy --prebuilt` uploads verbatim. Producing\n * it directly means Vercel runs no build of its own — everything it needs already exists.\n */\nconst OUTPUT_DIR = join('.vercel', 'output');\nconst FUNCTION_DIR = join('functions', 'index.func');\n\n/**\n * The function's own view of the build.\n *\n * `dist/server/main.mjs` is kept at that exact path inside the function because the runtime derives the\n * project root from where the bundle sits (see `deploy/filesystem.ts`) — so `dist/ssg` and `dist/public`\n * land where it already looks for them, and no runtime code needs to know it is on Vercel.\n */\nconst HANDLER = 'dist/server/main.mjs';\n\n/**\n * Routes, in the order Vercel evaluates them: hashed assets get the immutable header the CDN cannot\n * infer, then anything present in the static output is served from it, and whatever is left is the\n * app's to render.\n */\nconst ROUTES = [\n  { src: '^/_static/(.*)$', headers: { 'cache-control': 'public, max-age=31536000, immutable' }, continue: true },\n  { handle: 'filesystem' },\n  { src: '/(.*)', dest: '/index' },\n];\n\nexport async function finalizeVercelBuild(ctx: DeployBuildContext): Promise<void> {\n  const outputDir = join(ctx.rootDir, OUTPUT_DIR);\n  const staticOut = join(outputDir, 'static');\n  const functionDir = join(outputDir, FUNCTION_DIR);\n\n  // Rebuilt from scratch, so a deleted page or asset cannot survive in the uploaded output.\n  await rm(outputDir, { recursive: true, force: true });\n  mkdirSync(staticOut, { recursive: true });\n  mkdirSync(functionDir, { recursive: true });\n\n  // Served by the CDN: the hashed bundle under its public path, and `public/` at the web root.\n  cpSync(ctx.staticDir, join(staticOut, '_static'), { recursive: true });\n  if (ctx.publicDir) cpSync(ctx.publicDir, staticOut, { recursive: true });\n\n  // Shipped inside the function: the bundle, plus the two things it reads from disk at request time.\n  cpSync(join(ctx.distDir, 'server'), join(functionDir, 'dist', 'server'), { recursive: true });\n  if (existsSync(ctx.ssgDir)) cpSync(ctx.ssgDir, join(functionDir, 'dist', 'ssg'), { recursive: true });\n  if (ctx.publicDir) cpSync(ctx.publicDir, join(functionDir, 'dist', 'public'), { recursive: true });\n\n  writeFileSync(\n    join(functionDir, '.vc-config.json'),\n    `${JSON.stringify(\n      {\n        runtime: 'nodejs22.x',\n        handler: HANDLER,\n        launcherType: 'Nodejs',\n        // Without this the platform buffers the whole response, which would undo streamed SSR.\n        supportsResponseStreaming: true,\n      },\n      null,\n      2,\n    )}\\n`,\n  );\n\n  writeFileSync(join(outputDir, 'config.json'), `${JSON.stringify({ version: 3, routes: ROUTES }, null, 2)}\\n`);\n\n  console.log(`  • assembled ${OUTPUT_DIR} (Build Output API v3)`);\n}\n"]}
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../src/deploy/vercel/build.ts"],"names":[],"mappings":"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","sourcesContent":["import { cpSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { DeployBuildContext } from '../presets.js';\nimport { publicRouteCollisions, warnAboutPublicCollisions } from '../public-paths.js';\n\n/**\n * The Build Output API v3 layout, which `vercel deploy --prebuilt` uploads verbatim — producing it directly\n * means Vercel runs no build of its own.\n */\nconst OUTPUT_DIR = join('.vercel', 'output');\nconst FUNCTION_DIR = join('functions', 'index.func');\n\n/**\n * The bundle keeps this exact path inside the function because the runtime derives the project root from where\n * it sits (see `deploy/filesystem.ts`), so `dist/ssg` and `dist/public` land where it already looks — and no\n * runtime code needs to know it is on Vercel.\n */\nconst HANDLER = 'dist/server/main.mjs';\n\n/**\n * Routes, in the order Vercel evaluates them: hashed assets get the immutable header the CDN cannot infer,\n * then anything in the static output is served from it, and whatever is left is the app's to render.\n */\nconst ROUTES = [\n  { src: '^/_static/(.*)$', headers: { 'cache-control': 'public, max-age=31536000, immutable' }, continue: true },\n  { handle: 'filesystem' },\n  { src: '/(.*)', dest: '/index' },\n];\n\nexport async function finalizeVercelBuild(ctx: DeployBuildContext): Promise<void> {\n  const outputDir = join(ctx.rootDir, OUTPUT_DIR);\n  const staticOut = join(outputDir, 'static');\n  const functionDir = join(outputDir, FUNCTION_DIR);\n\n  // From scratch, so a deleted page or asset cannot survive in the uploaded output.\n  await rm(outputDir, { recursive: true, force: true });\n  mkdirSync(staticOut, { recursive: true });\n  mkdirSync(functionDir, { recursive: true });\n\n  // Served by the CDN: the hashed bundle under its public path, and `public/` at the web root.\n  cpSync(ctx.staticDir, join(staticOut, '_static'), { recursive: true });\n  if (ctx.publicDir) cpSync(ctx.publicDir, staticOut, { recursive: true });\n\n  // `{ handle: 'filesystem' }` is ahead of the function by construction, so a `public/` file on a route's\n  // path answers instead of the route here — and only here, which is what makes it worth saying at build\n  // time. `htmlExtensionless: false`: Vercel serves `about.html` at `/about.html` and adds `/about` only\n  // with `cleanUrls`, which is the project's setting and not something this build can read.\n  warnAboutPublicCollisions(publicRouteCollisions(ctx.publicDir, ctx.routes, { htmlExtensionless: false }), 'vercel');\n\n  // Shipped inside the function: the bundle, and the one thing it reads from disk at request time.\n  //\n  // `public/` is deliberately *not* among them, though it is on the filesystem targets. It went into the\n  // static output above, and `{ handle: 'filesystem' }` sits ahead of the catch-all route, so the platform\n  // answers those paths before the function is invoked — a copy here is bytes uploaded and unpacked on every\n  // cold start that nothing can ever read. `vercel/runtime.ts` turns the matching mount off to say so.\n  cpSync(join(ctx.distDir, 'server'), join(functionDir, 'dist', 'server'), { recursive: true });\n  if (existsSync(ctx.ssgDir)) cpSync(ctx.ssgDir, join(functionDir, 'dist', 'ssg'), { recursive: true });\n\n  writeFileSync(\n    join(functionDir, '.vc-config.json'),\n    `${JSON.stringify(\n      {\n        // The Node the build ran on, so the function runs the runtime the app was tested against — and so\n        // this does not become a hard-coded version the platform retires on a date the framework does not\n        // control. A major Vercel does not offer is an explicit error from the deploy rather than a mismatch.\n        runtime: `nodejs${process.versions.node.split('.')[0]}.x`,\n        handler: HANDLER,\n        launcherType: 'Nodejs',\n        // Without this the platform buffers the whole response, undoing streamed SSR.\n        supportsResponseStreaming: true,\n      },\n      null,\n      2,\n    )}\\n`,\n  );\n\n  writeFileSync(join(outputDir, 'config.json'), `${JSON.stringify({ version: 3, routes: ROUTES }, null, 2)}\\n`);\n\n  console.log(`  • assembled ${OUTPUT_DIR} (Build Output API v3)`);\n}\n"]}

package/dist/deploy/vercel/runtime.d.ts

@@ -2,13 +2,16 @@ import type { DeployRuntime } from '../contract.js';
 /**
  * Vercel, as a single Node function fed by the platform's own router.
  *
- * `/_static` and `public/` are in the static output, and `config.json` puts the filesystem handler
- * ahead of the function — so the CDN answers them and the function is never invoked for an asset,
- * which is why mounting them here would only be dead weight.
+ * The function is invoked the way `launcherType: 'Nodejs'` invokes one — with `(IncomingMessage,
+ * ServerResponse)`, not a web `Request`. That is the whole of the Build Output API's Node contract; the
+ * `Request`/`Response` handler shape the platform documents elsewhere belongs to the `@vercel/node` builder,
+ * which compiles and wraps a source file, and a `--prebuilt` upload never runs it. So the handoff converts,
+ * and `hono/vercel`'s `handle` — a pass-through that forwards its first argument straight to `app.fetch` —
+ * cannot be what does it.
  *
- * Prerendered pages are *not* static output: one URL answers with a document or a flight payload
- * depending on `Accept`, and a path-keyed CDN cannot choose. They ship inside the function instead and
- * are read from its read-only disk, exactly as on a server.
+ * `/_static` and `public/` are in the static output, and `config.json` puts the filesystem handler ahead of the
+ * function, so mounting them here would be dead weight. Prerendered pages are *not* static output — one URL
+ * answers with a document or a flight payload on the `RSC` request header, and a path-keyed CDN cannot choose — so
+ * they ship inside the function and are read from its read-only disk, exactly as on a server.
  */
 export declare const runtime: DeployRuntime;
-//# sourceMappingURL=runtime.d.ts.map

package/dist/deploy/vercel/runtime.js

@@ -1,26 +1,63 @@
-import { handle } from 'hono/vercel';
+import { getRequestListener } from '@hono/node-server';
 import { fileSystemRuntime } from '../filesystem.js';
+/**
+ * The scheme the browser used, which the socket cannot answer for: Vercel terminates TLS at the edge and
+ * reaches the function over plain HTTP, so an `https://` request arrives on an unencrypted socket and every
+ * absolute URL the app derived from it would carry the wrong scheme — a redirect back to `http://`, an
+ * origin check comparing against one.
+ *
+ * Read without `trustProxy`, unlike `publicUrl`, because on this target the header is not
+ * client-supplied: the function is reachable only through Vercel's edge, which sets it on every request. The
+ * config field stays what it is — the answer for a proxy *you* put in front, which the framework cannot vouch
+ * for. Falls back to `https`, the only scheme a deployment is served on.
+ */
+function browserScheme(incoming) {
+    const header = incoming.headers['x-forwarded-proto'];
+    const value = (Array.isArray(header) ? header[0] : header)?.split(',')[0]?.trim();
+    return value === 'http' ? 'http' : 'https';
+}
 /**
  * Vercel, as a single Node function fed by the platform's own router.
  *
- * `/_static` and `public/` are in the static output, and `config.json` puts the filesystem handler
- * ahead of the function — so the CDN answers them and the function is never invoked for an asset,
- * which is why mounting them here would only be dead weight.
+ * The function is invoked the way `launcherType: 'Nodejs'` invokes one — with `(IncomingMessage,
+ * ServerResponse)`, not a web `Request`. That is the whole of the Build Output API's Node contract; the
+ * `Request`/`Response` handler shape the platform documents elsewhere belongs to the `@vercel/node` builder,
+ * which compiles and wraps a source file, and a `--prebuilt` upload never runs it. So the handoff converts,
+ * and `hono/vercel`'s `handle` — a pass-through that forwards its first argument straight to `app.fetch` —
+ * cannot be what does it.
  *
- * Prerendered pages are *not* static output: one URL answers with a document or a flight payload
- * depending on `Accept`, and a path-keyed CDN cannot choose. They ship inside the function instead and
- * are read from its read-only disk, exactly as on a server.
+ * `/_static` and `public/` are in the static output, and `config.json` puts the filesystem handler ahead of the
+ * function, so mounting them here would be dead weight. Prerendered pages are *not* static output — one URL
+ * answers with a document or a flight payload on the `RSC` request header, and a path-keyed CDN cannot choose — so
+ * they ship inside the function and are read from its read-only disk, exactly as on a server.
  */
 export const runtime = {
     ...fileSystemRuntime,
     mountStaticAssets() {
         // Served from `.vercel/output/static` before the function runs.
     },
+    mountPublicFallback() {
+        // As above: `public/` is in the static output and `{ handle: 'filesystem' }` is matched ahead of this
+        // function, so nothing here could ever answer for one of those paths. Stated as an override rather than
+        // left to fall out of `dist/public` not being uploaded, because that would make the behaviour incidental
+        // to a `cpSync` in `build.ts` instead of a decision.
+        //
+        // The one thing this hands to the platform: resolving a directory to its `index.html`. Vercel's static
+        // handler does that; `serveStatic`, which the filesystem targets use, is no longer in the path.
+    },
     serveApp(app) {
-        return handle(app);
+        // The same conversion `rshono start` runs on, so a request is built here exactly as it is on the `node`
+        // target — including a streamed response body, which `supportsResponseStreaming` in `.vc-config.json`
+        // then keeps unbuffered on the way out.
+        const listener = getRequestListener(app.fetch);
+        return (incoming, outgoing) => {
+            const host = incoming.headers.host;
+            // Left alone when there is no `Host`, so the listener answers with its own 400 rather than this
+            // building `https://undefined/…` and the app rejecting a URL it should never have been handed.
+            if (host)
+                incoming.url = `${browserScheme(incoming)}://${host}${incoming.url ?? '/'}`;
+            return listener(incoming, outgoing);
+        };
     },
-    // Vercel compresses at the edge. Its Node runtime does support streaming, so the framework's own
-    // streamed SSR still reaches the browser progressively.
-    compress: null,
 };
 //# sourceMappingURL=runtime.js.map

package/dist/deploy/vercel/runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/deploy/vercel/runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,OAAO,GAAkB;IACpC,GAAG,iBAAiB;IAEpB,iBAAiB;QACf,gEAAgE;IAClE,CAAC;IAED,QAAQ,CAAC,GAAS;QAChB,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IAED,iGAAiG;IACjG,wDAAwD;IACxD,QAAQ,EAAE,IAAI;CACf,CAAC","sourcesContent":["import type { Hono } from 'hono';\nimport { handle } from 'hono/vercel';\nimport type { DeployRuntime } from '../contract.js';\nimport { fileSystemRuntime } from '../filesystem.js';\n\n/**\n * Vercel, as a single Node function fed by the platform's own router.\n *\n * `/_static` and `public/` are in the static output, and `config.json` puts the filesystem handler\n * ahead of the function — so the CDN answers them and the function is never invoked for an asset,\n * which is why mounting them here would only be dead weight.\n *\n * Prerendered pages are *not* static output: one URL answers with a document or a flight payload\n * depending on `Accept`, and a path-keyed CDN cannot choose. They ship inside the function instead and\n * are read from its read-only disk, exactly as on a server.\n */\nexport const runtime: DeployRuntime = {\n  ...fileSystemRuntime,\n\n  mountStaticAssets(): void {\n    // Served from `.vercel/output/static` before the function runs.\n  },\n\n  serveApp(app: Hono): unknown {\n    return handle(app);\n  },\n\n  // Vercel compresses at the edge. Its Node runtime does support streaming, so the framework's own\n  // streamed SSR still reaches the browser progressively.\n  compress: null,\n};\n"]}
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/deploy/vercel/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAIvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,SAAS,aAAa,CAAC,QAAyB;IAC9C,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrD,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IAClF,OAAO,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,OAAO,GAAkB;IACpC,GAAG,iBAAiB;IAEpB,iBAAiB;QACf,gEAAgE;IAClE,CAAC;IAED,mBAAmB;QACjB,sGAAsG;QACtG,wGAAwG;QACxG,yGAAyG;QACzG,qDAAqD;QACrD,EAAE;QACF,uGAAuG;QACvG,gGAAgG;IAClG,CAAC;IAED,QAAQ,CAAC,GAAS;QAChB,wGAAwG;QACxG,sGAAsG;QACtG,wCAAwC;QACxC,MAAM,QAAQ,GAAG,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAE/C,OAAO,CAAC,QAAyB,EAAE,QAAwB,EAAiB,EAAE;YAC5E,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC;YACnC,gGAAgG;YAChG,+FAA+F;YAC/F,IAAI,IAAI;gBAAE,QAAQ,CAAC,GAAG,GAAG,GAAG,aAAa,CAAC,QAAQ,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,IAAI,GAAG,EAAE,CAAC;YACtF,OAAO,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC,CAAC;IACJ,CAAC;CACF,CAAC","sourcesContent":["import { getRequestListener } from '@hono/node-server';\nimport type { Hono } from 'hono';\nimport type { IncomingMessage, ServerResponse } from 'node:http';\nimport type { DeployRuntime } from '../contract.js';\nimport { fileSystemRuntime } from '../filesystem.js';\n\n/**\n * The scheme the browser used, which the socket cannot answer for: Vercel terminates TLS at the edge and\n * reaches the function over plain HTTP, so an `https://` request arrives on an unencrypted socket and every\n * absolute URL the app derived from it would carry the wrong scheme — a redirect back to `http://`, an\n * origin check comparing against one.\n *\n * Read without `trustProxy`, unlike `publicUrl`, because on this target the header is not\n * client-supplied: the function is reachable only through Vercel's edge, which sets it on every request. The\n * config field stays what it is — the answer for a proxy *you* put in front, which the framework cannot vouch\n * for. Falls back to `https`, the only scheme a deployment is served on.\n */\nfunction browserScheme(incoming: IncomingMessage): string {\n  const header = incoming.headers['x-forwarded-proto'];\n  const value = (Array.isArray(header) ? header[0] : header)?.split(',')[0]?.trim();\n  return value === 'http' ? 'http' : 'https';\n}\n\n/**\n * Vercel, as a single Node function fed by the platform's own router.\n *\n * The function is invoked the way `launcherType: 'Nodejs'` invokes one — with `(IncomingMessage,\n * ServerResponse)`, not a web `Request`. That is the whole of the Build Output API's Node contract; the\n * `Request`/`Response` handler shape the platform documents elsewhere belongs to the `@vercel/node` builder,\n * which compiles and wraps a source file, and a `--prebuilt` upload never runs it. So the handoff converts,\n * and `hono/vercel`'s `handle` — a pass-through that forwards its first argument straight to `app.fetch` —\n * cannot be what does it.\n *\n * `/_static` and `public/` are in the static output, and `config.json` puts the filesystem handler ahead of the\n * function, so mounting them here would be dead weight. Prerendered pages are *not* static output — one URL\n * answers with a document or a flight payload on the `RSC` request header, and a path-keyed CDN cannot choose — so\n * they ship inside the function and are read from its read-only disk, exactly as on a server.\n */\nexport const runtime: DeployRuntime = {\n  ...fileSystemRuntime,\n\n  mountStaticAssets(): void {\n    // Served from `.vercel/output/static` before the function runs.\n  },\n\n  mountPublicFallback(): void {\n    // As above: `public/` is in the static output and `{ handle: 'filesystem' }` is matched ahead of this\n    // function, so nothing here could ever answer for one of those paths. Stated as an override rather than\n    // left to fall out of `dist/public` not being uploaded, because that would make the behaviour incidental\n    // to a `cpSync` in `build.ts` instead of a decision.\n    //\n    // The one thing this hands to the platform: resolving a directory to its `index.html`. Vercel's static\n    // handler does that; `serveStatic`, which the filesystem targets use, is no longer in the path.\n  },\n\n  serveApp(app: Hono): unknown {\n    // The same conversion `rshono start` runs on, so a request is built here exactly as it is on the `node`\n    // target — including a streamed response body, which `supportsResponseStreaming` in `.vc-config.json`\n    // then keeps unbuffered on the way out.\n    const listener = getRequestListener(app.fetch);\n\n    return (incoming: IncomingMessage, outgoing: ServerResponse): Promise<void> => {\n      const host = incoming.headers.host;\n      // Left alone when there is no `Host`, so the listener answers with its own 400 rather than this\n      // building `https://undefined/…` and the app rejecting a URL it should never have been handed.\n      if (host) incoming.url = `${browserScheme(incoming)}://${host}${incoming.url ?? '/'}`;\n      return listener(incoming, outgoing);\n    };\n  },\n};\n"]}

package/dist/index.d.ts

@@ -1,23 +1,25 @@
 /**
- * `@rshono/core` — the build-time surface: route and config declaration plus the types
- * your pages and endpoints are written against. Everything here is safe to
- * import from server code; none of it pulls in runtime machinery.
+ * `@rshono/core` — the build-time surface: route and config declaration, plus the types
+ * your pages and endpoints are written against. Nothing here pulls in runtime machinery.
  *
- * The two companion entry points are runtime-only:
- * - `@rshono/core/server` — {@link https://hono.dev | Hono} request context inside
- *   server components and actions (`getContext`, `redirect`, `notFound`), plus
- *   `onServerError` for reporting the errors the framework catches.
- * - `@rshono/core/client` — hooks and components for `'use client'` modules
- *   (`useNavigation`, `Boundary`, `ErrorBoundary`, `NavigationProgress`).
+ * Two companion entry points are runtime-only:
+ * - `@rshono/core/server` — request context, `redirect`, `notFound`, `onServerError`, `publicUrl`.
+ * - `@rshono/core/client` — `useNavigation`, `AsyncBoundary`, `CatchBoundary`.
+ *
+ * ESM only: the `exports` map declares `types` and `import` conditions and no `require` one.
+ *
+ * @example
+ * ```ts
+ * // src/routes.ts
+ * import { defineRoutes } from '@rshono/core';
+ *
+ * export const routes = defineRoutes([{ path: '/', component: () => import('./components/home') }]);
+ * ```
+ *
+ * @see {@link https://www.rshono.com/docs/api | Docs — API reference}
  *
  * @packageDocumentation
  */
-export { defineRoutes, isPageRoute, type EndpointRoute, type EndpointServerModule, type ErrorInfo, type ErrorPageProps, type FallbackPage, type HTTPMethod, type PageComponent, type PageProps, type PageRoute, type PathParams, type Route, type RouteConfig, } from './router.js';
-export { defineConfig, type RSHonoConfig, type RspackHookContext } from './config.js';
+export { defineRoutes, type EndpointRoute, type EndpointServerModule, type ErrorPageInfo, type ErrorPageProps, type FallbackPage, type HTTPMethod, type PageComponent, type PageProps, type PageRoute, type PathParams, type Route, type RouteConfig, } from './router.js';
+export { defineConfig, type RshonoConfig, type RspackHookContext } from './config.js';
 export type { DeployTarget } from './deploy/contract.js';
-/**
- * Re-exported from Hono for convenience, so an endpoint module can type its
- * `handler` without depending on `hono` directly.
- */
-export type { Context, Handler } from 'hono';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,17 +1,27 @@
 /**
- * `@rshono/core` — the build-time surface: route and config declaration plus the types
- * your pages and endpoints are written against. Everything here is safe to
- * import from server code; none of it pulls in runtime machinery.
+ * `@rshono/core` — the build-time surface: route and config declaration, plus the types
+ * your pages and endpoints are written against. Nothing here pulls in runtime machinery.
  *
- * The two companion entry points are runtime-only:
- * - `@rshono/core/server` — {@link https://hono.dev | Hono} request context inside
- *   server components and actions (`getContext`, `redirect`, `notFound`), plus
- *   `onServerError` for reporting the errors the framework catches.
- * - `@rshono/core/client` — hooks and components for `'use client'` modules
- *   (`useNavigation`, `Boundary`, `ErrorBoundary`, `NavigationProgress`).
+ * Two companion entry points are runtime-only:
+ * - `@rshono/core/server` — request context, `redirect`, `notFound`, `onServerError`, `publicUrl`.
+ * - `@rshono/core/client` — `useNavigation`, `AsyncBoundary`, `CatchBoundary`.
+ *
+ * ESM only: the `exports` map declares `types` and `import` conditions and no `require` one.
+ *
+ * @example
+ * ```ts
+ * // src/routes.ts
+ * import { defineRoutes } from '@rshono/core';
+ *
+ * export const routes = defineRoutes([{ path: '/', component: () => import('./components/home') }]);
+ * ```
+ *
+ * @see {@link https://www.rshono.com/docs/api | Docs — API reference}
  *
  * @packageDocumentation
  */
-export { defineRoutes, isPageRoute, } from './router.js';
+export { defineRoutes, } from './router.js';
 export { defineConfig } from './config.js';
+// Hono's `Context` and `Handler` are deliberately not re-exported — `hono` is a peer dependency, so
+// endpoints import them from there rather than from two spellings of the same type.
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,YAAY,EACZ,WAAW,GAaZ,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAA6C,MAAM,aAAa,CAAC","sourcesContent":["/**\n * `@rshono/core` — the build-time surface: route and config declaration plus the types\n * your pages and endpoints are written against. Everything here is safe to\n * import from server code; none of it pulls in runtime machinery.\n *\n * The two companion entry points are runtime-only:\n * - `@rshono/core/server` — {@link https://hono.dev | Hono} request context inside\n *   server components and actions (`getContext`, `redirect`, `notFound`), plus\n *   `onServerError` for reporting the errors the framework catches.\n * - `@rshono/core/client` — hooks and components for `'use client'` modules\n *   (`useNavigation`, `Boundary`, `ErrorBoundary`, `NavigationProgress`).\n *\n * @packageDocumentation\n */\n\nexport {\n  defineRoutes,\n  isPageRoute,\n  type EndpointRoute,\n  type EndpointServerModule,\n  type ErrorInfo,\n  type ErrorPageProps,\n  type FallbackPage,\n  type HTTPMethod,\n  type PageComponent,\n  type PageProps,\n  type PageRoute,\n  type PathParams,\n  type Route,\n  type RouteConfig,\n} from './router.js';\n\nexport { defineConfig, type RSHonoConfig, type RspackHookContext } from './config.js';\n\nexport type { DeployTarget } from './deploy/contract.js';\n\n/**\n * Re-exported from Hono for convenience, so an endpoint module can type its\n * `handler` without depending on `hono` directly.\n */\nexport type { Context, Handler } from 'hono';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EACL,YAAY,GAab,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAA6C,MAAM,aAAa,CAAC;AAItF,oGAAoG;AACpG,oFAAoF","sourcesContent":["/**\n * `@rshono/core` — the build-time surface: route and config declaration, plus the types\n * your pages and endpoints are written against. Nothing here pulls in runtime machinery.\n *\n * Two companion entry points are runtime-only:\n * - `@rshono/core/server` — request context, `redirect`, `notFound`, `onServerError`, `publicUrl`.\n * - `@rshono/core/client` — `useNavigation`, `AsyncBoundary`, `CatchBoundary`.\n *\n * ESM only: the `exports` map declares `types` and `import` conditions and no `require` one.\n *\n * @example\n * ```ts\n * // src/routes.ts\n * import { defineRoutes } from '@rshono/core';\n *\n * export const routes = defineRoutes([{ path: '/', component: () => import('./components/home') }]);\n * ```\n *\n * @see {@link https://www.rshono.com/docs/api | Docs — API reference}\n *\n * @packageDocumentation\n */\n\nexport {\n  defineRoutes,\n  type EndpointRoute,\n  type EndpointServerModule,\n  type ErrorPageInfo,\n  type ErrorPageProps,\n  type FallbackPage,\n  type HTTPMethod,\n  type PageComponent,\n  type PageProps,\n  type PageRoute,\n  type PathParams,\n  type Route,\n  type RouteConfig,\n} from './router.js';\n\nexport { defineConfig, type RshonoConfig, type RspackHookContext } from './config.js';\n\nexport type { DeployTarget } from './deploy/contract.js';\n\n// Hono's `Context` and `Handler` are deliberately not re-exported — `hono` is a peer dependency, so\n// endpoints import them from there rather than from two spellings of the same type.\n"]}