@rshono/core 1.0.0-rc.12 → 1.0.0-rc.13

package/dist/server/headers.d.ts

@@ -1,24 +1,17 @@
 /**
- * Small header utilities shared by the response-header defaults and the prerendered-page cache. Kept
- * apart from both because getting `Vary` and `ETag` comparison subtly wrong is exactly the kind of
- * thing that only shows up behind a CDN.
+ * Header utilities shared by the response-header defaults and the prerendered-page cache. Their own module
+ * because getting `Vary` and `ETag` comparison subtly wrong only shows up behind a CDN.
  */
 /**
- * Adds `value` to the `Vary` header without discarding what is already there.
- *
- * `Vary` is a list, and the framework's own entry (`Accept` — an HTML document or a flight payload from
- * one URL) is not necessarily the only one: a route, a middleware or a proxy may have added its own.
- * A plain `set` would drop the others, and a cache would then serve one variant in place of another.
- * `*` is left alone: it already means "never reuse this".
+ * Adds `value` to the `Vary` header without discarding what is already there — a route, a middleware or a proxy
+ * may have added its own entry, and a plain `set` would drop it, leaving a cache free to serve one variant in
+ * place of another. `*` is left alone: it already means "never reuse this".
  */
 export declare function appendVary(headers: Headers, value: string): void;
 /**
- * True when an `If-None-Match` request header matches `etag`, i.e. the client already holds this
- * exact body and should be answered with a 304.
- *
- * The header carries a *list*, and each entry may be weak (`W/"…"`). The weak prefix is ignored on
- * both sides: a proxy or CDN that gzips on the way out changes the bytes without changing the
- * representation, and is entitled to weaken the validator when it does.
+ * True when an `If-None-Match` matches `etag` — the client already holds this body and can be answered with a
+ * 304. The header carries a list, and the weak prefix is ignored on both sides: a CDN that gzips on the way out
+ * changes the bytes without changing the representation, and may weaken the validator when it does.
  */
 export declare function etagMatches(ifNoneMatch: string | undefined, etag: string): boolean;
 //# sourceMappingURL=headers.d.ts.map

package/dist/server/headers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/server/headers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAShE;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAQlF"}
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/server/headers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAShE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAQlF"}

package/dist/server/headers.js

@@ -1,15 +1,11 @@
 /**
- * Small header utilities shared by the response-header defaults and the prerendered-page cache. Kept
- * apart from both because getting `Vary` and `ETag` comparison subtly wrong is exactly the kind of
- * thing that only shows up behind a CDN.
+ * Header utilities shared by the response-header defaults and the prerendered-page cache. Their own module
+ * because getting `Vary` and `ETag` comparison subtly wrong only shows up behind a CDN.
  */
 /**
- * Adds `value` to the `Vary` header without discarding what is already there.
- *
- * `Vary` is a list, and the framework's own entry (`Accept` — an HTML document or a flight payload from
- * one URL) is not necessarily the only one: a route, a middleware or a proxy may have added its own.
- * A plain `set` would drop the others, and a cache would then serve one variant in place of another.
- * `*` is left alone: it already means "never reuse this".
+ * Adds `value` to the `Vary` header without discarding what is already there — a route, a middleware or a proxy
+ * may have added its own entry, and a plain `set` would drop it, leaving a cache free to serve one variant in
+ * place of another. `*` is left alone: it already means "never reuse this".
  */
 export function appendVary(headers, value) {
     const existing = headers.get('vary');
@@ -24,12 +20,9 @@ export function appendVary(headers, value) {
         headers.set('vary', `${existing}, ${value}`);
 }
 /**
- * True when an `If-None-Match` request header matches `etag`, i.e. the client already holds this
- * exact body and should be answered with a 304.
- *
- * The header carries a *list*, and each entry may be weak (`W/"…"`). The weak prefix is ignored on
- * both sides: a proxy or CDN that gzips on the way out changes the bytes without changing the
- * representation, and is entitled to weaken the validator when it does.
+ * True when an `If-None-Match` matches `etag` — the client already holds this body and can be answered with a
+ * 304. The header carries a list, and the weak prefix is ignored on both sides: a CDN that gzips on the way out
+ * changes the bytes without changing the representation, and may weaken the validator when it does.
  */
 export function etagMatches(ifNoneMatch, etag) {
     if (!ifNoneMatch)

package/dist/server/headers.js.map

@@ -1 +1 @@
-{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../src/server/headers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,OAAgB,EAAE,KAAa;IACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrC,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC3B,OAAO;IACT,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG;QAAE,OAAO;IACpC,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IACxG,IAAI,CAAC,OAAO;QAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,QAAQ,KAAK,KAAK,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,WAA+B,EAAE,IAAY;IACvE,IAAI,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC;IAC/B,MAAM,SAAS,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QAC3C,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QACnC,OAAO,SAAS,KAAK,GAAG,IAAI,SAAS,KAAK,MAAM,CAAC;IACnD,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Small header utilities shared by the response-header defaults and the prerendered-page cache. Kept\n * apart from both because getting `Vary` and `ETag` comparison subtly wrong is exactly the kind of\n * thing that only shows up behind a CDN.\n */\n\n/**\n * Adds `value` to the `Vary` header without discarding what is already there.\n *\n * `Vary` is a list, and the framework's own entry (`Accept` — an HTML document or a flight payload from\n * one URL) is not necessarily the only one: a route, a middleware or a proxy may have added its own.\n * A plain `set` would drop the others, and a cache would then serve one variant in place of another.\n * `*` is left alone: it already means \"never reuse this\".\n */\nexport function appendVary(headers: Headers, value: string): void {\n  const existing = headers.get('vary');\n  if (existing === null) {\n    headers.set('vary', value);\n    return;\n  }\n  if (existing.trim() === '*') return;\n  const already = existing.split(',').some((entry) => entry.trim().toLowerCase() === value.toLowerCase());\n  if (!already) headers.set('vary', `${existing}, ${value}`);\n}\n\n/**\n * True when an `If-None-Match` request header matches `etag`, i.e. the client already holds this\n * exact body and should be answered with a 304.\n *\n * The header carries a *list*, and each entry may be weak (`W/\"…\"`). The weak prefix is ignored on\n * both sides: a proxy or CDN that gzips on the way out changes the bytes without changing the\n * representation, and is entitled to weaken the validator when it does.\n */\nexport function etagMatches(ifNoneMatch: string | undefined, etag: string): boolean {\n  if (!ifNoneMatch) return false;\n  const normalize = (value: string) => value.trim().replace(/^W\\//, '');\n  const wanted = normalize(etag);\n  return ifNoneMatch.split(',').some((entry) => {\n    const candidate = normalize(entry);\n    return candidate === '*' || candidate === wanted;\n  });\n}\n"]}
+{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../src/server/headers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,OAAgB,EAAE,KAAa;IACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrC,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC3B,OAAO;IACT,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG;QAAE,OAAO;IACpC,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IACxG,IAAI,CAAC,OAAO;QAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,QAAQ,KAAK,KAAK,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,WAA+B,EAAE,IAAY;IACvE,IAAI,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC;IAC/B,MAAM,SAAS,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QAC3C,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QACnC,OAAO,SAAS,KAAK,GAAG,IAAI,SAAS,KAAK,MAAM,CAAC;IACnD,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Header utilities shared by the response-header defaults and the prerendered-page cache. Their own module\n * because getting `Vary` and `ETag` comparison subtly wrong only shows up behind a CDN.\n */\n\n/**\n * Adds `value` to the `Vary` header without discarding what is already there — a route, a middleware or a proxy\n * may have added its own entry, and a plain `set` would drop it, leaving a cache free to serve one variant in\n * place of another. `*` is left alone: it already means \"never reuse this\".\n */\nexport function appendVary(headers: Headers, value: string): void {\n  const existing = headers.get('vary');\n  if (existing === null) {\n    headers.set('vary', value);\n    return;\n  }\n  if (existing.trim() === '*') return;\n  const already = existing.split(',').some((entry) => entry.trim().toLowerCase() === value.toLowerCase());\n  if (!already) headers.set('vary', `${existing}, ${value}`);\n}\n\n/**\n * True when an `If-None-Match` matches `etag` — the client already holds this body and can be answered with a\n * 304. The header carries a list, and the weak prefix is ignored on both sides: a CDN that gzips on the way out\n * changes the bytes without changing the representation, and may weaken the validator when it does.\n */\nexport function etagMatches(ifNoneMatch: string | undefined, etag: string): boolean {\n  if (!ifNoneMatch) return false;\n  const normalize = (value: string) => value.trim().replace(/^W\\//, '');\n  const wanted = normalize(etag);\n  return ifNoneMatch.split(',').some((entry) => {\n    const candidate = normalize(entry);\n    return candidate === '*' || candidate === wanted;\n  });\n}\n"]}

package/dist/server/load-config.d.ts

@@ -1,7 +1,7 @@
 import type { RshonoConfig } from '../config.js';
 /**
- * Load the project config, or `{}` if none exists. Scans `rshono.config.{ts,js,mjs}` at
- * {@link rootDir} unless an explicit {@link configPath} is given (resolved relative to `cwd`).
+ * Loads the project config, or `{}` if there is none: scans `rshono.config.{ts,js,mjs}` at `rootDir`, unless an
+ * explicit `configPath` is given (resolved relative to `cwd`).
  */
 export declare function loadConfig(rootDir: string, configPath?: string): Promise<RshonoConfig>;
 //# sourceMappingURL=load-config.d.ts.map

package/dist/server/load-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../../src/server/load-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAmBjD;;;GAGG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA6B5F"}
+{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../../src/server/load-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAgBjD;;;GAGG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA6B5F"}

package/dist/server/load-config.js

@@ -3,22 +3,19 @@ import { isAbsolute, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 const CONFIG_FILES = ['rshono.config.ts', 'rshono.config.js', 'rshono.config.mjs'];
 /**
- * Imports the config module.
- *
- * A `.ts` config needs no loader of its own: Node strips types natively from 22.18 on, which is what
- * the package's `engines` floor is for. That replaced a `tsx` dependency whose only job was these two
- * lines — and `tsx` bundles esbuild, so it was the largest thing in the install.
+ * Imports the config module. A `.ts` config needs no loader: Node strips types natively from 22.18 on, which is
+ * what the package's `engines` floor is for.
  *
  * The one thing native stripping will not do is resolve a `.js` specifier to a `.ts` file, so a config
- * that imports a sibling module has to name it with its real extension. {@link loadConfig} turns the
- * resulting resolution failure into that advice rather than letting a raw `ERR_MODULE_NOT_FOUND` out.
+ * importing a sibling has to name it with its real extension — {@link loadConfig} turns that resolution failure
+ * into the advice rather than letting a raw `ERR_MODULE_NOT_FOUND` out.
  */
 function importConfig(file) {
     return import(pathToFileURL(file).href);
 }
 /**
- * Load the project config, or `{}` if none exists. Scans `rshono.config.{ts,js,mjs}` at
- * {@link rootDir} unless an explicit {@link configPath} is given (resolved relative to `cwd`).
+ * Loads the project config, or `{}` if there is none: scans `rshono.config.{ts,js,mjs}` at `rootDir`, unless an
+ * explicit `configPath` is given (resolved relative to `cwd`).
  */
 export async function loadConfig(rootDir, configPath) {
     const file = configPath

package/dist/server/load-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"load-config.js","sourceRoot":"","sources":["../../src/server/load-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,MAAM,YAAY,GAAG,CAAC,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;AAEnF;;;;;;;;;;GAUG;AACH,SAAS,YAAY,CAAC,IAAY;IAChC,OAAO,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAwC,CAAC;AACjF,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,OAAe,EAAE,UAAmB;IACnE,MAAM,IAAI,GAAG,UAAU;QACrB,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;YACtB,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC;QACtC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/D,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IACD,IAAI,GAA+B,CAAC;IACpC,IAAI,CAAC;QACH,GAAG,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,0FAA0F;QAC1F,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAK,KAAkC,EAAE,IAAI,KAAK,sBAAsB,EAAE,CAAC;YACpG,MAAM,IAAI,KAAK,CACb,YAAY,IAAI,6CAA8C,KAAe,CAAC,OAAO,IAAI;gBACvF,kGAAkG;gBAClG,sFAAsF,EACxF,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,YAAY,IAAI,yEAAyE,CAAC,CAAC;IAC7G,CAAC;IACD,OAAO,GAAG,CAAC,OAAO,CAAC;AACrB,CAAC","sourcesContent":["import { existsSync } from 'node:fs';\nimport { isAbsolute, join, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type { RshonoConfig } from '../config.js';\n\nconst CONFIG_FILES = ['rshono.config.ts', 'rshono.config.js', 'rshono.config.mjs'];\n\n/**\n * Imports the config module.\n *\n * A `.ts` config needs no loader of its own: Node strips types natively from 22.18 on, which is what\n * the package's `engines` floor is for. That replaced a `tsx` dependency whose only job was these two\n * lines — and `tsx` bundles esbuild, so it was the largest thing in the install.\n *\n * The one thing native stripping will not do is resolve a `.js` specifier to a `.ts` file, so a config\n * that imports a sibling module has to name it with its real extension. {@link loadConfig} turns the\n * resulting resolution failure into that advice rather than letting a raw `ERR_MODULE_NOT_FOUND` out.\n */\nfunction importConfig(file: string): Promise<{ default?: RshonoConfig }> {\n  return import(pathToFileURL(file).href) as Promise<{ default?: RshonoConfig }>;\n}\n\n/**\n * Load the project config, or `{}` if none exists. Scans `rshono.config.{ts,js,mjs}` at\n * {@link rootDir} unless an explicit {@link configPath} is given (resolved relative to `cwd`).\n */\nexport async function loadConfig(rootDir: string, configPath?: string): Promise<RshonoConfig> {\n  const file = configPath\n    ? isAbsolute(configPath)\n      ? configPath\n      : resolve(process.cwd(), configPath)\n    : CONFIG_FILES.map((f) => join(rootDir, f)).find(existsSync);\n  if (!file) return {};\n  if (!existsSync(file)) {\n    throw new Error(`[rshono] config file not found: ${file}`);\n  }\n  let mod: { default?: RshonoConfig };\n  try {\n    mod = await importConfig(file);\n  } catch (error) {\n    // The one failure mode native type stripping has that a TypeScript-aware loader does not.\n    if (/\\.[cm]?ts$/.test(file) && (error as { code?: string } | null)?.code === 'ERR_MODULE_NOT_FOUND') {\n      throw new Error(\n        `[rshono] ${file} imports a module Node could not resolve: ${(error as Error).message}\\n` +\n          '  A .ts config is loaded by Node itself, which does not rewrite a .js specifier to the .ts file ' +\n          'beside it. Import it by its real extension, or move the config to rshono.config.mjs.',\n        { cause: error },\n      );\n    }\n    throw error;\n  }\n  if (!mod.default) {\n    throw new Error(`[rshono] ${file} must \\`export default\\` a config object (use \\`defineConfig({ … })\\`).`);\n  }\n  return mod.default;\n}\n"]}
+{"version":3,"file":"load-config.js","sourceRoot":"","sources":["../../src/server/load-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,MAAM,YAAY,GAAG,CAAC,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;AAEnF;;;;;;;GAOG;AACH,SAAS,YAAY,CAAC,IAAY;IAChC,OAAO,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAwC,CAAC;AACjF,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,OAAe,EAAE,UAAmB;IACnE,MAAM,IAAI,GAAG,UAAU;QACrB,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;YACtB,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC;QACtC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/D,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IACD,IAAI,GAA+B,CAAC;IACpC,IAAI,CAAC;QACH,GAAG,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,0FAA0F;QAC1F,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAK,KAAkC,EAAE,IAAI,KAAK,sBAAsB,EAAE,CAAC;YACpG,MAAM,IAAI,KAAK,CACb,YAAY,IAAI,6CAA8C,KAAe,CAAC,OAAO,IAAI;gBACvF,kGAAkG;gBAClG,sFAAsF,EACxF,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,YAAY,IAAI,yEAAyE,CAAC,CAAC;IAC7G,CAAC;IACD,OAAO,GAAG,CAAC,OAAO,CAAC;AACrB,CAAC","sourcesContent":["import { existsSync } from 'node:fs';\nimport { isAbsolute, join, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type { RshonoConfig } from '../config.js';\n\nconst CONFIG_FILES = ['rshono.config.ts', 'rshono.config.js', 'rshono.config.mjs'];\n\n/**\n * Imports the config module. A `.ts` config needs no loader: Node strips types natively from 22.18 on, which is\n * what the package's `engines` floor is for.\n *\n * The one thing native stripping will not do is resolve a `.js` specifier to a `.ts` file, so a config\n * importing a sibling has to name it with its real extension — {@link loadConfig} turns that resolution failure\n * into the advice rather than letting a raw `ERR_MODULE_NOT_FOUND` out.\n */\nfunction importConfig(file: string): Promise<{ default?: RshonoConfig }> {\n  return import(pathToFileURL(file).href) as Promise<{ default?: RshonoConfig }>;\n}\n\n/**\n * Loads the project config, or `{}` if there is none: scans `rshono.config.{ts,js,mjs}` at `rootDir`, unless an\n * explicit `configPath` is given (resolved relative to `cwd`).\n */\nexport async function loadConfig(rootDir: string, configPath?: string): Promise<RshonoConfig> {\n  const file = configPath\n    ? isAbsolute(configPath)\n      ? configPath\n      : resolve(process.cwd(), configPath)\n    : CONFIG_FILES.map((f) => join(rootDir, f)).find(existsSync);\n  if (!file) return {};\n  if (!existsSync(file)) {\n    throw new Error(`[rshono] config file not found: ${file}`);\n  }\n  let mod: { default?: RshonoConfig };\n  try {\n    mod = await importConfig(file);\n  } catch (error) {\n    // The one failure mode native type stripping has that a TypeScript-aware loader does not.\n    if (/\\.[cm]?ts$/.test(file) && (error as { code?: string } | null)?.code === 'ERR_MODULE_NOT_FOUND') {\n      throw new Error(\n        `[rshono] ${file} imports a module Node could not resolve: ${(error as Error).message}\\n` +\n          '  A .ts config is loaded by Node itself, which does not rewrite a .js specifier to the .ts file ' +\n          'beside it. Import it by its real extension, or move the config to rshono.config.mjs.',\n        { cause: error },\n      );\n    }\n    throw error;\n  }\n  if (!mod.default) {\n    throw new Error(`[rshono] ${file} must \\`export default\\` a config object (use \\`defineConfig({ … })\\`).`);\n  }\n  return mod.default;\n}\n"]}

package/dist/server/prerendered.d.ts

@@ -1,15 +1,15 @@
 /**
- * Everything about a prerendered page that doesn't need a filesystem: where the build puts it, and
- * what it looks like once read back.
+ * Everything about a prerendered page that doesn't need a filesystem: where the build puts it, and what it
+ * looks like once read back.
  *
- * Split out of `ssg.ts` — which owns the writing and the reading, both through `node:fs` — because a
- * deploy target without a filesystem reads the very same layout out of an asset store, and importing
- * it from the fs module would drag `node:fs` and `node:crypto` into a bundle that has neither.
+ * Apart from `ssg.ts`, which does the reading and writing through `node:fs`, because a deploy target without a
+ * filesystem reads the same layout out of an asset store — and importing it from there would drag `node:fs`
+ * into a bundle that has neither.
  */
 /**
- * The two representations of a page, prerendered side by side: a hard load wants the HTML document, a
- * soft navigation asks the same URL for a flight payload. Without both, every in-app click would
- * re-render a page that was already built.
+ * The two representations of a page, prerendered side by side: a hard load wants the HTML document, a soft
+ * navigation asks the same URL for a flight payload. Without both, every in-app click would re-render a page
+ * that was already built.
  */
 export type PrerenderVariant = 'html' | 'flight';
 export declare const VARIANTS: {
@@ -25,70 +25,57 @@ export declare const VARIANTS: {
     };
 };
 /**
- * Where a route's prerendered output lives, relative to the output root — or `null` for a path that
- * cannot be prerendered at all (one with a param or a wildcard left in it).
+ * Where a route's prerendered output lives, relative to the output root — or `null` for a path that cannot be
+ * prerendered at all, one with a param or a wildcard left in it.
  *
- * Always `/`-separated, never the host's separator: the same string addresses a file on a filesystem
- * (`resolve()` and `join()` both accept forward slashes on Windows) and a key in an asset store,
- * where a backslash would simply be the wrong character.
+ * Always `/`-separated: the same string addresses a file on a filesystem, which accepts forward slashes on
+ * Windows too, and a key in an asset store, where a backslash would be the wrong character.
  */
 export declare function ssgFilePath(routePath: string, variant?: PrerenderVariant): string | null;
 /**
- * {@link ssgFilePath} for a path that came off a request, so traversal is a miss rather than a lookup.
- *
- * The first line of defence for every deploy target: a store addressed by key has no `resolve()` to
- * fall back on, so `..` has to be refused here or not at all.
+ * {@link ssgFilePath} for a path that came off a request, so traversal is a miss rather than a lookup. A store
+ * addressed by key has no `resolve()` to fall back on, so `..` is refused here or not at all.
  */
 export declare function prerenderedRelPath(requestPath: string, variant: PrerenderVariant): string | null;
 /**
- * A bounded, insertion-ordered cache of prerendered pages.
- *
- * Bounded so a site with thousands of prerendered pages keeps a working set rather than the whole
- * build in memory. Only *hits* are ever stored: caching misses would let anyone mint entries by
- * requesting paths that don't exist. The files are written at build time and never change while the
- * server is up, so an entry never needs invalidating.
+ * A bounded, insertion-ordered cache of prerendered pages, so a site with thousands of them keeps a working set
+ * rather than the whole build in memory. Only *hits* are stored — caching misses would let anyone mint entries
+ * by requesting paths that don't exist — and the files never change while the server is up.
  */
 export declare function createPageCache(max?: number): {
     get(key: string): PrerenderedPage | undefined;
     set(key: string, page: PrerenderedPage): void;
 };
 /**
- * A weak `ETag` for a page body — see {@link PrerenderedPage.etag} for why weak.
- *
- * Web Crypto rather than `node:crypto`, so the one implementation serves both a Node server and
- * `workerd`.
+ * A weak `ETag` for a page body — see {@link PrerenderedPage.etag} for why weak. Web Crypto rather than
+ * `node:crypto`, so one implementation serves both a Node server and `workerd`.
  */
 export declare function weakEtag(body: Uint8Array<ArrayBuffer>): Promise<string>;
 /**
- * Assembles a {@link PrerenderedPage} from a body just read out of the build.
- *
- * `storeEtag` is the validator the store supplied, where it has one — it already describes these
- * exact bytes, so it is preferred over hashing them again, and only weakened.
+ * Assembles a {@link PrerenderedPage} from a body just read out of the build. `storeEtag` is the validator the
+ * store supplied, where it has one: it already describes these exact bytes, so it is weakened rather than
+ * replaced by a fresh hash.
  */
 export declare function toPrerenderedPage(body: Uint8Array<ArrayBuffer>, storeEtag?: string | null): Promise<PrerenderedPage>;
 /** A prerendered page, ready to serve: its body and a validator derived from those exact bytes. */
 export interface PrerenderedPage {
     /**
-     * The document or the flight payload, depending on which {@link PrerenderVariant} was read.
-     *
-     * Bytes rather than a string, because this is a *cache* entry served verbatim to every request that
-     * hits it — held as a string, each of those would pay a fresh UTF-8 encode of the whole page on the
-     * way out. Read once, encoded never.
+     * The document or the flight payload, depending on which {@link PrerenderVariant} was read. Bytes rather
+     * than a string, because this cache entry is served verbatim to every request that hits it — as a string,
+     * each would pay a fresh UTF-8 encode of the whole page.
      */
     body: Uint8Array<ArrayBuffer>;
     /**
-     * `Content-Length` for {@link body}, in bytes rather than characters. Served explicitly because
-     * Hono sets no length for an in-memory body, and a proxy or CDN in front is entitled to make
-     * decisions with it — whether gzipping this response is worth the framing, most obviously.
+     * `Content-Length` for {@link body}, in bytes. Served explicitly because Hono sets no length for an
+     * in-memory body, and a proxy in front is entitled to make decisions with it.
      */
     contentLength: string;
     /**
      * `ETag` for the page, so a revalidating client can be answered with a 304 instead of the body.
      *
-     * Deliberately **weak**. The bytes on the wire depend on whether something in front re-encoded
-     * them, and a strong validator would have to differ per coding — so the 200 and the 304 that
-     * revalidates it could disagree, and a cache would treat them as different pages. A weak tag says
-     * "the same representation", which is what stays true across content codings.
+     * Deliberately **weak**: the bytes on the wire depend on whether something in front re-encoded them, so a
+     * strong validator would differ per coding and a cache would treat the 200 and the 304 that revalidates it
+     * as different pages. A weak tag says "the same representation", which stays true across codings.
      */
     etag: string;
 }

package/dist/server/prerendered.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prerendered.d.ts","sourceRoot":"","sources":["../../src/server/prerendered.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEjD,eAAO,MAAM,QAAQ;;iBACX,IAAI,EAAE,YAAY;iBAAE,MAAM,EAAE,WAAW;iBAAE,WAAW,EAAE,WAAW;;;iBAC/D,IAAI,EAAE,WAAW;iBAAE,MAAM,EAAE,kBAAkB;iBAAE,WAAW,EAAE,kBAAkB;;CACU,CAAC;AAErG;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAyB,GAAG,MAAM,GAAG,IAAI,CAKhG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAGhG;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,SAAM,GAAG;IAAE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAC;IAAC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,CAAA;CAAE,CAU3I;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAO7E;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC,CAM1H;AAED,mGAAmG;AACnG,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAC9B;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,CAAC;CACd"}
+{"version":3,"file":"prerendered.d.ts","sourceRoot":"","sources":["../../src/server/prerendered.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEjD,eAAO,MAAM,QAAQ;;iBACX,IAAI,EAAE,YAAY;iBAAE,MAAM,EAAE,WAAW;iBAAE,WAAW,EAAE,WAAW;;;iBAC/D,IAAI,EAAE,WAAW;iBAAE,MAAM,EAAE,kBAAkB;iBAAE,WAAW,EAAE,kBAAkB;;CACU,CAAC;AAErG;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAyB,GAAG,MAAM,GAAG,IAAI,CAKhG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAGhG;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,SAAM,GAAG;IAAE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAC;IAAC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,CAAA;CAAE,CAU3I;AAED;;;GAGG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAO7E;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC,CAM1H;AAED,mGAAmG;AACnG,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAC9B;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/server/prerendered.js

@@ -1,22 +1,21 @@
 /**
- * Everything about a prerendered page that doesn't need a filesystem: where the build puts it, and
- * what it looks like once read back.
+ * Everything about a prerendered page that doesn't need a filesystem: where the build puts it, and what it
+ * looks like once read back.
  *
- * Split out of `ssg.ts` — which owns the writing and the reading, both through `node:fs` — because a
- * deploy target without a filesystem reads the very same layout out of an asset store, and importing
- * it from the fs module would drag `node:fs` and `node:crypto` into a bundle that has neither.
+ * Apart from `ssg.ts`, which does the reading and writing through `node:fs`, because a deploy target without a
+ * filesystem reads the same layout out of an asset store — and importing it from there would drag `node:fs`
+ * into a bundle that has neither.
  */
 export const VARIANTS = {
     html: { file: 'index.html', accept: 'text/html', contentType: 'text/html' },
     flight: { file: 'index.rsc', accept: 'text/x-component', contentType: 'text/x-component' },
 };
 /**
- * Where a route's prerendered output lives, relative to the output root — or `null` for a path that
- * cannot be prerendered at all (one with a param or a wildcard left in it).
+ * Where a route's prerendered output lives, relative to the output root — or `null` for a path that cannot be
+ * prerendered at all, one with a param or a wildcard left in it.
  *
- * Always `/`-separated, never the host's separator: the same string addresses a file on a filesystem
- * (`resolve()` and `join()` both accept forward slashes on Windows) and a key in an asset store,
- * where a backslash would simply be the wrong character.
+ * Always `/`-separated: the same string addresses a file on a filesystem, which accepts forward slashes on
+ * Windows too, and a key in an asset store, where a backslash would be the wrong character.
  */
 export function ssgFilePath(routePath, variant = 'html') {
     if (/[:*]/.test(routePath))
@@ -26,10 +25,8 @@ export function ssgFilePath(routePath, variant = 'html') {
     return trimmed === '' ? file : `${trimmed}/${file}`;
 }
 /**
- * {@link ssgFilePath} for a path that came off a request, so traversal is a miss rather than a lookup.
- *
- * The first line of defence for every deploy target: a store addressed by key has no `resolve()` to
- * fall back on, so `..` has to be refused here or not at all.
+ * {@link ssgFilePath} for a path that came off a request, so traversal is a miss rather than a lookup. A store
+ * addressed by key has no `resolve()` to fall back on, so `..` is refused here or not at all.
  */
 export function prerenderedRelPath(requestPath, variant) {
     if (/(^|\/)\.\.?(\/|$)/.test(requestPath))
@@ -37,12 +34,9 @@ export function prerenderedRelPath(requestPath, variant) {
     return ssgFilePath(requestPath, variant);
 }
 /**
- * A bounded, insertion-ordered cache of prerendered pages.
- *
- * Bounded so a site with thousands of prerendered pages keeps a working set rather than the whole
- * build in memory. Only *hits* are ever stored: caching misses would let anyone mint entries by
- * requesting paths that don't exist. The files are written at build time and never change while the
- * server is up, so an entry never needs invalidating.
+ * A bounded, insertion-ordered cache of prerendered pages, so a site with thousands of them keeps a working set
+ * rather than the whole build in memory. Only *hits* are stored — caching misses would let anyone mint entries
+ * by requesting paths that don't exist — and the files never change while the server is up.
  */
 export function createPageCache(max = 128) {
     const pages = new Map();
@@ -50,17 +44,15 @@ export function createPageCache(max = 128) {
         get: (key) => pages.get(key),
         set(key, page) {
             pages.set(key, page);
-            // Insertion-ordered, so the first key is the oldest. One entry in means at most one out.
+            // Insertion-ordered, so the first key is the oldest.
             if (pages.size > max)
                 pages.delete(pages.keys().next().value);
         },
     };
 }
 /**
- * A weak `ETag` for a page body — see {@link PrerenderedPage.etag} for why weak.
- *
- * Web Crypto rather than `node:crypto`, so the one implementation serves both a Node server and
- * `workerd`.
+ * A weak `ETag` for a page body — see {@link PrerenderedPage.etag} for why weak. Web Crypto rather than
+ * `node:crypto`, so one implementation serves both a Node server and `workerd`.
  */
 export async function weakEtag(body) {
     const digest = await crypto.subtle.digest('SHA-256', body);
@@ -71,10 +63,9 @@ export async function weakEtag(body) {
     return `W/"${base64url.slice(0, 22)}"`;
 }
 /**
- * Assembles a {@link PrerenderedPage} from a body just read out of the build.
- *
- * `storeEtag` is the validator the store supplied, where it has one — it already describes these
- * exact bytes, so it is preferred over hashing them again, and only weakened.
+ * Assembles a {@link PrerenderedPage} from a body just read out of the build. `storeEtag` is the validator the
+ * store supplied, where it has one: it already describes these exact bytes, so it is weakened rather than
+ * replaced by a fresh hash.
  */
 export async function toPrerenderedPage(body, storeEtag) {
     return {

package/dist/server/prerendered.js.map

@@ -1 +1 @@
-{"version":3,"file":"prerendered.js","sourceRoot":"","sources":["../../src/server/prerendered.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE;IAC3E,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,kBAAkB,EAAE,WAAW,EAAE,kBAAkB,EAAE;CACQ,CAAC;AAErG;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,SAAiB,EAAE,OAAO,GAAqB,MAAM;IAC/E,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC;IACpC,OAAO,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,EAAE,CAAC;AACtD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,WAAmB,EAAE,OAAyB;IAC/E,IAAI,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC;QAAE,OAAO,IAAI,CAAC;IACvD,OAAO,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,GAAG,GAAG,GAAG;IACvC,MAAM,KAAK,GAAG,IAAI,GAAG,EAA2B,CAAC;IACjD,OAAO;QACL,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;QAC5B,GAAG,CAAC,GAAG,EAAE,IAAI;YACX,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YACrB,yFAAyF;YACzF,IAAI,KAAK,CAAC,IAAI,GAAG,GAAG;gBAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAM,CAAC,CAAC;QACjE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,IAA6B;IAC1D,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;SACnE,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;SACnB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;SACnB,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACtB,OAAO,MAAM,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;AACzC,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,IAA6B,EAAE,SAAyB;IAC9F,OAAO;QACL,IAAI;QACJ,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;QACtC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,IAAI,CAAC;KAC7E,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Everything about a prerendered page that doesn't need a filesystem: where the build puts it, and\n * what it looks like once read back.\n *\n * Split out of `ssg.ts` — which owns the writing and the reading, both through `node:fs` — because a\n * deploy target without a filesystem reads the very same layout out of an asset store, and importing\n * it from the fs module would drag `node:fs` and `node:crypto` into a bundle that has neither.\n */\n\n/**\n * The two representations of a page, prerendered side by side: a hard load wants the HTML document, a\n * soft navigation asks the same URL for a flight payload. Without both, every in-app click would\n * re-render a page that was already built.\n */\nexport type PrerenderVariant = 'html' | 'flight';\n\nexport const VARIANTS = {\n  html: { file: 'index.html', accept: 'text/html', contentType: 'text/html' },\n  flight: { file: 'index.rsc', accept: 'text/x-component', contentType: 'text/x-component' },\n} as const satisfies Record<PrerenderVariant, { file: string; accept: string; contentType: string }>;\n\n/**\n * Where a route's prerendered output lives, relative to the output root — or `null` for a path that\n * cannot be prerendered at all (one with a param or a wildcard left in it).\n *\n * Always `/`-separated, never the host's separator: the same string addresses a file on a filesystem\n * (`resolve()` and `join()` both accept forward slashes on Windows) and a key in an asset store,\n * where a backslash would simply be the wrong character.\n */\nexport function ssgFilePath(routePath: string, variant: PrerenderVariant = 'html'): string | null {\n  if (/[:*]/.test(routePath)) return null;\n  const trimmed = routePath.replace(/^\\/+|\\/+$/g, '');\n  const file = VARIANTS[variant].file;\n  return trimmed === '' ? file : `${trimmed}/${file}`;\n}\n\n/**\n * {@link ssgFilePath} for a path that came off a request, so traversal is a miss rather than a lookup.\n *\n * The first line of defence for every deploy target: a store addressed by key has no `resolve()` to\n * fall back on, so `..` has to be refused here or not at all.\n */\nexport function prerenderedRelPath(requestPath: string, variant: PrerenderVariant): string | null {\n  if (/(^|\\/)\\.\\.?(\\/|$)/.test(requestPath)) return null;\n  return ssgFilePath(requestPath, variant);\n}\n\n/**\n * A bounded, insertion-ordered cache of prerendered pages.\n *\n * Bounded so a site with thousands of prerendered pages keeps a working set rather than the whole\n * build in memory. Only *hits* are ever stored: caching misses would let anyone mint entries by\n * requesting paths that don't exist. The files are written at build time and never change while the\n * server is up, so an entry never needs invalidating.\n */\nexport function createPageCache(max = 128): { get(key: string): PrerenderedPage | undefined; set(key: string, page: PrerenderedPage): void } {\n  const pages = new Map<string, PrerenderedPage>();\n  return {\n    get: (key) => pages.get(key),\n    set(key, page) {\n      pages.set(key, page);\n      // Insertion-ordered, so the first key is the oldest. One entry in means at most one out.\n      if (pages.size > max) pages.delete(pages.keys().next().value!);\n    },\n  };\n}\n\n/**\n * A weak `ETag` for a page body — see {@link PrerenderedPage.etag} for why weak.\n *\n * Web Crypto rather than `node:crypto`, so the one implementation serves both a Node server and\n * `workerd`.\n */\nexport async function weakEtag(body: Uint8Array<ArrayBuffer>): Promise<string> {\n  const digest = await crypto.subtle.digest('SHA-256', body);\n  const base64url = btoa(String.fromCharCode(...new Uint8Array(digest)))\n    .replace(/\\+/g, '-')\n    .replace(/\\//g, '_')\n    .replace(/=+$/, '');\n  return `W/\"${base64url.slice(0, 22)}\"`;\n}\n\n/**\n * Assembles a {@link PrerenderedPage} from a body just read out of the build.\n *\n * `storeEtag` is the validator the store supplied, where it has one — it already describes these\n * exact bytes, so it is preferred over hashing them again, and only weakened.\n */\nexport async function toPrerenderedPage(body: Uint8Array<ArrayBuffer>, storeEtag?: string | null): Promise<PrerenderedPage> {\n  return {\n    body,\n    contentLength: String(body.byteLength),\n    etag: storeEtag ? storeEtag.replace(/^(?!W\\/)/, 'W/') : await weakEtag(body),\n  };\n}\n\n/** A prerendered page, ready to serve: its body and a validator derived from those exact bytes. */\nexport interface PrerenderedPage {\n  /**\n   * The document or the flight payload, depending on which {@link PrerenderVariant} was read.\n   *\n   * Bytes rather than a string, because this is a *cache* entry served verbatim to every request that\n   * hits it — held as a string, each of those would pay a fresh UTF-8 encode of the whole page on the\n   * way out. Read once, encoded never.\n   */\n  body: Uint8Array<ArrayBuffer>;\n  /**\n   * `Content-Length` for {@link body}, in bytes rather than characters. Served explicitly because\n   * Hono sets no length for an in-memory body, and a proxy or CDN in front is entitled to make\n   * decisions with it — whether gzipping this response is worth the framing, most obviously.\n   */\n  contentLength: string;\n  /**\n   * `ETag` for the page, so a revalidating client can be answered with a 304 instead of the body.\n   *\n   * Deliberately **weak**. The bytes on the wire depend on whether something in front re-encoded\n   * them, and a strong validator would have to differ per coding — so the 200 and the 304 that\n   * revalidates it could disagree, and a cache would treat them as different pages. A weak tag says\n   * \"the same representation\", which is what stays true across content codings.\n   */\n  etag: string;\n}\n"]}
+{"version":3,"file":"prerendered.js","sourceRoot":"","sources":["../../src/server/prerendered.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE;IAC3E,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,kBAAkB,EAAE,WAAW,EAAE,kBAAkB,EAAE;CACQ,CAAC;AAErG;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,SAAiB,EAAE,OAAO,GAAqB,MAAM;IAC/E,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC;IACpC,OAAO,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,EAAE,CAAC;AACtD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,WAAmB,EAAE,OAAyB;IAC/E,IAAI,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC;QAAE,OAAO,IAAI,CAAC;IACvD,OAAO,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,GAAG,GAAG,GAAG;IACvC,MAAM,KAAK,GAAG,IAAI,GAAG,EAA2B,CAAC;IACjD,OAAO;QACL,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;QAC5B,GAAG,CAAC,GAAG,EAAE,IAAI;YACX,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YACrB,qDAAqD;YACrD,IAAI,KAAK,CAAC,IAAI,GAAG,GAAG;gBAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAM,CAAC,CAAC;QACjE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,IAA6B;IAC1D,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;SACnE,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;SACnB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;SACnB,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACtB,OAAO,MAAM,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,IAA6B,EAAE,SAAyB;IAC9F,OAAO;QACL,IAAI;QACJ,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;QACtC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,IAAI,CAAC;KAC7E,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Everything about a prerendered page that doesn't need a filesystem: where the build puts it, and what it\n * looks like once read back.\n *\n * Apart from `ssg.ts`, which does the reading and writing through `node:fs`, because a deploy target without a\n * filesystem reads the same layout out of an asset store — and importing it from there would drag `node:fs`\n * into a bundle that has neither.\n */\n\n/**\n * The two representations of a page, prerendered side by side: a hard load wants the HTML document, a soft\n * navigation asks the same URL for a flight payload. Without both, every in-app click would re-render a page\n * that was already built.\n */\nexport type PrerenderVariant = 'html' | 'flight';\n\nexport const VARIANTS = {\n  html: { file: 'index.html', accept: 'text/html', contentType: 'text/html' },\n  flight: { file: 'index.rsc', accept: 'text/x-component', contentType: 'text/x-component' },\n} as const satisfies Record<PrerenderVariant, { file: string; accept: string; contentType: string }>;\n\n/**\n * Where a route's prerendered output lives, relative to the output root — or `null` for a path that cannot be\n * prerendered at all, one with a param or a wildcard left in it.\n *\n * Always `/`-separated: the same string addresses a file on a filesystem, which accepts forward slashes on\n * Windows too, and a key in an asset store, where a backslash would be the wrong character.\n */\nexport function ssgFilePath(routePath: string, variant: PrerenderVariant = 'html'): string | null {\n  if (/[:*]/.test(routePath)) return null;\n  const trimmed = routePath.replace(/^\\/+|\\/+$/g, '');\n  const file = VARIANTS[variant].file;\n  return trimmed === '' ? file : `${trimmed}/${file}`;\n}\n\n/**\n * {@link ssgFilePath} for a path that came off a request, so traversal is a miss rather than a lookup. A store\n * addressed by key has no `resolve()` to fall back on, so `..` is refused here or not at all.\n */\nexport function prerenderedRelPath(requestPath: string, variant: PrerenderVariant): string | null {\n  if (/(^|\\/)\\.\\.?(\\/|$)/.test(requestPath)) return null;\n  return ssgFilePath(requestPath, variant);\n}\n\n/**\n * A bounded, insertion-ordered cache of prerendered pages, so a site with thousands of them keeps a working set\n * rather than the whole build in memory. Only *hits* are stored — caching misses would let anyone mint entries\n * by requesting paths that don't exist — and the files never change while the server is up.\n */\nexport function createPageCache(max = 128): { get(key: string): PrerenderedPage | undefined; set(key: string, page: PrerenderedPage): void } {\n  const pages = new Map<string, PrerenderedPage>();\n  return {\n    get: (key) => pages.get(key),\n    set(key, page) {\n      pages.set(key, page);\n      // Insertion-ordered, so the first key is the oldest.\n      if (pages.size > max) pages.delete(pages.keys().next().value!);\n    },\n  };\n}\n\n/**\n * A weak `ETag` for a page body — see {@link PrerenderedPage.etag} for why weak. Web Crypto rather than\n * `node:crypto`, so one implementation serves both a Node server and `workerd`.\n */\nexport async function weakEtag(body: Uint8Array<ArrayBuffer>): Promise<string> {\n  const digest = await crypto.subtle.digest('SHA-256', body);\n  const base64url = btoa(String.fromCharCode(...new Uint8Array(digest)))\n    .replace(/\\+/g, '-')\n    .replace(/\\//g, '_')\n    .replace(/=+$/, '');\n  return `W/\"${base64url.slice(0, 22)}\"`;\n}\n\n/**\n * Assembles a {@link PrerenderedPage} from a body just read out of the build. `storeEtag` is the validator the\n * store supplied, where it has one: it already describes these exact bytes, so it is weakened rather than\n * replaced by a fresh hash.\n */\nexport async function toPrerenderedPage(body: Uint8Array<ArrayBuffer>, storeEtag?: string | null): Promise<PrerenderedPage> {\n  return {\n    body,\n    contentLength: String(body.byteLength),\n    etag: storeEtag ? storeEtag.replace(/^(?!W\\/)/, 'W/') : await weakEtag(body),\n  };\n}\n\n/** A prerendered page, ready to serve: its body and a validator derived from those exact bytes. */\nexport interface PrerenderedPage {\n  /**\n   * The document or the flight payload, depending on which {@link PrerenderVariant} was read. Bytes rather\n   * than a string, because this cache entry is served verbatim to every request that hits it — as a string,\n   * each would pay a fresh UTF-8 encode of the whole page.\n   */\n  body: Uint8Array<ArrayBuffer>;\n  /**\n   * `Content-Length` for {@link body}, in bytes. Served explicitly because Hono sets no length for an\n   * in-memory body, and a proxy in front is entitled to make decisions with it.\n   */\n  contentLength: string;\n  /**\n   * `ETag` for the page, so a revalidating client can be answered with a 304 instead of the body.\n   *\n   * Deliberately **weak**: the bytes on the wire depend on whether something in front re-encoded them, so a\n   * strong validator would differ per coding and a cache would treat the 200 and the 304 that revalidates it\n   * as different pages. A weak tag says \"the same representation\", which stays true across codings.\n   */\n  etag: string;\n}\n"]}

package/dist/server/server-config.d.ts

@@ -1,51 +1,36 @@
 import type { RshonoConfig } from '../config.js';
 /**
- * The framework settings the server bundle needs at request time, fully resolved.
- *
- * The value is produced once by {@link resolveServerConfig} from `rshono.config.ts`
- * and compiled into the server bundle as the `__RSHONO_CONFIG__` literal (see
- * `builder/rspack-config.ts`) — there is no runtime env-var interface for these.
- *
- * Only what the *build* decides. The per-request security controls that used to live alongside these
- * — the CSRF check, the CSP, the body cap — are Hono middleware an app registers in `src/server.ts`,
- * where they can be configured per route and per environment instead of once per bundle.
+ * The framework settings the server bundle needs at request time, fully resolved — produced once by
+ * {@link resolveServerConfig} and compiled in as the `__RSHONO_CONFIG__` literal. There is no runtime env-var
+ * interface for these, and nothing here is a per-request concern: those are Hono middleware in `src/server.ts`.
  */
 export interface ServerConfig {
     /**
-     * `true` when the bundle came from `rshono dev`.
-     *
-     * Baked in rather than read from `process.env.NODE_ENV` at runtime: it is decided by which command
-     * produced the bundle, and a deploy target need not have a `process` to read it from.
+     * `true` when the bundle came from `rshono dev`. Baked in rather than read from `process.env.NODE_ENV`,
+     * because a deploy target need not have a `process`.
      */
     isDev: boolean;
     /** Honour `X-Forwarded-Host` / `-Proto` when resolving the browser-facing URL. Forced on in dev. */
     trustProxy: boolean;
     /**
-     * The output directory this bundle was written to, relative to the project root — `dist` for a
-     * build, something of its own for `rshono dev` (see `BUILD_OUT_DIR` / `DEV_OUT_DIR`).
-     *
-     * Carried into the bundle because `deploy/filesystem.ts` locates the static assets and the
-     * prerendered pages beside it at runtime, and only the compiler knows which directory it used.
+     * The output directory this bundle was written to, relative to the project root. Carried into the bundle
+     * because `deploy/filesystem.ts` locates the assets and prerendered pages beside it at runtime, and only the
+     * compiler knows which directory it used.
      */
     outDir: string;
 }
 /**
- * The framework's built-in defaults.
- *
- * `port` and `host` are not config fields at all — they come from `PORT` / `HOST` (or `--port`)
- * wherever the address is resolved, `deploy/node/runtime.ts` for a server bundle and `cli/dev.ts`
- * for the dev server, and this is what both fall back to.
+ * The framework's built-in defaults. `port` and `host` are not config fields — they come from `PORT` / `HOST`
+ * or `--port` wherever the address is resolved, and this is what those fall back to.
  */
 export declare const SERVER_DEFAULTS: {
     readonly port: 3000;
     readonly host: '0.0.0.0';
 };
 /**
- * Resolve the user's {@link RshonoConfig} into the {@link ServerConfig} baked into the bundle.
- *
- * `isDev` is a build-time input rather than a config field because it decides one thing the user
- * shouldn't have to: `trustProxy` is forced on under `rshono dev`, where the framework's own proxy
- * is the only way in (it sets the forwarded headers itself and binds to localhost).
+ * Resolves the user's config into the {@link ServerConfig} baked into the bundle. `isDev` is a build-time input
+ * rather than a config field because it decides one thing the user should not have to: `trustProxy` is forced on
+ * under `rshono dev`, where the framework's own localhost proxy is the only way in.
  */
 export declare function resolveServerConfig(config: RshonoConfig, { isDev, outDir }: {
     isDev: boolean;

package/dist/server/server-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-config.d.ts","sourceRoot":"","sources":["../../src/server/server-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAC;IACf,oGAAoG;IACpG,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;aAC1B,IAAI,EAAE,IAAI;aACV,IAAI,EAAE,SAAS;CACP,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAM7H"}
+{"version":3,"file":"server-config.d.ts","sourceRoot":"","sources":["../../src/server/server-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;IACf,oGAAoG;IACpG,UAAU,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;aAC1B,IAAI,EAAE,IAAI;aACV,IAAI,EAAE,SAAS;CACP,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAM7H"}

package/dist/server/server-config.js

@@ -1,20 +1,15 @@
 /**
- * The framework's built-in defaults.
- *
- * `port` and `host` are not config fields at all — they come from `PORT` / `HOST` (or `--port`)
- * wherever the address is resolved, `deploy/node/runtime.ts` for a server bundle and `cli/dev.ts`
- * for the dev server, and this is what both fall back to.
+ * The framework's built-in defaults. `port` and `host` are not config fields — they come from `PORT` / `HOST`
+ * or `--port` wherever the address is resolved, and this is what those fall back to.
  */
 export const SERVER_DEFAULTS = {
     port: 3000,
     host: '0.0.0.0',
 };
 /**
- * Resolve the user's {@link RshonoConfig} into the {@link ServerConfig} baked into the bundle.
- *
- * `isDev` is a build-time input rather than a config field because it decides one thing the user
- * shouldn't have to: `trustProxy` is forced on under `rshono dev`, where the framework's own proxy
- * is the only way in (it sets the forwarded headers itself and binds to localhost).
+ * Resolves the user's config into the {@link ServerConfig} baked into the bundle. `isDev` is a build-time input
+ * rather than a config field because it decides one thing the user should not have to: `trustProxy` is forced on
+ * under `rshono dev`, where the framework's own localhost proxy is the only way in.
  */
 export function resolveServerConfig(config, { isDev, outDir }) {
     return {

package/dist/server/server-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"server-config.js","sourceRoot":"","sources":["../../src/server/server-config.ts"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,SAAS;CACP,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAoB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAsC;IAC7G,OAAO;QACL,KAAK;QACL,UAAU,EAAE,KAAK,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,KAAK,CAAC;QACjD,MAAM;KACP,CAAC;AACJ,CAAC","sourcesContent":["import type { RshonoConfig } from '../config.js';\n\n/**\n * The framework settings the server bundle needs at request time, fully resolved.\n *\n * The value is produced once by {@link resolveServerConfig} from `rshono.config.ts`\n * and compiled into the server bundle as the `__RSHONO_CONFIG__` literal (see\n * `builder/rspack-config.ts`) — there is no runtime env-var interface for these.\n *\n * Only what the *build* decides. The per-request security controls that used to live alongside these\n * — the CSRF check, the CSP, the body cap — are Hono middleware an app registers in `src/server.ts`,\n * where they can be configured per route and per environment instead of once per bundle.\n */\nexport interface ServerConfig {\n  /**\n   * `true` when the bundle came from `rshono dev`.\n   *\n   * Baked in rather than read from `process.env.NODE_ENV` at runtime: it is decided by which command\n   * produced the bundle, and a deploy target need not have a `process` to read it from.\n   */\n  isDev: boolean;\n  /** Honour `X-Forwarded-Host` / `-Proto` when resolving the browser-facing URL. Forced on in dev. */\n  trustProxy: boolean;\n  /**\n   * The output directory this bundle was written to, relative to the project root — `dist` for a\n   * build, something of its own for `rshono dev` (see `BUILD_OUT_DIR` / `DEV_OUT_DIR`).\n   *\n   * Carried into the bundle because `deploy/filesystem.ts` locates the static assets and the\n   * prerendered pages beside it at runtime, and only the compiler knows which directory it used.\n   */\n  outDir: string;\n}\n\n/**\n * The framework's built-in defaults.\n *\n * `port` and `host` are not config fields at all — they come from `PORT` / `HOST` (or `--port`)\n * wherever the address is resolved, `deploy/node/runtime.ts` for a server bundle and `cli/dev.ts`\n * for the dev server, and this is what both fall back to.\n */\nexport const SERVER_DEFAULTS = {\n  port: 3000,\n  host: '0.0.0.0',\n} as const;\n\n/**\n * Resolve the user's {@link RshonoConfig} into the {@link ServerConfig} baked into the bundle.\n *\n * `isDev` is a build-time input rather than a config field because it decides one thing the user\n * shouldn't have to: `trustProxy` is forced on under `rshono dev`, where the framework's own proxy\n * is the only way in (it sets the forwarded headers itself and binds to localhost).\n */\nexport function resolveServerConfig(config: RshonoConfig, { isDev, outDir }: { isDev: boolean; outDir: string }): ServerConfig {\n  return {\n    isDev,\n    trustProxy: isDev || (config.trustProxy ?? false),\n    outDir,\n  };\n}\n"]}
+{"version":3,"file":"server-config.js","sourceRoot":"","sources":["../../src/server/server-config.ts"],"names":[],"mappings":"AAuBA;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,SAAS;CACP,CAAC;AAEX;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAoB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAsC;IAC7G,OAAO;QACL,KAAK;QACL,UAAU,EAAE,KAAK,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,KAAK,CAAC;QACjD,MAAM;KACP,CAAC;AACJ,CAAC","sourcesContent":["import type { RshonoConfig } from '../config.js';\n\n/**\n * The framework settings the server bundle needs at request time, fully resolved — produced once by\n * {@link resolveServerConfig} and compiled in as the `__RSHONO_CONFIG__` literal. There is no runtime env-var\n * interface for these, and nothing here is a per-request concern: those are Hono middleware in `src/server.ts`.\n */\nexport interface ServerConfig {\n  /**\n   * `true` when the bundle came from `rshono dev`. Baked in rather than read from `process.env.NODE_ENV`,\n   * because a deploy target need not have a `process`.\n   */\n  isDev: boolean;\n  /** Honour `X-Forwarded-Host` / `-Proto` when resolving the browser-facing URL. Forced on in dev. */\n  trustProxy: boolean;\n  /**\n   * The output directory this bundle was written to, relative to the project root. Carried into the bundle\n   * because `deploy/filesystem.ts` locates the assets and prerendered pages beside it at runtime, and only the\n   * compiler knows which directory it used.\n   */\n  outDir: string;\n}\n\n/**\n * The framework's built-in defaults. `port` and `host` are not config fields — they come from `PORT` / `HOST`\n * or `--port` wherever the address is resolved, and this is what those fall back to.\n */\nexport const SERVER_DEFAULTS = {\n  port: 3000,\n  host: '0.0.0.0',\n} as const;\n\n/**\n * Resolves the user's config into the {@link ServerConfig} baked into the bundle. `isDev` is a build-time input\n * rather than a config field because it decides one thing the user should not have to: `trustProxy` is forced on\n * under `rshono dev`, where the framework's own localhost proxy is the only way in.\n */\nexport function resolveServerConfig(config: RshonoConfig, { isDev, outDir }: { isDev: boolean; outDir: string }): ServerConfig {\n  return {\n    isDev,\n    trustProxy: isDev || (config.trustProxy ?? false),\n    outDir,\n  };\n}\n"]}

package/dist/server/shutdown.d.ts

@@ -1,7 +1,6 @@
 /**
- * Registers `handler` for both `SIGINT` and `SIGTERM` — the two signals a process
- * manager or `Ctrl-C` uses to ask for a graceful stop. Consolidates the shutdown
- * wiring shared by the server bundle and the `start` launcher.
+ * Registers `handler` for both `SIGINT` and `SIGTERM` — the two signals a process manager or `Ctrl-C` uses to
+ * ask for a graceful stop. Shared by the server bundle and the `start` launcher.
  */
 export declare function onShutdown(handler: (signal: NodeJS.Signals) => void): void;
 //# sourceMappingURL=shutdown.d.ts.map

package/dist/server/shutdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../src/server/shutdown.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,KAAK,IAAI,GAAG,IAAI,CAI1E"}
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../src/server/shutdown.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,KAAK,IAAI,GAAG,IAAI,CAI1E"}

package/dist/server/shutdown.js

@@ -1,7 +1,6 @@
 /**
- * Registers `handler` for both `SIGINT` and `SIGTERM` — the two signals a process
- * manager or `Ctrl-C` uses to ask for a graceful stop. Consolidates the shutdown
- * wiring shared by the server bundle and the `start` launcher.
+ * Registers `handler` for both `SIGINT` and `SIGTERM` — the two signals a process manager or `Ctrl-C` uses to
+ * ask for a graceful stop. Shared by the server bundle and the `start` launcher.
  */
 export function onShutdown(handler) {
     for (const signal of ['SIGINT', 'SIGTERM']) {

package/dist/server/shutdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"shutdown.js","sourceRoot":"","sources":["../../src/server/shutdown.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,OAAyC;IAClE,KAAK,MAAM,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAU,EAAE,CAAC;QACpD,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC","sourcesContent":["/**\n * Registers `handler` for both `SIGINT` and `SIGTERM` — the two signals a process\n * manager or `Ctrl-C` uses to ask for a graceful stop. Consolidates the shutdown\n * wiring shared by the server bundle and the `start` launcher.\n */\nexport function onShutdown(handler: (signal: NodeJS.Signals) => void): void {\n  for (const signal of ['SIGINT', 'SIGTERM'] as const) {\n    process.on(signal, () => handler(signal));\n  }\n}\n"]}
+{"version":3,"file":"shutdown.js","sourceRoot":"","sources":["../../src/server/shutdown.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,OAAyC;IAClE,KAAK,MAAM,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAU,EAAE,CAAC;QACpD,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC","sourcesContent":["/**\n * Registers `handler` for both `SIGINT` and `SIGTERM` — the two signals a process manager or `Ctrl-C` uses to\n * ask for a graceful stop. Shared by the server bundle and the `start` launcher.\n */\nexport function onShutdown(handler: (signal: NodeJS.Signals) => void): void {\n  for (const signal of ['SIGINT', 'SIGTERM'] as const) {\n    process.on(signal, () => handler(signal));\n  }\n}\n"]}