void 0.28.0 → 1.0.3

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { n as __toESM } from "./rolldown-runtime-DXIUcv95.mjs";
-import { a as join, c as resolve, n as dirname, s as relative } from "./dist-ipQi0Q8y.mjs";
+import { a as join, c as resolve, n as dirname, o as normalize, s as relative } from "./dist-ipQi0Q8y.mjs";
 import { t as require_picocolors } from "./picocolors-BTps1_gs.mjs";
 import { d as walk, l as inferBindingsFromSource, m as applyBindingOverrides, n as FRAMEWORK_SCAN_DIRS, t as DEFAULT_SCAN_DIRS, u as staticModuleReferences } from "./plugin-inference-DsARdQKE.mjs";
 import { n as readProjectPaths, t as assertNoRootSourceConventionConflicts } from "./project-paths-DMvEeSau.mjs";
@@ -7,43 +7,44 @@ import { n as loadVoidAuthConfig } from "./config-D0GY5ItR.mjs";
 import { c as isNodeTarget, d as readConfig, s as getDatabaseDialect } from "./config-Bx_1SpnO.mjs";
 import { i as isMemberExpression, n as isIdentifier, r as isLiteral } from "./ast-CPGPjb0V.mjs";
 import { t as isRouteEnabledForEnvironment } from "./parse-filename-CUbj-1MP.mjs";
-import { a as hasSandboxSqliteMigration, c as sandboxContainerConfig, i as assertSandboxNamespaceConfig, m as scanJobsSync, n as DEFAULT_SANDBOX_CLASS_NAME, r as SANDBOX_MIGRATION_TAG, s as resolveSandboxConfig, t as analyzeApplicationSync, u as scanQueuesSync } from "./application-analysis-D72ZQfMZ.mjs";
+import { a as hasSandboxSqliteMigration, c as sandboxContainerConfig, i as assertSandboxNamespaceConfig, n as DEFAULT_SANDBOX_CLASS_NAME, p as scanJobsSync, r as SANDBOX_MIGRATION_TAG, s as resolveSandboxConfig, t as analyzeApplicationSync, u as scanQueuesSync } from "./application-analysis-AB_YYWgH.mjs";
 import { a as validateSsrEntries, n as SSR_SERVER_ENTRY_RELATIVE_PATHS, o as validateSsrEntry, t as SSR_CLIENT_ENTRY_RELATIVE_PATHS } from "./entry-ehmBvs5w.mjs";
 import { r as hasEmailHandlers } from "./email-BcjSyAL0.mjs";
 import { t as MagicString } from "./dist-Cegxq8gs.mjs";
 import { i as resolveLayoutIds } from "./scan-C0BMdmEd.mjs";
-import { a as resolveDistDir, c as hasApiRoutes, d as resolveAssetRoutingPolicy, l as hasDocumentRoutes, n as collectRevalidate, o as resolveWorkerDirName, r as hasRevalidate, s as generateQueueResolverSource, t as collectPages } from "./isr-config-DPjXM8J2.mjs";
+import { a as resolveDistDir, c as hasDocumentRoutes, n as collectRevalidate, o as resolveWorkerDirName, r as hasRevalidate, s as hasApiRoutes, t as collectPages, u as resolveAssetRoutingPolicy } from "./isr-config-fZaJJ8t7.mjs";
 import { i as voidWarn, n as voidError, r as voidLog, t as setShowTimestamp } from "./log-vqY3pqwI.mjs";
 import { n as mergeRoutingRules, t as lintRoutingPhases } from "./headers-Di1FsD3e.mjs";
 import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-rqDnVsJN.mjs";
 import { a as restoreCloudflarePreviewPointer, r as materializeCloudflareConfig, s as stashCloudflareDeployPointer } from "./cloudflare-config-DV60XFFK.mjs";
 import { D as syncWranglerBindings, E as resolveLiveBindingConfig, O as syncWranglerDurableObjects, T as readWranglerWebSocketTombstones, a as LIVE_MIGRATION_TAG, d as ensureWranglerCompatibilityDate, f as ensureWranglerNodejsAlsFlag, g as normalizeWranglerCompatibilityFlags, h as nextDurableObjectMigrationTag, k as syncWranglerWebSockets, m as hasDurableObjectSqliteMigration, p as findBindingNameOwner, u as ensureWranglerCompat, v as readExistingLiveBindingConfig, x as readWranglerCompat } from "./wrangler-BYs07Rxy.mjs";
-import { n as writeLocalD1PersistState, t as resolveLocalD1Target } from "./local-d1-BM3p74mm.mjs";
+import { n as writeLocalD1PersistState, t as resolveLocalD1Target } from "./local-d1-BxvQYEFi.mjs";
 import { n as scopedAccessCredentials } from "./cf-access-BM9G0lhO.mjs";
 import { n as ensurePlatformProxyAccess } from "./cf-access-CWP4avfP.mjs";
 import { a as getApiUrl, c as getToken, o as getProxyUrl } from "./auth-B6iOCjKI.mjs";
-import { m as printSuccess } from "./output-FNHKw5Ac.mjs";
-import { n as ensureProjectTsconfig, r as writeFileIfChanged } from "./project-tsconfig-bveqhlYA.mjs";
-import { i as generateDbDts, n as generateQueueTypes, r as DRIZZLE_OPERATORS, t as generateRouteTypes } from "./route-types-IrBuwJ7u.mjs";
-import { t as discoverSchema } from "./discover-D2PGT63u.mjs";
+import { m as printSuccess } from "./output-Ba6ZbrzY.mjs";
+import { r as writeFileIfChanged } from "./project-tsconfig-bveqhlYA.mjs";
+import { n as drizzlePlugin, t as generateQueueResolverSource } from "./dispatch-DrTTk8Xg.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 } from "./dev-inbox-Rd6j_8vM.mjs";
 import { n as scanWranglerDotenvKeys } from "./dotenv-CNazY3-w.mjs";
 import { a as isClientEnvKey, c as resolveRemoteMode, i as findReservedEnvKeys, n as LOCAL_ENV_FILE, o as loadLocalEnv, r as findLegacyEnvFiles, s as reservedEnvKeysMessage } from "./env-BJjULvL0.mjs";
 import { n as findEnvFileForPaths, r as generateEnvTypes, t as findEnvFile } from "./env-types-DS2_y4X8.mjs";
 import { t as loadUserEnvFile } from "./load-user-env-DD5qveNU.mjs";
-import { n as INTERNAL_BINDING_PREFIXES, t as INTERNAL_BINDING_EXACT_NAMES } from "./env-raw-Cklzcde3.mjs";
+import { n as INTERNAL_BINDING_PREFIXES, t as INTERNAL_BINDING_EXACT_NAMES } from "./env-raw-D74P4ebM.mjs";
 import { t as ASSET_EXTENSIONS } from "./routing-assets-VkrKIbxE.mjs";
 import { r as selectNativeVersionMetadataBinding, t as CLOUDFLARE_PRESERVE_BINDINGS_BUILD_ENV } from "./version-metadata-DIrqEHQo.mjs";
-import { f as prerenderPages, n as SEND_EMAIL_BINDING, p as prerenderPagesNode } from "./email-cloudflare-CH053RxK.mjs";
+import { f as prerenderPages, n as SEND_EMAIL_BINDING, p as prerenderPagesNode } from "./email-cloudflare-DfG6UEMm.mjs";
 import { r as defer } from "./validation-error-Dg9Recn1.mjs";
 import { i as safeJsonStringify } from "./protocol-RNP0u7UY.mjs";
-import { n as completeApplicationAnalysis } from "./application-routing-Dy589Vgn.mjs";
+import { n as completeApplicationAnalysis } from "./application-routing-L7V-TFhZ.mjs";
 import { n as generateVoidAuthDrizzleSchema, t as generateVoidAuthDatabaseModule } from "./drizzle-CF84FOVM.mjs";
+import { n as generateQueueTypes, t as generateRouteTypes } from "./route-types-BZi26DVS.mjs";
 import { a as defineMiddleware, c as defineScheduled, i as defineHead, n as basicAuth, o as defineQueue, r as defineHandler, s as defineRender, t as VoidAssetRewriteError } from "./handler-BZ1t7-Rv.mjs";
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import module, { builtinModules, createRequire } from "node:module";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { cloudflare } from "@cloudflare/vite-plugin";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { loadEnv, normalizePath, parseSync, resolveEnvPrefix } from "vite";
+import { defaultServerConditions, loadEnv, normalizePath, parseSync, resolveEnvPrefix } from "vite";
 import { appendSqliteClassMigration } from "@void/deploy-core";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { homedir } from "node:os";
@@ -488,10 +489,10 @@ function readVoidDevCredentials(root) {
 * block the server. On completion, writes project.json and restarts the server.
 */
 async function runAiSetupPrompt(root, token, apiUrl, server) {
-	const { select, text, isCancel, log } = await import("./dist-Bx1z6Eva.mjs");
-	const { PlatformClient } = await import("./client-C1BjRn3g.mjs");
-	const { attachSelectedPlatform, writeProjectConfig } = await import("./project-DiiOBZPF.mjs");
-	const { inferDefaultSlug } = await import("./resolve-project-B9Hr0D3n.mjs");
+	const { select, text, isCancel, log } = await import("./dist-CfgIkieS.mjs");
+	const { PlatformClient } = await import("./client-B60PwCC4.mjs");
+	const { attachSelectedPlatform, writeProjectConfig } = await import("./project-zdB3fs9G.mjs");
+	const { inferDefaultSlug } = await import("./resolve-project-PnhzMtY6.mjs");
 	const client = new PlatformClient(token, { apiUrl });
 	let projects;
 	try {
@@ -517,8 +518,8 @@ async function runAiSetupPrompt(root, token, apiUrl, server) {
 	let projectId;
 	let slug;
 	if (result === "__create__") {
-		const { validateProjectSlug } = await import("./project-slug-DofjTFd-.mjs");
-		const { createProjectWithSlugRetry } = await import("./create-project-DL7YXpjj.mjs");
+		const { validateProjectSlug } = await import("./project-slug-6cyz8E7k.mjs");
+		const { createProjectWithSlugRetry } = await import("./create-project-B-ewF_Af.mjs");
 		let created;
 		try {
 			created = await createProjectWithSlugRetry(client, inferDefaultSlug(root), async (defaultSlug) => {
@@ -552,7 +553,7 @@ async function runAiSetupPrompt(root, token, apiUrl, server) {
 }
 //#endregion
 //#region src/plugin-binding-runtime.ts
-const envModuleResolved$1 = fileURLToPath(import.meta.resolve("#self/_env"));
+const envModuleResolved = fileURLToPath(import.meta.resolve("#self/_env"));
 const kvModuleResolved = fileURLToPath(import.meta.resolve("void/kv"));
 const storageModuleResolved = fileURLToPath(import.meta.resolve("void/storage"));
 const VIRTUAL_KV_ID = "\0virtual:void-kv";
@@ -573,7 +574,7 @@ function bindingRuntimePlugin(bindingNames) {
 			filter: { id: /^\0virtual:void-(?:kv|storage)$/ },
 			handler(id) {
 				if (id === VIRTUAL_KV_ID) return `
-import { requireRuntimeBinding } from ${JSON.stringify(envModuleResolved$1)};
+import { requireRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
 import { createKV } from ${JSON.stringify(kvModuleResolved)};
 
 const namespace = new Proxy({}, {
@@ -588,7 +589,7 @@ export { createKV };
 export const kv = createKV(namespace);
 `;
 				if (id === VIRTUAL_STORAGE_ID) return `
-import { requireRuntimeBinding } from ${JSON.stringify(envModuleResolved$1)};
+import { requireRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
 export { createStorage } from ${JSON.stringify(storageModuleResolved)};
 
 export const storage = new Proxy({}, {
@@ -696,6 +697,19 @@ function isViteBuildOrPreview() {
 	const subcommand = process.argv[2];
 	return subcommand === "build" || subcommand === "preview";
 }
+/**
+* Point Cloudflare remote bindings opened in this process at the login from
+* `void connect` and `void cloudflare login`. The Cloudflare Vite plugin and
+* Wrangler's platform proxy authenticate remote bindings here, in dev, preview
+* and build prerendering. They read cf's login only when `CLOUDFLARE_CF_AUTH`
+* is present (any value), and Wrangler's separate login otherwise. The keyring
+* flag selects the encrypted cf profile that Void's login writes. Environment
+* API tokens still take precedence, and the OAuth token stays in the store.
+*/
+function selectVoidCloudflareLogin() {
+	process.env.CLOUDFLARE_CF_AUTH = "true";
+	process.env.CLOUDFLARE_AUTH_USE_KEYRING = "true";
+}
 const DEV_TRIGGER_TOKEN_FILE_MODE = 384;
 /**
 * Persist the dev-trigger token at `<root>/.void/dev-trigger-token` so
@@ -862,199 +876,6 @@ function devTriggersHintPlugin(root, devTriggerToken) {
 	};
 }
 //#endregion
-//#region src/plugin-drizzle.ts
-const drizzleD1Resolved = fileURLToPath(import.meta.resolve("drizzle-orm/d1"));
-const drizzleOrmResolved = fileURLToPath(import.meta.resolve("drizzle-orm"));
-const envModuleResolved = fileURLToPath(import.meta.resolve("#self/_env"));
-const drizzleNodePgResolved = fileURLToPath(import.meta.resolve("drizzle-orm/node-postgres"));
-const 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";
-/**
-* Vite plugin for Drizzle integration.
-*
-* - Intercepts `void/db` imports in SSR/worker environments and serves
-*   a virtual module that creates a Drizzle DB instance, using the user's
-*   schema when present.
-* - Generates `.void/db.d.ts` with proper Drizzle types.
-* - Sets up `@schema` Vite alias for convenient imports when a schema exists.
-* - Updates `.void/tsconfig.json` with TypeScript paths.
-*/
-function drizzlePlugin(root, hasRouteTypes, dialect = "sqlite", options = {}) {
-	const outDir = join(root, ".void");
-	const paths = readProjectPaths(root);
-	const schema = discoverSchema(root, paths);
-	const hasDbRuntime = schema != null || options.forceVirtualDb === true;
-	const d1BindingName = options.d1BindingName ?? "DB";
-	ensureProjectTsconfig(root, hasRouteTypes, hasDbRuntime, schema != null, {
-		redirectDbModule: options.redirectDbTypePaths,
-		paths
-	});
-	if (hasDbRuntime) generateDbDts(outDir, schema ?? null, dialect);
-	let isBuild = false;
-	return {
-		name: "void:drizzle",
-		enforce: "pre",
-		config(_, env) {
-			isBuild = env.command === "build";
-			if (!schema) return;
-			return { resolve: { alias: { "@schema": schema.path } } };
-		},
-		resolveId: {
-			filter: { id: /^(void\/db|@schema|pg$)/ },
-			handler(id, importer) {
-				if (id === "pg" && isBuild && dialect === "postgresql" && importer === VIRTUAL_DB_ID) return pgResolved;
-				if (id === "void/db" && this.environment?.name !== "client") {
-					if (!hasDbRuntime) return;
-					if (schema && importer) {
-						const normalizedImporter = normalizePath(importer);
-						const normalizedSchemaPath = normalizePath(schema.path);
-						if (schema.type === "file" && normalizedImporter === normalizedSchemaPath) return VIRTUAL_SCHEMA_DB_ID;
-						if (schema.type === "directory" && normalizedImporter.startsWith(normalizedSchemaPath)) return VIRTUAL_SCHEMA_DB_ID;
-					}
-					return VIRTUAL_DB_ID;
-				}
-				if (schema && (id === "@schema" || id.startsWith("@schema/"))) {
-					if (id === "@schema") return schema.path;
-					return join(schema.path, id.slice(8));
-				}
-			}
-		},
-		load: {
-			filter: { id: /^\0virtual:void-db(?:-schema)?$/ },
-			handler(id) {
-				if (id === VIRTUAL_SCHEMA_DB_ID) return `
-export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
-export const db = {};
-export function createDb() {
-  throw new Error("db: createDb() is unavailable when importing void/db from a schema file.");
-}
-`;
-				const schemaImport = schema ? `import * as schema from ${JSON.stringify(schema.path)};` : "";
-				const drizzleConfig = schema ? 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, 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: PostgreSQL is not configured. Add DATABASE_URL to .env for local dev, or configure Hyperdrive for production.");
-}
-
-function getInstance() {
-  return getRuntimeRequestResource(_requestResourceKey, () => {
-    const pool = new pg.Pool({
-      connectionString: getConnectionString(),
-      max: 1,
-      idleTimeoutMillis: 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});
-}
-`;
-				return `
-import { drizzle } from ${JSON.stringify(drizzleD1Resolved)};
-import { getRuntimeRequestResource, requireRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
-${schemaImport}
-export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
-
-const _requestResourceKey = {};
-
-export const db = new Proxy({}, {
-  get(_, prop) {
-    const instance = getRuntimeRequestResource(
-      _requestResourceKey,
-      () => createDb(requireRuntimeBinding(${JSON.stringify(d1BindingName)})),
-      () => createPrimaryDb(requireRuntimeBinding(${JSON.stringify(d1BindingName)}))
-    );
-    return Reflect.get(instance, prop);
-  },
-});
-
-export function createDb(d1) {
-  return drizzle(d1.withSession("first-unconstrained")${drizzleConfig});
-}
-
-function createPrimaryDb(d1) {
-  return drizzle(d1.withSession("first-primary")${drizzleConfig});
-}
-`;
-			}
-		},
-		async configureServer() {
-			if (!schema) return;
-			const migrationsDir = paths.migrationsDir;
-			if (!(existsSync(migrationsDir) && readdirSync(migrationsDir).some((f) => f.endsWith(".sql")))) {
-				if (dialect === "sqlite") {
-					const { getApplicationTables, getMiniflareDatabasePath } = await import("./runner-B5huK2eC.mjs");
-					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.
-         Run \`void db generate\` to create migration files for dev startup and deploy.`);
-			}
-		}
-	};
-}
-//#endregion
 //#region src/plugin-email-dev-inbox.ts
 const SECURITY_HEADERS = {
 	"Cache-Control": "no-store",
@@ -2208,6 +2029,17 @@ export const onRequest = defineMiddleware(async (context, next) => {
 });
 `;
 }
+const ASTRO_MIDDLEWARE_CLAIMS = Symbol.for("void.astroDevMiddleware.v1");
+/**
+* The dev servers in this process that use the middleware Void wrote, by file path. Astro restarts
+* the dev server in the same process with a fresh config, so a new plugin instance (from a new
+* copy of this module, too) is set up before the old server closes. Kept on `globalThis` so both
+* see the same claim.
+*/
+function astroMiddlewareClaims() {
+	const store = globalThis;
+	return store[ASTRO_MIDDLEWARE_CLAIMS] ??= /* @__PURE__ */ new Map();
+}
 /**
 * Writes a tiny Astro middleware to the user's project so
 * `/__void/scheduled` and `/__void/queue` are intercepted inside Astro's
@@ -2217,36 +2049,54 @@ export const onRequest = defineMiddleware(async (context, next) => {
 * already has `src/middleware.ts` we don't overwrite it — instead we log a
 * one-shot snippet they can paste into their existing middleware.
 *
-* If we wrote the file we remove it on dev-server close so the user's
-* source tree stays clean. `src/middleware.ts` belongs to the user, so the
-* `.gitignore` line we add for it is removed too; otherwise a middleware they
-* write later would be silently left out of git.
+* If we wrote the file we remove it when the last dev server using it closes,
+* so the user's source tree stays clean. `src/middleware.ts` belongs to the
+* user, so the `.gitignore` line we add for it is removed too; otherwise a
+* middleware they write later would be silently left out of git.
 */
 function astroDevTriggerInjectPlugin(root) {
 	const middlewarePath = join(root, ASTRO_MIDDLEWARE_RELATIVE);
 	const middlewareDirIndexPath = join(root, "src", "middleware", "index.ts");
-	let wroteFile = false;
-	let addedGitignoreLines = [];
+	const claims = astroMiddlewareClaims();
+	/** Whether the dev server being set up now holds the middleware Void wrote. */
 	const ensureFile = () => {
+		const claim = claims.get(middlewarePath);
+		if (claim && existsSync(middlewarePath)) {
+			claim.servers++;
+			return true;
+		}
 		if (existsSync(middlewarePath) || existsSync(middlewareDirIndexPath)) {
 			voidWarn("Astro middleware already exists. To enable /__void/scheduled and /__void/queue,\n         add the Void dev-trigger middleware to your existing onRequest sequence.\n         See https://void.cloud/guide/jobs#local-development.");
-			return;
+			return false;
 		}
 		mkdirSync(dirname(middlewarePath), { recursive: true });
 		writeFileSync(middlewarePath, astroMiddlewareSource(frameworkTriggersDispatchPath(root)));
-		wroteFile = true;
+		if (claim) claim.servers++;
+		else claims.set(middlewarePath, {
+			servers: 1,
+			gitignoreLines: ensureGitignoreLines(root, [ASTRO_MIDDLEWARE_RELATIVE])
+		});
+		return true;
 	};
-	const cleanup = () => {
-		if (wroteFile) rmSync(middlewarePath, { force: true });
-		removeGitignoreLines(root, addedGitignoreLines);
-		addedGitignoreLines = [];
+	const release = () => {
+		const claim = claims.get(middlewarePath);
+		if (!claim || --claim.servers > 0) return;
+		claims.delete(middlewarePath);
+		rmSync(middlewarePath, { force: true });
+		removeGitignoreLines(root, claim.gitignoreLines);
 	};
 	return {
 		name: "void:astro-dev-trigger-inject",
 		apply: "serve",
 		configureServer(server) {
-			ensureFile();
-			if (wroteFile) addedGitignoreLines = ensureGitignoreLines(root, [ASTRO_MIDDLEWARE_RELATIVE]);
+			if (!ensureFile()) return;
+			let held = true;
+			const cleanup = () => {
+				if (held) {
+					held = false;
+					release();
+				}
+			};
 			server.httpServer?.once("close", cleanup);
 			process.once("exit", cleanup);
 		}
@@ -3097,10 +2947,10 @@ export async function fetch(path, options) {
 * (see `generateClassATriggerWrapper`). Production deploys go through
 * `cli/wrapper.ts` instead.
 */
-function getFrameworkEntry(framework, root, devTriggerToken, notFound) {
+function getFrameworkEntry(framework, root, devTriggerToken, dialect, notFound) {
 	const isBuild = isViteBuildOrPreview();
 	if (!isBuild) writeFrameworkTriggersDispatch(root, devTriggerToken);
-	return generateClassATriggerWrapper(root, framework, getOriginalFrameworkEntry(framework, root), isBuild, void 0, notFound);
+	return generateClassATriggerWrapper(root, framework, getOriginalFrameworkEntry(framework, root), isBuild, dialect, void 0, notFound);
 }
 /** The framework's own server entry, before our trigger wrapper. */
 function getOriginalFrameworkEntry(framework, root) {
@@ -3117,6 +2967,11 @@ function getOriginalFrameworkEntry(framework, root) {
 * first, dispatches `/__void/{scheduled,queue}` if it matches, and otherwise
 * delegates to the framework's original entry.
 *
+* For PostgreSQL and MySQL, both shapes run the framework inside Void's request scope
+* (`withRuntimeEnv`), as Void's own handlers do, so void/db keeps one client per request. D1 apps
+* keep the framework's own fetch: in a request scope, void/db reads D1 through a replica-capable
+* session instead of the primary.
+*
 * We emit two shapes of the wrapper depending on the Vite command:
 *
 * - Serve: dispatch is dynamically imported and gets a chance to handle
@@ -3129,27 +2984,11 @@ function getOriginalFrameworkEntry(framework, root) {
 * dispatch file (and its transitive user-cron/queue imports + dev token)
 * would still ship in the production bundle.
 */
-function generateClassATriggerWrapper(root, framework, original, isBuild, assetsDir = "assets", notFound) {
+function generateClassATriggerWrapper(root, framework, original, isBuild, dialect, assetsDir = "assets", notFound) {
 	const outDir = join(root, ".void");
 	mkdirSync(outDir, { recursive: true });
 	const wrapperPath = join(outDir, `${framework}-trigger-wrapper.ts`);
-	const body = isBuild ? `// @ts-nocheck — Auto-generated by Void for vite build. Do NOT edit.
-import original from ${JSON.stringify(original)};
-
-export default {
-  ...original,
-  async fetch(request, env, ctx) {
-    return serveWithAssets(request, env, await original.fetch(request, env, ctx));
-  },
-};
-${compileAssetFallbackHelper(assetsDir, false, notFound)}
-` : `// @ts-nocheck — Auto-generated by Void in dev. Do NOT edit.
-import original from ${JSON.stringify(original)};
-
-export default {
-  ...original,
-  async fetch(request, env, ctx) {
-    if (request.method === "POST") {
+	const fetchBody = isBuild ? `    return serveWithAssets(request, env, await original.fetch(request, env, ctx));` : `    if (request.method === "POST") {
       const pathname = new URL(request.url).pathname;
       if (pathname === "/__void/scheduled" || pathname === "/__void/queue") {
         const { handleDevTrigger } = await import(${JSON.stringify(frameworkTriggersDispatchPath(root))});
@@ -3157,10 +2996,23 @@ export default {
         if (response) return response;
       }
     }
-    return original.fetch(request, env, ctx);
-  },
+    return original.fetch(request, env, ctx);`;
+	const scoped = dialect !== "sqlite";
+	const fetchMethod = scoped ? `  fetch(request, env, ctx) {
+    return withRuntimeEnv(env, async () => {
+${fetchBody.replace(/^/gm, "  ")}
+    });
+  },` : `  async fetch(request, env, ctx) {
+${fetchBody}
+  },`;
+	const body = `// @ts-nocheck — Auto-generated by Void ${isBuild ? "for vite build" : "in dev"}. Do NOT edit.
+import original from ${JSON.stringify(original)};
+${scoped ? "import { withRuntimeEnv } from \"void/_env\";\n" : ""}
+export default {
+  ...original,
+${fetchMethod}
 };
-`;
+${isBuild ? `${compileAssetFallbackHelper(assetsDir, false, notFound)}\n` : ""}`;
 	writeFileIfChanged(wrapperPath, body);
 	return wrapperPath;
 }
@@ -3213,10 +3065,207 @@ export default {
 	return entryPath;
 }
 //#endregion
+//#region src/installed-packages.ts
+function readManifest(dir) {
+	try {
+		return JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	} catch {
+		return;
+	}
+}
+/** The directory Node loads `name` from for code in `fromDir`. Ignores `exports`. */
+function findInstalledPackage(name, fromDir) {
+	const pnp = module.findPnpApi?.(fromDir);
+	if (pnp) try {
+		const manifest = pnp.resolveToUnqualified(`${name}/package.json`, `${fromDir}/`);
+		return manifest ? dirname(manifest) : void 0;
+	} catch {
+		return;
+	}
+	for (let dir = fromDir;; dir = dirname(dir)) {
+		const candidate = join(dir, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) return realpathSync(candidate);
+		if (dirname(dir) === dir) return;
+	}
+}
+function isVoidPackage(name) {
+	return name === "void" || name.startsWith("@void/");
+}
+/** The `exports` conditions that an import matches in Vite's SSR graph. */
+const IMPORT_CONDITIONS = /* @__PURE__ */ new Set([
+	"node",
+	"import",
+	"module",
+	"default"
+]);
+/**
+* Vite's SSR graph also matches `production` or `development`, as NODE_ENV says. Vite sets
+* NODE_ENV before it runs the plugin hooks that call this.
+*/
+function matchesImport(condition) {
+	const mode = process.env.NODE_ENV === "production" ? "production" : "development";
+	return IMPORT_CONDITIONS.has(condition) || condition === mode;
+}
+/** The target an import picks from an `exports` value: its first matching key, as in Node. */
+function importTarget(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const target = importTarget(item);
+			if (target) return target;
+		}
+		return;
+	}
+	if (!value || typeof value !== "object") return;
+	for (const [key, item] of Object.entries(value)) {
+		const target = matchesImport(key) ? importTarget(item) : void 0;
+		if (target) return target;
+	}
+}
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+/** The file an import of the package loads: `exports` ".", then `module`, then `main`. */
+function findImportEntry(dir, manifest) {
+	const exports = manifest.exports;
+	const entry = importTarget(exports && typeof exports === "object" && Object.keys(exports).some((key) => key.startsWith(".")) ? exports["."] : exports) ?? (typeof manifest.module === "string" ? manifest.module : void 0) ?? (typeof manifest.main === "string" ? manifest.main : "index.js");
+	for (const candidate of [
+		entry,
+		`${entry}.js`,
+		`${entry}/index.js`
+	]) {
+		const file = join(dir, candidate);
+		if (isFile(file)) return file;
+	}
+}
+/** Whether Node loads a `.mjs` or `.js` file in the package as an ES module. */
+function isEsmFile(file, dir, manifest) {
+	if (file.endsWith(".mjs")) return true;
+	if (!file.endsWith(".js")) return false;
+	for (let scope = dirname(file); scope.startsWith(`${dir}/`); scope = dirname(scope)) {
+		const nested = readManifest(scope);
+		if (nested) return nested.type === "module";
+	}
+	return manifest.type === "module";
+}
+/** A dynamic `import()` argument that is a single string literal naming a relative file. */
+const RELATIVE_LITERAL = /^(["'])(\.{1,2}\/[^"']*)\1$/;
+/** The relative files that a module's imports, re-exports and `import()` calls name. */
+function relativeImports(code, parsed) {
+	const specifiers = staticModuleReferences(parsed, code).map((reference) => reference.source);
+	for (const { moduleRequest } of parsed.module.dynamicImports) {
+		const literal = RELATIVE_LITERAL.exec(code.slice(moduleRequest.start, moduleRequest.end));
+		if (literal) specifiers.push(literal[2]);
+	}
+	return specifiers.filter((specifier) => /^\.{1,2}\//.test(specifier));
+}
+/** The most files of one package that the check reads. A package with more stays with Node. */
+const MAX_PACKAGE_MODULES = 2e3;
+/**
+* Vite's SSR module runner evaluates an inlined package as ES modules. The package's import
+* entry and every file it reaches through relative imports must be one. So the ES module
+* wrapper in Node's dual-package guide, or any ES module of the package that imports a
+* CommonJS file, keeps the package with Node.
+*/
+function shipsEsm(packageDir, manifest) {
+	const dir = normalize(packageDir);
+	const entry = findImportEntry(dir, manifest);
+	if (!entry) return false;
+	const files = [entry];
+	const seen = new Set(files);
+	for (const file of files) {
+		if (!isEsmFile(file, dir, manifest)) return false;
+		let code;
+		try {
+			code = readFileSync(file, "utf8");
+		} catch {
+			return false;
+		}
+		const parsed = parseSync(file, code, {
+			lang: "js",
+			sourceType: "module"
+		});
+		if (parsed.errors.length > 0) return false;
+		for (const specifier of relativeImports(code, parsed)) {
+			const next = join(dirname(file), specifier);
+			if (/\.[cm]?js$/.test(next) && !seen.has(next)) {
+				if (seen.size >= MAX_PACKAGE_MODULES) return false;
+				seen.add(next);
+				files.push(next);
+			}
+		}
+	}
+	return true;
+}
+/**
+* Installed ES module packages that list `void` or an `@void/` package as a dependency, among
+* the app's own dependencies and, through them, the packages they depend on (the rule
+* vite-plugin-svelte applies to Svelte libraries). Vite leaves a package in node_modules to Node,
+* whose `void/*` imports then skip Void's plugins: the generated `void/db` and the Node target's
+* guard. Listing these packages in `ssr.noExternal` keeps them in Vite's graph.
+*/
+function findVoidDependentPackages(root) {
+	const app = readManifest(root);
+	if (!app) return [];
+	const found = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (names, fromDir) => {
+		for (const name of names) {
+			if (isVoidPackage(name)) continue;
+			const dir = findInstalledPackage(name, fromDir);
+			if (!dir || seen.has(dir)) continue;
+			seen.add(dir);
+			const manifest = readManifest(dir);
+			const dependencies = {
+				...manifest?.dependencies,
+				...manifest?.optionalDependencies
+			};
+			if (!manifest || !Object.keys({
+				...dependencies,
+				...manifest.peerDependencies
+			}).some(isVoidPackage) || !shipsEsm(dir, manifest)) continue;
+			found.add(name);
+			visit(Object.keys(dependencies), dir);
+		}
+	};
+	visit(Object.keys({
+		...app.dependencies,
+		...app.devDependencies,
+		...app.optionalDependencies
+	}), root);
+	return [...found].sort();
+}
+/** `name` and every package it depends on, as installed for code in `fromDir`. */
+function findDependencyClosure(name, fromDir) {
+	const found = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (dependency, from) => {
+		const dir = findInstalledPackage(dependency, from);
+		if (!dir || seen.has(dir)) return;
+		seen.add(dir);
+		found.add(dependency);
+		const manifest = readManifest(dir);
+		for (const next of Object.keys({
+			...manifest?.dependencies,
+			...manifest?.optionalDependencies
+		})) visit(next, dir);
+	};
+	visit(name, fromDir);
+	return [...found].sort();
+}
+//#endregion
 //#region src/plugin-migration.ts
 function readDatabaseUrl(root) {
 	return loadLocalEnv(root).DATABASE_URL;
 }
+/** DATABASE_URL as Better Auth's local migrations read it: the shell before `.env`. */
+function readAuthDatabaseUrl(root) {
+	return (process.env.DATABASE_URL ?? readDatabaseUrl(root)) || void 0;
+}
 /**
 * Vite plugin that runs local migrations on dev server startup.
 * For SQLite/D1: applies migrations to the local miniflare database.
@@ -3230,33 +3279,53 @@ function migrationPlugin(root, dialect, databaseId = "local", persistRoot = join
 			const migrationsDir = readProjectPaths(root).migrationsDir;
 			const hasSqlMigrations = existsSync(migrationsDir);
 			if (!hasSqlMigrations && !auth?.enabled) return;
+			const migrateAuth = async (databaseUrl) => {
+				const { runLocalVoidAuthMigrations } = await import("./node-cPadMgUO.mjs");
+				await runLocalVoidAuthMigrations(root, dialect, persistRoot, databaseId, auth?.configPath, databaseUrl);
+			};
+			const mysqlAuth = dialect === "mysql" && auth?.enabled === true;
+			const logApplied = (applied) => {
+				if (applied.length > 0) voidLog(`Applied ${applied.length} migration(s): ${applied.join(", ")}`);
+			};
 			try {
-				if (hasSqlMigrations && dialect !== "sqlite") {
-					const url = readDatabaseUrl(root);
-					if (!url) {
+				if (dialect !== "sqlite") {
+					const { collectMigrations } = await import("./collect-Cae8A7Zr.mjs");
+					const allMigrations = collectMigrations(migrationsDir);
+					const runFiles = dialect === "mysql" ? allMigrations.length > 0 : hasSqlMigrations;
+					const url = runFiles ? readDatabaseUrl(root) : void 0;
+					const authUrl = mysqlAuth ? readAuthDatabaseUrl(root) : void 0;
+					if (runFiles && !url || mysqlAuth && !authUrl) {
 						afterServerReady(server, () => {
 							console.log();
 							voidError(`DATABASE_URL not found in .env — skipping ${dialect === "mysql" ? "MySQL" : "PostgreSQL"} migrations.`);
 						});
 						return;
 					}
-					const { collectMigrations } = await import("./collect-NUlJMpLY.mjs");
-					const { validateMigrations } = await import("./validate-C9xtFOYR.mjs");
-					const allMigrations = collectMigrations(migrationsDir);
-					const appliedNames = dialect === "mysql" ? await import("./runner-mysql-CaJq-hd6.mjs").then((runner) => runner.getMySqlAppliedMigrations(url)) : await import("./runner-pg-BJhFZZG4.mjs").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 authWithFiles = authUrl !== void 0 && authUrl === url;
+					if (url) {
+						const { validateMigrations } = await import("./validate-BQFdf0Pi.mjs");
+						const appliedNames = dialect === "mysql" ? await import("./runner-mysql-DWwE8jKi.mjs").then((runner) => runner.getMySqlAppliedMigrations(url)) : await import("./runner-pg-_Xncr3H5.mjs").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 = dialect === "mysql" ? await import("./runner-mysql-DWwE8jKi.mjs").then((runner) => runner.runMySqlMigrations(migrationsDir, url, authWithFiles ? async (names) => {
+							logApplied(names);
+							await migrateAuth(url);
+						} : void 0)) : await import("./runner-pg-_Xncr3H5.mjs").then((runner) => runner.runPgMigrations(migrationsDir, url));
+						if (!authWithFiles) logApplied(applied);
+					}
+					if (authUrl && !authWithFiles) {
+						const { withMySqlMigrationLockAt } = await import("./runner-mysql-DWwE8jKi.mjs");
+						await withMySqlMigrationLockAt(authUrl, () => migrateAuth(authUrl));
 					}
-					const applied = dialect === "mysql" ? await import("./runner-mysql-CaJq-hd6.mjs").then((runner) => runner.runMySqlMigrations(migrationsDir, url)) : await import("./runner-pg-BJhFZZG4.mjs").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-B5huK2eC.mjs");
-					const { collectMigrations } = await import("./collect-NUlJMpLY.mjs");
-					const { validateMigrations } = await import("./validate-C9xtFOYR.mjs");
+					const { runMigrations, getMiniflareDatabasePath, getAppliedMigrations } = await import("./runner-So9mYfcm.mjs");
+					const { collectMigrations } = await import("./collect-Cae8A7Zr.mjs");
+					const { validateMigrations } = await import("./validate-BQFdf0Pi.mjs");
 					const dbPath = getMiniflareDatabasePath(persistRoot, databaseId);
 					const allMigrations = collectMigrations(migrationsDir);
 					const appliedRows = await getAppliedMigrations(dbPath);
@@ -3271,8 +3340,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-DoKbo1SZ.mjs");
-					await runLocalVoidAuthMigrations(root, dialect, persistRoot, databaseId, auth.configPath);
+					if (!mysqlAuth) await migrateAuth();
 					voidLog("Applied Better Auth migrations");
 				}
 			} catch (err) {
@@ -3309,6 +3377,26 @@ function createCloudflareBuiltinsExternalPlugin() {
 		}
 	};
 }
+/**
+* Send a bare `void` import in server code to the handler helpers (`defineScheduled`,
+* `defineQueue`, ...), as Void apps and the cron/queue deploy bundles do. The package entry is the
+* Vite plugin: loaded in a worker environment, it pulls Wrangler into the dependency optimizer.
+*/
+function createBareVoidRedirectPlugin() {
+	let handlerFile;
+	return {
+		name: "void:bare-void-redirect",
+		resolveId: {
+			order: "pre",
+			filter: { id: /^void$/ },
+			handler() {
+				if (this.environment?.config.consumer === "client") return;
+				handlerFile ??= fileURLToPath(import.meta.resolve("#self/handler"));
+				return handlerFile;
+			}
+		}
+	};
+}
 function createDefaultWorkerEnvironmentPlugin() {
 	return {
 		name: "void:default-worker-environment",
@@ -3369,16 +3457,58 @@ function createWranglerCompatPersistPlugin(root, config) {
 		}
 	};
 }
-function createServerRuntimeOptimizerPlugin(voidOwnsWorkerRuntime) {
+const DATABASE_DRIVER_DEPS = {
+	sqlite: [],
+	postgresql: ["void > pg"],
+	mysql: ["void > mysql2"]
+};
+const NODE_BUILTIN = new RegExp(`^(?:node:)?(?:${builtinModules.join("|")})$`);
+const NODE_BUILTIN_REQUIRE_PREFIX = "\0void:node-require:";
+/**
+* The Node built-ins that workerd provides for the given compatibility settings, from the preset
+* the Cloudflare plugin builds Workers with (a dependency of `@cloudflare/vite-plugin`). Before
+* 2025-09-15 the preset fills in parts of `node:process` instead of listing it, but workerd
+* provides that module at every date.
+*/
+async function readWorkerdNodeBuiltins(compat) {
+	const vitePlugin = fileURLToPath(import.meta.resolve("@cloudflare/vite-plugin"));
+	const manifestPath = createRequire(vitePlugin).resolve("@cloudflare/unenv-preset/package.json");
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	const { getCloudflarePreset } = await import(pathToFileURL(join(dirname(manifestPath), manifest.exports["."].import)).href);
+	const { external } = getCloudflarePreset({
+		compatibilityDate: compat.compatibilityDate,
+		compatibilityFlags: compat.compatibilityFlags ?? []
+	});
+	return /* @__PURE__ */ new Set([...external.map((name) => name.replace(/^node:/, "")), "process"]);
+}
+function createServerRuntimeOptimizerPlugin(dialect, readCompat) {
+	let workerdNodeBuiltins;
 	return {
 		name: "void:server-runtime-optimizer",
-		configEnvironment(name) {
+		configEnvironment(name, environment) {
 			if (name === "client") return;
-			if (!voidOwnsWorkerRuntime) return { optimizeDeps: { exclude: ["void"] } };
+			if (!environment.resolve?.conditions?.includes("workerd")) return { optimizeDeps: { exclude: ["void"] } };
 			return { optimizeDeps: {
 				exclude: ["void"],
-				include: ["void > email-validator"]
+				include: ["void > email-validator", ...DATABASE_DRIVER_DEPS[dialect]]
 			} };
+		},
+		resolveId: {
+			order: "pre",
+			filter: { id: NODE_BUILTIN },
+			async handler(id, _importer, options) {
+				if (dialect === "sqlite" || options.kind !== "require-call" || this.environment?.mode !== "build" || !this.environment.config.resolve.conditions.includes("workerd")) return;
+				const name = id.replace(/^node:/, "");
+				workerdNodeBuiltins ??= readWorkerdNodeBuiltins(readCompat());
+				if (!(await workerdNodeBuiltins).has(name)) return;
+				return `${NODE_BUILTIN_REQUIRE_PREFIX}${name}`;
+			}
+		},
+		load: {
+			filter: { id: /^\0void:node-require:/ },
+			handler(id) {
+				return `import builtin from "node:${id.slice(19)}";\nexport { builtin as "module.exports" };\n`;
+			}
 		}
 	};
 }
@@ -3386,6 +3516,17 @@ function createServerRuntimeOptimizerPlugin(voidOwnsWorkerRuntime) {
 //#region src/sveltekit-hooks-transform.ts
 /** Add Void's dev bindings to SvelteKit's generated get_hooks function. */
 function injectSvelteKitHooks(code, id, dispatchPath) {
+	return editGetHooks(code, id, `\n  const { withRuntimeEnv } = await import("void/_env");\n  const { handleDevTrigger } = await import(${JSON.stringify(dispatchPath)});`, "const __origHandle = handle ?? (({ event, resolve }) => resolve(event));\n  handle = async ({ event, resolve }) => {\n    const __voidEnv = event.platform?.env ?? (await import('cloudflare:workers')).env;\n    return withRuntimeEnv(__voidEnv, async () => {\n    const __triggerResp = await handleDevTrigger(event.request, __voidEnv, undefined);\n    if (__triggerResp) return __triggerResp;\n    return __origHandle({ event, resolve });\n    });\n  };\n  ");
+}
+/**
+* Run each request of a SvelteKit build in Void's request scope. `envModule` is the env module
+* void/db imports. Kit prerenders in Node, where `cloudflare:workers` does not load and Kit 3
+* passes no platform, so those requests run outside the scope.
+*/
+function injectSvelteKitBuildHooks(code, id, envModule) {
+	return editGetHooks(code, id, `\n  const { withRuntimeEnv } = await import(${JSON.stringify(envModule)});`, "const __origHandle = handle ?? (({ event, resolve }) => resolve(event));\n  handle = async ({ event, resolve }) => {\n    const __voidEnv = event.platform?.env ??\n      (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers'\n        ? (await import('cloudflare:workers')).env\n        : undefined);\n    return withRuntimeEnv(__voidEnv, () => __origHandle({ event, resolve }));\n  };\n  ");
+}
+function editGetHooks(code, id, prologue, handleWrapper) {
 	if (!code.includes("get_hooks")) return;
 	const hooks = (parseSync(id, code).program.body ?? []).filter((node) => node.type === "ExportNamedDeclaration").map((node) => node.declaration).filter((node) => {
 		const name = node?.id;
@@ -3396,8 +3537,8 @@ function injectSvelteKitHooks(code, id, dispatchPath) {
 	const returns = (body?.body)?.filter((node) => node.type === "ReturnStatement" && node.argument?.type === "ObjectExpression") ?? [];
 	if (body?.type !== "BlockStatement" || body.start === void 0 || returns.length !== 1 || returns[0]?.start === void 0) throw new Error("sveltekit: Expected one object return in generated get_hooks.");
 	const ms = new MagicString(code);
-	ms.appendLeft(body.start + 1, `\n  const { withRuntimeEnv } = await import("void/_env");\n  const { handleDevTrigger } = await import(${JSON.stringify(dispatchPath)});`);
-	ms.appendLeft(returns[0].start, "const __origHandle = handle ?? (({ event, resolve }) => resolve(event));\n  handle = async ({ event, resolve }) => {\n    const __voidEnv = event.platform?.env ?? (await import('cloudflare:workers')).env;\n    return withRuntimeEnv(__voidEnv, async () => {\n    const __triggerResp = await handleDevTrigger(event.request, __voidEnv, undefined);\n    if (__triggerResp) return __triggerResp;\n    return __origHandle({ event, resolve });\n    });\n  };\n  ");
+	ms.appendLeft(body.start + 1, prologue);
+	ms.appendLeft(returns[0].start, handleWrapper);
 	return {
 		code: ms.toString(),
 		map: ms.generateMap({ hires: true })
@@ -3405,6 +3546,11 @@ function injectSvelteKitHooks(code, id, dispatchPath) {
 }
 //#endregion
 //#region src/plugin-framework.ts
+const handlerFile = fileURLToPath(import.meta.resolve("#self/handler"));
+const envModuleFile = fileURLToPath(import.meta.resolve("#self/_env"));
+const voidDir = dirname(fileURLToPath(import.meta.url));
+const ASTRO_SERVER_ENTRY = "@astrojs/cloudflare/entrypoints/server";
+const ASTRO_SCOPED_SERVER_ENTRY = "\0void:astro-server-entry";
 function createFrameworkPlugins(input) {
 	const { localD1, root, directCloudflareDestination, bindings, config, dialect, application, bindingNames, websocketRoutes, liveConfig, detected, clientStubsPlugin, serverRuntimeOptimizerPlugin, devTriggerToken, implicitDeployGuard } = input;
 	const frameworkPersistRoot = localD1.persistRoot;
@@ -3415,7 +3561,6 @@ function createFrameworkPlugins(input) {
 		name: "void:wrangler-compat",
 		enforce: "pre",
 		config(_, env) {
-			if (env.command === "serve" && directCloudflareDestination && bindings.needsAI) process.env.CLOUDFLARE_AUTH_USE_KEYRING = "true";
 			syncFrameworkCompat(ensureWranglerCompat(root, config));
 			if (env.command !== "serve") return;
 			if (ensureWranglerNodejsAlsFlag(root)) voidLog("Synced nodejs_als to Cloudflare config");
@@ -3468,19 +3613,90 @@ function createFrameworkPlugins(input) {
 	const svelteKitHooksInjectPlugin = {
 		name: "void:sveltekit-hooks-inject",
 		apply: "serve",
+		config() {
+			if (detected.class !== "b") return;
+			return { ssr: { noExternal: ["void", ...dialect === "sqlite" ? [] : findVoidDependentPackages(root)] } };
+		},
+		resolveId: {
+			order: "pre",
+			filter: { id: /^void$/ },
+			handler() {
+				if (detected.class !== "b" || this.environment?.name === "client") return;
+				return handlerFile;
+			}
+		},
 		transform(code, id) {
 			if (detected.class !== "b") return;
 			if (!id.includes(".svelte-kit/generated/server/internal") && !id.includes(".svelte-kit/generated/dev/server.js")) return;
 			return injectSvelteKitHooks(code, id, frameworkTriggersDispatchPath(root));
 		}
 	};
+	const astroRequestScopePlugin = detected.name === "astro" && dialect !== "sqlite" ? {
+		name: "void:astro-request-scope",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: /^@astrojs\/cloudflare\/entrypoints\/server(?:\.js)?$/ },
+			handler(_id, importer) {
+				if (importer === ASTRO_SCOPED_SERVER_ENTRY || this.environment?.name === "client") return;
+				return ASTRO_SCOPED_SERVER_ENTRY;
+			}
+		},
+		load: {
+			filter: { id: /^\0void:astro-server-entry$/ },
+			handler() {
+				return `import original from ${JSON.stringify(ASTRO_SERVER_ENTRY)};
+import { withRuntimeEnv } from ${JSON.stringify(envModuleFile)};
+export * from ${JSON.stringify(ASTRO_SERVER_ENTRY)};
+
+export default {
+  ...original,
+  fetch(request, env, ctx) {
+    return withRuntimeEnv(env, () => original.fetch(request, env, ctx));
+  },
+};
+`;
+			}
+		}
+	} : void 0;
+	const svelteKitWorkerBuildPlugin = detected.class === "b" && dialect !== "sqlite" ? {
+		name: "void:sveltekit-worker-build",
+		apply: "build",
+		enforce: "pre",
+		configEnvironment(name, environment) {
+			if (name !== "ssr") return;
+			return {
+				resolve: {
+					conditions: environment.resolve?.conditions ? ["workerd", "worker"] : [
+						"workerd",
+						"worker",
+						...defaultServerConditions
+					],
+					noExternal: [
+						"void",
+						"drizzle-orm",
+						dialect === "mysql" ? "mysql2" : "pg",
+						...findDependencyClosure("drizzle-orm", voidDir),
+						...findDependencyClosure(dialect === "mysql" ? "mysql2" : "pg", voidDir),
+						...findVoidDependentPackages(root)
+					]
+				},
+				build: { rolldownOptions: { platform: "neutral" } }
+			};
+		},
+		transform(code, id) {
+			if (!id.includes(".svelte-kit/generated/server/internal") && !id.includes(".svelte-kit/generated/build/server.js")) return;
+			return injectSvelteKitBuildHooks(code, id, envModuleFile);
+		}
+	} : void 0;
 	return [
 		devTriggerSecretGuardPlugin(),
 		createCloudflareBuiltinsExternalPlugin(),
 		wranglerCompatPlugin,
 		wranglerSyncPlugin,
 		...nuxtVite8WebSocketCompatPlugin ? [nuxtVite8WebSocketCompatPlugin] : [],
+		...astroRequestScopePlugin ? [astroRequestScopePlugin] : [],
 		svelteKitHooksInjectPlugin,
+		...svelteKitWorkerBuildPlugin ? [svelteKitWorkerBuildPlugin] : [],
 		clientStubsPlugin,
 		serverRuntimeOptimizerPlugin,
 		bindingRuntimePlugin(bindingNames),
@@ -3491,14 +3707,15 @@ function createFrameworkPlugins(input) {
 			d1BindingName: bindingNames?.d1,
 			forceVirtualDb: bindingNames?.d1 !== void 0,
 			localD1DatabaseId: localD1.databaseId,
-			localD1PersistRoot: frameworkPersistRoot
+			localD1PersistRoot: frameworkPersistRoot,
+			nitroBundlesServer: detected.name === "nuxt" || detected.name === "analog"
 		}),
 		migrationPlugin(root, dialect, localD1.databaseId, frameworkPersistRoot, { enabled: false }),
 		devTriggersHintPlugin(root, devTriggerToken),
 		frameworkTriggersPlugin(root, { devTriggerToken }),
 		...detected.name === "nuxt" ? [nitroDevTriggerInjectPlugin(root, { serverDir: "server" })] : [],
 		...detected.name === "analog" ? [analogDevTriggerInjectPlugin(root)] : [],
-		...detected.name === "astro" ? [astroDevTriggerInjectPlugin(root)] : [],
+		...detected.name === "astro" ? [createBareVoidRedirectPlugin(), astroDevTriggerInjectPlugin(root)] : [],
 		implicitDeployGuard
 	];
 }
@@ -3571,13 +3788,17 @@ function honoMiddleware(getApp) {
 *    single SSR build for API-only apps
 */
 function nodeTargetPlugin(target) {
+	const unavailable = (id, root, importer) => {
+		const source = importer ? ` Imported by ${relative(root, importer)}.` : "";
+		return /* @__PURE__ */ new Error(`target: '${id}' is not available with target '${target}'. CF bindings require target: "cloudflare".${source}`);
+	};
 	return [{
 		name: "void:node-target",
 		enforce: "pre",
 		resolveId: {
 			filter: { id: CF_ONLY_REGEX },
-			handler(id) {
-				throw new Error(`target: '${id}' is not available with target '${target}'. CF bindings require target: "cloudflare".`);
+			handler(id, importer) {
+				throw unavailable(id, this.environment.config.root, importer);
 			}
 		},
 		renderChunk(code, chunk) {
@@ -3589,8 +3810,13 @@ function nodeTargetPlugin(target) {
 			};
 		},
 		config(_, { command }) {
-			if (command !== "build") return;
 			const root = process.cwd();
+			const ssr = { noExternal: [
+				"void",
+				/^@void\//,
+				...findVoidDependentPackages(root)
+			] };
+			if (command !== "build") return { ssr };
 			const voidDir = join(root, ".void");
 			const ssrBuildOptions = {
 				outDir: "dist/ssr",
@@ -3607,18 +3833,22 @@ function nodeTargetPlugin(target) {
 				}
 			};
 			if (existsSync(readProjectPaths(root).pagesDir)) return {
+				ssr,
 				build: { outDir: "dist/client" },
 				environments: { ssr: { build: ssrBuildOptions } },
 				builder: {}
 			};
-			return { build: {
-				ssr: true,
-				...ssrBuildOptions
-			} };
+			return {
+				ssr,
+				build: {
+					ssr: true,
+					...ssrBuildOptions
+				}
+			};
 		},
 		async buildApp(builder) {
 			await builder.build(builder.environments.ssr);
-			await builder.build(builder.environments.client);
+			if (builder.environments.client) await builder.build(builder.environments.client);
 		},
 		configureServer(server) {
 			server.middlewares.use(honoMiddleware(async () => {
@@ -3636,6 +3866,20 @@ function nodeTargetPlugin(target) {
 				return appPromise;
 			}));
 		}
+	}, {
+		name: "void:node-target-cloudflare-modules",
+		apply: "build",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: /^cloudflare:/ },
+			handler(id, importer, options) {
+				if (options.kind === "dynamic-import") return {
+					id,
+					external: true
+				};
+				throw unavailable(id, this.environment.config.root, importer);
+			}
+		}
 	}];
 }
 //#endregion
@@ -4212,8 +4456,8 @@ function routingPlugin(root, options) {
 			if (!options.target) {
 				const migrationsDir = paths.migrationsDir;
 				if (existsSync(migrationsDir) || compileOptions.auth) {
-					const { collectMigrations } = await import("./collect-NUlJMpLY.mjs");
-					const { buildMigrationPlanBundle } = await import("./plan-CH2G51je.mjs");
+					const { collectMigrations } = await import("./collect-Cae8A7Zr.mjs");
+					const { buildMigrationPlanBundle } = await import("./plan-CKX_jWnD.mjs");
 					const migrations = existsSync(migrationsDir) ? collectMigrations(migrationsDir) : [];
 					const dialect = getDatabaseDialect(readConfig(root));
 					compileOptions.migrationHandlerPath = resolveFile(dialect === "postgresql" ? "#self/runtime/migration-handler-pg" : dialect === "mysql" ? "#self/runtime/migration-handler-mysql" : "#self/runtime/migration-handler");
@@ -4631,25 +4875,28 @@ const scheduledPreviewPointerCleanups = /* @__PURE__ */ new Set();
 function voidPlugin(options) {
 	const root = process.cwd();
 	const directCloudflareDestination = readDeploymentPlatform(root) === "cloudflare";
+	if (directCloudflareDestination) selectVoidCloudflareLogin();
 	warnIfPackageJsonIsNotEsm(root);
 	const devTriggerToken = isViteBuildOrPreview() ? crypto.randomUUID() : getOrCreateDevTriggerToken(root);
 	const config = readConfig(root);
 	const projectCloudflareConfigPath = !isNodeTarget(config.target) ? materializeCloudflareConfig(root) : void 0;
 	const cloudflareConfigPath = projectCloudflareConfigPath && existsSync(projectCloudflareConfigPath) ? projectCloudflareConfigPath : void 0;
 	let previewing = false;
+	const restorePreviewPointer = () => {
+		if (!existsSync(join(root, "void.config.ts"))) return;
+		if (restoreCloudflarePreviewPointer(root) && !scheduledPreviewPointerCleanups.has(root)) {
+			scheduledPreviewPointerCleanups.add(root);
+			process.once("exit", () => {
+				rmSync(join(root, ".wrangler", "deploy", "config.json"), { force: true });
+			});
+		}
+	};
 	const implicitDeployGuard = {
 		name: "void:remove-implicit-cloudflare-deploy-pointer",
 		enforce: "pre",
 		config(_config, environment) {
 			previewing = environment.isPreview === true;
-			if (previewing && existsSync(join(root, "void.config.ts"))) {
-				if (restoreCloudflarePreviewPointer(root) && !scheduledPreviewPointerCleanups.has(root)) {
-					scheduledPreviewPointerCleanups.add(root);
-					process.once("exit", () => {
-						rmSync(join(root, ".wrangler", "deploy", "config.json"), { force: true });
-					});
-				}
-			}
+			if (previewing) restorePreviewPointer();
 		},
 		closeBundle() {
 			if (!previewing && existsSync(join(root, "void.config.ts")) && process.env["VOID_CLOUDFLARE_DEPLOY_BUILD"] !== "1") {
@@ -4682,6 +4929,7 @@ function voidPlugin(options) {
 	assertNoRootSourceConventionConflicts(paths);
 	const detected = application.framework;
 	const framework = detected?.class === "a" ? detected.name : void 0;
+	if (detected?.name === "astro" && process.argv[2] === "preview") restorePreviewPointer();
 	const scanDirs = config.inference?.scanDirs ?? (detected ? FRAMEWORK_SCAN_DIRS : void 0);
 	const frameworkOwnsCloudflareRuntime = detected !== void 0 && (detected.class === "b" || detected.class === "c");
 	const localD1PersistRoot = frameworkOwnsCloudflareRuntime ? join(root, ".wrangler", "state") : options?.persistTo ?? join(root, ".void");
@@ -4699,7 +4947,7 @@ function voidPlugin(options) {
 	const hasInboundEmail = hasEmailHandlers(application.email);
 	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 clientStubsPlugin = createClientStubsPlugin();
-	const serverRuntimeOptimizerPlugin = createServerRuntimeOptimizerPlugin(!isNodeTarget(config.target) && !frameworkOwnsCloudflareRuntime);
+	const serverRuntimeOptimizerPlugin = createServerRuntimeOptimizerPlugin(dialect, () => readWranglerCompat(root, config));
 	const queues = framework ? [] : application.queues;
 	const websocketRoutes = framework ? [] : application.allWebsockets;
 	const durableObjects = application.durableObjects;
@@ -4800,7 +5048,6 @@ function voidPlugin(options) {
 			application = getApplicationAnalysis(routeEnvironment);
 			bindings = application.bindings;
 			authEnabled = application.authEnabled;
-			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");
@@ -4916,7 +5163,7 @@ function voidPlugin(options) {
 		}
 	};
 	if (framework) {
-		workerConfig.main = getFrameworkEntry(framework, root, devTriggerToken, config.routing?.notFound);
+		workerConfig.main = getFrameworkEntry(framework, root, devTriggerToken, dialect, config.routing?.notFound);
 		let notFoundIgnoredWarned = false;
 		const frameworkBuildWrapperPlugin = {
 			name: "void:framework-build-wrapper",
@@ -4926,7 +5173,7 @@ function voidPlugin(options) {
 					notFoundIgnoredWarned = true;
 					voidWarn(`Void generates no asset routing policy for a ${framework} build, so "routing.notFound" in void.config.ts 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);
+				generateClassATriggerWrapper(root, framework, getOriginalFrameworkEntry(framework, root), true, dialect, resolved.build.assetsDir, config.routing?.notFound);
 			}
 		};
 		const existingFlags = workerConfig.compatibility_flags ?? [];
@@ -4961,6 +5208,7 @@ function voidPlugin(options) {
 		} : void 0;
 		return [
 			createCloudflareBuiltinsExternalPlugin(),
+			createBareVoidRedirectPlugin(),
 			createWorkerEnvironmentSanitizerPlugin([viteEnvironment.name, ...viteEnvironment.childEnvironments ?? []]),
 			createWranglerCompatPersistPlugin(root, config),
 			devTriggerSecretGuardPlugin(),