@rshono/core 1.0.0-rc.0

package/dist/deploy/cloudflare/runtime.js

@@ -0,0 +1,129 @@
+import { prerenderedRelPath } from '../../server/prerendered.js';
+/**
+ * Where `finalize` puts the prerendered pages inside the assets directory.
+ *
+ * A prefix of its own, rather than the pages' real URLs, is what keeps every page URL reaching the
+ * worker: one URL answers with a document or a flight payload depending on `Accept`, and a CDN keyed
+ * on the path alone cannot make that choice. Assets miss, the worker runs, the worker negotiates.
+ *
+ * The bytes are public either way — they are a public page — but they are also reachable under this
+ * path, so `finalize` writes a `_headers` rule marking the tree `noindex` rather than leaving a
+ * crawler to find the same page twice.
+ */
+const SSG_PREFIX = '/__ssg';
+function assetsBinding(c) {
+    const binding = c.env?.ASSETS;
+    return binding && typeof binding.fetch === 'function' ? binding : null;
+}
+/**
+ * Asks the assets binding for one path, or `null` when there is no binding at all — so a caller can
+ * tell "this deployment serves its assets some other way" from "that file is not there".
+ *
+ * `headers` is passed on only where the *client's* conditional and range requests should be answered
+ * by the store: forwarding an `If-None-Match` while fetching a page to serve would come back 304 with
+ * no body, which is a useless answer to "give me this page".
+ */
+async function assetResponse(c, path, headers) {
+    const binding = assetsBinding(c);
+    if (!binding)
+        return null;
+    // Resolved against the request so the asset request carries this deployment's own origin; only the
+    // path is ever used to look one up.
+    const url = new URL(path, c.req.url);
+    return binding.fetch(new Request(url, { method: 'GET', headers }));
+}
+/**
+ * Hands an asset response back as the app's own.
+ *
+ * Rebuilt rather than returned as-is because a `Response` that came from `fetch` has immutable
+ * headers, and the framework's outermost middleware sets its baseline security headers on the way out.
+ */
+function serveAsset(asset) {
+    return new Response(asset.body, asset);
+}
+/**
+ * A weak `ETag` for a body the asset store gave us no validator for.
+ *
+ * Web Crypto rather than `node:crypto`: this module is compiled for `workerd`, and the digest is the
+ * one thing here that has a platform-neutral form.
+ */
+async function weakEtag(body) {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(body));
+    const bytes = String.fromCharCode(...new Uint8Array(digest));
+    const base64url = btoa(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    return `W/"${base64url.slice(0, 22)}"`;
+}
+/**
+ * Prerendered pages, keyed by the path that produced them.
+ *
+ * Per isolate rather than per process, and bounded for the same reason the Node cache is: a site with
+ * thousands of prerendered pages should keep a working set, not the whole build. Only *hits* are
+ * cached, so nobody can mint entries by requesting paths that do not exist.
+ */
+const pageCache = new Map();
+const MAX_CACHED_PAGES = 128;
+/**
+ * Cloudflare Workers: the host owns the process, so there is nothing to listen on; the CDN owns the
+ * assets, so there is nothing to serve from disk; and there is no filesystem, so `.env` files and a
+ * streaming gzip are both out.
+ *
+ * What is left is the assets binding, which every read here goes through.
+ */
+export const runtime = {
+    serveApp(app) {
+        // What Workers looks for on the default export. `app.fetch` already takes `(request, env, ctx)`,
+        // which is why bindings arrive as `c.env` — and so why `getContext().env` sees them.
+        return { fetch: app.fetch };
+    },
+    mountStaticAssets(app) {
+        // Normally dead: with the scaffolded config the CDN answers `/_static/*` before the worker is
+        // invoked at all. It exists so the deployment is still correct — if slower — under an assets
+        // configuration that routes everything to the worker first.
+        app.on(['GET', 'HEAD'], '/_static/*', async (c, next) => {
+            const asset = await assetResponse(c, c.req.path, c.req.raw.headers);
+            return asset && asset.status !== 404 ? serveAsset(asset) : next();
+        });
+    },
+    mountPublicFallback(app) {
+        app.on(['GET', 'HEAD'], '/*', async (c, next) => {
+            // The prerender tree lives in the same store; it is reachable directly from the CDN by design,
+            // but the app itself only ever serves it through `readPrerendered`, negotiated on `Accept`.
+            if (c.req.path.startsWith(`${SSG_PREFIX}/`))
+                return next();
+            const asset = await assetResponse(c, c.req.path, c.req.raw.headers);
+            return asset && asset.status !== 404 ? serveAsset(asset) : next();
+        });
+    },
+    async readPrerendered(c, variant) {
+        const relPath = prerenderedRelPath(c.req.path, variant);
+        if (relPath === null)
+            return null;
+        const key = `${variant}\0${relPath}`;
+        const cached = pageCache.get(key);
+        if (cached)
+            return cached;
+        const asset = await assetResponse(c, `${SSG_PREFIX}/${relPath}`);
+        if (!asset || asset.status !== 200)
+            return null;
+        const body = await asset.text();
+        const page = {
+            body,
+            contentLength: String(new TextEncoder().encode(body).byteLength),
+            // The store's own validator where it has one — it already describes these exact bytes. Weakened
+            // because compression downstream would make a strong one wrong for the compressed encoding.
+            etag: asset.headers.get('etag')?.replace(/^(?!W\/)/, 'W/') ?? (await weakEtag(body)),
+        };
+        pageCache.set(key, page);
+        if (pageCache.size > MAX_CACHED_PAGES)
+            pageCache.delete(pageCache.keys().next().value);
+        return page;
+    },
+    // Cloudflare compresses on the way out at the edge, and `workerd` has no `node:zlib` stream to do
+    // it with anyway. Doing it here would only spend CPU on bytes the edge is about to re-encode.
+    compress: null,
+    loadEnv() {
+        // Nothing to load: a Worker has no filesystem and no `.env`. Secrets and bindings arrive per
+        // request as `c.env`, which `getContext().env` already merges — see `runtime/context.ts`.
+    },
+};
+//# sourceMappingURL=runtime.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/deploy/cloudflare/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Context, Hono } from 'hono';\nimport { prerenderedRelPath, type PrerenderedPage } from '../../server/prerendered.js';\nimport type { DeployRuntime } from '../contract.js';\n\n/**\n * Where `finalize` puts the prerendered pages inside the assets directory.\n *\n * A prefix of its own, rather than the pages' real URLs, is what keeps every page URL reaching the\n * worker: one URL answers with a document or a flight payload depending on `Accept`, and a CDN keyed\n * on the path alone cannot make that choice. Assets miss, the worker runs, the worker negotiates.\n *\n * The bytes are public either way — they are a public page — but they are also reachable under this\n * path, so `finalize` writes a `_headers` rule marking the tree `noindex` rather than leaving a\n * crawler to find the same page twice.\n */\nconst SSG_PREFIX = '/__ssg';\n\n/** The Workers Assets binding, as much of it as this file uses. */\ninterface AssetsBinding {\n  fetch(request: Request): Promise<Response>;\n}\n\nfunction assetsBinding(c: Context): AssetsBinding | null {\n  const binding = (c.env as { ASSETS?: AssetsBinding } | undefined)?.ASSETS;\n  return binding && typeof binding.fetch === 'function' ? binding : null;\n}\n\n/**\n * Asks the assets binding for one path, or `null` when there is no binding at all — so a caller can\n * tell \"this deployment serves its assets some other way\" from \"that file is not there\".\n *\n * `headers` is passed on only where the *client's* conditional and range requests should be answered\n * by the store: forwarding an `If-None-Match` while fetching a page to serve would come back 304 with\n * no body, which is a useless answer to \"give me this page\".\n */\nasync function assetResponse(c: Context, path: string, headers?: Headers): Promise<Response | null> {\n  const binding = assetsBinding(c);\n  if (!binding) return null;\n  // Resolved against the request so the asset request carries this deployment's own origin; only the\n  // path is ever used to look one up.\n  const url = new URL(path, c.req.url);\n  return binding.fetch(new Request(url, { method: 'GET', headers }));\n}\n\n/**\n * Hands an asset response back as the app's own.\n *\n * Rebuilt rather than returned as-is because a `Response` that came from `fetch` has immutable\n * headers, and the framework's outermost middleware sets its baseline security headers on the way out.\n */\nfunction serveAsset(asset: Response): Response {\n  return new Response(asset.body, asset);\n}\n\n/**\n * A weak `ETag` for a body the asset store gave us no validator for.\n *\n * Web Crypto rather than `node:crypto`: this module is compiled for `workerd`, and the digest is the\n * one thing here that has a platform-neutral form.\n */\nasync function weakEtag(body: string): Promise<string> {\n  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(body));\n  const bytes = String.fromCharCode(...new Uint8Array(digest));\n  const base64url = btoa(bytes).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n  return `W/\"${base64url.slice(0, 22)}\"`;\n}\n\n/**\n * Prerendered pages, keyed by the path that produced them.\n *\n * Per isolate rather than per process, and bounded for the same reason the Node cache is: a site with\n * thousands of prerendered pages should keep a working set, not the whole build. Only *hits* are\n * cached, so nobody can mint entries by requesting paths that do not exist.\n */\nconst pageCache = new Map<string, PrerenderedPage>();\nconst MAX_CACHED_PAGES = 128;\n\n/**\n * Cloudflare Workers: the host owns the process, so there is nothing to listen on; the CDN owns the\n * assets, so there is nothing to serve from disk; and there is no filesystem, so `.env` files and a\n * streaming gzip are both out.\n *\n * What is left is the assets binding, which every read here goes through.\n */\nexport const runtime: DeployRuntime = {\n  serveApp(app: Hono): unknown {\n    // What Workers looks for on the default export. `app.fetch` already takes `(request, env, ctx)`,\n    // which is why bindings arrive as `c.env` — and so why `getContext().env` sees them.\n    return { fetch: app.fetch };\n  },\n\n  mountStaticAssets(app: Hono): void {\n    // Normally dead: with the scaffolded config the CDN answers `/_static/*` before the worker is\n    // invoked at all. It exists so the deployment is still correct — if slower — under an assets\n    // configuration that routes everything to the worker first.\n    app.on(['GET', 'HEAD'], '/_static/*', async (c, next) => {\n      const asset = await assetResponse(c, c.req.path, c.req.raw.headers);\n      return asset && asset.status !== 404 ? serveAsset(asset) : next();\n    });\n  },\n\n  mountPublicFallback(app: Hono): void {\n    app.on(['GET', 'HEAD'], '/*', async (c, next) => {\n      // The prerender tree lives in the same store; it is reachable directly from the CDN by design,\n      // but the app itself only ever serves it through `readPrerendered`, negotiated on `Accept`.\n      if (c.req.path.startsWith(`${SSG_PREFIX}/`)) return next();\n      const asset = await assetResponse(c, c.req.path, c.req.raw.headers);\n      return asset && asset.status !== 404 ? serveAsset(asset) : next();\n    });\n  },\n\n  async readPrerendered(c: Context, variant): Promise<PrerenderedPage | null> {\n    const relPath = prerenderedRelPath(c.req.path, variant);\n    if (relPath === null) return null;\n\n    const key = `${variant}\\0${relPath}`;\n    const cached = pageCache.get(key);\n    if (cached) return cached;\n\n    const asset = await assetResponse(c, `${SSG_PREFIX}/${relPath}`);\n    if (!asset || asset.status !== 200) return null;\n\n    const body = await asset.text();\n    const page: PrerenderedPage = {\n      body,\n      contentLength: String(new TextEncoder().encode(body).byteLength),\n      // The store's own validator where it has one — it already describes these exact bytes. Weakened\n      // because compression downstream would make a strong one wrong for the compressed encoding.\n      etag: asset.headers.get('etag')?.replace(/^(?!W\\/)/, 'W/') ?? (await weakEtag(body)),\n    };\n\n    pageCache.set(key, page);\n    if (pageCache.size > MAX_CACHED_PAGES) pageCache.delete(pageCache.keys().next().value!);\n    return page;\n  },\n\n  // Cloudflare compresses on the way out at the edge, and `workerd` has no `node:zlib` stream to do\n  // it with anyway. Doing it here would only spend CPU on bytes the edge is about to re-encode.\n  compress: null,\n\n  loadEnv(): void {\n    // Nothing to load: a Worker has no filesystem and no `.env`. Secrets and bindings arrive per\n    // request as `c.env`, which `getContext().env` already merges — see `runtime/context.ts`.\n  },\n};\n"]}

package/dist/deploy/contract.d.ts

@@ -0,0 +1,65 @@
+import type { Context, Hono, MiddlewareHandler } from 'hono';
+import type { PrerenderVariant, PrerenderedPage } from '../server/prerendered.js';
+/**
+ * A hosting platform rshono can build for. Selected with {@link RSHonoConfig.deploy}, the
+ * `--deploy` flag or the `RSHONO_DEPLOY` env var, and resolved to a preset by `deploy/presets.ts`.
+ *
+ * `rshono dev` always runs the `node` server whatever this says — the dev server owns the process,
+ * watches both compilers and fronts them on one port, none of which a hosting platform provides.
+ */
+export type DeployTarget = 'node' | 'cloudflare' | 'bun' | 'deno' | 'vercel' | 'netlify' | 'aws-lambda';
+/**
+ * Everything the app server needs from the platform it is running on.
+ *
+ * One preset implements this per target, and the `@rshono/deploy` alias resolves to exactly that
+ * module at build time (see `builder/rspack-config.ts`), so only the selected platform's code is
+ * ever in the bundle. `runtime/entry.rsc.tsx` is written against this interface and nothing else —
+ * it is the whole of what "which platform is this" means at request time.
+ *
+ * The split is deliberately by *capability*, not by runtime: a platform with a filesystem reuses the
+ * implementations in `server/` (`static.ts`, `compress.ts`, `ssg.ts`) and only differs in how the
+ * finished app is handed over.
+ */
+export interface DeployRuntime {
+    /**
+     * Hands the assembled app to the platform, and returns whatever the entry module should
+     * `export default` there.
+     *
+     * The two shapes hosting takes, in one call: where rshono owns the process (node, bun, deno) this
+     * binds a port and returns nothing; where the host owns it, it returns the export the platform
+     * looks for — `{ fetch }` on Workers, a handler function on Vercel/Netlify/Lambda.
+     */
+    serveApp(app: Hono): unknown;
+    /**
+     * Mounts the hashed client bundle at `/_static`. A no-op where the platform's own CDN serves it
+     * before a request ever reaches the app.
+     *
+     * Called *before* the app's routes, so the bundle is never shadowed by one.
+     */
+    mountStaticAssets(app: Hono): void;
+    /**
+     * Mounts the `public/` fallback at the web root — files served verbatim, and only for paths no
+     * route claimed. Called *after* every route for exactly that reason.
+     */
+    mountPublicFallback(app: Hono): void;
+    /**
+     * Reads the page prerendered for `c.req.path` by `rshono build`, or `null` when there is none (in
+     * which case the route renders per request, which is always a valid answer).
+     *
+     * Takes the whole {@link Context} rather than just the path because on a platform with no
+     * filesystem the store *is* a request-scoped binding — `c.env.ASSETS` on Workers. The path is
+     * untrusted either way, so an implementation has to treat traversal as a miss, not a lookup
+     * (see `prerenderedRelPath`).
+     */
+    readPrerendered(c: Context, variant: PrerenderVariant): Promise<PrerenderedPage | null>;
+    /**
+     * Response compression, or `null` where the platform already compresses on the way out (and
+     * doing it twice would only cost CPU) or cannot stream a compressor at all.
+     *
+     * Whether it is *used* is still the app's `compress` setting; this is only whether it is available.
+     */
+    compress: MiddlewareHandler | null;
+    /** Loads `.env` files, where the platform has a filesystem to read them from. Env is bindings elsewhere. */
+    loadEnv(): void;
+}
+//# sourceMappingURL=contract.d.ts.map

package/dist/deploy/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/deploy/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,YAAY,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,YAAY,CAAC;AAExG;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO,CAAC;IAC7B;;;;;OAKG;IACH,iBAAiB,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC;IACnC;;;OAGG;IACH,mBAAmB,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC;IACrC;;;;;;;;OAQG;IACH,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACxF;;;;;OAKG;IACH,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACnC,4GAA4G;IAC5G,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/deploy/contract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contract.js.map

package/dist/deploy/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../src/deploy/contract.ts"],"names":[],"mappings":"","sourcesContent":["import type { Context, Hono, MiddlewareHandler } from 'hono';\nimport type { PrerenderVariant, PrerenderedPage } from '../server/prerendered.js';\n\n/**\n * A hosting platform rshono can build for. Selected with {@link RSHonoConfig.deploy}, the\n * `--deploy` flag or the `RSHONO_DEPLOY` env var, and resolved to a preset by `deploy/presets.ts`.\n *\n * `rshono dev` always runs the `node` server whatever this says — the dev server owns the process,\n * watches both compilers and fronts them on one port, none of which a hosting platform provides.\n */\nexport type DeployTarget = 'node' | 'cloudflare' | 'bun' | 'deno' | 'vercel' | 'netlify' | 'aws-lambda';\n\n/**\n * Everything the app server needs from the platform it is running on.\n *\n * One preset implements this per target, and the `@rshono/deploy` alias resolves to exactly that\n * module at build time (see `builder/rspack-config.ts`), so only the selected platform's code is\n * ever in the bundle. `runtime/entry.rsc.tsx` is written against this interface and nothing else —\n * it is the whole of what \"which platform is this\" means at request time.\n *\n * The split is deliberately by *capability*, not by runtime: a platform with a filesystem reuses the\n * implementations in `server/` (`static.ts`, `compress.ts`, `ssg.ts`) and only differs in how the\n * finished app is handed over.\n */\nexport interface DeployRuntime {\n  /**\n   * Hands the assembled app to the platform, and returns whatever the entry module should\n   * `export default` there.\n   *\n   * The two shapes hosting takes, in one call: where rshono owns the process (node, bun, deno) this\n   * binds a port and returns nothing; where the host owns it, it returns the export the platform\n   * looks for — `{ fetch }` on Workers, a handler function on Vercel/Netlify/Lambda.\n   */\n  serveApp(app: Hono): unknown;\n  /**\n   * Mounts the hashed client bundle at `/_static`. A no-op where the platform's own CDN serves it\n   * before a request ever reaches the app.\n   *\n   * Called *before* the app's routes, so the bundle is never shadowed by one.\n   */\n  mountStaticAssets(app: Hono): void;\n  /**\n   * Mounts the `public/` fallback at the web root — files served verbatim, and only for paths no\n   * route claimed. Called *after* every route for exactly that reason.\n   */\n  mountPublicFallback(app: Hono): void;\n  /**\n   * Reads the page prerendered for `c.req.path` by `rshono build`, or `null` when there is none (in\n   * which case the route renders per request, which is always a valid answer).\n   *\n   * Takes the whole {@link Context} rather than just the path because on a platform with no\n   * filesystem the store *is* a request-scoped binding — `c.env.ASSETS` on Workers. The path is\n   * untrusted either way, so an implementation has to treat traversal as a miss, not a lookup\n   * (see `prerenderedRelPath`).\n   */\n  readPrerendered(c: Context, variant: PrerenderVariant): Promise<PrerenderedPage | null>;\n  /**\n   * Response compression, or `null` where the platform already compresses on the way out (and\n   * doing it twice would only cost CPU) or cannot stream a compressor at all.\n   *\n   * Whether it is *used* is still the app's `compress` setting; this is only whether it is available.\n   */\n  compress: MiddlewareHandler | null;\n  /** Loads `.env` files, where the platform has a filesystem to read them from. Env is bindings elsewhere. */\n  loadEnv(): void;\n}\n"]}

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

@@ -0,0 +1,11 @@
+import type { DeployRuntime } from '../contract.js';
+/**
+ * Deno: `deno serve` and Deno Deploy both look for a `fetch` on the default export, so the handoff is
+ * an export rather than a listener — which is also what makes one build work for both.
+ *
+ * The compiler settings stay Node's deliberately. Deno's `node:` compatibility covers everything
+ * `server/` uses, so the Node builds of React and the RSC runtime run as-is, and the alternative would
+ * be a second bundle shape to keep working for no behavioural gain.
+ */
+export declare const runtime: DeployRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/deploy/deno/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/deploy/deno/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE,aAMrB,CAAC"}

package/dist/deploy/deno/runtime.js

@@ -0,0 +1,16 @@
+import { fileSystemRuntime } from '../filesystem.js';
+/**
+ * Deno: `deno serve` and Deno Deploy both look for a `fetch` on the default export, so the handoff is
+ * an export rather than a listener — which is also what makes one build work for both.
+ *
+ * The compiler settings stay Node's deliberately. Deno's `node:` compatibility covers everything
+ * `server/` uses, so the Node builds of React and the RSC runtime run as-is, and the alternative would
+ * be a second bundle shape to keep working for no behavioural gain.
+ */
+export const runtime = {
+    ...fileSystemRuntime,
+    serveApp(app) {
+        return { fetch: app.fetch };
+    },
+};
+//# sourceMappingURL=runtime.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/deploy/deno/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,OAAO,GAAkB;IACpC,GAAG,iBAAiB;IAEpB,QAAQ,CAAC,GAAS;QAChB,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;CACF,CAAC","sourcesContent":["import type { Hono } from 'hono';\nimport type { DeployRuntime } from '../contract.js';\nimport { fileSystemRuntime } from '../filesystem.js';\n\n/**\n * Deno: `deno serve` and Deno Deploy both look for a `fetch` on the default export, so the handoff is\n * an export rather than a listener — which is also what makes one build work for both.\n *\n * The compiler settings stay Node's deliberately. Deno's `node:` compatibility covers everything\n * `server/` uses, so the Node builds of React and the RSC runtime run as-is, and the alternative would\n * be a second bundle shape to keep working for no behavioural gain.\n */\nexport const runtime: DeployRuntime = {\n  ...fileSystemRuntime,\n\n  serveApp(app: Hono): unknown {\n    return { fetch: app.fetch };\n  },\n};\n"]}

package/dist/deploy/filesystem.d.ts

@@ -0,0 +1,10 @@
+import type { DeployRuntime } from './contract.js';
+/**
+ * Everything a deploy target with a real filesystem does the same way.
+ *
+ * Node, Bun, Deno and the serverless runtimes that unpack a bundle onto disk (Vercel, Netlify, Lambda)
+ * differ only in how the finished app is handed over — so each of those presets is this object plus
+ * its own {@link DeployRuntime.serveApp}, and the implementations live once, in `server/`.
+ */
+export declare const fileSystemRuntime: Omit<DeployRuntime, 'serveApp'>;
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/deploy/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/deploy/filesystem.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAqBnD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAmB7D,CAAC"}

package/dist/deploy/filesystem.js

@@ -0,0 +1,47 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { compress } from '../server/compress.js';
+import { loadEnvFiles } from '../server/load-env.js';
+import { readPrerendered } from '../server/ssg.js';
+import { createPublicFallback, createStaticAssetsApp } from '../server/static.js';
+const isDev = __RSHONO_CONFIG__.isDev;
+/**
+ * The project root, derived from where the bundle itself ended up: `rshono build` writes the server
+ * bundle to `<root>/dist/server/main.mjs`, and this module is bundled into it, which makes
+ * `import.meta.dirname` `<root>/dist/server` at runtime.
+ *
+ * Derived rather than baked in at build time on purpose: an absolute build-time path would tie the
+ * output to the machine that produced it, and building in CI to run somewhere else is the normal case.
+ * A preset that relocates the bundle keeps `dist/server/main.mjs` intact inside its own layout for
+ * exactly this reason.
+ */
+const rootDir = join(import.meta.dirname, '..', '..');
+const staticDir = join(rootDir, 'dist', 'static');
+const ssgDir = join(rootDir, 'dist', 'ssg');
+/** `public/` is copied into `dist/` by the build, so a deployed build is self-contained; dev reads the source. */
+const publicDir = isDev ? join(rootDir, 'public') : join(rootDir, 'dist', 'public');
+/**
+ * Everything a deploy target with a real filesystem does the same way.
+ *
+ * Node, Bun, Deno and the serverless runtimes that unpack a bundle onto disk (Vercel, Netlify, Lambda)
+ * differ only in how the finished app is handed over — so each of those presets is this object plus
+ * its own {@link DeployRuntime.serveApp}, and the implementations live once, in `server/`.
+ */
+export const fileSystemRuntime = {
+    mountStaticAssets(app) {
+        app.route('/_static', createStaticAssetsApp({ root: staticDir, isDev }));
+    },
+    mountPublicFallback(app) {
+        if (!existsSync(publicDir))
+            return;
+        app.on(['GET', 'HEAD'], '/*', createPublicFallback({ root: publicDir, isDev }));
+    },
+    readPrerendered(c, variant) {
+        return readPrerendered(ssgDir, c.req.path, variant);
+    },
+    compress: compress(),
+    loadEnv() {
+        loadEnvFiles(rootDir);
+    },
+};
+//# sourceMappingURL=filesystem.js.map

package/dist/deploy/filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.js","sourceRoot":"","sources":["../../src/deploy/filesystem.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGlF,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC;AAEtC;;;;;;;;;GASG;AACH,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAEtD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AAClD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAC5C,kHAAkH;AAClH,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AAEpF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAoC;IAChE,iBAAiB,CAAC,GAAS;QACzB,GAAG,CAAC,KAAK,CAAC,UAAU,EAAE,qBAAqB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED,mBAAmB,CAAC,GAAS;QAC3B,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;YAAE,OAAO;QACnC,GAAG,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,oBAAoB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAClF,CAAC;IAED,eAAe,CAAC,CAAC,EAAE,OAAO;QACxB,OAAO,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAED,QAAQ,EAAE,QAAQ,EAAE;IAEpB,OAAO;QACL,YAAY,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC;CACF,CAAC","sourcesContent":["import type { Hono } from 'hono';\nimport { existsSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { compress } from '../server/compress.js';\nimport { loadEnvFiles } from '../server/load-env.js';\nimport { readPrerendered } from '../server/ssg.js';\nimport { createPublicFallback, createStaticAssetsApp } from '../server/static.js';\nimport type { DeployRuntime } from './contract.js';\n\nconst isDev = __RSHONO_CONFIG__.isDev;\n\n/**\n * The project root, derived from where the bundle itself ended up: `rshono build` writes the server\n * bundle to `<root>/dist/server/main.mjs`, and this module is bundled into it, which makes\n * `import.meta.dirname` `<root>/dist/server` at runtime.\n *\n * Derived rather than baked in at build time on purpose: an absolute build-time path would tie the\n * output to the machine that produced it, and building in CI to run somewhere else is the normal case.\n * A preset that relocates the bundle keeps `dist/server/main.mjs` intact inside its own layout for\n * exactly this reason.\n */\nconst rootDir = join(import.meta.dirname, '..', '..');\n\nconst staticDir = join(rootDir, 'dist', 'static');\nconst ssgDir = join(rootDir, 'dist', 'ssg');\n/** `public/` is copied into `dist/` by the build, so a deployed build is self-contained; dev reads the source. */\nconst publicDir = isDev ? join(rootDir, 'public') : join(rootDir, 'dist', 'public');\n\n/**\n * Everything a deploy target with a real filesystem does the same way.\n *\n * Node, Bun, Deno and the serverless runtimes that unpack a bundle onto disk (Vercel, Netlify, Lambda)\n * differ only in how the finished app is handed over — so each of those presets is this object plus\n * its own {@link DeployRuntime.serveApp}, and the implementations live once, in `server/`.\n */\nexport const fileSystemRuntime: Omit<DeployRuntime, 'serveApp'> = {\n  mountStaticAssets(app: Hono): void {\n    app.route('/_static', createStaticAssetsApp({ root: staticDir, isDev }));\n  },\n\n  mountPublicFallback(app: Hono): void {\n    if (!existsSync(publicDir)) return;\n    app.on(['GET', 'HEAD'], '/*', createPublicFallback({ root: publicDir, isDev }));\n  },\n\n  readPrerendered(c, variant) {\n    return readPrerendered(ssgDir, c.req.path, variant);\n  },\n\n  compress: compress(),\n\n  loadEnv(): void {\n    loadEnvFiles(rootDir);\n  },\n};\n"]}

package/dist/deploy/listen.d.ts

@@ -0,0 +1,20 @@
+/** What to bind, for the targets where rshono owns the process rather than being handed a request. */
+export interface ListenAddress {
+    port: number;
+    hostname: string;
+}
+/**
+ * Resolves the address to listen on: an explicit override (the dev server, which picks the port for
+ * its worker) beats the environment, which beats `rshono.config.ts`, which beats the built-in default.
+ *
+ * `PORT` and `HOST` stay env-overridable because that is the deployment convention everywhere this
+ * runs — a container, a process manager, a PaaS. `??` rather than `||` so an explicit `PORT=0`, which
+ * means "any free port", is honoured.
+ */
+export declare function listenAddress(overrides?: {
+    port?: number;
+    hostname?: string;
+}): ListenAddress;
+/** What to print once listening — `localhost` rather than the wildcard the socket is actually bound to. */
+export declare function readyMessage({ port, hostname }: ListenAddress): string;
+//# sourceMappingURL=listen.d.ts.map

package/dist/deploy/listen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listen.d.ts","sourceRoot":"","sources":["../../src/deploy/listen.ts"],"names":[],"mappings":"AAOA,sGAAsG;AACtG,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,SAAS,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAM7F;AAED,2GAA2G;AAC3G,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,aAAa,GAAG,MAAM,CAEtE"}

package/dist/deploy/listen.js

@@ -0,0 +1,24 @@
+import { SERVER_DEFAULTS } from '../server/server-config.js';
+const CONFIG = __RSHONO_CONFIG__;
+/** Bound to every interface — so the address printed on start is `localhost`, not this. */
+const WILDCARD_HOST = '0.0.0.0';
+/**
+ * Resolves the address to listen on: an explicit override (the dev server, which picks the port for
+ * its worker) beats the environment, which beats `rshono.config.ts`, which beats the built-in default.
+ *
+ * `PORT` and `HOST` stay env-overridable because that is the deployment convention everywhere this
+ * runs — a container, a process manager, a PaaS. `??` rather than `||` so an explicit `PORT=0`, which
+ * means "any free port", is honoured.
+ */
+export function listenAddress(overrides) {
+    const envPort = process.env.PORT !== undefined ? Number(process.env.PORT) : undefined;
+    return {
+        port: overrides?.port ?? envPort ?? CONFIG.port ?? SERVER_DEFAULTS.port,
+        hostname: overrides?.hostname ?? process.env.HOST ?? CONFIG.host ?? SERVER_DEFAULTS.host,
+    };
+}
+/** What to print once listening — `localhost` rather than the wildcard the socket is actually bound to. */
+export function readyMessage({ port, hostname }) {
+    return `  ➜ rshono serving on http://${hostname === WILDCARD_HOST ? 'localhost' : hostname}:${port}`;
+}
+//# sourceMappingURL=listen.js.map

package/dist/deploy/listen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listen.js","sourceRoot":"","sources":["../../src/deploy/listen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,MAAM,MAAM,GAAG,iBAAiB,CAAC;AAEjC,2FAA2F;AAC3F,MAAM,aAAa,GAAG,SAAS,CAAC;AAQhC;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,SAAgD;IAC5E,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACtF,OAAO;QACL,IAAI,EAAE,SAAS,EAAE,IAAI,IAAI,OAAO,IAAI,MAAM,CAAC,IAAI,IAAI,eAAe,CAAC,IAAI;QACvE,QAAQ,EAAE,SAAS,EAAE,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,IAAI,eAAe,CAAC,IAAI;KACzF,CAAC;AACJ,CAAC;AAED,2GAA2G;AAC3G,MAAM,UAAU,YAAY,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAiB;IAC5D,OAAO,gCAAgC,QAAQ,KAAK,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,IAAI,IAAI,EAAE,CAAC;AACvG,CAAC","sourcesContent":["import { SERVER_DEFAULTS } from '../server/server-config.js';\n\nconst CONFIG = __RSHONO_CONFIG__;\n\n/** Bound to every interface — so the address printed on start is `localhost`, not this. */\nconst WILDCARD_HOST = '0.0.0.0';\n\n/** What to bind, for the targets where rshono owns the process rather than being handed a request. */\nexport interface ListenAddress {\n  port: number;\n  hostname: string;\n}\n\n/**\n * Resolves the address to listen on: an explicit override (the dev server, which picks the port for\n * its worker) beats the environment, which beats `rshono.config.ts`, which beats the built-in default.\n *\n * `PORT` and `HOST` stay env-overridable because that is the deployment convention everywhere this\n * runs — a container, a process manager, a PaaS. `??` rather than `||` so an explicit `PORT=0`, which\n * means \"any free port\", is honoured.\n */\nexport function listenAddress(overrides?: { port?: number; hostname?: string }): ListenAddress {\n  const envPort = process.env.PORT !== undefined ? Number(process.env.PORT) : undefined;\n  return {\n    port: overrides?.port ?? envPort ?? CONFIG.port ?? SERVER_DEFAULTS.port,\n    hostname: overrides?.hostname ?? process.env.HOST ?? CONFIG.host ?? SERVER_DEFAULTS.host,\n  };\n}\n\n/** What to print once listening — `localhost` rather than the wildcard the socket is actually bound to. */\nexport function readyMessage({ port, hostname }: ListenAddress): string {\n  return `  ➜ rshono serving on http://${hostname === WILDCARD_HOST ? 'localhost' : hostname}:${port}`;\n}\n"]}

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

@@ -0,0 +1,8 @@
+import type { DeployBuildContext } from '../presets.js';
+/**
+ * `dist/server/main.mjs` is kept at that exact path inside the function bundle because the runtime
+ * derives the project root from where it sits (see `deploy/filesystem.ts`), which is what puts
+ * `dist/ssg` within reach at request time.
+ */
+export declare function finalizeNetlifyBuild(ctx: DeployBuildContext): Promise<void>;
+//# sourceMappingURL=build.d.ts.map

package/dist/deploy/netlify/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/deploy/netlify/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AA0BxD;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBjF"}

package/dist/deploy/netlify/build.js

@@ -0,0 +1,52 @@
+import { cpSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * What Netlify uploads: a publish directory the CDN serves, and an internal function directory the
+ * platform picks handlers up from without the project needing a `netlify/functions` folder of its own.
+ */
+const PUBLISH_DIR = join('.netlify', 'publish');
+const FUNCTIONS_DIR = join('.netlify', 'functions-internal');
+const FUNCTION_NAME = 'rshono-server';
+/**
+ * The function entry Netlify loads. It re-exports the built bundle's default handler and, next to it,
+ * the v2 `config` that claims every path — so routing is declared in code rather than in a redirect
+ * rule the project would have to maintain.
+ *
+ * `preferStatic` is what keeps the CDN in front: a path that exists in the publish directory is served
+ * from there and the function is never invoked.
+ */
+const FUNCTION_ENTRY = `export { default } from '../../dist/server/main.mjs';
+
+export const config = {
+  path: '/*',
+  preferStatic: true,
+};
+`;
+/**
+ * `dist/server/main.mjs` is kept at that exact path inside the function bundle because the runtime
+ * derives the project root from where it sits (see `deploy/filesystem.ts`), which is what puts
+ * `dist/ssg` within reach at request time.
+ */
+export async function finalizeNetlifyBuild(ctx) {
+    const publishDir = join(ctx.rootDir, PUBLISH_DIR);
+    const functionsDir = join(ctx.rootDir, FUNCTIONS_DIR);
+    // Rebuilt from scratch, so a deleted page or asset cannot survive in the uploaded output.
+    await rm(publishDir, { recursive: true, force: true });
+    await rm(functionsDir, { recursive: true, force: true });
+    mkdirSync(publishDir, { recursive: true });
+    mkdirSync(functionsDir, { recursive: true });
+    cpSync(ctx.staticDir, join(publishDir, '_static'), { recursive: true });
+    if (ctx.publicDir)
+        cpSync(ctx.publicDir, publishDir, { recursive: true });
+    // The one header the CDN cannot infer; everything else keeps Netlify's defaults.
+    writeFileSync(join(publishDir, '_headers'), '/_static/*\n  Cache-Control: public, max-age=31536000, immutable\n');
+    cpSync(join(ctx.distDir, 'server'), join(functionsDir, 'dist', 'server'), { recursive: true });
+    if (existsSync(ctx.ssgDir))
+        cpSync(ctx.ssgDir, join(functionsDir, 'dist', 'ssg'), { recursive: true });
+    if (ctx.publicDir)
+        cpSync(ctx.publicDir, join(functionsDir, 'dist', 'public'), { recursive: true });
+    writeFileSync(join(functionsDir, `${FUNCTION_NAME}.mjs`), FUNCTION_ENTRY);
+    console.log(`  • assembled ${PUBLISH_DIR} and ${FUNCTIONS_DIR}`);
+}
+//# sourceMappingURL=build.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../src/deploy/netlify/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC;;;GAGG;AACH,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;AAChD,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,oBAAoB,CAAC,CAAC;AAC7D,MAAM,aAAa,GAAG,eAAe,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,cAAc,GAAG;;;;;;CAMtB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,GAAuB;IAChE,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAClD,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;IAEtD,0FAA0F;IAC1F,MAAM,EAAE,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACvD,MAAM,EAAE,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACzD,SAAS,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3C,SAAS,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE7C,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACxE,IAAI,GAAG,CAAC,SAAS;QAAE,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1E,iFAAiF;IACjF,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,oEAAoE,CAAC,CAAC;IAElH,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/F,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;QAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACvG,IAAI,GAAG,CAAC,SAAS;QAAE,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACpG,aAAa,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,aAAa,MAAM,CAAC,EAAE,cAAc,CAAC,CAAC;IAE1E,OAAO,CAAC,GAAG,CAAC,iBAAiB,WAAW,QAAQ,aAAa,EAAE,CAAC,CAAC;AACnE,CAAC","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 * What Netlify uploads: a publish directory the CDN serves, and an internal function directory the\n * platform picks handlers up from without the project needing a `netlify/functions` folder of its own.\n */\nconst PUBLISH_DIR = join('.netlify', 'publish');\nconst FUNCTIONS_DIR = join('.netlify', 'functions-internal');\nconst FUNCTION_NAME = 'rshono-server';\n\n/**\n * The function entry Netlify loads. It re-exports the built bundle's default handler and, next to it,\n * the v2 `config` that claims every path — so routing is declared in code rather than in a redirect\n * rule the project would have to maintain.\n *\n * `preferStatic` is what keeps the CDN in front: a path that exists in the publish directory is served\n * from there and the function is never invoked.\n */\nconst FUNCTION_ENTRY = `export { default } from '../../dist/server/main.mjs';\n\nexport const config = {\n  path: '/*',\n  preferStatic: true,\n};\n`;\n\n/**\n * `dist/server/main.mjs` is kept at that exact path inside the function bundle because the runtime\n * derives the project root from where it sits (see `deploy/filesystem.ts`), which is what puts\n * `dist/ssg` within reach at request time.\n */\nexport async function finalizeNetlifyBuild(ctx: DeployBuildContext): Promise<void> {\n  const publishDir = join(ctx.rootDir, PUBLISH_DIR);\n  const functionsDir = join(ctx.rootDir, FUNCTIONS_DIR);\n\n  // Rebuilt from scratch, so a deleted page or asset cannot survive in the uploaded output.\n  await rm(publishDir, { recursive: true, force: true });\n  await rm(functionsDir, { recursive: true, force: true });\n  mkdirSync(publishDir, { recursive: true });\n  mkdirSync(functionsDir, { recursive: true });\n\n  cpSync(ctx.staticDir, join(publishDir, '_static'), { recursive: true });\n  if (ctx.publicDir) cpSync(ctx.publicDir, publishDir, { recursive: true });\n  // The one header the CDN cannot infer; everything else keeps Netlify's defaults.\n  writeFileSync(join(publishDir, '_headers'), '/_static/*\\n  Cache-Control: public, max-age=31536000, immutable\\n');\n\n  cpSync(join(ctx.distDir, 'server'), join(functionsDir, 'dist', 'server'), { recursive: true });\n  if (existsSync(ctx.ssgDir)) cpSync(ctx.ssgDir, join(functionsDir, 'dist', 'ssg'), { recursive: true });\n  if (ctx.publicDir) cpSync(ctx.publicDir, join(functionsDir, 'dist', 'public'), { recursive: true });\n  writeFileSync(join(functionsDir, `${FUNCTION_NAME}.mjs`), FUNCTION_ENTRY);\n\n  console.log(`  • assembled ${PUBLISH_DIR} and ${FUNCTIONS_DIR}`);\n}\n"]}

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

@@ -0,0 +1,13 @@
+import type { DeployRuntime } from '../contract.js';
+/**
+ * Netlify, as one Functions v2 handler behind the CDN.
+ *
+ * Same division as Vercel: the publish directory holds `/_static` and `public/`, so the CDN answers
+ * those and the function is only reached for a page. Prerendered pages ship inside the function and are
+ * read from disk, because serving them from the CDN would lose the `Accept` negotiation that decides
+ * between a document and a flight payload.
+ *
+ * Functions v2 streams a `Response` body, so streamed SSR survives.
+ */
+export declare const runtime: DeployRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/deploy/netlify/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/deploy/netlify/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,EAAE,aAarB,CAAC"}

package/dist/deploy/netlify/runtime.js

@@ -0,0 +1,24 @@
+import { handle } from 'hono/netlify';
+import { fileSystemRuntime } from '../filesystem.js';
+/**
+ * Netlify, as one Functions v2 handler behind the CDN.
+ *
+ * Same division as Vercel: the publish directory holds `/_static` and `public/`, so the CDN answers
+ * those and the function is only reached for a page. Prerendered pages ship inside the function and are
+ * read from disk, because serving them from the CDN would lose the `Accept` negotiation that decides
+ * between a document and a flight payload.
+ *
+ * Functions v2 streams a `Response` body, so streamed SSR survives.
+ */
+export const runtime = {
+    ...fileSystemRuntime,
+    mountStaticAssets() {
+        // Served from the publish directory before the function runs.
+    },
+    serveApp(app) {
+        return handle(app);
+    },
+    // Netlify compresses at the edge.
+    compress: null,
+};
+//# sourceMappingURL=runtime.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/deploy/netlify/runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,OAAO,GAAkB;IACpC,GAAG,iBAAiB;IAEpB,iBAAiB;QACf,8DAA8D;IAChE,CAAC;IAED,QAAQ,CAAC,GAAS;QAChB,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IAED,kCAAkC;IAClC,QAAQ,EAAE,IAAI;CACf,CAAC","sourcesContent":["import type { Hono } from 'hono';\nimport { handle } from 'hono/netlify';\nimport type { DeployRuntime } from '../contract.js';\nimport { fileSystemRuntime } from '../filesystem.js';\n\n/**\n * Netlify, as one Functions v2 handler behind the CDN.\n *\n * Same division as Vercel: the publish directory holds `/_static` and `public/`, so the CDN answers\n * those and the function is only reached for a page. Prerendered pages ship inside the function and are\n * read from disk, because serving them from the CDN would lose the `Accept` negotiation that decides\n * between a document and a flight payload.\n *\n * Functions v2 streams a `Response` body, so streamed SSR survives.\n */\nexport const runtime: DeployRuntime = {\n  ...fileSystemRuntime,\n\n  mountStaticAssets(): void {\n    // Served from the publish directory before the function runs.\n  },\n\n  serveApp(app: Hono): unknown {\n    return handle(app);\n  },\n\n  // Netlify compresses at the edge.\n  compress: null,\n};\n"]}

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

@@ -0,0 +1,7 @@
+import type { DeployRuntime } from '../contract.js';
+/**
+ * Node: a long-lived process that owns its own port, with a filesystem behind every asset. The shape
+ * the framework was built against, and the only target `rshono dev` ever produces.
+ */
+export declare const runtime: DeployRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/deploy/node/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/deploy/node/runtime.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIpD;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,aA2BrB,CAAC"}

package/dist/deploy/node/runtime.js

@@ -0,0 +1,36 @@
+import { serve } from '@hono/node-server';
+import { parentPort, workerData } from 'node:worker_threads';
+import { onShutdown } from '../../server/shutdown.js';
+import { fileSystemRuntime } from '../filesystem.js';
+import { listenAddress, readyMessage } from '../listen.js';
+/**
+ * Node: a long-lived process that owns its own port, with a filesystem behind every asset. The shape
+ * the framework was built against, and the only target `rshono dev` ever produces.
+ */
+export const runtime = {
+    ...fileSystemRuntime,
+    serveApp(app) {
+        // `rshono build` imports this bundle to prerender `render: 'static'` routes. That pass renders
+        // through `app.fetch` directly and must not bind a port — nothing is listening for it, and the
+        // build would never exit.
+        if (process.env.RSHONO_PRERENDER)
+            return;
+        // The dev server runs this bundle in a worker thread and picks the port itself, so its choice wins
+        // over both the environment and the config file.
+        const devWorker = workerData;
+        const address = listenAddress(devWorker ?? undefined);
+        const server = serve({ fetch: app.fetch, ...address }, (info) => {
+            if (parentPort) {
+                parentPort.postMessage({ type: 'ready', port: info.port });
+            }
+            else {
+                console.log(readyMessage({ ...address, port: info.port }));
+            }
+        });
+        onShutdown(() => {
+            server.close(() => process.exit(0));
+            setTimeout(() => process.exit(0), 3000).unref();
+        });
+    },
+};
+//# sourceMappingURL=runtime.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/deploy/node/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE3D;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAkB;IACpC,GAAG,iBAAiB;IAEpB,QAAQ,CAAC,GAAS;QAChB,+FAA+F;QAC/F,+FAA+F;QAC/F,0BAA0B;QAC1B,IAAI,OAAO,CAAC,GAAG,CAAC,gBAAgB;YAAE,OAAO;QAEzC,mGAAmG;QACnG,iDAAiD;QACjD,MAAM,SAAS,GAAG,UAAyD,CAAC;QAC5E,MAAM,OAAO,GAAG,aAAa,CAAC,SAAS,IAAI,SAAS,CAAC,CAAC;QAEtD,MAAM,MAAM,GAAG,KAAK,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,OAAO,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE;YAC9D,IAAI,UAAU,EAAE,CAAC;gBACf,UAAU,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YAC7D,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YAC7D,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACpC,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;CACF,CAAC","sourcesContent":["import { serve } from '@hono/node-server';\nimport type { Hono } from 'hono';\nimport { parentPort, workerData } from 'node:worker_threads';\nimport { onShutdown } from '../../server/shutdown.js';\nimport type { DeployRuntime } from '../contract.js';\nimport { fileSystemRuntime } from '../filesystem.js';\nimport { listenAddress, readyMessage } from '../listen.js';\n\n/**\n * Node: a long-lived process that owns its own port, with a filesystem behind every asset. The shape\n * the framework was built against, and the only target `rshono dev` ever produces.\n */\nexport const runtime: DeployRuntime = {\n  ...fileSystemRuntime,\n\n  serveApp(app: Hono): undefined {\n    // `rshono build` imports this bundle to prerender `render: 'static'` routes. That pass renders\n    // through `app.fetch` directly and must not bind a port — nothing is listening for it, and the\n    // build would never exit.\n    if (process.env.RSHONO_PRERENDER) return;\n\n    // The dev server runs this bundle in a worker thread and picks the port itself, so its choice wins\n    // over both the environment and the config file.\n    const devWorker = workerData as { port?: number; hostname?: string } | null;\n    const address = listenAddress(devWorker ?? undefined);\n\n    const server = serve({ fetch: app.fetch, ...address }, (info) => {\n      if (parentPort) {\n        parentPort.postMessage({ type: 'ready', port: info.port });\n      } else {\n        console.log(readyMessage({ ...address, port: info.port }));\n      }\n    });\n\n    onShutdown(() => {\n      server.close(() => process.exit(0));\n      setTimeout(() => process.exit(0), 3000).unref();\n    });\n  },\n};\n"]}