void 0.1.6 → 0.7.0

package/dist/index.mjs

@@ -0,0 +1,4695 @@
+import { r as __toESM } from "./chunk-DJd-R1mw.mjs";
+import { a as join, n as dirname, o as relative } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { u as require_picocolors } from "./output-BwlcIYSR.mjs";
+import { n as loadVoidAuthConfig, t as findVoidAuthConfig } from "./config-CvHtTM0q.mjs";
+import { r as readProjectConfig } from "./project-TqORyHn8.mjs";
+import { l as isStagingMode, s as getToken } from "./client-snXOjrp1.mjs";
+import { _ as resolveSandboxConfig, a as prerenderPagesNode, c as filterLoadedEnv, d as ensureWranglerCompatibilityDate, f as ensureWranglerNodejsAlsFlag, g as isSandboxEnabled, h as SANDBOX_MIGRATION_TAG, i as prerenderPages, l as resolveRemoteMode, m as syncWranglerBindings, n as resolveDistDir, o as DEFAULT_PROXY_URL, p as readWranglerCompat, r as resolveWorkerDirName, s as STAGING_PROXY_URL, u as stripInternalEnvKeys } from "./deploy-BPKblFx6.mjs";
+import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-BIa9HwVX.mjs";
+import { i as scanJobsSync, n as scanWebSocketRoutesSync, r as scanQueuesSync, t as scanRoutes } from "./scan-C6HMEIdW.mjs";
+import { a as SSR_SERVER_ENTRY_RELATIVE_PATHS, c as validateSsrEntry, d as isIdentifier, f as isLiteral, h as walk, i as SSR_CLIENT_ENTRY_RELATIVE_PATHS, l as inferBindingsFromSource, n as detectFramework, p as isMemberExpression, r as inferProjectBindings, s as validateSsrEntries, t as FRAMEWORK_SCAN_DIRS } from "./plugin-inference-oZ6Ybu2_.mjs";
+import { i as voidWarn, n as voidError, r as voidLog, t as setShowTimestamp } from "./log-DXdqnmhF.mjs";
+import { r as parseDotenvFile } from "./dotenv-DwO4ti0Z.mjs";
+import { i as generateDbDts, n as generateQueueTypes, r as DRIZZLE_OPERATORS, t as generateRouteTypes } from "./route-types-DReF1gUY.mjs";
+import { n as ensureProjectTsconfig } from "./project-tsconfig-DfkESbDL.mjs";
+import { t as discoverSchema } from "./discover-B7FkXBLB.mjs";
+import { t as MagicString } from "./magic-string.es-D6g9UnIy.mjs";
+import { n as generateEnvTypes, t as findEnvFile } from "./env-types-DknSA4SO.mjs";
+import { a as loadUserEnvFile } from "./env-validation-DJKjR_8q.mjs";
+import { i as resolveLayoutIds } from "./scan-Ba4hFwlH.mjs";
+import { n as lintDuplicateSources, r as mergeRoutingRules, t as lintDestinationSplats } from "./headers-DCXc7mDs.mjs";
+import { n as generateVoidAuthDrizzleSchema, t as generateVoidAuthDatabaseModule } from "./drizzle-NnudE_UN.mjs";
+import { t as INTERNAL_BINDING_PREFIXES } from "./env-raw-BDL4TvdN.mjs";
+import { n as defer } from "./defer-DcxEsVH1.mjs";
+import { VoidAssetRewriteError, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled } from "./runtime/handler.mjs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, writeFileSync, writeSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { loadEnv, normalizePath, parseSync } from "vite";
+import { homedir } from "node:os";
+//#region src/plugin-dev-triggers-hint.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+/**
+* Prints a one-shot hint on dev server start when the project has crons
+* or queues, explaining how to trigger them locally. Both default Void mode
+* and framework mode (SvelteKit, Nuxt, Analog, Astro, TanStack Start, React
+* Router, vinext) expose `/__void/scheduled` and `/__void/queue`.
+*/
+function devTriggersHintPlugin(root, options) {
+	const { devTriggerToken } = options;
+	return {
+		name: "void:dev-triggers-hint",
+		apply: "serve",
+		configureServer(server) {
+			const jobs = scanJobsSync(root);
+			const queues = scanQueuesSync(root);
+			if (jobs.length === 0 && queues.length === 0) return;
+			const afterReady = (fn) => {
+				if (server.httpServer) server.httpServer.once("listening", () => setTimeout(fn, 100));
+				else fn();
+			};
+			afterReady(() => {
+				const address = server.httpServer?.address();
+				const port = typeof address === "object" && address ? address.port : null;
+				if (port == null) return;
+				const baseUrl = `http://localhost:${port}`;
+				const summary = [];
+				if (jobs.length > 0) summary.push(`${jobs.length} cron${jobs.length === 1 ? "" : "s"}`);
+				if (queues.length > 0) summary.push(`${queues.length} queue${queues.length === 1 ? "" : "s"}`);
+				console.log();
+				voidLog(`Detected ${summary.join(" and ")}. Trigger locally:`);
+				const configuredProxyToken = parseDotenvFile(join(root, ".dev.vars"), { expand: false }).__VOID_PROXY_TOKEN;
+				const authHeader = configuredProxyToken ? `x-void-internal: ${configuredProxyToken}` : `x-void-dev-trigger: ${devTriggerToken}`;
+				if (jobs.length > 0) {
+					const sample = jobs[0].crons[0];
+					console.log(`         \x1b[2mcurl -X POST ${baseUrl}/__void/scheduled \\\n           -H "${authHeader}" \\\n           -d '{"cron":"${sample}","scheduledTime":'"$(date +%s000)"'}'\x1b[22m`);
+				}
+				if (queues.length > 0) {
+					const sample = queues[0].name;
+					console.log(`         \x1b[2mcurl -X POST ${baseUrl}/__void/queue \\\n           -H "${authHeader}" \\\n           -d '{"queue":"${sample}","messages":[{"id":"1","timestamp":'"$(date +%s000)"',"body":{},"attempts":1}]}'\x1b[22m`);
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/plugin-drizzle.ts
+const drizzleD1Resolved = fileURLToPath(import.meta.resolve("drizzle-orm/d1"));
+const drizzleOrmResolved = fileURLToPath(import.meta.resolve("drizzle-orm"));
+const envModuleResolved = fileURLToPath(import.meta.resolve("#self/_env"));
+const drizzleNodePgResolved = fileURLToPath(import.meta.resolve("drizzle-orm/node-postgres"));
+const pgResolved = fileURLToPath(import.meta.resolve("pg"));
+const VIRTUAL_DB_ID = "\0virtual:void-db";
+const VIRTUAL_SCHEMA_DB_ID = "\0virtual:void-db-schema";
+/**
+* Vite plugin for Drizzle integration.
+*
+* - Intercepts `void/db` imports in SSR/worker environments and serves
+*   a virtual module that creates a Drizzle DB instance, using the user's
+*   schema when present.
+* - Generates `.void/db.d.ts` with proper Drizzle types.
+* - Sets up `@schema` Vite alias for convenient imports when a schema exists.
+* - Updates `.void/tsconfig.json` with TypeScript paths.
+*/
+function drizzlePlugin(root, hasRouteTypes, dialect = "sqlite", options = {}) {
+	const outDir = join(root, ".void");
+	const schema = discoverSchema(root);
+	const hasDbRuntime = schema != null || options.forceVirtualDb === true;
+	ensureProjectTsconfig(root, hasRouteTypes, hasDbRuntime, schema != null, { redirectDbModule: options.redirectDbTypePaths });
+	if (hasDbRuntime) generateDbDts(outDir, schema ?? null, dialect);
+	let isBuild = false;
+	return {
+		name: "void:drizzle",
+		enforce: "pre",
+		config(_, env) {
+			isBuild = env.command === "build";
+			if (!schema) return;
+			return { resolve: { alias: { "@schema": schema.path } } };
+		},
+		resolveId: {
+			filter: { id: /^(void\/db|@schema|pg$)/ },
+			handler(id, importer) {
+				if (id === "pg" && isBuild && dialect === "postgresql" && importer === VIRTUAL_DB_ID) return pgResolved;
+				if (id === "void/db" && this.environment?.name !== "client") {
+					if (!hasDbRuntime) return;
+					if (schema && importer) {
+						const normalizedImporter = normalizePath(importer);
+						const normalizedSchemaPath = normalizePath(schema.path);
+						if (schema.type === "file" && normalizedImporter === normalizedSchemaPath) return VIRTUAL_SCHEMA_DB_ID;
+						if (schema.type === "directory" && normalizedImporter.startsWith(normalizedSchemaPath)) return VIRTUAL_SCHEMA_DB_ID;
+					}
+					return VIRTUAL_DB_ID;
+				}
+				if (schema && (id === "@schema" || id.startsWith("@schema/"))) {
+					if (id === "@schema") return schema.path;
+					return join(schema.path, id.slice(8));
+				}
+			}
+		},
+		load: {
+			filter: { id: /^\0virtual:void-db(?:-schema)?$/ },
+			handler(id) {
+				if (id === VIRTUAL_SCHEMA_DB_ID) return `
+export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
+export const db = {};
+export function createDb() {
+  throw new Error("db: createDb() is unavailable when importing void/db from a schema file.");
+}
+`;
+				const schemaImport = schema ? `import * as schema from ${JSON.stringify(schema.path)};` : "";
+				const drizzleConfig = schema ? ", { schema }" : "";
+				if (dialect === "postgresql") return `
+import { drizzle } from ${JSON.stringify(drizzleNodePgResolved)};
+import pg from "pg";
+import { getRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
+${schemaImport}
+export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
+
+let _prodInstance;
+
+function getConnectionString() {
+  const url = getRuntimeBinding("DATABASE_URL");
+  if (url) return url;
+  const hd = getRuntimeBinding("HYPERDRIVE");
+  if (hd?.connectionString) return hd.connectionString;
+  throw new Error("db: PostgreSQL is not configured. Add DATABASE_URL to .env.local for local dev, or configure Hyperdrive for production.");
+}
+
+function getInstance() {
+  // Local dev (DATABASE_URL): create a fresh Pool per query chain.
+  // workerd kills TCP sockets between requests, so pg.Pool's cached
+  // connections go stale and hang. Fresh Pool = fresh connection every time.
+  if (getRuntimeBinding("DATABASE_URL")) {
+    return drizzle(new pg.Pool({ connectionString: getRuntimeBinding("DATABASE_URL"), max: 1 })${drizzleConfig});
+  }
+  // Production (Hyperdrive): cache the instance — Hyperdrive handles pooling.
+  _prodInstance ??= drizzle(getConnectionString()${drizzleConfig});
+  return _prodInstance;
+}
+
+export const db = new Proxy({}, {
+  get(_, prop) {
+    return Reflect.get(getInstance(), prop);
+  },
+});
+
+export function createDb(connectionString) {
+  return drizzle(connectionString${drizzleConfig});
+}
+`;
+				return `
+import { drizzle } from ${JSON.stringify(drizzleD1Resolved)};
+import { requireRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
+${schemaImport}
+export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
+
+let _instance;
+
+export const db = new Proxy({}, {
+  get(_, prop) {
+    _instance ??= drizzle(requireRuntimeBinding("DB")${drizzleConfig});
+    return Reflect.get(_instance, prop);
+  },
+});
+
+export function createDb(d1) {
+  return drizzle(d1${drizzleConfig});
+}
+`;
+			}
+		},
+		configureServer(server) {
+			if (!schema) return;
+			const migrationsDir = join(root, "db", "migrations");
+			if (!(existsSync(migrationsDir) && readdirSync(migrationsDir).some((f) => f.endsWith(".sql")))) voidWarn("Schema found but no migrations in db/migrations/.\n         Run `void db push` to apply to local DB, or\n         `void db generate` to create migration files.");
+			const watchPath = schema.path;
+			const regenerate = (path) => {
+				if (path === watchPath || schema.type === "directory" && path.startsWith(watchPath)) generateDbDts(outDir, schema, dialect);
+			};
+			server.watcher.on("change", regenerate);
+			server.watcher.on("add", regenerate);
+			server.watcher.on("unlink", regenerate);
+		}
+	};
+}
+//#endregion
+//#region src/plugin-env-client-fold.ts
+let cachedModule$1 = null;
+async function loadEnvPublic$1() {
+	if (cachedModule$1) return cachedModule$1;
+	const mod = await import("./runtime/env-public.mjs");
+	cachedModule$1 = mod;
+	return mod;
+}
+const SKIP_EXT$1 = /\.(?:css|s[ac]ss|less|styl|json|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|otf|eot|wasm|mp[34]|webm|md|mdx)(?:\?|$)/;
+const SCRIPT_LANG_RE$1 = /[?&]lang\.([a-z0-9]+)/i;
+function mentionsVoidEnv$1(code) {
+	return code.includes("void/env");
+}
+function extractEnvBindings$1(program) {
+	const direct = /* @__PURE__ */ new Set();
+	const namespace = /* @__PURE__ */ new Set();
+	let found = false;
+	for (const node of program.body ?? []) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.source.value !== "void/env") continue;
+		found = true;
+		for (const spec of node.specifiers ?? []) if (spec.type === "ImportSpecifier") {
+			const importedName = spec.imported;
+			if (!isIdentifier(importedName)) continue;
+			if (importedName.name === "env") direct.add(spec.local.name);
+		} else if (spec.type === "ImportNamespaceSpecifier") namespace.add(spec.local.name);
+	}
+	if (!found || direct.size === 0 && namespace.size === 0) return null;
+	return {
+		directNames: direct,
+		namespaceNames: namespace
+	};
+}
+/**
+* Walk the AST and collect every static `env.FOO` / `env["FOO"]` (or
+* `<ns>.env.FOO`) read. Dynamic keys (`env[variable]`) are intentionally
+* ignored — the Proxy still serves them at runtime, and we can't prove
+* they'd be folded the same way Vite folds `import.meta.env.FOO`.
+*/
+function findFoldHits(program, bindings) {
+	const hits = [];
+	walk(program, { enter(node) {
+		const current = node;
+		if (!isMemberExpression(current)) return;
+		if (isIdentifier(current.object) && bindings.directNames.has(current.object.name)) {
+			pushHit(current, hits);
+			return;
+		}
+		const obj = current.object;
+		if (isMemberExpression(obj) && !obj.computed && isIdentifier(obj.object) && bindings.namespaceNames.has(obj.object.name) && isIdentifier(obj.property) && obj.property.name === "env") pushHit(current, hits);
+	} });
+	return hits;
+}
+function pushHit(node, hits) {
+	if (!node.computed && isIdentifier(node.property)) {
+		hits.push({
+			start: node.start,
+			end: node.end,
+			property: node.property.name
+		});
+		return;
+	}
+	if (node.computed && isLiteral(node.property) && typeof node.property.value === "string") {
+		hits.push({
+			start: node.start,
+			end: node.end,
+			property: node.property.value
+		});
+		return;
+	}
+}
+/** Default Vite `envPrefix`. */
+const DEFAULT_ENV_PREFIXES$1 = ["VITE_"];
+/**
+* Build-time constant folding for client-only `env.FOO` reads.
+*
+* Purpose: match what Vite already does for `import.meta.env.FOO` so that
+* branches like `if (env.MODE === "production") { ... }` get dead-code
+* eliminated in production client bundles. The runtime `env` Proxy on the
+* client already resolves keys via `import.meta.env`, so *semantics* don't
+* change — we just move the lookup from runtime to build time, which
+* unlocks DCE and bundler minification of guarded blocks.
+*
+* Safety properties:
+*   • Runs only when `this.environment.name === 'client'`. Server / SSR /
+*     worker builds keep the full runtime Proxy (secrets, runtime-injected
+*     vars, HMR remain live).
+*   • Only folds keys that match the configured `envPrefix` — the exact
+*     set Vite is already willing to ship to the browser bundle. A
+*     server-only key is never folded (and the env-client-guard plugin
+*     would have errored out earlier anyway).
+*   • Only folds static member access: `env.FOO` and `env["FOO"]`.
+*     Dynamic access, destructuring, and reassignment fall through to the
+*     runtime Proxy.
+*   • Only folds keys with a known build-time value (loaded .env* merged
+*     with schema `.default(...)` entries). Unknown keys are left as-is
+*     and the Proxy handles them at runtime — no "undefined" shoved in.
+*   • Build-only (`apply: 'build'`). Dev runs through the Proxy so HMR
+*     and editing `.env.local` take effect without a full rebuild.
+*/
+function envClientFoldPlugin() {
+	let envPrefixes = DEFAULT_ENV_PREFIXES$1;
+	let loadedEnv = {};
+	const schemaDefaults = {};
+	/** The merged view the transform consults for each key. */
+	function resolveValue(key) {
+		if (key in loadedEnv) return loadedEnv[key];
+		if (key in schemaDefaults) return schemaDefaults[key];
+	}
+	function isExposedToClient(key) {
+		return envPrefixes.some((p) => key.startsWith(p));
+	}
+	return {
+		name: "void:env-client-fold",
+		apply: "build",
+		enforce: "post",
+		async configResolved(config) {
+			const prefix = config.envPrefix;
+			if (typeof prefix === "string") envPrefixes = [prefix];
+			else if (Array.isArray(prefix) && prefix.length > 0) envPrefixes = prefix;
+			else envPrefixes = DEFAULT_ENV_PREFIXES$1;
+			loadedEnv = { ...config.env ?? {} };
+			try {
+				const mod = await loadEnvPublic$1();
+				if (mod._hasRegisteredSchema()) {
+					const defaults = mod._getSchemaDefaults();
+					for (const [key, value] of Object.entries(defaults)) if (isExposedToClient(key) && !(key in loadedEnv)) schemaDefaults[key] = value;
+				}
+			} catch {}
+		},
+		async transform(code, id) {
+			if (this.environment?.name !== "client") return;
+			if (id.includes("/node_modules/")) return;
+			if (SKIP_EXT$1.test(id)) return;
+			const langMatch = SCRIPT_LANG_RE$1.exec(id);
+			const isScriptQuery = langMatch !== null && /^(?:m?[jt]sx?|cjs)$/i.test(langMatch[1]);
+			const isPlainScript = /\.(?:[mc]?[jt]sx?)(?:\?|$)/.test(id);
+			const isSfc = /\.(?:svelte|vue|astro)(?:\?|$)/.test(id);
+			if (!isScriptQuery && !isPlainScript && !isSfc) return;
+			if (!mentionsVoidEnv$1(code)) return;
+			if (Object.keys(loadedEnv).length === 0 && Object.keys(schemaDefaults).length === 0) return;
+			let parsed;
+			try {
+				parsed = parseSync(id, code);
+			} catch {
+				return;
+			}
+			const program = parsed.program;
+			const bindings = extractEnvBindings$1(program);
+			if (!bindings) return;
+			const hits = findFoldHits(program, bindings);
+			if (hits.length === 0) return;
+			let ms = null;
+			for (const hit of hits) {
+				if (!isExposedToClient(hit.property)) continue;
+				const value = resolveValue(hit.property);
+				if (value === void 0) continue;
+				if (!ms) ms = new MagicString(code);
+				ms.overwrite(hit.start, hit.end, JSON.stringify(value));
+			}
+			if (!ms) return;
+			return {
+				code: ms.toString(),
+				map: ms.generateMap({ hires: "boundary" })
+			};
+		}
+	};
+}
+//#endregion
+//#region src/plugin-env-client-guard.ts
+let cachedModule = null;
+async function loadEnvPublic() {
+	if (cachedModule) return cachedModule;
+	const mod = await import("./runtime/env-public.mjs");
+	cachedModule = mod;
+	return mod;
+}
+const SKIP_EXT = /\.(?:css|s[ac]ss|less|styl|json|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|otf|eot|wasm|mp[34]|webm|md|mdx)(?:\?|$)/;
+const SCRIPT_LANG_RE = /[?&]lang\.([a-z0-9]+)/i;
+/**
+* Quick check: does the source mention `void/env` at all? If not, skip the
+* full AST walk. Catches static imports, dynamic imports, and edge cases
+* like comments — false positives here just mean we parse a file we didn't
+* have to, never that we miss a real reference.
+*/
+function mentionsVoidEnv(code) {
+	return code.includes("void/env");
+}
+function extractEnvBindings(program) {
+	const direct = /* @__PURE__ */ new Set();
+	const namespace = /* @__PURE__ */ new Set();
+	let found = false;
+	for (const node of program.body ?? []) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.source.value !== "void/env") continue;
+		found = true;
+		for (const spec of node.specifiers ?? []) if (spec.type === "ImportSpecifier") {
+			const importedName = spec.imported;
+			if (!isIdentifier(importedName)) continue;
+			if (importedName.name === "env") direct.add(spec.local.name);
+		} else if (spec.type === "ImportNamespaceSpecifier") namespace.add(spec.local.name);
+		else if (spec.type === "ImportDefaultSpecifier") {}
+	}
+	if (!found || direct.size === 0 && namespace.size === 0) return null;
+	return {
+		directNames: direct,
+		namespaceNames: namespace
+	};
+}
+function buildOffsetIndex(code) {
+	const lineStarts = [0];
+	for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) lineStarts.push(i + 1);
+	return { lineStarts };
+}
+function offsetToLineCol(index, offset) {
+	const arr = index.lineStarts;
+	let lo = 0;
+	let hi = arr.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >>> 1;
+		if (arr[mid] <= offset) lo = mid;
+		else hi = mid - 1;
+	}
+	return {
+		line: lo + 1,
+		column: offset - arr[lo] + 1
+	};
+}
+/**
+* Walk the AST collecting every `env.X` (or `<ns>.env.X`) read where `env`
+* is bound to the `void/env` proxy. Computed access produces a warning hit
+* with `property === null`; everything else carries the property name.
+*/
+function findHits(program, bindings) {
+	const hits = [];
+	walk(program, { enter(node) {
+		const current = node;
+		if (!isMemberExpression(current)) return;
+		if (isIdentifier(current.object) && bindings.directNames.has(current.object.name)) {
+			recordHit(current, hits);
+			return;
+		}
+		const obj = current.object;
+		if (isMemberExpression(obj) && !obj.computed && isIdentifier(obj.object) && bindings.namespaceNames.has(obj.object.name) && isIdentifier(obj.property) && obj.property.name === "env") recordHit(current, hits);
+	} });
+	return hits;
+}
+function recordHit(node, hits) {
+	if (node.computed) {
+		hits.push({
+			kind: "warn",
+			property: null,
+			start: node.start
+		});
+		return;
+	}
+	if (!isIdentifier(node.property)) return;
+	hits.push({
+		kind: "error",
+		property: node.property.name,
+		start: node.start
+	});
+}
+/**
+* Vite plugin that fails the client build when a server-only env key
+* (anything in `defineEnv` not prefixed with `VITE_`) is referenced from a
+* module that ends up in the client bundle. The runtime proxy in
+* `env-public-client.ts` already throws for the same class of bug at
+* request time — this plugin moves the diagnosis forward to compile time
+* so it shows up in `pnpm build` and the dev overlay, not in production
+* after an admin clicks the offending route.
+*
+* No-op when no `env.ts` is registered. Server / SSR / worker environments
+* are skipped — only the `client` environment is checked.
+*/
+/** Default value matches Vite's default `envPrefix`. */
+const DEFAULT_ENV_PREFIXES = ["VITE_"];
+function envClientGuardPlugin(root) {
+	let envPrefixes = DEFAULT_ENV_PREFIXES;
+	return {
+		name: "void:env-client-guard",
+		enforce: "post",
+		configResolved(config) {
+			const prefix = config.envPrefix;
+			if (typeof prefix === "string") envPrefixes = [prefix];
+			else if (Array.isArray(prefix) && prefix.length > 0) envPrefixes = prefix;
+		},
+		async transform(code, id) {
+			if (this.environment?.name !== "client") return;
+			if (id.includes("/node_modules/")) return;
+			if (SKIP_EXT.test(id)) return;
+			const langMatch = SCRIPT_LANG_RE.exec(id);
+			const isScriptQuery = langMatch !== null && /^(?:m?[jt]sx?|cjs)$/i.test(langMatch[1]);
+			const isPlainScript = /\.(?:[mc]?[jt]sx?)(?:\?|$)/.test(id);
+			const isSfc = /\.(?:svelte|vue|astro)(?:\?|$)/.test(id);
+			if (!isScriptQuery && !isPlainScript && !isSfc) return;
+			if (!mentionsVoidEnv(code)) return;
+			const { _hasRegisteredSchema, _getRegisteredSchema } = await loadEnvPublic();
+			if (!_hasRegisteredSchema()) return;
+			const schema = _getRegisteredSchema();
+			if (!schema || Object.keys(schema).length === 0) return;
+			let parsed;
+			try {
+				parsed = parseSync(id, code);
+			} catch {
+				return;
+			}
+			const program = parsed.program;
+			const bindings = extractEnvBindings(program);
+			if (!bindings) return;
+			const hits = findHits(program, bindings);
+			if (hits.length === 0) return;
+			const offsets = buildOffsetIndex(code);
+			const relPath = relative(root, id.split("?")[0]) || id;
+			for (const hit of hits) {
+				const { line, column } = offsetToLineCol(offsets, hit.start);
+				if (hit.kind === "warn") {
+					this.warn({
+						message: `Computed access to "env[…]" at ${relPath}:${line}:${column} cannot be statically verified. If the key being read is server-only, this will throw at runtime in the browser. Prefer literal property access (env.VITE_FOO) so the build can check the split.`,
+						loc: {
+							line,
+							column,
+							file: id
+						}
+					});
+					continue;
+				}
+				const key = hit.property;
+				if (!(key in schema)) continue;
+				if (envPrefixes.some((p) => key.startsWith(p))) continue;
+				const prefixHint = envPrefixes.length === 1 ? `${envPrefixes[0]}* prefix` : `one of these prefixes: ${envPrefixes.join(", ")}`;
+				this.error({
+					message: `Server-only env "${key}" referenced from client code at ${relPath}:${line}:${column}.\nIf this should be available in the browser, rename it with the ${prefixHint} in env.ts.\nIf it must stay server-only, remove this reference and read the value via a server route or loader.`,
+					loc: {
+						line,
+						column,
+						file: id
+					}
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugin-env-schema.ts
+let cachedSchemaModule = null;
+async function loadSchemaModule() {
+	if (cachedSchemaModule) return cachedSchemaModule;
+	const mod = await import("./runtime/env-public.mjs");
+	cachedSchemaModule = mod;
+	return mod;
+}
+/**
+* Vite plugin that auto-discovers `env.ts` at the project root and:
+*   - imports it (registering the user's schema via `defineEnv`)
+*   - generates `.void/env.d.ts` so `env.X` and `c.env.X` are typed
+*   - validates the merged dev env (.env files + process.env) and warns
+*     on missing/invalid required keys
+*   - regenerates types + re-validates when env.ts changes (HMR)
+*
+* Hard errors are reserved for `void deploy`; dev keeps moving with warnings
+* so unrelated work isn't blocked by a stale .env.local.
+*/
+/** Patterns Vite's `define` typically uses for env-shaped constants. */
+const DEFINE_ENV_PATTERN = /^(?:globalThis\.)?(?:process\.env|import\.meta\.env)\.([A-Z_][A-Z0-9_]*)$/;
+function envSchemaPlugin(root, options = {}) {
+	const outDir = join(root, ".void");
+	let envFile = null;
+	let viteMode = "development";
+	let envDir = root;
+	async function emitDefaults() {
+		if (!envFile || !options.onDefaults) return;
+		const { _hasRegisteredSchema, _getSchemaDefaults } = await loadSchemaModule();
+		if (!_hasRegisteredSchema()) return;
+		options.onDefaults(_getSchemaDefaults());
+	}
+	function regenerateTypes() {
+		if (!envFile) return;
+		mkdirSync(outDir, { recursive: true });
+		const { dts } = generateEnvTypes(envFile, outDir);
+		writeFileSync(join(outDir, "env.d.ts"), dts);
+	}
+	async function importUserEnv() {
+		if (!envFile) return;
+		try {
+			await loadUserEnvFile(envFile);
+		} catch (err) {
+			voidWarn(err.message);
+		}
+	}
+	async function warnOnDefineOverlap(define) {
+		const { _hasRegisteredSchema, _getRegisteredSchema } = await loadSchemaModule();
+		if (!_hasRegisteredSchema()) return;
+		const schema = _getRegisteredSchema();
+		if (!schema) return;
+		const overlaps = [];
+		for (const defineKey of Object.keys(define)) {
+			const match = DEFINE_ENV_PATTERN.exec(defineKey);
+			if (!match) continue;
+			const name = match[1];
+			if (name in schema) overlaps.push({
+				defineKey,
+				schemaKey: name
+			});
+		}
+		if (overlaps.length === 0) return;
+		const lines = ["Vite `define` is shadowing schema env keys:"];
+		for (const { defineKey, schemaKey } of overlaps) lines.push(`  • "${defineKey}" → schema key "${schemaKey}". The compiled client code receives the define value, but the typed env.X proxy and validation still source from the schema. Prefer one or the other for any given key.`);
+		voidWarn(lines.join("\n"));
+	}
+	async function validateAndWarn() {
+		if (!envFile) return;
+		const { _hasRegisteredSchema, validateAllEnv } = await loadSchemaModule();
+		if (!_hasRegisteredSchema()) return;
+		const { loadEnv } = await import("vite");
+		const report = await validateAllEnv(filterLoadedEnv(loadEnv(viteMode, envDir, "")));
+		if (report.valid) return;
+		const lines = ["Env validation issues:"];
+		for (const key of report.missing) lines.push(`  • ${key} is required but missing — add it to .env.local or set in your shell`);
+		for (const { key, messages } of report.invalid) lines.push(`  • ${key}: ${messages.join("; ")}`);
+		voidWarn(lines.join("\n"));
+	}
+	return {
+		name: "void:env-schema",
+		async config() {
+			envFile = findEnvFile(root);
+			if (!envFile) return;
+			regenerateTypes();
+			await importUserEnv();
+			await emitDefaults();
+		},
+		async configResolved(config) {
+			viteMode = config.mode;
+			envDir = typeof config.envDir === "string" ? config.envDir : root;
+			if (envFile && config.define) await warnOnDefineOverlap(config.define);
+		},
+		async configureServer(server) {
+			if (!envFile) return;
+			await importUserEnv();
+			const run = () => {
+				validateAndWarn();
+			};
+			if (server.httpServer) server.httpServer.once("listening", () => setTimeout(run, 100));
+			else run();
+			server.watcher.add(envFile);
+			server.watcher.on("change", async (file) => {
+				if (file === envFile) {
+					voidLog("env.ts changed — regenerating types");
+					regenerateTypes();
+					await importUserEnv();
+					await emitDefaults();
+					await validateAndWarn();
+				}
+			});
+		},
+		async buildStart() {
+			if (envFile) await importUserEnv();
+		}
+	};
+}
+//#endregion
+//#region src/plugin-framework-triggers.ts
+/** Absolute path of the generated dispatch file. Stable across the dev process. */
+function frameworkTriggersDispatchPath(root) {
+	return join(root, ".void", "dev-triggers.ts");
+}
+/**
+* Synchronously emit `<root>/.void/dev-triggers.ts`. We expose this directly
+* (in addition to the Vite plugin below) so callers like the Class A entry
+* wrapper can guarantee the file exists at the moment they reference it,
+* without depending on `configResolved` ordering.
+*/
+function writeFrameworkTriggersDispatch(root, devTriggerToken) {
+	const jobs = scanJobsSync(root);
+	const queues = scanQueuesSync(root);
+	const target = frameworkTriggersDispatchPath(root);
+	mkdirSync(dirname(target), { recursive: true });
+	writeFileSync(target, generateModule(root, jobs, queues, devTriggerToken));
+}
+/**
+* Writes a real file at `<root>/.void/dev-triggers.ts` exporting
+* `handleDevTrigger(request, env, ctx)`. We use a real file (not a Vite
+* virtual module) because Nitro and Astro have their own server bundlers
+* that don't go through Vite's plugin pipeline. The framework injection
+* code imports this path at runtime to dispatch cron and queue handlers
+* with the framework adapter's real bindings.
+*/
+function frameworkTriggersPlugin(root, options) {
+	const writeDispatch = () => writeFrameworkTriggersDispatch(root, options.devTriggerToken);
+	const dispatchPath = frameworkTriggersDispatchPath(root);
+	return {
+		name: "void:framework-triggers",
+		apply: "serve",
+		configResolved() {
+			writeDispatch();
+		},
+		configureServer(server) {
+			const cronsPrefix = normalizePath(join(root, "crons"));
+			const queuesPrefix = normalizePath(join(root, "queues"));
+			const isInteresting = (file) => {
+				const normalized = normalizePath(file);
+				return normalized.startsWith(cronsPrefix) || normalized.startsWith(queuesPrefix);
+			};
+			const onChange = (file) => {
+				if (!isInteresting(file)) return;
+				writeDispatch();
+				for (const env of Object.values(server.environments)) {
+					const mod = env.moduleGraph.getModuleById(dispatchPath);
+					if (mod) env.moduleGraph.invalidateModule(mod);
+				}
+			};
+			server.watcher.on("add", onChange);
+			server.watcher.on("change", onChange);
+			server.watcher.on("unlink", onChange);
+		}
+	};
+}
+function generateModule(root, jobs, queues, devTriggerToken) {
+	const jobImports = jobs.map((j, i) => `import __job${i} from ${JSON.stringify(join(root, "crons", j.filePath))};`).join("\n");
+	const queueImports = queues.map((q, i) => `import __queue${i} from ${JSON.stringify(join(root, "queues", q.filePath))};`).join("\n");
+	const jobTable = jobs.map((j, i) => `  { crons: ${JSON.stringify(j.crons)}, handler: __job${i} }`).join(",\n");
+	const queueTable = queues.map((q, i) => `  { name: ${JSON.stringify(q.name)}, handler: __queue${i} }`).join(",\n");
+	return `// @ts-nocheck — Auto-generated by Void in dev. Do NOT edit. Regenerated on every config load.
+${jobImports}
+${queueImports}
+
+const __DEV_TRIGGER_TOKEN = ${JSON.stringify(devTriggerToken)};
+
+const __jobs = [
+${jobTable}
+];
+
+const __queues = [
+${queueTable}
+];
+
+function __json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function __authorize(request, env) {
+  const internal = request.headers.get("x-void-internal");
+  const dev = request.headers.get("x-void-dev-trigger");
+  const expected = env?.__VOID_PROXY_TOKEN;
+  if (expected) return internal === expected;
+  return dev === __DEV_TRIGGER_TOKEN;
+}
+
+function __wrapMessage(m, decisions) {
+  let decided = false;
+  return {
+    id: m.id,
+    timestamp: new Date(m.timestamp),
+    body: m.body,
+    attempts: m.attempts,
+    ack() {
+      if (!decided) {
+        decided = true;
+        decisions.set(m.id, { action: "ack" });
+      }
+    },
+    retry(opts) {
+      if (!decided) {
+        decided = true;
+        decisions.set(m.id, {
+          action: "retry",
+          ...(opts?.delaySeconds != null ? { delaySeconds: opts.delaySeconds } : {}),
+        });
+      }
+    },
+  };
+}
+
+async function __dispatchScheduled(request, env, ctx) {
+  const { cron, scheduledTime } = await request.json();
+  const job = __jobs.find((j) => j.crons.includes(cron));
+  if (!job) {
+    return __json({ error: \`No cron handler matches "\${cron}"\` }, 404);
+  }
+  const controller = { cron, scheduledTime, noRetry() {} };
+  await job.handler(controller, env, ctx ?? { waitUntil() {}, passThroughOnException() {} });
+  return __json({ ok: true });
+}
+
+async function __dispatchQueue(request, env) {
+  const payload = await request.json();
+  // Exact match only — payload.queue is the user-typed queue name from the
+  // dev curl. The prod platform-side dispatch suffix-matches against
+  // project-prefixed queue names, but that isn't relevant here and would
+  // cause false positives between e.g. "events" and "user-events".
+  const q = __queues.find((entry) => entry.name === payload.queue);
+  if (!q) {
+    return __json({ error: \`No queue handler matches "\${payload.queue}"\` }, 404);
+  }
+  const decisions = new Map();
+  const messages = (payload.messages ?? []).map((m) => __wrapMessage(m, decisions));
+  const batch = {
+    queue: payload.queue,
+    messages,
+    ackAll() {
+      for (const m of messages) m.ack();
+    },
+    retryAll(opts) {
+      for (const m of messages) m.retry(opts);
+    },
+  };
+  try {
+    await q.handler(batch, env);
+  } catch (err) {
+    console.error("[void] queue handler threw:", err);
+    // CF queues retry the entire batch when a consumer throws, regardless
+    // of any ack/retry calls made before the throw — drop partial decisions
+    // so dev-mode response semantics match prod.
+    return __json({ ok: false });
+  }
+  return __json({
+    ok: true,
+    ...(decisions.size > 0 ? { decisions: Object.fromEntries(decisions) } : {}),
+  });
+}
+
+/**
+ * If \`request\` is a /__void/scheduled or /__void/queue trigger, validate auth,
+ * dispatch, and return a \`Response\`. Otherwise return null so the caller can
+ * forward to the framework's normal request handling.
+ */
+export async function handleDevTrigger(request, env, ctx) {
+  if (request.method !== "POST") return null;
+  const url = new URL(request.url);
+  if (url.pathname !== "/__void/scheduled" && url.pathname !== "/__void/queue") {
+    return null;
+  }
+  if (!__authorize(request, env)) {
+    return __json({ error: "unauthorized" }, 401);
+  }
+  if (url.pathname === "/__void/scheduled") {
+    return __dispatchScheduled(request, env, ctx);
+  }
+  return __dispatchQueue(request, env);
+}
+`;
+}
+const NITRO_MIDDLEWARE_FILENAME = "__void-dev-trigger.ts";
+function nitroMiddlewareSource(dispatchPath) {
+	return `// @ts-nocheck — Auto-generated by Void in dev. Do NOT edit. Removed when the dev server stops.
+import { handleDevTrigger } from ${JSON.stringify(dispatchPath)};
+
+export default async function voidDevTrigger(event) {
+  const req = event.node.req;
+  if (req.method !== 'POST') return;
+  const path = req.url || '';
+  if (!path.startsWith('/__void/scheduled') && !path.startsWith('/__void/queue')) return;
+
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  const body = Buffer.concat(chunks).toString('utf8');
+
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (typeof v === 'string') headers.set(k, v);
+    else if (Array.isArray(v)) headers.set(k, v.join(', '));
+  }
+  const webReq = new Request(\`http://localhost\${path}\`, { method: 'POST', headers, body });
+
+  const cloudflare = event.context?.cloudflare;
+  const response = await handleDevTrigger(webReq, cloudflare?.env ?? {}, cloudflare?.context);
+  if (!response) return;
+
+  const res = event.node.res;
+  res.statusCode = response.status;
+  for (const [k, v] of response.headers) res.setHeader(k, v);
+  res.end(await response.text());
+  return true;
+}
+`;
+}
+/**
+* Writes a tiny Nitro server middleware to the user's project so
+* \`/__void/scheduled\` and \`/__void/queue\` are intercepted inside Nitro's
+* request pipeline (where \`event.context.cloudflare?.env\` is populated).
+*
+* Nitro discovers middleware from \`<serverDir>/middleware/*.ts\`. Nuxt scans
+* \`server/\`, Analog scans \`src/server/\`, so the caller specifies which.
+* To keep the generated file out of git we append a \`.gitignore\` entry,
+* and the file is removed when the dev server stops.
+*/
+function nitroDevTriggerInjectPlugin(root, options) {
+	const middlewareRelative = `${options.serverDir}/middleware/${NITRO_MIDDLEWARE_FILENAME}`;
+	const middlewarePath = join(root, middlewareRelative);
+	const gitignoreLine = middlewareRelative;
+	const dispatchPath = frameworkTriggersDispatchPath(root);
+	const ensureFile = () => {
+		mkdirSync(dirname(middlewarePath), { recursive: true });
+		writeFileSync(middlewarePath, nitroMiddlewareSource(dispatchPath));
+	};
+	const ensureGitignore = () => {
+		const gitignorePath = join(root, ".gitignore");
+		let contents = "";
+		if (existsSync(gitignorePath)) {
+			contents = readFileSync(gitignorePath, "utf-8");
+			if (contents.split("\n").some((line) => line.trim() === gitignoreLine)) return;
+		}
+		const sep = contents.length === 0 || contents.endsWith("\n") ? "" : "\n";
+		writeFileSync(gitignorePath, `${contents}${sep}${gitignoreLine}\n`);
+	};
+	const cleanup = () => {
+		rmSync(middlewarePath, { force: true });
+	};
+	return {
+		name: "void:nitro-dev-trigger-inject",
+		apply: "serve",
+		configureServer(server) {
+			ensureFile();
+			ensureGitignore();
+			server.httpServer?.once("close", cleanup);
+			const onExit = () => cleanup();
+			process.once("exit", onExit);
+		}
+	};
+}
+const ANALOG_ROUTE_DIR_RELATIVE = "src/server/routes/api/__void";
+const ANALOG_TRIGGERS = [{
+	user: "scheduled",
+	file: "cron-trigger"
+}, {
+	user: "queue",
+	file: "queue-trigger"
+}];
+function analogRouteSource(dispatchPath, userTrigger) {
+	return `// @ts-nocheck — Auto-generated by Void in dev. Do NOT edit. Removed when the dev server stops.
+import { defineEventHandler } from 'h3';
+import { handleDevTrigger } from ${JSON.stringify(dispatchPath)};
+
+export default defineEventHandler(async (event) => {
+  const req = event.node.req;
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  const body = Buffer.concat(chunks).toString('utf8');
+
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (typeof v === 'string') headers.set(k, v);
+    else if (Array.isArray(v)) headers.set(k, v.join(', '));
+  }
+  const webReq = new Request('http://localhost/__void/${userTrigger}', {
+    method: 'POST',
+    headers,
+    body,
+  });
+
+  const cloudflare = event.context?.cloudflare;
+  const response = await handleDevTrigger(webReq, cloudflare?.env ?? {}, cloudflare?.context);
+  if (!response) return;
+
+  const res = event.node.res;
+  res.statusCode = response.status;
+  for (const [k, v] of response.headers) res.setHeader(k, v);
+  res.end(await response.text());
+  return true;
+});
+`;
+}
+/**
+* Analog-specific injection. Analog's @analogjs/vite-plugin-nitro registers
+* user "server middleware" on Vite's connect pipeline (deliberately, to keep
+* some routes out of Nitro), so Nitro plugins like nitro-cloudflare-dev never
+* run for it and `event.context.cloudflare` is empty there.
+*
+* Workaround: put the actual handler at \`src/server/routes/api/__void/[trigger].ts\`
+* — Nitro \*does\* run plugins for routes — and proxy \`/__void/{scheduled,queue}\`
+* to \`/api/__void/{scheduled,queue}\` from a small Vite middleware so the
+* user-facing URL stays consistent with the other frameworks.
+*/
+function analogDevTriggerInjectPlugin(root) {
+	const routeDir = join(root, ANALOG_ROUTE_DIR_RELATIVE);
+	const routePaths = ANALOG_TRIGGERS.map((t) => ({
+		...t,
+		path: join(routeDir, `${t.file}.ts`)
+	}));
+	const gitignoreLines = ANALOG_TRIGGERS.map((t) => `${ANALOG_ROUTE_DIR_RELATIVE}/${t.file}.ts`);
+	const dispatchPath = frameworkTriggersDispatchPath(root);
+	const ensureFiles = () => {
+		mkdirSync(routeDir, { recursive: true });
+		for (const { user, path } of routePaths) writeFileSync(path, analogRouteSource(dispatchPath, user));
+	};
+	const ensureGitignore = () => {
+		const gitignorePath = join(root, ".gitignore");
+		let contents = "";
+		if (existsSync(gitignorePath)) contents = readFileSync(gitignorePath, "utf-8");
+		const existing = new Set(contents.split("\n").map((l) => l.trim()));
+		const missing = gitignoreLines.filter((l) => !existing.has(l));
+		if (missing.length === 0) return;
+		const sep = contents.length === 0 || contents.endsWith("\n") ? "" : "\n";
+		writeFileSync(gitignorePath, `${contents}${sep}${missing.join("\n")}\n`);
+	};
+	const cleanup = () => {
+		for (const { path } of routePaths) rmSync(path, { force: true });
+	};
+	return {
+		name: "void:analog-dev-trigger-inject",
+		apply: "serve",
+		configureServer(server) {
+			ensureFiles();
+			ensureGitignore();
+			const proxy = async (req, res, next) => {
+				if (req.method !== "POST") {
+					next();
+					return;
+				}
+				const path = req.url ?? "";
+				const match = ANALOG_TRIGGERS.find((t) => path === `/__void/${t.user}`);
+				if (!match) {
+					next();
+					return;
+				}
+				try {
+					const chunks = [];
+					for await (const chunk of req) chunks.push(chunk);
+					const body = Buffer.concat(chunks);
+					const headers = new Headers();
+					for (const [k, v] of Object.entries(req.headers)) if (typeof v === "string") headers.set(k, v);
+					else if (Array.isArray(v)) headers.set(k, v.join(", "));
+					const host = req.headers.host ?? "localhost";
+					const upstream = await fetch(`http://${host}/api/__void/${match.file}`, {
+						method: "POST",
+						headers,
+						body
+					});
+					res.statusCode = upstream.status;
+					upstream.headers.forEach((v, k) => res.setHeader(k, v));
+					res.end(Buffer.from(await upstream.arrayBuffer()));
+				} catch (err) {
+					next(err);
+				}
+			};
+			server.middlewares.use(proxy);
+			server.httpServer?.once("close", cleanup);
+			const onExit = () => cleanup();
+			process.once("exit", onExit);
+		}
+	};
+}
+const ASTRO_MIDDLEWARE_RELATIVE = "src/middleware.ts";
+function astroMiddlewareSource(dispatchPath) {
+	return `// @ts-nocheck — Auto-generated by Void in dev. Do NOT edit. Removed when the dev server stops.
+import { defineMiddleware } from 'astro:middleware';
+import { env } from 'cloudflare:workers';
+import { handleDevTrigger } from ${JSON.stringify(dispatchPath)};
+
+export const onRequest = defineMiddleware(async (context, next) => {
+  if (context.request.method !== 'POST') return next();
+  const { pathname } = context.url;
+  if (pathname !== '/__void/scheduled' && pathname !== '/__void/queue') return next();
+
+  const response = await handleDevTrigger(context.request, env, context.locals.cfContext);
+  return response ?? next();
+});
+`;
+}
+const ASTRO_GITIGNORE_LINE = "src/middleware.ts";
+/**
+* Writes a tiny Astro middleware to the user's project so
+* \`/__void/scheduled\` and \`/__void/queue\` are intercepted inside Astro's
+* request pipeline (where \`context.locals.runtime.env\` is populated by
+* \`@astrojs/cloudflare\`).
+*
+* Astro middleware lives at a single discoverable entry, so if the user
+* already has \`src/middleware.ts\` we don't overwrite it — instead we log a
+* one-shot snippet they can paste into their existing middleware.
+*
+* If we wrote the file we remove it on dev-server close so the user's
+* source tree stays clean.
+*/
+function astroDevTriggerInjectPlugin(root) {
+	const middlewarePath = join(root, ASTRO_MIDDLEWARE_RELATIVE);
+	const middlewareDirIndexPath = join(root, "src", "middleware", "index.ts");
+	let wroteFile = false;
+	const ensureFile = () => {
+		if (existsSync(middlewarePath) || existsSync(middlewareDirIndexPath)) {
+			voidWarn("Astro middleware already exists. To enable /__void/scheduled and /__void/queue,\n         add the Void dev-trigger middleware to your existing onRequest sequence.\n         See https://void.cloud/guide/jobs#local-development.");
+			return;
+		}
+		mkdirSync(dirname(middlewarePath), { recursive: true });
+		writeFileSync(middlewarePath, astroMiddlewareSource(frameworkTriggersDispatchPath(root)));
+		wroteFile = true;
+	};
+	const ensureGitignore = () => {
+		if (!wroteFile) return;
+		const gitignorePath = join(root, ".gitignore");
+		let contents = "";
+		if (existsSync(gitignorePath)) {
+			contents = readFileSync(gitignorePath, "utf-8");
+			if (contents.split("\n").some((line) => line.trim() === ASTRO_GITIGNORE_LINE)) return;
+		}
+		const sep = contents.length === 0 || contents.endsWith("\n") ? "" : "\n";
+		writeFileSync(gitignorePath, `${contents}${sep}${ASTRO_GITIGNORE_LINE}\n`);
+	};
+	const cleanup = () => {
+		if (wroteFile) rmSync(middlewarePath, { force: true });
+	};
+	return {
+		name: "void:astro-dev-trigger-inject",
+		apply: "serve",
+		configureServer(server) {
+			ensureFile();
+			ensureGitignore();
+			server.httpServer?.once("close", cleanup);
+			const onExit = () => cleanup();
+			process.once("exit", onExit);
+		}
+	};
+}
+//#endregion
+//#region src/plugin-migration.ts
+function readDatabaseUrl(root) {
+	const envPath = join(root, ".env.local");
+	if (!existsSync(envPath)) return;
+	const content = readFileSync(envPath, "utf-8");
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) continue;
+		if (trimmed.slice(0, eqIndex).trim() !== "DATABASE_URL") continue;
+		let value = trimmed.slice(eqIndex + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		return value;
+	}
+}
+/**
+* Vite plugin that runs local migrations on dev server startup.
+* For SQLite/D1: applies migrations to the local miniflare database.
+* For PostgreSQL: connects via DATABASE_URL from .env.local.
+*/
+function migrationPlugin(root, dialect, databaseId = "local", persistRoot = join(root, ".void"), auth) {
+	return {
+		name: "void:migrations",
+		apply: "serve",
+		async configureServer(server) {
+			const migrationsDir = join(root, "db", "migrations");
+			const hasSqlMigrations = existsSync(migrationsDir);
+			if (!hasSqlMigrations && !auth?.enabled) return;
+			try {
+				if (hasSqlMigrations && dialect === "postgresql") {
+					const url = readDatabaseUrl(root);
+					if (!url) {
+						const warn = () => {
+							console.log();
+							voidError("DATABASE_URL not found in .env.local — skipping PostgreSQL migrations.");
+						};
+						if (server.httpServer) server.httpServer.once("listening", () => setTimeout(warn, 100));
+						else warn();
+						return;
+					}
+					const { runPgMigrations, getPgAppliedMigrations } = await import("./runner-pg-D0wWHYnr.mjs");
+					const { collectMigrations } = await import("./collect-CjeZgz5D.mjs").then((n) => n.n);
+					const { validateMigrations } = await import("./validate-CaMavMxu.mjs").then((n) => n.i);
+					const allMigrations = collectMigrations(migrationsDir);
+					const pgApplied = await getPgAppliedMigrations(url);
+					const pgAppliedSet = new Set(pgApplied);
+					const pgPending = allMigrations.filter((m) => !pgAppliedSet.has(m.name));
+					if (pgPending.length > 0) try {
+						validateMigrations(pgPending);
+					} catch (err) {
+						voidWarn(err instanceof Error ? err.message : String(err));
+					}
+					const applied = await runPgMigrations(migrationsDir, url);
+					if (applied.length > 0) voidLog(`Applied ${applied.length} migration(s): ${applied.join(", ")}`);
+				} else if (hasSqlMigrations) {
+					const { runMigrations, getMiniflareDatabasePath, getAppliedMigrations } = await import("./runner-6Ep3fNQu.mjs");
+					const { collectMigrations } = await import("./collect-CjeZgz5D.mjs").then((n) => n.n);
+					const { validateMigrations } = await import("./validate-CaMavMxu.mjs").then((n) => n.i);
+					const dbPath = getMiniflareDatabasePath(persistRoot, databaseId);
+					const allMigrations = collectMigrations(migrationsDir);
+					const appliedRows = await getAppliedMigrations(dbPath);
+					const appliedSet = new Set(appliedRows.map((r) => r.name));
+					const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+					if (pending.length > 0) try {
+						validateMigrations(pending);
+					} catch (err) {
+						voidWarn(err instanceof Error ? err.message : String(err));
+					}
+					const applied = await runMigrations(migrationsDir, dbPath);
+					if (applied.length > 0) voidLog(`Applied ${applied.length} migration(s): ${applied.join(", ")}`);
+				}
+				if (auth?.enabled) {
+					const { runLocalVoidAuthMigrations } = await import("./node-DDfXj10V.mjs");
+					await runLocalVoidAuthMigrations(root, dialect, persistRoot, databaseId, auth.configPath);
+					voidLog("Applied Better Auth migrations");
+				}
+			} catch (err) {
+				voidError(`Migration error: ${err}`);
+			}
+		}
+	};
+}
+const CF_ONLY_REGEX = new RegExp(`^(${[
+	"void/db",
+	"void/kv",
+	"void/auth",
+	"void/storage",
+	"void/ai",
+	"void/sandbox",
+	"void/env"
+].map((s) => s.replace("/", "\\/")).join("|")})$`);
+/**
+* Bridge Node.js HTTP to Web API and serve via a Hono app.
+* Used by both dev server and preview server middleware.
+*/
+function honoMiddleware(getApp) {
+	return async (req, res, next) => {
+		try {
+			if (!req.url || req.url.startsWith("/@") || req.url.startsWith("/__") || req.url.startsWith("/node_modules/")) {
+				next();
+				return;
+			}
+			const app = await getApp();
+			if (!app?.fetch) {
+				next();
+				return;
+			}
+			const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
+			const headers = new Headers();
+			for (const [key, value] of Object.entries(req.headers)) if (value) headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+			const hasBody = req.method !== "GET" && req.method !== "HEAD";
+			const request = new Request(url.toString(), {
+				method: req.method,
+				headers,
+				body: hasBody ? req : void 0,
+				duplex: hasBody ? "half" : void 0
+			});
+			const response = await app.fetch(request);
+			if (response.status === 404) {
+				next();
+				return;
+			}
+			res.statusCode = response.status;
+			response.headers.forEach((value, key) => {
+				res.setHeader(key, value);
+			});
+			if (response.body) {
+				const reader = response.body.getReader();
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					res.write(value);
+				}
+				res.end();
+			} else res.end();
+		} catch (err) {
+			next(err);
+		}
+	};
+}
+/**
+* Vite plugin for non-Cloudflare deploy targets (Node.js, Bun, Deno).
+*
+* Replaces `@cloudflare/vite-plugin` in the plugin composition. Provides:
+* 1. Binding guard — compile-time errors for CF-only void/* imports
+* 2. Dev server — Vite SSR middleware to run Hono in Node.js
+* 3. Preview server — serves from the built SSR entry
+* 4. Build — dual-environment build (client + SSR) for pages apps,
+*    single SSR build for API-only apps
+*/
+function nodeTargetPlugin(target) {
+	return [{
+		name: "void:node-target",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: CF_ONLY_REGEX },
+			handler(id) {
+				throw new Error(`target: '${id}' is not available with target '${target}'. CF bindings require target: "cloudflare".`);
+			}
+		},
+		config(_, { command }) {
+			if (command !== "build") return;
+			const root = process.cwd();
+			const voidDir = join(root, ".void");
+			const ssrBuildOptions = {
+				outDir: "dist/ssr",
+				rollupOptions: {
+					input: {
+						app: join(voidDir, "app.ts"),
+						index: join(voidDir, "index.ts")
+					},
+					external: [
+						/^node:/,
+						"@hono/node-server",
+						"@hono/node-server/serve-static"
+					]
+				}
+			};
+			if (existsSync(join(root, "pages"))) return {
+				build: { outDir: "dist/client" },
+				environments: { ssr: { build: ssrBuildOptions } },
+				builder: {}
+			};
+			return { build: {
+				ssr: true,
+				...ssrBuildOptions
+			} };
+		},
+		async buildApp(builder) {
+			await builder.build(builder.environments.ssr);
+			await builder.build(builder.environments.client);
+		},
+		configureServer(server) {
+			server.middlewares.use(honoMiddleware(async () => {
+				return (await server.ssrLoadModule("virtual:void-routes")).default;
+			}));
+		},
+		configurePreviewServer(server) {
+			const entryPath = join(process.cwd(), "dist", "ssr", "app.js");
+			let appPromise = null;
+			server.middlewares.use(honoMiddleware(() => {
+				if (!appPromise) appPromise = import(
+					/* @vite-ignore */
+					pathToFileURL(entryPath).href
+).then((m) => m.default, () => null);
+				return appPromise;
+			}));
+		}
+	}];
+}
+//#endregion
+//#region src/plugin-prerender.ts
+/**
+* Vite plugin that prerenders pages at build time when `output: "static"`.
+*
+* Runs in the `closeBundle` hook so prerender logs appear after Vite's
+* asset summary. Gated on the "client" environment so it only runs once.
+*/
+function prerenderPlugin(root, config) {
+	return {
+		name: "void:prerender",
+		apply: "build",
+		async closeBundle() {
+			if (config.output !== "static") return;
+			if (this.environment?.name !== "client") return;
+			setShowTimestamp(false);
+			const distDir = resolveDistDir(root);
+			const clientDir = join(distDir, "client");
+			let result;
+			if (isNodeTarget(config.target)) result = await prerenderPagesNode({
+				root,
+				ssrDir: join(distDir, "ssr"),
+				clientDir
+			});
+			else {
+				const persistDir = join(root, ".void");
+				result = await prerenderPages({
+					root,
+					workerDir: join(distDir, resolveWorkerDirName(distDir)),
+					clientDir,
+					persistDir,
+					remoteMode: resolveRemoteMode(config.remote),
+					projectId: process.env.VOID_DEPLOY_PROJECT_ID || void 0
+				});
+			}
+			if (result.paths.length === 0) {
+				voidLog("No pages to prerender");
+				return;
+			}
+			if (result.failed.length > 0) voidWarn(`${result.failed.length} page(s) failed to prerender`);
+		}
+	};
+}
+//#endregion
+//#region src/plugin-restart.ts
+const BINDING_HINT_RESOLVED = "\0virtual:void/binding-hint";
+const RESTARTING_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Restarting</title>
+  <style>
+    body{margin:0;height:100vh;display:flex;align-items:center;justify-content:center;background:#1a1a2e;color:#e0def4;font:14px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace}
+    .tag{color:#c4a7e7;font-weight:700}
+    @keyframes d{0%,80%{opacity:0}40%{opacity:1}}
+    .dots span{opacity:0;animation:d 1.4s infinite}
+    .dots span:nth-child(2){animation-delay:.2s}
+    .dots span:nth-child(3){animation-delay:.4s}
+  </style>
+</head>
+<body>
+  <div><span class="tag">[void]</span> Restarting dev server<span class="dots"><span>.</span><span>.</span><span>.</span></span></div>
+  <script>
+    fetch("/__void/restart",{method:"POST"}).catch(function(){});
+    setTimeout(function p(){
+      fetch("/__void/ping").then(function(r){
+        if(r.ok)location.href=new URLSearchParams(location.search).get("return")||"/";
+        else setTimeout(p,150);
+      }).catch(function(){setTimeout(p,150)});
+    },300);
+  <\/script>
+</body>
+</html>`;
+const CLIENT_MODULE = `if (import.meta.hot) {
+  import.meta.hot.on("void:new-binding", (d) => {
+    if (document.getElementById("void-binding-hint")) return;
+    const e = document.createElement("div");
+    e.id = "void-binding-hint";
+    e.style.cssText = "position:fixed;top:16px;right:16px;z-index:99999;padding:12px 16px;background:rgba(26,26,46,0.95);color:#e0def4;font:13px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;border-radius:8px;border:1px solid rgba(255,255,255,0.08);box-shadow:0 8px 32px rgba(0,0,0,0.4);backdrop-filter:blur(8px);cursor:pointer;max-width:300px;transform:translateX(calc(100% + 16px));transition:transform .3s ease";
+    e.innerHTML = "<strong style=\\"color:#c4a7e7\\">[void]</strong> " + d.message + " Click to restart.";
+    e.onclick = () => { location.href = "/__void/restarting?return=" + encodeURIComponent(location.pathname + location.search); };
+    document.body.appendChild(e);
+    requestAnimationFrame(() => requestAnimationFrame(() => {
+      e.style.transform = "translateX(0)";
+    }));
+  });
+}`;
+/**
+* Vite plugin that provides controlled dev-server restart via the browser.
+*
+* Serves three endpoints:
+* - `/__void/restarting` — standalone loading page (no Vite HMR client)
+* - `/__void/restart`    — POST triggers `server.restart()` after a short delay
+* - `/__void/ping`       — health check; returns 503 on the old server instance
+*                          (after restart is triggered) and 200 on the new one
+*
+* Also injects a virtual module (`virtual:void/binding-hint`) that listens for
+* `void:new-binding` HMR events and shows a toast with a click-to-restart action.
+*/
+function restartPlugin() {
+	return {
+		name: "void:restart",
+		apply: "serve",
+		resolveId: {
+			filter: { id: /^virtual:void\/binding-hint$/ },
+			handler() {
+				return BINDING_HINT_RESOLVED;
+			}
+		},
+		load: {
+			filter: { id: /^\0virtual:void\/binding-hint$/ },
+			handler() {
+				return CLIENT_MODULE;
+			}
+		},
+		configureServer(server) {
+			let restartPending = false;
+			server.middlewares.use("/__void/ping", (_req, res) => {
+				res.writeHead(restartPending ? 503 : 200);
+				res.end();
+			});
+			server.middlewares.use("/__void/restart", (req, res) => {
+				if (req.method !== "POST") {
+					res.writeHead(405);
+					res.end();
+					return;
+				}
+				restartPending = true;
+				res.writeHead(200);
+				res.end();
+				setTimeout(() => server.restart(), 50);
+			});
+			server.middlewares.use("/__void/restarting", (_req, res) => {
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end(RESTARTING_HTML);
+			});
+		}
+	};
+}
+//#endregion
+//#region src/router/compile.ts
+/**
+* Script tag injected into dev HTML to load the binding-hint virtual module.
+* The virtual module (served by restartPlugin) listens for `void:new-binding`
+* HMR events and shows a toast with a click-to-restart action.
+*/
+const BINDING_HINT_SCRIPT = `<script type="module" src="/@id/virtual:void/binding-hint"><\/script>`;
+const DEFAULT_ERROR_PAGE_FONT_STACK = "system-ui, -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif";
+function pushDefaultErrorPageHelpers(lines, options) {
+	const dev = options.dev === true;
+	lines.push(`const __VOID_ERROR_PAGE_FONT_STACK = ${JSON.stringify(DEFAULT_ERROR_PAGE_FONT_STACK)};`);
+	lines.push(`const __VOID_DEV = ${JSON.stringify(dev)};`);
+	lines.push(`const __VOID_PROJECT_ROOT = ${JSON.stringify(options.projectRoot)};`);
+	lines.push(`const __VOID_HOME_DIR = ${JSON.stringify(options.homeDir)};`);
+	lines.push(`function __voidEscapeHtml(value) {`);
+	lines.push(`  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidShouldServeHtmlErrorPage(request) {`);
+	lines.push(`  if (request.method !== "GET" && request.method !== "HEAD") return false;`);
+	lines.push(`  const url = new URL(request.url);`);
+	lines.push(`  if (url.pathname === "/api" || url.pathname.startsWith("/api/")) return false;`);
+	lines.push(`  if (/\\/[^/]+\\.[^/]+$/.test(url.pathname)) return false;`);
+	lines.push(`  const destination = request.headers.get("sec-fetch-dest");`);
+	lines.push(`  if (destination && destination !== "document" && destination !== "empty") return false;`);
+	lines.push(`  const accept = request.headers.get("accept");`);
+	lines.push(`  return !accept || accept.includes("text/html") || accept.includes("*/*");`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidNormalizeFsPath(value) {`);
+	lines.push(`  return typeof value === "string" ? value.replaceAll("\\\\", "/") : "";`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidIsAbsolutePath(value) {`);
+	lines.push(`  return value.startsWith("/") || /^[A-Za-z]:\\//.test(value);`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidDisplayPath(value) {`);
+	lines.push(`  const path = __voidNormalizeFsPath(value);`);
+	lines.push(`  const homeDir = __voidNormalizeFsPath(__VOID_HOME_DIR);`);
+	lines.push(`  const projectRoot = __voidNormalizeFsPath(__VOID_PROJECT_ROOT);`);
+	lines.push(`  if (!path) return "";`);
+	lines.push(`  if (projectRoot && (path === projectRoot || path.startsWith(projectRoot + "/"))) {`);
+	lines.push(`    const suffix = path.slice(projectRoot.length).replace(/^\\/?/, "");`);
+	lines.push(`    return suffix ? "./" + suffix : "./";`);
+	lines.push(`  }`);
+	lines.push(`  if (homeDir && (path === homeDir || path.startsWith(homeDir + "/"))) {`);
+	lines.push(`    const suffix = path.slice(homeDir.length).replace(/^\\/?/, "");`);
+	lines.push(`    return suffix ? "~/" + suffix : "~/";`);
+	lines.push(`  }`);
+	lines.push(`  return path;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidEditorHref(value, line, column) {`);
+	lines.push(`  const path = __voidNormalizeFsPath(value);`);
+	lines.push(`  if (!__voidIsAbsolutePath(path)) return "";`);
+	lines.push(`  return "vscode://file/" + encodeURI(path).replaceAll("#", "%23").replaceAll("?", "%3F") + ":" + String(line) + ":" + String(column);`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidCreateStackFrame(functionName, file, line, column, raw) {`);
+	lines.push(`  const normalizedFile = __voidNormalizeFsPath(file);`);
+	lines.push(`  const lineNumber = Number(line);`);
+	lines.push(`  const columnNumber = Number(column);`);
+	lines.push(`  if (!normalizedFile || !Number.isFinite(lineNumber) || lineNumber <= 0) return null;`);
+	lines.push(`  const safeColumn = Number.isFinite(columnNumber) && columnNumber > 0 ? columnNumber : 1;`);
+	lines.push(`  return {`);
+	lines.push(`    functionName: functionName || "",`);
+	lines.push(`    file: normalizedFile,`);
+	lines.push(`    line: lineNumber,`);
+	lines.push(`    column: safeColumn,`);
+	lines.push(`    displayPath: __voidDisplayPath(normalizedFile),`);
+	lines.push(`    href: __voidEditorHref(normalizedFile, lineNumber, safeColumn),`);
+	lines.push(`    raw: raw || "",`);
+	lines.push(`  };`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidParseFrameLocation(value) {`);
+	lines.push(`  const match = value.match(/^(.*):(\\d+):(\\d+)$/);`);
+	lines.push(`  if (!match) return null;`);
+	lines.push(`  return __voidCreateStackFrame("", match[1], Number(match[2]), Number(match[3]), value);`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidParseStackFrames(stack) {`);
+	lines.push(`  if (!stack) return [];`);
+	lines.push(`  const frames = [];`);
+	lines.push(`  for (const rawLine of stack.split(/\\n+/)) {`);
+	lines.push(`    const line = rawLine.trim();`);
+	lines.push(`    if (!line) continue;`);
+	lines.push(`    let frame = null;`);
+	lines.push(`    let match = line.match(/^at\\s+(?:async\\s+)?(.+?)\\s+\\((.+)\\)$/);`);
+	lines.push(`    if (match) {`);
+	lines.push(`      const location = __voidParseFrameLocation(match[2]);`);
+	lines.push(`      frame = location ? { ...location, functionName: match[1] } : null;`);
+	lines.push(`    } else {`);
+	lines.push(`      match = line.match(/^at\\s+(.+)$/);`);
+	lines.push(`      if (match) {`);
+	lines.push(`        frame = __voidParseFrameLocation(match[1]);`);
+	lines.push(`      } else {`);
+	lines.push(`        match = line.match(/^(.*?)@(.+)$/);`);
+	lines.push(`        if (match) {`);
+	lines.push(`          const location = __voidParseFrameLocation(match[2]);`);
+	lines.push(`          frame = location ? { ...location, functionName: match[1] } : null;`);
+	lines.push(`        }`);
+	lines.push(`      }`);
+	lines.push(`    }`);
+	lines.push(`    if (frame) frames.push({ ...frame, raw: line });`);
+	lines.push(`  }`);
+	lines.push(`  return frames;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidGetStackFrames(error) {`);
+	lines.push(`  if (!(error instanceof Error)) return [];`);
+	lines.push(`  if (!error.stack && typeof Error.captureStackTrace === "function") {`);
+	lines.push(`    try {`);
+	lines.push(`      Error.captureStackTrace(error, __voidGetStackFrames);`);
+	lines.push(`    } catch {`);
+	lines.push(`      // Ignore runtimes that reject captureStackTrace on thrown errors.`);
+	lines.push(`    }`);
+	lines.push(`  }`);
+	lines.push(`  const originalPrepareStackTrace = Error.prepareStackTrace;`);
+	lines.push(`  try {`);
+	lines.push(`    Error.prepareStackTrace = (_, callSites) => callSites;`);
+	lines.push(`    const structured = error.stack;`);
+	lines.push(`    if (Array.isArray(structured)) {`);
+	lines.push(`      const frames = [];`);
+	lines.push(`      for (const callSite of structured) {`);
+	lines.push(`        try {`);
+	lines.push(`          const fileName = callSite.getFileName?.() || callSite.getScriptNameOrSourceURL?.();`);
+	lines.push(`          const line = callSite.getLineNumber?.();`);
+	lines.push(`          const column = callSite.getColumnNumber?.();`);
+	lines.push(`          const functionName = callSite.getFunctionName?.() || callSite.getMethodName?.() || "";`);
+	lines.push(`          const frame = __voidCreateStackFrame(functionName, fileName || "", line, column, String(callSite));`);
+	lines.push(`          if (frame) frames.push(frame);`);
+	lines.push(`        } catch {`);
+	lines.push(`          // Ignore malformed CallSite entries and continue rendering.`);
+	lines.push(`        }`);
+	lines.push(`      }`);
+	lines.push(`      if (frames.length > 0) return frames;`);
+	lines.push(`    }`);
+	lines.push(`  } catch {`);
+	lines.push(`    // Fall through to string parsing.`);
+	lines.push(`  } finally {`);
+	lines.push(`    Error.prepareStackTrace = originalPrepareStackTrace;`);
+	lines.push(`  }`);
+	lines.push(`  return __voidParseStackFrames(typeof error.stack === "string" ? error.stack : "");`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidDescribeThrownValue(value) {`);
+	lines.push(`  if (value instanceof Error) {`);
+	lines.push(`    return {`);
+	lines.push(`      name: value.name || "Error",`);
+	lines.push(`      message: value.message || "",`);
+	lines.push(`      stack: typeof value.stack === "string" ? value.stack : "",`);
+	lines.push(`      frames: __voidGetStackFrames(value),`);
+	lines.push(`    };`);
+	lines.push(`  }`);
+	lines.push(`  if (typeof value === "string") {`);
+	lines.push(`    return { name: "Thrown value", message: value, stack: "", frames: [] };`);
+	lines.push(`  }`);
+	lines.push(`  let message = "";`);
+	lines.push(`  try {`);
+	lines.push(`    if (typeof value === "object" && value !== null) {`);
+	lines.push(`      message = JSON.stringify(value, null, 2) ?? String(value);`);
+	lines.push(`    } else {`);
+	lines.push(`      message = String(value);`);
+	lines.push(`    }`);
+	lines.push(`  } catch {`);
+	lines.push(`    message = String(value);`);
+	lines.push(`  }`);
+	lines.push(`  return { name: "Thrown value", message, stack: "", frames: [] };`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidRenderStack(entry) {`);
+	lines.push(`  if (Array.isArray(entry.frames) && entry.frames.length > 0) {`);
+	lines.push(`    const items = entry.frames.map((frame) => {`);
+	lines.push(`      const name = frame.functionName || "(anonymous)";`);
+	lines.push(`      const location = frame.displayPath + ":" + frame.line + ":" + frame.column;`);
+	lines.push(`      const body = \`<span class="__void-error-frame-function">\${__voidEscapeHtml(name)}</span><span class="__void-error-frame-location">\${__voidEscapeHtml(location)}</span>\`;`);
+	lines.push(`      if (frame.href) {`);
+	lines.push(`        return \`<a class="__void-error-frame" href="\${__voidEscapeHtml(frame.href)}">\${body}</a>\`;`);
+	lines.push(`      }`);
+	lines.push(`      return \`<div class="__void-error-frame is-static">\${body}</div>\`;`);
+	lines.push(`    }).join("");`);
+	lines.push(`    return \`<div class="__void-error-stack"><div class="__void-error-stack-label">Stack trace</div><div class="__void-error-frames">\${items}</div></div>\`;`);
+	lines.push(`  }`);
+	lines.push(`  if (!entry.stack) return "";`);
+	lines.push(`  return \`<div class="__void-error-stack"><div class="__void-error-stack-label">Stack trace</div><pre>\${__voidEscapeHtml(entry.stack)}</pre></div>\`;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidCollectErrorChain(error) {`);
+	lines.push(`  const chain = [];`);
+	lines.push(`  const seen = new Set();`);
+	lines.push(`  let current = error;`);
+	lines.push(`  let depth = 0;`);
+	lines.push(`  while (current != null && depth < 8 && !seen.has(current)) {`);
+	lines.push(`    seen.add(current);`);
+	lines.push(`    const entry = __voidDescribeThrownValue(current);`);
+	lines.push(`    chain.push({`);
+	lines.push(`      label: depth === 0 ? "Error" : "Cause " + depth,`);
+	lines.push(`      ...entry,`);
+	lines.push(`    });`);
+	lines.push(`    current = current instanceof Error ? current.cause : undefined;`);
+	lines.push(`    depth += 1;`);
+	lines.push(`  }`);
+	lines.push(`  if (current != null) {`);
+	lines.push(`    chain.push({`);
+	lines.push(`      label: "Cause " + depth,`);
+	lines.push(`      name: "Truncated",`);
+	lines.push(`      message: "Additional nested causes were omitted.",`);
+	lines.push(`      stack: "",`);
+	lines.push(`      frames: [],`);
+	lines.push(`    });`);
+	lines.push(`  }`);
+	lines.push(`  if (chain.length === 0) {`);
+	lines.push(`    chain.push({`);
+	lines.push(`      label: "Error",`);
+	lines.push(`      name: "Unknown error",`);
+	lines.push(`      message: "No error details were available.",`);
+	lines.push(`      stack: "",`);
+	lines.push(`      frames: [],`);
+	lines.push(`    });`);
+	lines.push(`  }`);
+	lines.push(`  return chain;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidRenderDevErrorOverlay(request, status, title, error) {`);
+	lines.push(`  const chain = __voidCollectErrorChain(error);`);
+	lines.push(`  const errorCountLabel = chain.length + (chain.length === 1 ? " Error" : " Errors");`);
+	lines.push(`  const sections = chain.map((entry, index) => {`);
+	lines.push(`    const heading = entry.name || (index === 0 ? title : "Cause");`);
+	lines.push(`    const message = entry.message || title;`);
+	lines.push(`    const stack = __voidRenderStack(entry);`);
+	lines.push(`    if (index === 0) {`);
+	lines.push(`      return \`<section class="__void-error-section is-root"><p class="__void-error-message">\${__voidEscapeHtml(message)}</p>\${stack}</section>\`;`);
+	lines.push(`    }`);
+	lines.push(`    return \`<section class="__void-error-section"><div class="__void-error-kicker">\${__voidEscapeHtml(entry.label)}</div><h2>\${__voidEscapeHtml(heading)}</h2><p>\${__voidEscapeHtml(message)}</p>\${stack}</section>\`;`);
+	lines.push(`  }).join("");`);
+	lines.push(`  return \`<style>`);
+	lines.push(`    .__void-error-overlay {`);
+	lines.push(`      position: fixed;`);
+	lines.push(`      inset: 0;`);
+	lines.push(`      z-index: 2147483647;`);
+	lines.push(`      pointer-events: none;`);
+	lines.push(`      font-family: \${__VOID_ERROR_PAGE_FONT_STACK};`);
+	lines.push(`      color: #f5f5f5;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-backdrop {`);
+	lines.push(`      position: absolute;`);
+	lines.push(`      inset: 0;`);
+	lines.push(`      background: rgba(10, 10, 10, 0.52);`);
+	lines.push(`      backdrop-filter: blur(4px);`);
+	lines.push(`      transition: opacity 180ms ease;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-panel {`);
+	lines.push(`      position: absolute;`);
+	lines.push(`      inset: auto auto 24px 24px;`);
+	lines.push(`      inline-size: min(760px, calc(100vw - 48px));`);
+	lines.push(`      max-block-size: min(80dvh, 920px);`);
+	lines.push(`      overflow: auto;`);
+	lines.push(`      pointer-events: auto;`);
+	lines.push(`      border-radius: 32px;`);
+	lines.push(`      corner-shape: squircle;`);
+	lines.push(`      border: 1px solid rgba(255, 255, 255, 0.14);`);
+	lines.push(`      background: linear-gradient(180deg, rgba(24, 24, 27, 0.98), rgba(9, 9, 11, 0.98));`);
+	lines.push(`      box-shadow: 0 24px 80px rgba(0, 0, 0, 0.45);`);
+	lines.push(`      padding: 12px 16px;`);
+	lines.push(`      transition: transform 180ms ease, opacity 180ms ease;`);
+	lines.push(`      transform-origin: bottom left;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-close {`);
+	lines.push(`      position: absolute;`);
+	lines.push(`      inset: 12px 12px auto auto;`);
+	lines.push(`      inline-size: 36px;`);
+	lines.push(`      block-size: 36px;`);
+	lines.push(`      border: 0;`);
+	lines.push(`      border-radius: 999px;`);
+	lines.push(`      background: rgba(255, 255, 255, 0.08);`);
+	lines.push(`      color: #fafafa;`);
+	lines.push(`      cursor: pointer;`);
+	lines.push(`      display: grid;`);
+	lines.push(`      place-items: center;`);
+	lines.push(`      padding: 0;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-close:hover {`);
+	lines.push(`      background: rgba(255, 255, 255, 0.14);`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-close svg {`);
+	lines.push(`      inline-size: 16px;`);
+	lines.push(`      block-size: 16px;`);
+	lines.push(`      display: block;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-minimized {`);
+	lines.push(`      position: absolute;`);
+	lines.push(`      inset: auto auto 24px 24px;`);
+	lines.push(`      pointer-events: none;`);
+	lines.push(`      opacity: 0;`);
+	lines.push(`      transform: scale(0.92);`);
+	lines.push(`      transform-origin: bottom left;`);
+	lines.push(`      border: 1px solid rgba(248, 113, 113, 0.35);`);
+	lines.push(`      border-radius: 32px;`);
+	lines.push(`      corner-shape: squircle;`);
+	lines.push(`      background: rgba(24, 24, 27, 0.96);`);
+	lines.push(`      color: #fca5a5;`);
+	lines.push(`      padding: 12px 8px;`);
+	lines.push(`      box-shadow: 0 18px 36px rgba(0, 0, 0, 0.28);`);
+	lines.push(`      cursor: pointer;`);
+	lines.push(`      font: 700 13px/1 \${__VOID_ERROR_PAGE_FONT_STACK};`);
+	lines.push(`      letter-spacing: 0.04em;`);
+	lines.push(`      text-transform: uppercase;`);
+	lines.push(`      transition: transform 180ms ease, opacity 180ms ease;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-header {`);
+	lines.push(`      display: flex;`);
+	lines.push(`      flex-direction: column;`);
+	lines.push(`      gap: 6px;`);
+	lines.push(`      margin-block-end: 0;`);
+	lines.push(`      padding-right: 52px;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-status {`);
+	lines.push(`      margin: 0;`);
+	lines.push(`      color: #fca5a5;`);
+	lines.push(`      font-size: 12px;`);
+	lines.push(`      font-weight: 700;`);
+	lines.push(`      letter-spacing: 0.12em;`);
+	lines.push(`      text-transform: uppercase;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-section {`);
+	lines.push(`      border-top: 1px solid rgba(255, 255, 255, 0.08);`);
+	lines.push(`      padding-top: 16px;`);
+	lines.push(`      margin-top: 16px;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-section.is-root {`);
+	lines.push(`      border-top: 0;`);
+	lines.push(`      padding-top: 0;`);
+	lines.push(`      margin-top: 0;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-message {`);
+	lines.push(`      margin: 0;`);
+	lines.push(`      color: #fff;`);
+	lines.push(`      font-size: 1.7rem;`);
+	lines.push(`      line-height: 1.15;`);
+	lines.push(`      letter-spacing: -0.03em;`);
+	lines.push(`      white-space: pre-wrap;`);
+	lines.push(`      word-break: break-word;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-kicker {`);
+	lines.push(`      margin-bottom: 6px;`);
+	lines.push(`      color: #fda4af;`);
+	lines.push(`      font-size: 12px;`);
+	lines.push(`      font-weight: 700;`);
+	lines.push(`      letter-spacing: 0.08em;`);
+	lines.push(`      text-transform: uppercase;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-section h2 {`);
+	lines.push(`      margin: 0 0 8px;`);
+	lines.push(`      font-size: 1.05rem;`);
+	lines.push(`      color: #fff;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-section p {`);
+	lines.push(`      margin: 0;`);
+	lines.push(`      color: #e4e4e7;`);
+	lines.push(`      white-space: pre-wrap;`);
+	lines.push(`      word-break: break-word;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-stack {`);
+	lines.push(`      margin-top: 18px;`);
+	lines.push(`      border: 1px solid rgba(255, 255, 255, 0.08);`);
+	lines.push(`      border-radius: 32px;`);
+	lines.push(`      background: rgba(255, 255, 255, 0.03);`);
+	lines.push(`      corner-shape: squircle;`);
+	lines.push(`      overflow: hidden;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-stack-label {`);
+	lines.push(`      padding: 12px 14px 10px;`);
+	lines.push(`      color: #f4f4f5;`);
+	lines.push(`      font-size: 12px;`);
+	lines.push(`      font-weight: 700;`);
+	lines.push(`      letter-spacing: 0.08em;`);
+	lines.push(`      text-transform: uppercase;`);
+	lines.push(`      border-bottom: 1px solid rgba(255, 255, 255, 0.08);`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-frames {`);
+	lines.push(`      display: flex;`);
+	lines.push(`      flex-direction: column;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-frame {`);
+	lines.push(`      display: flex;`);
+	lines.push(`      align-items: baseline;`);
+	lines.push(`      justify-content: space-between;`);
+	lines.push(`      gap: 16px;`);
+	lines.push(`      padding: 12px 14px;`);
+	lines.push(`      color: inherit;`);
+	lines.push(`      text-decoration: none;`);
+	lines.push(`      border-top: 1px solid rgba(255, 255, 255, 0.06);`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-frame:first-child {`);
+	lines.push(`      border-top: 0;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-frame:hover {`);
+	lines.push(`      background: rgba(255, 255, 255, 0.05);`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-frame.is-static {`);
+	lines.push(`      cursor: default;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-frame-function {`);
+	lines.push(`      flex: 1 1 auto;`);
+	lines.push(`      min-width: 0;`);
+	lines.push(`      color: #fafafa;`);
+	lines.push(`      font: 600 12px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;`);
+	lines.push(`      white-space: nowrap;`);
+	lines.push(`      overflow: hidden;`);
+	lines.push(`      text-overflow: ellipsis;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-frame-location {`);
+	lines.push(`      flex: 0 1 52%;`);
+	lines.push(`      min-width: 0;`);
+	lines.push(`      color: #fda4af;`);
+	lines.push(`      font: 500 12px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;`);
+	lines.push(`      text-align: right;`);
+	lines.push(`      white-space: nowrap;`);
+	lines.push(`      overflow: hidden;`);
+	lines.push(`      text-overflow: ellipsis;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-section pre {`);
+	lines.push(`      margin: 0;`);
+	lines.push(`      padding: 12px 14px;`);
+	lines.push(`      overflow: auto;`);
+	lines.push(`      color: #e4e4e7;`);
+	lines.push(`      font: 500 12px/1.6 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;`);
+	lines.push(`      white-space: pre-wrap;`);
+	lines.push(`      word-break: break-word;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-overlay.is-minimized .__void-error-backdrop {`);
+	lines.push(`      opacity: 0;`);
+	lines.push(`      pointer-events: none;`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-overlay.is-minimized .__void-error-panel {`);
+	lines.push(`      opacity: 0;`);
+	lines.push(`      pointer-events: none;`);
+	lines.push(`      transform: scale(0.92);`);
+	lines.push(`    }`);
+	lines.push(`    .__void-error-overlay.is-minimized .__void-error-minimized {`);
+	lines.push(`      opacity: 1;`);
+	lines.push(`      pointer-events: auto;`);
+	lines.push(`      transform: scale(1);`);
+	lines.push(`    }`);
+	lines.push(`    @media (max-width: 720px) {`);
+	lines.push(`      .__void-error-panel {`);
+	lines.push(`        inset: auto 12px 12px 12px;`);
+	lines.push(`        inline-size: auto;`);
+	lines.push(`        max-block-size: min(70dvh, 920px);`);
+	lines.push(`        padding: 16px;`);
+	lines.push(`      }`);
+	lines.push(`      .__void-error-minimized {`);
+	lines.push(`        inset: auto auto 12px 12px;`);
+	lines.push(`      }`);
+	lines.push(`      .__void-error-frame {`);
+	lines.push(`        flex-direction: column;`);
+	lines.push(`        align-items: flex-start;`);
+	lines.push(`      }`);
+	lines.push(`      .__void-error-frame-location {`);
+	lines.push(`        text-align: left;`);
+	lines.push(`      }`);
+	lines.push(`    }`);
+	lines.push(`  </style>`);
+	lines.push(`<aside class="__void-error-overlay" data-void-error-overlay role="dialog" aria-label="Void dev error overlay"><div class="__void-error-backdrop" data-void-error-backdrop></div><section class="__void-error-panel"><button type="button" class="__void-error-close" data-void-error-close aria-label="Minimize error overlay"><svg viewBox="0 0 16 16" aria-hidden="true" focusable="false"><path d="M3.757 3.757 12.243 12.243M12.243 3.757 3.757 12.243" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/></svg></button><header class="__void-error-header"><p class="__void-error-status">\${__voidEscapeHtml(String(status) + ": " + title)}</p></header>\${sections}</section><button type="button" class="__void-error-minimized" data-void-error-toggle aria-label="Show dev error overlay" aria-expanded="true">\${__voidEscapeHtml(errorCountLabel)}</button><script>(function(){const script=document.currentScript;if(!(script instanceof HTMLScriptElement))return;const root=script.closest("[data-void-error-overlay]");if(!(root instanceof HTMLElement))return;const backdrop=root.querySelector("[data-void-error-backdrop]");const closeButton=root.querySelector("[data-void-error-close]");const toggle=root.querySelector("[data-void-error-toggle]");const setMinimized=(minimized)=>{root.classList.toggle("is-minimized", minimized);if(toggle instanceof HTMLElement)toggle.setAttribute("aria-expanded", minimized ? "false" : "true");};if(backdrop instanceof HTMLElement)backdrop.addEventListener("click",()=>setMinimized(true));if(closeButton instanceof HTMLElement)closeButton.addEventListener("click",()=>setMinimized(true));if(toggle instanceof HTMLElement)toggle.addEventListener("click",()=>setMinimized(false));})();<\/script></aside>\`;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidInjectDevErrorOverlay(html, overlay) {`);
+	lines.push(`  return /<\\/body\\s*>/i.test(html) ? html.replace(/<\\/body\\s*>/i, overlay + "</body>") : html + overlay;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidRenderErrorPage(request, status, title, error) {`);
+	lines.push(`  const heading = status + ": " + title;`);
+	lines.push(`  const prefix = status + ": ";`);
+	lines.push(`  const overlay = __VOID_DEV && status === 500 && error ? __voidRenderDevErrorOverlay(request, status, title, error) : "";`);
+	lines.push(`  return \`<!doctype html>`);
+	lines.push(`<html lang="en">`);
+	lines.push(`  <head>`);
+	lines.push(`    <meta charset="utf-8">`);
+	lines.push(`    <meta name="viewport" content="width=device-width, initial-scale=1">`);
+	lines.push(`    <title>\${__voidEscapeHtml(heading)}</title>`);
+	lines.push(`    <style>`);
+	lines.push(`      :root {`);
+	lines.push(`        color-scheme: light dark;`);
+	lines.push(`        font-family: \${__VOID_ERROR_PAGE_FONT_STACK};`);
+	lines.push(`        background: #f5f5f5;`);
+	lines.push(`        color: #171717;`);
+	lines.push(`      }`);
+	lines.push(`      * { box-sizing: border-box; }`);
+	lines.push(`      body {`);
+	lines.push(`        margin: 0;`);
+	lines.push(`        min-block-size: 100dvh;`);
+	lines.push(`        display: grid;`);
+	lines.push(`        place-items: center;`);
+	lines.push(`        padding: 24px;`);
+	lines.push(`        background: radial-gradient(circle at top, rgba(255, 255, 255, 0.96), rgba(245, 245, 245, 0.96) 52%), linear-gradient(180deg, #fafafa 0%, #f1f1f1 100%);`);
+	lines.push(`        font: 500 16px/1.5 \${__VOID_ERROR_PAGE_FONT_STACK};`);
+	lines.push(`      }`);
+	lines.push(`      main {`);
+	lines.push(`        inline-size: min(100%, 560px);`);
+	lines.push(`        padding: 32px 36px;`);
+	lines.push(`        border: 1px solid #d4d4d8;`);
+	lines.push(`        border-radius: 32px;`);
+	lines.push(`        corner-shape: squircle;`);
+	lines.push(`        background: rgba(255, 255, 255, 0.88);`);
+	lines.push(`        text-align: center;`);
+	lines.push(`        backdrop-filter: blur(12px);`);
+	lines.push(`      }`);
+	lines.push(`      h1 {`);
+	lines.push(`        margin: 0;`);
+	lines.push(`        font: 400 clamp(1.5rem, 1.2rem + 1vw, 2rem) / 1.1 \${__VOID_ERROR_PAGE_FONT_STACK};`);
+	lines.push(`        letter-spacing: -0.03em;`);
+	lines.push(`      }`);
+	lines.push(`      strong {`);
+	lines.push(`        font-weight: 600;`);
+	lines.push(`      }`);
+	lines.push(`      @media (prefers-color-scheme: dark) {`);
+	lines.push(`        :root {`);
+	lines.push(`          background: #0a0a0a;`);
+	lines.push(`          color: #f5f5f5;`);
+	lines.push(`        }`);
+	lines.push(`        body {`);
+	lines.push(`          background: radial-gradient(circle at top, rgba(38, 38, 38, 0.96), rgba(10, 10, 10, 0.96) 52%), linear-gradient(180deg, #171717 0%, #0a0a0a 100%);`);
+	lines.push(`        }`);
+	lines.push(`        main {`);
+	lines.push(`          border-color: #27272a;`);
+	lines.push(`          background: rgba(23, 23, 23, 0.88);`);
+	lines.push(`        }`);
+	lines.push(`      }`);
+	lines.push(`    </style>`);
+	lines.push(`  </head>`);
+	lines.push(`  <body>`);
+	lines.push(`    <main>`);
+	lines.push(`      <h1><strong>\${__voidEscapeHtml(prefix)}</strong>\${__voidEscapeHtml(title)}</h1>`);
+	lines.push(`    </main>`);
+	lines.push(`    \${overlay}`);
+	lines.push(`  </body>`);
+	lines.push(`</html>\`;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function __voidCreateErrorResponse(request, status, title, error) {`);
+	lines.push(`  if (!__voidShouldServeHtmlErrorPage(request)) {`);
+	lines.push(`    return new Response(title, { status });`);
+	lines.push(`  }`);
+	lines.push(`  return new Response(request.method === "HEAD" ? null : __voidRenderErrorPage(request, status, title, error), {`);
+	lines.push(`    status,`);
+	lines.push(`    headers: { "content-type": "text/html; charset=utf-8" },`);
+	lines.push(`  });`);
+	lines.push(`}`);
+	lines.push("");
+}
+/**
+* Generate the code for the virtual route table module (virtual:void-routes).
+* This module creates a Hono app with:
+* - Middleware registered via app.use()
+* - Routes registered with lazy-loaded handlers and auto-conversion
+*/
+function compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, ssr, options, pages = null) {
+	const lines = [];
+	const auth = options.auth;
+	const webSockets = scan.websockets ?? [];
+	lines.push(`import { AsyncLocalStorage } from "node:async_hooks";`);
+	lines.push(`import { Hono } from ${JSON.stringify(options.honoPath)};`);
+	lines.push(`import { convertReturnValue } from ${JSON.stringify(options.responsePath)};`);
+	lines.push(`import { VoidAssetRewriteError as __VoidAssetRewriteError } from ${JSON.stringify(options.handlerPath)};`);
+	if (options.nodeTarget) lines.push(`const withRuntimeEnv = (_env, fn) => fn();`);
+	else lines.push(`import { withRuntimeEnv } from ${JSON.stringify(options.runtimeEnvPath)};`);
+	if (auth) {
+		const authImports = [
+			"runVoidAuthMiddleware",
+			"handleVoidAuthRequest",
+			"runVoidAuthMigrations"
+		];
+		if (webSockets.length > 0) authImports.push("resolveVoidAuthState as __resolveVoidAuthStateRuntime");
+		lines.push(`import { ${authImports.join(", ")} } from ${JSON.stringify(auth.authRuntimePath)};`);
+		if (auth.authDatabasePath) lines.push(`import { __voidAuthDatabase } from ${JSON.stringify(auth.authDatabasePath)};`);
+		if (auth.authSchemaPath) lines.push(`import { migrationSchema as __voidAuthMigrationSchema } from ${JSON.stringify(auth.authSchemaPath)};`);
+		if (auth.authConfigPath) lines.push(`import __voidAuthConfig from ${JSON.stringify(auth.authConfigPath)};`);
+	}
+	if (webSockets.length > 0 && options.webSocketRuntimePath) lines.push(`import { createWebSocketDurableObject as __createWebSocketDurableObject, handleWebSocketUpgrade as __handleWebSocketUpgrade, forwardWebSocketRequest as __forwardWebSocketRequest } from ${JSON.stringify(options.webSocketRuntimePath)};`);
+	lines.push("");
+	for (let i = 0; i < scan.middleware.length; i++) {
+		const mw = scan.middleware[i];
+		lines.push(`import middleware${i} from ${JSON.stringify(`${middlewareDir}/${mw.filePath}`)};`);
+	}
+	for (let i = 0; i < webSockets.length; i++) {
+		const route = webSockets[i];
+		lines.push(`import websocket${i} from ${JSON.stringify(`${routesDir}/${route.filePath}`)};`);
+	}
+	lines.push("");
+	if (auth) {
+		lines.push(`const __voidAuthOptions = { dialect: ${JSON.stringify(auth.dialect)}, providers: ${JSON.stringify(auth.providers)}, userConfig: ${auth.authConfigPath ? "__voidAuthConfig" : "undefined"} };`);
+		if (webSockets.length > 0) lines.push(`const __resolveVoidAuthState = (request, env, runtime) => __resolveVoidAuthStateRuntime(request, env, runtime${auth.authDatabasePath ? ", __voidAuthDatabase" : ""});`);
+		lines.push("");
+	}
+	lines.push(`const app = new Hono();`);
+	lines.push(`export const requestContext = new AsyncLocalStorage();`);
+	lines.push("const __voidOriginalUrls = new WeakMap();");
+	lines.push("const __voidFallbackHandled = new WeakSet();");
+	const ASSET_EXTENSIONS = [
+		"png",
+		"jpg",
+		"jpeg",
+		"gif",
+		"webp",
+		"avif",
+		"svg",
+		"ico",
+		"css",
+		"js",
+		"mjs",
+		"cjs",
+		"woff",
+		"woff2",
+		"ttf",
+		"otf",
+		"eot",
+		"mp4",
+		"webm",
+		"mp3",
+		"wav",
+		"pdf",
+		"txt",
+		"xml",
+		"json",
+		"wasm",
+		"map"
+	];
+	const routePatterns = [];
+	for (const r of scan.routes) routePatterns.push(r.pattern);
+	if (pages && scan.pages.pages.length > 0) for (const p of scan.pages.pages) routePatterns.push(p.pattern);
+	const usedExts = /* @__PURE__ */ new Set();
+	for (const p of routePatterns) {
+		const m = /\.([A-Za-z0-9]+)$/.exec(p);
+		if (m) usedExts.add(m[1].toLowerCase());
+	}
+	const blockedExts = ASSET_EXTENSIONS.filter((e) => !usedExts.has(e));
+	if (blockedExts.length > 0) lines.push(`const __voidAssetRewriteExtRE = /\\.(${blockedExts.join("|")})$/i;`);
+	else lines.push("const __voidAssetRewriteExtRE = /(?!)/;");
+	lines.push(`const __VOID_DEV_ROUTING = ${JSON.stringify(options.dev === true)};`);
+	lines.push("function __voidAnnotateRouting(response, trace) {");
+	lines.push("  if (!__VOID_DEV_ROUTING || !response) return response;");
+	lines.push("  const headers = new Headers(response.headers);");
+	lines.push("  headers.set(\"X-Void-Routing\", trace);");
+	lines.push("  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });");
+	lines.push("}");
+	lines.push("");
+	lines.push("function __voidShouldMarkNoMatch(request) {");
+	lines.push("  const url = new URL(request.url);");
+	lines.push("  if (request.method !== \"GET\" && request.method !== \"HEAD\") return false;");
+	lines.push("  if (url.pathname === \"/api\" || url.pathname.startsWith(\"/api/\")) return false;");
+	lines.push("  if (/\\/[^/]+\\.[^/]+$/.test(url.pathname)) return false;");
+	lines.push("  return true;");
+	lines.push("}");
+	lines.push("function __voidMarkNoMatch(request, response) {");
+	lines.push("  if (!response || response.status !== 404 || !__voidShouldMarkNoMatch(request)) return response;");
+	lines.push("  const headers = new Headers(response.headers);");
+	lines.push("  headers.set(\"X-Void-No-Match\", \"1\");");
+	lines.push("  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });");
+	lines.push("}");
+	lines.push("");
+	ensureMergeQueryHelperEmitted(lines);
+	lines.push("app.use(async (c, next) => {");
+	if (!options.nodeTarget && options.dev !== true) {
+		lines.push("  if (!__voidOriginalUrls.has(c.req.raw)) {");
+		lines.push("    const __h = c.req.raw.headers.get(\"X-Void-Original-URL\");");
+		lines.push("    if (__h != null) {");
+		lines.push("      try { __voidOriginalUrls.set(c.req.raw, new URL(__h)); } catch {}");
+		lines.push("    }");
+		lines.push("  }");
+	}
+	lines.push("  c.rewrite = (path) => {");
+	lines.push("    if (!path.startsWith(\"/\") || path.startsWith(\"//\")) {");
+	lines.push("      throw new Error(\"c.rewrite() only accepts internal, path-absolute destinations — they must start with a single \\\"/\\\" (a leading \\\"//\\\" parses as protocol-relative and would proxy cross-origin); use fetch() for external URLs\");");
+	lines.push("    }");
+	lines.push("    const __qIdx = path.indexOf(\"?\");");
+	lines.push("    const __hIdx = path.indexOf(\"#\");");
+	lines.push("    const __firstDelim = __qIdx === -1 ? __hIdx : __hIdx === -1 ? __qIdx : Math.min(__qIdx, __hIdx);");
+	lines.push("    const __assetCheckPath = __firstDelim === -1 ? path : path.slice(0, __firstDelim);");
+	lines.push("    if (__voidAssetRewriteExtRE.test(__assetCheckPath)) {");
+	lines.push("      throw new __VoidAssetRewriteError(path);");
+	lines.push("    }");
+	lines.push("    const __pathOnly = __firstDelim === -1 ? path : path.slice(0, __firstDelim);");
+	lines.push("    const __searchOnly = __qIdx === -1 ? \"\" : path.slice(__qIdx, __hIdx === -1 ? path.length : __hIdx);");
+	lines.push("    const rewriteUrl = new URL(c.req.url);");
+	lines.push("    rewriteUrl.pathname = __pathOnly;");
+	lines.push("    if (__searchOnly) rewriteUrl.search = __searchOnly;");
+	lines.push("    const rewriteReq = new Request(rewriteUrl.toString(), c.req.raw);");
+	lines.push("    const __prior = __voidOriginalUrls.get(c.req.raw);");
+	lines.push("    __voidOriginalUrls.set(rewriteReq, __prior ?? new URL(c.req.url));");
+	if (options.nodeTarget) lines.push("    const __rewritePromise = app.fetch(rewriteReq, c.env);");
+	else lines.push("    const __rewritePromise = app.fetch(rewriteReq, c.env, c.executionCtx);");
+	lines.push("    if (!__VOID_DEV_ROUTING) return __rewritePromise;");
+	lines.push("    return __rewritePromise.then((res) => __voidAnnotateRouting(res, \"c.rewrite \\u2192 \" + path + \" (middleware)\"));");
+	lines.push("  };");
+	lines.push("  const __origRedirect = c.redirect.bind(c);");
+	lines.push("  c.redirect = (location, status) => {");
+	lines.push("    if (typeof location === \"string\" && location.startsWith(\"/\") && !location.startsWith(\"//\")) {");
+	lines.push("      const search = new URL(c.req.raw.url).search;");
+	lines.push("      return __origRedirect(__mergeQueryIntoLocation(location, search), status);");
+	lines.push("    }");
+	lines.push("    return __origRedirect(location, status);");
+	lines.push("  };");
+	lines.push("  c.originalUrl = () => __voidOriginalUrls.get(c.req.raw) ?? null;");
+	lines.push("  c.isRewritten = () => __voidOriginalUrls.has(c.req.raw);");
+	lines.push("  await next();");
+	lines.push("});");
+	lines.push("");
+	lines.push("app.use(async (c, next) => {");
+	if (options.nodeTarget) lines.push("  await requestContext.run({ request: c.req.raw }, next);");
+	else lines.push("  await requestContext.run({ request: c.req.raw, executionCtx: c.executionCtx }, next);");
+	lines.push("});");
+	lines.push("");
+	const emitEdgeRules = options.nodeTarget || options.dev === true;
+	if (emitEdgeRules && options.redirectRules?.length) compileRoutingRulesMiddleware(lines, options.redirectRules, options.dev === true, options.nodeTarget === true);
+	if (emitEdgeRules && options.headerRules?.length) compileHeaderMiddleware(lines, options.headerRules);
+	if (auth) {
+		lines.push("app.use(async (c, next) => {");
+		lines.push(`  return runVoidAuthMiddleware(c, next, __voidAuthOptions${auth.authDatabasePath ? ", __voidAuthDatabase" : ""});`);
+		lines.push("});");
+		lines.push("");
+	}
+	for (let i = 0; i < scan.middleware.length; i++) lines.push(`app.use(middleware${i});`);
+	if (scan.middleware.length > 0) lines.push("");
+	if (auth) {
+		lines.push("app.all(\"/api/auth\", async (c) => {");
+		lines.push(`  return handleVoidAuthRequest(c, __voidAuthOptions${auth.authDatabasePath ? ", __voidAuthDatabase" : ""});`);
+		lines.push("});");
+		lines.push("");
+		lines.push("app.all(\"/api/auth/*\", async (c) => {");
+		lines.push(`  return handleVoidAuthRequest(c, __voidAuthOptions${auth.authDatabasePath ? ", __voidAuthDatabase" : ""});`);
+		lines.push("});");
+		lines.push("");
+	}
+	const seenFiles = /* @__PURE__ */ new Set();
+	for (const route of scan.routes) {
+		const filePath = `${routesDir}/${route.filePath}`;
+		const varName = `_mod_${route.filePath.replace(/[^a-zA-Z0-9]/g, "_")}`;
+		const loaderName = `_load_${route.filePath.replace(/[^a-zA-Z0-9]/g, "_")}`;
+		if (!seenFiles.has(route.filePath)) {
+			seenFiles.add(route.filePath);
+			if (options.dev !== true) lines.push(`let ${varName};`);
+			lines.push(`async function ${loaderName}() {`);
+			if (options.dev === true) lines.push(`  return import(${JSON.stringify(filePath)});`);
+			else {
+				lines.push(`  if (!${varName}) ${varName} = await import(${JSON.stringify(filePath)});`);
+				lines.push(`  return ${varName};`);
+			}
+			lines.push(`}`);
+		}
+		if (route.methods.length === 0) {
+			lines.push(`app.all(${JSON.stringify(route.pattern)}, async (c) => {`);
+			lines.push(`  const mod = await ${loaderName}();`);
+			lines.push(`  return convertReturnValue(await mod.default(c));`);
+			lines.push(`});`);
+		} else for (const method of route.methods) {
+			const honoMethod = method.toLowerCase();
+			lines.push(`app.${honoMethod}(${JSON.stringify(route.pattern)}, async (c) => {`);
+			lines.push(`  const mod = await ${loaderName}();`);
+			lines.push(`  return convertReturnValue(await mod.${method}(c));`);
+			lines.push(`});`);
+		}
+	}
+	lines.push("");
+	if (webSockets.length > 0) {
+		for (let i = 0; i < webSockets.length; i++) {
+			const route = webSockets[i];
+			lines.push(`export const ${route.className} = __createWebSocketDurableObject(websocket${i}, ${JSON.stringify({
+				pattern: route.pattern,
+				params: route.params,
+				className: route.className,
+				bindingName: route.bindingName
+			})}, ${auth ? "__voidAuthOptions" : "undefined"}, ${auth ? "__resolveVoidAuthState" : "undefined"});`);
+		}
+		lines.push("");
+		lines.push(`const __voidWebSocketRoutes = ${JSON.stringify(webSockets.map((route) => ({
+			pattern: route.pattern,
+			params: route.params,
+			className: route.className,
+			bindingName: route.bindingName
+		})))};`);
+		lines.push("export async function __voidHandleWebSocket(request, env) {");
+		lines.push("  return __handleWebSocketUpgrade(request, env, __voidWebSocketRoutes);");
+		lines.push("}");
+		lines.push("");
+		for (let i = 0; i < webSockets.length; i++) {
+			const route = webSockets[i];
+			lines.push(`app.all(${JSON.stringify(route.pattern)}, async (c) => {`);
+			lines.push(`  return __forwardWebSocketRequest(c.req.raw, c.env, __voidWebSocketRoutes[${i}]);`);
+			lines.push("});");
+		}
+		lines.push("");
+	} else {
+		lines.push("export async function __voidHandleWebSocket() { return null; }");
+		lines.push("");
+	}
+	if (pages && scan.pages.pages.length > 0) compilePageRoutes(lines, scan, pages, options);
+	compilePrerenderCollector(lines, scan, ssr, options);
+	if (ssr) {
+		const clientEntryUrl = `/${ssr.clientEntryRelativePath}`;
+		lines.push(`const SSR_CLIENT_ENTRY_ID = ${JSON.stringify(ssr.clientEntryRelativePath)};`);
+		lines.push(`const SSR_CLIENT_ENTRY_URL = ${JSON.stringify(clientEntryUrl)};`);
+		lines.push(`let cachedSsrManifest = null;`);
+		lines.push("");
+		lines.push(`function escapeHtml(value) {`);
+		lines.push(`  return String(value).replace(/"/g, "&quot;");`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`function getDevClientTags() {`);
+		lines.push(`  const preloadTags = [\`<script type="module" src="/@vite/client"><\/script>\`];`);
+		lines.push(`  preloadTags.push(\`${BINDING_HINT_SCRIPT}\`);`);
+		if (options.reactRefresh) lines.push(`  preloadTags.push(\`<script type="module">
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+<\/script>\`);`);
+		lines.push(`  const bodyTag = \`<script type="module" src="\${escapeHtml(SSR_CLIENT_ENTRY_URL)}"><\/script>\`;`);
+		lines.push(`  return { css: "", preloads: preloadTags.join("\\n"), body: bodyTag };`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`function collectManifestFiles(manifest, entryId) {`);
+		lines.push(`  const seen = new Set();`);
+		lines.push(`  const toVisit = [entryId];`);
+		lines.push(`  while (toVisit.length > 0) {`);
+		lines.push(`    const currentId = toVisit.pop();`);
+		lines.push(`    if (seen.has(currentId)) continue;`);
+		lines.push(`    seen.add(currentId);`);
+		lines.push(`    const chunk = manifest[currentId];`);
+		lines.push(`    if (!chunk || !Array.isArray(chunk.imports)) continue;`);
+		lines.push(`    for (const importedId of chunk.imports) toVisit.push(importedId);`);
+		lines.push(`  }`);
+		lines.push(`  return Array.from(seen);`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`async function loadSsrManifest(request, env) {`);
+		lines.push(`  if (cachedSsrManifest) return cachedSsrManifest;`);
+		lines.push(`  if (typeof globalThis.__VITE_MANIFEST__ === "object" && globalThis.__VITE_MANIFEST__) {`);
+		lines.push(`    cachedSsrManifest = globalThis.__VITE_MANIFEST__;`);
+		lines.push(`    return cachedSsrManifest;`);
+		lines.push(`  }`);
+		lines.push(`  const assets = env?.ASSETS;`);
+		lines.push(`  if (!assets || typeof assets.fetch !== "function") return null;`);
+		lines.push(`  const manifestUrl = new URL("/.vite/manifest.json", request.url);`);
+		lines.push(`  const response = await assets.fetch(new Request(manifestUrl.toString()));`);
+		lines.push(`  if (!response.ok) return null;`);
+		lines.push(`  cachedSsrManifest = await response.json();`);
+		lines.push(`  return cachedSsrManifest;`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`async function getClientAssetTags(request, env) {`);
+		lines.push(`  const manifest = await loadSsrManifest(request, env);`);
+		lines.push(`  if (!manifest || typeof manifest !== "object") {`);
+		lines.push(`    if (!import.meta.env.DEV) return { css: "", preloads: "", body: "" };`);
+		lines.push(`    return getDevClientTags();`);
+		lines.push(`  }`);
+		lines.push(`  const entry = manifest[SSR_CLIENT_ENTRY_ID];`);
+		lines.push(`  if (!entry || typeof entry !== "object" || typeof entry.file !== "string") {`);
+		lines.push(`    return { css: "", preloads: "", body: "" };`);
+		lines.push(`  }`);
+		lines.push(`  const ids = collectManifestFiles(manifest, SSR_CLIENT_ENTRY_ID);`);
+		lines.push(`  const cssFiles = new Set();`);
+		lines.push(`  const preloadFiles = new Set();`);
+		lines.push(`  for (const id of ids) {`);
+		lines.push(`    const chunk = manifest[id];`);
+		lines.push(`    if (!chunk || typeof chunk !== "object") continue;`);
+		lines.push(`    if (Array.isArray(chunk.css)) {`);
+		lines.push(`      for (const cssFile of chunk.css) cssFiles.add(cssFile);`);
+		lines.push(`    }`);
+		lines.push(`    if (id !== SSR_CLIENT_ENTRY_ID && typeof chunk.file === "string") {`);
+		lines.push(`      preloadFiles.add(chunk.file);`);
+		lines.push(`    }`);
+		lines.push(`  }`);
+		lines.push(`  const cssTags = [];`);
+		lines.push(`  for (const cssFile of cssFiles) {`);
+		lines.push(`    cssTags.push(\`<link rel="stylesheet" href="/\${escapeHtml(cssFile)}">\`);`);
+		lines.push(`  }`);
+		lines.push(`  const preloadTags = [];`);
+		lines.push(`  for (const preloadFile of preloadFiles) {`);
+		lines.push(`    preloadTags.push(\`<link rel="modulepreload" href="/\${escapeHtml(preloadFile)}">\`);`);
+		lines.push(`  }`);
+		lines.push(`  const bodyTag = \`<script type="module" src="/\${escapeHtml(entry.file)}"><\/script>\`;`);
+		lines.push(`  return { css: cssTags.join("\\n"), preloads: preloadTags.join("\\n"), body: bodyTag };`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`function shouldHandleSsrRequest(c) {`);
+		lines.push(`  const path = c.req.path;`);
+		lines.push(`  if (path === "/api" || path.startsWith("/api/")) return false;`);
+		lines.push(`  if (/\\/[^/]+\\.[^/]+$/.test(path)) return false;`);
+		lines.push(`  const destination = c.req.header("sec-fetch-dest");`);
+		lines.push(`  if (destination && destination !== "document" && destination !== "empty") return false;`);
+		lines.push(`  return true;`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`async function fetchFromAssets(c) {`);
+		lines.push(`  const assets = c.env?.ASSETS;`);
+		lines.push(`  if (!assets || typeof assets.fetch !== "function") {`);
+		lines.push(`    return __voidMarkNoMatch(c.req.raw, new Response("Not Found", { status: 404 }));`);
+		lines.push(`  }`);
+		lines.push(`  const response = await assets.fetch(c.req.raw);`);
+		lines.push(`  return response.status === 404 ? __voidMarkNoMatch(c.req.raw, new Response("Not Found", { status: 404 })) : response;`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`async function renderSsrResponse(c, mod) {`);
+		lines.push(`  const render = typeof mod.render === "function" ? mod.render : mod.default;`);
+		lines.push(`  if (typeof render !== "function") {`);
+		lines.push(`    throw new Error("ssr: Invalid entry. Export render(c, assetTags).");`);
+		lines.push(`  }`);
+		lines.push(`  const assetTags = await getClientAssetTags(c.req.raw, c.env);`);
+		lines.push(`  return render(c, assetTags);`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`app.notFound(async (c) => {`);
+		if (options.nodeTarget && options.fallbackRules?.length) emitFallbackRulesCheck(lines, options.fallbackRules, options.dev === true, "  ", options.nodeTarget === true);
+		lines.push(`  if (!shouldHandleSsrRequest(c)) {`);
+		if (!options.nodeTarget && options.dev === true && options.fallbackRules?.length) {
+			lines.push(`    const __assetRes = await fetchFromAssets(c);`);
+			lines.push(`    if (__assetRes.status !== 404) return __assetRes;`);
+			emitFallbackRulesCheck(lines, options.fallbackRules, options.dev === true, "    ", false);
+			lines.push(`    return __assetRes;`);
+		} else lines.push(`    return fetchFromAssets(c);`);
+		lines.push(`  }`);
+		lines.push(`  const mod = await import(${JSON.stringify(ssr.serverEntryPath)});`);
+		lines.push(`  return renderSsrResponse(c, mod);`);
+		lines.push(`});`);
+		lines.push("");
+	} else if ((options.nodeTarget || options.dev === true) && options.fallbackRules?.length && !(pages && scan.pages.pages.length > 0)) {
+		lines.push(`app.notFound(async (c) => {`);
+		if (!options.nodeTarget && options.dev === true) {
+			lines.push(`  const assets = c.env?.ASSETS;`);
+			lines.push(`  if (assets && typeof assets.fetch === "function") {`);
+			lines.push(`    const __assetRes = await assets.fetch(c.req.raw);`);
+			lines.push(`    if (__assetRes.status !== 404) return __assetRes;`);
+			lines.push(`  }`);
+		}
+		emitFallbackRulesCheck(lines, options.fallbackRules, options.dev === true, "  ", options.nodeTarget === true);
+		lines.push(`  return __voidMarkNoMatch(c.req.raw, new Response("Not Found", { status: 404 }));`);
+		lines.push(`});`);
+		lines.push("");
+	}
+	if (scan.jobs.length > 0) {
+		for (let i = 0; i < scan.jobs.length; i++) {
+			const job = scan.jobs[i];
+			lines.push(`const job${i}Crons = ${JSON.stringify(job.crons)};`);
+		}
+		lines.push("");
+		lines.push("export async function scheduled(controller, env, ctx) {");
+		lines.push("  switch (controller.cron) {");
+		for (let i = 0; i < scan.jobs.length; i++) {
+			const job = scan.jobs[i];
+			const filePath = JSON.stringify(`${jobsDir}/${job.filePath}`);
+			for (let j = 0; j < job.crons.length; j++) if (j < job.crons.length - 1) lines.push(`    case job${i}Crons[${j}]:`);
+			else lines.push(`    case job${i}Crons[${j}]: {`);
+			lines.push(`      const mod = await import(${filePath});`);
+			lines.push("      if (typeof mod.default === 'function') {");
+			lines.push("        await mod.default(controller, env, ctx);");
+			lines.push("      }");
+			lines.push("      return;");
+			lines.push("    }");
+		}
+		lines.push("    default:");
+		lines.push("      return;");
+		lines.push("  }");
+		lines.push("}");
+		lines.push("");
+	} else {
+		lines.push("export async function scheduled() {}");
+		lines.push("");
+	}
+	if (scan.jobs.length > 0) {
+		lines.push("const __scheduledHandler = async (c) => {");
+		lines.push("  const __token = c.req.header(\"x-void-internal\");");
+		lines.push("  const __expected = __getRawEnv()?.__VOID_PROXY_TOKEN;");
+		lines.push("  const __devToken = c.req.header(\"x-void-dev-trigger\");");
+		lines.push("  if (__expected ? __token !== __expected : import.meta.env.DEV ? __devToken !== __VOID_DEV_TRIGGER_TOKEN : __token !== __VOID_BUILD_KEY) {");
+		lines.push("    return c.json({ error: \"unauthorized\" }, 401);");
+		lines.push("  }");
+		lines.push("  const { cron, scheduledTime } = await c.req.json();");
+		lines.push("  const controller = { cron, scheduledTime, noRetry() {} };");
+		lines.push("  await scheduled(controller, c.env, c.executionCtx);");
+		lines.push("  return c.json({ ok: true });");
+		lines.push("};");
+		lines.push("app.post(\"/__void/scheduled\", __scheduledHandler);");
+		lines.push("");
+	}
+	if (scan.queues.length > 0) {
+		for (let i = 0; i < scan.queues.length; i++) lines.push(`const queue${i}Name = ${JSON.stringify(scan.queues[i].name)};`);
+		lines.push("");
+		lines.push("export async function __processQueue(payload, env) {");
+		lines.push("  const queueSuffix = payload.queue;");
+		lines.push("  const __decisions = new Map();");
+		lines.push("  function __wrapMsg(m) {");
+		lines.push("    let decided = false;");
+		lines.push("    return {");
+		lines.push("      id: m.id, timestamp: new Date(m.timestamp), body: m.body, attempts: m.attempts,");
+		lines.push("      ack() { if (!decided) { decided = true; __decisions.set(m.id, { action: \"ack\" }); } },");
+		lines.push("      retry(opts) { if (!decided) { decided = true; __decisions.set(m.id, { action: \"retry\", ...(opts?.delaySeconds != null ? { delaySeconds: opts.delaySeconds } : {}) }); } },");
+		lines.push("    };");
+		lines.push("  }");
+		lines.push("  const __msgs = payload.messages.map(__wrapMsg);");
+		lines.push("  const batch = {");
+		lines.push("    queue: queueSuffix,");
+		lines.push("    messages: __msgs,");
+		lines.push("    ackAll() { for (const m of __msgs) m.ack(); },");
+		lines.push("    retryAll(opts) { for (const m of __msgs) m.retry(opts); },");
+		lines.push("  };");
+		lines.push("  let __ok = true;");
+		lines.push("  try {");
+		for (let i = 0; i < scan.queues.length; i++) {
+			const q = scan.queues[i];
+			const cond = i === 0 ? "if" : "} else if";
+			lines.push(`    ${cond} (queueSuffix === queue${i}Name || queueSuffix.endsWith("-" + queue${i}Name)) {`);
+			lines.push(`      const mod = await import(${JSON.stringify(`${queuesDir}/${q.filePath}`)});`);
+			lines.push("      if (typeof mod.default === 'function') await mod.default(batch, env);");
+		}
+		lines.push("    }");
+		lines.push("  } catch { __ok = false; }");
+		lines.push("  return { ok: __ok, ...(__decisions.size > 0 ? { decisions: Object.fromEntries(__decisions) } : {}) };");
+		lines.push("}");
+		lines.push("");
+		lines.push("const __queueHandler = async (c) => {");
+		lines.push("  const __token = c.req.header(\"x-void-internal\");");
+		lines.push("  const __expected = __getRawEnv()?.__VOID_PROXY_TOKEN;");
+		lines.push("  const __devToken = c.req.header(\"x-void-dev-trigger\");");
+		lines.push("  if (__expected ? __token !== __expected : import.meta.env.DEV ? __devToken !== __VOID_DEV_TRIGGER_TOKEN : __token !== __VOID_BUILD_KEY) {");
+		lines.push("    return c.json({ error: \"unauthorized\" }, 401);");
+		lines.push("  }");
+		lines.push("  const payload = await c.req.json();");
+		lines.push("  const result = await __processQueue(payload, c.env);");
+		lines.push("  return c.json(result);");
+		lines.push("};");
+		lines.push("app.post(\"/__void/queue\", __queueHandler);");
+		lines.push("");
+	}
+	if (options.migrationHandlerPath && (options.migrations?.length || auth)) {
+		lines.push(`import { createMigrationHandler as __createMigrationHandler } from ${JSON.stringify(options.migrationHandlerPath)};`);
+		lines.push(`const __migrations = ${JSON.stringify(options.migrations)};`);
+		lines.push(`const __migrationDialect = ${JSON.stringify(options.migrationDialect ?? "sqlite")};`);
+		lines.push("app.post(\"/__void/migrate\", async (c) => {");
+		lines.push("  const __voidMigrationHandler = __createMigrationHandler(");
+		lines.push("    __getRawEnv(),");
+		lines.push("    __migrations,");
+		lines.push("    __migrationDialect,");
+		if (auth) lines.push(`    () => runVoidAuthMigrations(new Request(c.req.url), __getRawEnv(), __voidAuthOptions${auth.authSchemaPath ? ", __voidAuthMigrationSchema" : ""}),`);
+		else lines.push("    undefined,");
+		lines.push("  );");
+		lines.push("  return __voidMigrationHandler(c.req.raw);");
+		lines.push("});");
+		lines.push("");
+	}
+	if (options.bindingHandlerPath) {
+		lines.push(`import { createBindingHandler as __createBindingHandler } from ${JSON.stringify(options.bindingHandlerPath)};`);
+		lines.push("let __voidBindingApp;");
+		lines.push("app.all(\"/__void/*\", async (c) => {");
+		lines.push("  if (!__voidBindingApp) __voidBindingApp = __createBindingHandler(__getRawEnv());");
+		lines.push("  const url = new URL(c.req.url);");
+		lines.push("  url.pathname = url.pathname.slice(7);");
+		lines.push("  return __voidBindingApp.fetch(new Request(url.toString(), c.req.raw));");
+		lines.push("});");
+		lines.push("");
+	}
+	lines.push("const __rawEnvStore = new AsyncLocalStorage();");
+	lines.push("export function __withRawEnv(env, fn) { return __rawEnvStore.run(env, fn); }");
+	lines.push("function __getRawEnv() { return __rawEnvStore.getStore(); }");
+	lines.push(`export const __VOID_BUILD_KEY = ${JSON.stringify(crypto.randomUUID())};`);
+	lines.push(`export const __VOID_DEV_TRIGGER_TOKEN = ${JSON.stringify(options.devTriggerToken ?? crypto.randomUUID())};`);
+	lines.push("");
+	lines.push(`export default app;`);
+	return lines.join("\n");
+}
+function compilePrerenderCollector(lines, scan, ssr, options) {
+	const staticPaths = scan.pages.pages.filter((page) => page.prerender && page.params.length === 0 && !page.catchAll).map((page) => page.pattern);
+	const dynamicPages = scan.pages.pages.filter((page) => page.prerender && page.hasGetPrerenderPaths && (page.params.length > 0 || page.catchAll));
+	const explicitPaths = options.explicitPrerenderPaths ?? [];
+	lines.push(`function __voidBuildPrerenderPath(pattern, params) {`);
+	lines.push(`  let path = pattern;`);
+	lines.push(`  for (const [key, value] of Object.entries(params)) {`);
+	lines.push(`    path = path.replace(":" + key + "{.+}", value);`);
+	lines.push(`    path = path.replace(":" + key, value);`);
+	lines.push(`  }`);
+	lines.push(`  return path;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`export async function __voidCollectPrerenderPaths(request, env, ctx) {`);
+	lines.push(`  return withRuntimeEnv(env, async () => {`);
+	if (options.nodeTarget) lines.push(`    return requestContext.run({ request }, async () => {`);
+	else lines.push(`    return requestContext.run({ request, executionCtx: ctx }, async () => {`);
+	lines.push(`      const paths = [];`);
+	for (const path of staticPaths) lines.push(`      paths.push(${JSON.stringify(path)});`);
+	for (const page of dynamicPages) {
+		const loaderName = `_pload_${page.componentId.replace(/[^a-zA-Z0-9]/g, "_")}`;
+		lines.push(`      {`);
+		lines.push(`        const mod = await ${loaderName}();`);
+		lines.push(`        if (typeof mod.getPrerenderPaths === "function") {`);
+		lines.push(`          const paramSets = await mod.getPrerenderPaths();`);
+		lines.push(`          if (Array.isArray(paramSets)) {`);
+		lines.push(`            for (const params of paramSets) {`);
+		lines.push(`              paths.push(__voidBuildPrerenderPath(${JSON.stringify(page.pattern)}, params));`);
+		lines.push(`            }`);
+		lines.push(`          }`);
+		lines.push(`        }`);
+		lines.push(`      }`);
+	}
+	if (ssr) {
+		lines.push(`      {`);
+		lines.push(`        const mod = await import(${JSON.stringify(ssr.serverEntryPath)});`);
+		lines.push(`        if (typeof mod.getPrerenderPaths === "function") {`);
+		lines.push(`          const ssrPaths = await mod.getPrerenderPaths();`);
+		lines.push(`          if (Array.isArray(ssrPaths)) {`);
+		lines.push(`            for (const path of ssrPaths) {`);
+		lines.push(`              if (typeof path === "string") paths.push(path);`);
+		lines.push(`            }`);
+		lines.push(`          }`);
+		lines.push(`        }`);
+		lines.push(`      }`);
+	}
+	for (const path of explicitPaths) lines.push(`      paths.push(${JSON.stringify(path)});`);
+	lines.push(`      return [...new Set(paths)];`);
+	lines.push(`    });`);
+	lines.push(`  });`);
+	lines.push(`}`);
+	lines.push("");
+}
+function compilePageRoutes(lines, scan, pages, options) {
+	lines.push(`import { handlePageGet, handlePageMutation } from ${JSON.stringify(pages.protocolPath)};`);
+	lines.push(`import { renderHeadToString, renderHtmlAttrs, renderBodyAttrs } from ${JSON.stringify(pages.headPath)};`);
+	lines.push(`import { renderPage } from "virtual:void-pages-renderer";`);
+	const hasIslandPages = scan.pages.pages.some((p) => p.island);
+	if (hasIslandPages) lines.push(`import { renderIslandPage } from "virtual:void-islands-renderer";`);
+	lines.push("");
+	lines.push(`const __voidHeadConfig = ${JSON.stringify(pages.headConfig ?? null)};`);
+	lines.push("");
+	pushDefaultErrorPageHelpers(lines, options);
+	const clientEntryId = pages.clientEntryId;
+	lines.push(`const PAGES_CLIENT_ENTRY_ID = ${JSON.stringify(clientEntryId)};`);
+	lines.push(`const PAGES_CLIENT_ENTRY_URL = ${JSON.stringify("/@id/__x00__" + clientEntryId)};`);
+	lines.push(`let cachedPagesManifest = null;`);
+	lines.push("");
+	lines.push(`function escapeHtmlAttr(value) {`);
+	lines.push(`  return String(value).replace(/"/g, "&quot;");`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function getPagesDevClientTags() {`);
+	lines.push(`  const preloads = \`<script type="module" src="/@vite/client"><\/script>\\n${BINDING_HINT_SCRIPT}\`;`);
+	lines.push(`  const bodyTag = \`<script type="module" src="\${escapeHtmlAttr(PAGES_CLIENT_ENTRY_URL)}"><\/script>\`;`);
+	lines.push(`  return { css: "", preloads, body: bodyTag };`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`function collectPagesManifestFiles(manifest, entryId) {`);
+	lines.push(`  const seen = new Set();`);
+	lines.push(`  const toVisit = [entryId];`);
+	lines.push(`  while (toVisit.length > 0) {`);
+	lines.push(`    const currentId = toVisit.pop();`);
+	lines.push(`    if (seen.has(currentId)) continue;`);
+	lines.push(`    seen.add(currentId);`);
+	lines.push(`    const chunk = manifest[currentId];`);
+	lines.push(`    if (!chunk || !Array.isArray(chunk.imports)) continue;`);
+	lines.push(`    for (const importedId of chunk.imports) toVisit.push(importedId);`);
+	lines.push(`  }`);
+	lines.push(`  return Array.from(seen);`);
+	lines.push(`}`);
+	lines.push("");
+	const relPagesDir = pages.pagesDirRelative;
+	const pageCssKeys = {};
+	for (const page of scan.pages.pages) {
+		const keys = [`${relPagesDir}/${page.componentPath}`];
+		const layoutIds = resolveLayoutIds(page, scan.pages.layouts, scan.pages.namedLayouts);
+		for (const layoutId of layoutIds) {
+			const layout = scan.pages.layouts.find((l) => (l.directory ? `${l.directory}/layout` : "layout") === layoutId);
+			if (layout) {
+				keys.push(`${relPagesDir}/${layout.filePath}`);
+				continue;
+			}
+			const named = scan.pages.namedLayouts.find((nl) => {
+				return (nl.directory ? `${nl.directory}/_layouts/${nl.name}` : `_layouts/${nl.name}`) === layoutId;
+			});
+			if (named) keys.push(`${relPagesDir}/${named.filePath}`);
+		}
+		pageCssKeys[page.componentId] = keys;
+	}
+	lines.push(`const PAGE_CSS_KEYS = ${JSON.stringify(pageCssKeys)};`);
+	lines.push("");
+	lines.push(`function collectRouteCss(manifest, entryId, pageKeys) {`);
+	lines.push(`  const cssFiles = new Set();`);
+	lines.push(`  const visited = new Set();`);
+	lines.push(`  const toVisit = [entryId];`);
+	lines.push(`  while (toVisit.length > 0) {`);
+	lines.push(`    const id = toVisit.pop();`);
+	lines.push(`    if (visited.has(id)) continue;`);
+	lines.push(`    visited.add(id);`);
+	lines.push(`    const chunk = manifest[id];`);
+	lines.push(`    if (!chunk) continue;`);
+	lines.push(`    if (Array.isArray(chunk.css)) {`);
+	lines.push(`      for (const f of chunk.css) cssFiles.add(f);`);
+	lines.push(`    }`);
+	lines.push(`    if (Array.isArray(chunk.imports)) {`);
+	lines.push(`      for (const i of chunk.imports) toVisit.push(i);`);
+	lines.push(`    }`);
+	lines.push(`  }`);
+	lines.push(`  for (const key of pageKeys) {`);
+	lines.push(`    const stack = [key];`);
+	lines.push(`    while (stack.length > 0) {`);
+	lines.push(`      const id = stack.pop();`);
+	lines.push(`      if (visited.has(id)) continue;`);
+	lines.push(`      visited.add(id);`);
+	lines.push(`      const chunk = manifest[id];`);
+	lines.push(`      if (!chunk) continue;`);
+	lines.push(`      if (Array.isArray(chunk.css)) {`);
+	lines.push(`        for (const f of chunk.css) cssFiles.add(f);`);
+	lines.push(`      }`);
+	lines.push(`      if (Array.isArray(chunk.imports)) {`);
+	lines.push(`        for (const i of chunk.imports) stack.push(i);`);
+	lines.push(`      }`);
+	lines.push(`    }`);
+	lines.push(`  }`);
+	lines.push(`  return cssFiles;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`async function loadPagesManifest(request, env) {`);
+	lines.push(`  if (cachedPagesManifest) return cachedPagesManifest;`);
+	lines.push(`  if (typeof globalThis.__VITE_MANIFEST__ === "object" && globalThis.__VITE_MANIFEST__) {`);
+	lines.push(`    cachedPagesManifest = globalThis.__VITE_MANIFEST__;`);
+	lines.push(`    return cachedPagesManifest;`);
+	lines.push(`  }`);
+	lines.push(`  const assets = env?.ASSETS;`);
+	lines.push(`  if (!assets || typeof assets.fetch !== "function") return null;`);
+	lines.push(`  const manifestUrl = new URL("/.vite/manifest.json", request.url);`);
+	lines.push(`  const response = await assets.fetch(new Request(manifestUrl.toString()));`);
+	lines.push(`  if (!response.ok) return null;`);
+	lines.push(`  cachedPagesManifest = await response.json();`);
+	lines.push(`  return cachedPagesManifest;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`async function getPagesAssetTags(request, env, componentId) {`);
+	lines.push(`  const manifest = await loadPagesManifest(request, env);`);
+	lines.push(`  if (!manifest || typeof manifest !== "object") {`);
+	lines.push(`    if (!import.meta.env.DEV) return { css: "", preloads: "", body: "" };`);
+	lines.push(`    return getPagesDevClientTags();`);
+	lines.push(`  }`);
+	lines.push(`  const entry = manifest[PAGES_CLIENT_ENTRY_ID];`);
+	lines.push(`  if (!entry || typeof entry !== "object" || typeof entry.file !== "string") {`);
+	lines.push(`    return { css: "", preloads: "", body: "" };`);
+	lines.push(`  }`);
+	lines.push(`  const ids = collectPagesManifestFiles(manifest, PAGES_CLIENT_ENTRY_ID);`);
+	lines.push(`  const pageKeys = componentId ? (PAGE_CSS_KEYS[componentId] || []) : [];`);
+	lines.push(`  const cssFiles = collectRouteCss(manifest, PAGES_CLIENT_ENTRY_ID, pageKeys);`);
+	lines.push(`  const preloadFiles = new Set();`);
+	lines.push(`  for (const id of ids) {`);
+	lines.push(`    const chunk = manifest[id];`);
+	lines.push(`    if (!chunk || typeof chunk !== "object") continue;`);
+	lines.push(`    if (id !== PAGES_CLIENT_ENTRY_ID && typeof chunk.file === "string") {`);
+	lines.push(`      preloadFiles.add(chunk.file);`);
+	lines.push(`    }`);
+	lines.push(`  }`);
+	lines.push(`  const cssTags = [];`);
+	lines.push(`  for (const cssFile of cssFiles) {`);
+	lines.push(`    cssTags.push(\`<link rel="stylesheet" href="/\${escapeHtmlAttr(cssFile)}">\`);`);
+	lines.push(`  }`);
+	lines.push(`  const preloadTags = [];`);
+	lines.push(`  for (const preloadFile of preloadFiles) {`);
+	lines.push(`    preloadTags.push(\`<link rel="modulepreload" href="/\${escapeHtmlAttr(preloadFile)}">\`);`);
+	lines.push(`  }`);
+	lines.push(`  const bodyTag = \`<script type="module" src="/\${escapeHtmlAttr(entry.file)}"><\/script>\`;`);
+	lines.push(`  return { css: cssTags.join("\\n"), preloads: preloadTags.join("\\n"), body: bodyTag };`);
+	lines.push(`}`);
+	lines.push("");
+	if (hasIslandPages && pages.islandClientEntryId) {
+		const islandEntryId = pages.islandClientEntryId;
+		lines.push(`const ISLANDS_CLIENT_ENTRY_ID = ${JSON.stringify(islandEntryId)};`);
+		lines.push(`const ISLANDS_CLIENT_ENTRY_URL = ${JSON.stringify("/@id/__x00__" + islandEntryId)};`);
+		if (pages.mdClientEntryId) {
+			lines.push(`const MD_CLIENT_ENTRY_ID = ${JSON.stringify(pages.mdClientEntryId)};`);
+			lines.push(`const MD_CLIENT_ENTRY_URL = ${JSON.stringify("/@id/__x00__" + pages.mdClientEntryId)};`);
+		}
+		lines.push("");
+		lines.push(`function getIslandsDevClientTags() {`);
+		lines.push(`  const preloads = \`<script type="module" src="/@vite/client"><\/script>\\n${BINDING_HINT_SCRIPT}\`;`);
+		lines.push(`  let bodyTag = \`<script type="module" src="\${escapeHtmlAttr(ISLANDS_CLIENT_ENTRY_URL)}"><\/script>\`;`);
+		if (pages.mdClientEntryId) lines.push(`  bodyTag += \`\\n<script type="module" src="\${escapeHtmlAttr(MD_CLIENT_ENTRY_URL)}"><\/script>\`;`);
+		lines.push(`  return { css: "", preloads, body: bodyTag };`);
+		lines.push(`}`);
+		lines.push("");
+		lines.push(`async function getIslandsAssetTags(request, env, componentId) {`);
+		lines.push(`  const manifest = await loadPagesManifest(request, env);`);
+		lines.push(`  if (!manifest || typeof manifest !== "object") {`);
+		lines.push(`    if (!import.meta.env.DEV) return { css: "", preloads: "", body: "" };`);
+		lines.push(`    return getIslandsDevClientTags();`);
+		lines.push(`  }`);
+		lines.push(`  const entry = manifest[ISLANDS_CLIENT_ENTRY_ID];`);
+		lines.push(`  if (!entry || typeof entry !== "object" || typeof entry.file !== "string") {`);
+		lines.push(`    return { css: "", preloads: "", body: "" };`);
+		lines.push(`  }`);
+		lines.push(`  const ids = collectPagesManifestFiles(manifest, ISLANDS_CLIENT_ENTRY_ID);`);
+		if (pages.mdClientEntryId) {
+			lines.push(`  const mdEntry = manifest[MD_CLIENT_ENTRY_ID];`);
+			lines.push(`  if (mdEntry && typeof mdEntry.file === "string") {`);
+			lines.push(`    const mdIds = collectPagesManifestFiles(manifest, MD_CLIENT_ENTRY_ID);`);
+			lines.push(`    for (const mdId of mdIds) ids.push(mdId);`);
+			lines.push(`  }`);
+		}
+		lines.push(`  const pageKeys = componentId ? (PAGE_CSS_KEYS[componentId] || []) : [];`);
+		lines.push(`  const cssFiles = collectRouteCss(manifest, ISLANDS_CLIENT_ENTRY_ID, pageKeys);`);
+		if (pages.mdClientEntryId) {
+			lines.push(`  if (mdEntry && typeof mdEntry.file === "string") {`);
+			lines.push(`    const mdKeys = [];`);
+			lines.push(`    const mdCss = collectRouteCss(manifest, MD_CLIENT_ENTRY_ID, mdKeys);`);
+			lines.push(`    for (const f of mdCss) cssFiles.add(f);`);
+			lines.push(`  }`);
+		}
+		lines.push(`  const preloadFiles = new Set();`);
+		lines.push(`  for (const id of ids) {`);
+		lines.push(`    const chunk = manifest[id];`);
+		lines.push(`    if (!chunk || typeof chunk !== "object") continue;`);
+		const excludeFromPreload = pages.mdClientEntryId ? `id !== ISLANDS_CLIENT_ENTRY_ID && id !== MD_CLIENT_ENTRY_ID` : `id !== ISLANDS_CLIENT_ENTRY_ID`;
+		lines.push(`    if (${excludeFromPreload} && typeof chunk.file === "string") {`);
+		lines.push(`      preloadFiles.add(chunk.file);`);
+		lines.push(`    }`);
+		lines.push(`  }`);
+		lines.push(`  const cssTags = [];`);
+		lines.push(`  for (const cssFile of cssFiles) {`);
+		lines.push(`    cssTags.push(\`<link rel="stylesheet" href="/\${escapeHtmlAttr(cssFile)}">\`);`);
+		lines.push(`  }`);
+		lines.push(`  const preloadTags = [];`);
+		lines.push(`  for (const preloadFile of preloadFiles) {`);
+		lines.push(`    preloadTags.push(\`<link rel="modulepreload" href="/\${escapeHtmlAttr(preloadFile)}">\`);`);
+		lines.push(`  }`);
+		lines.push(`  let bodyTag = \`<script type="module" src="/\${escapeHtmlAttr(entry.file)}"><\/script>\`;`);
+		if (pages.mdClientEntryId) {
+			lines.push(`  if (mdEntry && typeof mdEntry.file === "string") {`);
+			lines.push(`    bodyTag += \`\\n<script type="module" src="/\${escapeHtmlAttr(mdEntry.file)}"><\/script>\`;`);
+			lines.push(`  }`);
+		}
+		lines.push(`  return { css: cssTags.join("\\n"), preloads: preloadTags.join("\\n"), body: bodyTag };`);
+		lines.push(`}`);
+		lines.push("");
+	}
+	const seenServerFiles = /* @__PURE__ */ new Set();
+	for (const page of scan.pages.pages) {
+		const safeId = page.componentId.replace(/[^a-zA-Z0-9]/g, "_");
+		let serverImportPath = null;
+		if (page.serverPath) serverImportPath = `${pages.pagesDir}/${page.serverPath}`;
+		if (serverImportPath && !seenServerFiles.has(serverImportPath)) {
+			seenServerFiles.add(serverImportPath);
+			const varName = `_pmod_${safeId}`;
+			const loaderName = `_pload_${safeId}`;
+			lines.push(`let ${varName};`);
+			lines.push(`async function ${loaderName}() {`);
+			lines.push(`  if (!${varName}) ${varName} = await import(${JSON.stringify(serverImportPath)});`);
+			lines.push(`  return ${varName};`);
+			lines.push(`}`);
+		}
+		let mdHeadRef = null;
+		if (!serverImportPath && page.metadata && (page.metadata.title || page.metadata.description)) {
+			const headObj = {};
+			if (page.metadata.title) headObj.title = page.metadata.title;
+			if (page.metadata.description) headObj.meta = [{
+				name: "description",
+				content: page.metadata.description
+			}];
+			const headVarName = `__mdHead_${safeId}`;
+			lines.push(`const ${headVarName} = () => (${JSON.stringify(headObj)});`);
+			mdHeadRef = headVarName;
+		}
+		const renderer = page.island ? "renderIslandPage" : "renderPage";
+		const assetTags = page.island && pages.islandClientEntryId ? "getIslandsAssetTags" : "getPagesAssetTags";
+		const islandFlag = page.island ? ", true" : "";
+		lines.push(`app.get(${JSON.stringify(page.pattern)}, async (c) => {`);
+		if (serverImportPath) {
+			const loaderName = `_pload_${safeId}`;
+			lines.push(`  const mod = await ${loaderName}();`);
+			lines.push(`  return handlePageGet(mod.loader, mod.head, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${islandFlag});`);
+		} else {
+			const headArg = mdHeadRef ?? "undefined";
+			lines.push(`  return handlePageGet(undefined, ${headArg}, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${islandFlag});`);
+		}
+		lines.push(`});`);
+		if (page.methods.includes("action") || page.methods.includes("actions")) {
+			const loaderName = `_pload_${safeId}`;
+			lines.push(`app.on(["POST", "PUT", "PATCH", "DELETE"], ${JSON.stringify(page.pattern)}, async (c) => {`);
+			lines.push(`  const mod = await ${loaderName}();`);
+			if (page.methods.includes("actions")) {
+				lines.push(`  const actionName = new URL(c.req.url).searchParams.keys().next().value;`);
+				lines.push(`  const handler = actionName ? mod.actions?.[actionName] : mod.actions?.default;`);
+				lines.push(`  if (!handler) return new Response("Unknown action" + (actionName ? ": " + actionName : ""), { status: 404 });`);
+			} else lines.push(`  const handler = mod.action;`);
+			lines.push(`  return handlePageMutation(handler, mod.loader, mod.head, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${islandFlag});`);
+			lines.push(`});`);
+		}
+	}
+	lines.push("");
+	lines.push(`async function fetchPagesAsset(c) {`);
+	lines.push(`  if (c.req.method !== "GET" && c.req.method !== "HEAD") {`);
+	lines.push(`    return new Response("Not Found", { status: 404 });`);
+	lines.push(`  }`);
+	lines.push(`  const assets = c.env?.ASSETS;`);
+	lines.push(`  if (!assets || typeof assets.fetch !== "function") {`);
+	lines.push(`    return __voidMarkNoMatch(c.req.raw, new Response("Not Found", { status: 404 }));`);
+	lines.push(`  }`);
+	lines.push(`  return assets.fetch(c.req.raw);`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`async function serveCustomErrorPage(c, status, fallbackText, error) {`);
+	lines.push(`  try {`);
+	lines.push(`    const assets = c.env?.ASSETS;`);
+	lines.push(`    if (assets && typeof assets.fetch === "function") {`);
+	lines.push(`      const errReq = new Request(new URL("/" + status + ".html", c.req.url));`);
+	lines.push(`      const errRes = await assets.fetch(errReq);`);
+	lines.push(`      if (errRes.ok) {`);
+	lines.push(`        if (__VOID_DEV && status === 500 && error && __voidShouldServeHtmlErrorPage(c.req.raw)) {`);
+	lines.push(`          const overlay = __voidRenderDevErrorOverlay(c.req.raw, status, fallbackText, error);`);
+	lines.push(`          const html = await errRes.text();`);
+	lines.push(`          return new Response(c.req.method === "HEAD" ? null : __voidInjectDevErrorOverlay(html, overlay), {`);
+	lines.push(`            status,`);
+	lines.push(`            headers: { "content-type": "text/html; charset=utf-8" },`);
+	lines.push(`          });`);
+	lines.push(`        }`);
+	lines.push(`        return new Response(errRes.body, { status, headers: { "content-type": "text/html; charset=utf-8" } });`);
+	lines.push(`      }`);
+	lines.push(`    }`);
+	lines.push(`  } catch {}`);
+	lines.push(`  return __voidCreateErrorResponse(c.req.raw, status, fallbackText, error);`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`app.onError((err, c) => {`);
+	lines.push(`  if (err && typeof err === "object" && "getResponse" in err) return err.getResponse();`);
+	lines.push(`  console.error(err);`);
+	lines.push(`  return serveCustomErrorPage(c, 500, "Internal Server Error", err);`);
+	lines.push(`});`);
+	lines.push("");
+	lines.push(`app.notFound(async (c) => {`);
+	lines.push(`  const path = c.req.path;`);
+	lines.push(`  if (path === "/api" || path.startsWith("/api/")) {`);
+	lines.push(`    return c.text("Not Found", 404);`);
+	lines.push(`  }`);
+	lines.push(`  if (c.req.method !== "GET" && c.req.method !== "HEAD") {`);
+	lines.push(`    return c.text("Not Found", 404);`);
+	lines.push(`  }`);
+	lines.push(`  const assetRes = await fetchPagesAsset(c);`);
+	lines.push(`  if (assetRes.status !== 404) return assetRes;`);
+	if ((options.nodeTarget || options.dev === true) && options.fallbackRules?.length) emitFallbackRulesCheck(lines, options.fallbackRules, options.dev === true, "  ", options.nodeTarget === true);
+	lines.push(`  if (path.includes("/.")) {`);
+	lines.push(`    return serveCustomErrorPage(c, 404, "Not Found");`);
+	lines.push(`  }`);
+	lines.push(`  const lastSeg = path.substring(path.lastIndexOf("/") + 1);`);
+	lines.push(`  if (lastSeg.includes(".")) {`);
+	lines.push(`    return serveCustomErrorPage(c, 404, "Not Found");`);
+	lines.push(`  }`);
+	lines.push(`  if (path !== "/" && path.endsWith("/")) {`);
+	lines.push(`    const url = new URL(c.req.url);`);
+	lines.push(`    url.pathname = path.slice(0, -1);`);
+	lines.push(`    return Response.redirect(url.href, 301);`);
+	lines.push(`  }`);
+	lines.push(`  return __voidMarkNoMatch(c.req.raw, await serveCustomErrorPage(c, 404, "Not Found"));`);
+	lines.push(`});`);
+	lines.push("");
+}
+/**
+* Generate the Worker entry module code.
+* Re-exports the Hono app from the virtual module with an asset-serving
+* fallthrough: when the app returns 404, the entry tries env.ASSETS.fetch()
+* and adds proper Cache-Control headers (immutable for Vite-hashed /assets/*).
+*
+* When `hasQueues` is true, also exports a `queue()` handler that
+* serializes the native MessageBatch and dispatches it to the
+* `/__void/queue` Hono route. In local dev Miniflare delivers batches
+* natively to this export; in production the relay worker does it.
+*
+* When `remotePath` is provided, wraps the fetch handler to detect
+* remote mode (`__VOID_REMOTE`) and replace local bindings with
+* proxy-backed versions.
+*/
+function compileWorkerEntry(hasQueues = false, remote, assetsDir = "assets", webSocketClasses = [], runtimeEnvPath = "void/_env", envSchemaModule, sandbox, serveSpaFallback = false) {
+	const remotePath = remote?.remotePath;
+	const hasSandbox = sandbox === true || typeof sandbox === "object";
+	const sandboxClassName = typeof sandbox === "object" ? sandbox.className ?? "Sandbox" : "Sandbox";
+	const sandboxBindingName = typeof sandbox === "object" ? sandbox.bindingName ?? "SANDBOX" : "SANDBOX";
+	const sandboxRuntimePath = typeof sandbox === "object" ? sandbox.runtimePath ?? "void/sandbox" : "void/sandbox";
+	const sandboxImport = hasSandbox ? `import { Sandbox as __VoidSandbox } from "@cloudflare/sandbox";\nimport { __setSandboxBindingName } from ${JSON.stringify(sandboxRuntimePath)};\n` : "";
+	const sandboxExport = hasSandbox ? sandboxClassName === "Sandbox" ? `export { __VoidSandbox as Sandbox };\n__setSandboxBindingName(${JSON.stringify(sandboxBindingName)});\n` : `export class ${sandboxClassName} extends __VoidSandbox {}\n__setSandboxBindingName(${JSON.stringify(sandboxBindingName)});\n` : "";
+	const runtimeEnvImport = `import { withRuntimeEnv } from ${JSON.stringify(runtimeEnvPath)};\n`;
+	const remoteImport = remote ? `import { createRemoteEnv } from ${JSON.stringify(remote.remotePath)};\n` : "";
+	const envSchemaImport = envSchemaModule ? `import ${JSON.stringify(envSchemaModule.importPath)};\nimport { _validateEnvOnce } from ${JSON.stringify(envSchemaModule.helperPath)};\n` : "";
+	const envValidateCall = envSchemaModule ? "  await _validateEnvOnce(env);\n" : "";
+	const prefixCheck = INTERNAL_BINDING_PREFIXES.map((p) => `prop.startsWith(${JSON.stringify(p)})`).join(" || ");
+	const filterBindingsHelper = `
+function __filterInternalBindings(env) {
+  return new Proxy(env, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && (${prefixCheck})) return undefined;
+      return Reflect.get(target, prop, receiver);
+    },
+    has(target, prop) {
+      if (typeof prop === "string" && (${prefixCheck})) return false;
+      return Reflect.has(target, prop);
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target).filter(
+        (key) => typeof key !== "string" || (${INTERNAL_BINDING_PREFIXES.map((p) => `!key.startsWith(${JSON.stringify(p)})`).join(" && ")})
+      );
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (typeof prop === "string" && (${prefixCheck})) return undefined;
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    },
+  });
+}
+`;
+	const spaFallbackCode = serveSpaFallback ? `  // SPA fallback: when routes/middleware make assetConfig.not_found_handling
+  // = 'none', the asset binding returns 404 instead of falling back to
+  // index.html itself. Do that fallback here, after user routes/middleware
+  // have run, so auth gates and OAuth callbacks see the request first.
+  // Pages and SSR apps leave this disabled so intentional HTML 404s stay 404.
+  const accept = request.headers.get("accept") ?? "";
+  if (accept.includes("text/html")) {
+    const indexUrl = new URL("/index.html", request.url);
+    const indexAsset = await env.ASSETS.fetch(new Request(indexUrl, { method: request.method }));
+    if (indexAsset.status === 200) {
+      const res = new Response(indexAsset.body, {
+        status: 200,
+        headers: indexAsset.headers,
+      });
+      res.headers.set("Cache-Control", "no-store");
+      res.headers.set("Content-Type", "text/html; charset=utf-8");
+      return res;
+    }
+  }
+  return response;` : `  return response;`;
+	const assetHelper = `
+async function serveWithAssets(request, env, response) {
+  if (response.status !== 404 || !env.ASSETS || (request.method !== "GET" && request.method !== "HEAD")) return response;
+  const asset = await env.ASSETS.fetch(new Request(request.url, { method: request.method, headers: request.headers }));
+  if (asset.status !== 404) {
+    const res = new Response(asset.body, asset);
+    if (new URL(request.url).pathname.startsWith(${JSON.stringify("/" + assetsDir + "/")})) {
+      res.headers.set("Cache-Control", "public, max-age=31536000, immutable");
+    } else {
+      res.headers.set("Cache-Control", "no-store");
+    }
+    return res;
+  }
+${spaFallbackCode}
+}
+`;
+	const fetchHandler = remotePath ? `async (request, env, ctx) => {
+${envValidateCall}  const ws = await __voidHandleWebSocket(request, env);
+  if (ws) return ws;
+  if (env.__VOID_REMOTE === "1") env = createRemoteEnv(env);
+  return __withRawEnv(env, () => {
+    const userEnv = __filterInternalBindings(env);
+    return withRuntimeEnv(env, async () => {
+      const internal = await __handleInternal(request, env, ctx);
+      if (internal) return internal;
+      return serveWithAssets(request, env, await app.fetch(request, userEnv, ctx));
+    });
+  });
+}` : `async (request, env, ctx) => {
+${envValidateCall}  const ws = await __voidHandleWebSocket(request, env);
+  if (ws) return ws;
+  return __withRawEnv(env, () => {
+    const userEnv = __filterInternalBindings(env);
+    return withRuntimeEnv(env, async () => {
+      const internal = await __handleInternal(request, env, ctx);
+      if (internal) return internal;
+      return serveWithAssets(request, env, await app.fetch(request, userEnv, ctx));
+    });
+  });
+}`;
+	const internalRouteHelper = `async function __handleInternal(request, env, ctx) {
+  const url = new URL(request.url);
+  // Readiness probe — platform polls this to confirm the worker is live after WfP upload.
+  // Handled here (before app.fetch) so user middleware cannot block it.
+  if (request.method === "GET" && url.pathname === "/__void/ready") {
+    return Response.json({ ready: true });
+  }
+  if (request.method !== "POST" || url.pathname !== "/__void/prerender-paths") return null;
+  const __expected = env.__VOID_PROXY_TOKEN;
+  if (__expected) {
+    const __token = request.headers.get("x-void-internal");
+    if (!__token || __token !== __expected) {
+      return Response.json({ error: "unauthorized" }, { status: 401 });
+    }
+  }
+  const paths = await __voidCollectPrerenderPaths(request, env, ctx);
+  return Response.json({ paths });
+}`;
+	const scheduledHandler = remotePath ? `async function handleScheduled(controller, env, ctx) {
+${envValidateCall}  if (env.__VOID_REMOTE === "1") env = createRemoteEnv(env);
+  const userEnv = __filterInternalBindings(env);
+  return withRuntimeEnv(env, () => scheduled(controller, userEnv, ctx));
+}` : `async function handleScheduled(controller, env, ctx) {
+${envValidateCall}  const userEnv = __filterInternalBindings(env);
+  return withRuntimeEnv(env, () => scheduled(controller, userEnv, ctx));
+}`;
+	if (hasQueues) return `${sandboxImport}import app, { scheduled, __voidCollectPrerenderPaths, __voidHandleWebSocket, __withRawEnv, __processQueue${webSocketClasses.length > 0 ? `, ${webSocketClasses.join(", ")}` : ""} } from 'virtual:void-routes';
+${runtimeEnvImport}${envSchemaImport}${remoteImport}${filterBindingsHelper}${assetHelper}
+${internalRouteHelper}
+${scheduledHandler}
+async function queue(batch, env, ctx) {
+${envValidateCall}${remotePath ? `  if (env.__VOID_REMOTE === "1") env = createRemoteEnv(env);\n` : ""}  const userEnv = __filterInternalBindings(env);
+  const messages = [...batch.messages].map(m => ({
+    id: m.id, timestamp: m.timestamp.toISOString(),
+    body: m.body, attempts: m.attempts,
+  }));
+  const payload = { queue: batch.queue, messages };
+  const __qr = await __withRawEnv(env, () => withRuntimeEnv(env, () => __processQueue(payload, userEnv)));
+  if (__qr.decisions) {
+    const __msgMap = new Map();
+    for (const m of batch.messages) __msgMap.set(m.id, m);
+    for (const [id, d] of Object.entries(__qr.decisions)) {
+      const m = __msgMap.get(id);
+      if (!m) continue;
+      if (d.action === "ack") m.ack();
+      else if (d.action === "retry") m.retry(d.delaySeconds != null ? { delaySeconds: d.delaySeconds } : undefined);
+    }
+  }
+  if (!__qr.ok) throw new Error("queue: Handler failed.");
+}
+
+${webSocketClasses.map((name) => `export { ${name} };`).join("\n")}
+${sandboxExport}
+export default { fetch: ${fetchHandler}, scheduled: handleScheduled, queue };`;
+	return `${sandboxImport}import app, { scheduled, __voidCollectPrerenderPaths, __voidHandleWebSocket, __withRawEnv${webSocketClasses.length > 0 ? `, ${webSocketClasses.join(", ")}` : ""} } from 'virtual:void-routes';
+${runtimeEnvImport}${envSchemaImport}${remoteImport}${filterBindingsHelper}${assetHelper}
+${internalRouteHelper}
+${scheduledHandler}
+${webSocketClasses.map((name) => `export { ${name} };`).join("\n")}
+${sandboxExport}
+export default { fetch: ${fetchHandler}, scheduled: handleScheduled };`;
+}
+/**
+* Generate the app module — exports the Hono app with static asset serving.
+* This is the entry imported by `vite preview` and can be used programmatically.
+*
+* When `envSchemaModule` is provided, splices boot-time env validation so it
+* runs on the first request (including the prerender child process spawned
+* by `prerenderPagesNode`). Mirrors `compileWorkerEntry`: a side-effect import
+* registers the schema, and `_validateEnvOnce` throws `EnvValidationError` on
+* bad values. Env source on Node/Bun is `process.env`; on Deno it's
+* `Deno.env.toObject()`.
+*/
+function compileNodeApp(target, honoPath, envSchemaModule) {
+	const staticImport = target === "bun" ? `import { serveStatic } from "hono/bun";` : target === "deno" ? `import { serveStatic } from "hono/deno";` : `import { serveStatic } from "@hono/node-server/serve-static";`;
+	const envSchemaImport = envSchemaModule ? `import ${JSON.stringify(envSchemaModule.importPath)};\nimport { _validateEnvOnce } from ${JSON.stringify(envSchemaModule.helperPath)};\n` : "";
+	const envMiddleware = envSchemaModule ? `app.use("*", async (c, next) => { await _validateEnvOnce(${target === "deno" ? "Deno.env.toObject()" : "process.env"}); return next(); });\n` : "";
+	return `${staticImport}
+import { Hono } from ${JSON.stringify(honoPath)};
+import innerApp, { __voidCollectPrerenderPaths } from "virtual:void-routes";
+${envSchemaImport}
+const app = new Hono();
+${envMiddleware}app.post("/__void/prerender-paths", async (c) => {
+  const __expected = c.env?.__VOID_PROXY_TOKEN;
+  if (__expected) {
+    const __token = c.req.header("x-void-internal");
+    if (!__token || __token !== __expected) return c.json({ error: "unauthorized" }, 401);
+  }
+  const paths = await __voidCollectPrerenderPaths(c.req.raw);
+  return c.json({ paths });
+});
+app.use("/assets/*", serveStatic({ root: "./client" }));
+app.all("*", (c) => innerApp.fetch(c.req.raw));
+export default app;`;
+}
+/**
+* Generate the server entry — imports the app and starts an HTTP server.
+* This is what users run with `node dist/ssr/index.js`.
+*/
+function compileNodeServer(target) {
+	if (target === "bun") return `import app from "./app.js";
+
+const port = Number(process.env.PORT || 3000);
+Bun.serve({ fetch: app.fetch, port });
+console.log("Listening on http://localhost:" + port);`;
+	if (target === "deno") return `import app from "./app.js";
+
+const port = Number(Deno.env.get("PORT") || 3000);
+Deno.serve({ port }, app.fetch);`;
+	return `import { serve } from "@hono/node-server";
+import app from "./app.js";
+
+const port = Number(process.env.PORT || 3000);
+serve({ fetch: app.fetch, port }, (info) => {
+  console.log("Listening on http://localhost:" + info.port);
+});`;
+}
+/**
+* Generate the server-side fetch client module for non-CF targets.
+* Same as compileWorkerClient but without cloudflare:workers dependency.
+* Calls app.fetch() directly (no HTTP round-trip) with ALS context forwarding.
+*/
+function compileBrowserClient(authClientPath, fetchPath, fetchStreamPath) {
+	return `export { fetch, FetchError } from ${JSON.stringify(fetchPath)};
+export { fetchStream, StreamError } from ${JSON.stringify(fetchStreamPath)};
+export { auth, createAuthClient } from ${JSON.stringify(authClientPath)};`;
+}
+function compileNodeClient(authClientPath) {
+	return `import app, { requestContext } from "virtual:void-routes";
+export { auth, createAuthClient } from ${JSON.stringify(authClientPath)};
+
+export class FetchError extends Error {
+  constructor(status, statusText, data) {
+    super(\`fetch: Request failed with status \${status}.\`);
+    this.name = "FetchError";
+    this.status = status;
+    this.statusText = statusText;
+    this.data = data;
+  }
+}
+
+export async function fetch(path, options) {
+  let url = path;
+  if (options?.params) {
+    for (const [key, value] of Object.entries(options.params)) {
+      url = url.replace(":" + key, encodeURIComponent(value));
+    }
+  }
+
+  if (options?.query) {
+    const qs = new URLSearchParams(options.query).toString();
+    if (qs) url += "?" + qs;
+  }
+
+  const method = options?.method ?? "GET";
+  const headers = new Headers(options?.headers);
+
+  const store = requestContext.getStore();
+  if (store?.request) {
+    const outerReq = store.request;
+    if (!headers.has("cookie")) {
+      const cookie = outerReq.headers.get("cookie");
+      if (cookie) headers.set("cookie", cookie);
+    }
+    if (!headers.has("authorization")) {
+      const auth = outerReq.headers.get("authorization");
+      if (auth) headers.set("authorization", auth);
+    }
+  }
+
+  if (options?.body != null && !headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+
+  const request = new Request("http://localhost" + url, {
+    method,
+    headers,
+    body: options?.body != null ? JSON.stringify(options.body) : undefined,
+  });
+
+  const response = await app.fetch(request);
+
+  if (response.status === 204) return undefined;
+
+  const contentType = response.headers.get("content-type") ?? "";
+  const data = contentType.includes("application/json") ? await response.json() : await response.text();
+
+  if (!response.ok) {
+    throw new FetchError(response.status, response.statusText, data);
+  }
+
+  return data;
+}`;
+}
+/**
+* Emit inline `__compilePattern()` and `__matchPattern()` — pattern compilation
+* with named captures, matching the dispatch worker's behavior in
+* `packages/dispatch/src/pattern.ts`.
+*
+* Syntax:
+*   :name    — single path segment (captured as `name`)
+*   :name*   — zero or more segments (captured as `name`)
+*   *        — zero or more segments (captured as `splat`, legacy)
+*
+* When a pattern contains multiple bare `*`, only the first captures as
+* `splat`; later occurrences emit a non-capturing `.*` so the constructed
+* `RegExp` doesn't reject "duplicate group name" at request time. `:name*`
+* uses a distinct group name and never clashes with `*`. `__matchPattern`
+* additionally swallows any compile-time `RegExp` error and returns `false`
+* so a single malformed rule cannot 500 unrelated requests on CF dev.
+*/
+function emitCompilePattern(lines) {
+	lines.push("function __compilePattern(source) {");
+	lines.push("  const names = [];");
+	lines.push("  let legacySplatCaptured = false;");
+	lines.push("  let pattern = \"\";");
+	lines.push("  let i = 0;");
+	lines.push("  while (i < source.length) {");
+	lines.push("    const ch = source[i];");
+	lines.push("    if (ch === \":\") {");
+	lines.push("      let j = i + 1;");
+	lines.push("      while (j < source.length && /[A-Za-z0-9_]/.test(source[j])) j++;");
+	lines.push("      const name = source.slice(i + 1, j);");
+	lines.push("      if (!name) { pattern += \"\\\\:\"; i++; continue; }");
+	lines.push("      if (source[j] === \"*\") {");
+	lines.push("        names.push(name);");
+	lines.push("        pattern += `(?<${name}>.*)`;");
+	lines.push("        i = j + 1;");
+	lines.push("      } else {");
+	lines.push("        names.push(name);");
+	lines.push("        pattern += `(?<${name}>[^/]+)`;");
+	lines.push("        i = j;");
+	lines.push("      }");
+	lines.push("    } else if (ch === \"*\") {");
+	lines.push("      if (legacySplatCaptured) {");
+	lines.push("        pattern += \".*\";");
+	lines.push("      } else {");
+	lines.push("        names.push(\"splat\");");
+	lines.push("        pattern += \"(?<splat>.*)\";");
+	lines.push("        legacySplatCaptured = true;");
+	lines.push("      }");
+	lines.push("      i++;");
+	lines.push("    } else {");
+	lines.push("      if (/[.+?^${}()|[\\]\\\\]/.test(ch)) pattern += \"\\\\\";");
+	lines.push("      pattern += ch;");
+	lines.push("      i++;");
+	lines.push("    }");
+	lines.push("  }");
+	lines.push("  return { regex: new RegExp(`^${pattern}$`), names };");
+	lines.push("}");
+	lines.push("const __matchPatternWarned = new Set();");
+	lines.push("function __matchPattern(pattern, pathname) {");
+	lines.push("  try {");
+	lines.push("    return __compilePattern(pattern).regex.test(pathname);");
+	lines.push("  } catch (err) {");
+	lines.push("    if (!__matchPatternWarned.has(pattern)) {");
+	lines.push("      __matchPatternWarned.add(pattern);");
+	lines.push("      console.warn(`[void] failed to compile route pattern ${JSON.stringify(pattern)}: ${err && err.message ? err.message : err}`);");
+	lines.push("    }");
+	lines.push("    return false;");
+	lines.push("  }");
+	lines.push("}");
+	lines.push("function __substituteParams(destination, params) {");
+	lines.push("  return destination.replace(/:([A-Za-z0-9_]+)\\*?/g, (whole, name) => {");
+	lines.push("    return params[name] != null ? params[name] : whole;");
+	lines.push("  });");
+	lines.push("}");
+	lines.push("");
+}
+function ensureCompilePatternEmitted(lines) {
+	if (!lines.some((l) => l.includes("function __compilePattern"))) emitCompilePattern(lines);
+}
+/**
+* Emit the `__mergeQueryIntoLocation` helper. Shared between the static
+* routing-rules middleware (for `_redirects` entries) and the dynamic
+* `c.redirect` wrapper, so it's emitted unconditionally above the rewrite
+* middleware. If the destination already carries a param, the destination
+* wins — matching the static-redirect semantics.
+*/
+function ensureMergeQueryHelperEmitted(lines) {
+	if (lines.some((l) => l.includes("function __mergeQueryIntoLocation"))) return;
+	lines.push("function __mergeQueryIntoLocation(destination, search) {");
+	lines.push("  if (!search || search === \"?\") return destination;");
+	lines.push("  const fragIdx = destination.indexOf(\"#\");");
+	lines.push("  const base = fragIdx === -1 ? destination : destination.slice(0, fragIdx);");
+	lines.push("  const fragment = fragIdx === -1 ? \"\" : destination.slice(fragIdx);");
+	lines.push("  const q = base.indexOf(\"?\");");
+	lines.push("  if (q === -1) return base + search + fragment;");
+	lines.push("  if (q === base.length - 1) return base.slice(0, q) + fragment;");
+	lines.push("  const dp = new URLSearchParams(base.slice(q + 1));");
+	lines.push("  for (const [k, v] of new URLSearchParams(search)) {");
+	lines.push("    if (!dp.has(k)) dp.append(k, v);");
+	lines.push("  }");
+	lines.push("  return base.slice(0, q) + \"?\" + dp.toString() + fragment;");
+	lines.push("}");
+	lines.push("");
+}
+/**
+* Shared body for routing-rule evaluation: match rules in order (last wins),
+* substitute captures into destination, handle rewrite (200) or redirect (3xx).
+* Used by both the pre-pipeline routing middleware and the post-pipeline
+* fallback (notFound) middleware.
+*/
+function emitApplyRoutingRules(lines, rulesVar, indent, nodeTarget, markFallbackHandled = false) {
+	lines.push(`${indent}let matched;`);
+	lines.push(`${indent}for (const rule of ${rulesVar}) {`);
+	lines.push(`${indent}  if (rule.host && rule.host !== requestHost) continue;`);
+	lines.push(`${indent}  let regex;`);
+	lines.push(`${indent}  try {`);
+	lines.push(`${indent}    ({ regex } = __compilePattern(rule.source));`);
+	lines.push(`${indent}  } catch (err) {`);
+	lines.push(`${indent}    if (!__matchPatternWarned.has(rule.source)) {`);
+	lines.push(`${indent}      __matchPatternWarned.add(rule.source);`);
+	lines.push(`${indent}      console.warn(\`[void] skipping routing rule with invalid source \${JSON.stringify(rule.source)}: \${err && err.message ? err.message : err}\`);`);
+	lines.push(`${indent}    }`);
+	lines.push(`${indent}    continue;`);
+	lines.push(`${indent}  }`);
+	lines.push(`${indent}  const m = regex.exec(pathname);`);
+	lines.push(`${indent}  if (m) { matched = { rule, params: m.groups || {} }; break; }`);
+	lines.push(`${indent}}`);
+	lines.push(`${indent}if (matched) {`);
+	lines.push(`${indent}  const dest = __substituteParams(matched.rule.destination, matched.params);`);
+	lines.push(`${indent}  if (matched.rule.status === 200) {`);
+	lines.push(`${indent}    const __qIdx = dest.indexOf("?");`);
+	lines.push(`${indent}    const __pathOnly = __qIdx === -1 ? dest : dest.slice(0, __qIdx);`);
+	lines.push(`${indent}    const __searchOnly = __qIdx === -1 ? "" : dest.slice(__qIdx);`);
+	lines.push(`${indent}    const rewriteUrl = new URL(c.req.url);`);
+	lines.push(`${indent}    rewriteUrl.pathname = __pathOnly;`);
+	lines.push(`${indent}    if (__searchOnly) rewriteUrl.search = __searchOnly;`);
+	lines.push(`${indent}    const rewriteReq = new Request(rewriteUrl.toString(), c.req.raw);`);
+	lines.push(`${indent}    const __prior = __voidOriginalUrls.get(c.req.raw);`);
+	lines.push(`${indent}    __voidOriginalUrls.set(rewriteReq, __prior ?? new URL(c.req.url));`);
+	if (markFallbackHandled) lines.push(`${indent}    __voidFallbackHandled.add(rewriteReq);`);
+	if (nodeTarget) lines.push(`${indent}    const __r = await app.fetch(rewriteReq, c.env);`);
+	else lines.push(`${indent}    const __r = await app.fetch(rewriteReq, c.env, c.executionCtx);`);
+	lines.push(`${indent}    if (!__VOID_DEV_ROUTING) return __r;`);
+	lines.push(`${indent}    const __kind = matched.rule.force === true ? "rewrite" : "fallback";`);
+	lines.push(`${indent}    const __trace = __kind + "[" + matched.rule.source + "] \\u2192 " + dest + " (" + (matched.rule.origin || "unknown") + ")";`);
+	lines.push(`${indent}    return __voidAnnotateRouting(__r, __trace);`);
+	lines.push(`${indent}  }`);
+	lines.push(`${indent}  const location = __mergeQueryIntoLocation(dest, new URL(c.req.url).search);`);
+	lines.push(`${indent}  const __redir = c.redirect(location, matched.rule.status);`);
+	lines.push(`${indent}  if (!__VOID_DEV_ROUTING) return __redir;`);
+	lines.push(`${indent}  const __rtrace = "redirect[" + matched.rule.source + "] \\u2192 " + dest + " " + matched.rule.status + " (" + (matched.rule.origin || "unknown") + ")";`);
+	lines.push(`${indent}  return __voidAnnotateRouting(__redir, __rtrace);`);
+	lines.push(`${indent}}`);
+}
+/**
+* Strip dev-only `origin` metadata from a rule list before embedding in the
+* generated worker code. Keeps production bundles free of authoring hints.
+*
+* Keep in sync with `stripDevOnlyRuleFields` in `cli/package.ts`. This helper
+* intentionally preserves `force` because the Node/Bun/Deno-target codegen
+* reads it at runtime to label the `X-Void-Routing` trace header as either
+* `rewrite[...]` (force) or `fallback[...]`. The CLI version strips both
+* fields because the deploy manifest never transmits either to the dispatch
+* worker (phase is implied by which bucket the rule ships in).
+*/
+function stripOriginForProd(rules) {
+	return rules.map(({ origin: _origin, ...rest }) => rest);
+}
+/**
+* Emit routing rules middleware — handles both redirects (3xx) and rewrites (200).
+* Last match wins. Rewrites re-dispatch with a guard header to prevent loops.
+* Redirects preserve the request's query string in the Location header.
+*
+* When `dev === true` the per-rule `origin` metadata is preserved in the
+* compiled rule table and a matched rule's trace is emitted on the
+* `X-Void-Routing` response header. In production the origin field is
+* stripped and no trace header is emitted.
+*/
+function compileRoutingRulesMiddleware(lines, rules, dev, nodeTarget) {
+	ensureCompilePatternEmitted(lines);
+	lines.push("// Routing rules: redirects + rewrites (applied before route handlers)");
+	lines.push(`const __routingRules = ${JSON.stringify(dev ? rules : stripOriginForProd(rules))};`);
+	lines.push("app.use(\"*\", async (c, next) => {");
+	lines.push("  if (__voidOriginalUrls.has(c.req.raw)) return next();");
+	lines.push("  const __reqUrl = new URL(c.req.url);");
+	lines.push("  const pathname = __reqUrl.pathname;");
+	lines.push("  const requestHost = __reqUrl.hostname;");
+	emitApplyRoutingRules(lines, "__routingRules", "  ", nodeTarget);
+	if (dev) {
+		lines.push("  await next();");
+		lines.push("  if (__VOID_DEV_ROUTING && c.res && !c.res.headers.has(\"X-Void-Routing\")) {");
+		lines.push("    try { c.res.headers.set(\"X-Void-Routing\", \"pass-through\"); } catch {}");
+		lines.push("  }");
+	} else lines.push("  return next();");
+	lines.push("});");
+	lines.push("");
+}
+/**
+* Emit a fallback-rule check inside Hono's `notFound` hook. Fires only when
+* the pipeline didn't match a route — the "asset-miss / no route matched"
+* phase. Re-dispatches through `app.fetch` on a rule match so the re-dispatched
+* request runs through the full middleware + route stack with
+* `X-Void-Original-URL` set; falls through to the caller's existing notFound
+* body when no rule matches.
+*
+* Indent `indent` so the emitted statements nest cleanly within the caller's
+* block. Expects `__matchPattern`, `__voidOriginalUrls`, `__mergeQueryIntoLocation`,
+* `__substituteParams`, and `__voidAnnotateRouting` to already be in scope —
+* which they are, because `compileRoutingRulesMiddleware` runs earlier in
+* compile order and emits every one of them.
+*/
+function emitFallbackRulesCheck(lines, rules, dev, indent, nodeTarget) {
+	ensureCompilePatternEmitted(lines);
+	const tableMarker = "// Fallback rules (applied on no-match, post-route)";
+	if (!lines.includes(tableMarker)) {
+		lines.push(tableMarker);
+		lines.push(`const __fallbackRules = ${JSON.stringify(dev ? rules : stripOriginForProd(rules))};`);
+		lines.push("");
+	}
+	lines.push(`${indent}if (!__voidFallbackHandled.has(c.req.raw)) {`);
+	lines.push(`${indent}  const __reqUrl = new URL(c.req.url);`);
+	lines.push(`${indent}  const pathname = __reqUrl.pathname;`);
+	lines.push(`${indent}  const requestHost = __reqUrl.hostname;`);
+	emitApplyRoutingRules(lines, "__fallbackRules", `${indent}  `, nodeTarget, true);
+	lines.push(`${indent}}`);
+}
+/**
+* Emit header middleware — applies matching header rules to every response.
+* All matching rules merge; last match wins for same header name.
+*/
+function compileHeaderMiddleware(lines, rules) {
+	ensureCompilePatternEmitted(lines);
+	lines.push("// Header rules (applied to responses)");
+	lines.push(`const __headerRules = ${JSON.stringify(rules)};`);
+	lines.push("app.use(\"*\", async (c, next) => {");
+	lines.push("  await next();");
+	lines.push("  const pathname = new URL(c.req.url).pathname;");
+	lines.push("  const matched = [];");
+	lines.push("  for (const rule of __headerRules) {");
+	lines.push("    if (__matchPattern(rule.pattern, pathname)) matched.push(...rule.headers);");
+	lines.push("  }");
+	lines.push("  for (const [name, value] of matched) {");
+	lines.push("    c.res.headers.set(name, value);");
+	lines.push("  }");
+	lines.push("});");
+	lines.push("");
+}
+function compileWorkerClient(authClientPath) {
+	return `import app, { requestContext } from "virtual:void-routes";
+import { env } from "cloudflare:workers";
+export { auth, createAuthClient } from ${JSON.stringify(authClientPath)};
+
+export class FetchError extends Error {
+  constructor(status, statusText, data) {
+    super(\`fetch: Request failed with status \${status}.\`);
+    this.name = "FetchError";
+    this.status = status;
+    this.statusText = statusText;
+    this.data = data;
+  }
+}
+
+export async function fetch(path, options) {
+  let url = path;
+  if (options?.params) {
+    for (const [key, value] of Object.entries(options.params)) {
+      url = url.replace(":" + key, encodeURIComponent(value));
+    }
+  }
+
+  if (options?.query) {
+    const qs = new URLSearchParams(options.query).toString();
+    if (qs) url += "?" + qs;
+  }
+
+  const method = options?.method ?? "GET";
+  const headers = new Headers(options?.headers);
+
+  // Auto-forward cookie and authorization from the outer request via ALS
+  const store = requestContext.getStore();
+  if (store?.request) {
+    const outerReq = store.request;
+    if (!headers.has("cookie")) {
+      const cookie = outerReq.headers.get("cookie");
+      if (cookie) headers.set("cookie", cookie);
+    }
+    if (!headers.has("authorization")) {
+      const auth = outerReq.headers.get("authorization");
+      if (auth) headers.set("authorization", auth);
+    }
+  }
+
+  if (options?.body != null && !headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+
+  const request = new Request("http://worker.local" + url, {
+    method,
+    headers,
+    body: options?.body != null ? JSON.stringify(options.body) : undefined,
+  });
+
+  // Use real executionCtx from ALS if available, otherwise provide a no-op fallback
+  const executionCtx = store?.executionCtx ?? { waitUntil() {}, passThroughOnException() {} };
+  const response = await app.fetch(request, env, executionCtx);
+
+  if (response.status === 204) return undefined;
+
+  const contentType = response.headers.get("content-type") ?? "";
+  const data = contentType.includes("application/json") ? await response.json() : await response.text();
+
+  if (!response.ok) {
+    throw new FetchError(response.status, response.statusText, data);
+  }
+
+  return data;
+}
+`;
+}
+//#endregion
+//#region src/plugin-routing.ts
+const VIRTUAL_ROUTES_ID = "virtual:void-routes";
+const VIRTUAL_CLIENT_WORKER_ID = "virtual:void-client-worker";
+const VIRTUAL_CLIENT_BROWSER_ID = "virtual:void-client-browser";
+const RESOLVE_ID_FILTER = /^(virtual:void-(routes|client-worker|client-browser)|void(\/client|\/queues)?)$/;
+const LOAD_ID_FILTER = /^virtual:void-(routes|client-worker|client-browser)$/;
+function routingPlugin(root, options) {
+	let scan = null;
+	let ssr = null;
+	let authConfigPath = null;
+	const routesDir = join(root, "routes");
+	const middlewareDir = join(root, "middleware");
+	const jobsDir = join(root, "crons");
+	const queuesDir = join(root, "queues");
+	const pagesDir = join(root, "pages");
+	const srcDir = join(root, "src");
+	const authConfigDir = root;
+	const ssrEntryAbsPaths = new Set([...SSR_SERVER_ENTRY_RELATIVE_PATHS, ...SSR_CLIENT_ENTRY_RELATIVE_PATHS].map((path) => join(root, path)));
+	function writeRouteTypes() {
+		if (!scan) return;
+		const { dts } = generateRouteTypes(scan, routesDir, outDir, pagesDir);
+		writeFileSync(join(outDir, "routes.d.ts"), dts);
+	}
+	function writeQueueTypes() {
+		if (!scan) return;
+		const dts = generateQueueTypes(scan.queues, queuesDir, outDir);
+		writeFileSync(join(outDir, "queues.d.ts"), dts);
+	}
+	async function rescan() {
+		scan = await scanRoutes(root, { output: options.output });
+		authConfigPath = findVoidAuthConfig(root);
+		const entries = validateSsrEntries(root);
+		ssr = entries ? {
+			serverEntryPath: entries.server.absolutePath,
+			clientEntryRelativePath: entries.client.relativePath
+		} : null;
+	}
+	const resolveFile = (specifier) => fileURLToPath(import.meta.resolve(specifier));
+	const handlerFile = resolveFile("#self/handler");
+	const runtimeDir = dirname(resolveFile("#self/client"));
+	const fetchPath = resolveFile("#self/runtime/fetch");
+	const fetchStreamPath = resolveFile("#self/runtime/fetch-stream");
+	const sandboxRuntimePath = resolveFile("#self/sandbox");
+	const drizzleAdapterPath = resolveFile("better-auth/adapters/drizzle");
+	let authClientPath = join(runtimeDir, "auth-client.mjs");
+	const remote = options.remoteMode ? {
+		remotePath: resolveFile("#self/remote"),
+		envPath: resolveFile("#self/_env")
+	} : void 0;
+	function getEnvSchemaModule() {
+		const envFile = findEnvFile(root);
+		if (!envFile) return;
+		return {
+			importPath: envFile,
+			helperPath: resolveFile("#self/env")
+		};
+	}
+	const compileOptions = {
+		honoPath: resolveFile("hono"),
+		responsePath: resolveFile("#self/response"),
+		handlerPath: resolveFile("#self/handler"),
+		runtimeEnvPath: resolveFile("#self/_env"),
+		projectRoot: root,
+		homeDir: homedir(),
+		webSocketRuntimePath: resolveFile("#self/runtime/ws-server"),
+		reactRefresh: false,
+		dev: false,
+		devTriggerToken: options.devTriggerToken,
+		auth: null,
+		nodeTarget: !!options.target,
+		explicitPrerenderPaths: options.prerenderPaths,
+		bindingHandlerPath: options.target ? void 0 : resolveFile("#self/remote/binding-handler")
+	};
+	let publicDir = join(root, "public");
+	function reloadFileRules() {
+		const merged = mergeRoutingRules({
+			dir: publicDir,
+			routing: options.routing
+		});
+		lintDuplicateSources(merged.redirectRules, "redirects/rewrites (pre-asset)");
+		lintDuplicateSources(merged.fallbackRules, "fallbacks (post-asset)");
+		lintDestinationSplats(merged.redirectRules, "redirects/rewrites (pre-asset)");
+		lintDestinationSplats(merged.fallbackRules, "fallbacks (post-asset)");
+		compileOptions.headerRules = merged.headerRules.length > 0 ? merged.headerRules : void 0;
+		compileOptions.redirectRules = merged.redirectRules.length > 0 ? merged.redirectRules : void 0;
+		compileOptions.fallbackRules = merged.fallbackRules;
+	}
+	reloadFileRules();
+	function resolveAuthCompileOptions() {
+		if (!options.isAuthEnabled() && !authConfigPath) {
+			compileOptions.auth = null;
+			return;
+		}
+		const config = readConfig(root);
+		const dialect = getDatabaseDialect(config);
+		compileOptions.auth = {
+			authRuntimePath: dialect === "postgresql" ? join(runtimeDir, "better-auth-pg.mjs") : join(runtimeDir, "better-auth.mjs"),
+			authConfigPath,
+			authDatabasePath: null,
+			authSchemaPath: null,
+			dialect,
+			providers: config.auth?.providers ?? null
+		};
+	}
+	async function writeAuthDatabaseFiles() {
+		if (!compileOptions.auth) return;
+		const authRuntime = {
+			dialect: compileOptions.auth.dialect,
+			providers: compileOptions.auth.providers,
+			userConfig: await loadVoidAuthConfig(compileOptions.auth.authConfigPath)
+		};
+		const env = loadEnv(resolvedConfig?.mode ?? "development", root, "");
+		const schemaPath = join(outDir, "better-auth-schema.ts");
+		const databasePath = join(outDir, "better-auth-db.ts");
+		writeFileSync(schemaPath, generateVoidAuthDrizzleSchema(authRuntime, env));
+		writeFileSync(databasePath, generateVoidAuthDatabaseModule({
+			dialect: compileOptions.auth.dialect,
+			schemaImportPath: schemaPath,
+			drizzleAdapterPath
+		}));
+		compileOptions.auth.authSchemaPath = schemaPath;
+		compileOptions.auth.authDatabasePath = databasePath;
+	}
+	let resolvedConfig = null;
+	function resolveAuthClientPath(config) {
+		if (config.plugins.some((plugin) => plugin.name === "void-react:pages")) return join(runtimeDir, "auth-client-react.mjs");
+		if (config.plugins.some((plugin) => plugin.name === "void-vue:pages")) return join(runtimeDir, "auth-client-vue.mjs");
+		if (config.plugins.some((plugin) => plugin.name === "void-svelte:pages")) return join(runtimeDir, "auth-client-svelte.mjs");
+		if (config.plugins.some((plugin) => plugin.name === "void-solid:pages")) return join(runtimeDir, "auth-client-solid.mjs");
+		return join(runtimeDir, "auth-client.mjs");
+	}
+	function isPotentialAuthConfigPath(path) {
+		if (!path.startsWith(authConfigDir + "/")) return false;
+		const rel = path.slice(authConfigDir.length + 1);
+		return /^auth\.(c|m)?[jt]s$/.test(rel);
+	}
+	function getPagesCompileOptions() {
+		if (!scan || scan.pages.pages.length === 0) return null;
+		const hasIslandPages = scan.pages.pages.some((p) => p.island);
+		const mdPlugin = resolvedConfig?.plugins?.find((p) => p.name === "void-md");
+		const mdClientEntryId = hasIslandPages && mdPlugin?.api?.clientEntryId ? mdPlugin.api.clientEntryId : void 0;
+		return {
+			pagesDir,
+			pagesDirRelative: relative(root, pagesDir).replaceAll("\\", "/"),
+			protocolPath: resolveFile("#self/pages-protocol"),
+			headPath: resolveFile("#self/pages-head"),
+			clientEntryId: "virtual:void-pages-client",
+			islandClientEntryId: hasIslandPages ? "virtual:void-islands-client" : void 0,
+			mdClientEntryId,
+			headConfig: options.headConfig
+		};
+	}
+	function shouldServeSpaFallback() {
+		return !!scan && scan.pages.pages.length === 0 && !ssr && (scan.routes.length > 0 || (scan.websockets?.length ?? 0) > 0 || scan.middleware.length > 0 || compileOptions.auth !== null);
+	}
+	const outDir = join(root, ".void");
+	mkdirSync(outDir, { recursive: true });
+	if (options.target) {
+		writeFileSync(join(outDir, "app.ts"), compileNodeApp(options.target, compileOptions.honoPath, getEnvSchemaModule()));
+		writeFileSync(join(outDir, "index.ts"), compileNodeServer(options.target));
+	} else writeFileSync(join(outDir, "entry.ts"), compileWorkerEntry(false, remote, void 0, void 0, compileOptions.runtimeEnvPath, getEnvSchemaModule(), options.hasSandbox ? {
+		bindingName: options.sandboxBindingName,
+		className: options.sandboxClassName,
+		runtimePath: sandboxRuntimePath
+	} : false));
+	return {
+		name: "void:routing",
+		enforce: "pre",
+		configResolved(config) {
+			resolvedConfig = config;
+			authClientPath = resolveAuthClientPath(config);
+			compileOptions.dev = config.command === "serve";
+			compileOptions.reactRefresh = config.plugins.some((plugin) => plugin.name === "vite:react-babel" || plugin.name === "vite:react-refresh" || plugin.name === "vite:react-swc");
+			const resolvedPublicDir = config.publicDir && config.publicDir.length > 0 ? config.publicDir : null;
+			if (resolvedPublicDir !== publicDir) {
+				publicDir = resolvedPublicDir;
+				reloadFileRules();
+			}
+		},
+		config(_, env) {
+			if (env.command === "serve" && options.isAuthEnabled()) return { resolve: { alias: [
+				"client",
+				"react",
+				"vue",
+				"svelte",
+				"solid"
+			].flatMap((sub) => {
+				try {
+					return [{
+						find: `better-auth/${sub}`,
+						replacement: resolveFile(`better-auth/${sub}`)
+					}];
+				} catch {
+					return [];
+				}
+			}) } };
+			const entries = validateSsrEntries(root);
+			if (!entries || env.command !== "build") return;
+			return { build: {
+				manifest: true,
+				rollupOptions: { input: entries.client.absolutePath }
+			} };
+		},
+		async buildStart() {
+			await rescan();
+			if (options.target && (scan?.websockets?.length ?? 0) > 0) throw new Error("routing: WebSocket routes require the default Cloudflare target.");
+			resolveAuthCompileOptions();
+			await writeAuthDatabaseFiles();
+			writeRouteTypes();
+			writeQueueTypes();
+			if (!options.target) {
+				const migrationsDir = join(root, "db", "migrations");
+				if (existsSync(migrationsDir) || compileOptions.auth) {
+					const { collectMigrations } = await import("./collect-CjeZgz5D.mjs").then((n) => n.n);
+					const migrations = existsSync(migrationsDir) ? collectMigrations(migrationsDir) : [];
+					const dialect = getDatabaseDialect(readConfig(root));
+					compileOptions.migrationHandlerPath = resolveFile(dialect === "postgresql" ? "#self/runtime/migration-handler-pg" : "#self/runtime/migration-handler");
+					compileOptions.migrations = migrations;
+					compileOptions.migrationDialect = dialect;
+				}
+			}
+			if (options.target) {
+				writeFileSync(join(outDir, "app.ts"), compileNodeApp(options.target, compileOptions.honoPath, getEnvSchemaModule()));
+				writeFileSync(join(outDir, "index.ts"), compileNodeServer(options.target));
+			} else writeFileSync(join(outDir, "entry.ts"), compileWorkerEntry(scan.queues.length > 0, remote, resolvedConfig?.build.assetsDir, (scan.websockets ?? []).map((route) => route.className), compileOptions.runtimeEnvPath, getEnvSchemaModule(), options.hasSandbox ? {
+				bindingName: options.sandboxBindingName,
+				className: options.sandboxClassName,
+				runtimePath: sandboxRuntimePath
+			} : false, shouldServeSpaFallback()));
+		},
+		resolveId: {
+			filter: { id: RESOLVE_ID_FILTER },
+			handler(id) {
+				if (id === VIRTUAL_ROUTES_ID) return VIRTUAL_ROUTES_ID;
+				if (id === VIRTUAL_CLIENT_WORKER_ID) return VIRTUAL_CLIENT_WORKER_ID;
+				if (id === VIRTUAL_CLIENT_BROWSER_ID) return VIRTUAL_CLIENT_BROWSER_ID;
+				if (id === "void") return handlerFile;
+				if (id === "void/queues") return resolveFile("#self/queues");
+				if (id === "void/client") return this.environment?.name === "client" ? VIRTUAL_CLIENT_BROWSER_ID : VIRTUAL_CLIENT_WORKER_ID;
+			}
+		},
+		load: {
+			filter: { id: LOAD_ID_FILTER },
+			async handler(id) {
+				if (id === VIRTUAL_CLIENT_BROWSER_ID) return compileBrowserClient(authClientPath, fetchPath, fetchStreamPath);
+				if (id === VIRTUAL_CLIENT_WORKER_ID) {
+					if (options.target) return compileNodeClient(authClientPath);
+					return compileWorkerClient(authClientPath);
+				}
+				if (id !== VIRTUAL_ROUTES_ID) return;
+				if (!scan) await rescan();
+				return compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, ssr, compileOptions, getPagesCompileOptions());
+			}
+		},
+		configureServer(devServer) {
+			const watcher = devServer.watcher;
+			const handleFileChange = async (path, event) => {
+				if (!path.startsWith(routesDir) && !path.startsWith(middlewareDir) && !path.startsWith(jobsDir) && !path.startsWith(queuesDir) && !path.startsWith(pagesDir) && !path.startsWith(srcDir) && !isPotentialAuthConfigPath(path)) return;
+				if (path.startsWith(srcDir) && !ssrEntryAbsPaths.has(path)) return;
+				await rescan();
+				resolveAuthCompileOptions();
+				await writeAuthDatabaseFiles();
+				writeRouteTypes();
+				writeQueueTypes();
+				if (options.target) {
+					writeFileSync(join(outDir, "app.ts"), compileNodeApp(options.target, compileOptions.honoPath, getEnvSchemaModule()));
+					writeFileSync(join(outDir, "index.ts"), compileNodeServer(options.target));
+				} else writeFileSync(join(outDir, "entry.ts"), compileWorkerEntry(scan.queues.length > 0, remote, resolvedConfig?.build.assetsDir, (scan.websockets ?? []).map((route) => route.className), compileOptions.runtimeEnvPath, getEnvSchemaModule(), options.hasSandbox ? {
+					bindingName: options.sandboxBindingName,
+					className: options.sandboxClassName,
+					runtimePath: sandboxRuntimePath
+				} : false, shouldServeSpaFallback()));
+				const structural = event !== "change";
+				for (const env of Object.values(devServer.environments)) {
+					const mod = env.moduleGraph.getModuleById(VIRTUAL_ROUTES_ID);
+					if (mod) {
+						env.moduleGraph.invalidateModule(mod);
+						if (structural) env.hot.send({ type: "full-reload" });
+					}
+				}
+				if (/\.island\./.test(path) || path.endsWith(".md")) devServer.environments.client?.hot.send({ type: "full-reload" });
+			};
+			watcher.on("add", (path) => handleFileChange(path, "add"));
+			watcher.on("change", (path) => handleFileChange(path, "change"));
+			watcher.on("unlink", (path) => handleFileChange(path, "unlink"));
+			if (publicDir) {
+				const redirectsPath = join(publicDir, "_redirects");
+				const headersPath = join(publicDir, "_headers");
+				const handleRulesFileChange = (path) => {
+					if (path !== redirectsPath && path !== headersPath) return;
+					reloadFileRules();
+					for (const env of Object.values(devServer.environments)) {
+						const mod = env.moduleGraph.getModuleById(VIRTUAL_ROUTES_ID);
+						if (mod) {
+							env.moduleGraph.invalidateModule(mod);
+							env.hot.send({ type: "full-reload" });
+						}
+					}
+				};
+				watcher.on("add", handleRulesFileChange);
+				watcher.on("change", handleRulesFileChange);
+				watcher.on("unlink", handleRulesFileChange);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* Persist the dev-trigger token at `<root>/.void/dev-trigger-token` so
+* every voidPlugin() invocation against the same project reads the same
+* value. This matters because `@cloudflare/vite-plugin` spawns a
+* worker-environment child Vite that re-imports vite.config.ts and calls
+* voidPlugin() again — without persistence the parent and child would
+* generate different UUIDs, the dispatch file would embed one and the
+* hint plugin would print the other, and curls would land on
+* `unauthorized`.
+*
+* The file persists across dev sessions by design — it lives under `.void/`
+* (gitignored), and `cleanupWrapper` in `void deploy` explicitly preserves
+* it across its own wipe so saved curl scripts keep working between deploys.
+* The token is local to the project and only honored by a worker bound to
+* localhost; treat it like the rest of `.void/` — disposable scratch state,
+* safe to remove manually if desired.
+*/
+/**
+* Best-effort detection of `vite build` (and `vite preview`) so we can skip
+* dev-only side effects — writing the dev-trigger token and the dispatch
+* file — when no dev server will run. Vite's CLI passes the subcommand as
+* `process.argv[2]`; programmatic API users (and `vite` with no subcommand)
+* default to `dev`, which we detect as the absence of a build-shaped first
+* positional. This is intentionally permissive: when in doubt, we behave as
+* if we're in dev so first-request correctness is preserved.
+*/
+function isViteBuildOrPreview() {
+	const subcommand = process.argv[2];
+	return subcommand === "build" || subcommand === "preview";
+}
+function getOrCreateDevTriggerToken(root) {
+	const tokenPath = join(root, ".void", "dev-trigger-token");
+	const readExisting = () => {
+		try {
+			const existing = readFileSync(tokenPath, "utf-8").trim();
+			return existing.length > 0 ? existing : void 0;
+		} catch {
+			return;
+		}
+	};
+	const existing = readExisting();
+	if (existing) return existing;
+	mkdirSync(join(root, ".void"), { recursive: true });
+	const fresh = crypto.randomUUID();
+	try {
+		const fd = openSync(tokenPath, "wx");
+		try {
+			writeSync(fd, fresh);
+		} finally {
+			closeSync(fd);
+		}
+		return fresh;
+	} catch (err) {
+		if (err.code !== "EEXIST") throw err;
+		const winner = readExisting();
+		if (winner) return winner;
+		return fresh;
+	}
+}
+/**
+* Warn when the project's `package.json` does not declare `"type": "module"`.
+*
+* Vite's default `configLoader: "bundle"` bundles `vite.config.ts`,
+* externalizes deps, and then loads the bundle. When `package.json` is non-ESM
+* the bundle is written as `.js` and loaded via CJS `require()`, which throws
+* `ERR_REQUIRE_ASYNC_MODULE` if any externalized dep's ESM graph contains
+* top-level await. `@cloudflare/vite-plugin` (which voidPlugin pulls in) has
+* exactly such a TLA, so non-ESM consumers hit this on every Vite invocation.
+*
+* Runs once per Vite process (factory time), single sync read.
+*/
+function warnIfPackageJsonIsNotEsm(root) {
+	const pkgPath = join(root, "package.json");
+	if (!existsSync(pkgPath)) return;
+	let pkg;
+	try {
+		pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+	} catch {
+		return;
+	}
+	if (pkg.type === "module") return;
+	voidWarn("package.json is missing `\"type\": \"module\"`. Vite's default config loader will fail with ERR_REQUIRE_ASYNC_MODULE on transitive top-level await (e.g. @cloudflare/vite-plugin). Add `\"type\": \"module\"` to package.json, or run vite build with `--configLoader runner`.");
+}
+/**
+* Resolve the server entry module for a Class A framework. We always wrap
+* the framework's own entry with a tiny shim that intercepts
+* `/__void/{scheduled,queue}` in dev so cron and queue handlers run with
+* the worker's full CF bindings. The interception block is gated on
+* `import.meta.env.DEV` and the dispatch module is loaded via dynamic
+* `import()` so the entire dev path (including user cron imports) is
+* dead-code-eliminated in `vite build`. Production deploys go through
+* `cli/wrapper.ts` instead.
+*/
+function getFrameworkEntry(framework, root, devTriggerToken) {
+	const isBuild = isViteBuildOrPreview();
+	if (!isBuild) writeFrameworkTriggersDispatch(root, devTriggerToken);
+	return generateClassATriggerWrapper(root, framework, getOriginalFrameworkEntry(framework, root), isBuild);
+}
+/** The framework's own server entry, before our trigger wrapper. */
+function getOriginalFrameworkEntry(framework, root) {
+	switch (framework) {
+		case "tanstack-start": return "@tanstack/react-start/server-entry";
+		case "react-router": return generateReactRouterEntry(root);
+		case "vinext-app": return "vinext/server/app-router-entry";
+		case "vinext-pages": return generateVinextPagesEntry(root);
+	}
+}
+/**
+* Generate `<root>/.void/<framework>-trigger-wrapper.ts`. This file becomes
+* `workerConfig.main` so the dev miniflare/workerd evaluates *our* fetch
+* first, dispatches `/__void/{scheduled,queue}` if it matches, and otherwise
+* delegates to the framework's original entry.
+*
+* We emit two shapes of the wrapper depending on the Vite command:
+*
+* - Serve: dispatch is dynamically imported and gets a chance to handle
+*   `/__void/{scheduled,queue}` before falling through to the framework.
+* - Build: dispatch is omitted entirely. The wrapper just delegates fetch.
+*
+* We can't simply gate the dynamic import on `import.meta.env.DEV` and
+* trust DCE: rolldown emits chunks for dynamic imports during chunk
+* splitting, *before* constant folding removes the dead branch, so the
+* dispatch file (and its transitive user-cron/queue imports + dev token)
+* would still ship in the production bundle.
+*/
+function generateClassATriggerWrapper(root, framework, original, isBuild) {
+	const outDir = join(root, ".void");
+	mkdirSync(outDir, { recursive: true });
+	const wrapperPath = join(outDir, `${framework}-trigger-wrapper.ts`);
+	writeFileSync(wrapperPath, isBuild ? `// @ts-nocheck — Auto-generated by Void for vite build. Do NOT edit.
+import original from ${JSON.stringify(original)};
+
+export default {
+  ...original,
+  async fetch(request, env, ctx) {
+    return original.fetch(request, env, ctx);
+  },
+};
+` : `// @ts-nocheck — Auto-generated by Void in dev. Do NOT edit.
+import original from ${JSON.stringify(original)};
+
+export default {
+  ...original,
+  async fetch(request, env, ctx) {
+    const { handleDevTrigger } = await import(${JSON.stringify(frameworkTriggersDispatchPath(root))});
+    const response = await handleDevTrigger(request, env, ctx);
+    if (response) return response;
+    return original.fetch(request, env, ctx);
+  },
+};
+`);
+	return wrapperPath;
+}
+/** Generate a worker entry for vinext Pages Router projects. */
+function generateVinextPagesEntry(root) {
+	const outDir = join(root, ".void");
+	mkdirSync(outDir, { recursive: true });
+	const entryPath = join(outDir, "vinext-pages-entry.ts");
+	writeFileSync(entryPath, `// Auto-generated by Void — vinext Pages Router worker entry
+// @ts-expect-error virtual module resolved by vinext at build time
+import { renderPage, handleApiRoute } from "virtual:vinext-server-entry";
+
+export default {
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    if (pathname.replaceAll("\\\\", "/").startsWith("//")) {
+      return new Response("404 Not Found", { status: 404 });
+    }
+    const urlWithQuery = pathname + url.search;
+    if (pathname.startsWith("/api/") || pathname === "/api") {
+      return await handleApiRoute(request, urlWithQuery);
+    }
+    return await renderPage(request, urlWithQuery, null);
+  },
+};
+`);
+	return entryPath;
+}
+/** Generate a worker entry for React Router v7 projects. */
+function generateReactRouterEntry(root) {
+	const outDir = join(root, ".void");
+	mkdirSync(outDir, { recursive: true });
+	const entryPath = join(outDir, "react-router-entry.ts");
+	writeFileSync(entryPath, `// Auto-generated by Void — React Router v7 worker entry
+import { createRequestHandler } from "react-router";
+
+const requestHandler = createRequestHandler(
+  // @ts-expect-error virtual module resolved by @react-router/dev at build time
+  () => import("virtual:react-router/server-build"),
+  import.meta.env.MODE,
+);
+
+export default {
+  async fetch(request: Request): Promise<Response> {
+    return requestHandler(request);
+  },
+};
+`);
+	return entryPath;
+}
+/** Check whether a binding name already exists in a resolved bindings array. */
+function hasBinding(list, name) {
+	return Array.isArray(list) && list.some((b) => b.binding === name);
+}
+const CLOUDFLARE_BUILTIN_IMPORT = /^cloudflare:/;
+const SANDBOX_SDK_IMPORT = "@cloudflare/sandbox";
+const SANDBOX_SDK_IMPORT_FILTER = /^@cloudflare\/sandbox$/;
+const DEFAULT_WORKER_ENVIRONMENT_NAME = "void_worker";
+const DEFAULT_WORKER_OUT_DIR = "dist/ssr";
+function resolveSandboxSdkEntry() {
+	return fileURLToPath(import.meta.resolve(SANDBOX_SDK_IMPORT));
+}
+function createCloudflareBuiltinsExternalPlugin() {
+	return {
+		name: "void:cloudflare-builtins-external",
+		config(_, env) {
+			if (env.command !== "build") return;
+			return { build: { rollupOptions: { external: [CLOUDFLARE_BUILTIN_IMPORT] } } };
+		}
+	};
+}
+function createDefaultWorkerEnvironmentPlugin() {
+	return {
+		name: "void:default-worker-environment",
+		config(config) {
+			const currentEnvironment = config.environments?.[DEFAULT_WORKER_ENVIRONMENT_NAME];
+			return { environments: { [DEFAULT_WORKER_ENVIRONMENT_NAME]: {
+				...currentEnvironment,
+				build: {
+					...currentEnvironment?.build,
+					outDir: currentEnvironment?.build?.outDir ?? DEFAULT_WORKER_OUT_DIR
+				}
+			} } };
+		}
+	};
+}
+function createSandboxSdkResolvePlugin() {
+	let resolved;
+	return {
+		name: "void:sandbox-sdk-resolve",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: SANDBOX_SDK_IMPORT_FILTER },
+			handler(id) {
+				if (id !== SANDBOX_SDK_IMPORT) return;
+				resolved ??= resolveSandboxSdkEntry();
+				return resolved;
+			}
+		}
+	};
+}
+/**
+* Read Void auth credentials for local dev AI proxy access.
+* Returns a discriminated union so callers can distinguish
+* "no token" from "no project" for targeted onboarding guidance.
+*/
+function readVoidDevCredentials(root) {
+	const token = getToken(root);
+	if (!token) return { status: "no-token" };
+	const staging = isStagingMode(root) || void 0;
+	const project = readProjectConfig(root);
+	if (!project) return {
+		status: "no-project",
+		token,
+		staging
+	};
+	return {
+		status: "ok",
+		token,
+		projectId: project.projectId,
+		staging
+	};
+}
+const DEFAULT_API_URL = "https://api.void.cloud";
+const STAGING_API_URL = "https://api.staging.void.cloud";
+/**
+* Interactive AI setup prompt shown during dev server startup when the user
+* has a token but no linked project. Runs as fire-and-forget so it doesn't
+* block the server. On completion, writes project.json and restarts the server.
+*/
+async function runAiSetupPrompt(root, token, staging, server) {
+	const { select, text, isCancel, log } = await import("./dist-Dayj3gCK.mjs").then((n) => n.p);
+	const { PlatformClient } = await import("./client-snXOjrp1.mjs").then((n) => n.r);
+	const { writeProjectConfig } = await import("./project-TqORyHn8.mjs").then((n) => n.n);
+	const { inferDefaultSlug } = await import("./resolve-project-Br5BR03U.mjs").then((n) => n.i);
+	const client = new PlatformClient(token, staging ? STAGING_API_URL : DEFAULT_API_URL);
+	let projects;
+	try {
+		projects = await client.listProjects();
+	} catch {
+		voidWarn("Failed to fetch projects. Run `void project link` to link a project manually.");
+		return;
+	}
+	const options = [{
+		value: "__create__",
+		label: "Create new project"
+	}, ...projects.map((p) => ({
+		value: p.id,
+		label: p.slug
+	}))];
+	console.log();
+	log.info("[void] AI requires a linked project. Let's set one up:");
+	const result = await select({
+		message: "Select a project:",
+		options
+	});
+	if (isCancel(result)) return;
+	let projectId;
+	let slug;
+	if (result === "__create__") {
+		const defaultSlug = inferDefaultSlug(root);
+		const { validateProjectSlug } = await import("./project-slug-CKam8lF9.mjs").then((n) => n.t);
+		const slugResult = await text({
+			message: "Choose a slug for your new Void project:",
+			placeholder: "my-app",
+			initialValue: defaultSlug,
+			validate: validateProjectSlug
+		});
+		if (isCancel(slugResult)) return;
+		try {
+			const created = await client.createProject(slugResult.trim());
+			projectId = created.id;
+			slug = created.slug;
+		} catch (err) {
+			voidError(`project: Failed to create project: '${err instanceof Error ? err.message : String(err)}'.`);
+			return;
+		}
+		log.success(`Project created: ${import_picocolors.default.blue(slug)}`);
+	} else {
+		const project = projects.find((p) => p.id === result);
+		projectId = project.id;
+		slug = project.slug;
+	}
+	writeProjectConfig(root, {
+		projectId,
+		slug
+	});
+	log.success(`Linked to ${import_picocolors.default.blue(slug)}`);
+	await server.restart();
+}
+/**
+* Void plugin — the main entry point.
+*
+* Composes:
+* 1. Routing plugin (file-based routing from routes/ and middleware/)
+* 2. Migration plugin (auto-apply .sql migrations on dev startup)
+* 3. @cloudflare/vite-plugin (workerd runtime, HMR, builds)
+*
+* Binding inference runs synchronously here so results are available
+* before the Cloudflare plugin initializes.
+*
+* If the user has a `wrangler.jsonc` / `wrangler.json` in their project root,
+* the Cloudflare plugin reads it and provides the resolved config to our
+* config function. Bindings already defined there (with real IDs for
+* production deployment) are preserved — we only add inferred bindings
+* that are missing. This allows `vite build && wrangler deploy` to work
+* for deploying directly to Cloudflare without the Void platform.
+*/
+function voidPlugin(options) {
+	const root = process.cwd();
+	warnIfPackageJsonIsNotEsm(root);
+	const devTriggerToken = isViteBuildOrPreview() ? crypto.randomUUID() : getOrCreateDevTriggerToken(root);
+	const config = readConfig(root);
+	const dialect = getDatabaseDialect(config);
+	const detected = detectFramework(root);
+	const framework = detected?.class === "a" ? detected.name : void 0;
+	const scanDirs = config.inference?.scanDirs ?? (detected ? FRAMEWORK_SCAN_DIRS : void 0);
+	const inferenceOptions = config.inference?.bindings ? { bindings: config.inference.bindings } : void 0;
+	const inferredBindings = inferProjectBindings(root, inferenceOptions, scanDirs);
+	const bindings = isSandboxEnabled(config) ? {
+		...inferredBindings,
+		needsSandbox: true
+	} : inferredBindings;
+	const sandboxConfig = bindings.needsSandbox ? resolveSandboxConfig(config, root) : void 0;
+	const authConfigPath = findVoidAuthConfig(root);
+	const authEnabled = bindings.needsAuth || authConfigPath !== null || config.auth !== void 0;
+	if (detected && authEnabled) throw new Error("auth: Void-managed Better Auth is only supported in Void apps. Use Better Auth's official integration for this framework instead.");
+	if (detected && bindings.needsSandbox) throw new Error("sandbox: Cloudflare Sandboxes are currently supported in Void apps only.");
+	const STUB_PREFIX = "\0void-client-stub:";
+	const SERVER_ONLY_STUBS = {
+		"void/db": "export const db = {}; export const createDb = () => ({});",
+		"void/kv": "export const kv = {}; export const createKV = () => ({});",
+		"void/ai": "export const ai = {};",
+		"void/queues": "export const queues = {};",
+		"void/storage": "export const storage = {}; export const createStorage = () => ({});",
+		"void/isr": "export const revalidate = async () => {};",
+		"void/sandbox": "export const sandbox = {}; export const getSandbox = () => ({});"
+	};
+	const STUB_RESOLVE_FILTER = new RegExp(`^(${Object.keys(SERVER_ONLY_STUBS).join("|").replaceAll("/", "\\/")})$`);
+	const STUB_LOAD_FILTER = new RegExp(`^\\0void-client-stub:`);
+	const clientStubsPlugin = {
+		name: "void:client-stubs",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: STUB_RESOLVE_FILTER },
+			handler(id) {
+				if (this.environment?.name === "client") return STUB_PREFIX + id;
+			}
+		},
+		load: {
+			filter: { id: STUB_LOAD_FILTER },
+			handler(id) {
+				return SERVER_ONLY_STUBS[id.slice(18)] ?? "export default {};";
+			}
+		}
+	};
+	const queues = framework ? [] : scanQueuesSync(root);
+	const websocketRoutes = framework ? [] : scanWebSocketRoutesSync(root);
+	if (detected && (detected.class === "b" || detected.class === "c")) {
+		const bindingNames = resolveBindingNames(config.inference?.bindings);
+		const frameworkPersistRoot = join(root, ".wrangler", "state");
+		const syncFrameworkCompat = () => {
+			if (ensureWranglerCompatibilityDate(root, readWranglerCompat(root, config).compatibilityDate)) voidLog("Synced compatibility_date to wrangler config");
+		};
+		return [
+			createCloudflareBuiltinsExternalPlugin(),
+			{
+				name: "void:wrangler-compat",
+				enforce: "pre",
+				config(_, env) {
+					syncFrameworkCompat();
+					if (env.command !== "serve") return;
+					if (ensureWranglerNodejsAlsFlag(root)) voidLog("Synced nodejs_als to wrangler config");
+				}
+			},
+			{
+				name: "void:wrangler-sync",
+				configResolved(resolvedConfig) {
+					syncFrameworkCompat();
+					if (resolvedConfig.command !== "serve") return;
+					if (syncWranglerBindings(root, bindings, {
+						bindingNames,
+						websockets: websocketRoutes,
+						sandbox: sandboxConfig
+					})) voidLog("Synced bindings to wrangler.jsonc");
+				}
+			},
+			{
+				name: "void:sveltekit-hooks-inject",
+				apply: "serve",
+				transform(code, id) {
+					if (detected.class !== "b") return;
+					if (!id.includes(".svelte-kit/generated/server/internal")) return;
+					if (!code.includes("export async function get_hooks")) return;
+					const dispatchPath = JSON.stringify(frameworkTriggersDispatchPath(root));
+					return code.replace("export async function get_hooks() {", `export async function get_hooks() {
+  const { withRuntimeEnv } = await import("void/_env");
+  const { handleDevTrigger } = await import(${dispatchPath});`).replace(/return\s*\{/, "const __origHandle = handle ?? (({ event, resolve }) => resolve(event));\n  handle = ({ event, resolve }) => withRuntimeEnv(event.platform?.env, async () => {\n    const __triggerResp = await handleDevTrigger(event.request, event.platform?.env, undefined);\n    if (__triggerResp) return __triggerResp;\n    return __origHandle({ event, resolve });\n  });\n  return {");
+				}
+			},
+			clientStubsPlugin,
+			envSchemaPlugin(root),
+			envClientGuardPlugin(root),
+			envClientFoldPlugin(),
+			drizzlePlugin(root, false, dialect, { forceVirtualDb: authEnabled }),
+			migrationPlugin(root, dialect, "local", frameworkPersistRoot, { enabled: false }),
+			devTriggersHintPlugin(root, {
+				framework: true,
+				devTriggerToken
+			}),
+			frameworkTriggersPlugin(root, { devTriggerToken }),
+			...detected.name === "nuxt" ? [nitroDevTriggerInjectPlugin(root, { serverDir: "server" })] : [],
+			...detected.name === "analog" ? [analogDevTriggerInjectPlugin(root)] : [],
+			...detected.name === "astro" ? [astroDevTriggerInjectPlugin(root)] : []
+		];
+	}
+	const remoteMode = resolveRemoteMode(config.remote);
+	const workerConfig = {};
+	let viteCommand = "build";
+	const wranglerCompat = isNodeTarget(config.target) ? void 0 : readWranglerCompat(root, config);
+	if (wranglerCompat) {
+		workerConfig.compatibility_date = wranglerCompat.compatibilityDate;
+		if (wranglerCompat.compatibilityFlags) workerConfig.compatibility_flags = wranglerCompat.compatibilityFlags;
+	}
+	const inspectorPortEnv = process.env.VOID_INSPECTOR_PORT;
+	const inspectorPort = inspectorPortEnv === "false" ? false : typeof inspectorPortEnv === "string" && inspectorPortEnv.length > 0 ? Number.parseInt(inspectorPortEnv, 10) : void 0;
+	const inspectorPortOption = inspectorPort === false ? { inspectorPort: false } : typeof inspectorPort === "number" ? { inspectorPort } : {};
+	const outDir = join(root, ".void");
+	mkdirSync(outDir, { recursive: true });
+	function mergeBindings(resolved) {
+		const result = { ...workerConfig };
+		const d1 = [];
+		if ((bindings.needsD1 || authEnabled && dialect === "sqlite") && !hasBinding(resolved.d1_databases, "DB")) d1.push({
+			binding: "DB",
+			database_name: "default",
+			database_id: "local"
+		});
+		if (d1.length > 0) result.d1_databases = [...resolved.d1_databases ?? [], ...d1];
+		const kv = [];
+		if (bindings.needsKV && !hasBinding(resolved.kv_namespaces, "KV")) kv.push({
+			binding: "KV",
+			id: "local"
+		});
+		if (kv.length > 0) result.kv_namespaces = [...resolved.kv_namespaces ?? [], ...kv];
+		if (bindings.needsR2 && !hasBinding(resolved.r2_buckets, "STORAGE")) result.r2_buckets = [...resolved.r2_buckets ?? [], {
+			binding: "STORAGE",
+			bucket_name: "default"
+		}];
+		if (queues.length > 0) result.queues = {
+			producers: queues.map((q) => ({
+				queue: q.name,
+				binding: q.bindingName
+			})),
+			consumers: queues.map((q) => ({
+				queue: q.name,
+				...q.maxBatchSize != null && { max_batch_size: q.maxBatchSize },
+				...q.maxBatchTimeout != null && { max_batch_timeout: q.maxBatchTimeout },
+				...q.maxRetries != null && { max_retries: q.maxRetries },
+				...q.retryDelay != null && { retry_delay: q.retryDelay }
+			}))
+		};
+		if (websocketRoutes.length > 0) {
+			const existingDurableObjectBindings = resolved.durable_objects?.bindings ?? [];
+			const missingDurableObjectBindings = websocketRoutes.filter((route) => !existingDurableObjectBindings.some((binding) => binding.name === route.bindingName)).map((route) => ({
+				name: route.bindingName,
+				class_name: route.className
+			}));
+			if (missingDurableObjectBindings.length > 0) result.durable_objects = { bindings: [...existingDurableObjectBindings, ...missingDurableObjectBindings] };
+			if (!Array.isArray(resolved.migrations)) result.migrations = [{
+				tag: "void-ws-v1",
+				new_classes: websocketRoutes.map((route) => route.className)
+			}];
+		}
+		if (bindings.needsSandbox && sandboxConfig) {
+			const existingDurableObjectBindings = (result.durable_objects ?? resolved.durable_objects)?.bindings ?? [];
+			if (!existingDurableObjectBindings.some((binding) => binding.name === sandboxConfig.binding)) result.durable_objects = { bindings: [...existingDurableObjectBindings, {
+				name: sandboxConfig.binding,
+				class_name: sandboxConfig.className
+			}] };
+			const existingContainers = result.containers ?? resolved.containers ?? [];
+			if (!existingContainers.some((container) => container.class_name === sandboxConfig.className)) result.containers = [...existingContainers, {
+				name: sandboxConfig.containerName,
+				class_name: sandboxConfig.className,
+				image: sandboxConfig.image,
+				...sandboxConfig.imageBuildContext && { image_build_context: sandboxConfig.imageBuildContext },
+				...sandboxConfig.instanceType && { instance_type: sandboxConfig.instanceType },
+				...sandboxConfig.maxInstances != null && { max_instances: sandboxConfig.maxInstances }
+			}];
+			const currentMigrations = result.migrations ?? resolved.migrations;
+			const existingMigrations = Array.isArray(currentMigrations) ? currentMigrations : [];
+			if (!existingMigrations.some((migration) => migration.tag === "void-sandbox-v1" || migration.new_sqlite_classes?.includes(sandboxConfig.className))) result.migrations = [...existingMigrations, {
+				tag: SANDBOX_MIGRATION_TAG,
+				new_sqlite_classes: [sandboxConfig.className]
+			}];
+		}
+		if (viteCommand === "serve" && bindings.needsAI) {
+			const credentials = readVoidDevCredentials(root);
+			if (credentials.status === "ok") {
+				const vars = result.vars ?? {};
+				vars.__VOID_TOKEN = credentials.token;
+				vars.__VOID_PROJECT_ID = credentials.projectId;
+				if (credentials.staging) vars.__VOID_STAGING = "1";
+				result.vars = vars;
+			}
+		}
+		if (viteCommand === "serve" && remoteMode && (bindings.needsD1 || bindings.needsKV || bindings.needsR2)) {
+			const credentials = readVoidDevCredentials(root);
+			if (credentials.status === "ok") {
+				const vars = result.vars ?? {};
+				vars.__VOID_PROXY_URL = credentials.staging ? STAGING_PROXY_URL : DEFAULT_PROXY_URL;
+				vars.__VOID_TOKEN = credentials.token;
+				vars.__VOID_PROJECT_ID = credentials.projectId;
+				vars.__VOID_REMOTE = "1";
+				result.vars = vars;
+			}
+		}
+		return result;
+	}
+	function applySchemaDefaultsToWorkerVars(defaults) {
+		const vars = workerConfig.vars ?? {};
+		for (const [key, value] of Object.entries(defaults)) if (vars[key] === void 0) vars[key] = value;
+		workerConfig.vars = vars;
+	}
+	const envPlugin = {
+		name: "void:env",
+		config(userConfig, { mode, command }) {
+			viteCommand = command;
+			const ignored = ["**/.void/**"];
+			const { sanitized: env, stripped } = stripInternalEnvKeys(filterLoadedEnv(loadEnv(mode, typeof userConfig.envDir === "string" && userConfig.envDir.length > 0 ? join(root, userConfig.envDir) : root, "")));
+			if (stripped.length > 0) voidWarn(`Ignoring internal env keys from .env files: ${stripped.join(", ")}. These are reserved for Void runtime use.`);
+			workerConfig.vars = {
+				...workerConfig.vars,
+				...env
+			};
+			const assets = workerConfig.assets;
+			if (command === "serve" && assets) delete assets.run_worker_first;
+			const watchConfig = { server: { watch: { ignored } } };
+			if (!isNodeTarget(config.target) && config.output !== "static") {
+				const envNames = framework === "vinext-app" ? ["rsc", "ssr"] : ["ssr"];
+				return {
+					...watchConfig,
+					environments: Object.fromEntries(envNames.map((n) => [n, { build: { minify: true } }]))
+				};
+			}
+			return watchConfig;
+		},
+		configureServer(server) {
+			const afterReady = (fn) => {
+				if (server.httpServer) server.httpServer.once("listening", () => setTimeout(fn, 100));
+				else fn();
+			};
+			if (remoteMode && (bindings.needsD1 || bindings.needsKV || bindings.needsR2)) {
+				const credentials = readVoidDevCredentials(root);
+				if (credentials.status === "ok") {
+					const lines = ["\x1B[36mRemote bindings active\x1B[39m"];
+					if (bindings.needsD1) lines.push("  DB      \x1B[2m→ remote D1\x1B[22m");
+					if (bindings.needsKV) lines.push("  KV      \x1B[2m→ remote KV\x1B[22m");
+					if (bindings.needsR2) lines.push("  STORAGE \x1B[2m→ remote R2\x1B[22m");
+					afterReady(() => {
+						console.log();
+						voidLog(lines.join("\n         "));
+					});
+				} else if (credentials.status === "no-token") afterReady(() => {
+					console.log();
+					voidWarn("Remote mode requires authentication. Run `void auth login`, then restart.");
+					voidWarn("Falling back to local bindings.");
+				});
+				else afterReady(() => {
+					console.log();
+					voidWarn("Remote mode requires a linked project. Run `void project link` first.");
+					voidWarn("Falling back to local bindings.");
+				});
+			}
+			if (bindings.needsAI) {
+				const credentials = readVoidDevCredentials(root);
+				if (credentials.status === "no-token") afterReady(() => {
+					console.log();
+					voidWarn("AI requires authentication. Run `void auth login`, then restart the dev server.");
+				});
+				else if (credentials.status === "no-project") if (process.stdin.isTTY) afterReady(() => {
+					console.log();
+					runAiSetupPrompt(root, credentials.token, credentials.staging, server);
+				});
+				else afterReady(() => {
+					console.log();
+					voidWarn("AI requires a linked project. Run `void project link` to set one up.");
+				});
+			}
+		}
+	};
+	const autoDetectBindings = !inferenceOptions;
+	const autoDetectAuth = !authEnabled;
+	const bindingWatchPlugin = {
+		name: "void:binding-watch",
+		apply: "serve",
+		configureServer(server) {
+			if (!autoDetectBindings && !autoDetectAuth) return;
+			const watchDirs = [...new Set([...scanDirs ?? [
+				"routes",
+				"middleware",
+				"queues",
+				"pages",
+				"crons"
+			], "src"])].map((d) => join(root, d));
+			let hintShown = false;
+			const check = (path) => {
+				if (hintShown) return;
+				if (!watchDirs.some((d) => path.startsWith(d))) return;
+				try {
+					const fileBindings = inferBindingsFromSource(readFileSync(path, "utf-8"), path.split("/").pop());
+					const newBindings = [];
+					if (autoDetectBindings) {
+						if (fileBindings.needsD1 && !bindings.needsD1) newBindings.push("D1 (void/db)");
+						if (fileBindings.needsKV && !bindings.needsKV) newBindings.push("KV (void/kv)");
+						if (fileBindings.needsR2 && !bindings.needsR2) newBindings.push("R2 (void/storage)");
+						if (fileBindings.needsAI && !bindings.needsAI) newBindings.push("AI (void/ai)");
+						if (fileBindings.needsSandbox && !bindings.needsSandbox) newBindings.push("Sandbox (void/sandbox)");
+					}
+					if (autoDetectAuth && fileBindings.needsAuth) newBindings.push("Auth (void/auth)");
+					if (newBindings.length > 0) {
+						hintShown = true;
+						const detected = newBindings.join(", ");
+						setTimeout(() => {
+							voidLog(`New ${detected} binding detected. Restart to apply.`);
+						}, 300);
+						server.hot.send({
+							type: "custom",
+							event: "void:new-binding",
+							data: { message: `New ${detected} binding detected.` }
+						});
+					}
+				} catch {}
+			};
+			const attach = () => {
+				server.watcher.on("add", check);
+				server.watcher.on("change", check);
+			};
+			if (server.httpServer) server.httpServer.once("listening", attach);
+			else attach();
+		}
+	};
+	if (framework) {
+		workerConfig.main = getFrameworkEntry(framework, root, devTriggerToken);
+		const existingFlags = workerConfig.compatibility_flags ?? [];
+		if (!existingFlags.includes("nodejs_compat")) workerConfig.compatibility_flags = [...existingFlags, "nodejs_compat"];
+		const viteEnvironment = framework === "vinext-app" ? {
+			name: "rsc",
+			childEnvironments: ["ssr"]
+		} : { name: "ssr" };
+		const redirectDbTypePaths = framework !== "vinext-app" && framework !== "vinext-pages";
+		const vinextCompat = framework === "vinext-app" || framework === "vinext-pages" ? {
+			name: "void:vinext-compat",
+			enforce: "pre",
+			config(userConfig) {
+				const plugins = Array.isArray(userConfig.plugins) ? userConfig.plugins : [];
+				for (const p of plugins) if (p && typeof p === "object" && !Array.isArray(p) && "name" in p && p.name === "vite-tsconfig-paths") {
+					const plugin = p;
+					for (const key of Object.keys(plugin)) if (key !== "name" && typeof plugin[key] === "function") plugin[key] = () => {};
+				}
+			}
+		} : void 0;
+		return [
+			createCloudflareBuiltinsExternalPlugin(),
+			restartPlugin(),
+			bindingWatchPlugin,
+			envPlugin,
+			envSchemaPlugin(root, { onDefaults: applySchemaDefaultsToWorkerVars }),
+			envClientGuardPlugin(root),
+			envClientFoldPlugin(),
+			clientStubsPlugin,
+			drizzlePlugin(root, false, getDatabaseDialect(config), {
+				forceVirtualDb: authEnabled,
+				redirectDbTypePaths
+			}),
+			migrationPlugin(root, getDatabaseDialect(config)),
+			...vinextCompat ? [vinextCompat] : [],
+			frameworkTriggersPlugin(root, { devTriggerToken }),
+			devTriggersHintPlugin(root, {
+				framework: true,
+				devTriggerToken
+			}),
+			...cloudflare({
+				...inspectorPortOption,
+				persistState: { path: options?.persistTo ?? outDir },
+				auxiliaryWorkers: options?.auxiliaryWorkers,
+				viteEnvironment,
+				config: mergeBindings
+			})
+		];
+	}
+	if (isNodeTarget(config.target)) {
+		if (authEnabled) throw new Error("auth: Void-managed Better Auth is only supported in Cloudflare Void apps. Use Better Auth directly for this target instead.");
+		if (config.inference?.bindings) voidWarn("\"inference.bindings\" in void.json is ignored with target: \"" + config.target + "\"");
+		if (config.worker) voidWarn("\"worker\" in void.json is ignored with target: \"" + config.target + "\"");
+		if (config.remote) voidWarn("\"remote\" in void.json is ignored with target: \"" + config.target + "\"");
+		if (bindings.needsSandbox) throw new Error(`sandbox: Cloudflare Sandboxes require target: "cloudflare". They are not available with target: '${config.target}'.`);
+		if (config.routing?.revalidate) voidWarn("\"routing.revalidate\" in void.json is ignored with target: \"" + config.target + "\" (edge caching is CF-only)");
+		return [
+			restartPlugin(),
+			envPlugin,
+			envSchemaPlugin(root),
+			routingPlugin(root, {
+				isAuthEnabled: () => false,
+				devTriggerToken,
+				headConfig: config.head,
+				output: config.output,
+				prerenderPaths: config.routing?.prerender,
+				target: config.target,
+				routing: config.routing,
+				hasSandbox: false
+			}),
+			prerenderPlugin(root, config),
+			...nodeTargetPlugin(config.target)
+		];
+	}
+	const existingFlags = workerConfig.compatibility_flags ?? [];
+	if ((dialect === "postgresql" || bindings.needsSandbox) && !existingFlags.includes("nodejs_compat")) workerConfig.compatibility_flags = [...existingFlags.filter((f) => f !== "nodejs_als"), "nodejs_compat"];
+	else if (!existingFlags.includes("nodejs_als") && !existingFlags.includes("nodejs_compat")) workerConfig.compatibility_flags = [...existingFlags, "nodejs_als"];
+	const jobs = scanJobsSync(root);
+	const ssrEntry = validateSsrEntry(root);
+	const hasPages = existsSync(join(root, "pages"));
+	workerConfig.main = join(root, ".void", "entry.ts");
+	if (jobs.length > 0) workerConfig.triggers = { crons: jobs.flatMap((job) => job.crons) };
+	if (ssrEntry || hasPages) workerConfig.assets = {
+		binding: "ASSETS",
+		run_worker_first: ["/**"]
+	};
+	return [
+		createCloudflareBuiltinsExternalPlugin(),
+		createDefaultWorkerEnvironmentPlugin(),
+		restartPlugin(),
+		bindingWatchPlugin,
+		envPlugin,
+		envSchemaPlugin(root, { onDefaults: applySchemaDefaultsToWorkerVars }),
+		envClientGuardPlugin(root),
+		envClientFoldPlugin(),
+		clientStubsPlugin,
+		...bindings.needsSandbox ? [createSandboxSdkResolvePlugin()] : [],
+		routingPlugin(root, {
+			isAuthEnabled: () => authEnabled,
+			devTriggerToken,
+			headConfig: config.head,
+			output: config.output,
+			prerenderPaths: config.routing?.prerender,
+			remoteMode,
+			routing: config.routing,
+			hasSandbox: bindings.needsSandbox,
+			sandboxBindingName: sandboxConfig?.binding,
+			sandboxClassName: sandboxConfig?.className
+		}),
+		drizzlePlugin(root, true, dialect, { forceVirtualDb: authEnabled }),
+		migrationPlugin(root, dialect, "local", join(root, ".void"), {
+			enabled: authEnabled,
+			configPath: authConfigPath
+		}),
+		prerenderPlugin(root, config),
+		devTriggersHintPlugin(root, {
+			framework: false,
+			devTriggerToken
+		}),
+		...cloudflare({
+			...inspectorPortOption,
+			persistState: { path: options?.persistTo ?? outDir },
+			auxiliaryWorkers: options?.auxiliaryWorkers,
+			viteEnvironment: { name: DEFAULT_WORKER_ENVIRONMENT_NAME },
+			config: mergeBindings
+		})
+	];
+}
+//#endregion
+export { VoidAssetRewriteError, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled, voidPlugin };