bosia 0.9.8 → 0.9.10

package/src/core/client/prefetch.ts

@@ -17,7 +17,9 @@ export function buildMaskBits(path: string): string | null {
 	const url = new URL(path, window.location.origin);
 	const pathname = url.pathname;
 	const match = findMatch(clientRoutes, pathname);
-	if (!match) return null;
+	// Prerendered data is a fixed file: nothing to skip, and on Workers only a
+	// plain GET reaches it (the asset server answers a POST with 405).
+	if (!match || match.route.prerender) return null;
 	const ctx = liveContext(pathname, match.params, url);
 	const layoutIds = (match.route as any).layoutIds as (string | null)[];
 	const pageId = (match.route as any).pageId as string | null;

package/src/core/config.ts

@@ -9,7 +9,7 @@ let cachedFromPath: string | null = null;
 
 const CONFIG_NAMES = ["bosia.config.ts", "bosia.config.js", "bosia.config.mjs"];
 
-function findConfigPath(cwd: string): string | null {
+export function findConfigPath(cwd: string): string | null {
 	for (const name of CONFIG_NAMES) {
 		const p = join(cwd, name);
 		if (existsSync(p)) return p;
@@ -39,9 +39,7 @@ export async function loadBosiaConfig(cwd: string = process.cwd()): Promise<Bosi
 				`${prebuiltPath} must export a default object (use \`export default defineConfig({...})\`).`,
 			);
 		}
-		const rawPlugins = Array.isArray(config.plugins) ? config.plugins : [];
-		const plugins = rawPlugins.filter((p): p is BosiaPlugin => Boolean(p));
-		cached = { plugins };
+		cached = normalizeConfig(config);
 		cachedFromPath = cwd;
 		return cached;
 	}
@@ -57,7 +55,7 @@ export async function loadBosiaConfig(cwd: string = process.cwd()): Promise<Bosi
 		entrypoints: [configPath],
 		target: "bun",
 		format: "esm",
-		external: ["bosia", "elysia", "bun", "svelte", "svelte/server"],
+		external: ["bosia", "bun", "svelte", "svelte/server"],
 	});
 
 	if (!result.success || !result.outputs[0]) {
@@ -89,13 +87,26 @@ export async function loadBosiaConfig(cwd: string = process.cwd()): Promise<Bosi
 		);
 	}
 
+	cached = normalizeConfig(config);
+	cachedFromPath = cwd;
+	return cached;
+}
+
+// Keep every field — only `plugins` needs cleaning. Rebuilding the object as
+// `{ plugins }` silently dropped `strictImports` and anything added later.
+function normalizeConfig(config: BosiaConfig): BosiaConfig {
 	const rawPlugins = Array.isArray(config.plugins) ? config.plugins : [];
-	const plugins = rawPlugins.filter((p): p is BosiaPlugin => Boolean(p));
-	const normalized: BosiaConfig = { plugins };
+	return { ...config, plugins: rawPlugins.filter((p): p is BosiaPlugin => Boolean(p)) };
+}
 
-	cached = normalized;
+/**
+ * Hand over an already-imported config. For runtimes that can't load
+ * `bosia.config.ts` off disk (Workers bundles it statically); call before
+ * anything reads the config.
+ */
+export function setBosiaConfig(config: BosiaConfig, cwd: string = process.cwd()): void {
+	cached = normalizeConfig(config);
 	cachedFromPath = cwd;
-	return normalized;
 }
 
 /** Test-only — drops the in-memory cache so tests can reload fresh config files. */

package/src/core/dev.ts

@@ -1,7 +1,7 @@
 import { spawn, type Subprocess } from "bun";
 import { readdirSync, statSync, watch, type Dirent } from "fs";
 import { join } from "path";
-import { loadEnv, resetDeclaredKeys } from "./env.ts";
+import { loadEnv } from "./env.ts";
 import { BOSIA_NODE_PATH } from "./paths.ts";
 import { pidsOnPort } from "./port.ts";
 import { affectsRouteManifest, shouldIgnoreForRebuild } from "./devWatch.ts";
@@ -31,7 +31,6 @@ function reloadEnv() {
 	for (const [k, v] of Object.entries(SHELL_ENV_SNAPSHOT)) {
 		if (v !== undefined) process.env[k] = v;
 	}
-	resetDeclaredKeys();
 	loadEnv("development");
 }
 
@@ -211,7 +210,7 @@ async function startAppServer() {
 			NODE_ENV: "development",
 			// Force app server to APP_PORT — prevents PORT from .env conflicting with the dev proxy
 			PORT: String(APP_PORT),
-			// Allow externalized deps (elysia, etc.) to resolve from bosia's node_modules
+			// Allow externalized deps to resolve from bosia's node_modules
 			NODE_PATH: BOSIA_NODE_PATH,
 			// Point the server child at dev's output dir so its OUT_DIR reads match what build wrote.
 			BOSIA_OUT_DIR: DEV_OUT_DIR,

package/src/core/env.ts

@@ -162,11 +162,6 @@ export function loadEnv(mode: string, dir?: string): Record<string, string> {
 		for (const key of Object.keys(parsed)) declaredNames.add(key);
 	}
 
-	// Track declared keys so html.ts only exposes .env-declared PUBLIC_* vars
-	for (const key of declaredNames) {
-		_declaredKeys.add(key);
-	}
-
 	// Apply to process.env — system env wins (don't overwrite existing).
 	// Name-only keys stay absent so `process.env.X ?? default` still falls back.
 	for (const [key, value] of Object.entries(merged)) {
@@ -186,21 +181,6 @@ export function loadEnv(mode: string, dir?: string): Record<string, string> {
 	return result;
 }
 
-// ─── Declared Key Tracking ───────────────────────────
-// Track which keys were declared in .env files so html.ts only exposes those to the client.
-
-const _declaredKeys = new Set<string>();
-
-/** Returns the set of env var keys that were declared in .env files. */
-export function getDeclaredEnvKeys(): ReadonlySet<string> {
-	return _declaredKeys;
-}
-
-/** Clear the declared-keys set. Call before re-running `loadEnv` on hot-reload so removed PUBLIC_* keys stop leaking to the client. */
-export function resetDeclaredKeys(): void {
-	_declaredKeys.clear();
-}
-
 // ─── Classifier ──────────────────────────────────────────
 
 export interface ClassifiedEnv {

package/src/core/hooks.ts

@@ -31,6 +31,19 @@ export interface Cookies {
 
 // ─── Event Types ──────────────────────────────────────────
 
+/**
+ * Runtime bindings (Cloudflare Workers: D1, KV, R2, vars). Augment to type them:
+ * `declare module "bosia" { interface PlatformEnv { DB: D1Database } }`
+ */
+export interface PlatformEnv {
+	[key: string]: any;
+}
+
+/** What the host runtime hands the app. */
+export interface Platform {
+	env: PlatformEnv;
+}
+
 export type RequestEvent = {
 	request: Request;
 	url: URL;
@@ -56,6 +69,11 @@ export type RequestEvent = {
 	 * authorization: a check that runs on one kind and not the other is a hole.
 	 */
 	isDataRequest: boolean;
+	/**
+	 * Runtime platform context. On Cloudflare Workers, `platform.env` holds the
+	 * bindings (D1, KV, R2, …). `undefined` on Bun.
+	 */
+	platform?: Platform;
 };
 
 export type LoadEvent = {
@@ -73,6 +91,11 @@ export type LoadEvent = {
 	 * namespaced (e.g. `"app:user"`).
 	 */
 	depends: (...keys: string[]) => void;
+	/**
+	 * Runtime platform context. On Cloudflare Workers, `platform.env` holds the
+	 * bindings (D1, KV, R2, …). `undefined` on Bun.
+	 */
+	platform?: Platform;
 	/**
 	 * Set response headers for this request. Headers accumulate across
 	 * layout and page loaders and land on both the SSR HTML response and
@@ -150,6 +173,11 @@ export type MetadataEvent = {
 	locals: Record<string, any>;
 	cookies: Cookies;
 	fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+	/**
+	 * Runtime platform context. On Cloudflare Workers, `platform.env` holds the
+	 * bindings (D1, KV, R2, …). `undefined` on Bun.
+	 */
+	platform?: Platform;
 };
 
 export type Metadata = {

package/src/core/html.ts

@@ -1,13 +1,17 @@
-import { existsSync, readFileSync } from "fs";
-import { getDeclaredEnvKeys } from "./env.ts";
+import { gzipSync } from "node:zlib";
+
+import { readArtifact } from "./artifacts.ts";
 import { nonceAttr } from "./csp.ts";
-import { OUT_DIR } from "./paths.ts";
 import { rebaseHtmlAttrs } from "./basePath.ts";
 import { currentBase } from "./appBase.ts";
 import type { AppHtmlSegments } from "./appHtml.ts";
 import { interpolateSegment } from "./appHtml.ts";
 import type { Metadata } from "./hooks.ts";
 
+// Workers compresses any body sent with a Content-Encoding header — again, if it
+// already is — unless told the bytes are final. Bun ignores the key.
+export const PRECOMPRESSED = { encodeBody: "manual" } as ResponseInit;
+
 // ─── Dist Manifest ───────────────────────────────────────
 // Maps hashed filenames → script/link tags.
 // Cached at startup; server restarts on rebuild in dev anyway.
@@ -18,12 +22,9 @@ export const distManifest: {
 	entry: string;
 	tw?: string;
 	basePath?: string;
-} = (() => {
-	const p = `${OUT_DIR}/manifest.json`;
-	return existsSync(p)
-		? JSON.parse(readFileSync(p, "utf-8"))
-		: { js: [], css: [], entry: "hydrate.js" };
-})();
+	/** PUBLIC_* (non-static) names declared in .env files, stamped by the build. */
+	publicEnv?: string[];
+} = readArtifact("manifest.json") ?? { js: [], css: [], entry: "hydrate.js" };
 
 export const isDev = process.env.NODE_ENV !== "production";
 const cacheBust = isDev ? `?v=${Date.now()}` : "";
@@ -115,23 +116,19 @@ export function safeJsonForScript(data: unknown): string {
 // ─── Public Env Injection ─────────────────────────────────
 
 /**
- * Collect PUBLIC_* (non-static) vars that were declared in .env files.
- * Only exposes keys tracked by loadEnv() — never leaks system env vars
- * that happen to start with PUBLIC_.
+ * PUBLIC_* (non-static) vars declared in .env files, with their current values.
+ * The names come from the build (`distManifest.publicEnv`), never from
+ * process.env — system env vars that happen to start with PUBLIC_ don't leak.
+ * The server runs as its own process (and on Workers, with no .env on disk),
+ * so the names must travel with the build rather than in loadEnv()'s memory.
  */
-const _publicDynamicEnv: Record<string, string> = (() => {
-	const declared = getDeclaredEnvKeys();
+export function getPublicDynamicEnv(): Record<string, string> {
 	const result: Record<string, string> = {};
-	for (const key of declared) {
-		if (key.startsWith("PUBLIC_") && !key.startsWith("PUBLIC_STATIC_")) {
-			const value = process.env[key];
-			if (value !== undefined) result[key] = value;
-		}
+	for (const key of distManifest.publicEnv ?? []) {
+		const value = process.env[key];
+		if (value !== undefined) result[key] = value;
 	}
 	return result;
-})();
-function getPublicDynamicEnv(): Record<string, string> {
-	return _publicDynamicEnv;
 }
 
 // ─── Lang Validation ──────────────────────────────────────
@@ -428,6 +425,13 @@ export function buildHtmlTail(
 
 const GZIP_MIN_BYTES = 2048;
 
+// Off on Workers: Cloudflare's edge compresses responses itself, outside the
+// worker's CPU budget. The first brotli call alone cost ~4ms of a 10ms limit.
+export let compressionOn = true;
+export function disableCompression(): void {
+	compressionOn = false;
+}
+
 // Shared, stateless — one instance instead of a fresh allocation per response.
 const textEncoder = new TextEncoder();
 
@@ -449,8 +453,9 @@ export function compress(
 	const bytes = textEncoder.encode(body);
 	// Skip compression in dev — the dev proxy's fetch() auto-decompresses gzip
 	// responses but keeps the Content-Encoding header, causing ERR_CONTENT_DECODING_FAILED.
-	if (!isDev && bytes.length > GZIP_MIN_BYTES && accept.includes("gzip")) {
-		return new Response(Bun.gzipSync(bytes), {
+	if (compressionOn && !isDev && bytes.length > GZIP_MIN_BYTES && accept.includes("gzip")) {
+		return new Response(gzipSync(bytes), {
+			...PRECOMPRESSED,
 			status,
 			headers: { ...headers, "content-encoding": "gzip" },
 		});

package/src/core/paths.ts

@@ -2,7 +2,9 @@ import { join, dirname, delimiter } from "path";
 import { existsSync } from "fs";
 
 // This file lives at src/core/paths.ts → package root is ../..
-const BOSIA_PKG_DIR = join(import.meta.dir, "..", "..");
+// `import.meta.dir` is undefined on Workers — no package dir and no
+// node_modules there, so every lookup below just comes back empty.
+const BOSIA_PKG_DIR = import.meta.dir ? join(import.meta.dir, "..", "..") : "";
 
 const NESTED_NM = join(BOSIA_PKG_DIR, "node_modules");
 
@@ -22,7 +24,7 @@ function collectAncestorNodeModules(start: string): string[] {
 	return out;
 }
 
-const ANCESTOR_NM = collectAncestorNodeModules(dirname(BOSIA_PKG_DIR));
+const ANCESTOR_NM = BOSIA_PKG_DIR ? collectAncestorNodeModules(dirname(BOSIA_PKG_DIR)) : [];
 const ALL_NM = [NESTED_NM, ...ANCESTOR_NM];
 
 /** NODE_PATH value covering nested and every ancestor node_modules */

package/src/core/platform.ts

@@ -0,0 +1,24 @@
+import type { Platform } from "./hooks.ts";
+
+// Set once at boot by the runtime entry — on Workers, the bindings. Isolate-wide,
+// so events read it here instead of threading it through every loader call.
+let current: Platform | undefined;
+
+export function setPlatform(platform: Platform | undefined): void {
+	current = platform;
+}
+
+export function getPlatform(): Platform | undefined {
+	return current;
+}
+
+// True only while server.workers.ts renders `/` once at isolate startup, so V8
+// compiles the render path before the first real request. That render runs no
+// user hooks, loaders, metadata() or +server.ts handlers — startup has no
+// bindings, and a hook caching a failed `connect()` would break the isolate —
+// and never touches the response cache.
+export let warmingUp = false;
+
+export function setWarmingUp(on: boolean): void {
+	warmingUp = on;
+}

package/src/core/plugin.ts

@@ -1,3 +1,4 @@
+import { builtinModules } from "module";
 import { join, dirname } from "path";
 
 import { resolveImportPath } from "./resolveImport.ts";
@@ -7,8 +8,13 @@ import { resolveImportPath } from "./resolveImport.ts";
 //   bosia:routes  → .bosia/routes.ts  (generated route map)
 //   $env           → .bosia/env.server.ts (bun) or .bosia/env.client.ts (browser)
 //   $*             → resolved dynamically via tsconfig.json compilerOptions.paths
+//   ./artifacts.ts → .bosia/artifacts.ts (workers runtime — no filesystem)
+//   bosia:workers-runtime → .bosia/runtime.workers.ts (workers runtime)
 
-export function makeBosiaPlugin(target: "browser" | "bun" = "bun") {
+export function makeBosiaPlugin(
+	target: "browser" | "bun" = "bun",
+	runtime: "bun" | "workers" = "bun",
+) {
 	return {
 		name: "bosia-resolver",
 		setup(build: import("bun").PluginBuilder) {
@@ -23,6 +29,25 @@ export function makeBosiaPlugin(target: "browser" | "bun" = "bun") {
 				),
 			}));
 
+			// Workers has no filesystem: the core's build-artifact reader becomes
+			// the generated module with the same JSON inlined.
+			if (runtime === "workers") {
+				build.onResolve({ filter: /^\.\/artifacts\.ts$/ }, (args) =>
+					args.importer.startsWith(import.meta.dir)
+						? { path: join(process.cwd(), ".bosia", "artifacts.ts") }
+						: undefined,
+				);
+				build.onResolve({ filter: /^bosia:workers-runtime$/ }, () => ({
+					path: join(process.cwd(), ".bosia", "runtime.workers.ts"),
+				}));
+				// workerd provides Node builtins under nodejs_compat. Keep them external
+				// as `node:*`: a browser-target build would swap a bare `fs` for `{}`.
+				const builtins = new Set(builtinModules);
+				build.onResolve({ filter: /^[a-z_]+(\/[a-z_]+)?$/ }, (args) =>
+					builtins.has(args.path) ? { path: `node:${args.path}`, external: true } : undefined,
+				);
+			}
+
 			// $env → .bosia/env.client.ts (browser) or .bosia/env.server.ts (bun)
 			build.onResolve({ filter: /^\$env$/ }, () => ({
 				path: join(

package/src/core/plugins/inspector/index.ts

@@ -1,6 +1,5 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import type { Elysia } from "elysia";
 import { createInspectorBunPlugin } from "./bun-plugin.ts";
 import { getOverlayScript } from "./overlay.ts";
 import { resolveFrame, resolveStack } from "./sourcemap.ts";
@@ -142,7 +141,7 @@ function installProcessListeners() {
 // live in a separately-bundled module graph from this disk-loaded plugin —
 // can notify the inspector without an import dependency. Renderer catches
 // (page load, layout load, SSR load) swallow errors and return a rendered
-// error page, so they never reach Elysia `.onError()` on their own. The
+// error page, so they never reach the backend `.onError()` on their own. The
 // global is typed in core/devErrorReport.ts.
 function installGlobalReporter() {
 	globalThis.__BOSIA_REPORT_ERROR__ = (e) => {
@@ -179,10 +178,7 @@ export function inspector(options: InspectorOptions = {}): BosiaPlugin | false {
 
 		backend: {
 			before(app) {
-				// Cast to the base Elysia type — chaining .post/.get/.onError narrows
-				// the generic so the plugin return type drifts unless we widen back.
-				let chained: Elysia = app as unknown as Elysia;
-				chained = chained.post(endpoint, async ({ body }: { body: unknown }) => {
+				let chained = app.post(endpoint, async ({ body }) => {
 					const data = (body ?? {}) as {
 						file?: string;
 						line?: number;
@@ -270,7 +266,7 @@ export function inspector(options: InspectorOptions = {}): BosiaPlugin | false {
 					installProcessListeners();
 					installGlobalReporter();
 
-					// Elysia onError — runs because server.ts registers plugin
+					// Backend onError — runs because server.ts registers plugin
 					// backend.before() ahead of the base .onError() responder.
 					chained = chained.onError(({ error }) => {
 						const e = error as Error;
@@ -281,12 +277,12 @@ export function inspector(options: InspectorOptions = {}): BosiaPlugin | false {
 						});
 						// Fall through to the base handler.
 						return undefined;
-					}) as unknown as Elysia;
+					});
 
 					// Live SSE stream. New clients also get a flush of the bounded
 					// replay buffer so errors that fired during a failing render
 					// (before the 500 page's overlay could subscribe) are visible.
-					chained = chained.get("/__bosia/errors", ({ request }: { request: Request }) => {
+					chained = chained.get("/__bosia/errors", ({ request }) => {
 						const stream = new ReadableStream<Uint8Array>({
 							start(ctrl) {
 								sseClients.add(ctrl);
@@ -322,7 +318,7 @@ export function inspector(options: InspectorOptions = {}): BosiaPlugin | false {
 								Connection: "keep-alive",
 							},
 						});
-					}) as unknown as Elysia;
+					});
 				}
 
 				return chained;

package/src/core/plugins/server-timing.ts

@@ -39,7 +39,7 @@ export function serverTiming(options: ServerTimingOptions = {}): BosiaPlugin {
 							return;
 						}
 
-						// Otherwise, push into Elysia's outbound header bag.
+						// Otherwise, push into the outbound header bag.
 						const headers = (set.headers ??= {}) as Record<string, string>;
 						headers[headerName] = value;
 					});

package/src/core/prerender.ts

@@ -5,6 +5,7 @@ import type { RouteManifest, TrailingSlash } from "./types.ts";
 
 import { BOSIA_NODE_PATH, OUT_DIR } from "./paths.ts";
 import { currentBase } from "./appBase.ts";
+import { prerenderSkipReason, wantsPrerender } from "./scanner.ts";
 
 /** Acquire an OS-assigned ephemeral port. Tiny TOCTOU race window; acceptable for build-time use. */
 export function getEphemeralPort(): Promise<number> {
@@ -129,11 +130,10 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<Prerender
 		if (!route.pageServer) return [];
 		const filePath = join("src", "routes", route.pageServer);
 		const content = await Bun.file(filePath).text();
-		if (!/export\s+const\s+prerender\s*=\s*true/.test(content)) return [];
-		if (/export\s+const\s+ssr\s*=\s*false/.test(content)) {
-			console.warn(
-				`   ⚠️  ${route.pattern} has prerender=true && ssr=false — contradictory, skipped`,
-			);
+		if (!wantsPrerender(content)) return [];
+		const skip = prerenderSkipReason(content);
+		if (skip) {
+			console.warn(`   ⚠️  ${route.pattern} has prerender=true && ${skip}, skipped`);
 			return [];
 		}
 		const ts = route.trailingSlash;
@@ -144,7 +144,7 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<Prerender
 	const apiTasks = manifest.apis.map(async (route): Promise<PrerenderTarget[]> => {
 		const filePath = join("src", "routes", route.server);
 		const content = await Bun.file(filePath).text();
-		if (!/export\s+const\s+prerender\s*=\s*true/.test(content)) return [];
+		if (!wantsPrerender(content)) return [];
 		if (route.pattern.includes("["))
 			return expandDynamicRoute(route.pattern, filePath, "api", "never");
 		return [{ path: route.pattern, kind: "api", trailingSlash: "never" }];

package/src/core/renderer.ts

@@ -36,6 +36,7 @@ import {
 } from "./html.ts";
 import type { Metadata } from "./hooks.ts";
 import { loadPlugins } from "./config.ts";
+import { getPlatform, warmingUp } from "./platform.ts";
 import { reportDevErrorFromCatch } from "./devErrorReport.ts";
 import { dev500Response } from "./dev-500.ts";
 import type { BosiaPlugin, RenderContext } from "./types/plugin.ts";
@@ -419,7 +420,7 @@ export async function loadRouteData(
 				continue;
 			}
 			const mod = await ls.loader();
-			if (typeof mod.load === "function") {
+			if (typeof mod.load === "function" && !warmingUp) {
 				// Snapshot per layer so loaders cannot mutate the shared accumulator,
 				// preserving the same isolation semantics as the previous merge-on-call code.
 				const snapshot = { ...parentData };
@@ -436,6 +437,7 @@ export async function loadRouteData(
 							fetch: trackedFetch(fetch, origin, deps),
 							metadata: null,
 							depends: makeDepends(deps),
+							platform: getPlatform(),
 							setHeaders,
 						}),
 						LOAD_TIMEOUT,
@@ -487,7 +489,7 @@ export async function loadRouteData(
 			if (skipPage) {
 				pageData = null;
 				pageDeps = null;
-			} else if (typeof mod.load === "function") {
+			} else if (typeof mod.load === "function" && !warmingUp) {
 				const snapshot = { ...parentData };
 				const parent = async () => snapshot;
 				const deps = emptyDeps();
@@ -502,6 +504,7 @@ export async function loadRouteData(
 							fetch: trackedFetch(fetch, origin, deps),
 							metadata: metadataData,
 							depends: makeDepends(deps),
+							platform: getPlatform(),
 							setHeaders,
 						}),
 						LOAD_TIMEOUT,
@@ -560,11 +563,11 @@ export async function loadMetadata(
 	if (!route.pageServer) return null;
 	try {
 		const mod = await route.pageServer();
-		if (typeof mod.metadata === "function") {
+		if (typeof mod.metadata === "function" && !warmingUp) {
 			const fetch = makeFetch(req, url);
 			return (
 				(await withTimeout(
-					mod.metadata({ params, url, locals, cookies, fetch }),
+					mod.metadata({ params, url, locals, cookies, fetch, platform: getPlatform() }),
 					METADATA_TIMEOUT,
 					`metadata (${url.pathname})`,
 				)) ?? null
@@ -618,7 +621,8 @@ export async function renderSSRStream(
 	// into the cached HTML but the CSP header is re-derived each request, so a
 	// cached page would ship with a dead nonce and the browser would block its
 	// inline scripts. Operators who turn on CSP_DIRECTIVES forfeit the cache.
-	const cacheable = CACHE_ENABLED && !CSP_ENABLED && routeCacheable && req.method === "GET";
+	const cacheable =
+		CACHE_ENABLED && !CSP_ENABLED && !warmingUp && routeCacheable && req.method === "GET";
 	let cacheKey: string | null = null;
 	let releaseMiss: (() => void) | null = null;
 	if (cacheable) {
@@ -652,7 +656,8 @@ export async function renderSSRStream(
 			metadata = await loadMetadata(route, params, url, locals, cookies, req);
 		} catch (err) {
 			if (isRedirect(err)) {
-				return Response.redirect(err.location, err.status);
+				// Not Response.redirect(): it rejects relative URLs on Workers.
+				return new Response(null, { status: err.status, headers: { Location: err.location } });
 			}
 			if (isHttpError(err)) {
 				return renderErrorPage(
@@ -690,7 +695,8 @@ export async function renderSSRStream(
 			]);
 			pageMod = pm;
 		} catch (err) {
-			if (isRedirect(err)) return Response.redirect(err.location, err.status);
+			if (isRedirect(err))
+				return new Response(null, { status: err.status, headers: { Location: err.location } });
 			if (isHttpError(err)) {
 				const e = err as HttpError & {
 					errorDepth?: number;
@@ -950,7 +956,8 @@ export async function renderPageWithFormData(
 	try {
 		metadata = await loadMetadata(route, params, url, locals, cookies, req);
 	} catch (err) {
-		if (isRedirect(err)) return Response.redirect(err.location, err.status);
+		if (isRedirect(err))
+			return new Response(null, { status: err.status, headers: { Location: err.location } });
 		if (isHttpError(err)) {
 			return renderErrorPage(
 				err.status,

package/src/core/routeFile.ts

@@ -68,6 +68,7 @@ export function generateRoutesFile(manifest: RouteManifest): void {
 	lines.push("  layoutIds: (string | null)[];");
 	lines.push("  loading: (() => Promise<any>) | null;");
 	lines.push("  layoutPaths: string[];");
+	lines.push("  prerender: boolean;");
 	lines.push("}> = [");
 	for (const r of pages) {
 		const layoutImports = r.layouts
@@ -102,6 +103,7 @@ export function generateRoutesFile(manifest: RouteManifest): void {
 			`    loading: ${r.loading ? `() => import(${JSON.stringify(toImportPath(r.loading))})` : "null"},`,
 		);
 		lines.push(`    layoutPaths: ${JSON.stringify(r.layouts)},`);
+		lines.push(`    prerender: ${r.prerender},`);
 		lines.push("  },");
 	}
 	lines.push("];\n");
@@ -204,6 +206,7 @@ function generateClientRoutesFile(
 	lines.push("  layoutIds: (string | null)[];");
 	lines.push("  loading: (() => Promise<any>) | null;");
 	lines.push("  layoutPaths: string[];");
+	lines.push("  prerender: boolean;");
 	lines.push("}> = [");
 	for (const r of pages) {
 		const layoutImports = r.layouts
@@ -235,6 +238,7 @@ function generateClientRoutesFile(
 			`    loading: ${r.loading ? `() => import(${JSON.stringify(toImportPath(r.loading))})` : "null"},`,
 		);
 		lines.push(`    layoutPaths: ${JSON.stringify(r.layouts)},`);
+		lines.push(`    prerender: ${r.prerender},`);
 		lines.push("  },");
 	}
 	lines.push("];\n");

package/src/core/scanner.ts

@@ -42,6 +42,35 @@ function readPageCache(filePath: string): boolean | null {
 	}
 }
 
+/** Literal `export const prerender = true` in a server module's source. */
+export function wantsPrerender(src: string): boolean {
+	return /export\s+const\s+prerender\s*=\s*true/.test(src);
+}
+
+/** Why a page that asks for prerender can't have it, or null when it can. */
+export function prerenderSkipReason(src: string): string | null {
+	if (/export\s+const\s+ssr\s*=\s*false/.test(src)) return "ssr=false — contradictory";
+	// A static file can't run an action: Bun would answer the POST with the
+	// prerendered HTML, Workers' asset server with 405. Render it live instead.
+	if (
+		/export\s+(const|let|var|async\s+function|function)\s+actions\b|export\s*\{[^}]*\bactions\b/.test(
+			src,
+		)
+	)
+		return "actions — forms need a live page";
+	return null;
+}
+
+/** True when the page will really be prerendered — the client fetches its data as a static file. */
+function readPrerender(filePath: string): boolean {
+	try {
+		const src = readFileSync(filePath, "utf-8");
+		return wantsPrerender(src) && prerenderSkipReason(src) === null;
+	} catch {
+		return false;
+	}
+}
+
 function readTrailingSlash(filePath: string): TrailingSlash | null {
 	try {
 		const src = readFileSync(filePath, "utf-8");
@@ -137,6 +166,7 @@ export function scanRoutes(): RouteManifest {
 				errorPages: [...currentErrorPages],
 				trailingSlash: effectiveTs,
 				cache: readPageCache(join(ROUTES_DIR, pageFile)),
+				prerender: pageServerFile ? readPrerender(join(ROUTES_DIR, pageServerFile)) : false,
 			});
 		}