bosia 0.9.7 → 0.9.9

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "bosia",
-	"version": "0.9.7",
+	"version": "0.9.9",
 	"type": "module",
-	"description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing No Node.js, no Vite, no adapters.",
+	"description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing. No Node.js, no Vite. Runs on Bun or Cloudflare Workers.",
 	"keywords": [
 		"bun",
 		"svelte",

package/src/ambient.d.ts

@@ -11,6 +11,7 @@ declare module "bosia:routes" {
 		layouts: Loader[];
 		hasServerData: boolean;
 		trailingSlash: TrailingSlash;
+		prerender: boolean;
 	}>;
 
 	export const serverRoutes: Array<{
@@ -29,3 +30,9 @@ declare module "bosia:routes" {
 
 	export const errorPage: Loader | null;
 }
+
+// Workers only — backed by .bosia/runtime.workers.ts (see core/workersCodegen.ts).
+declare module "bosia:workers-runtime" {
+	export const handle: import("./core/hooks.ts").Handle | null;
+	export const config: import("./core/types/plugin.ts").BosiaConfig;
+}

package/src/cli/build.ts

@@ -2,8 +2,13 @@ import { spawn } from "bun";
 import { resolve } from "path";
 import { loadEnv } from "../core/env.ts";
 
-export async function runBuild() {
+export async function runBuild(args: string[] = []) {
 	loadEnv("production");
+	// --target=workers or --target workers; overrides bosia.config's `target`.
+	const eq = args.find((a) => a.startsWith("--target="));
+	const i = args.indexOf("--target");
+	const target = eq ? eq.slice("--target=".length) : i !== -1 ? args[i + 1] : undefined;
+	if (target) process.env.BOSIA_TARGET = target;
 	const buildScript = resolve(import.meta.dir, "../core/build.ts");
 	const proc = spawn(["bun", "run", buildScript], {
 		stdout: "inherit",

package/src/cli/index.ts

@@ -2,7 +2,7 @@
 // ─── Bosia CLI ────────────────────────────────────────────
 //   bun x bosia@latest create <name>   scaffold a new project
 //   bun x bosia dev                       start the development server
-//   bun x bosia build                     build for production
+//   bun x bosia build [--target=workers]  build for production (Bun or Cloudflare Workers)
 //   bun x bosia start                     run the production server
 //   bun x bosia@latest add <name>         add a UI component from the registry
 //   bun x bosia@latest feat <name>        add a feature scaffold from the registry
@@ -40,7 +40,7 @@ async function main() {
 		}
 		case "build": {
 			const { runBuild } = await import("./build.ts");
-			await runBuild();
+			await runBuild(args);
 			break;
 		}
 		case "sync": {
@@ -114,7 +114,7 @@ Usage:
 Commands:
   create <name> [--template <t>]  Scaffold a new Bosia project
   dev                 Start the development server
-  build               Build for production
+  build               Build for production (--target=workers for Cloudflare)
   sync                Generate .bosia/ codegen (routes, $types, env) without building
   start               Run the production server
   test [args]         Run tests with bun test (auto-loads .env.test, sets BOSIA_ENV=test)

package/src/cli/start.ts

@@ -6,12 +6,20 @@ export async function runStart() {
 	loadEnv("production");
 
 	let serverEntry = "index.js";
+	let target = "bun";
 	try {
 		const manifest = await Bun.file(`${OUT_DIR}/manifest.json`).json();
 		serverEntry = manifest.serverEntry ?? "index.js";
+		target = manifest.target ?? "bun";
 	} catch {}
 
-	const proc = spawn(["bun", "run", `${OUT_DIR}/server/${serverEntry}`], {
+	// A Workers build runs in workerd, locally via wrangler (fetched on first use).
+	const cmd =
+		target === "workers"
+			? ["bunx", "wrangler", "dev", ...(process.env.PORT ? ["--port", process.env.PORT] : [])]
+			: ["bun", "run", `${OUT_DIR}/server/${serverEntry}`];
+
+	const proc = spawn(cmd, {
 		stdout: "inherit",
 		stderr: "inherit",
 		cwd: process.cwd(),

package/src/cli/sync.ts

@@ -1,4 +1,4 @@
-import { scanRoutes } from "../core/scanner.ts";
+import { scanRoutes, RouteConflictError } from "../core/scanner.ts";
 import { generateRoutesFile } from "../core/routeFile.ts";
 import { generateRouteTypes, ensureRootDirs } from "../core/routeTypes.ts";
 import { loadEnv, classifyEnvVars } from "../core/env.ts";
@@ -8,7 +8,14 @@ import { findBrandPlaceholders, BRAND_SENTINEL } from "../core/brandGuard.ts";
 export async function runSync() {
 	const envMode = process.env.NODE_ENV === "production" ? "production" : "development";
 	const classifiedEnv = classifyEnvVars(loadEnv(envMode));
-	const manifest = scanRoutes();
+	let manifest;
+	try {
+		manifest = scanRoutes();
+	} catch (err) {
+		if (!(err instanceof RouteConflictError)) throw err;
+		console.error(`❌ ${err.message}`);
+		process.exit(1);
+	}
 	generateRoutesFile(manifest);
 	generateRouteTypes(manifest);
 	ensureRootDirs();

package/src/core/appHtml.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
 
 import { OUT_DIR } from "./paths.ts";
+import { readArtifact } from "./artifacts.ts";
 import { rebaseHtmlAttrs } from "./basePath.ts";
 import { currentBase } from "./appBase.ts";
 
@@ -86,16 +87,6 @@ export function writeAppHtmlSegments(segments: AppHtmlSegments, outDir: string =
 	return target;
 }
 
-function readPersistedSegments(cwd: string): AppHtmlSegments | undefined {
-	const persistedPath = join(cwd, OUT_DIR, "app-html.json");
-	if (!existsSync(persistedPath)) return undefined;
-	try {
-		return JSON.parse(readFileSync(persistedPath, "utf-8")) as AppHtmlSegments;
-	} catch {
-		return undefined;
-	}
-}
-
 // ─── Cached Getter ────────────────────────────────────────
 
 export function getAppHtmlSegments(cwd: string = process.cwd()): AppHtmlSegments {
@@ -104,7 +95,8 @@ export function getAppHtmlSegments(cwd: string = process.cwd()): AppHtmlSegments
 	}
 	// Prefer persisted dist artifact (production runtime — no `src/` in image).
 	// Fall back to parsing `src/app.html` directly (dev mode, build step).
-	cachedSegments = readPersistedSegments(cwd) ?? loadAppHtmlTemplate(cwd);
+	cachedSegments =
+		readArtifact<AppHtmlSegments>("app-html.json", join(cwd, OUT_DIR)) ?? loadAppHtmlTemplate(cwd);
 	return cachedSegments;
 }
 

package/src/core/artifacts.ts

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+import { OUT_DIR } from "./paths.ts";
+
+// ─── Build Artifacts ─────────────────────────────────────
+// The one place the runtime reads the JSON the build left in OUT_DIR
+// (manifest.json, app-html.json, route-manifest.json). Runtimes without a
+// filesystem (Cloudflare Workers) swap this module for `.bosia/artifacts.ts`,
+// which holds the same JSON inlined — see artifactCodegen.ts and plugin.ts.
+
+/** Parsed `<dir>/<name>`, or undefined when it is missing or unreadable. */
+export function readArtifact<T>(name: string, dir: string = OUT_DIR): T | undefined {
+	const p = join(dir, name);
+	if (!existsSync(p)) return undefined;
+	try {
+		return JSON.parse(readFileSync(p, "utf-8")) as T;
+	} catch {
+		return undefined;
+	}
+}

package/src/core/build.ts

@@ -2,7 +2,7 @@ import { writeFileSync, readFileSync, rmSync, mkdirSync, existsSync } from "fs";
 import { basename, join, relative } from "path";
 import type { RouteManifest } from "./types.ts";
 
-import { scanRoutes } from "./scanner.ts";
+import { scanRoutes, RouteConflictError } from "./scanner.ts";
 import { generateRoutesFile } from "./routeFile.ts";
 import { generateRouteTypes, ensureRootDirs } from "./routeTypes.ts";
 import { makeBosiaPlugin } from "./plugin.ts";
@@ -14,9 +14,15 @@ import { generateEnvModules } from "./envCodegen.ts";
 import { BOSIA_NODE_PATH, OUT_DIR, resolveBosiaBin, toPosix } from "./paths.ts";
 import { currentBase } from "./appBase.ts";
 import { finalizeTailwindCss, TW_TEMP_BASENAME } from "./twHash.ts";
-import { loadPlugins } from "./config.ts";
-import type { BuildContext } from "./types/plugin.ts";
+import { loadBosiaConfig, loadPlugins } from "./config.ts";
+import type { BuildContext, RuntimeTarget } from "./types/plugin.ts";
 import { loadAppHtmlTemplate, writeAppHtmlSegments } from "./appHtml.ts";
+import {
+	generateArtifactsModule,
+	generateWorkersRuntime,
+	generateWranglerConfig,
+} from "./workersCodegen.ts";
+import { workersGuardReport } from "./workersGuard.ts";
 
 // Resolved from this file's location inside the bosia package
 const CORE_DIR = import.meta.dir;
@@ -42,6 +48,23 @@ const buildCtx: BuildContext = {
 	cwd: process.cwd(),
 };
 
+// 0-bis. Runtime target: `bosia build --target=` (BOSIA_TARGET) beats bosia.config.
+const target = (process.env.BOSIA_TARGET ||
+	(await loadBosiaConfig()).target ||
+	"bun") as RuntimeTarget;
+if (target !== "bun" && target !== "workers") {
+	console.error(`❌ Unknown target "${target}". Use "bun" or "workers".`);
+	process.exit(1);
+}
+if (target !== "bun") console.log(`🎯 Target: ${target}`);
+if (target === "workers") {
+	const guard = workersGuardReport();
+	if (guard) {
+		console.error(`❌ ${guard}`);
+		process.exit(1);
+	}
+}
+
 for (const p of userPlugins) {
 	if (p.build?.preBuild) {
 		await p.build.preBuild(buildCtx);
@@ -77,6 +100,8 @@ for (const p of [
 	".bosia/routes.client.ts",
 	".bosia/env.server.ts",
 	".bosia/env.client.ts",
+	".bosia/artifacts.ts",
+	".bosia/runtime.workers.ts",
 	".bosia/types",
 ]) {
 	try {
@@ -85,7 +110,14 @@ for (const p of [
 }
 
 // 1. Scan routes (or reuse the cached manifest — see 0b-pre)
-const manifest = cachedManifest ?? scanRoutes();
+let manifest: RouteManifest;
+try {
+	manifest = cachedManifest ?? scanRoutes();
+} catch (err) {
+	if (!(err instanceof RouteConflictError)) throw err;
+	console.error(`❌ ${err.message}`);
+	process.exit(1);
+}
 buildCtx.manifest = manifest;
 console.log(
 	`📂 Found ${manifest.pages.length} page route(s)${cachedManifest ? " (cached scan)" : ""}:`,
@@ -180,7 +212,9 @@ const clientPromise = Bun.build({
 	target: "browser",
 	conditions: ["svelte"],
 	splitting: true,
-	naming: { entry: "[name]-[hash].[ext]", chunk: "[name]-[hash].[ext]" },
+	// Chunks are named after their source, which for routes is `+page` — and
+	// Cloudflare's asset server answers a `+` in the path with a redirect.
+	naming: { entry: "[name]-[hash].[ext]", chunk: "chunk-[hash].[ext]" },
 	minify: isProduction,
 	sourcemap: isProduction ? "none" : "linked",
 	define: {
@@ -191,7 +225,7 @@ const clientPromise = Bun.build({
 });
 
 const serverPromise = Bun.build({
-	entrypoints: [join(CORE_DIR, "server.ts")],
+	entrypoints: [join(CORE_DIR, "server.bun.ts")],
 	outdir: `${OUT_DIR}/server`,
 	target: "bun",
 	conditions: ["svelte"],
@@ -285,10 +319,14 @@ const distManifest = {
 		jsFiles.find((f) => f.startsWith("hydrate")) ??
 		"hydrate.js",
 	serverEntry,
+	target,
 	tw: twFile,
 	// The CSS urls and the client route table are baked in with this prefix.
 	// Stamped so the server can warn when it boots with a different one.
 	basePath: currentBase(),
+	// Names of PUBLIC_* runtime vars the page may expose to the browser. The
+	// server is its own process, so it can't see which names loadEnv() declared.
+	publicEnv: Object.keys(classifiedEnv.publicDynamic),
 };
 writeFileSync(`${OUT_DIR}/manifest.json`, JSON.stringify(distManifest, null, 2));
 console.log(`✅ Client bundle: ${jsFiles.join(", ")}`);
@@ -315,6 +353,10 @@ await prerenderStaticRoutes(manifest);
 // 10. Generate static site output (HTML + client assets + public → dist/static/)
 generateStaticSite();
 
+// 11. Workers target: a second server bundle for Cloudflare. The Bun one above
+// still exists — prerender just booted it to crawl static routes.
+if (target === "workers") await buildWorker();
+
 for (const p of userPlugins) {
 	if (p.build?.postBuild) {
 		await p.build.postBuild(buildCtx);
@@ -325,6 +367,63 @@ console.log(`\n🎉 Build complete in ${Math.round(performance.now() - buildStar
 
 // ─── Helpers ─────────────────────────────────────────────
 
+// Dev-only plugins in bosia.config.ts (the inspector) import svelte/compiler, which
+// would put ~820KB of never-run code in the worker, 60% of the demo's bundle.
+// Nothing compiles Svelte at runtime, so every export becomes a function that throws.
+function stubSvelteCompiler(): import("bun").BunPlugin {
+	return {
+		name: "bosia-stub-svelte-compiler",
+		setup(build) {
+			build.onResolve({ filter: /^svelte\/compiler$/ }, () => ({
+				path: "svelte/compiler",
+				namespace: "bosia-stub",
+			}));
+			build.onLoad({ filter: /.*/, namespace: "bosia-stub" }, async () => {
+				const names = Object.keys(await import("svelte/compiler"));
+				const fail = `() => { throw new Error("The Svelte compiler isn't available on Cloudflare Workers"); }`;
+				return {
+					loader: "js",
+					contents: names.map((n) => `export const ${n} = ${fail};`).join("\n"),
+				};
+			});
+		},
+	};
+}
+
+async function buildWorker(): Promise<void> {
+	// The isolate has no filesystem: inline the artifacts and static-import the
+	// user's hooks + config instead of reading them off disk at boot.
+	generateArtifactsModule();
+	generateWorkersRuntime();
+	// target "node" would emit createRequire(import.meta.url), and import.meta.url
+	// is undefined in workerd. Node builtins stay `node:` imports (nodejs_compat).
+	const result = await Bun.build({
+		entrypoints: [join(CORE_DIR, "server.workers.ts")],
+		outdir: `${OUT_DIR}/worker`,
+		target: "browser",
+		format: "esm",
+		conditions: ["workerd", "worker", "svelte"],
+		naming: { entry: "index.[ext]" },
+		minify: isProduction,
+		external: ["node:*"],
+		define: { "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV ?? "development") },
+		plugins: [
+			stubSvelteCompiler(),
+			makeBosiaPlugin("bun", "workers"),
+			...userServerBunPlugins,
+			makeBosiaSvelteCompiler("bun"),
+		],
+	});
+	if (!result.success) {
+		console.error("❌ Worker build failed:");
+		for (const msg of result.logs) console.error(msg);
+		process.exit(1);
+	}
+	const kb = Math.round((result.outputs[0]?.size ?? 0) / 1024);
+	console.log(`✅ Worker entry:  ${OUT_DIR}/worker/index.js (${kb}KB)`);
+	if (generateWranglerConfig()) console.log("☁️  Wrote wrangler.jsonc");
+}
+
 async function readUserDependencyNames(cwd: string): Promise<string[]> {
 	try {
 		const pkg = (await Bun.file(join(cwd, "package.json")).json()) as {

package/src/core/cache.ts

@@ -5,10 +5,14 @@
 //
 // See docs/guides/response-cache.md.
 
-import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
+// node:crypto / node:zlib rather than Bun.* — the same code runs on Bun and on
+// Cloudflare Workers (nodejs_compat), and both stay sync there.
+import { createHash } from "node:crypto";
+import { brotliCompressSync, gzipSync, constants as zlibConstants } from "node:zlib";
 import type { Cookies, LoaderDeps } from "./hooks.ts";
 import type { CookieJar } from "./cookies.ts";
 import { dedupKey } from "./dedup.ts";
+import { compressionOn, PRECOMPRESSED } from "./html.ts";
 
 // ─── Config ──────────────────────────────────────────────
 
@@ -125,7 +129,7 @@ const pathIndex = new Map<string, Set<string>>(); // pathname → cacheKeys
 
 /** SHA-256 truncated to 64 bits — identity buckets must not collide across users. */
 function identityDigest(s: string): string {
-	return new Bun.CryptoHasher("sha256").update(s).digest("hex").slice(0, 16);
+	return createHash("sha256").update(s).digest("hex").slice(0, 16);
 }
 
 export function computeIdentityHash(req: Request, cookies: Pick<CookieJar, "peek">): string {
@@ -282,11 +286,11 @@ export function buildCompressedVariants(body: Bytes): {
 	brotli: Bytes | null;
 } {
 	const COMPRESS_MIN_BYTES = 2048;
-	if (body.length < COMPRESS_MIN_BYTES) return { gzip: null, brotli: null };
+	if (!compressionOn || body.length < COMPRESS_MIN_BYTES) return { gzip: null, brotli: null };
 	let gzip: Bytes | null = null;
 	let brotli: Bytes | null = null;
 	try {
-		gzip = Bun.gzipSync(body) as Bytes;
+		gzip = new Uint8Array(gzipSync(body)) as Bytes;
 	} catch {
 		gzip = null;
 	}
@@ -360,11 +364,11 @@ export function serveCached(entry: CacheEntry, req: Request): Response {
 	};
 	if (entry.brotli && accept.includes("br")) {
 		headers["content-encoding"] = "br";
-		return new Response(entry.brotli, { status: entry.status, headers });
+		return new Response(entry.brotli, { ...PRECOMPRESSED, status: entry.status, headers });
 	}
 	if (entry.gzip && accept.includes("gzip")) {
 		headers["content-encoding"] = "gzip";
-		return new Response(entry.gzip, { status: entry.status, headers });
+		return new Response(entry.gzip, { ...PRECOMPRESSED, status: entry.status, headers });
 	}
 	return new Response(entry.raw, { status: entry.status, headers });
 }

package/src/core/client/App.svelte

@@ -219,7 +219,10 @@
 		// Forward cached parent data for skipped layers so downstream loaders see
 		// real parent() data, not {}. POST only when there's something to carry —
 		// keeps the no-skip case a cacheable/dedupable GET.
-		const snapshots = buildParentSnapshots(path, maskBits);
+		// A prerendered route's data is a fixed file, so there is nothing to skip —
+		// and on Workers the asset server answers anything but GET with 405.
+		const prerendered = match.route.prerender;
+		const snapshots = prerendered ? {} : buildParentSnapshots(path, maskBits);
 		const dataInit: RequestInit =
 			Object.keys(snapshots).length > 0
 				? {
@@ -231,7 +234,7 @@
 		const dataFetch = cached
 			? Promise.resolve(cached)
 			: match.route.hasServerData
-				? fetch(dataUrl(path, maskBits), dataInit)
+				? fetch(dataUrl(path, prerendered ? undefined : maskBits), dataInit)
 						.then(readDataResponse)
 						// Only a failed request reaches here now — offline, DNS, aborted.
 						// A response that arrived is read for what it says, not discarded.

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;
 	}
@@ -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");
 }
 

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 = {