void 0.10.12 → 0.20.0

package/dist/index.mjs

@@ -1,32 +1,38 @@
-import { r as __toESM } from "./rolldown-runtime-DJK8HYOj.mjs";
-import { a as join, n as dirname, s as relative } from "./dist-DaKKDf8D.mjs";
-import { M as require_picocolors } from "./agents-CtgBYqld.mjs";
-import { A as resolveAssetRoutingPolicy, C as syncWranglerBindings, D as resolveSandboxConfig, E as isSandboxEnabled, O as hasApiRoutes, S as resolveLiveBindingConfig, T as SANDBOX_MIGRATION_TAG, _ as nextDurableObjectMigrationTag, a as prerenderPagesNode, c as filterLoadedEnv, d as LIVE_MIGRATION_TAG, g as hasDurableObjectSqliteMigration, h as ensureWranglerNodejsAlsFlag, i as prerenderPages, k as hasDocumentRoutes, l as resolveRemoteMode, m as ensureWranglerCompatibilityDate, n as resolveDistDir, o as collectRevalidate, p as ensureWranglerCompat, r as resolveWorkerDirName, s as hasRevalidate, u as stripInternalEnvKeys, v as normalizeWranglerCompatibilityFlags, x as readWranglerCompat, y as readExistingLiveBindingConfig } from "./deploy-u7Rv9q_q.mjs";
-import { i as resolveProjectPaths, n as readProjectPaths, t as assertNoRootSourceConventionConflicts } from "./project-paths-BQd7OmIo.mjs";
-import { a as scanQueuesSync, c as loadVoidAuthConfig, i as scanWebSocketRoutesSync, n as scanRoutePatternsSync, o as scanJobsSync, r as scanRoutes, s as findVoidAuthConfig, t as scanMiddlewareSync } from "./scan-DYXkrasO.mjs";
-import { b as readProjectConfig, f as getToken, m as isStagingMode } from "./client-Gb71-XkG.mjs";
-import { n as ensureProjectTsconfig, r as writeFileIfChanged } from "./project-tsconfig-B-QtXjLQ.mjs";
-import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-BkTvs43g.mjs";
-import { a as inferBindingsFromSource, i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, o as walk, r as detectFramework, t as DEFAULT_SCAN_DIRS } from "./plugin-inference-DMeavIJ6.mjs";
-import { a as validateSsrEntries, c as isIdentifier, l as isLiteral, n as SSR_SERVER_ENTRY_RELATIVE_PATHS, o as validateSsrEntry, t as SSR_CLIENT_ENTRY_RELATIVE_PATHS, u as isMemberExpression } from "./entry-D7yy4xVH.mjs";
+import { r as __toESM } from "./rolldown-runtime-rQ84J-ij.mjs";
+import { c as relative, l as resolve, n as dirname, o as join } from "./dist-BrsS7cai.mjs";
+import { st as require_picocolors } from "./output-tFQLLj26.mjs";
+import { D as resolveAssetRoutingPolicy, E as hasDocumentRoutes, T as hasApiRoutes, _ as scanDurableObjectModules, c as resolveDistDir, d as generateQueueResolverSource, f as prerenderPages, g as hasRevalidate, h as collectRevalidate, l as resolveWorkerDirName, m as collectPages, p as prerenderPagesNode, v as SEND_EMAIL_BINDING } from "./deploy-CcDoeBIf.mjs";
+import { i as resolveProjectPaths, n as readProjectPaths, t as assertNoRootSourceConventionConflicts } from "./project-paths-SK8nMHPp.mjs";
+import { a as scanQueuesSync, c as loadVoidAuthConfig, i as scanWebSocketRoutesSync, n as scanRoutePatternsSync, o as scanJobsSync, r as scanRoutes, s as findVoidAuthConfig, t as scanMiddlewareSync } from "./scan-BMH4rzlv.mjs";
+import { a as getApiUrl, b as readDeploymentPlatform, c as getToken, o as getProxyUrl, u as isStagingMode, x as readProjectConfig } from "./auth-W9WII-mN.mjs";
+import { C as readWranglerWebSocketTombstones, D as syncWranglerWebSockets, E as syncWranglerDurableObjects, M as isSandboxEnabled, P as resolveSandboxConfig, T as syncWranglerBindings, a as LIVE_MIGRATION_TAG, d as ensureWranglerNodejsAlsFlag, g as readExistingLiveBindingConfig, h as normalizeWranglerCompatibilityFlags, j as SANDBOX_MIGRATION_TAG, l as ensureWranglerCompat, m as nextDurableObjectMigrationTag, p as hasDurableObjectSqliteMigration, u as ensureWranglerCompatibilityDate, w as resolveLiveBindingConfig, y as readWranglerCompat } from "./wrangler--imS8n0d.mjs";
+import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-BQFq7QvD.mjs";
 import { i as voidWarn, n as voidError, r as voidLog, t as setShowTimestamp } from "./log-ChfPKsVd.mjs";
-import { l as parseDotenvFile } from "./preset-BjyR3lzz.mjs";
-import { i as generateVoidAuthDrizzleSchema, n as generateQueueTypes, o as DRIZZLE_OPERATORS, r as generateVoidAuthDatabaseModule, s as generateDbDts, t as generateRouteTypes } from "./route-types-COI2DsZv.mjs";
-import { t as discoverSchema } from "./discover-CJHyvYfR.mjs";
-import { t as MagicString } from "./magic-string.es-ZQjdJFFn.mjs";
-import { n as findEnvFileForPaths, r as generateEnvTypes, t as findEnvFile } from "./env-types-QBj-ndax.mjs";
-import { h as loadUserEnvFile } from "./env-validation-Dea3v3ej.mjs";
-import { i as resolveLayoutIds } from "./scan-DEwlM_Xy.mjs";
-import { n as STAGING_PROXY_URL, t as DEFAULT_PROXY_URL } from "./proxy-D-3_D-Gl.mjs";
-import { n as lintDuplicateSources, r as mergeRoutingRules, t as lintDestinationSplats } from "./headers-nsHIFixA.mjs";
+import { n as lintDuplicateSources, r as mergeRoutingRules, t as lintDestinationSplats } from "./headers-D8QfRX9Y.mjs";
+import { n as ensureProjectTsconfig, r as writeFileIfChanged } from "./project-tsconfig-Ql2XsSQp.mjs";
+import { a as inferBindingsFromSource, i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, o as walk, r as detectFramework, t as DEFAULT_SCAN_DIRS } from "./plugin-inference-BDRfZngg.mjs";
+import { a as validateSsrEntries, c as isIdentifier, l as isLiteral, n as SSR_SERVER_ENTRY_RELATIVE_PATHS, o as validateSsrEntry, t as SSR_CLIENT_ENTRY_RELATIVE_PATHS, u as isMemberExpression } from "./entry-DU3oDoQ3.mjs";
+import { n as writeLocalD1PersistState, t as resolveLocalD1Target } from "./local-d1-BE8KBbMy.mjs";
+import { n as parseDotenvFile } from "./dotenv-VQxupEUv.mjs";
+import { i as generateVoidAuthDrizzleSchema, n as generateQueueTypes, o as DRIZZLE_OPERATORS, r as generateVoidAuthDatabaseModule, s as generateDbDts, t as generateRouteTypes } from "./route-types-Da-DpyUp.mjs";
+import { t as discoverSchema } from "./discover-xvfrgJeo.mjs";
+import { _ as parseCapturedMessage, a as DEV_INBOX_ENV_VAR, c as DEV_INBOX_TOKEN_ENV_VAR, f as clearDevBuffer, g as listDevMessages, l as DEV_INBOX_TOKEN_HEADER, m as findDevMessage, n as DEV_INBOX_ACK_VALUE, o as DEV_INBOX_MAX_CAPTURE_BYTES, s as DEV_INBOX_PREFIX, t as DEV_INBOX_ACK_HEADER, u as DEV_INBOX_TOKEN_QUERY, v as pushToDevBuffer, y as registerEmailSink } from "./dev-inbox-DkgRWLkW.mjs";
+import { t as MagicString } from "./dist-BR1quN_w.mjs";
+import { n as findEnvFileForPaths, r as generateEnvTypes, t as findEnvFile } from "./env-types-BNPhro-M.mjs";
+import { h as loadUserEnvFile } from "./env-validation-ENpMy6Ez.mjs";
+import { a as loadLocalEnv, o as resolveRemoteMode, r as findLegacyEnvFiles, s as stripInternalEnvKeys, t as CLIENT_ENV_PREFIX$2 } from "./env-D4Emu-M_.mjs";
+import { i as resolveLayoutIds, o as isRouteEnabledForEnvironment } from "./scan-CpK-57ug.mjs";
+import { a as scanEmailHandlersSync, r as hasEmailHandlers } from "./email-Ce6SQq-i.mjs";
 import { n as INTERNAL_BINDING_PREFIXES, t as INTERNAL_BINDING_EXACT_NAMES } from "./env-raw-Cx8ElDdj.mjs";
 import { n as defer } from "./defer-YsYDUoii.mjs";
 import { VoidAssetRewriteError, basicAuth, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled } from "./runtime/handler.mjs";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, writeFileSync, writeSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { cloudflare } from "@cloudflare/vite-plugin";
-import { loadEnv, normalizePath, parseSync } from "vite";
+import { appendSqliteClassMigration } from "@void/deploy-core";
+import { timingSafeEqual } from "node:crypto";
 import { homedir } from "node:os";
+import { normalizePath, parseSync } from "vite";
 import { init, parse } from "es-module-lexer";
 //#region src/pages/dev-css-assets.ts
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
@@ -272,7 +278,7 @@ function pagesDevCssAssetsPlugin(root, token) {
 		resolveId(id) {
 			if (id !== "virtual:void-pages-dev-assets") return;
 			if (this.environment?.name === "client") throw new Error(`${DEV_CSS_ASSET_MODULE_ID} is server-only and cannot be imported by client code.`);
-			return "\0virtual:void-pages-dev-assets";
+			return "\0" + DEV_CSS_ASSET_MODULE_ID;
 		},
 		load(id) {
 			if (id !== "\0virtual:void-pages-dev-assets") return;
@@ -412,8 +418,8 @@ export async function getVoidPagesDevCss(request, env, payload) {
 			}
 			const edges = [];
 			for (const item of imports) {
-				if (item.d !== -1 || !item.n) continue;
-				const resolved = await this.resolve(item.n, id, { skipSelf: true });
+				if (item.type !== "static" && item.type !== "reexport-star" || !item.specifier) continue;
+				const resolved = await this.resolve(item.specifier, id, { skipSelf: true });
 				if (resolved?.id) edges.push(normalizeDevCssUrl(resolved.id, root));
 			}
 			edgeStore.set(id, edges);
@@ -505,7 +511,7 @@ function devTriggersHintPlugin(root, options) {
 				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 configuredProxyToken = parseDotenvFile(join(root, ".env"), { 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];
@@ -525,7 +531,9 @@ 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 drizzleMysql2Resolved = fileURLToPath(import.meta.resolve("drizzle-orm/mysql2"));
 const pgResolved = fileURLToPath(import.meta.resolve("pg"));
+const mysql2Resolved = fileURLToPath(import.meta.resolve("mysql2"));
 const VIRTUAL_DB_ID = "\0virtual:void-db";
 const VIRTUAL_SCHEMA_DB_ID = "\0virtual:void-db-schema";
 /**
@@ -589,34 +597,72 @@ export function createDb() {
 }
 `;
 				const schemaImport = schema ? `import * as schema from ${JSON.stringify(schema.path)};` : "";
-				const drizzleConfig = schema ? ", { schema }" : "";
+				const drizzleConfig = schema ? dialect === "mysql" ? ", { schema, mode: \"default\" }" : ", { schema }" : "";
+				if (dialect === "mysql") return `
+import { drizzle } from ${JSON.stringify(drizzleMysql2Resolved)};
+import { createPool } from ${JSON.stringify(mysql2Resolved)};
+import { getRuntimeBinding, getRuntimeRequestResource } from ${JSON.stringify(envModuleResolved)};
+${schemaImport}
+export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
+
+const _requestResourceKey = {};
+
+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: MySQL is not configured. Add DATABASE_URL to .env for local dev, or configure Hyperdrive for production.");
+}
+
+function getInstance() {
+  return getRuntimeRequestResource(_requestResourceKey, () => {
+    const pool = createPool({
+      uri: getConnectionString(),
+      connectionLimit: 1,
+      maxIdle: 1,
+      idleTimeout: 1000,
+    });
+    return drizzle(pool${drizzleConfig});
+  });
+}
+
+export const db = new Proxy({}, {
+  get(_, prop) {
+    return Reflect.get(getInstance(), prop);
+  },
+});
+
+export function createDb(connectionString) {
+  return drizzle(connectionString${drizzleConfig});
+}
+`;
 				if (dialect === "postgresql") return `
 import { drizzle } from ${JSON.stringify(drizzleNodePgResolved)};
 import pg from "pg";
-import { getRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
+import { getRuntimeBinding, getRuntimeRequestResource } from ${JSON.stringify(envModuleResolved)};
 ${schemaImport}
 export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
 
-let _prodInstance;
+const _requestResourceKey = {};
 
 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.");
+  throw new Error("db: PostgreSQL is not configured. Add DATABASE_URL to .env 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;
+  return getRuntimeRequestResource(_requestResourceKey, () => {
+    const pool = new pg.Pool({
+      connectionString: getConnectionString(),
+      max: 1,
+      idleTimeoutMillis: 1000,
+    });
+    return drizzle(pool${drizzleConfig});
+  });
 }
 
 export const db = new Proxy({}, {
@@ -655,7 +701,7 @@ export function createDb(d1) {
 			const migrationsDir = paths.migrationsDir;
 			if (!(existsSync(migrationsDir) && readdirSync(migrationsDir).some((f) => f.endsWith(".sql")))) {
 				if (dialect === "sqlite") {
-					const { getApplicationTables, getMiniflareDatabasePath } = await import("./runner-kapo9aPs.mjs");
+					const { getApplicationTables, getMiniflareDatabasePath } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
 					if ((await getApplicationTables(getMiniflareDatabasePath(options.localD1PersistRoot ?? join(root, ".void"), options.localD1DatabaseId ?? "local")).catch(() => [])).length > 0) return;
 				}
 				voidWarn(`Schema found but no migrations in ${paths.sourceRelative("db/migrations")}/.\n         \`void db push\` syncs the schema to your local DB without creating migration files.
@@ -672,6 +718,264 @@ export function createDb(d1) {
 	};
 }
 //#endregion
+//#region src/plugin-email-dev-inbox.ts
+const INBOX_PREFIX = DEV_INBOX_PREFIX;
+const SECURITY_HEADERS = {
+	"Cache-Control": "no-store",
+	"X-Content-Type-Options": "nosniff",
+	"X-Frame-Options": "DENY",
+	"Referrer-Policy": "no-referrer",
+	"Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; frame-src data:; img-src data:; connect-src 'none'"
+};
+function emailDevInboxPlugin(options) {
+	const { devTriggerToken } = options;
+	let devMode = false;
+	let unregister;
+	/** `href` for an inbox path that keeps the browser session authorized. */
+	const inboxHref = (path) => `${INBOX_PREFIX}${path}?${DEV_INBOX_TOKEN_QUERY}=${encodeURIComponent(devTriggerToken)}`;
+	return {
+		name: "void:email-dev-inbox",
+		apply: "serve",
+		config() {
+			devMode = true;
+		},
+		buildStart() {
+			if (!devMode || unregister) return;
+			unregister = registerEmailSink((m) => pushToDevBuffer(m));
+		},
+		buildEnd() {
+			if (unregister) {
+				unregister();
+				unregister = void 0;
+			}
+		},
+		configureServer(server) {
+			if (server.config.command !== "serve") return;
+			const printInboxUrl = () => {
+				const address = server.httpServer?.address();
+				const port = typeof address === "object" && address ? address.port : null;
+				if (port == null) return;
+				voidLog(`Email inbox: http://localhost:${port}${inboxHref("")}`);
+			};
+			if (server.httpServer) server.httpServer.once("listening", () => setTimeout(printInboxUrl, 100));
+			server.middlewares.use(INBOX_PREFIX, (req, res) => {
+				if (server.config.command !== "serve") {
+					res.writeHead(404, SECURITY_HEADERS);
+					res.end();
+					return;
+				}
+				const url = new URL(req.url ?? "/", "http://localhost");
+				const path = url.pathname;
+				if (!isAuthorized(req.headers["x-void-dev-trigger"], url, devTriggerToken)) {
+					res.writeHead(401, {
+						...SECURITY_HEADERS,
+						"Content-Type": "text/plain; charset=utf-8"
+					});
+					res.end(`Unauthorized: the void dev inbox requires the dev-trigger token — send it as the ${DEV_INBOX_TOKEN_HEADER} header or the ?${DEV_INBOX_TOKEN_QUERY}= query (printed as the inbox URL when void dev starts; stored in .void/dev-trigger-token).`);
+					return;
+				}
+				if (req.method === "POST" && path === "/_capture") {
+					handleCapture(req, res);
+					return;
+				}
+				if (req.method === "DELETE" && path === "/") {
+					clearDevBuffer();
+					res.writeHead(204, SECURITY_HEADERS);
+					res.end();
+					return;
+				}
+				if (req.method !== "GET") {
+					res.writeHead(405, SECURITY_HEADERS);
+					res.end();
+					return;
+				}
+				if (path === "/" || path === "") {
+					res.writeHead(200, {
+						...SECURITY_HEADERS,
+						"Content-Type": "text/html; charset=utf-8"
+					});
+					res.end(renderListHtml(listDevMessages(), inboxHref));
+					return;
+				}
+				const match = path.match(/^\/([^/]+)(\/raw)?$/);
+				if (!match) {
+					res.writeHead(404, SECURITY_HEADERS);
+					res.end();
+					return;
+				}
+				const id = match[1];
+				const wantsRaw = Boolean(match[2]);
+				const message = findDevMessage(id);
+				if (!message) {
+					res.writeHead(404, {
+						...SECURITY_HEADERS,
+						"Content-Type": "text/plain"
+					});
+					res.end("Email not found.");
+					return;
+				}
+				if (wantsRaw) {
+					const safeId = id.replace(/["\r\n]/g, "");
+					res.writeHead(200, {
+						...SECURITY_HEADERS,
+						"Content-Type": "message/rfc822",
+						"Content-Disposition": `attachment; filename="${safeId}.eml"`
+					});
+					res.end(Buffer.from(message.raw));
+					return;
+				}
+				res.writeHead(200, {
+					...SECURITY_HEADERS,
+					"Content-Type": "text/html; charset=utf-8"
+				});
+				res.end(renderDetailHtml(message, inboxHref));
+			});
+		}
+	};
+}
+/**
+* Constant-time check of the presented token — header first (worker, curl),
+* then the query (browser). Both are compared against the one project token.
+*/
+function isAuthorized(headerValue, url, expected) {
+	const presented = typeof headerValue === "string" ? headerValue : url.searchParams.get(DEV_INBOX_TOKEN_QUERY);
+	if (typeof presented !== "string") return false;
+	const a = Buffer.from(presented);
+	const b = Buffer.from(expected);
+	return a.byteLength === b.byteLength && timingSafeEqual(a, b);
+}
+/**
+* `POST /__void/inbox/_capture` — the worker's dev-inbox hop.
+*
+* Fails with a status the worker can distinguish, and only a success carries
+* the ack header, so the worker never mistakes an ordinary asset 200 for a
+* capture. Never throws: an exception here would surface as a dev-server 500
+* in the middle of the user's `sendEmail`.
+*/
+async function handleCapture(req, res) {
+	try {
+		if (!String(req.headers["content-type"] ?? "").includes("application/json")) {
+			res.writeHead(415, SECURITY_HEADERS);
+			res.end();
+			return;
+		}
+		const chunks = [];
+		let size = 0;
+		for await (const chunk of req) {
+			const buf = typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk);
+			size += buf.byteLength;
+			if (size > DEV_INBOX_MAX_CAPTURE_BYTES) {
+				res.writeHead(413, SECURITY_HEADERS);
+				res.end();
+				return;
+			}
+			chunks.push(buf);
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+		} catch {
+			res.writeHead(400, SECURITY_HEADERS);
+			res.end();
+			return;
+		}
+		const message = parseCapturedMessage(parsed);
+		if (!message) {
+			res.writeHead(400, SECURITY_HEADERS);
+			res.end();
+			return;
+		}
+		pushToDevBuffer(message);
+		res.writeHead(200, {
+			...SECURITY_HEADERS,
+			[DEV_INBOX_ACK_HEADER]: DEV_INBOX_ACK_VALUE,
+			"Content-Type": "application/json"
+		});
+		res.end(JSON.stringify({
+			ok: true,
+			id: message.id
+		}));
+	} catch {
+		res.writeHead(500, SECURITY_HEADERS);
+		res.end();
+	}
+}
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function formatAddress(a) {
+	return a.name ? `${a.name} <${a.email}>` : a.email;
+}
+function formatTime(ts) {
+	return new Date(ts).toLocaleString();
+}
+const STYLE = `
+  :root { color-scheme: light dark; }
+  body { font: 14px/1.5 ui-sans-serif, system-ui, sans-serif; margin: 0; padding: 24px; max-width: 1024px; margin: 0 auto; }
+  h1 { font-size: 18px; margin: 0 0 16px; }
+  h2 { font-size: 14px; margin: 24px 0 8px; text-transform: uppercase; letter-spacing: 0.05em; opacity: 0.7; }
+  table { border-collapse: collapse; width: 100%; }
+  th, td { text-align: left; padding: 8px 12px; border-bottom: 1px solid color-mix(in srgb, currentColor 15%, transparent); vertical-align: top; }
+  th { font-weight: 600; opacity: 0.7; font-size: 12px; text-transform: uppercase; letter-spacing: 0.05em; }
+  a { color: #5b8def; text-decoration: none; }
+  a:hover { text-decoration: underline; }
+  .meta { font-size: 12px; opacity: 0.7; }
+  .empty { padding: 48px; text-align: center; opacity: 0.6; }
+  .row { display: flex; gap: 12px; align-items: baseline; }
+  .row .subject { font-weight: 600; }
+  iframe { width: 100%; min-height: 480px; border: 1px solid color-mix(in srgb, currentColor 15%, transparent); border-radius: 8px; background: white; }
+  .actions { display: flex; gap: 12px; margin-bottom: 16px; }
+  .button { display: inline-block; padding: 6px 12px; border: 1px solid color-mix(in srgb, currentColor 25%, transparent); border-radius: 6px; cursor: pointer; background: transparent; color: inherit; font: inherit; }
+  pre { white-space: pre-wrap; word-break: break-word; padding: 12px; background: color-mix(in srgb, currentColor 5%, transparent); border-radius: 6px; }
+  .header-table th { width: 160px; }
+`;
+function renderListHtml(messages, href) {
+	const rows = messages.map((m) => `
+        <tr>
+          <td><a href="${escapeHtml(href(`/${m.id}`))}">${escapeHtml(m.subject || "(no subject)")}</a></td>
+          <td>${escapeHtml(formatAddress(m.from))}</td>
+          <td>${escapeHtml(m.to.map(formatAddress).join(", "))}</td>
+          <td class="meta">${escapeHtml(formatTime(m.capturedAt))}</td>
+          <td class="meta"><a href="${escapeHtml(href(`/${m.id}/raw`))}">.eml</a></td>
+        </tr>`).join("");
+	return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>Void — Email inbox</title><style>${STYLE}</style></head>
+<body>
+  <h1>Email inbox <span class="meta">(${messages.length} message${messages.length === 1 ? "" : "s"})</span></h1>
+  ${messages.length === 0 ? `<div class="empty">No messages captured yet. Call <code>sendEmail()</code> from your app to populate.</div>` : `<table>
+            <thead><tr><th>Subject</th><th>From</th><th>To</th><th>Captured</th><th></th></tr></thead>
+            <tbody>${rows}</tbody>
+          </table>`}
+</body></html>`;
+}
+function renderDetailHtml(m, href) {
+	const headerRows = Object.entries(m.headers).map(([k, v]) => `<tr><th>${escapeHtml(k)}</th><td>${escapeHtml(v)}</td></tr>`).join("");
+	const attachmentRows = m.attachments.map((a) => `<tr><td>${escapeHtml(a.filename)}</td><td>${escapeHtml(a.contentType)}</td><td>${a.size} B</td><td>${a.disposition}</td></tr>`).join("");
+	const bodyHtml = m.html ? `<iframe sandbox srcdoc="${escapeHtml(m.html)}"></iframe>` : `<pre>${escapeHtml(m.text ?? "")}</pre>`;
+	return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${escapeHtml(m.subject || "(no subject)")} — Void inbox</title><style>${STYLE}</style></head>
+<body>
+  <div class="actions">
+    <a class="button" href="${escapeHtml(href(""))}">← Back</a>
+    <a class="button" href="${escapeHtml(href(`/${m.id}/raw`))}">Download .eml</a>
+  </div>
+  <h1>${escapeHtml(m.subject || "(no subject)")}</h1>
+  <table class="header-table">
+    <tr><th>From</th><td>${escapeHtml(formatAddress(m.from))}</td></tr>
+    <tr><th>To</th><td>${escapeHtml(m.to.map(formatAddress).join(", "))}</td></tr>
+    ${m.cc.length > 0 ? `<tr><th>Cc</th><td>${escapeHtml(m.cc.map(formatAddress).join(", "))}</td></tr>` : ""}
+    ${m.bcc.length > 0 ? `<tr><th>Bcc</th><td>${escapeHtml(m.bcc.map(formatAddress).join(", "))}</td></tr>` : ""}
+    ${m.replyTo ? `<tr><th>Reply-To</th><td>${escapeHtml(formatAddress(m.replyTo))}</td></tr>` : ""}
+    <tr><th>Captured</th><td class="meta">${escapeHtml(formatTime(m.capturedAt))}</td></tr>
+    <tr><th>Message-ID</th><td class="meta">${escapeHtml(m.messageId)}</td></tr>
+  </table>
+  ${headerRows ? `<h2>Custom headers</h2><table class="header-table">${headerRows}</table>` : ""}
+  ${attachmentRows ? `<h2>Attachments</h2><table><thead><tr><th>Filename</th><th>Type</th><th>Size</th><th>Disposition</th></tr></thead><tbody>${attachmentRows}</tbody></table>` : ""}
+  <h2>Body</h2>
+  ${bodyHtml}
+</body></html>`;
+}
+//#endregion
 //#region src/plugin-env-client-fold.ts
 let cachedModule$1 = null;
 async function loadEnvPublic$1() {
@@ -743,8 +1047,7 @@ function pushHit(node, hits) {
 		return;
 	}
 }
-/** Default Vite `envPrefix`. */
-const DEFAULT_ENV_PREFIXES$2 = ["VITE_"];
+const CLIENT_ENV_PREFIX$1 = "VITE_";
 /**
 * Build-time constant folding for client-only `env.FOO` reads.
 *
@@ -759,21 +1062,19 @@ const DEFAULT_ENV_PREFIXES$2 = ["VITE_"];
 *   • 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
+*   • Only folds keys that match Void's fixed `VITE_` client prefix. 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
+*   • Only folds keys with a known build-time value (build shell or schema
+*     `.default(...)`). 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.
+*   • Build-only (`apply: 'build'`). Dev runs through the Proxy so local
+*     `.env` edits take effect without a full rebuild.
 */
 function envClientFoldPlugin() {
-	let envPrefixes = DEFAULT_ENV_PREFIXES$2;
 	let loadedEnv = {};
 	const schemaDefaults = {};
 	/** The merged view the transform consults for each key. */
@@ -782,18 +1083,14 @@ function envClientFoldPlugin() {
 		if (key in schemaDefaults) return schemaDefaults[key];
 	}
 	function isExposedToClient(key) {
-		return envPrefixes.some((p) => key.startsWith(p));
+		return key.startsWith(CLIENT_ENV_PREFIX$1);
 	}
 	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$2;
-			loadedEnv = { ...config.env ?? {} };
+			loadedEnv = config.env ?? {};
 			try {
 				const mod = await loadEnvPublic$1();
 				if (mod._hasRegisteredSchema()) {
@@ -947,18 +1244,11 @@ function recordHit(node, hits) {
 * 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$1 = ["VITE_"];
+const CLIENT_ENV_PREFIX = "VITE_";
 function envClientGuardPlugin(root) {
-	let envPrefixes = DEFAULT_ENV_PREFIXES$1;
 	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;
@@ -1001,10 +1291,9 @@ function envClientGuardPlugin(root) {
 				}
 				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(", ")}`;
+				if (key.startsWith(CLIENT_ENV_PREFIX)) continue;
 				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.`,
+					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 VITE_* prefix 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,
@@ -1028,32 +1317,42 @@ async function loadSchemaModule() {
 * 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
+*   - validates the local dev env (`.env` + 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.
+* so unrelated work isn't blocked by a stale local value.
 */
 /** 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_]*)$/;
-const DEFAULT_ENV_PREFIXES = ["VITE_"];
-function resolveEnvPrefixes(prefix) {
-	if (typeof prefix === "string") return [prefix];
-	if (Array.isArray(prefix) && prefix.length > 0) return prefix;
-	return DEFAULT_ENV_PREFIXES;
-}
+const CLIENT_ENV_PREFIXES = [CLIENT_ENV_PREFIX$2];
 function envSchemaPlugin(root, options = {}) {
 	const outDir = join(root, ".void");
 	let envFile = null;
-	let viteMode = "development";
-	let envDir = root;
+	let command = "serve";
 	const appliedClientDefaults = /* @__PURE__ */ new Map();
-	async function emitDefaults() {
-		if (!envFile || !options.onDefaults) return;
-		const { _hasRegisteredSchema, _getSchemaDefaults } = await loadSchemaModule();
+	async function emitSchemaFacts(prefixes) {
+		if (!envFile || !options.onSchema) return;
+		const { _hasRegisteredSchema, _getRegisteredSchema } = await loadSchemaModule();
 		if (!_hasRegisteredSchema()) return;
-		options.onDefaults(_getSchemaDefaults());
+		const schema = _getRegisteredSchema() ?? {};
+		const keys = Object.keys(schema);
+		const clientKeys = keys.filter((key) => prefixes.some((prefix) => key.startsWith(prefix)));
+		const clientKeySet = new Set(clientKeys);
+		const serverKeys = keys.filter((key) => !clientKeySet.has(key));
+		const requiredServerKeys = [];
+		for (const key of serverKeys) {
+			const result = schema[key]["~standard"].validate(void 0);
+			const resolved = result instanceof Promise ? await result : result;
+			if (resolved && typeof resolved === "object" && "issues" in resolved && resolved.issues) requiredServerKeys.push(key);
+		}
+		options.onSchema({
+			keys,
+			clientKeys,
+			serverKeys,
+			requiredServerKeys
+		});
 	}
 	function regenerateTypes() {
 		if (!envFile) return;
@@ -1061,11 +1360,12 @@ function envSchemaPlugin(root, options = {}) {
 		const { dts } = generateEnvTypes(envFile, outDir);
 		writeFileIfChanged(join(outDir, "env.d.ts"), dts);
 	}
-	async function importUserEnv() {
+	async function importUserEnv(strict = false) {
 		if (!envFile) return;
 		try {
 			await loadUserEnvFile(envFile);
 		} catch (err) {
+			if (strict) throw err;
 			voidWarn(err.message);
 		}
 	}
@@ -1093,41 +1393,76 @@ function envSchemaPlugin(root, options = {}) {
 		if (!envFile) return;
 		const { _hasRegisteredSchema, validateAllEnv } = await loadSchemaModule();
 		if (!_hasRegisteredSchema()) return;
-		const { loadEnv } = await import("vite");
-		const report = await validateAllEnv(filterLoadedEnv(loadEnv(viteMode, envDir, "")));
+		const report = await validateAllEnv({
+			...loadLocalEnv(root, { onWarn: (message) => voidWarn(message) }),
+			...process.env
+		});
 		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 of report.missing) lines.push(`  • ${key} is required but missing — add it to .env or set it in your shell`);
 		for (const { key, messages } of report.invalid) lines.push(`  • ${key}: ${messages.join("; ")}`);
 		voidWarn(lines.join("\n"));
 	}
-	async function applyClientDefaultsToViteEnv(config) {
+	async function applyClientValuesToViteEnv(config) {
 		if (!envFile) return;
-		for (const [key, value] of appliedClientDefaults) if (config.env[key] === value) delete config.env[key];
+		const configEnv = config.env ?? {};
+		for (const [key, value] of appliedClientDefaults) if (configEnv[key] === value) delete configEnv[key];
 		appliedClientDefaults.clear();
-		const { _hasRegisteredSchema, _getSchemaDefaults } = await loadSchemaModule();
+		const { _hasRegisteredSchema, _getRegisteredSchema, _getSchemaDefaults } = await loadSchemaModule();
 		if (!_hasRegisteredSchema()) return;
-		const prefixes = resolveEnvPrefixes(config.envPrefix);
+		const schema = _getRegisteredSchema() ?? {};
+		const readable = {
+			...command === "serve" ? loadLocalEnv(root) : {},
+			...process.env
+		};
+		for (const key of Object.keys(schema)) {
+			if (!key.startsWith("VITE_") || configEnv[key] !== void 0) continue;
+			const value = readable[key];
+			if (value !== void 0) configEnv[key] = value;
+		}
 		for (const [key, value] of Object.entries(_getSchemaDefaults())) {
-			if (!prefixes.some((prefix) => key.startsWith(prefix))) continue;
-			if (config.env[key] !== void 0) continue;
-			config.env[key] = value;
+			if (!key.startsWith("VITE_")) continue;
+			if (configEnv[key] !== void 0) continue;
+			configEnv[key] = value;
 			appliedClientDefaults.set(key, value);
 		}
 	}
 	return {
 		name: "void:env-schema",
-		async config() {
+		enforce: "pre",
+		async config(_config, environment) {
+			const legacyFiles = findLegacyEnvFiles(root);
+			if (legacyFiles.length > 0) throw new Error(`void/env supports one local file: .env. Remove ${legacyFiles.join(", ")} and follow the env migration guide.`);
 			envFile = findEnvFile(root);
 			if (!envFile) return;
 			regenerateTypes();
-			await importUserEnv();
-			await emitDefaults();
+			await importUserEnv(environment.command === "build");
+			await emitSchemaFacts(CLIENT_ENV_PREFIXES);
 		},
 		async configResolved(config) {
-			viteMode = config.mode;
-			envDir = typeof config.envDir === "string" ? config.envDir : root;
-			await applyClientDefaultsToViteEnv(config);
+			command = config.command;
+			await emitSchemaFacts(CLIENT_ENV_PREFIXES);
+			if (command === "build") {
+				const local = loadLocalEnv(root, { onWarn: (message) => voidWarn(message) });
+				for (const [key, value] of Object.entries(local)) if (process.env[key] === void 0 && config.env[key] === value) delete config.env[key];
+			}
+			await applyClientValuesToViteEnv(config);
+			if (command === "build" && envFile) {
+				const { validateAllEnv } = await loadSchemaModule();
+				const report = await validateAllEnv({
+					...config.env,
+					...process.env
+				});
+				const clientKey = (key) => key.startsWith(CLIENT_ENV_PREFIX$2);
+				const missing = report.missing.filter(clientKey);
+				const invalid = report.invalid.filter(({ key }) => clientKey(key));
+				if (missing.length > 0 || invalid.length > 0) {
+					const lines = ["Client env validation failed:"];
+					for (const key of missing) lines.push(`  • ${key} is required — set it in the build shell or add a schema default`);
+					for (const { key, messages } of invalid) lines.push(`  • ${key}: ${messages.join("; ")}`);
+					throw new Error(lines.join("\n"));
+				}
+			}
 			if (envFile && config.define) await warnOnDefineOverlap(config.define);
 		},
 		async configureServer(server) {
@@ -1144,8 +1479,8 @@ function envSchemaPlugin(root, options = {}) {
 					voidLog("env.ts changed — regenerating types");
 					regenerateTypes();
 					await importUserEnv();
-					await emitDefaults();
-					await applyClientDefaultsToViteEnv(server.config);
+					await emitSchemaFacts(CLIENT_ENV_PREFIXES);
+					await applyClientValuesToViteEnv(server.config);
 					await validateAndWarn();
 					server.ws.send({ type: "full-reload" });
 				}
@@ -1158,6 +1493,7 @@ function envSchemaPlugin(root, options = {}) {
 }
 //#endregion
 //#region src/plugin-framework-triggers.ts
+const DISPATCH_FILE_MODE = 384;
 /** Absolute path of the generated dispatch file. Stable across the dev process. */
 function frameworkTriggersDispatchPath(root) {
 	return join(root, ".void", "dev-triggers.ts");
@@ -1174,7 +1510,10 @@ function writeFrameworkTriggersDispatch(root, devTriggerToken) {
 	const queues = scanQueuesSync(root, paths.queuesDir);
 	const target = frameworkTriggersDispatchPath(root);
 	mkdirSync(dirname(target), { recursive: true });
-	writeFileSync(target, generateModule(paths.cronsDir, paths.queuesDir, jobs, queues, devTriggerToken));
+	writeFileSync(target, generateModule(paths.cronsDir, paths.queuesDir, jobs, queues, devTriggerToken), { mode: DISPATCH_FILE_MODE });
+	if (process.platform !== "win32") try {
+		chmodSync(target, DISPATCH_FILE_MODE);
+	} catch {}
 }
 /**
 * Writes a real file at `<root>/.void/dev-triggers.ts` exporting
@@ -1616,24 +1955,12 @@ function astroDevTriggerInjectPlugin(root) {
 //#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;
-	}
+	return loadLocalEnv(root).DATABASE_URL;
 }
 /**
 * 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.
+* For PostgreSQL/MySQL: connects via DATABASE_URL from .env.
 */
 function migrationPlugin(root, dialect, databaseId = "local", persistRoot = join(root, ".void"), auth) {
 	return {
@@ -1644,35 +1971,34 @@ function migrationPlugin(root, dialect, databaseId = "local", persistRoot = join
 			const hasSqlMigrations = existsSync(migrationsDir);
 			if (!hasSqlMigrations && !auth?.enabled) return;
 			try {
-				if (hasSqlMigrations && dialect === "postgresql") {
+				if (hasSqlMigrations && dialect !== "sqlite") {
 					const url = readDatabaseUrl(root);
 					if (!url) {
 						const warn = () => {
 							console.log();
-							voidError("DATABASE_URL not found in .env.local — skipping PostgreSQL migrations.");
+							voidError(`DATABASE_URL not found in .env — skipping ${dialect === "mysql" ? "MySQL" : "PostgreSQL"} migrations.`);
 						};
 						if (server.httpServer) server.httpServer.once("listening", () => setTimeout(warn, 100));
 						else warn();
 						return;
 					}
-					const { runPgMigrations, getPgAppliedMigrations } = await import("./runner-pg-CHM76xuC.mjs");
-					const { collectMigrations } = await import("./validate-Cw_RLeTj.mjs").then((n) => n.l);
-					const { validateMigrations } = await import("./validate-Cw_RLeTj.mjs").then((n) => n.i);
+					const { collectMigrations } = await import("./validate-Bihr8WBi.mjs").then((n) => n.l);
+					const { validateMigrations } = await import("./validate-Bihr8WBi.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);
+					const appliedNames = dialect === "mysql" ? await import("./runner-mysql-CgRFl3s6.mjs").then((n) => n.n).then((runner) => runner.getMySqlAppliedMigrations(url)) : await import("./runner-pg-DCkWPsWS.mjs").then((n) => n.n).then((runner) => runner.getPgAppliedMigrations(url));
+					const appliedSet = new Set(appliedNames);
+					const pending = allMigrations.filter((migration) => !appliedSet.has(migration.name));
+					if (pending.length > 0) try {
+						validateMigrations(pending);
 					} catch (err) {
 						voidWarn(err instanceof Error ? err.message : String(err));
 					}
-					const applied = await runPgMigrations(migrationsDir, url);
+					const applied = dialect === "mysql" ? await import("./runner-mysql-CgRFl3s6.mjs").then((n) => n.n).then((runner) => runner.runMySqlMigrations(migrationsDir, url)) : await import("./runner-pg-DCkWPsWS.mjs").then((n) => n.n).then((runner) => runner.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-kapo9aPs.mjs");
-					const { collectMigrations } = await import("./validate-Cw_RLeTj.mjs").then((n) => n.l);
-					const { validateMigrations } = await import("./validate-Cw_RLeTj.mjs").then((n) => n.i);
+					const { runMigrations, getMiniflareDatabasePath, getAppliedMigrations } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+					const { collectMigrations } = await import("./validate-Bihr8WBi.mjs").then((n) => n.l);
+					const { validateMigrations } = await import("./validate-Bihr8WBi.mjs").then((n) => n.i);
 					const dbPath = getMiniflareDatabasePath(persistRoot, databaseId);
 					const allMigrations = collectMigrations(migrationsDir);
 					const appliedRows = await getAppliedMigrations(dbPath);
@@ -1687,7 +2013,7 @@ function migrationPlugin(root, dialect, databaseId = "local", persistRoot = join
 					if (applied.length > 0) voidLog(`Applied ${applied.length} migration(s): ${applied.join(", ")}`);
 				}
 				if (auth?.enabled) {
-					const { runLocalVoidAuthMigrations } = await import("./node-Da0UcsGA.mjs");
+					const { runLocalVoidAuthMigrations } = await import("./node-BkaXcpAc.mjs");
 					await runLocalVoidAuthMigrations(root, dialect, persistRoot, databaseId, auth.configPath);
 					voidLog("Applied Better Auth migrations");
 				}
@@ -1775,6 +2101,14 @@ function nodeTargetPlugin(target) {
 				throw new Error(`target: '${id}' is not available with target '${target}'. CF bindings require target: "cloudflare".`);
 			}
 		},
+		renderChunk(code, chunk) {
+			if (!code.includes("import.meta.voidClientDirectory")) return null;
+			const clientPath = relative(dirname(chunk.fileName), "../client");
+			return {
+				code: code.replaceAll("import.meta.voidClientDirectory", `new URL(${JSON.stringify(`${clientPath}/`)}, import.meta.url)`),
+				map: null
+			};
+		},
 		config(_, { command }) {
 			if (command !== "build") return;
 			const root = process.cwd();
@@ -1839,6 +2173,7 @@ function prerenderPlugin(root, config) {
 		apply: "build",
 		async closeBundle() {
 			if (config.output !== "static") return;
+			if (process.env.VOID_DEPLOY_BUILD === "1") return;
 			if (this.environment?.name !== "client") return;
 			setShowTimestamp(false);
 			const distDir = resolveDistDir(root);
@@ -1851,12 +2186,15 @@ function prerenderPlugin(root, config) {
 			});
 			else {
 				const persistDir = join(root, ".void");
+				const workerDirName = resolveWorkerDirName(distDir);
+				const workerDir = join(distDir, workerDirName);
+				const remoteMode = resolveRemoteMode(config.remote);
 				result = await prerenderPages({
 					root,
-					workerDir: join(distDir, resolveWorkerDirName(distDir)),
+					workerDir,
 					clientDir,
 					persistDir,
-					remoteMode: resolveRemoteMode(config.remote),
+					remoteMode,
 					projectId: process.env.VOID_DEPLOY_PROJECT_ID || void 0
 				});
 			}
@@ -2535,10 +2873,11 @@ function pushDefaultErrorPageHelpers(lines, options) {
 * - 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, mergedRevalidate) {
+function compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, ssr, options, pages = null, mergedRevalidate, isrPages, isrPathRevalidate) {
 	const lines = [];
 	const auth = options.auth;
 	const webSockets = scan.websockets ?? [];
+	const managedDispatch = options.nodeTarget !== true && options.dev !== true && options.managedDispatch === true;
 	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)};`);
@@ -2557,7 +2896,7 @@ function compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, s
 		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)};`);
+	if ((webSockets.length > 0 || options.webSocketTombstones?.length) && options.webSocketRuntimePath) lines.push(`import { createWebSocketDurableObject as __createWebSocketDurableObject, createWebSocketTombstoneDurableObject as __createWebSocketTombstoneDurableObject, forwardWebSocketRequest as __forwardWebSocketRequest } from ${JSON.stringify(options.webSocketRuntimePath)};`);
 	if (options.hasLive && options.liveRuntimePath) lines.push(`import { createLiveDurableObject as __createLiveDurableObject } from ${JSON.stringify(options.liveRuntimePath)};`);
 	lines.push("");
 	for (let i = 0; i < scan.middleware.length; i++) {
@@ -2642,7 +2981,7 @@ function compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, s
 	lines.push("");
 	ensureMergeQueryHelperEmitted(lines);
 	lines.push("app.use(async (c, next) => {");
-	if (!options.nodeTarget && options.dev !== true) {
+	if (managedDispatch) {
 		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) {");
@@ -2692,7 +3031,7 @@ function compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, s
 	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;
+	const emitEdgeRules = !managedDispatch;
 	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) {
@@ -2703,6 +3042,14 @@ function compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, s
 	}
 	for (let i = 0; i < scan.middleware.length; i++) lines.push(`app.use(middleware${i});`);
 	if (scan.middleware.length > 0) lines.push("");
+	for (let i = 0; i < webSockets.length; i++) {
+		const route = webSockets[i];
+		lines.push(`app.all(${JSON.stringify(route.pattern)}, async (c, next) => {`);
+		lines.push(`  if (c.req.raw.headers.get("upgrade")?.toLowerCase() !== "websocket") return next();`);
+		lines.push(`  return __forwardWebSocketRequest(c.req.raw, c.env, __voidWebSocketRoutes[${i}]);`);
+		lines.push("});");
+	}
+	if (webSockets.length > 0) lines.push("");
 	if (auth) {
 		lines.push("app.all(\"/api/auth\", async (c) => {");
 		lines.push(`  return handleVoidAuthRequest(c, __voidAuthOptions${auth.authDatabasePath ? ", __voidAuthDatabase" : ""});`);
@@ -2760,21 +3107,10 @@ function compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, s
 			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("");
 	}
+	for (const className of options.webSocketTombstones ?? []) lines.push(`export const ${className} = __createWebSocketTombstoneDurableObject(${JSON.stringify(className)});`);
+	if (options.webSocketTombstones?.length) lines.push("");
 	if (options.hasLive) {
 		lines.push("export const VoidLiveStreamDurableObject = __createLiveDurableObject();");
 		lines.push("");
@@ -2899,7 +3235,7 @@ window.__vite_plugin_react_preamble_installed__ = true;
 		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) {
+		if (!options.nodeTarget && emitEdgeRules && 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);
@@ -2910,16 +3246,16 @@ window.__vite_plugin_react_preamble_installed__ = true;
 		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)) {
+	} else if (emitEdgeRules && (options.fallbackRules?.length || !options.nodeTarget && options.headerRules?.length) && !(pages && scan.pages.pages.length > 0)) {
 		lines.push(`app.notFound(async (c) => {`);
-		if (!options.nodeTarget && options.dev === true) {
+		if (!options.nodeTarget) {
 			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);
+		if (options.fallbackRules?.length) 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("");
@@ -2931,22 +3267,20 @@ window.__vite_plugin_react_preamble_installed__ = true;
 		}
 		lines.push("");
 		lines.push("export async function scheduled(controller, env, ctx) {");
-		lines.push("  switch (controller.cron) {");
+		lines.push("  const tasks = [];");
 		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(`  if (job${i}Crons.includes(controller.cron)) {`);
+			lines.push("    tasks.push((async () => {");
 			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("      if (typeof mod.default === 'function') await mod.default(controller, env, ctx);");
+			lines.push("    })());");
+			lines.push("  }");
 		}
-		lines.push("    default:");
-		lines.push("      return;");
-		lines.push("  }");
+		lines.push("  const results = await Promise.allSettled(tasks);");
+		lines.push("  const errors = results.filter(result => result.status === \"rejected\").map(result => result.reason);");
+		lines.push("  if (errors.length) throw new AggregateError(errors, \"Scheduled jobs failed\");");
 		lines.push("}");
 		lines.push("");
 	} else {
@@ -2970,10 +3304,14 @@ window.__vite_plugin_react_preamble_installed__ = true;
 		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(generateQueueResolverSource(scan.queues.map((queue) => queue.name)));
 		lines.push("");
 		lines.push("export async function __processQueue(payload, env) {");
 		lines.push("  const queueSuffix = payload.queue;");
+		lines.push("  const __queueIndex = __resolveQueueIndex(queueSuffix);");
+		lines.push("  if (__queueIndex === -1) {");
+		lines.push("    return { ok: false, error: `No unambiguous queue handler matches \"${String(queueSuffix)}\"` };");
+		lines.push("  }");
 		lines.push("  const __decisions = new Map();");
 		lines.push("  function __wrapMsg(m) {");
 		lines.push("    let decided = false;");
@@ -2992,12 +3330,14 @@ window.__vite_plugin_react_preamble_installed__ = true;
 		lines.push("  };");
 		lines.push("  let __ok = true;");
 		lines.push("  try {");
+		lines.push("    switch (__queueIndex) {");
 		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(`      case ${i}: {`);
+			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("        break;");
+			lines.push("      }");
 		}
 		lines.push("    }");
 		lines.push("  } catch { __ok = false; }");
@@ -3018,6 +3358,63 @@ window.__vite_plugin_react_preamble_installed__ = true;
 		lines.push("app.post(\"/__void/queue\", __queueHandler);");
 		lines.push("");
 	}
+	const email = scan.email;
+	const emailDir = options.emailDir;
+	if (emailDir && email && (email.addresses.length > 0 || email.defaultHandler)) {
+		if (email.defaultHandler) lines.push(`const __emailDefault = () => import(${JSON.stringify(`${emailDir}/${email.defaultHandler}`)});`);
+		for (let i = 0; i < email.addresses.length; i++) {
+			const def = email.addresses[i];
+			lines.push(`const __emailAddr${i} = () => import(${JSON.stringify(`${emailDir}/${def.filePath}`)});`);
+		}
+		if (email.addresses.length > 0) {
+			lines.push("const __emailPatterns = [");
+			for (let i = 0; i < email.addresses.length; i++) {
+				const def = email.addresses[i];
+				const path = `${emailDir}/${def.filePath}`;
+				lines.push(`  { re: new RegExp(${JSON.stringify(def.pattern.regexSource)}, "i"), params: ${JSON.stringify(def.pattern.paramNames)}, path: ${JSON.stringify(path)}, load: __emailAddr${i} },`);
+			}
+			lines.push("];");
+		}
+		lines.push("");
+		lines.push("export async function __emailHandler(message, env, ctx, __opts) {");
+		lines.push("  const __platformTo = message ? message.__voidPlatformTo : undefined;");
+		lines.push("  const __to = String((__platformTo ?? (message && message.to)) || \"\");");
+		lines.push("  const __localFull = __to.split(\"@\")[0] || \"\";");
+		lines.push("  let __local = __localFull;");
+		lines.push("  if (__opts && __opts.slug) {");
+		lines.push("    const __plus = __localFull.indexOf(\"+\");");
+		lines.push("    __local = __plus === -1 ? \"\" : __localFull.slice(__plus + 1);");
+		lines.push("  }");
+		if (email.addresses.length > 0) {
+			lines.push("  for (const __p of __emailPatterns) {");
+			lines.push("    const __m = __p.re.exec(__local);");
+			lines.push("    if (!__m) continue;");
+			lines.push("    const __params = {};");
+			lines.push("    for (let __i = 0; __i < __p.params.length; __i++) {");
+			lines.push("      __params[__p.params[__i]] = __m[__i + 1];");
+			lines.push("    }");
+			lines.push("    const __mod = await __p.load();");
+			lines.push("    if (typeof __mod.default !== \"function\") {");
+			lines.push("      throw new Error(\"email handler at \" + __p.path + \" has no default export\");");
+			lines.push("    }");
+			lines.push("    return await __mod.default(message, env, ctx, { params: __params });");
+			lines.push("  }");
+		}
+		if (email.defaultHandler) {
+			const defaultPath = `${emailDir}/${email.defaultHandler}`;
+			lines.push("  const __dmod = await __emailDefault();");
+			lines.push("  if (typeof __dmod.default !== \"function\") {");
+			lines.push(`    throw new Error("email handler at " + ${JSON.stringify(defaultPath)} + " has no default export");`);
+			lines.push("  }");
+			lines.push("  return await __dmod.default(message, env, ctx, { params: {} });");
+		} else {
+			lines.push("  if (typeof message.setReject === \"function\") {");
+			lines.push("    message.setReject(\"no handler matched recipient \\\"\" + __to + \"\\\" — add email/_default.ts to handle unmatched mail\");");
+			lines.push("  }");
+		}
+		lines.push("}");
+		lines.push("");
+	}
 	if (options.migrationHandlerPath && (options.migrations?.length || auth)) {
 		const d1BindingName = options.bindingNames?.d1;
 		lines.push(`import { createMigrationHandler as __createMigrationHandler } from ${JSON.stringify(options.migrationHandlerPath)};`);
@@ -3136,6 +3533,8 @@ window.__vite_plugin_react_preamble_installed__ = true;
 	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(`export const __VOID_ISR_REVALIDATE = ${JSON.stringify(mergedRevalidate)};`);
+	lines.push(`export const __VOID_ISR_PAGES = ${JSON.stringify(isrPages)};`);
+	lines.push(`export const __VOID_ISR_PATH_REVALIDATE = ${JSON.stringify(isrPathRevalidate)};`);
 	lines.push(`export const __VOID_ISR_DEPLOYMENT_ID = ${JSON.stringify(crypto.randomUUID())};`);
 	lines.push("");
 	lines.push(`export default app;`);
@@ -3540,7 +3939,7 @@ function compilePageRoutes(lines, scan, pages, options) {
 	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);
+	if (!(options.nodeTarget !== true && options.dev !== true && options.managedDispatch === 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(`  }`);
@@ -3633,7 +4032,11 @@ ${fallthroughCode}
 * 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, live, isr, notFound = "none") {
+function deriveEmailRuntimePath(runtimeEnvPath) {
+	return runtimeEnvPath.replace(/_?env(\.[^/]+)?$/, (_m, ext) => "email" + (ext ?? ""));
+}
+function compileWorkerEntry(options = {}) {
+	const { hasQueues = false, remote, assetsDir = "assets", webSocketClasses = [], runtimeEnvPath = "void/_env", runtimeEmailPath, envSchemaModule, sandbox, serveSpaFallback = false, hasEmail = false, live, isr, notFound = "none", durableObjects = [] } = options;
 	const remotePath = remote?.remotePath;
 	const remoteBindingNames = JSON.stringify(remote?.bindingNames);
 	const createRemoteEnvCall = `createRemoteEnv(env${remote?.bindingNames ? `, ${remoteBindingNames}` : ""})`;
@@ -3649,10 +4052,13 @@ function compileWorkerEntry(hasQueues = false, remote, assetsDir = "assets", web
 	const liveRouteImport = hasLive ? ", VoidLiveStreamDurableObject" : "";
 	const liveRuntimeImport = hasLive ? `import { __setLiveBindingName } from "void/live";\n` : "";
 	const liveExport = hasLive ? liveClassName === "VoidLiveStreamDurableObject" ? `export { VoidLiveStreamDurableObject };\n__setLiveBindingName(${JSON.stringify(liveBindingName)});\n` : `export { VoidLiveStreamDurableObject as ${liveClassName} };\n__setLiveBindingName(${JSON.stringify(liveBindingName)});\n` : "";
+	const durableObjectImports = durableObjects.map(({ filePath }, index) => `import __voidDurableObject${index} from ${JSON.stringify(filePath)};`).join("\n");
+	const durableObjectExports = durableObjects.map(({ bindingName, className }, index) => `__voidDurableObject${index}.__bind(${JSON.stringify(bindingName)});\nexport const ${className} = __voidDurableObject${index}.class;`).join("\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 fetchEnvValidateCall = envSchemaModule ? "  if (request.method !== \"POST\" || new URL(request.url).pathname !== \"/__void/prerender-paths\") await _validateEnvOnce(env);\n" : "";
 	const exactNames = isr ? INTERNAL_BINDING_EXACT_NAMES : [];
 	const prefixCheck = [...INTERNAL_BINDING_PREFIXES.map((p) => `prop.startsWith(${JSON.stringify(p)})`), ...exactNames.map((n) => `prop === ${JSON.stringify(n)}`)].join(" || ");
 	const filterBindingsHelper = `
@@ -3679,19 +4085,17 @@ function __filterInternalBindings(env) {
 }
 `;
 	const assetHelper = compileAssetFallbackHelper(assetsDir, serveSpaFallback, notFound);
-	const isrImport = isr ? `import { handleIsr } from ${JSON.stringify(isr.runtimePath)};\nimport { __VOID_ISR_REVALIDATE, __VOID_ISR_DEPLOYMENT_ID } from 'virtual:void-routes';\n` : "";
+	const isrImport = isr ? `import { handleIsr } from ${JSON.stringify(isr.runtimePath)};\nimport { __VOID_ISR_REVALIDATE, __VOID_ISR_PAGES, __VOID_ISR_PATH_REVALIDATE, __VOID_ISR_DEPLOYMENT_ID } from 'virtual:void-routes';\n` : "";
 	const isrEnvCapture = isr ? `  env.__VOID_ISR_DEPLOYMENT_ID ??= __VOID_ISR_DEPLOYMENT_ID;\n  env.__VOID_ISR_HOST = new URL(request.url).hostname;\n` : "";
 	const isrDeploymentStamp = isr ? `  env.__VOID_ISR_DEPLOYMENT_ID ??= __VOID_ISR_DEPLOYMENT_ID;\n` : "";
 	const renderBlock = isr ? `      const __render = async (req) => serveWithAssets(req, env, await app.fetch(req, userEnv, ctx));
-      if (env.ISR_CACHE) {
-        const __isr = await handleIsr(request, env, ctx, { revalidate: __VOID_ISR_REVALIDATE, deploymentId: __VOID_ISR_DEPLOYMENT_ID }, __render);
+      if (env.ISR_CACHE && request.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+        const __isr = await handleIsr(request, env, ctx, { revalidate: __VOID_ISR_REVALIDATE, pages: __VOID_ISR_PAGES, pathRevalidate: __VOID_ISR_PATH_REVALIDATE, deploymentId: __VOID_ISR_DEPLOYMENT_ID, queryAllowlist: ${JSON.stringify(isr?.queryAllowlist)} }, __render);
         if (__isr) return __isr;
       }
       return __render(request);` : `      return serveWithAssets(request, env, await app.fetch(request, userEnv, ctx));`;
 	const fetchHandler = remotePath ? `async (request, env, ctx) => {
-${envValidateCall}  const ws = await __voidHandleWebSocket(request, env);
-  if (ws) return ws;
-  if (env.__VOID_REMOTE === "1") env = ${createRemoteEnvCall};
+${fetchEnvValidateCall}  if (env.__VOID_REMOTE === "1") env = ${createRemoteEnvCall};
 ${isrEnvCapture}  return __withRawEnv(env, () => {
     const userEnv = __filterInternalBindings(env);
     return withRuntimeEnv(env, async () => {
@@ -3701,9 +4105,7 @@ ${renderBlock}
     });
   });
 }` : `async (request, env, ctx) => {
-${envValidateCall}  const ws = await __voidHandleWebSocket(request, env);
-  if (ws) return ws;
-${isrEnvCapture}  return __withRawEnv(env, () => {
+${fetchEnvValidateCall}${isrEnvCapture}  return __withRawEnv(env, () => {
     const userEnv = __filterInternalBindings(env);
     return withRuntimeEnv(env, async () => {
       const internal = await __handleInternal(request, env, ctx);
@@ -3740,11 +4142,40 @@ ${isrDeploymentStamp}  const userEnv = __filterInternalBindings(env);
 ${envValidateCall}${isrDeploymentStamp}  const userEnv = __filterInternalBindings(env);
   return withRuntimeEnv(env, () => scheduled(controller, userEnv, ctx));
 }`;
-	if (hasQueues) return `${sandboxImport}${liveRuntimeImport}import app, { scheduled, __voidCollectPrerenderPaths, __voidHandleInternalRoute, __voidHandleWebSocket, __withRawEnv, __processQueue${webSocketClasses.length > 0 ? `, ${webSocketClasses.join(", ")}` : ""}${liveRouteImport} } from 'virtual:void-routes';
-${runtimeEnvImport}${envSchemaImport}${remoteImport}${isrImport}${filterBindingsHelper}${assetHelper}
+	const emailImport = hasEmail ? ", __emailHandler" : "";
+	const emailRuntimePath = runtimeEmailPath ?? deriveEmailRuntimePath(runtimeEnvPath);
+	const emailProxyImport = hasEmail ? `import { createMessageProxy as __createMessageProxy, enactEmailActions as __enactEmailActions, isForwardableEmailMessage as __isForwardableEmailMessage } from ${JSON.stringify(emailRuntimePath)};\n` : "";
+	const emailHandler = hasEmail ? remotePath ? `async function handleEmail(envelope, env, ctx) {
+${envValidateCall}  if (env.__VOID_REMOTE === "1") env = ${createRemoteEnvCall};
+  const userEnv = __filterInternalBindings(env);
+  const __slug = typeof env.__VOID_PROJECT_SLUG === "string" && env.__VOID_PROJECT_SLUG.length > 0 ? env.__VOID_PROJECT_SLUG : undefined;
+  const { message, getActions } = __createMessageProxy(envelope, { slug: __slug });
+  await __withRawEnv(env, () => withRuntimeEnv(env, () => __emailHandler(message, userEnv, ctx, { slug: __slug })));
+  const __actions = getActions();
+  if (__isForwardableEmailMessage(envelope)) await __enactEmailActions(envelope, __actions);
+  return __actions;
+}` : `async function handleEmail(envelope, env, ctx) {
+${envValidateCall}  const userEnv = __filterInternalBindings(env);
+  const __slug = typeof env.__VOID_PROJECT_SLUG === "string" && env.__VOID_PROJECT_SLUG.length > 0 ? env.__VOID_PROJECT_SLUG : undefined;
+  const { message, getActions } = __createMessageProxy(envelope, { slug: __slug });
+  await __withRawEnv(env, () => withRuntimeEnv(env, () => __emailHandler(message, userEnv, ctx, { slug: __slug })));
+  const __actions = getActions();
+  if (__isForwardableEmailMessage(envelope)) await __enactEmailActions(envelope, __actions);
+  return __actions;
+}` : "";
+	const entryImport = `import { WorkerEntrypoint } from "cloudflare:workers";\n`;
+	const fetchDeclaration = `const __voidFetch = ${fetchHandler};`;
+	const entryClass = `export default class extends WorkerEntrypoint {
+  async fetch(request) { return __voidFetch(request, this.env, this.ctx); }
+  async scheduled(controller) { return handleScheduled(controller, this.env, this.ctx); }
+${hasQueues ? `  async queue(batch) { return __voidQueue(batch, this.env, this.ctx); }\n` : ""}${hasEmail ? `  async email(envelope) { return handleEmail(envelope, this.env, this.ctx); }\n` : ""}}`;
+	if (hasQueues) return `${sandboxImport}${entryImport}${liveRuntimeImport}import app, { scheduled, __voidCollectPrerenderPaths, __voidHandleInternalRoute, __withRawEnv, __processQueue${emailImport}${webSocketClasses.length > 0 ? `, ${webSocketClasses.join(", ")}` : ""}${liveRouteImport} } from 'virtual:void-routes';
+${durableObjectImports}\n${runtimeEnvImport}${emailProxyImport}${envSchemaImport}${remoteImport}${isrImport}${filterBindingsHelper}${assetHelper}
 ${internalRouteHelper}
+${fetchDeclaration}
 ${scheduledHandler}
-async function queue(batch, env, ctx) {
+${emailHandler}
+async function __voidQueue(batch, env, ctx) {
 ${envValidateCall}${remotePath ? `  if (env.__VOID_REMOTE === "1") env = ${createRemoteEnvCall};\n` : ""}${isrDeploymentStamp}  const userEnv = __filterInternalBindings(env);
   const messages = [...batch.messages].map(m => ({
     id: m.id, timestamp: m.timestamp.toISOString(),
@@ -3768,15 +4199,19 @@ ${envValidateCall}${remotePath ? `  if (env.__VOID_REMOTE === "1") env = ${creat
 ${webSocketClasses.map((name) => `export { ${name} };`).join("\n")}
 ${liveExport}
 ${sandboxExport}
-export default { fetch: ${fetchHandler}, scheduled: handleScheduled, queue };`;
-	return `${sandboxImport}${liveRuntimeImport}import app, { scheduled, __voidCollectPrerenderPaths, __voidHandleInternalRoute, __voidHandleWebSocket, __withRawEnv${webSocketClasses.length > 0 ? `, ${webSocketClasses.join(", ")}` : ""}${liveRouteImport} } from 'virtual:void-routes';
-${runtimeEnvImport}${envSchemaImport}${remoteImport}${isrImport}${filterBindingsHelper}${assetHelper}
+${durableObjectExports}
+${entryClass}`;
+	return `${sandboxImport}${entryImport}${liveRuntimeImport}import app, { scheduled, __voidCollectPrerenderPaths, __voidHandleInternalRoute, __withRawEnv${emailImport}${webSocketClasses.length > 0 ? `, ${webSocketClasses.join(", ")}` : ""}${liveRouteImport} } from 'virtual:void-routes';
+${durableObjectImports}\n${runtimeEnvImport}${emailProxyImport}${envSchemaImport}${remoteImport}${isrImport}${filterBindingsHelper}${assetHelper}
 ${internalRouteHelper}
+${fetchDeclaration}
 ${scheduledHandler}
+${emailHandler}
 ${webSocketClasses.map((name) => `export { ${name} };`).join("\n")}
 ${liveExport}
 ${sandboxExport}
-export default { fetch: ${fetchHandler}, scheduled: handleScheduled };`;
+${durableObjectExports}
+${entryClass}`;
 }
 /**
 * Generate the app module — exports the Hono app with static asset serving.
@@ -3792,11 +4227,17 @@ export default { fetch: ${fetchHandler}, scheduled: handleScheduled };`;
 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` : "";
+	const envMiddleware = envSchemaModule ? `app.use("*", async (c, next) => { if (c.req.method !== "POST" || c.req.path !== "/__void/prerender-paths") await _validateEnvOnce(${target === "deno" ? "Deno.env.toObject()" : "process.env"}); return next(); });\n` : "";
 	return `${staticImport}
+import { fileURLToPath } from "node:url";
 import { Hono } from ${JSON.stringify(honoPath)};
 import innerApp, { __voidCollectPrerenderPaths } from "virtual:void-routes";
 ${envSchemaImport}
+// Resolved by nodeTargetPlugin for this emitted chunk, including shared chunks.
+const clientRoot = fileURLToPath(import.meta.voidClientDirectory);
+const assetApp = new Hono();
+assetApp.get("*", serveStatic({ root: clientRoot }));
+const assets = { fetch: (request) => assetApp.fetch(request) };
 const app = new Hono();
 ${envMiddleware}app.post("/__void/prerender-paths", async (c) => {
   const __expected = c.env?.__VOID_PROXY_TOKEN;
@@ -3807,8 +4248,8 @@ ${envMiddleware}app.post("/__void/prerender-paths", async (c) => {
   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));
+app.get("/assets/*", (c) => assets.fetch(c.req.raw));
+app.all("*", (c) => innerApp.fetch(c.req.raw, { ...c.env, ASSETS: assets }));
 export default app;`;
 }
 /**
@@ -4252,6 +4693,7 @@ const RESOLVE_ID_FILTER = /^(virtual:void-(routes|client-worker(?::(react|vue|sv
 const LOAD_ID_FILTER = /^virtual:void-(routes|client-worker(?::(react|vue|svelte|solid))?|client-browser(?::(react|vue|svelte|solid))?)$/;
 function routingPlugin(root, options) {
 	let scan = null;
+	let routeEnvironment = "prod";
 	let ssr = null;
 	let authConfigPath = null;
 	const paths = readProjectPaths(root);
@@ -4259,6 +4701,7 @@ function routingPlugin(root, options) {
 	const middlewareDir = paths.middlewareDir;
 	const jobsDir = paths.cronsDir;
 	const queuesDir = paths.queuesDir;
+	const emailDir = paths.emailDir;
 	const pagesDir = paths.pagesDir;
 	const ssrDir = paths.ssrDir;
 	const authConfigPaths = new Set(paths.authConfigCandidates.map((path) => normalizePath(path)));
@@ -4267,9 +4710,14 @@ function routingPlugin(root, options) {
 	const normalizedMiddlewareDir = normalizePath(middlewareDir);
 	const normalizedJobsDir = normalizePath(jobsDir);
 	const normalizedQueuesDir = normalizePath(queuesDir);
+	const normalizedEmailDir = normalizePath(emailDir);
 	const normalizedPagesDir = normalizePath(pagesDir);
 	const normalizedSsrDir = normalizePath(ssrDir);
 	const ssrEntryAbsPaths = new Set([...SSR_SERVER_ENTRY_RELATIVE_PATHS, ...SSR_CLIENT_ENTRY_RELATIVE_PATHS].map((path) => normalizePath(join(ssrDir, path.split("/").pop()))));
+	function hasEmailHandlers() {
+		const email = scan?.email;
+		return Boolean(email && (email.addresses.length > 0 || email.defaultHandler));
+	}
 	function isInDirectory(path, directory) {
 		return path === directory || path.startsWith(directory + "/");
 	}
@@ -4286,7 +4734,8 @@ function routingPlugin(root, options) {
 	async function rescan() {
 		scan = await scanRoutes(root, {
 			output: options.output,
-			paths
+			paths,
+			environment: routeEnvironment
 		});
 		authConfigPath = findVoidAuthConfig(root, paths);
 		const entries = validateSsrEntries(root, paths);
@@ -4327,16 +4776,20 @@ function routingPlugin(root, options) {
 		responsePath: resolveFile("#self/response"),
 		handlerPath: resolveFile("#self/handler"),
 		runtimeEnvPath: resolveFile("#self/_env"),
+		runtimeEmailPath: resolveFile("#self/email"),
+		emailDir,
 		projectRoot: root,
 		homeDir: homedir(),
 		webSocketRuntimePath: resolveFile("#self/runtime/ws-server"),
 		liveRuntimePath: resolveFile("#self/runtime/live-server"),
 		hasLive: options.live !== void 0,
+		webSocketTombstones: options.websocketTombstones,
 		reactRefresh: false,
 		dev: false,
 		devTriggerToken: options.devTriggerToken,
 		auth: null,
 		nodeTarget: !!options.target,
+		managedDispatch: false,
 		explicitPrerenderPaths: options.prerenderPaths,
 		bindingHandlerPath: options.target ? void 0 : resolveFile("#self/remote/binding-handler"),
 		bindingNames: options.bindingNames
@@ -4364,7 +4817,7 @@ function routingPlugin(root, options) {
 		const config = readConfig(root);
 		const dialect = getDatabaseDialect(config);
 		compileOptions.auth = {
-			authRuntimePath: dialect === "postgresql" ? join(runtimeDir, "better-auth-pg.mjs") : join(runtimeDir, "better-auth.mjs"),
+			authRuntimePath: dialect === "postgresql" ? join(runtimeDir, "better-auth-pg.mjs") : dialect === "mysql" ? join(runtimeDir, "better-auth-mysql.mjs") : join(runtimeDir, "better-auth.mjs"),
 			authConfigPath,
 			authDatabasePath: null,
 			authSchemaPath: null,
@@ -4379,7 +4832,10 @@ function routingPlugin(root, options) {
 			providers: compileOptions.auth.providers,
 			userConfig: await loadVoidAuthConfig(compileOptions.auth.authConfigPath)
 		};
-		const env = loadEnv(resolvedConfig?.mode ?? "development", root, "");
+		const env = {
+			...resolvedConfig?.command === "serve" ? loadLocalEnv(root) : {},
+			...process.env
+		};
 		const schemaPath = join(outDir, "better-auth-schema.ts");
 		const databasePath = join(outDir, "better-auth-db.ts");
 		writeFileIfChanged(schemaPath, generateVoidAuthDrizzleSchema(authRuntime, env));
@@ -4393,6 +4849,8 @@ function routingPlugin(root, options) {
 	}
 	let resolvedConfig = null;
 	let isrRevalidate;
+	let isrPages;
+	let isrPathRevalidate;
 	function resolveAuthClientPath(config) {
 		if (config.plugins.some((plugin) => plugin.name === "void-react:pages")) return explicitAuthClientPaths.react;
 		if (config.plugins.some((plugin) => plugin.name === "void-vue:pages")) return explicitAuthClientPaths.vue;
@@ -4473,11 +4931,20 @@ function routingPlugin(root, options) {
 	if (options.target) {
 		writeFileIfChanged(join(outDir, "app.ts"), compileNodeApp(options.target, compileOptions.honoPath, getEnvSchemaModule()));
 		writeFileIfChanged(join(outDir, "index.ts"), compileNodeServer(options.target));
-	} else writeFileIfChanged(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, void 0, options.live));
+	} else writeFileIfChanged(join(outDir, "entry.ts"), compileWorkerEntry({
+		remote,
+		webSocketClasses: options.websocketTombstones,
+		runtimeEnvPath: compileOptions.runtimeEnvPath,
+		runtimeEmailPath: compileOptions.runtimeEmailPath,
+		envSchemaModule: getEnvSchemaModule(),
+		sandbox: options.hasSandbox ? {
+			bindingName: options.sandboxBindingName,
+			className: options.sandboxClassName,
+			runtimePath: sandboxRuntimePath
+		} : false,
+		live: options.live,
+		durableObjects: options.durableObjects
+	}));
 	return {
 		name: "void:routing",
 		enforce: "pre",
@@ -4493,6 +4960,8 @@ function routingPlugin(root, options) {
 			}
 		},
 		config(_, env) {
+			routeEnvironment = env.command === "serve" && !env.isPreview ? "dev" : "prod";
+			compileOptions.managedDispatch = !options.target && env.command === "build" && Boolean(process.env.VOID_DEPLOY_PROJECT_ID);
 			if (env.command === "serve" && options.isAuthEnabled()) return { resolve: { alias: [
 				"client",
 				"react",
@@ -4526,11 +4995,11 @@ function routingPlugin(root, options) {
 			if (!options.target) {
 				const migrationsDir = paths.migrationsDir;
 				if (existsSync(migrationsDir) || compileOptions.auth) {
-					const { collectMigrations } = await import("./validate-Cw_RLeTj.mjs").then((n) => n.l);
-					const { buildMigrationPlanBundle } = await import("./validate-Cw_RLeTj.mjs").then((n) => n.s);
+					const { collectMigrations } = await import("./validate-Bihr8WBi.mjs").then((n) => n.l);
+					const { buildMigrationPlanBundle } = await import("./validate-Bihr8WBi.mjs").then((n) => n.s);
 					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.migrationHandlerPath = resolveFile(dialect === "postgresql" ? "#self/runtime/migration-handler-pg" : dialect === "mysql" ? "#self/runtime/migration-handler-mysql" : "#self/runtime/migration-handler");
 					compileOptions.migrations = migrations;
 					compileOptions.migrationPlanBundle = dialect === "sqlite" ? buildMigrationPlanBundle(migrations) : void 0;
 					compileOptions.migrationDialect = dialect;
@@ -4540,15 +5009,37 @@ function routingPlugin(root, options) {
 				writeFileIfChanged(join(outDir, "app.ts"), compileNodeApp(options.target, compileOptions.honoPath, getEnvSchemaModule()));
 				writeFileIfChanged(join(outDir, "index.ts"), compileNodeServer(options.target));
 			} else {
-				const merged = collectRevalidate(readConfig(root), scan.pages);
+				const buildConfig = readConfig(root);
+				const merged = collectRevalidate(buildConfig, scan.pages);
+				const configuredRevalidate = buildConfig.routing?.revalidate;
 				const emitIsr = !options.target && resolvedConfig?.command === "build" && !process.env.VOID_DEPLOY_PROJECT_ID && hasRevalidate(merged);
 				isrRevalidate = emitIsr ? merged : void 0;
-				const isr = emitIsr ? { runtimePath: resolveFile("#self/runtime/isr-cache") } : void 0;
-				writeFileIfChanged(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(), options.live, isr, currentNotFoundHandling()));
+				isrPages = emitIsr ? collectPages(scan.pages, configuredRevalidate) : void 0;
+				isrPathRevalidate = emitIsr && configuredRevalidate && typeof configuredRevalidate === "object" ? configuredRevalidate : void 0;
+				const isr = emitIsr ? {
+					runtimePath: resolveFile("@void/isr/runtime"),
+					queryAllowlist: buildConfig.routing?.revalidateQueryAllowlist
+				} : void 0;
+				writeFileIfChanged(join(outDir, "entry.ts"), compileWorkerEntry({
+					hasQueues: scan.queues.length > 0,
+					remote,
+					assetsDir: resolvedConfig?.build.assetsDir,
+					webSocketClasses: [...(scan.websockets ?? []).map((route) => route.className), ...options.websocketTombstones ?? []],
+					runtimeEnvPath: compileOptions.runtimeEnvPath,
+					runtimeEmailPath: compileOptions.runtimeEmailPath,
+					envSchemaModule: getEnvSchemaModule(),
+					sandbox: options.hasSandbox ? {
+						bindingName: options.sandboxBindingName,
+						className: options.sandboxClassName,
+						runtimePath: sandboxRuntimePath
+					} : false,
+					hasEmail: hasEmailHandlers(),
+					serveSpaFallback: shouldServeSpaFallback(),
+					live: options.live,
+					isr,
+					notFound: currentNotFoundHandling(),
+					durableObjects: options.durableObjects
+				}));
 			}
 		},
 		resolveId: {
@@ -4573,14 +5064,14 @@ function routingPlugin(root, options) {
 				}
 				if (id !== VIRTUAL_ROUTES_ID) return;
 				if (!scan) await rescan();
-				return compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, ssr, compileOptions, getPagesCompileOptions(), isrRevalidate);
+				return compileRouteTable(scan, routesDir, middlewareDir, jobsDir, queuesDir, ssr, compileOptions, getPagesCompileOptions(), isrRevalidate, isrPages, isrPathRevalidate);
 			}
 		},
 		configureServer(devServer) {
 			const watcher = devServer.watcher;
 			const handleFileChange = async (path, event) => {
 				const normalizedPath = normalizePath(path);
-				const sourceConventionChanged = isInDirectory(normalizedPath, normalizedRoutesDir) || isInDirectory(normalizedPath, normalizedMiddlewareDir) || isInDirectory(normalizedPath, normalizedJobsDir) || isInDirectory(normalizedPath, normalizedQueuesDir) || isInDirectory(normalizedPath, normalizedPagesDir) || isPotentialAuthConfigPath(normalizedPath) || isPotentialEnvFilePath(normalizedPath);
+				const sourceConventionChanged = isInDirectory(normalizedPath, normalizedRoutesDir) || isInDirectory(normalizedPath, normalizedMiddlewareDir) || isInDirectory(normalizedPath, normalizedJobsDir) || isInDirectory(normalizedPath, normalizedQueuesDir) || isInDirectory(normalizedPath, normalizedEmailDir) || isInDirectory(normalizedPath, normalizedPagesDir) || isPotentialAuthConfigPath(normalizedPath) || isPotentialEnvFilePath(normalizedPath);
 				if (!sourceConventionChanged && !isInDirectory(normalizedPath, normalizedSsrDir) && !isPotentialEnvFilePath(normalizedPath)) return;
 				if (!sourceConventionChanged && isInDirectory(normalizedPath, normalizedSsrDir) && !ssrEntryAbsPaths.has(normalizedPath)) return;
 				await rescan();
@@ -4595,11 +5086,26 @@ function routingPlugin(root, options) {
 				if (options.target) {
 					writeFileIfChanged(join(outDir, "app.ts"), compileNodeApp(options.target, compileOptions.honoPath, getEnvSchemaModule()));
 					writeFileIfChanged(join(outDir, "index.ts"), compileNodeServer(options.target));
-				} else writeFileIfChanged(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(), options.live, void 0, currentNotFoundHandling()));
+				} else writeFileIfChanged(join(outDir, "entry.ts"), compileWorkerEntry({
+					hasQueues: scan.queues.length > 0,
+					remote,
+					assetsDir: resolvedConfig?.build.assetsDir,
+					webSocketClasses: [...(scan.websockets ?? []).map((route) => route.className), ...options.websocketTombstones ?? []],
+					runtimeEnvPath: compileOptions.runtimeEnvPath,
+					runtimeEmailPath: compileOptions.runtimeEmailPath,
+					envSchemaModule: getEnvSchemaModule(),
+					sandbox: options.hasSandbox ? {
+						bindingName: options.sandboxBindingName,
+						className: options.sandboxClassName,
+						runtimePath: sandboxRuntimePath
+					} : false,
+					hasEmail: hasEmailHandlers(),
+					serveSpaFallback: shouldServeSpaFallback(),
+					live: options.live,
+					isr: void 0,
+					notFound: currentNotFoundHandling(),
+					durableObjects: options.durableObjects
+				}));
 				const structural = event !== "change";
 				const pageManifestChanged = isInDirectory(normalizedPath, normalizedPagesDir) && (structural || normalizedPath.endsWith(".md"));
 				for (const env of Object.values(devServer.environments)) {
@@ -4657,6 +5163,13 @@ function routingPlugin(root, options) {
 * 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.
+*
+* The file is owner-only (0600). It is the one credential the dev-inbox
+* routes accept, and loopback is reachable by every account on the host,
+* so a default-umask 0644 file would hand any other local user the raw MIME,
+* the DELETE, and the capture endpoint. A file persisted by an earlier
+* release is tightened in place, never rotated. Windows has no group/other
+* bits — `mode` and `chmod` only toggle write there — so it is left alone.
 */
 /**
 * Best-effort detection of `vite build` (and `vite preview`) so we can skip
@@ -4671,6 +5184,7 @@ function isViteBuildOrPreview() {
 	const subcommand = process.argv[2];
 	return subcommand === "build" || subcommand === "preview";
 }
+const DEV_TRIGGER_TOKEN_FILE_MODE = 384;
 function getOrCreateDevTriggerToken(root) {
 	const tokenPath = join(root, ".void", "dev-trigger-token");
 	const readExisting = () => {
@@ -4681,12 +5195,21 @@ function getOrCreateDevTriggerToken(root) {
 			return;
 		}
 	};
+	const tightenExisting = () => {
+		if (process.platform === "win32") return;
+		try {
+			if ((statSync(tokenPath).mode & 63) !== 0) chmodSync(tokenPath, DEV_TRIGGER_TOKEN_FILE_MODE);
+		} catch {}
+	};
 	const existing = readExisting();
-	if (existing) return existing;
+	if (existing) {
+		tightenExisting();
+		return existing;
+	}
 	mkdirSync(join(root, ".void"), { recursive: true });
 	const fresh = crypto.randomUUID();
 	try {
-		const fd = openSync(tokenPath, "wx");
+		const fd = openSync(tokenPath, "wx", DEV_TRIGGER_TOKEN_FILE_MODE);
 		try {
 			writeSync(fd, fresh);
 		} finally {
@@ -4770,7 +5293,7 @@ function generateClassATriggerWrapper(root, framework, original, isBuild, assets
 	const outDir = join(root, ".void");
 	mkdirSync(outDir, { recursive: true });
 	const wrapperPath = join(outDir, `${framework}-trigger-wrapper.ts`);
-	writeFileIfChanged(wrapperPath, isBuild ? `// @ts-nocheck — Auto-generated by Void for vite build. Do NOT edit.
+	const body = isBuild ? `// @ts-nocheck — Auto-generated by Void for vite build. Do NOT edit.
 import original from ${JSON.stringify(original)};
 
 export default {
@@ -4792,7 +5315,8 @@ export default {
     return original.fetch(request, env, ctx);
   },
 };
-`);
+`;
+	writeFileIfChanged(wrapperPath, body);
 	return wrapperPath;
 }
 /** Generate a worker entry for vinext Pages Router projects. */
@@ -4850,16 +5374,49 @@ function hasBinding(list, name) {
 /**
 * Decide whether to inject a Workers AI binding into the built wrangler config.
 *
-* Build-only: dev/miniflare has no local Workers AI, so serve must never bind
-* `env.AI` (dev uses the P2 `__VOID_TOKEN` proxy path instead).
+* Builds use the production binding. During dev, a project explicitly saved
+* with the direct Cloudflare destination uses Cloudflare's remote binding;
+* managed and unsaved projects keep using the Void HTTPS proxy.
 *
 * `!resolvedAi` is load-bearing: mergeBindings' return is defu-merged over the
 * resolved root-wrangler config and wins, so skipping when the user already
 * declared an `ai` binding avoids clobbering theirs. `!resultAi` is harmless
 * defense-in-depth (nothing else in mergeBindings sets `result.ai`).
 */
-function shouldBindWorkersAi(command, needsAI, resolvedAi, resultAi) {
-	return needsAI && command === "build" && !resultAi && !resolvedAi;
+function shouldBindWorkersAi(command, needsAI, resolvedAi, resultAi, directCloudflareDev = false) {
+	return needsAI && (command === "build" || command === "serve" && directCloudflareDev) && !resultAi && !resolvedAi;
+}
+/**
+* Decide whether to inject the `void dev` email-inbox loopback var.
+*
+* The dev inbox buffer lives in the Vite dev server's Node process;
+* `sendEmail` runs in workerd and reaches it by fetching the inbox capture
+* endpoint through the worker's assets binding, which
+* `@cloudflare/vite-plugin` wires straight into the dev server's middleware
+* stack. The var carries that binding's NAME (`ASSETS` for a Void app, or
+* whatever a Class A framework's own wrangler config declares) and its
+* presence is what arms the dev path at runtime — so it must never reach a
+* production build's `wrangler.json`, exactly like the `__VOID_TOKEN`
+* credential gate.
+*
+* Gated on `routeEnvironment`, not on `command`: `vite preview` also reports
+* `command: 'serve'`, but it runs the BUILT worker whose assets binding is a
+* real asset directory rather than a dev-server loopback. `routeEnvironment`
+* is the existing `command === 'serve' && !isPreview` distinction.
+*
+* Without an assets binding there is no loopback, so injecting the var would
+* only arm a path that must then fail; gate on it instead.
+*/
+function shouldInjectEmailDevInboxVar(routeEnvironment, needsEmail, assetsBinding) {
+	return routeEnvironment === "dev" && !!needsEmail && typeof assetsBinding === "string" && !!assetsBinding;
+}
+/** Resolve the runtime Workers AI binding, preserving a root Wrangler declaration. */
+function resolveWorkersAiBindingName(resolvedAi, configuredName) {
+	if (typeof resolvedAi === "object" && resolvedAi !== null) {
+		const binding = resolvedAi.binding;
+		if (typeof binding === "string") return binding;
+	}
+	return configuredName ?? "AI";
 }
 const CLOUDFLARE_BUILTIN_IMPORT = /^cloudflare:/;
 const SANDBOX_SDK_IMPORT = "@cloudflare/sandbox";
@@ -4956,9 +5513,11 @@ function readVoidDevCredentials(root) {
 	const token = getToken(root);
 	if (!token) return { status: "no-token" };
 	const staging = isStagingMode(root) || void 0;
+	const apiUrl = getApiUrl(root);
 	const project = readProjectConfig(root);
 	if (!project) return {
 		status: "no-project",
+		apiUrl,
 		token,
 		staging
 	};
@@ -4966,22 +5525,21 @@ function readVoidDevCredentials(root) {
 		status: "ok",
 		token,
 		projectId: project.projectId,
+		proxyUrl: getProxyUrl(root),
 		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("./agents-CtgBYqld.mjs").then((n) => n.C);
-	const { PlatformClient } = await import("./client-Gb71-XkG.mjs").then((n) => n.r);
-	const { writeProjectConfig } = await import("./client-Gb71-XkG.mjs").then((n) => n.y);
-	const { inferDefaultSlug } = await import("./resolve-project-BBMtLLV9.mjs").then((n) => n.i);
-	const client = new PlatformClient(token, staging ? STAGING_API_URL : DEFAULT_API_URL);
+async function runAiSetupPrompt(root, token, apiUrl, server) {
+	const { select, text, isCancel, log } = await import("./output-tFQLLj26.mjs").then((n) => n.T);
+	const { PlatformClient } = await import("./client-CyCHWSO_.mjs").then((n) => n.r);
+	const { attachSelectedPlatform, writeProjectConfig } = await import("./auth-W9WII-mN.mjs").then((n) => n.y);
+	const { inferDefaultSlug } = await import("./resolve-project--Vxawf7z.mjs").then((n) => n.i);
+	const client = new PlatformClient(token, apiUrl);
 	let projects;
 	try {
 		projects = await client.listProjects();
@@ -5006,8 +5564,8 @@ async function runAiSetupPrompt(root, token, staging, server) {
 	let projectId;
 	let slug;
 	if (result === "__create__") {
-		const { validateProjectSlug } = await import("./create-project-DsYvl3TB.mjs").then((n) => n.a);
-		const { createProjectWithSlugRetry } = await import("./create-project-DsYvl3TB.mjs").then((n) => n.t);
+		const { validateProjectSlug } = await import("./create-project-DMV-csEm.mjs").then((n) => n.a);
+		const { createProjectWithSlugRetry } = await import("./create-project-DMV-csEm.mjs").then((n) => n.t);
 		let created;
 		try {
 			created = await createProjectWithSlugRetry(client, inferDefaultSlug(root), async (defaultSlug) => {
@@ -5017,7 +5575,7 @@ async function runAiSetupPrompt(root, token, staging, server) {
 					initialValue: defaultSlug,
 					validate: validateProjectSlug
 				});
-				if (isCancel(slugResult)) return;
+				if (isCancel(slugResult) || typeof slugResult === "symbol") return;
 				return slugResult.trim();
 			});
 		} catch (err) {
@@ -5032,10 +5590,10 @@ async function runAiSetupPrompt(root, token, staging, server) {
 		projectId = project.id;
 		slug = project.slug;
 	}
-	writeProjectConfig(root, {
+	writeProjectConfig(root, attachSelectedPlatform(root, {
 		projectId,
 		slug
-	});
+	}, client.apiUrl));
 	log.success(`Linked to ${import_picocolors.default.blue(slug)}`);
 	await server.restart();
 }
@@ -5059,10 +5617,12 @@ async function runAiSetupPrompt(root, token, staging, server) {
 */
 function voidPlugin(options) {
 	const root = process.cwd();
+	const directCloudflareDestination = readDeploymentPlatform(root) === "cloudflare";
 	warnIfPackageJsonIsNotEsm(root);
 	const devTriggerToken = isViteBuildOrPreview() ? crypto.randomUUID() : getOrCreateDevTriggerToken(root);
 	const config = readConfig(root);
 	const paths = resolveProjectPaths(root, config);
+	let routeEnvironment = "prod";
 	assertNoRootSourceConventionConflicts(paths);
 	const dialect = getDatabaseDialect(config);
 	const detected = detectFramework(root);
@@ -5070,6 +5630,13 @@ function voidPlugin(options) {
 	const scanDirs = config.inference?.scanDirs ?? (detected ? FRAMEWORK_SCAN_DIRS : void 0);
 	const inferenceOptions = config.inference?.bindings ? { bindings: config.inference.bindings } : void 0;
 	const bindingNames = resolveBindingNames(config.inference?.bindings);
+	const frameworkOwnsCloudflareRuntime = detected !== void 0 && (detected.class === "b" || detected.class === "c");
+	const localD1PersistRoot = frameworkOwnsCloudflareRuntime ? join(root, ".wrangler", "state") : options?.persistTo ?? join(root, ".void");
+	const localD1 = resolveLocalD1Target(root, {
+		bindingName: bindingNames?.d1 ?? "DB",
+		persistRoot: localD1PersistRoot
+	});
+	writeLocalD1PersistState(root, !isNodeTarget(config.target) && !frameworkOwnsCloudflareRuntime ? options?.persistTo : void 0);
 	const inferredBindings = inferProjectBindings(root, {
 		...inferenceOptions,
 		paths
@@ -5084,6 +5651,8 @@ function voidPlugin(options) {
 	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.");
 	if (detected && bindings.needsLive) throw new Error("live: void/live is currently supported in Void apps only.");
+	const hasInboundEmail = hasEmailHandlers(scanEmailHandlersSync(paths.sourceRoot));
+	if (detected && hasInboundEmail) throw new Error("email: inbound email handlers are only supported in Void apps. Remove the email/ directory — `sendEmail` from void/email keeps working.");
 	const STUB_PREFIX = "\0void-client-stub:";
 	const SERVER_ONLY_STUBS = {
 		"void/db": "export const db = {}; export const createDb = () => ({});",
@@ -5100,12 +5669,37 @@ function voidPlugin(options) {
           this.reason = reason;
         }
       }
+      export class SandboxUnavailableError extends Error {
+        constructor(message = 'Managed Sandbox is unavailable on this Void platform.') {
+          super(message);
+          this.name = 'SandboxUnavailableError';
+        }
+      }
       export async function getSandbox() {
         throw new Error('void/sandbox is server-only and cannot be imported by browser code.');
       }
       export const sandbox = { get: getSandbox };
     `,
-		"void/live": ""
+		"void/email": `
+      const serverOnly = (name) => () => {
+        throw new Error(name + ' is server-only and cannot be imported by browser code.');
+      };
+      export const sendEmail = serverOnly('sendEmail');
+      export const createEmail = serverOnly('createEmail');
+      export const defineEmail = serverOnly('defineEmail');
+      export const parseEmail = serverOnly('parseEmail');
+      export const replyEmail = serverOnly('replyEmail');
+      export const createMessageProxy = serverOnly('createMessageProxy');
+    `,
+		"void/email/testing": `
+      const serverOnly = (name) => () => {
+        throw new Error(name + ' is server-only and cannot be imported by browser code.');
+      };
+      export const createEmailTestHarness = serverOnly('createEmailTestHarness');
+      export const createInboundTestHarness = serverOnly('createInboundTestHarness');
+    `,
+		"void/live": "",
+		"void/durable": ""
 	};
 	const STUB_RESOLVE_FILTER = new RegExp(`^(${Object.keys(SERVER_ONLY_STUBS).join("|").replaceAll("/", "\\/")})$`);
 	const STUB_LOAD_FILTER = new RegExp(`^\\0void-client-stub:`);
@@ -5116,7 +5710,7 @@ function voidPlugin(options) {
 			filter: { id: STUB_RESOLVE_FILTER },
 			handler(id) {
 				if (this.environment?.name === "client") {
-					if (id === "void/live") this.error("void/live is server-only and cannot be imported by browser code. Import void/live/client instead.");
+					if (id === "void/live" || id === "void/durable") this.error(id === "void/live" ? "void/live is server-only and cannot be imported by browser code. Import void/live/client instead." : "void/durable is server-only and cannot be imported by browser code.");
 					return STUB_PREFIX + id;
 				}
 			}
@@ -5128,16 +5722,40 @@ function voidPlugin(options) {
 			}
 		}
 	};
+	const serverRuntimeOptimizerPlugin = {
+		name: "void:server-runtime-optimizer",
+		configEnvironment(name) {
+			if (name !== "client") return { optimizeDeps: { exclude: ["void"] } };
+		}
+	};
 	const queues = framework ? [] : scanQueuesSync(root, paths.queuesDir);
 	const websocketRoutes = framework ? [] : scanWebSocketRoutesSync(root, paths);
+	const durableObjects = scanDurableObjectModules(root);
+	if (detected && durableObjects.length > 0) throw new Error("durable: durable-objects/ is currently supported in Void apps only, not framework adapter mode.");
+	for (const module of durableObjects) {
+		const websocketCollision = websocketRoutes.find((route) => route.bindingName === module.bindingName || route.className === module.className);
+		if (websocketCollision) throw new Error(`durable: durable-objects/${module.filePath.split("/").pop()} conflicts with WebSocket route '${websocketCollision.filePath}'. Rename one of the files.`);
+		if (sandboxConfig && (sandboxConfig.binding === module.bindingName || sandboxConfig.className === module.className)) throw new Error(`durable: durable-objects/${module.filePath.split("/").pop()} conflicts with the configured Sandbox binding or class. Rename the Durable Object file.`);
+	}
+	let websocketTombstones = [];
+	if (!isNodeTarget(config.target)) {
+		syncWranglerDurableObjects(root, durableObjects);
+		const productionWebSocketRoutes = websocketRoutes.filter((route) => isRouteEnabledForEnvironment(route, "prod"));
+		syncWranglerWebSockets(root, productionWebSocketRoutes);
+		websocketTombstones = readWranglerWebSocketTombstones(root, productionWebSocketRoutes);
+	}
 	const liveConfig = !isNodeTarget(config.target) ? bindings.needsLive ? resolveLiveBindingConfig(root, {
-		reservedBindings: websocketRoutes.map((route) => route.bindingName),
-		reservedClasses: [...websocketRoutes.map((route) => route.className), sandboxConfig?.className]
+		reservedBindings: [...websocketRoutes.map((route) => route.bindingName), ...durableObjects.map((module) => module.bindingName)],
+		reservedClasses: [
+			...websocketRoutes.map((route) => route.className),
+			...durableObjects.map((module) => module.className),
+			sandboxConfig?.className
+		]
 	}) : readExistingLiveBindingConfig(root) : void 0;
 	if (detected && (detected.class === "b" || detected.class === "c")) {
-		const frameworkPersistRoot = join(root, ".wrangler", "state");
+		const frameworkPersistRoot = localD1.persistRoot;
 		const syncFrameworkCompat = (compat) => {
-			if (ensureWranglerCompatibilityDate(root, compat.compatibilityDate)) voidLog("Synced compatibility_date to wrangler config");
+			if (ensureWranglerCompatibilityDate(root, compat.compatibilityDate)) voidLog("Synced compatibility_date to Cloudflare config");
 		};
 		const wranglerCompatPlugin = {
 			name: "void:wrangler-compat",
@@ -5145,7 +5763,7 @@ function voidPlugin(options) {
 			config(_, env) {
 				syncFrameworkCompat(ensureWranglerCompat(root, config));
 				if (env.command !== "serve") return;
-				if (ensureWranglerNodejsAlsFlag(root)) voidLog("Synced nodejs_als to wrangler config");
+				if (ensureWranglerNodejsAlsFlag(root)) voidLog("Synced nodejs_als to Cloudflare config");
 			},
 			buildStart() {
 				syncFrameworkCompat(ensureWranglerCompat(root, config));
@@ -5202,6 +5820,7 @@ function voidPlugin(options) {
 			...nuxtVite8WebSocketCompatPlugin ? [nuxtVite8WebSocketCompatPlugin] : [],
 			svelteKitHooksInjectPlugin,
 			clientStubsPlugin,
+			serverRuntimeOptimizerPlugin,
 			bindingRuntimePlugin(bindingNames),
 			envSchemaPlugin(root),
 			envClientGuardPlugin(root),
@@ -5209,9 +5828,10 @@ function voidPlugin(options) {
 			drizzlePlugin(root, false, dialect, {
 				d1BindingName: bindingNames?.d1,
 				forceVirtualDb: authEnabled || bindingNames?.d1 !== void 0,
+				localD1DatabaseId: localD1.databaseId,
 				localD1PersistRoot: frameworkPersistRoot
 			}),
-			migrationPlugin(root, dialect, "local", frameworkPersistRoot, { enabled: false }),
+			migrationPlugin(root, dialect, localD1.databaseId, frameworkPersistRoot, { enabled: false }),
 			devTriggersHintPlugin(root, {
 				framework: true,
 				devTriggerToken
@@ -5224,6 +5844,10 @@ function voidPlugin(options) {
 	}
 	const remoteMode = resolveRemoteMode(config.remote);
 	const workerConfig = {};
+	const jobs = scanJobsSync(root, paths.cronsDir);
+	if (jobs.length > 0) workerConfig.triggers = { crons: [...new Set(jobs.flatMap((job) => job.crons))] };
+	let envSchemaFacts;
+	let assetRouting;
 	if (config.worker?.vars) workerConfig.vars = { ...config.worker.vars };
 	let viteCommand = "build";
 	const wranglerCompat = isNodeTarget(config.target) ? void 0 : readWranglerCompat(root, config);
@@ -5231,17 +5855,35 @@ function voidPlugin(options) {
 		workerConfig.compatibility_date = wranglerCompat.compatibilityDate;
 		if (wranglerCompat.compatibilityFlags) workerConfig.compatibility_flags = wranglerCompat.compatibilityFlags;
 	}
+	if (config.worker?.limits?.cpu_ms) workerConfig.limits = { cpu_ms: config.worker.limits.cpu_ms };
 	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 environmentWebsocketRoutes = websocketRoutes.filter((route) => isRouteEnabledForEnvironment(route, routeEnvironment));
 		const result = { ...workerConfig };
-		const generatedAssets = workerConfig.assets;
-		if (generatedAssets && resolved.assets) {
-			if (generatedAssets.not_found_handling !== void 0) delete resolved.assets.not_found_handling;
-			if (generatedAssets.run_worker_first !== void 0) delete resolved.assets.run_worker_first;
+		result.compatibility_flags = [.../* @__PURE__ */ new Set([...result.compatibility_flags ?? [], ...resolved.compatibility_flags ?? []])];
+		resolved.compatibility_flags = [];
+		if (envSchemaFacts || authEnabled && process.env["VOID_CLOUDFLARE_DEPLOY_BUILD"] === "1") {
+			const plaintextVars = {
+				...resolved.vars ?? {},
+				...result.vars ?? {}
+			};
+			const plaintextServerKeys = (envSchemaFacts?.serverKeys ?? []).filter((key) => key in plaintextVars);
+			if (viteCommand === "build" && plaintextServerKeys.length > 0) throw new Error(`Server env keys cannot be Worker plaintext vars: ${plaintextServerKeys.join(", ")}. Remove them from worker.vars/wrangler vars and set them with the remote secret store.`);
+			const configuredRequired = resolved.secrets?.required ?? [];
+			const required = [.../* @__PURE__ */ new Set([
+				...configuredRequired,
+				...envSchemaFacts?.requiredServerKeys ?? [],
+				...authEnabled && process.env["VOID_CLOUDFLARE_DEPLOY_BUILD"] === "1" ? ["BETTER_AUTH_SECRET"] : []
+			])];
+			if (required.length > 0) result.secrets = { required };
+		}
+		if (workerConfig.assets && resolved.assets) {
+			delete resolved.assets.not_found_handling;
+			delete resolved.assets.run_worker_first;
 		}
 		const d1Name = bindingNames?.d1 ?? "DB";
 		const d1 = [];
@@ -5263,10 +5905,41 @@ function voidPlugin(options) {
 			binding: r2Name,
 			bucket_name: "default"
 		}];
-		if (shouldBindWorkersAi(viteCommand, bindings.needsAI, resolved.ai, result.ai)) result.ai = { binding: "AI" };
-		if (config.ai?.gateway) {
+		const resolvedAi = resolved.ai;
+		const resultAi = result.ai;
+		const aiBindingName = resolveWorkersAiBindingName(resolvedAi, bindingNames?.ai);
+		if (viteCommand === "serve" && bindings.needsAI && directCloudflareDestination && !resultAi && typeof resolvedAi === "object" && resolvedAi !== null && "binding" in resolvedAi && typeof resolvedAi.binding === "string") result.ai = {
+			...resolvedAi,
+			remote: true
+		};
+		else if (shouldBindWorkersAi(viteCommand, bindings.needsAI, resolvedAi, resultAi, directCloudflareDestination)) result.ai = {
+			binding: aiBindingName,
+			...viteCommand === "serve" && { remote: true }
+		};
+		if (aiBindingName !== "AI" || config.ai?.gateway) {
 			const vars = result.vars ?? {};
-			vars.__VOID_AI_GATEWAY = config.ai.gateway;
+			if (aiBindingName !== "AI") vars.__VOID_AI_BINDING = aiBindingName;
+			if (config.ai?.gateway) vars.__VOID_AI_GATEWAY = config.ai.gateway;
+			result.vars = vars;
+		}
+		const emailDevInboxBinding = workerConfig.assets?.binding ?? resolved.assets?.binding;
+		if (shouldInjectEmailDevInboxVar(routeEnvironment, bindings.needsEmail, emailDevInboxBinding)) {
+			const vars = result.vars ?? {};
+			vars[DEV_INBOX_ENV_VAR] = emailDevInboxBinding;
+			vars[DEV_INBOX_TOKEN_ENV_VAR] = devTriggerToken;
+			result.vars = vars;
+		}
+		if (viteCommand === "serve" && bindings.needsEmail) {
+			const sendEmail = resolved.send_email;
+			if (Array.isArray(sendEmail)) {
+				const kept = sendEmail.filter((entry) => entry?.name !== SEND_EMAIL_BINDING);
+				if (kept.length > 0) resolved.send_email = kept;
+				else delete resolved.send_email;
+			}
+		}
+		if (viteCommand === "serve" && config.email?.from) {
+			const vars = result.vars ?? {};
+			vars.__VOID_EMAIL_FROM = config.email.from;
 			result.vars = vars;
 		}
 		if (queues.length > 0) result.queues = {
@@ -5282,17 +5955,40 @@ function voidPlugin(options) {
 				...q.retryDelay != null && { retry_delay: q.retryDelay }
 			}))
 		};
-		if (websocketRoutes.length > 0) {
+		if (environmentWebsocketRoutes.length > 0) {
 			const existingDurableObjectBindings = resolved.durable_objects?.bindings ?? [];
-			const missingDurableObjectBindings = websocketRoutes.filter((route) => !existingDurableObjectBindings.some((binding) => binding.name === route.bindingName)).map((route) => ({
+			for (const route of environmentWebsocketRoutes) {
+				const conflict = existingDurableObjectBindings.find((binding) => binding.name === route.bindingName && binding.class_name !== route.className);
+				if (conflict) throw new Error(`websocket: binding '${route.bindingName}' is already configured for class '${conflict.class_name}', but '${route.filePath}' requires '${route.className}'.`);
+			}
+			const missingDurableObjectBindings = environmentWebsocketRoutes.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)
-			}];
+			const currentMigrations = resolved.migrations;
+			const planned = appendSqliteClassMigration(Array.isArray(currentMigrations) ? currentMigrations : [], environmentWebsocketRoutes.map((route) => route.className), "void-ws-v1", existingDurableObjectBindings.map((binding) => binding.class_name));
+			if (planned.added) result.migrations = planned.migrations;
+		}
+		if (durableObjects.length > 0) {
+			const existingBindings = (result.durable_objects ?? resolved.durable_objects)?.bindings ?? [];
+			for (const module of durableObjects) {
+				const conflict = existingBindings.find((binding) => binding.name === module.bindingName && binding.class_name !== module.className);
+				if (conflict) throw new Error(`durable: binding '${module.bindingName}' is already configured for class '${conflict.class_name}', but durable-objects/ requires '${module.className}'.`);
+			}
+			const additions = durableObjects.filter((module) => !existingBindings.some((binding) => binding.name === module.bindingName)).map((module) => ({
+				name: module.bindingName,
+				class_name: module.className
+			}));
+			if (additions.length > 0) result.durable_objects = { bindings: [...existingBindings, ...additions] };
+			const currentMigrations = result.migrations ?? resolved.migrations;
+			const existingMigrations = Array.isArray(currentMigrations) ? currentMigrations : [];
+			for (const module of durableObjects) if (existingMigrations.find((migration) => migration.tag === module.migrationTag && !migration.new_sqlite_classes?.includes(module.className))) throw new Error(`durable: migration tag '${module.migrationTag}' is already used by another Durable Object migration.`);
+			const migrationAdditions = durableObjects.filter((module) => !existingMigrations.some((migration) => migration.tag === module.migrationTag || migration.new_sqlite_classes?.includes(module.className))).map((module) => ({
+				tag: module.migrationTag,
+				new_sqlite_classes: [module.className]
+			}));
+			if (migrationAdditions.length > 0) result.migrations = [...existingMigrations, ...migrationAdditions];
 		}
 		if (bindings.needsSandbox && sandboxConfig) {
 			const existingDurableObjectBindings = (result.durable_objects ?? resolved.durable_objects)?.bindings ?? [];
@@ -5329,12 +6025,13 @@ function voidPlugin(options) {
 				new_sqlite_classes: [liveConfig.className]
 			}];
 		}
-		if (viteCommand === "serve" && bindings.needsAI) {
+		if (viteCommand === "serve" && bindings.needsAI && !directCloudflareDestination) {
 			const credentials = readVoidDevCredentials(root);
 			if (credentials.status === "ok") {
 				const vars = result.vars ?? {};
 				vars.__VOID_TOKEN = credentials.token;
 				vars.__VOID_PROJECT_ID = credentials.projectId;
+				vars.__VOID_PROXY_URL = credentials.proxyUrl;
 				if (credentials.staging) vars.__VOID_STAGING = "1";
 				result.vars = vars;
 			}
@@ -5343,7 +6040,7 @@ function voidPlugin(options) {
 			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_PROXY_URL = credentials.proxyUrl;
 				vars.__VOID_TOKEN = credentials.token;
 				vars.__VOID_PROJECT_ID = credentials.projectId;
 				vars.__VOID_REMOTE = "1";
@@ -5352,31 +6049,34 @@ function voidPlugin(options) {
 		}
 		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;
+	function applyEnvSchema(facts) {
+		envSchemaFacts = facts;
 	}
-	let voidDeployBuildConfig;
 	const envPlugin = {
 		name: "void:env",
-		api: { getVoidDeployBuildConfig: () => voidDeployBuildConfig },
-		config(userConfig, { mode, command }) {
+		config(userConfig, { command, isPreview }) {
 			viteCommand = command;
+			routeEnvironment = command === "serve" && !isPreview ? "dev" : "prod";
+			if (command === "serve" && directCloudflareDestination && bindings.needsAI) process.env.CLOUDFLARE_AUTH_USE_KEYRING = "true";
+			if (!framework && !isNodeTarget(config.target)) {
+				managedCloudflareBuild = command === "build" && Boolean(process.env.VOID_DEPLOY_PROJECT_ID);
+				assetRoutingPublicDir = userConfig.publicDir === false ? null : typeof userConfig.publicDir === "string" ? resolve(root, userConfig.publicDir) : join(root, "public");
+				assetRouting = resolveConfiguredAssetRoutingPolicy();
+				applyAssetRoutingPolicy(assetRouting);
+			}
 			const ignored = ["**/.void/**"];
-			const rawEnvDir = typeof userConfig.envDir === "string" && userConfig.envDir.length > 0 ? userConfig.envDir : void 0;
-			voidDeployBuildConfig = {
-				mode,
-				envDir: rawEnvDir
-			};
-			const { sanitized: env, stripped } = stripInternalEnvKeys(filterLoadedEnv(loadEnv(mode, rawEnvDir ? join(root, rawEnvDir) : 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
-			};
+			if (command === "serve") {
+				const local = loadLocalEnv(root, { onWarn: (message) => voidWarn(message) });
+				const { sanitized: env, stripped } = stripInternalEnvKeys(local);
+				if (stripped.length > 0) voidWarn(`Ignoring internal env keys from .env: ${stripped.join(", ")}. These are reserved for Void runtime use.`);
+				workerConfig.vars = {
+					...workerConfig.vars,
+					...env
+				};
+				if (isPreview) for (const [key, value] of Object.entries(env)) process.env[key] ??= value;
+			}
 			const assets = workerConfig.assets;
-			if (command === "serve" && assets?.run_worker_first?.includes("/**")) assets.run_worker_first = [...DEV_ASSET_ROUTING_EXCLUSIONS, "/**"];
+			if (command === "serve" && !isPreview && assets?.run_worker_first?.includes("/**")) assets.run_worker_first = [...DEV_ASSET_ROUTING_EXCLUSIONS, "/**"];
 			const watchConfig = { server: { watch: { ignored } } };
 			if (!isNodeTarget(config.target) && config.output !== "static") {
 				const envNames = framework === "vinext-app" ? ["rsc", "ssr"] : ["ssr"];
@@ -5414,20 +6114,22 @@ function voidPlugin(options) {
 					voidWarn("Falling back to local bindings.");
 				});
 			}
-			if (bindings.needsAI) {
+			if (bindings.needsAI && !directCloudflareDestination) {
 				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.");
-				});
+				else if (credentials.status === "no-project") {
+					if (process.stdin.isTTY) afterReady(() => {
+						console.log();
+						runAiSetupPrompt(root, credentials.token, credentials.apiUrl, server);
+					});
+					else afterReady(() => {
+						console.log();
+						voidWarn("AI requires a linked project. Run `void project link` to set one up.");
+					});
+				}
 			}
 		}
 	};
@@ -5444,7 +6146,8 @@ function voidPlugin(options) {
 				if (hintShown) return;
 				if (!watchDirs.some((d) => path.startsWith(d))) return;
 				try {
-					const fileBindings = inferBindingsFromSource(readFileSync(path, "utf-8"), path.split("/").pop());
+					const code = readFileSync(path, "utf-8");
+					const fileBindings = inferBindingsFromSource(code, path.split("/").pop());
 					const newBindings = [];
 					if (autoDetectBindings) {
 						if (fileBindings.needsD1 && !bindings.needsD1) newBindings.push("D1 (void/db)");
@@ -5452,6 +6155,7 @@ function voidPlugin(options) {
 						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 (fileBindings.needsEmail && !bindings.needsEmail) newBindings.push("Email (void/email)");
 					}
 					if (autoDetectAuth && fileBindings.needsAuth) newBindings.push("Auth (void/auth)");
 					if (newBindings.length > 0) {
@@ -5478,18 +6182,15 @@ function voidPlugin(options) {
 	};
 	if (framework) {
 		workerConfig.main = getFrameworkEntry(framework, root, devTriggerToken, config.routing?.notFound);
+		let notFoundIgnoredWarned = false;
 		const frameworkBuildWrapperPlugin = {
 			name: "void:framework-build-wrapper",
-			config(_userConfig, env) {
-				const notFound = config.routing?.notFound;
-				if (env.command !== "build" || notFound === void 0) return;
-				workerConfig.assets = {
-					...workerConfig.assets,
-					not_found_handling: notFound
-				};
-			},
 			configResolved(resolved) {
 				if (resolved.command !== "build") return;
+				if (config.routing?.notFound !== void 0 && !process.env.VOID_DEPLOY_BUILD && !notFoundIgnoredWarned) {
+					notFoundIgnoredWarned = true;
+					voidWarn(`Void generates no asset routing policy for a ${framework} build, so "routing.notFound" in void.json is not written to the built worker config. During a self-hosted build and direct Cloudflare deployment, it takes effect only if your own Cloudflare config declares a complete \`assets\` policy (\`binding\`, \`directory\`, \`not_found_handling\`, \`run_worker_first\`); otherwise Cloudflare's default applies. Managed \`void deploy\` supplies the policy for you.`);
+				}
 				generateClassATriggerWrapper(root, framework, getOriginalFrameworkEntry(framework, root), true, resolved.build.assetsDir, config.routing?.notFound);
 			}
 		};
@@ -5517,19 +6218,22 @@ function voidPlugin(options) {
 			createWranglerCompatPersistPlugin(root, config),
 			restartPlugin(),
 			bindingWatchPlugin,
+			...bindings.needsEmail ? [emailDevInboxPlugin({ devTriggerToken })] : [],
 			envPlugin,
-			envSchemaPlugin(root, { onDefaults: applySchemaDefaultsToWorkerVars }),
+			envSchemaPlugin(root, { onSchema: applyEnvSchema }),
 			envClientGuardPlugin(root),
 			envClientFoldPlugin(),
 			clientStubsPlugin,
+			serverRuntimeOptimizerPlugin,
 			bindingRuntimePlugin(bindingNames),
 			drizzlePlugin(root, false, getDatabaseDialect(config), {
 				d1BindingName: bindingNames?.d1,
 				forceVirtualDb: authEnabled || bindingNames?.d1 !== void 0,
-				localD1PersistRoot: options?.persistTo ?? outDir,
+				localD1DatabaseId: localD1.databaseId,
+				localD1PersistRoot: localD1.persistRoot,
 				redirectDbTypePaths
 			}),
-			migrationPlugin(root, getDatabaseDialect(config)),
+			migrationPlugin(root, getDatabaseDialect(config), localD1.databaseId, localD1.persistRoot),
 			...vinextCompat ? [vinextCompat] : [],
 			frameworkBuildWrapperPlugin,
 			frameworkTriggersPlugin(root, { devTriggerToken }),
@@ -5539,7 +6243,7 @@ function voidPlugin(options) {
 			}),
 			...cloudflare({
 				...inspectorPortOption,
-				persistState: { path: options?.persistTo ?? outDir },
+				persistState: { path: localD1.persistRoot },
 				auxiliaryWorkers: options?.auxiliaryWorkers,
 				viteEnvironment,
 				config: mergeBindings
@@ -5553,10 +6257,13 @@ function voidPlugin(options) {
 		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 (bindings.needsLive) throw new Error(`live: void/live requires target: "cloudflare". It is not available with target: '${config.target}'.`);
+		if (durableObjects.length > 0) throw new Error(`durable: durable-objects/ requires target: "cloudflare". It is not available with target: '${config.target}'.`);
+		if (hasInboundEmail) throw new Error(`email: inbound email handlers (email/) 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,
+			serverRuntimeOptimizerPlugin,
 			envSchemaPlugin(root),
 			...pagesDevCssAssetsPlugin(root, devTriggerToken),
 			routingPlugin(root, {
@@ -5574,28 +6281,43 @@ function voidPlugin(options) {
 		];
 	}
 	const existingFlags = workerConfig.compatibility_flags ?? [];
-	const normalizedFlags = normalizeWranglerCompatibilityFlags(existingFlags, { needsNodejsCompat: authEnabled || dialect === "postgresql" || bindings.needsSandbox });
+	const needsNodejsCompat = authEnabled || dialect !== "sqlite" || bindings.needsSandbox;
+	const normalizedFlags = normalizeWranglerCompatibilityFlags(existingFlags, { needsNodejsCompat });
 	if (normalizedFlags && normalizedFlags !== existingFlags) workerConfig.compatibility_flags = normalizedFlags;
-	const jobs = scanJobsSync(root, paths.cronsDir);
 	const ssrEntry = validateSsrEntry(root, paths);
 	const hasPages = existsSync(paths.pagesDir);
 	const hasMiddleware = scanMiddlewareSync(root, paths).length > 0;
-	const routePatterns = scanRoutePatternsSync(root, paths);
-	const hasDocumentRoutes$1 = hasDocumentRoutes(routePatterns);
-	const hasApiRoutes$1 = hasApiRoutes(routePatterns) || hasApiRoutes(websocketRoutes) || authEnabled;
-	let assetRouting = resolveAssetRoutingPolicy({
-		isSsr: Boolean(ssrEntry),
-		hasPages,
-		hasApiRoutes: hasApiRoutes$1,
-		hasDocumentRoutes: hasDocumentRoutes$1,
-		hasMiddleware,
-		hasWebSockets: hasDocumentRoutes(websocketRoutes),
-		authEnabled,
-		liveEnabled: liveConfig !== void 0,
-		notFound: config.routing?.notFound
-	});
+	let assetRoutingPublicDir = join(root, "public");
+	let managedCloudflareBuild = false;
+	function resolveConfiguredAssetRoutingPolicy() {
+		const routePatterns = scanRoutePatternsSync(root, paths, routeEnvironment);
+		const environmentWebsocketRoutes = websocketRoutes.filter((route) => isRouteEnabledForEnvironment(route, routeEnvironment));
+		const policy = resolveAssetRoutingPolicy({
+			isSsr: Boolean(ssrEntry),
+			hasPages,
+			hasApiRoutes: hasApiRoutes(routePatterns) || hasApiRoutes(environmentWebsocketRoutes) || authEnabled,
+			hasDocumentRoutes: hasDocumentRoutes(routePatterns),
+			hasMiddleware,
+			hasWebSockets: hasDocumentRoutes(environmentWebsocketRoutes),
+			authEnabled,
+			liveEnabled: liveConfig !== void 0,
+			notFound: config.routing?.notFound
+		});
+		const rules = mergeRoutingRules({
+			dir: assetRoutingPublicDir,
+			routing: config.routing
+		});
+		if (!managedCloudflareBuild && (rules.headerRules.length > 0 || rules.redirectRules.length > 0 || (rules.fallbackRules?.length ?? 0) > 0)) {
+			policy.assetConfig.run_worker_first = ["/**"];
+			if (rules.fallbackRules?.length && policy.assetConfig.not_found_handling === "single-page-application") {
+				policy.assetConfig.not_found_handling = "none";
+				policy.workerSpaFallback = true;
+			}
+		}
+		return policy;
+	}
+	assetRouting = resolveConfiguredAssetRoutingPolicy();
 	workerConfig.main = join(root, ".void", "entry.ts");
-	if (jobs.length > 0) workerConfig.triggers = { crons: jobs.flatMap((job) => job.crons) };
 	function applyAssetRoutingPolicy(policy) {
 		workerConfig.assets = {
 			binding: "ASSETS",
@@ -5617,11 +6339,13 @@ function voidPlugin(options) {
 		createWranglerCompatPersistPlugin(root, config),
 		restartPlugin(),
 		bindingWatchPlugin,
+		...bindings.needsEmail ? [emailDevInboxPlugin({ devTriggerToken })] : [],
 		envPlugin,
-		envSchemaPlugin(root, { onDefaults: applySchemaDefaultsToWorkerVars }),
+		envSchemaPlugin(root, { onSchema: applyEnvSchema }),
 		envClientGuardPlugin(root),
 		envClientFoldPlugin(),
 		clientStubsPlugin,
+		serverRuntimeOptimizerPlugin,
 		bindingRuntimePlugin(bindingNames),
 		...bindings.needsSandbox ? [createSandboxSdkResolvePlugin()] : [],
 		...pagesDevCssAssetsPlugin(root, devTriggerToken),
@@ -5638,14 +6362,17 @@ function voidPlugin(options) {
 			sandboxBindingName: sandboxConfig?.binding,
 			sandboxClassName: sandboxConfig?.className,
 			live: liveConfig,
+			durableObjects,
+			websocketTombstones,
 			onDevAssetRoutingPolicyChange: updateDevAssetRoutingPolicy
 		}),
 		drizzlePlugin(root, true, dialect, {
 			d1BindingName: bindingNames?.d1,
 			forceVirtualDb: authEnabled || bindingNames?.d1 !== void 0,
-			localD1PersistRoot: options?.persistTo ?? outDir
+			localD1DatabaseId: localD1.databaseId,
+			localD1PersistRoot: localD1.persistRoot
 		}),
-		migrationPlugin(root, dialect, "local", join(root, ".void"), {
+		migrationPlugin(root, dialect, localD1.databaseId, localD1.persistRoot, {
 			enabled: authEnabled,
 			configPath: authConfigPath
 		}),
@@ -5656,7 +6383,7 @@ function voidPlugin(options) {
 		}),
 		...cloudflare({
 			...inspectorPortOption,
-			persistState: { path: options?.persistTo ?? outDir },
+			persistState: { path: localD1.persistRoot },
 			auxiliaryWorkers: options?.auxiliaryWorkers,
 			viteEnvironment: { name: DEFAULT_WORKER_ENVIRONMENT_NAME },
 			config: mergeBindings
@@ -5664,4 +6391,4 @@ function voidPlugin(options) {
 	];
 }
 //#endregion
-export { VoidAssetRewriteError, basicAuth, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled, shouldBindWorkersAi, voidPlugin };
+export { VoidAssetRewriteError, basicAuth, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled, resolveWorkersAiBindingName, shouldBindWorkersAi, shouldInjectEmailDevInboxVar, voidPlugin };