@jk2908/solas 0.9.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.11.0
+
+### Breaking
+
+- A route's static-params export is now `staticParams` (was `params`), matching the `Route.StaticParams` type. `Route.Prerender` became `Route.PrerenderMode` (`'full' | 'ppr'`); the `prerender` option and route export are typed `Route.PrerenderMode | false` (`false` turns prerendering off).
+
+### Features
+
+- Added build guards, installed by the adapters. An adapter declares the build features it supports (`actions`, `endpoints`) and Solas warns when the graph uses one it does not. The static adapter supports none, so it warns about server actions and `+endpoint` routes.
+
+### Fixes
+
+- The build-time prerender now shims `cloudflare:workers`, so an app that imports bindings at module scope no longer breaks the build. Bindings do not exist at build time, so reading one warns and returns `undefined`.
+
+## 0.10.0
+
+### Breaking
+
+- Adapters moved under `@jk2908/solas/adapters/*` and are now default exports: `import cloudflare from '@jk2908/solas/adapters/cloudflare'`, `import serve from '@jk2908/solas/adapters/node'`, `import staticAdapter from '@jk2908/solas/adapters/static'`. The Cloudflare runtime (`createWorker`, `createCloudflareAssets`) is now `@jk2908/solas/adapters/cloudflare/runtime`. The old `/cloudflare`, `/cloudflare/vite`, and `/node` entries are removed.
+
+### Features
+
+- Added a static site adapter, `@jk2908/solas/adapters/static`. It sets `prerender: 'full'` and merges the client assets, full prerenders, `sitemap.xml`, and `robots.txt` into one directory any static host can serve.
+
 ## 0.9.1
 
 - Trimmed the install section of the README.

package/README.md

@@ -34,7 +34,7 @@ Platform deployment is configured with the `adapter` option, which registers the
 import { defineConfig } from 'vite'
 
 import solas from '@jk2908/solas'
-import { cloudflare } from '@jk2908/solas/cloudflare/vite'
+import cloudflare from '@jk2908/solas/adapters/cloudflare'
 import react from '@vitejs/plugin-react'
 
 export default defineConfig({
@@ -205,7 +205,7 @@ export const metadata: Route.Metadata<Solas.Routes['/writing/:slug']> = ({ param
 	}
 }
 
-export const params: Route.StaticParams<Solas.Routes['/writing/:slug']> = () =>
+export const staticParams: Route.StaticParams<Solas.Routes['/writing/:slug']> = () =>
 	allPosts?.map(p => ({ slug: p.__mdsrc.slug })) ?? []
 ```
 
@@ -318,10 +318,10 @@ export const prerender = false
 
 In that example, the app default is `full`, the `about` layout overrides it to `ppr`, and the page overrides it again to `false`.
 
-For dynamic routes, prerendering uses the params you export from the page:
+For dynamic routes, prerendering uses the staticParams you export from the page:
 
 ```tsx
-export const params = () => [{ id: 'post-1' }, { id: 'post-2' }]
+export const staticParams = () => [{ id: 'post-1' }, { id: 'post-2' }]
 export const prerender = 'full'
 ```
 
@@ -482,7 +482,7 @@ Use `sitemap` to generate a `sitemap.xml` at build time.
 
 Default: `false`
 
-When enabled, Solas writes a sitemap containing all routes with deterministic URLs: static routes, prerendered routes, and dynamic routes resolved via `params`. The origin for each URL comes from the resolved origin (see Config > `url`).
+When enabled, Solas writes a sitemap containing all routes with deterministic URLs: static routes, prerendered routes, and dynamic routes resolved via `staticParams`. The origin for each URL comes from the resolved origin (see Config > `url`).
 
 ```ts
 export default defineConfig(({ mode }) => ({
@@ -567,7 +567,7 @@ npm install -D @cloudflare/vite-plugin@beta cf
 import { defineConfig } from 'vite'
 
 import solas from '@jk2908/solas'
-import { cloudflare } from '@jk2908/solas/cloudflare/vite'
+import cloudflare from '@jk2908/solas/adapters/cloudflare'
 import react from '@vitejs/plugin-react'
 
 export default defineConfig({
@@ -621,6 +621,8 @@ const value = await env.MY_KV.get('key')
 
 The Cloudflare Vite plugin emulates bindings in `cf dev` and `vite preview`, so there is nothing extra to configure locally.
 
+Bindings do not exist during the build-time prerender, where Solas imports the Worker in Node with `cloudflare:workers` shimmed. Reading one then warns and returns `undefined`, so guard it with a fallback or read it at request time.
+
 For types, the plugin writes `.cloudflare/types/index.d.ts` (bindings inferred from `cloudflare.config.ts`). Include it in `tsconfig.json` so `cloudflare:workers`'s `env` is typed:
 
 ```jsonc
@@ -643,18 +645,18 @@ Because workers have no filesystem, the Worker reads its own output through the
 `cloudflare()` forwards its `cloudflare` option to `@cloudflare/vite-plugin`. To build a Worker manually, `createWorker` composes the entry behaviour, and `createCloudflareAssets` builds the store directly:
 
 ```ts
-import { createCloudflareAssets } from '@jk2908/solas/cloudflare'
+import { createCloudflareAssets } from '@jk2908/solas/adapters/cloudflare/runtime'
 
 const assets = createCloudflareAssets(env)
 ```
 
 ## Node
 
-`vite dev` and `vite preview` already run the built handler in Node (via `@vitejs/plugin-rsc`'s default server handler), so nothing extra is needed locally. For a production Node server, use `@jk2908/solas/node`:
+`vite dev` and `vite preview` already run the built handler in Node (via `@vitejs/plugin-rsc`'s default server handler), so nothing extra is needed locally. For a production Node server, use `@jk2908/solas/adapters/node`:
 
 ```ts
 // server.ts
-import { serve } from '@jk2908/solas/node'
+import serve from '@jk2908/solas/adapters/node'
 
 await serve()
 ```
@@ -686,11 +688,34 @@ import handler from './dist/rsc/index.js'
 Deno.serve(request => handler.fetch(request))
 ```
 
-The handler reads `dist` through `node:fs`, which Bun and Deno (2.x, via Node compat) provide. Run from the project root. Bun can also run `@jk2908/solas/node` as-is, since it implements `node:http`.
+The handler reads `dist` through `node:fs`, which Bun and Deno (2.x, via Node compat) provide. Run from the project root. Bun can also run `@jk2908/solas/adapters/node` as-is, since it implements `node:http`.
+
+## Static
+
+The static adapter sets `prerender: 'full'` so every route is rendered to HTML at build time, then assembles a directory any static host can serve. There is no server.
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+
+import solas from '@jk2908/solas'
+import staticAdapter from '@jk2908/solas/adapters/static'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+	plugins: [solas({ adapter: staticAdapter() }), react()],
+})
+```
+
+`vite build` writes the site to `build/` (override with `outDir`): the client assets, each route as `<route>.html` (or `<route>/index.html` under `trailingSlash: 'always'`), plus `sitemap.xml` and `robots.txt`. Serve that directory with anything — `npx serve build`, GitHub Pages, Netlify, an S3 bucket, nginx.
+
+Because it forces full prerendering, routes that need a server are not a fit: per-route PPR or SSR opt-ins and dynamic routes without `params()`.
+
+Server actions and runtime endpoints also need a server, so the build warns when the graph contains any (a `'use server'` module or a `+endpoint` file).
 
 ## Runtime
 
-At request time Solas reads its output through an `Assets` interface (`exists`/`readText`/`readBuffer`/`mimeType`) injected into `createHandler`, defaulting to the Node standard library (which Bun runs natively). References are logical (`{ namespace, path }`), where the namespaces are `client` (Vite client output), `static` (full prerenders), and `artifact` (runtime manifest and ppr files). Platforms without a filesystem provide their own store; `@jk2908/solas/cloudflare` builds one around the `ASSETS` binding via `createWorker`. Build-time reads and writes use `node:fs` directly and are not abstracted.
+At request time Solas reads its output through an `Assets` interface (`exists`/`readText`/`readBuffer`/`mimeType`) injected into `createHandler`, defaulting to the Node standard library (which Bun runs natively). References are logical (`{ namespace, path }`), where the namespaces are `client` (Vite client output), `static` (full prerenders), and `artifact` (runtime manifest and ppr files). Platforms without a filesystem provide their own store; `@jk2908/solas/adapters/cloudflare/runtime` builds one around the `ASSETS` binding via `createWorker`. Build-time reads and writes use `node:fs` directly and are not abstracted.
 
 ## Scripts
 

package/dist/adapters/cloudflare/assets.d.ts

@@ -0,0 +1,37 @@
+import type { AssetNamespace, Assets } from '../../internal/runtimes/assets.js';
+/**
+ * The subset of the Cloudflare `assets` Fetcher binding that Solas needs.
+ */
+export type CloudflareAssets = {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+};
+/**
+ * The bindings shape the Cloudflare asset store reads from.
+ */
+export type CloudflareEnv = {
+    ASSETS?: CloudflareAssets;
+    [key: string]: unknown;
+};
+/**
+ * Path prefix the adapter copies `dist/.solas` artifacts under in the asset
+ * output.
+ */
+export declare const ARTIFACT_PREFIX = "_solas-artifacts";
+/**
+ * Where each namespace lives in the asset output, keyed by the shared
+ * `AssetNamespace`. `client` files sit at the asset root; `static` (prerenders)
+ * and `artifact` (manifest, ppr) live under the artifact prefix.
+ *
+ * Prerenders must not sit at their route paths: the asset layer ignores
+ * `Accept`, so it would answer an RSC navigation (`Accept: text/x-component`)
+ * with HTML instead of letting the Worker render it.
+ */
+export declare const NAMESPACE_PREFIX: Record<AssetNamespace, string>;
+/**
+ * Create a Solas asset store backed by the Cloudflare assets binding.
+ *
+ * Workers have no writable filesystem, so this is read-only. `client` files are
+ * served from the asset root; `static` and `artifact` files are served from the
+ * adapter's artifact prefix.
+ */
+export declare function createCloudflareAssets(env: CloudflareEnv): Assets;

package/dist/adapters/cloudflare/assets.js

@@ -0,0 +1,71 @@
+import { getMimeTypeFromPath } from '../../internal/runtimes/mime.js';
+/**
+ * Path prefix the adapter copies `dist/.solas` artifacts under in the asset
+ * output.
+ */
+export const ARTIFACT_PREFIX = '_solas-artifacts';
+// The assets binding matches on pathname only, so this is only used to satisfy
+// the URL constructor
+const ASSET_ORIGIN = 'https://solas-assets.invalid';
+/**
+ * Where each namespace lives in the asset output, keyed by the shared
+ * `AssetNamespace`. `client` files sit at the asset root; `static` (prerenders)
+ * and `artifact` (manifest, ppr) live under the artifact prefix.
+ *
+ * Prerenders must not sit at their route paths: the asset layer ignores
+ * `Accept`, so it would answer an RSC navigation (`Accept: text/x-component`)
+ * with HTML instead of letting the Worker render it.
+ */
+export const NAMESPACE_PREFIX = {
+    client: '',
+    static: `${ARTIFACT_PREFIX}/static`,
+    artifact: ARTIFACT_PREFIX,
+};
+/**
+ * Create a Solas asset store backed by the Cloudflare assets binding.
+ *
+ * Workers have no writable filesystem, so this is read-only. `client` files are
+ * served from the asset root; `static` and `artifact` files are served from the
+ * adapter's artifact prefix.
+ */
+export function createCloudflareAssets(env) {
+    const assets = env.ASSETS;
+    if (!assets || typeof assets.fetch !== 'function') {
+        throw new Error('[solas] createCloudflareAssets requires an `ASSETS` binding. Add an assets binding to your Worker.');
+    }
+    // narrowed here, and `const` keeps that type inside the closures below
+    const binding = assets;
+    function toUrl(asset) {
+        const prefix = NAMESPACE_PREFIX[asset.namespace];
+        const path = prefix ? `${prefix}/${asset.path}` : asset.path;
+        return new URL(`/${path}`, ASSET_ORIGIN).toString();
+    }
+    async function read(asset) {
+        const res = await binding.fetch(toUrl(asset), {
+            // asset responses should be passed through verbatim
+            headers: { 'accept-encoding': 'identity' },
+        });
+        return res.ok ? res : null;
+    }
+    async function readOrThrow(asset) {
+        const res = await read(asset);
+        if (!res) {
+            throw new Error(`[solas] asset not found: ${asset.namespace}/${asset.path}`);
+        }
+        return res;
+    }
+    return {
+        async exists(asset) {
+            return (await read(asset)) !== null;
+        },
+        async readText(asset) {
+            return (await readOrThrow(asset)).text();
+        },
+        async readBuffer(asset) {
+            return (await readOrThrow(asset)).arrayBuffer();
+        },
+        mimeType(filePath) {
+            return getMimeTypeFromPath(filePath);
+        },
+    };
+}

package/dist/adapters/cloudflare/bindings.d.ts

@@ -0,0 +1,7 @@
+import type { PrerenderImport } from '../../internal/postbuild.js';
+/**
+ * Wrap the prerender import so `cloudflare:workers` resolves to a local shim
+ * while the server bundle loads. The bundle on disk keeps the real import; this
+ * only affects the Node import Solas makes to prerender.
+ */
+export declare function withBindingsShim(next: PrerenderImport): PrerenderImport;

package/dist/adapters/cloudflare/bindings.js

@@ -0,0 +1,26 @@
+/** The shim module `cloudflare:workers` resolves to during the prerender. */
+const WORKERS_SHIM = new URL('./workers-shim.js', import.meta.url).href;
+/**
+ * Wrap the prerender import so `cloudflare:workers` resolves to a local shim
+ * while the server bundle loads. The bundle on disk keeps the real import; this
+ * only affects the Node import Solas makes to prerender.
+ */
+export function withBindingsShim(next) {
+    return async () => {
+        const { registerHooks } = await import('node:module');
+        const hooks = registerHooks({
+            resolve(specifier, context, nextResolve) {
+                if (specifier === 'cloudflare:workers') {
+                    return { url: WORKERS_SHIM, shortCircuit: true };
+                }
+                return nextResolve(specifier, context);
+            },
+        });
+        try {
+            return await next();
+        }
+        finally {
+            hooks.deregister();
+        }
+    };
+}

package/dist/adapters/cloudflare/index.d.ts

@@ -1,2 +1,2 @@
-export { ARTIFACT_PREFIX, createCloudflareAssets, type CloudflareAssets, type CloudflareEnv, } from './runtime.js';
-export { createWorker, type CreateWorkerOptions } from './worker.js';
+export { adapter as default } from './vite.js';
+export type { SolasCloudflareOptions } from './vite.js';

package/dist/adapters/cloudflare/index.js

@@ -1,2 +1 @@
-export { ARTIFACT_PREFIX, createCloudflareAssets, } from './runtime.js';
-export { createWorker } from './worker.js';
+export { adapter as default } from './vite.js';

package/dist/adapters/cloudflare/runtime.d.ts

@@ -1,37 +1,2 @@
-import type { AssetNamespace, Assets } from '../../internal/runtimes/assets.js';
-/**
- * The subset of the Cloudflare `assets` Fetcher binding that Solas needs.
- */
-export type CloudflareAssets = {
-    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-};
-/**
- * The bindings shape the Cloudflare asset store reads from.
- */
-export type CloudflareEnv = {
-    ASSETS?: CloudflareAssets;
-    [key: string]: unknown;
-};
-/**
- * Path prefix the adapter copies `dist/.solas` artifacts under in the asset
- * output.
- */
-export declare const ARTIFACT_PREFIX = "_solas-artifacts";
-/**
- * Where each namespace lives in the asset output, keyed by the shared
- * `AssetNamespace`. `client` files sit at the asset root; `static` (prerenders)
- * and `artifact` (manifest, ppr) live under the artifact prefix.
- *
- * Prerenders must not sit at their route paths: the asset layer ignores
- * `Accept`, so it would answer an RSC navigation (`Accept: text/x-component`)
- * with HTML instead of letting the Worker render it.
- */
-export declare const NAMESPACE_PREFIX: Record<AssetNamespace, string>;
-/**
- * Create a Solas asset store backed by the Cloudflare assets binding.
- *
- * Workers have no writable filesystem, so this is read-only. `client` files are
- * served from the asset root; `static` and `artifact` files are served from the
- * adapter's artifact prefix.
- */
-export declare function createCloudflareAssets(env: CloudflareEnv): Assets;
+export { ARTIFACT_PREFIX, createCloudflareAssets, type CloudflareAssets, type CloudflareEnv, } from './assets.js';
+export { createWorker, type CreateWorkerOptions } from './worker.js';

package/dist/adapters/cloudflare/runtime.js

@@ -1,71 +1,2 @@
-import { getMimeTypeFromPath } from '../../internal/runtimes/mime.js';
-/**
- * Path prefix the adapter copies `dist/.solas` artifacts under in the asset
- * output.
- */
-export const ARTIFACT_PREFIX = '_solas-artifacts';
-// The assets binding matches on pathname only, so this is only used to satisfy
-// the URL constructor
-const ASSET_ORIGIN = 'https://solas-assets.invalid';
-/**
- * Where each namespace lives in the asset output, keyed by the shared
- * `AssetNamespace`. `client` files sit at the asset root; `static` (prerenders)
- * and `artifact` (manifest, ppr) live under the artifact prefix.
- *
- * Prerenders must not sit at their route paths: the asset layer ignores
- * `Accept`, so it would answer an RSC navigation (`Accept: text/x-component`)
- * with HTML instead of letting the Worker render it.
- */
-export const NAMESPACE_PREFIX = {
-    client: '',
-    static: `${ARTIFACT_PREFIX}/static`,
-    artifact: ARTIFACT_PREFIX,
-};
-/**
- * Create a Solas asset store backed by the Cloudflare assets binding.
- *
- * Workers have no writable filesystem, so this is read-only. `client` files are
- * served from the asset root; `static` and `artifact` files are served from the
- * adapter's artifact prefix.
- */
-export function createCloudflareAssets(env) {
-    const assets = env.ASSETS;
-    if (!assets || typeof assets.fetch !== 'function') {
-        throw new Error('[solas] createCloudflareAssets requires an `ASSETS` binding. Add an assets binding to your Worker.');
-    }
-    // narrowed here, and `const` keeps that type inside the closures below
-    const binding = assets;
-    function toUrl(asset) {
-        const prefix = NAMESPACE_PREFIX[asset.namespace];
-        const path = prefix ? `${prefix}/${asset.path}` : asset.path;
-        return new URL(`/${path}`, ASSET_ORIGIN).toString();
-    }
-    async function read(asset) {
-        const res = await binding.fetch(toUrl(asset), {
-            // asset responses should be passed through verbatim
-            headers: { 'accept-encoding': 'identity' },
-        });
-        return res.ok ? res : null;
-    }
-    async function readOrThrow(asset) {
-        const res = await read(asset);
-        if (!res) {
-            throw new Error(`[solas] asset not found: ${asset.namespace}/${asset.path}`);
-        }
-        return res;
-    }
-    return {
-        async exists(asset) {
-            return (await read(asset)) !== null;
-        },
-        async readText(asset) {
-            return (await readOrThrow(asset)).text();
-        },
-        async readBuffer(asset) {
-            return (await readOrThrow(asset)).arrayBuffer();
-        },
-        mimeType(filePath) {
-            return getMimeTypeFromPath(filePath);
-        },
-    };
-}
+export { ARTIFACT_PREFIX, createCloudflareAssets, } from './assets.js';
+export { createWorker } from './worker.js';

package/dist/adapters/cloudflare/vite.d.ts

@@ -1,5 +1,5 @@
+import type { PluginOption } from 'vite';
 import { cloudflare as cloudflareVitePlugin } from '@cloudflare/vite-plugin';
-import type { Adapter } from '../../types.js';
 /**
  * @see {@link https://developers.cloudflare.com/workers/vite-plugin/}
  */
@@ -17,5 +17,8 @@ export type SolasCloudflareOptions = {
  * asset-backed store, points Solas's prerender step at the Cloudflare Worker
  * bundle, and copies prerender artifacts into the asset output.
  */
-export declare function cloudflare(options?: SolasCloudflareOptions): Adapter;
+export declare function adapter(options?: SolasCloudflareOptions): {
+    name: string;
+    plugins: PluginOption[];
+};
 export {};

package/dist/adapters/cloudflare/vite.js

@@ -3,8 +3,9 @@ import path from 'node:path';
 import { cloudflare as cloudflareVitePlugin } from '@cloudflare/vite-plugin';
 import * as Config from '../../config.js';
 import { writeCloudflareEntry } from '../../internal/codegen/environments.js';
-import { setRscEntry } from '../../internal/postbuild.js';
-import { NAMESPACE_PREFIX } from './runtime.js';
+import { setPrerenderImport, setRscEntry } from '../../internal/postbuild.js';
+import { NAMESPACE_PREFIX } from './assets.js';
+import { withBindingsShim } from './bindings.js';
 const VIRTUAL_ENTRY = 'virtual:solas-cloudflare-entry';
 /**
  * Solas dependencies that are imported at request time from the Worker
@@ -103,7 +104,7 @@ function withAdapterConfig(config) {
  * asset-backed store, points Solas's prerender step at the Cloudflare Worker
  * bundle, and copies prerender artifacts into the asset output.
  */
-export function cloudflare(options = {}) {
+export function adapter(options = {}) {
     const cwd = process.cwd();
     // back the virtual entry id with a path inside the generated dir so the
     // generated entry's relative imports (`./manifest.js`, ...) resolve
@@ -127,6 +128,9 @@ export function cloudflare(options = {}) {
             if (rscOutDir) {
                 setRscEntry(path.resolve(cwd, rscOutDir, 'index.js'));
             }
+            // the Worker bundle imports `cloudflare:workers`, which only exists in
+            // workerd, so shim it around the Node import
+            setPrerenderImport(withBindingsShim);
         },
         configEnvironment(name, environment) {
             // Pre-bundle the Worker environments so workerd never has to re-optimize
@@ -163,5 +167,6 @@ export function cloudflare(options = {}) {
             },
         },
     };
-    return { name: 'cloudflare', plugins: [adapter, ...cfPlugins] };
+    const plugins = [adapter, ...cfPlugins];
+    return { name: 'cloudflare', plugins };
 }

package/dist/adapters/cloudflare/worker.d.ts

@@ -1,5 +1,5 @@
 import type { ImportMap, Manifest, RuntimeConfig } from '../../types.js';
-import { type CloudflareEnv } from './runtime.js';
+import { type CloudflareEnv } from './assets.js';
 export type CreateWorkerOptions = {
     config: RuntimeConfig;
     manifest: Manifest;

package/dist/adapters/cloudflare/worker.js

@@ -1,6 +1,6 @@
 import { createRuntimeHandler } from '../../internal/env/rsc.js';
 import { nodeAssets } from '../../internal/runtimes/assets.js';
-import { createCloudflareAssets } from './runtime.js';
+import { createCloudflareAssets } from './assets.js';
 /**
  * Build a Cloudflare Worker around Solas's RSC handler.
  *

package/dist/adapters/cloudflare/workers-shim.d.ts

@@ -0,0 +1,20 @@
+export declare const env: Record<string, unknown>;
+export declare const exports: Record<string, unknown>;
+export declare const cache: Record<string, unknown>;
+export declare const tracing: Record<string, unknown>;
+export declare function waitUntil(_promise: Promise<unknown>): void;
+export declare function withEnv<T>(_env: unknown, fn: () => T): T;
+export declare function withExports<T>(_exports: unknown, fn: () => T): T;
+export declare function withEnvAndExports<T>(_env: unknown, _exports: unknown, fn: () => T): T;
+export declare class RpcStub {
+}
+export declare class RpcTarget {
+}
+export declare class WorkerEntrypoint {
+}
+export declare class DurableObject {
+}
+export declare class WorkflowStep {
+}
+export declare class WorkflowEntrypoint {
+}

package/dist/adapters/cloudflare/workers-shim.js

@@ -0,0 +1,50 @@
+/**
+ * A stand-in for `cloudflare:workers`, loaded only while Solas imports the
+ * Worker bundle in Node for the build-time prerender (see `bindings.ts`). The
+ * real module is a workerd built-in, which Node cannot resolve.
+ *
+ * The exports mirror `@cloudflare/workers-types`' `CloudflareWorkersModule`.
+ * There are no bindings at build time, so reading one warns and returns
+ * `undefined` rather than throwing, and the classes are inert stubs so a module
+ * that extends one still loads. None of this runs on the deployed Worker.
+ */
+const warned = new Set();
+function binding() {
+    return new Proxy({}, {
+        get(_target, key) {
+            if (!warned.has(key)) {
+                warned.add(key);
+                console.warn(`[solas] "${String(key)}" was read during the build-time ` +
+                    `prerender, where no bindings exist. It returned undefined. ` +
+                    `Read it at request time, or guard it with a fallback.`);
+            }
+            return;
+        },
+    });
+}
+export const env = binding();
+export const exports = binding();
+export const cache = binding();
+export const tracing = binding();
+export function waitUntil(_promise) { }
+export function withEnv(_env, fn) {
+    return fn();
+}
+export function withExports(_exports, fn) {
+    return fn();
+}
+export function withEnvAndExports(_env, _exports, fn) {
+    return fn();
+}
+export class RpcStub {
+}
+export class RpcTarget {
+}
+export class WorkerEntrypoint {
+}
+export class DurableObject {
+}
+export class WorkflowStep {
+}
+export class WorkflowEntrypoint {
+}

package/dist/adapters/node.d.ts

@@ -38,6 +38,7 @@ export type Server = http.Server & AsyncDisposable;
  * Deno and Bun do not need this helper: use `Deno.serve(handler.fetch)` or
  * `Bun.serve({ fetch: handler.fetch })` directly.
  */
-export declare function serve(options?: ServeOptions): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> & {
+declare function adapter(options?: ServeOptions): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> & {
     [Symbol.asyncDispose](): Promise<void>;
 }>;
+export { adapter as default };

package/dist/adapters/node.js

@@ -114,7 +114,7 @@ async function sendResponse(res, response) {
  * Deno and Bun do not need this helper: use `Deno.serve(handler.fetch)` or
  * `Bun.serve({ fetch: handler.fetch })` directly.
  */
-export async function serve(options = {}) {
+async function adapter(options = {}) {
     const outDir = options.outDir ?? 'dist';
     const entry = path.resolve(options.entry ?? path.join(outDir, 'rsc', 'index.js'));
     const port = options.port ?? (Number(process.env.PORT) || 3000);
@@ -142,3 +142,4 @@ export async function serve(options = {}) {
         },
     });
 }
+export { adapter as default };

package/dist/adapters/static.d.ts

@@ -0,0 +1,27 @@
+import type { PluginOption } from 'vite';
+export type SolasStaticOptions = {
+    /**
+     * Directory, relative to the project root, the static site is written to.
+     *
+     * @default 'build'
+     */
+    outDir?: string;
+};
+/**
+ * Static site adapter for Solas.
+ *
+ * Sets `prerender: 'full'` so every route is rendered to HTML at build time,
+ * then merges Solas's output into a single directory any static host can serve:
+ * the client assets, the full prerenders (at their route paths) and the
+ * generated `sitemap.xml` / `robots.txt`.
+ *
+ * It installs the guards with no server features supported, so the build warns
+ * when the graph contains server actions or `+endpoint` routes, which a static
+ * host cannot run.
+ */
+declare function adapter(options?: SolasStaticOptions): {
+    name: string;
+    plugins: PluginOption[];
+    prerender: "full";
+};
+export { adapter as default };

package/dist/adapters/static.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as Config from '../config.js';
+import { Features, guards } from '../internal/guards.js';
+const ROOT_FILES = ['sitemap.xml', 'robots.txt'];
+/**
+ * Static site adapter for Solas.
+ *
+ * Sets `prerender: 'full'` so every route is rendered to HTML at build time,
+ * then merges Solas's output into a single directory any static host can serve:
+ * the client assets, the full prerenders (at their route paths) and the
+ * generated `sitemap.xml` / `robots.txt`.
+ *
+ * It installs the guards with no server features supported, so the build warns
+ * when the graph contains server actions or `+endpoint` routes, which a static
+ * host cannot run.
+ */
+function adapter(options = {}) {
+    const cwd = process.cwd();
+    const outDir = options.outDir ?? 'build';
+    const plugin = {
+        name: 'solas-static',
+        enforce: 'post',
+        buildApp: {
+            order: 'post',
+            async handler() {
+                // runs after Solas's own `post` buildApp, so `dist/client`,
+                // `dist/static`, the sitemap and robots.txt already exist
+                const dist = path.join(cwd, Config.OUT_DIR);
+                const target = path.resolve(cwd, outDir);
+                await fs.rm(target, { recursive: true, force: true });
+                for (const dir of ['client', 'static']) {
+                    const source = path.join(dist, dir);
+                    if (await exists(source)) {
+                        await fs.cp(source, target, { recursive: true });
+                    }
+                }
+                for (const file of ROOT_FILES) {
+                    const source = path.join(dist, file);
+                    if (await exists(source)) {
+                        await fs.copyFile(source, path.join(target, file));
+                    }
+                }
+            },
+        },
+    };
+    const plugins = [guards(Features.None), plugin];
+    return { name: 'static', plugins, prerender: 'full' };
+}
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { adapter as default };

package/dist/config.d.ts

@@ -13,7 +13,8 @@ export declare const PUBLIC_DIR = "public";
 export declare const $: unique symbol;
 export declare const REQUEST_META_KEY: string;
 export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
-export declare const PRERENDER_MODES: readonly ["full", "ppr", false];
+export declare const PRERENDER_MODES: readonly ["full", "ppr"];
+export declare const PRERENDER_OPTIONS: readonly ["full", "ppr", false];
 export declare const TRAILING_SLASH_MODES: readonly ["always", "never", "ignore"];
 export declare const RUNTIME_MANIFEST = "runtime-manifest.json";
 export declare function validate(input: unknown, envUrl?: string): PluginConfig;

package/dist/config.js

@@ -12,7 +12,8 @@ export const PUBLIC_DIR = 'public';
 export const $ = Symbol(SLUG);
 export const REQUEST_META_KEY = `__${SLUG.toUpperCase()}__`;
 export const LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
-export const PRERENDER_MODES = ['full', 'ppr', false];
+export const PRERENDER_MODES = ['full', 'ppr'];
+export const PRERENDER_OPTIONS = [...PRERENDER_MODES, false];
 export const TRAILING_SLASH_MODES = ['always', 'never', 'ignore'];
 export const RUNTIME_MANIFEST = 'runtime-manifest.json';
 const CONFIG_KEYS = new Set([
@@ -122,7 +123,7 @@ export function validate(input, envUrl) {
         }
     }
     if ('prerender' in input && input.prerender !== undefined) {
-        if (!new Set(PRERENDER_MODES).has(input.prerender)) {
+        if (!new Set(PRERENDER_OPTIONS).has(input.prerender)) {
             errors.push("prerender must be 'full', 'ppr', or false");
         }
     }

package/dist/index.js

@@ -37,6 +37,9 @@ function solas(c) {
     const config = {
         ...DEFAULT_CONFIG,
         ...validatedConfig,
+        // a platform's required prerender mode wins: a static host, for example,
+        // has no server to render PPR or SSR routes
+        ...(c?.adapter?.prerender !== undefined ? { prerender: c.adapter.prerender } : {}),
     };
     let resolvedUrl = normaliseOrigin(c?.url) ?? normaliseOrigin(envUrl);
     if (config.logger?.level)

package/dist/internal/codegen/environments.js

@@ -31,7 +31,7 @@ export function writeCloudflareEntry() {
     return source `
 		${AUTOGEN_MSG}
 
-		import { createWorker } from '${Config.PKG_NAME}/cloudflare'
+		import { createWorker } from '${Config.PKG_NAME}/adapters/cloudflare/runtime'
 
 		import { manifest } from './manifest.js'
 		import { importMap } from './maps.js'

package/dist/internal/guards.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Build features a platform may not support, as flags so they combine:
+ * `Features.Actions | Features.Endpoints`.
+ */
+export declare const Features: {
+    readonly None: 0;
+    readonly Actions: number;
+    readonly Endpoints: number;
+    readonly All: number;
+};
+export type Feature = (typeof Features)[keyof typeof Features];
+/**
+ * Build guards, installed by an adapter: warns when the build graph uses a
+ * feature the adapter does not support. `supports` is a set of `Features` flags
+ * (`Features.Actions | Features.Endpoints`), defaulting to `Features.All`.
+ */
+export declare function guards(supports?: Feature): {
+    name: string;
+    enforce: "pre";
+    transform(this: import("rolldown").TransformPluginContext, code: string, id: string): undefined;
+};

package/dist/internal/guards.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger();
+/**
+ * Build features a platform may not support, as flags so they combine:
+ * `Features.Actions | Features.Endpoints`.
+ */
+export const Features = {
+    None: 0,
+    Actions: 1 << 0,
+    Endpoints: 1 << 1,
+    All: (1 << 0) | (1 << 1),
+};
+const LABEL = {
+    [Features.Actions]: 'a server action',
+    [Features.Endpoints]: 'a runtime endpoint',
+};
+const SOURCE = /\.(m?[jt]sx?)$/;
+const ENDPOINT = /\+endpoint\.m?[jt]sx?$/;
+const USE_SERVER = /^\s*['"]use server['"]/m;
+/**
+ * Build guards, installed by an adapter: warns when the build graph uses a
+ * feature the adapter does not support. `supports` is a set of `Features` flags
+ * (`Features.Actions | Features.Endpoints`), defaulting to `Features.All`.
+ */
+export function guards(supports = Features.All) {
+    const cwd = process.cwd();
+    const warned = new Set();
+    return {
+        name: 'solas:guards',
+        enforce: 'pre',
+        transform(code, id) {
+            const file = id.split('?')[0];
+            if (!path.isAbsolute(file) || !file.startsWith(cwd) || warned.has(file))
+                return;
+            if (!SOURCE.test(file))
+                return;
+            let feature;
+            if (ENDPOINT.test(file)) {
+                feature = Features.Endpoints;
+            }
+            else if (USE_SERVER.test(code)) {
+                feature = Features.Actions;
+            }
+            if (feature === undefined || (supports & feature) !== 0)
+                return;
+            warned.add(file);
+            logger.warn(`[build] this build uses ${LABEL[feature]} (${path.relative(cwd, file)}), ` +
+                `which the adapter does not support`);
+        },
+    };
+}

package/dist/internal/postbuild.d.ts

@@ -1,2 +1,16 @@
+import * as Prerender from './prerender.js';
 export declare function setRscEntry(entry: string): void;
+type App = Parameters<typeof Prerender.run>[0];
+/** Imports the server bundle `postbuild` prerenders with. */
+export type PrerenderImport = () => Promise<{
+    default: App;
+}>;
+/**
+ * Set a wrapper for the import `postbuild` makes to prerender. It receives the
+ * plain import and returns one that sets up and tears down platform-specific
+ * module resolution around it, for example shimming a runtime module that Node
+ * cannot resolve (such as `cloudflare:workers`).
+ */
+export declare function setPrerenderImport(wrap: (next: PrerenderImport) => PrerenderImport): void;
 export declare function postbuild(cwd?: string): Promise<void>;
+export {};

package/dist/internal/postbuild.js

@@ -15,6 +15,16 @@ let rscEntryOverride;
 export function setRscEntry(entry) {
     rscEntryOverride = entry;
 }
+let prerenderImport;
+/**
+ * Set a wrapper for the import `postbuild` makes to prerender. It receives the
+ * plain import and returns one that sets up and tears down platform-specific
+ * module resolution around it, for example shimming a runtime module that Node
+ * cannot resolve (such as `cloudflare:workers`).
+ */
+export function setPrerenderImport(wrap) {
+    prerenderImport = wrap;
+}
 export async function postbuild(cwd = process.cwd()) {
     const manifestPath = path.join(cwd, Config.GENERATED_DIR, 'build.json');
     let manifest;
@@ -44,7 +54,10 @@ export async function postbuild(cwd = process.cwd()) {
         logger.info('[prerender]', `prerendering ${manifest.prerenderRoutes.length} routes (concurrency: ${concurrency})...`);
         const rscEntry = rscEntryOverride ?? path.join(rscDir, 'index.js');
         rscEntryOverride = undefined;
-        const { default: app } = await import(/* @vite-ignore */ rscEntry);
+        const base = () => import(/* @vite-ignore */ rscEntry);
+        const load = prerenderImport ? prerenderImport(base) : base;
+        prerenderImport = undefined;
+        const { default: app } = await load();
         async function enqueueWrite(task) {
             const write = task().finally(() => {
                 pendingWrites.delete(write);

package/dist/internal/prerender.js

@@ -270,7 +270,7 @@ export async function getStaticFlag(filePath, buildContext) {
  * in the route module and calling it to get the list of parameter objects.
  */
 export async function getStaticParams(filePath, buildContext) {
-    const params = await buildContext.exportReader.value(filePath, 'params', (v) => typeof v === 'function');
+    const params = await buildContext.exportReader.value(filePath, 'staticParams', (v) => typeof v === 'function');
     if (!params)
         return [];
     const resolved = await Promise.resolve().then(() => params());

package/dist/types.d.ts

@@ -26,10 +26,15 @@ export type HeadersInput = HeaderEntries | ((req: Request) => HeaderEntries | Pr
 export type Adapter = {
     name: string;
     plugins: PluginOption[];
+    /**
+     * Prerender mode the platform requires, which overrides the `solas()`
+     * option. A static host has no server, so it needs `'full'`.
+     */
+    prerender?: Route.PrerenderMode | false;
 };
 type PluginConfigBase = {
     precompress?: boolean;
-    prerender?: Route.Prerender;
+    prerender?: Route.PrerenderMode | false;
     metadata?: Metadata.Item;
     trailingSlash?: (typeof Config.TRAILING_SLASH_MODES)[number];
     trustedOrigins?: readonly string[];
@@ -83,7 +88,7 @@ export type Segment = {
         page?: string | null;
     };
     error?: HttpException | Error;
-    prerender: Route.Prerender;
+    prerender: Route.PrerenderMode | false;
     dynamic: boolean;
     wildcard: boolean;
 };
@@ -143,7 +148,7 @@ export declare namespace Route {
     } : {
         params: ParamsOf<TRoute>;
     }) & ErrorPropsOf<TError>;
-    export type Prerender = (typeof Config.PRERENDER_MODES)[number];
+    export type PrerenderMode = (typeof Config.PRERENDER_MODES)[number];
     export {};
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.9.1",
+	"version": "0.11.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",
@@ -69,17 +69,21 @@
 			"types": "./dist/error-boundary.d.ts",
 			"import": "./dist/error-boundary.js"
 		},
-		"./cloudflare": {
+		"./adapters/cloudflare": {
 			"types": "./dist/adapters/cloudflare/index.d.ts",
 			"import": "./dist/adapters/cloudflare/index.js"
 		},
-		"./cloudflare/vite": {
-			"types": "./dist/adapters/cloudflare/vite.d.ts",
-			"import": "./dist/adapters/cloudflare/vite.js"
+		"./adapters/cloudflare/runtime": {
+			"types": "./dist/adapters/cloudflare/runtime.d.ts",
+			"import": "./dist/adapters/cloudflare/runtime.js"
 		},
-		"./node": {
+		"./adapters/node": {
 			"types": "./dist/adapters/node.d.ts",
 			"import": "./dist/adapters/node.js"
+		},
+		"./adapters/static": {
+			"types": "./dist/adapters/static.d.ts",
+			"import": "./dist/adapters/static.js"
 		}
 	},
 	"scripts": {
@@ -103,6 +107,7 @@
 		"path-to-regexp": "^8.3.0"
 	},
 	"devDependencies": {
+		"@cloudflare/workers-types": "^5.20261015.1",
 		"@prettier/plugin-oxc": "^0.1.3",
 		"@typescript/native-preview": "^7.0.0-dev.20260224.1",
 		"@vitejs/plugin-react": "^6.1.2",