void 0.1.6 → 0.7.0

package/dist/deploy-BPKblFx6.mjs

@@ -0,0 +1,2424 @@
+import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
+import { a as join, i as isAbsolute, n as dirname, o as relative, r as extname, s as resolve } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as cliTitle, r as createSpinner, s as import_picocolors } from "./output-BwlcIYSR.mjs";
+import { t as findVoidAuthConfig } from "./config-CvHtTM0q.mjs";
+import { c as R, g as ge, u as Se, v as ue, x as q, y as ye } from "./dist-Dayj3gCK.mjs";
+import { a as writeProjectConfig, r as readProjectConfig } from "./project-TqORyHn8.mjs";
+import { a as parsePlatformErrorBody, c as getTokenSource, i as isExpiredTokenError, l as isStagingMode, n as PlatformClient, s as getToken, t as PlatformApiError } from "./client-snXOjrp1.mjs";
+import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-BIa9HwVX.mjs";
+import { i as scanJobsSync, n as scanWebSocketRoutesSync, r as scanQueuesSync, t as scanRoutes } from "./scan-C6HMEIdW.mjs";
+import { c as validateSsrEntry, n as detectFramework, r as inferProjectBindings, t as FRAMEWORK_SCAN_DIRS } from "./plugin-inference-oZ6Ybu2_.mjs";
+import { i as voidWarn, r as voidLog } from "./log-DXdqnmhF.mjs";
+import { t as discoverSchema } from "./discover-B7FkXBLB.mjs";
+import { t as findEnvFile } from "./env-types-DknSA4SO.mjs";
+import { i as validateProdEnv, n as formatEnvReport, r as getDeployEnvDefaults, t as fetchRemoteSecretNames } from "./env-validation-DJKjR_8q.mjs";
+import { n as writeDrizzleConfig } from "./config-BzM9Dy7T.mjs";
+import { t as collectMigrations } from "./collect-CjeZgz5D.mjs";
+import { r as validateMigrations, t as assertJournalCoherence } from "./validate-CaMavMxu.mjs";
+import { t as scanPages } from "./scan-Ba4hFwlH.mjs";
+import { n as promptProjectSelection, r as promptProjectSetupAction, t as promptAndCreateProject } from "./create-project-BIA15W7z.mjs";
+import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-Br5BR03U.mjs";
+import { n as lintDuplicateSources, r as mergeRoutingRules, t as lintDestinationSplats } from "./headers-DCXc7mDs.mjs";
+import { t as promptForLoginToken } from "./login-CkcXUiIu.mjs";
+import { i as resolveProjectCommand, n as detectPreset, r as formatProjectCommand, t as FRAMEWORK_PRESETS } from "./preset-D4I73kT4.mjs";
+import { createRequire } from "node:module";
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { build, loadEnv } from "vite";
+import { tmpdir } from "node:os";
+import { parse } from "jsonc-parser";
+import { execFile, execFileSync, execSync } from "node:child_process";
+import { hash } from "blake3-jit";
+import ignore from "ignore";
+const SANDBOX_MIGRATION_TAG = "void-sandbox-v1";
+const require = createRequire(import.meta.url);
+function isSandboxEnabled(config) {
+	return config.sandbox !== void 0 && config.sandbox !== false;
+}
+function getDefaultSandboxImage() {
+	return join(getSandboxPackageRoot(), "Dockerfile");
+}
+function getDefaultSandboxPlatformImage() {
+	return `docker.io/cloudflare/sandbox:${JSON.parse(readFileSync(join(getSandboxPackageRoot(), "package.json"), "utf-8")).version ?? "latest"}`;
+}
+function isLocalSandboxImage(image) {
+	const lowerImage = image.toLowerCase();
+	return isAbsolute(image) || image.startsWith("./") || image.startsWith("../") || lowerImage === "dockerfile" || lowerImage.includes("dockerfile") || lowerImage.endsWith("/dockerfile") || lowerImage.endsWith("\\dockerfile");
+}
+function requiresSandboxPlatformImage(config) {
+	if (typeof config.sandbox !== "object" || config.sandbox === null) return false;
+	return typeof config.sandbox.image === "string" && isLocalSandboxImage(config.sandbox.image) && config.sandbox.platformImage === void 0;
+}
+function resolveSandboxConfig(config, root = process.cwd()) {
+	const raw = typeof config.sandbox === "object" ? config.sandbox : {};
+	const image = raw.image ?? getDefaultSandboxImage();
+	const imageBuildContext = raw.imageBuildContext;
+	const platformImage = raw.platformImage ?? (raw.image && !isLocalSandboxImage(raw.image) ? raw.image : getDefaultSandboxPlatformImage());
+	return {
+		binding: raw.binding ?? "SANDBOX",
+		className: raw.className ?? "Sandbox",
+		containerName: raw.containerName ?? "void-sandbox",
+		image: resolveSandboxImage(image, root),
+		platformImage,
+		...imageBuildContext && { imageBuildContext: isAbsolute(imageBuildContext) ? imageBuildContext : join(root, imageBuildContext) },
+		...raw.instanceType && { instanceType: raw.instanceType },
+		...raw.maxInstances != null && { maxInstances: raw.maxInstances }
+	};
+}
+function getSandboxPackageRoot() {
+	return join(dirname(require.resolve("@cloudflare/sandbox")), "..");
+}
+function resolveSandboxImage(image, root) {
+	if (!isLocalSandboxImage(image) || isAbsolute(image)) return image;
+	return join(root, image);
+}
+//#endregion
+//#region src/cli/wrangler.ts
+const COMPAT_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const NODEJS_ALS_FLAG = "nodejs_als";
+const VOID_CONFIG_FILE = "void.json";
+/** Latest compatibility date the Void test suite is pinned against. */
+const LATEST_KNOWN_COMPAT_DATE = "2026-02-24";
+/**
+* Read compatibility settings from `wrangler.jsonc`/`wrangler.json` and
+* `void.json`, with priority: void.json > wrangler.jsonc > build output.
+*
+* If no explicit `compatibility_date` is configured, pins the latest known-good
+* date in `void.json` so subsequent runs are explicit and stable.
+*
+* @param buildOutputDir - Optional path to the build output directory (e.g.
+*   `dist/ssr`) which may contain a plugin-generated `wrangler.json` with the
+*   correct compat settings for the built worker.
+*/
+function readWranglerCompat(root, config, buildOutputDir) {
+	const voidConfig = config ?? readVoidConfigIfExists(root);
+	let raw;
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) try {
+		raw = readFileSync(join(root, name), "utf-8");
+		break;
+	} catch {}
+	let wranglerDate;
+	let wranglerFlags;
+	if (raw) {
+		const parsed = parseJsonc(raw);
+		if (typeof parsed.compatibility_date === "string") {
+			validateCompatDate(parsed.compatibility_date, "wrangler config");
+			wranglerDate = parsed.compatibility_date;
+		}
+		if (Array.isArray(parsed.compatibility_flags) && parsed.compatibility_flags.every((f) => typeof f === "string")) wranglerFlags = parsed.compatibility_flags;
+	}
+	let buildDate;
+	let buildFlags;
+	if (buildOutputDir) try {
+		const buildRaw = readFileSync(join(buildOutputDir, "wrangler.json"), "utf-8");
+		const buildParsed = JSON.parse(buildRaw);
+		if (typeof buildParsed.compatibility_date === "string") {
+			validateCompatDate(buildParsed.compatibility_date, "build output wrangler.json");
+			buildDate = buildParsed.compatibility_date;
+		}
+		if (Array.isArray(buildParsed.compatibility_flags) && buildParsed.compatibility_flags.every((f) => typeof f === "string")) buildFlags = buildParsed.compatibility_flags;
+	} catch {}
+	const voidDate = voidConfig?.worker?.compatibility_date;
+	const voidFlags = voidConfig?.worker?.compatibility_flags;
+	if (voidDate !== void 0) validateCompatDate(voidDate, "void.json worker config");
+	const result = { compatibilityDate: voidDate ?? wranglerDate ?? buildDate ?? ensureVoidCompatibilityDate(root, voidConfig) };
+	const flags = voidFlags ?? wranglerFlags ?? buildFlags;
+	if (flags && flags.length > 0) result.compatibilityFlags = flags;
+	return result;
+}
+function validateCompatDate(value, source) {
+	if (!COMPAT_DATE_RE.test(value)) throw new Error(`config: "compatibility_date" in ${source} must use YYYY-MM-DD format, got '${value}'.`);
+}
+function readVoidConfigIfExists(root) {
+	const filePath = join(root, VOID_CONFIG_FILE);
+	if (!existsSync(filePath)) return;
+	try {
+		const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`config: ${VOID_CONFIG_FILE} must be a JSON object.`);
+		return parsed;
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new Error(`config: Invalid JSON in ${VOID_CONFIG_FILE}.`);
+		throw error;
+	}
+}
+function ensureVoidCompatibilityDate(root, config) {
+	const filePath = join(root, VOID_CONFIG_FILE);
+	let nextConfig = {};
+	if (existsSync(filePath)) try {
+		const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`config: ${VOID_CONFIG_FILE} must be a JSON object.`);
+		nextConfig = parsed;
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new Error(`config: Invalid JSON in ${VOID_CONFIG_FILE}.`);
+		throw error;
+	}
+	else if (config) nextConfig = { ...config };
+	nextConfig.worker = {
+		...nextConfig.worker ?? {},
+		compatibility_date: LATEST_KNOWN_COMPAT_DATE
+	};
+	writeFileSync(filePath, `${JSON.stringify(nextConfig, null, 2)}\n`);
+	return LATEST_KNOWN_COMPAT_DATE;
+}
+/**
+* Sync inferred/configured bindings into the project's wrangler.jsonc for local dev.
+* Only adds bindings that are missing — existing bindings are preserved.
+* Returns true if the file was modified.
+*/
+function syncWranglerBindings(root, bindings, options) {
+	let configPath;
+	let parsed;
+	let created = false;
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const p = join(root, name);
+		if (existsSync(p)) {
+			configPath = p;
+			try {
+				parsed = parseJsonc(readFileSync(p, "utf-8"));
+			} catch {}
+			break;
+		}
+	}
+	if (!configPath || !parsed) {
+		configPath = join(root, "wrangler.jsonc");
+		parsed = {};
+		created = true;
+	}
+	let modified = false;
+	const d1Name = options?.bindingNames?.d1 ?? "DB";
+	if (bindings.needsD1) {
+		const existing = parsed.d1_databases ?? [];
+		if (!existing.some((b) => b.binding === d1Name)) {
+			parsed.d1_databases = [...existing, {
+				binding: d1Name,
+				database_name: "default",
+				database_id: "local"
+			}];
+			modified = true;
+		}
+	}
+	const kvName = options?.bindingNames?.kv ?? "KV";
+	if (bindings.needsKV) {
+		const existing = parsed.kv_namespaces ?? [];
+		if (!existing.some((b) => b.binding === kvName)) {
+			parsed.kv_namespaces = [...existing, {
+				binding: kvName,
+				id: "local"
+			}];
+			modified = true;
+		}
+	}
+	const r2Name = options?.bindingNames?.r2 ?? "STORAGE";
+	if (bindings.needsR2) {
+		const existing = parsed.r2_buckets ?? [];
+		if (!existing.some((b) => b.binding === r2Name)) {
+			parsed.r2_buckets = [...existing, {
+				binding: r2Name,
+				bucket_name: "default"
+			}];
+			modified = true;
+		}
+	}
+	if (options?.websockets && options.websockets.length > 0) {
+		const existing = parsed.durable_objects?.bindings ?? [];
+		const additions = options.websockets.filter((route) => !existing.some((binding) => binding.name === route.bindingName)).map((route) => ({
+			name: route.bindingName,
+			class_name: route.className
+		}));
+		if (additions.length > 0) {
+			parsed.durable_objects = { bindings: [...existing, ...additions] };
+			modified = true;
+		}
+		if (!Array.isArray(parsed.migrations)) {
+			parsed.migrations = [{
+				tag: "void-ws-v1",
+				new_classes: options.websockets.map((route) => route.className)
+			}];
+			modified = true;
+		}
+	}
+	if (bindings.needsSandbox) {
+		const sandbox = options?.sandbox ?? resolveSandboxConfig({ sandbox: true }, root);
+		const bindingName = options?.bindingNames?.sandbox ?? sandbox?.binding ?? "SANDBOX";
+		const className = sandbox?.className ?? "Sandbox";
+		const existingDurableObjectBindings = parsed.durable_objects?.bindings ?? [];
+		if (!existingDurableObjectBindings.some((binding) => binding.name === bindingName)) {
+			parsed.durable_objects = { bindings: [...existingDurableObjectBindings, {
+				name: bindingName,
+				class_name: className
+			}] };
+			modified = true;
+		}
+		const existingContainers = parsed.containers ?? [];
+		if (!existingContainers.some((container) => container.class_name === className)) {
+			parsed.containers = [...existingContainers, {
+				name: sandbox?.containerName ?? "void-sandbox",
+				class_name: className,
+				image: sandbox?.image,
+				...sandbox?.imageBuildContext && { image_build_context: sandbox.imageBuildContext },
+				...sandbox?.instanceType && { instance_type: sandbox.instanceType },
+				...sandbox?.maxInstances != null && { max_instances: sandbox.maxInstances }
+			}];
+			modified = true;
+		}
+		const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
+		if (!migrations.some((migration) => migration.tag === "void-sandbox-v1" || migration.new_sqlite_classes?.includes(className))) {
+			parsed.migrations = [...migrations, {
+				tag: SANDBOX_MIGRATION_TAG,
+				new_sqlite_classes: [className]
+			}];
+			modified = true;
+		}
+	}
+	if (created || modified) writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+	return created || modified;
+}
+/**
+* Ensure a wrangler config has an explicit compatibility date.
+* Used when `worker.compatibility_date` is configured in void.json but the
+* active framework reads Cloudflare settings from wrangler.jsonc/json.
+*/
+function ensureWranglerCompatibilityDate(root, compatibilityDate) {
+	validateCompatDate(compatibilityDate, "void.json worker config");
+	let configPath;
+	let parsed;
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const p = join(root, name);
+		if (existsSync(p)) {
+			configPath = p;
+			try {
+				parsed = parseJsonc(readFileSync(p, "utf-8"));
+			} catch {}
+			break;
+		}
+	}
+	if (!configPath || !parsed) {
+		configPath = join(root, "wrangler.jsonc");
+		parsed = {};
+	}
+	if (parsed.compatibility_date === compatibilityDate) return false;
+	parsed.compatibility_date = compatibilityDate;
+	writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+	return true;
+}
+/**
+* Ensure the `nodejs_als` compatibility flag exists in wrangler config.
+* Returns true if the config file was modified.
+*/
+function ensureWranglerNodejsAlsFlag(root) {
+	let configPath;
+	let parsed;
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const p = join(root, name);
+		if (existsSync(p)) {
+			configPath = p;
+			try {
+				parsed = parseJsonc(readFileSync(p, "utf-8"));
+			} catch {}
+			break;
+		}
+	}
+	if (!configPath || !parsed) {
+		configPath = join(root, "wrangler.jsonc");
+		parsed = {};
+	}
+	const compatibilityFlags = Array.isArray(parsed.compatibility_flags) ? parsed.compatibility_flags : [];
+	if (compatibilityFlags.includes(NODEJS_ALS_FLAG)) return false;
+	parsed.compatibility_flags = [...compatibilityFlags, NODEJS_ALS_FLAG];
+	writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+	return true;
+}
+function parseJsonc(text) {
+	const errors = [];
+	const result = parse(text, errors, { allowTrailingComma: true });
+	if (errors.length > 0) throw new SyntaxError("Failed to parse JSONC");
+	return result;
+}
+//#endregion
+//#region src/shared/env.ts
+/**
+* Strip shell environment pollution from a Vite `loadEnv(mode, root, '')`
+* result. Vite returns `.env`-file entries AND every `process.env` entry
+* when called with an empty prefix; we want only the keys that came from
+* `.env` files (either new keys or keys that override a shell value).
+*
+* Used anywhere we need to populate worker vars from `.env` without
+* shipping the developer's shell environment (PATH, HOME, etc.) into
+* `wrangler.json` or the prerender Miniflare instance.
+*/
+function filterLoadedEnv(loaded) {
+	const shellKeys = new Set(Object.keys(process.env));
+	const env = {};
+	for (const [key, value] of Object.entries(loaded)) if (!shellKeys.has(key) || process.env[key] !== value) env[key] = value;
+	return env;
+}
+/**
+* Resolve whether the plugin should run in "remote" mode (proxy real
+* D1/KV/R2 via the platform) based on the project config plus an optional
+* `VOID_REMOTE` env override.
+*
+* Tri-state override semantics:
+*   - `VOID_REMOTE=1` → force remote mode on
+*   - `VOID_REMOTE=0` → force remote mode off (e.g. local/CI builds of a
+*     project whose `void.json` has `remote: true`)
+*   - unset / any other value → fall back to `config.remote`
+*
+* Both the dev-server plugin (index.ts) and the prerender build plugin
+* (plugin-prerender.ts) must derive `remoteMode` through this helper so
+* dev and build stay in lockstep.
+*/
+function resolveRemoteMode(configRemote) {
+	const override = process.env.VOID_REMOTE;
+	if (override === "1") return true;
+	if (override === "0") return false;
+	return configRemote === true;
+}
+const INTERNAL_ENV_KEY_SET = new Set([
+	"__VOID_TOKEN",
+	"__VOID_PROJECT_ID",
+	"__VOID_REMOTE",
+	"__VOID_STAGING",
+	"__VOID_PROXY_URL",
+	"__VOID_PROXY_TOKEN"
+]);
+/**
+* Remove any internal Void env keys from a user-supplied env record. Returns
+* the sanitized record plus the list of keys that were stripped so callers
+* (which live in non-leaf modules) can emit a warning via `voidWarn`.
+*
+* This module is a leaf — it must not import from `../log` or any non-leaf
+* module, otherwise the prerender subprocess's worker bundle acquires
+* unwanted transitive dependencies. That's why warnings are the caller's
+* responsibility.
+*/
+function stripInternalEnvKeys(input) {
+	if (!input) return {
+		sanitized: {},
+		stripped: []
+	};
+	const sanitized = {};
+	const stripped = [];
+	for (const [key, value] of Object.entries(input)) {
+		if (INTERNAL_ENV_KEY_SET.has(key)) {
+			stripped.push(key);
+			continue;
+		}
+		sanitized[key] = value;
+	}
+	return {
+		sanitized,
+		stripped
+	};
+}
+//#endregion
+//#region src/shared/proxy.ts
+const DEFAULT_PROXY_URL = "https://proxy.void.cloud";
+const STAGING_PROXY_URL = "https://proxy.staging.void.cloud";
+//#endregion
+//#region src/prerender.ts
+const PRERENDER_PATHS_ENDPOINT = "/__void/prerender-paths";
+const STATIC_PAGE_DATA_DIR = "_void/pages";
+function outputFileForPath(path) {
+	return path === "/" ? "index.html" : `${path.slice(1)}.html`;
+}
+function pageDataFileForPath(path) {
+	return path === "/" ? `${STATIC_PAGE_DATA_DIR}/index.json` : `${STATIC_PAGE_DATA_DIR}/${path.slice(1)}.json`;
+}
+async function readPrerenderPathsResponse(response) {
+	if (!response.ok) throw new Error(`prerender: Failed to collect prerender paths. HTTP ${response.status}.`);
+	const payload = await response.json();
+	if (!Array.isArray(payload.paths) || !payload.paths.every((path) => typeof path === "string")) throw new Error("prerender: Failed to collect prerender paths. Response payload is invalid.");
+	return payload.paths;
+}
+async function renderPrerenderPaths(paths, clientDir, fetchPath, fetchPageData) {
+	const result = {
+		rendered: [],
+		failed: []
+	};
+	for (const path of paths) try {
+		const response = await fetchPath(path);
+		const html = await response.text();
+		if (!response.ok) {
+			result.failed.push({
+				path,
+				error: `HTTP ${response.status}`
+			});
+			voidWarn(`prerender ${path} failed: HTTP ${response.status}`);
+			continue;
+		}
+		const outputFile = outputFileForPath(path);
+		const outputPath = join(clientDir, outputFile);
+		mkdirSync(dirname(outputPath), { recursive: true });
+		writeFileSync(outputPath, html);
+		if (fetchPageData) {
+			const pageDataResponse = await fetchPageData(path);
+			if (pageDataResponse.headers.get("X-VoidPages")) {
+				const pageData = await pageDataResponse.json();
+				const pageDataPath = join(clientDir, pageDataFileForPath(path));
+				mkdirSync(dirname(pageDataPath), { recursive: true });
+				writeFileSync(pageDataPath, JSON.stringify(pageData));
+			}
+		}
+		result.rendered.push(path);
+		voidLog(`prerender \x1b[36m${outputFile}\x1b[39m`);
+	} catch (err) {
+		const error = err instanceof Error ? err.message : String(err);
+		result.failed.push({
+			path,
+			error
+		});
+		voidWarn(`prerender ${path} failed: ${error}`);
+	}
+	return result;
+}
+function normalizeWorkerModulePath(path) {
+	return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function resolveWorkerModuleType(relativePath) {
+	const normalized = normalizeWorkerModulePath(relativePath);
+	if (normalized.includes("/.vite/") || normalized.startsWith(".vite/")) return null;
+	if (normalized === "wrangler.json" || normalized === "wrangler.jsonc") return null;
+	if (normalized.endsWith(".mjs") || normalized.endsWith(".js")) return "ESModule";
+	if (normalized.endsWith(".cjs")) return "CommonJS";
+	if (normalized.endsWith(".wasm")) return "CompiledWasm";
+	if (normalized.endsWith(".txt")) return "Text";
+	if (normalized.endsWith(".bin")) return "Data";
+	return null;
+}
+function collectFiles$1(dir) {
+	const files = [];
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...collectFiles$1(fullPath));
+		else files.push(fullPath);
+	}
+	return files;
+}
+function collectPrerenderWorkerModules(workerDir, workerMain) {
+	const normalizedEntry = normalizeWorkerModulePath(workerMain);
+	const modules = collectFiles$1(workerDir).flatMap((filePath) => {
+		const relativePath = normalizeWorkerModulePath(relative(workerDir, filePath));
+		const type = resolveWorkerModuleType(relativePath);
+		if (!type) return [];
+		const file = readFileSync(filePath);
+		return [{
+			path: filePath,
+			relativePath,
+			type,
+			contents: type === "CompiledWasm" || type === "Data" ? new Uint8Array(file) : file.toString("utf-8")
+		}];
+	});
+	modules.sort((a, b) => {
+		if (a.relativePath === normalizedEntry) return -1;
+		if (b.relativePath === normalizedEntry) return 1;
+		return a.relativePath.localeCompare(b.relativePath);
+	});
+	if (!modules.some((module) => module.relativePath === normalizedEntry)) throw new Error(`prerender: Worker entry '${normalizedEntry}' not found in '${workerDir}'.`);
+	return modules.map(({ relativePath: _relativePath, ...module }) => module);
+}
+function buildPrerenderBindings(input) {
+	const { sanitized: wranglerVars, stripped: wranglerStripped } = stripInternalEnvKeys(input.wranglerVars);
+	const { sanitized: env, stripped: envStripped } = stripInternalEnvKeys(input.env);
+	const allStripped = [...new Set([...wranglerStripped, ...envStripped])];
+	if (allStripped.length > 0) voidWarn(`Ignoring internal env keys in prerender inputs: ${allStripped.join(", ")}. These are reserved for Void runtime use.`);
+	const voidBindings = {};
+	if (input.voidToken && input.voidProjectId) {
+		voidBindings.__VOID_TOKEN = input.voidToken;
+		voidBindings.__VOID_PROJECT_ID = input.voidProjectId;
+		if (input.voidStaging) voidBindings.__VOID_STAGING = "1";
+		voidBindings.__VOID_PROXY_URL = input.voidStaging ? STAGING_PROXY_URL : DEFAULT_PROXY_URL;
+		if (input.remoteMode) voidBindings.__VOID_REMOTE = "1";
+	}
+	return {
+		...wranglerVars,
+		...env,
+		...voidBindings
+	};
+}
+async function createCloudflarePrerenderRunner(options) {
+	const { root, workerDir, persistDir, clientDir, remoteMode } = options;
+	const wranglerPath = join(workerDir, "wrangler.json");
+	if (!existsSync(wranglerPath)) throw new Error(`prerender: wrangler.json not found in '${workerDir}'.`);
+	const wranglerConfig = JSON.parse(readFileSync(wranglerPath, "utf-8"));
+	const wranglerCompat = readWranglerCompat(root, readConfig(root), workerDir);
+	const workerMain = wranglerConfig.main ?? "index.js";
+	const env = filterLoadedEnv(loadEnv("production", root, ""));
+	const voidToken = getToken(root);
+	let voidProjectId = options.projectId;
+	if (!voidProjectId) voidProjectId = process.env.VOID_DEPLOY_PROJECT_ID || void 0;
+	if (!voidProjectId) {
+		const projectJsonPath = join(root, ".void", "project.json");
+		try {
+			voidProjectId = JSON.parse(readFileSync(projectJsonPath, "utf-8")).projectId;
+		} catch {}
+	}
+	const voidStaging = isStagingMode(root);
+	const bindings = buildPrerenderBindings({
+		wranglerVars: wranglerConfig.vars,
+		env,
+		voidToken,
+		voidProjectId,
+		voidStaging,
+		remoteMode
+	});
+	const { Miniflare } = await import(pathToFileURL(createRequire(import.meta.resolve("wrangler/package.json")).resolve("miniflare")).href);
+	const mfOptions = {
+		modules: collectPrerenderWorkerModules(workerDir, workerMain),
+		modulesRoot: workerDir,
+		compatibilityDate: wranglerCompat.compatibilityDate,
+		compatibilityFlags: wranglerCompat.compatibilityFlags ?? [],
+		bindings
+	};
+	if (clientDir) mfOptions.serviceBindings = { [wranglerConfig.assets?.binding ?? "ASSETS"](request) {
+		const filePath = join(clientDir, new URL(request.url).pathname);
+		try {
+			const content = readFileSync(filePath);
+			return new Response(content);
+		} catch {
+			return new Response("Not Found", { status: 404 });
+		}
+	} };
+	const d1 = wranglerConfig.d1_databases;
+	if (Array.isArray(d1) && d1.length > 0) {
+		const databases = {};
+		for (const db of d1) databases[db.binding] = db.database_id;
+		mfOptions.d1Databases = databases;
+		mfOptions.d1Persist = persistDir;
+	}
+	const kv = wranglerConfig.kv_namespaces;
+	if (Array.isArray(kv) && kv.length > 0) {
+		const namespaces = {};
+		for (const ns of kv) namespaces[ns.binding] = ns.id;
+		mfOptions.kvNamespaces = namespaces;
+		mfOptions.kvPersist = persistDir;
+	}
+	const r2 = wranglerConfig.r2_buckets;
+	if (Array.isArray(r2) && r2.length > 0) {
+		const buckets = {};
+		for (const bucket of r2) buckets[bucket.binding] = bucket.bucket_name;
+		mfOptions.r2Buckets = buckets;
+		mfOptions.r2Persist = persistDir;
+	}
+	const mf = new Miniflare(mfOptions);
+	const proxyToken = mfOptions.bindings?.__VOID_PROXY_TOKEN;
+	return {
+		async collectPaths() {
+			const headers = {};
+			if (proxyToken) headers["x-void-internal"] = proxyToken;
+			return readPrerenderPathsResponse(await mf.dispatchFetch(`http://localhost${PRERENDER_PATHS_ENDPOINT}`, {
+				method: "POST",
+				headers
+			}));
+		},
+		async fetchPath(path) {
+			return mf.dispatchFetch(`http://localhost${path}`);
+		},
+		async fetchPageData(path) {
+			return mf.dispatchFetch(`http://localhost${path}`, { headers: {
+				Accept: "application/json",
+				Purpose: "prefetch",
+				"X-VoidPages": "true"
+			} });
+		},
+		async close() {
+			await mf.dispose();
+		}
+	};
+}
+async function collectPrerenderPaths(options) {
+	const runner = await createCloudflarePrerenderRunner(options);
+	try {
+		return await runner.collectPaths();
+	} finally {
+		await runner.close();
+	}
+}
+/**
+* Prerender pages by spinning up Miniflare with the built worker.
+* Collects paths through the built worker's internal endpoint and then
+* fetches each page, writing HTML responses to `clientDir`.
+*/
+async function prerenderPages(options) {
+	const runner = await createCloudflarePrerenderRunner(options);
+	try {
+		const paths = await runner.collectPaths();
+		if (paths.length === 0) return {
+			paths,
+			rendered: [],
+			failed: []
+		};
+		return {
+			paths,
+			...await renderPrerenderPaths(paths, options.clientDir, (path) => runner.fetchPath(path), (path) => runner.fetchPageData(path))
+		};
+	} finally {
+		await runner.close();
+	}
+}
+async function runNodePrerenderRunner(root, config) {
+	const { sanitized: env, stripped } = stripInternalEnvKeys(filterLoadedEnv(loadEnv("production", root, "")));
+	if (stripped.length > 0) voidWarn(`Ignoring internal env keys from .env files in Node prerender runner: ${stripped.join(", ")}. These are reserved for Void runtime use.`);
+	const runnerPath = join(root, ".void", "prerender-runner.mjs");
+	mkdirSync(dirname(runnerPath), { recursive: true });
+	writeFileSync(runnerPath, `
+import { pathToFileURL } from "node:url";
+import { join, dirname } from "pathe";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+
+const config = JSON.parse(process.argv[2]);
+const { mode, ssrDir, clientDir } = config;
+
+if (clientDir) {
+  try {
+    const manifestPath = join(clientDir, ".vite", "manifest.json");
+    globalThis.__VITE_MANIFEST__ = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    // Ignore missing manifests so prerender can continue without client assets.
+  }
+}
+
+const appUrl = pathToFileURL(join(ssrDir, "app.js")).href;
+const app = await import(appUrl);
+const fetch = app.default?.fetch;
+if (!fetch) {
+  console.error("[void] No default export with fetch() found in app.js");
+  process.exit(1);
+}
+
+async function collectPaths() {
+  const headers = {};
+  if (process.env.__VOID_PROXY_TOKEN) headers["x-void-internal"] = process.env.__VOID_PROXY_TOKEN;
+  const response = await fetch(
+    new Request("http://localhost${PRERENDER_PATHS_ENDPOINT}", { method: "POST", headers }),
+  );
+  if (!response.ok) {
+    throw new Error("prerender: Failed to collect prerender paths. HTTP " + response.status + ".");
+  }
+  const payload = await response.json();
+  if (!payload || !Array.isArray(payload.paths) || !payload.paths.every((path) => typeof path === "string")) {
+    throw new Error("prerender: Failed to collect prerender paths. Response payload is invalid.");
+  }
+  return payload.paths;
+}
+
+async function renderPaths(paths) {
+  if (!clientDir) return { rendered: [], failed: [] };
+  const result = { rendered: [], failed: [] };
+
+  for (const path of paths) {
+    try {
+      const response = await fetch(new Request("http://localhost" + path));
+      const html = await response.text();
+      if (!response.ok) {
+        result.failed.push({ path, error: "HTTP " + response.status });
+        continue;
+      }
+      const outputFile = path === "/" ? "index.html" : path.slice(1) + ".html";
+      const outputPath = join(clientDir, outputFile);
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, html);
+      const pageDataResponse = await fetch(new Request("http://localhost" + path, {
+        headers: { "Accept": "application/json", "Purpose": "prefetch", "X-VoidPages": "true" },
+      }));
+      if (pageDataResponse.headers.get("X-VoidPages")) {
+        const pageData = await pageDataResponse.json();
+        const pageDataFile = path === "/" ? "_void/pages/index.json" : "_void/pages/" + path.slice(1) + ".json";
+        const pageDataPath = join(clientDir, pageDataFile);
+        mkdirSync(dirname(pageDataPath), { recursive: true });
+        writeFileSync(pageDataPath, JSON.stringify(pageData));
+      }
+      result.rendered.push(path);
+    } catch (err) {
+      result.failed.push({ path, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+
+  return result;
+}
+
+if (mode === "collect") {
+  process.stdout.write(JSON.stringify({ paths: await collectPaths() }));
+} else {
+  const paths = await collectPaths();
+  const result = await renderPaths(paths);
+  process.stdout.write(JSON.stringify({ paths, ...result }));
+}
+`);
+	try {
+		return await new Promise((resolve, reject) => {
+			execFile(process.execPath, [runnerPath, JSON.stringify(config)], {
+				env: {
+					...process.env,
+					...env
+				},
+				cwd: root,
+				maxBuffer: 10 * 1024 * 1024
+			}, (error, stdout, stderr) => {
+				if (stderr) process.stderr.write(stderr);
+				if (error) {
+					reject(/* @__PURE__ */ new Error(`Prerender child process failed: ${error.message}`));
+					return;
+				}
+				try {
+					resolve(JSON.parse(stdout));
+				} catch {
+					reject(/* @__PURE__ */ new Error(`Failed to parse prerender output: ${stdout}`));
+				}
+			});
+		});
+	} finally {
+		try {
+			unlinkSync(runnerPath);
+		} catch {}
+	}
+}
+async function collectPrerenderPathsNode(options) {
+	return (await runNodePrerenderRunner(options.root, {
+		mode: "collect",
+		ssrDir: options.ssrDir,
+		clientDir: options.clientDir
+	})).paths;
+}
+/**
+* Prerender pages for Node.js targets by spawning a child process.
+*
+* Uses a child process to avoid mutating `process.env` in the parent Vite
+* build process. The child imports the built app, collects prerender paths
+* from the internal endpoint, renders each page, and returns the result.
+*/
+async function prerenderPagesNode(options) {
+	const result = await runNodePrerenderRunner(options.root, {
+		mode: "collect-and-render",
+		ssrDir: options.ssrDir,
+		clientDir: options.clientDir
+	});
+	for (const path of result.rendered) voidLog(`prerender \x1b[36m${outputFileForPath(path)}\x1b[39m`);
+	for (const { path, error } of result.failed) voidWarn(`prerender ${path} failed: ${error}`);
+	return result;
+}
+//#endregion
+//#region src/cli/deploy-errors.ts
+const BODY_SNIPPET_MAX = 200;
+function trimSnippet(body) {
+	const collapsed = body.replace(/\s+/g, " ").trim();
+	if (collapsed.length <= BODY_SNIPPET_MAX) return collapsed;
+	return `${collapsed.slice(0, BODY_SNIPPET_MAX)}...`;
+}
+function appendDeploymentLine(message, deploymentId) {
+	return deploymentId ? `${message}\nDeployment: ${deploymentId}` : message;
+}
+/**
+* Format a server-emitted `event: 'error'` payload with an optional deployment id.
+*/
+function formatDeployFailureMessage(message, deploymentId) {
+	return appendDeploymentLine(message, deploymentId);
+}
+/**
+* Format the "stream ended cleanly but no terminal event arrived" case.
+*
+* This is the only call site that should emit the bare "Connection lost during
+* deploy" message — the server closed the NDJSON stream without emitting
+* `done` or `error`, so there is no underlying error to carry.
+*/
+function formatConnectionLostMessage(deploymentId) {
+	return appendDeploymentLine("deploy: Connection lost during deploy.", deploymentId);
+}
+/**
+* Convert an exception thrown during the deploy NDJSON stream into a
+* user-facing `Error` with a readable message.
+*
+* Three cases:
+*   1. `PlatformApiError` with 409 + a JSON body carrying `{error, deployment}`
+*      — surface the server-supplied error and prefer the body's deployment id.
+*   2. Any other `PlatformApiError` — surface as `Deploy failed (HTTP <status>): <detail>`
+*      where detail is the parsed `error`/`message` field or a trimmed body snippet.
+*   3. Anything else — preserve the original message under a `Connection lost
+*      during deploy: <original>` prefix so the caller can still tell network,
+*      parse, and transport errors apart.
+*/
+function formatStreamDeployError(err, deploymentId) {
+	if (err instanceof PlatformApiError) {
+		const parsed = parsePlatformErrorBody(err.body);
+		const parsedError = parsed?.error ?? parsed?.message ?? null;
+		const effectiveDeploymentId = parsed?.deployment ?? null ?? deploymentId;
+		if (err.status === 409 && parsedError) return new Error(appendDeploymentLine(`deploy: Deploy failed: ${parsedError}`, effectiveDeploymentId));
+		const detail = parsedError ?? trimSnippet(err.body);
+		const base = detail ? `deploy: Deploy failed (HTTP ${err.status}): ${detail}` : `deploy: Deploy failed (HTTP ${err.status}).`;
+		return new Error(appendDeploymentLine(base, effectiveDeploymentId));
+	}
+	const original = err instanceof Error ? err.message : String(err);
+	return new Error(appendDeploymentLine(`deploy: Connection lost during deploy: '${original}'.`, deploymentId));
+}
+//#endregion
+//#region src/shared/utils.ts
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+function slash(p) {
+	return p.replace(/\\/g, "/");
+}
+function toSlash(p) {
+	return isWindows ? slash(p) : p;
+}
+//#endregion
+//#region src/cli/package.ts
+const textEncoder = new TextEncoder();
+/**
+* Strip dev-only / internal-only fields from each rule before shipping the
+* manifest. The resulting entries contain only `{ source, destination, status }`.
+*
+* - `origin` is used to build the `X-Void-Routing` trace header during local
+*   dev; the deployed platform doesn't consume it.
+* - `force` is used internally by the CLI/router to split rules into the
+*   `redirectRules` (pre-asset, always-fires) and `fallbackRules` (post-asset,
+*   only when the asset resolver 404s) buckets and to label the trace header
+*   on `node`/`bun`/`deno` targets. The platform dispatch worker decides phase
+*   purely from which array the rule lives in, so shipping `force` is dead weight.
+*
+* Keep in sync with `stripOriginForProd` in `router/compile.ts`, which strips
+* only `origin` because the Node/Bun/Deno-target generated code still reads
+* `force` at runtime to label the dev trace header.
+*/
+function stripDevOnlyRuleFields(rules) {
+	if (!rules) return rules;
+	return rules.map(({ origin: _origin, force: _force, ...rest }) => rest);
+}
+/**
+* Layer user-defined `routing.fallbacks` with the SPA app type's implicit
+* `/index.html` fallback. Decision: user fallbacks take precedence; if none
+* matches, the SPA default kicks in.
+*
+* The platform's `not_found_handling: 'single-page-application'` is a global
+* switch — set once per deployment — so we can't have the platform evaluate
+* user fallbacks *before* applying it. Instead, when the user has configured
+* fallbacks on a SPA app, we disable the platform-level SPA setting and
+* append a synthetic catch-all fallback rule (`/*` → `/index.html`) after
+* the user's rules. The dispatch worker evaluates routing rules with
+* first-match-wins semantics, so placing the synthetic rule last means any
+* user rule that matches a more specific pattern fires first; the synthetic
+* rule only catches paths no user rule matched.
+*
+* When the user has no fallbacks configured, the platform-level SPA switch
+* is left intact (zero worker-side overhead for the common case).
+*/
+function resolveSpaFallbackChain(appType, fallbackRules) {
+	const userRules = fallbackRules && fallbackRules.length > 0 ? fallbackRules : void 0;
+	if (appType !== "spa") return {
+		assetConfig: { not_found_handling: appType === "static" ? "404-page" : "none" },
+		fallbackRules: userRules
+	};
+	if (!userRules) return {
+		assetConfig: { not_found_handling: "single-page-application" },
+		fallbackRules: void 0
+	};
+	if (userRules.some((r) => r.host === void 0 && r.source === "/*" && r.destination === "/index.html")) return {
+		assetConfig: { not_found_handling: "none" },
+		fallbackRules: userRules
+	};
+	const syntheticSpaFallback = {
+		source: "/*",
+		destination: "/index.html",
+		status: 200,
+		force: false,
+		origin: "spa-default"
+	};
+	return {
+		assetConfig: { not_found_handling: "none" },
+		fallbackRules: [...userRules, syntheticSpaFallback]
+	};
+}
+const PROGRESS_CHUNK = 50;
+/**
+* Yield to the event loop every PROGRESS_CHUNK iterations so spinner ticks
+* can repaint, and emit a progress message via onProgress. Otherwise the
+* tight sync loop blocks the spinner interval and the user sees no updates.
+*/
+async function tickProgress(i, total, onProgress, label) {
+	if (!onProgress) return;
+	if (i % PROGRESS_CHUNK !== 0 && i !== total) return;
+	onProgress(`${label} (${i}/${total})`);
+	await new Promise((resolve) => setImmediate(resolve));
+}
+/**
+* Compute a CF-compatible asset hash: BLAKE3 of base64(content) + extension,
+* first 32 hex chars. Matches Wrangler's hashFile algorithm exactly.
+* Must match the API's computeAssetHash algorithm exactly.
+*/
+function computeAssetHash(content, filePath) {
+	const base64 = content.toString("base64");
+	const ext = extname(filePath).substring(1);
+	const input = textEncoder.encode(base64 + ext);
+	return Buffer.from(hash(input)).toString("hex").slice(0, 32);
+}
+/**
+* Create a filter function that excludes .assetsignore, _headers, _redirects,
+* deploy-internal patterns, and any patterns listed in a .assetsignore file.
+* Matches Wrangler's createAssetsIgnoreFunction from workers-shared/utils/helpers.ts.
+*/
+function createAssetsIgnoreFunction(dir, extraPatterns = []) {
+	const patterns = [
+		"/.assetsignore",
+		"/_redirects",
+		"/_headers",
+		...extraPatterns
+	];
+	const assetsIgnorePath = join(dir, ".assetsignore");
+	let assetsIgnoreFilePresent = false;
+	if (existsSync(assetsIgnorePath)) {
+		assetsIgnoreFilePresent = true;
+		const content = readFileSync(assetsIgnorePath, "utf-8");
+		patterns.push(...content.split("\n"));
+	}
+	const ig = ignore().add(patterns);
+	const isIgnored = (relativePath) => {
+		const normalized = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
+		return ig.test(normalized).ignored;
+	};
+	return {
+		isIgnored,
+		assetsIgnoreFilePresent
+	};
+}
+/**
+* Guard against accidentally uploading _worker.js as a static asset.
+* Matches Wrangler's errorOnLegacyPagesWorkerJSAsset behavior:
+* throws only when no .assetsignore file exists (if .assetsignore is present
+* but doesn't exclude _worker.js, the user intentionally wants to upload it).
+*/
+function checkWorkerJsAsset(relativePath, assetsIgnoreFilePresent) {
+	if (assetsIgnoreFilePresent) return;
+	const name = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
+	if (name === "_worker.js" || name.startsWith("_worker.js/")) throw new Error(`deploy: Refusing to upload _worker.js ${name === "_worker.js" ? "file" : "directory"} as an asset. This could expose private server-side code to the public Internet. If this is unintended, remove it or add a .assetsignore file containing "_worker.js". If intentional, add an empty .assetsignore file to suppress this error.`);
+}
+/**
+* Collect all files in a directory, compute hashes, and return both the
+* manifest (for preflight) and the raw file map (for selective packaging).
+*/
+async function collectAndHashAssets(dir, onProgress, opts = {}) {
+	const assetManifest = {};
+	const assetFiles = /* @__PURE__ */ new Map();
+	try {
+		const { isIgnored, assetsIgnoreFilePresent } = createAssetsIgnoreFunction(dir, opts.ignorePatterns);
+		const files = collectFiles(dir);
+		let processed = 0;
+		for (const filePath of files) {
+			processed++;
+			await tickProgress(processed, files.length, onProgress, "Hashing assets");
+			const relativePath = "/" + toSlash(relative(dir, filePath));
+			if (isIgnored(relativePath)) continue;
+			checkWorkerJsAsset(relativePath, assetsIgnoreFilePresent);
+			const content = readFileSync(filePath);
+			assetManifest[relativePath] = {
+				hash: computeAssetHash(content, filePath),
+				size: content.length
+			};
+			assetFiles.set(relativePath, content);
+		}
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "ENOENT") {} else throw err;
+	}
+	return {
+		assetManifest,
+		assetFiles
+	};
+}
+function toWebSocketManifest(routes) {
+	if (!routes || routes.length === 0) return;
+	return {
+		routes: routes.map((route) => ({
+			pattern: route.pattern,
+			filePath: route.filePath,
+			className: route.className,
+			mode: route.mode,
+			hasAuthGate: route.hasAuthGate
+		})),
+		classes: routes.map((route) => route.className)
+	};
+}
+function toSandboxManifest(sandbox) {
+	return {
+		bindingName: sandbox.binding,
+		className: sandbox.className,
+		containerName: sandbox.containerName,
+		image: sandbox.platformImage,
+		...sandbox.instanceType && { instanceType: sandbox.instanceType },
+		...sandbox.maxInstances != null && { maxInstances: sandbox.maxInstances }
+	};
+}
+async function packageBuild(distDir, workerDirName, bindings, migrations, schedules, ssr, framework, revalidate, vars, queues, prerender, assetConfig, options, neededAssets, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, dialect, webSockets, onProgress) {
+	const formData = new FormData();
+	const manifest = {
+		version: 3,
+		bindings: {}
+	};
+	if (bindings.needsAuth) manifest.auth = true;
+	const hasMigrations = migrations && migrations.length > 0;
+	if (bindings.needsD1 || bindings.needsAuth || hasMigrations) if (dialect === "postgresql") manifest.bindings.hyperdrive = ["HYPERDRIVE"];
+	else manifest.bindings.d1 = [options?.bindingNames?.d1 ?? "DB"];
+	if (bindings.needsKV) manifest.bindings.kv = [options?.bindingNames?.kv ?? "KV"];
+	if (bindings.needsR2) manifest.bindings.r2 = [options?.bindingNames?.r2 ?? "STORAGE"];
+	if (bindings.needsAI) manifest.bindings.ai = true;
+	if (bindings.needsSandbox) {
+		if (!options?.sandbox) throw new Error("deploy: Sandbox bindings require sandbox package options.");
+		manifest.sandbox = toSandboxManifest({
+			...options.sandbox,
+			binding: options.bindingNames?.sandbox ?? options.sandbox.binding
+		});
+	}
+	if (migrations && migrations.length > 0) {
+		manifest.migrations = {
+			dialect: dialect ?? "sqlite",
+			pending: migrations.length
+		};
+		onProgress?.(`Packaging ${migrations.length} migration${migrations.length === 1 ? "" : "s"}...`);
+		for (const m of migrations) formData.append(`migration:${m.name}`, new Blob([m.sql]), m.name);
+	}
+	if (schedules && schedules.length > 0) manifest.schedules = schedules;
+	if (queues && queues.length > 0) manifest.queues = queues;
+	if (ssr) manifest.ssr = true;
+	if (framework) manifest.framework = framework;
+	manifest.type = framework ? "framework" : "void";
+	if (revalidate != null && revalidate !== 0) manifest.revalidate = revalidate;
+	if (options?.revalidateQueryAllowlist && Object.keys(options.revalidateQueryAllowlist).length > 0) manifest.revalidateQueryAllowlist = options.revalidateQueryAllowlist;
+	if (prerender && prerender.length > 0) manifest.prerender = prerender;
+	let resolvedAssetConfig = assetConfig;
+	let resolvedFallbackRules = fallbackRules;
+	if (assetConfig?.not_found_handling === "single-page-application") {
+		const chain = resolveSpaFallbackChain("spa", fallbackRules);
+		resolvedAssetConfig = {
+			...assetConfig,
+			...chain.assetConfig
+		};
+		resolvedFallbackRules = chain.fallbackRules;
+	} else if (fallbackRules && fallbackRules.length > 0) {
+		const msg = "routing.fallbacks is set but appType is not \"spa\"; fallbacks will be applied, but no \"/* -> /index.html\" SPA shell fallback is synthesised — unmatched paths fall through to the platform 404.";
+		onProgress?.(msg);
+		console.warn(`[void] ${msg}`);
+	}
+	if (resolvedAssetConfig) manifest.assetConfig = resolvedAssetConfig;
+	if (vars && Object.keys(vars).length > 0) manifest.vars = vars;
+	if (options?.workerMain) manifest.workerMain = options.workerMain;
+	if (options?.compatibilityDate) manifest.compatibilityDate = options.compatibilityDate;
+	if (options?.compatibilityFlags && options.compatibilityFlags.length > 0) manifest.compatibilityFlags = options.compatibilityFlags;
+	if (hashedAssetsPrefix) manifest.hashedAssetsPrefix = hashedAssetsPrefix;
+	if (headerRules && headerRules.length > 0) manifest.headerRules = headerRules;
+	if (redirectRules && redirectRules.length > 0) manifest.redirectRules = stripDevOnlyRuleFields(redirectRules);
+	if (resolvedFallbackRules && resolvedFallbackRules.length > 0) manifest.fallbackRules = stripDevOnlyRuleFields(resolvedFallbackRules);
+	const websocketManifest = toWebSocketManifest(webSockets);
+	if (websocketManifest) manifest.websocket = websocketManifest;
+	formData.append("manifest", JSON.stringify(manifest));
+	onProgress?.("Packaging worker files...");
+	const workerDir = join(distDir, workerDirName);
+	const workerFiles = collectFiles(workerDir);
+	for (const filePath of workerFiles) {
+		const relativePath = toSlash(relative(workerDir, filePath));
+		if (!isWorkerModule(relativePath)) continue;
+		const content = readFileSync(filePath);
+		formData.append(`worker:${relativePath}`, new Blob([content]), relativePath);
+	}
+	const clientDir = join(distDir, "client");
+	try {
+		const { isIgnored, assetsIgnoreFilePresent } = createAssetsIgnoreFunction(clientDir);
+		const clientFiles = collectFiles(clientDir);
+		let processed = 0;
+		for (const filePath of clientFiles) {
+			processed++;
+			await tickProgress(processed, clientFiles.length, onProgress, "Packaging assets");
+			const relativePath = toSlash(relative(clientDir, filePath));
+			if (isIgnored("/" + relativePath)) continue;
+			checkWorkerJsAsset(relativePath, assetsIgnoreFilePresent);
+			if (neededAssets && !neededAssets.has("/" + relativePath)) continue;
+			const content = readFileSync(filePath);
+			formData.append(`asset:${relativePath}`, new Blob([content]), relativePath);
+		}
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "ENOENT") {} else throw err;
+	}
+	if (neededAssets) formData.append("preflight", "true");
+	return formData;
+}
+/**
+* Package a static build (no worker) into a FormData ready for upload.
+*/
+async function packageStaticBuild(outputDir, appType, neededAssets, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, onProgress) {
+	const formData = new FormData();
+	const { assetConfig, fallbackRules: resolvedFallbackRules } = resolveSpaFallbackChain(appType, fallbackRules);
+	const manifest = {
+		version: 3,
+		bindings: {},
+		type: appType,
+		assetConfig
+	};
+	if (hashedAssetsPrefix) manifest.hashedAssetsPrefix = hashedAssetsPrefix;
+	if (headerRules && headerRules.length > 0) manifest.headerRules = headerRules;
+	if (redirectRules && redirectRules.length > 0) manifest.redirectRules = stripDevOnlyRuleFields(redirectRules);
+	if (resolvedFallbackRules && resolvedFallbackRules.length > 0) manifest.fallbackRules = stripDevOnlyRuleFields(resolvedFallbackRules);
+	formData.append("manifest", JSON.stringify(manifest));
+	const { isIgnored, assetsIgnoreFilePresent } = createAssetsIgnoreFunction(outputDir);
+	const files = collectFiles(outputDir);
+	let processed = 0;
+	for (const filePath of files) {
+		processed++;
+		await tickProgress(processed, files.length, onProgress, "Packaging assets");
+		const relativePath = toSlash(relative(outputDir, filePath));
+		if (isIgnored("/" + relativePath)) continue;
+		checkWorkerJsAsset(relativePath, assetsIgnoreFilePresent);
+		if (neededAssets && !neededAssets.has("/" + relativePath)) continue;
+		const content = readFileSync(filePath);
+		formData.append(`asset:${relativePath}`, new Blob([content]), relativePath);
+	}
+	if (neededAssets) formData.append("preflight", "true");
+	return formData;
+}
+/**
+* Package a framework build (Class B/C) into a FormData ready for upload.
+*
+* Unlike `packageBuild`, the worker and assets directories are absolute paths
+* (resolved from the project root + preset), and the worker directory may be
+* inside the assets directory (SvelteKit, Astro). Worker files are excluded
+* from asset collection when directories overlap.
+*/
+async function packageFrameworkBuild(opts) {
+	const formData = new FormData();
+	const po = opts.packageOptions;
+	const manifest = {
+		version: 3,
+		bindings: {}
+	};
+	const hasMigrations = opts.migrations && opts.migrations.length > 0;
+	if (opts.bindings.needsD1 || opts.bindings.needsAuth || hasMigrations) if (opts.dialect === "postgresql") manifest.bindings.hyperdrive = ["HYPERDRIVE"];
+	else manifest.bindings.d1 = [po?.bindingNames?.d1 ?? "DB"];
+	if (opts.bindings.needsKV) manifest.bindings.kv = [po?.bindingNames?.kv ?? "KV"];
+	if (opts.bindings.needsR2) manifest.bindings.r2 = [po?.bindingNames?.r2 ?? "STORAGE"];
+	if (opts.bindings.needsAI) manifest.bindings.ai = true;
+	if (opts.migrations && opts.migrations.length > 0) {
+		manifest.migrations = {
+			dialect: opts.dialect ?? "sqlite",
+			pending: opts.migrations.length
+		};
+		opts.onProgress?.(`Packaging ${opts.migrations.length} migration${opts.migrations.length === 1 ? "" : "s"}...`);
+		for (const m of opts.migrations) formData.append(`migration:${m.name}`, new Blob([m.sql]), m.name);
+	}
+	if (opts.schedules && opts.schedules.length > 0) manifest.schedules = opts.schedules;
+	if (opts.queues && opts.queues.length > 0) manifest.queues = opts.queues;
+	if (opts.revalidate != null && opts.revalidate !== 0) manifest.revalidate = opts.revalidate;
+	if (opts.revalidateQueryAllowlist && Object.keys(opts.revalidateQueryAllowlist).length > 0) manifest.revalidateQueryAllowlist = opts.revalidateQueryAllowlist;
+	if (opts.prerender && opts.prerender.length > 0) manifest.prerender = opts.prerender;
+	if (opts.assetConfig) manifest.assetConfig = opts.assetConfig;
+	if (opts.vars && Object.keys(opts.vars).length > 0) manifest.vars = opts.vars;
+	manifest.ssr = true;
+	manifest.framework = opts.frameworkName;
+	manifest.type = "framework";
+	manifest.workerMain = po?.workerMain ?? opts.workerMain;
+	if (po?.compatibilityDate) manifest.compatibilityDate = po.compatibilityDate;
+	if (po?.compatibilityFlags && po.compatibilityFlags.length > 0) manifest.compatibilityFlags = po.compatibilityFlags;
+	if (opts.hashedAssetsPrefix) manifest.hashedAssetsPrefix = opts.hashedAssetsPrefix;
+	if (opts.headerRules && opts.headerRules.length > 0) manifest.headerRules = opts.headerRules;
+	if (opts.redirectRules && opts.redirectRules.length > 0) manifest.redirectRules = stripDevOnlyRuleFields(opts.redirectRules);
+	if (opts.fallbackRules && opts.fallbackRules.length > 0) manifest.fallbackRules = stripDevOnlyRuleFields(opts.fallbackRules);
+	const websocketManifest = toWebSocketManifest(opts.webSockets);
+	if (websocketManifest) manifest.websocket = websocketManifest;
+	formData.append("manifest", JSON.stringify(manifest));
+	const workerDirNorm = opts.workerDir.replace(/\\/g, "/");
+	const assetsDirNorm = opts.assetsDir.replace(/\\/g, "/");
+	const isOverlap = workerDirNorm.startsWith(assetsDirNorm + "/") || workerDirNorm === assetsDirNorm;
+	opts.onProgress?.("Packaging worker files...");
+	const workerFiles = collectFiles(opts.workerDir);
+	for (const filePath of workerFiles) {
+		const relativePath = toSlash(relative(opts.workerDir, filePath));
+		if (!isWorkerModule(relativePath)) continue;
+		const content = readFileSync(filePath);
+		formData.append(`worker:${relativePath}`, new Blob([content]), relativePath);
+	}
+	try {
+		const { isIgnored, assetsIgnoreFilePresent } = createAssetsIgnoreFunction(opts.assetsDir, opts.assetIgnorePatterns);
+		const assetFiles = collectFiles(opts.assetsDir);
+		let processed = 0;
+		for (const filePath of assetFiles) {
+			processed++;
+			await tickProgress(processed, assetFiles.length, opts.onProgress, "Packaging assets");
+			if (isOverlap && filePath.replace(/\\/g, "/").startsWith(workerDirNorm)) continue;
+			const relativePath = toSlash(relative(opts.assetsDir, filePath));
+			if (isIgnored("/" + relativePath)) continue;
+			checkWorkerJsAsset(relativePath, assetsIgnoreFilePresent);
+			if (opts.neededAssets && !opts.neededAssets.has("/" + relativePath)) continue;
+			const content = readFileSync(filePath);
+			formData.append(`asset:${relativePath}`, new Blob([content]), relativePath);
+		}
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "ENOENT") {} else throw err;
+	}
+	if (opts.neededAssets) formData.append("preflight", "true");
+	return formData;
+}
+/**
+* Check if a file (by relative path) should be included as a worker module.
+* Skips build metadata and files with extensions CF Workers can't handle as modules.
+*/
+function isWorkerModule(relativePath) {
+	const norm = relativePath.replace(/\\/g, "/");
+	if (norm.includes("/.vite/") || norm.startsWith(".vite/")) return false;
+	if (norm === "wrangler.json" || norm === "wrangler.jsonc") return false;
+	return /\.(js|mjs|cjs|wasm|map|txt)$/.test(norm);
+}
+/**
+* Recursively collect all file paths in a directory.
+*/
+function collectFiles(dir) {
+	const files = [];
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...collectFiles(fullPath));
+		else files.push(fullPath);
+	}
+	return files;
+}
+//#endregion
+//#region src/cli/wrapper.ts
+const BUNDLED_ENTRY_RE = /^index\.(?:m?js|cjs)$/;
+function selectBundledEntryFilename(outFiles) {
+	const entryFilename = outFiles.find((file) => BUNDLED_ENTRY_RE.test(file));
+	if (!entryFilename) throw new Error(`deploy: Bundled worker entry not found. Expected index.js, index.mjs, or index.cjs in bundle output. Found: ${outFiles.join(", ") || "(none)"}`);
+	return entryFilename;
+}
+/**
+* Determine whether a wrapper is needed based on the features.
+*/
+function needsWrapper(features) {
+	return features.crons.length > 0 || features.queues.length > 0 || !!features.hasMigrations;
+}
+/**
+* Generate a wrapper entry in-place in the worker directory.
+*
+* - Renames the original entry (e.g. `index.js` → `__original.js`)
+* - Compiles cron/queue handlers via a small Vite build
+* - Writes a wrapper module as the original entry name that imports
+*   the renamed original + compiled handlers
+*
+* The original worker code is never re-bundled.
+*/
+async function generateWrapper(workerDir, workerMain, root, features) {
+	const renamedName = `__original${extname(workerMain) || ".js"}`;
+	renameSync(join(workerDir, workerMain), join(workerDir, renamedName));
+	let handlerFilename = "__void_handlers.mjs";
+	if (features.crons.length > 0 || features.queues.length > 0) {
+		const tmpDir = join(root, ".void", "handlers");
+		mkdirSync(tmpDir, { recursive: true });
+		const handlersSource = generateHandlersSource(root, features);
+		const handlersEntry = join(tmpDir, "handlers.ts");
+		writeFileSync(handlersEntry, handlersSource);
+		const outDir = join(tmpDir, "out");
+		await build({
+			root: tmpDir,
+			logLevel: "silent",
+			build: {
+				outDir,
+				emptyOutDir: true,
+				lib: {
+					entry: handlersEntry,
+					formats: ["es"],
+					fileName: "__void_handlers"
+				},
+				rollupOptions: { external: [/^cloudflare:/, /^node:/] },
+				minify: false,
+				target: "esnext"
+			}
+		});
+		handlerFilename = readdirSync(outDir).filter((f) => f.startsWith("__void_handlers"))[0] ?? "__void_handlers.mjs";
+		copyFileSync(join(outDir, handlerFilename), join(workerDir, handlerFilename));
+	}
+	let migrations;
+	if (features.hasMigrations) {
+		const { collectMigrations } = await import("./collect-CjeZgz5D.mjs").then((n) => n.n);
+		migrations = collectMigrations(join(root, "db", "migrations"));
+		const handlerFilename_ = features.migrationDialect === "postgresql" ? "migration-handler-pg.mjs" : "migration-handler.mjs";
+		let handlerPath = join(import.meta.dirname, "runtime", handlerFilename_);
+		if (!existsSync(handlerPath)) handlerPath = join(import.meta.dirname, "..", "runtime", handlerFilename_);
+		if (!existsSync(handlerPath)) handlerPath = join(import.meta.dirname, "..", "..", "dist", "runtime", handlerFilename_);
+		if (!existsSync(handlerPath)) throw new Error(`Migration handler not found: ${handlerFilename_}. Run "pnpm -C packages/void build" first.`);
+		copyFileSync(handlerPath, join(workerDir, "__void_migration_handler.mjs"));
+	}
+	const wrapperSource = generateWrapperSource(renamedName, handlerFilename, features, migrations);
+	writeFileSync(join(workerDir, workerMain), wrapperSource);
+}
+/**
+* Bundle a worker entry into a self-contained module.
+*
+* Used for frameworks whose build output has unbundled bare imports
+* (e.g. SvelteKit's `_worker.js` imports from `@sveltejs/kit`).
+*/
+async function bundleEntry(root, entry) {
+	const tmpDir = join(root, ".void", "bundle");
+	mkdirSync(tmpDir, { recursive: true });
+	const outDir = join(tmpDir, "out");
+	await build({
+		root: tmpDir,
+		logLevel: "silent",
+		build: {
+			outDir,
+			emptyOutDir: true,
+			lib: {
+				entry,
+				formats: ["es"],
+				fileName: "index"
+			},
+			rollupOptions: {
+				external: [/^cloudflare:/, /^node:/],
+				output: { banner: [
+					"const __noopCache = {",
+					"  match() { return Promise.resolve(undefined); },",
+					"  put() { return Promise.resolve(); },",
+					"  delete() { return Promise.resolve(false); },",
+					"};",
+					"globalThis.caches = { default: __noopCache, open() { return Promise.resolve(__noopCache); } };"
+				].join("\n") }
+			},
+			minify: false,
+			target: "esnext"
+		}
+	});
+	return {
+		entryFilename: selectBundledEntryFilename(readdirSync(outDir)),
+		outputDir: outDir
+	};
+}
+/**
+* Clean up generated wrapper/bundle files. Preserves `dev-trigger-token`
+* across the wipe so that subsequent `void dev` sessions keep using the
+* same UUID — invalidating it on every deploy would force users to update
+* any saved curl scripts that exercise `/__void/{scheduled,queue}`.
+*/
+function cleanupWrapper(root) {
+	const voidDir = join(root, ".void");
+	const tokenPath = join(voidDir, "dev-trigger-token");
+	let preservedToken;
+	if (existsSync(tokenPath)) try {
+		preservedToken = readFileSync(tokenPath, "utf-8");
+	} catch {}
+	rmSync(voidDir, {
+		recursive: true,
+		force: true
+	});
+	if (preservedToken !== void 0) {
+		mkdirSync(voidDir, { recursive: true });
+		writeFileSync(tokenPath, preservedToken);
+	}
+}
+function generateWrapperSource(renamedEntry, handlersModule, features, migrations) {
+	const lines = [];
+	lines.push(`import original from "./${renamedEntry}";`);
+	if (features.crons.length > 0) lines.push(`import { handleScheduled } from "./${handlersModule}";`);
+	if (features.queues.length > 0) lines.push(`import { handleQueue } from "./${handlersModule}";`);
+	if (migrations && migrations.length > 0) {
+		lines.push(`import { createMigrationHandler } from "./__void_migration_handler.mjs";`);
+		lines.push(`const __migrations = ${JSON.stringify(migrations)};`);
+		lines.push(`const __migrationDialect = ${JSON.stringify(features.migrationDialect ?? "sqlite")};`);
+	}
+	lines.push("");
+	const needsFetchWrap = features.crons.length > 0 || migrations && migrations.length > 0;
+	if (needsFetchWrap) {
+		lines.push("async function wrappedFetch(request, env, ctx) {");
+		lines.push("  const url = new URL(request.url);");
+		if (migrations && migrations.length > 0) {
+			lines.push("  if (request.method === \"POST\" && url.pathname === \"/__void/migrate\") {");
+			lines.push("    const handler = createMigrationHandler(env, __migrations, __migrationDialect);");
+			lines.push("    return handler(request);");
+			lines.push("  }");
+		}
+		if (features.crons.length > 0) {
+			lines.push("  if (request.method === \"POST\" && url.pathname === \"/__void/scheduled\") {");
+			lines.push("    const __token = request.headers.get(\"x-void-internal\");");
+			lines.push("    const __expected = env?.__VOID_PROXY_TOKEN || env?.CRON_SECRET;");
+			lines.push("    if (__expected && __token !== __expected) {");
+			lines.push("      return new Response(JSON.stringify({ error: 'unauthorized' }), {");
+			lines.push("        status: 401,");
+			lines.push("        headers: { \"Content-Type\": \"application/json\" },");
+			lines.push("      });");
+			lines.push("    }");
+			lines.push("    try {");
+			lines.push("      const { cron, scheduledTime } = await request.json();");
+			lines.push("      const controller = { cron, scheduledTime, noRetry() {} };");
+			lines.push("      await handleScheduled(controller, env, ctx);");
+			lines.push("      return new Response(JSON.stringify({ ok: true }), {");
+			lines.push("        headers: { \"Content-Type\": \"application/json\" },");
+			lines.push("      });");
+			lines.push("    } catch (err) {");
+			lines.push("      return new Response(JSON.stringify({ error: String(err) }), {");
+			lines.push("        status: 500,");
+			lines.push("        headers: { \"Content-Type\": \"application/json\" },");
+			lines.push("      });");
+			lines.push("    }");
+			lines.push("  }");
+		}
+		lines.push("  return original.fetch(request, env, ctx);");
+		lines.push("}");
+		lines.push("");
+	}
+	lines.push("export default {");
+	if (needsFetchWrap) lines.push("  fetch: wrappedFetch,");
+	else lines.push("  fetch: original.fetch,");
+	if (features.crons.length > 0) lines.push("  scheduled: handleScheduled,");
+	if (features.queues.length > 0) lines.push("  queue: handleQueue,");
+	lines.push("};");
+	return lines.join("\n");
+}
+function generateHandlersSource(root, features) {
+	const lines = [];
+	if (features.crons.length > 0) {
+		for (let i = 0; i < features.crons.length; i++) {
+			const absPath = join(root, "crons", features.crons[i].filePath);
+			lines.push(`import cronHandler${i} from "${absPath}";`);
+		}
+		lines.push("");
+		lines.push("export async function handleScheduled(controller, env, ctx) {");
+		lines.push("  switch (controller.cron) {");
+		for (let i = 0; i < features.crons.length; i++) {
+			for (const expr of features.crons[i].crons) lines.push(`    case ${JSON.stringify(expr)}:`);
+			lines.push(`      if (typeof cronHandler${i} === "function") {`);
+			lines.push(`        await cronHandler${i}(controller, env, ctx);`);
+			lines.push(`      } else if (cronHandler${i} && typeof cronHandler${i}.default === "function") {`);
+			lines.push(`        await cronHandler${i}.default(controller, env, ctx);`);
+			lines.push(`      }`);
+			lines.push(`      return;`);
+		}
+		lines.push("  }");
+		lines.push("}");
+	}
+	if (features.queues.length > 0) {
+		lines.push("");
+		for (let i = 0; i < features.queues.length; i++) {
+			const absPath = join(root, "queues", features.queues[i].filePath);
+			lines.push(`import queueHandler${i} from "${absPath}";`);
+		}
+		lines.push("");
+		lines.push("export async function handleQueue(batch, env, ctx) {");
+		lines.push("  const queueSuffix = batch.queue;");
+		lines.push("  const messages = [...batch.messages].map(m => ({");
+		lines.push("    id: m.id,");
+		lines.push("    timestamp: m.timestamp.toISOString(),");
+		lines.push("    body: m.body,");
+		lines.push("    attempts: m.attempts,");
+		lines.push("  }));");
+		lines.push("  const payload = { queue: queueSuffix, messages };");
+		for (let i = 0; i < features.queues.length; i++) {
+			const name = features.queues[i].name;
+			lines.push("");
+			lines.push(`  if (queueSuffix === ${JSON.stringify(name)} || queueSuffix.endsWith("-" + ${JSON.stringify(name)})) {`);
+			lines.push(`    if (typeof queueHandler${i} === "function") {`);
+			lines.push(`      await queueHandler${i}(payload, env);`);
+			lines.push(`    } else if (queueHandler${i} && typeof queueHandler${i}.default === "function") {`);
+			lines.push(`      await queueHandler${i}.default(payload, env);`);
+			lines.push(`    }`);
+			lines.push(`    return;`);
+			lines.push(`  }`);
+		}
+		lines.push("}");
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/cli/deploy.ts
+var deploy_exports = /* @__PURE__ */ __exportAll({
+	applyDeployEvent: () => applyDeployEvent,
+	hasDeploySchemaDrift: () => hasDeploySchemaDrift,
+	promptDeployProjectConfig: () => promptDeployProjectConfig,
+	resolveAssetConfig: () => resolveAssetConfig,
+	resolveDeployWranglerCompat: () => resolveDeployWranglerCompat,
+	resolveDistDir: () => resolveDistDir,
+	resolveStaticBuildCommand: () => resolveStaticBuildCommand,
+	resolveWorkerDirName: () => resolveWorkerDirName,
+	runDeploy: () => runDeploy,
+	warnRedundantForceOn3xx: () => warnRedundantForceOn3xx
+});
+const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
+const deployDriftCheckDir = join(".void", "deploy-drift-check");
+var DeployEventError = class extends Error {};
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Resolve the Cloudflare Workers Static Assets `not_found_handling` config.
+*
+* Any worker capable of producing HTML (SSR, pages, file-based routes, or
+* middleware) must use `'none'` so the asset binding returns 404 for
+* unmatched paths and the worker — gated by `run_worker_first` — owns the
+* response. With `'single-page-application'`, CF short-circuits any
+* `Sec-Fetch-Mode: navigate` request straight to the SPA shell *before*
+* `run_worker_first` is consulted, silently bypassing auth middleware and
+* breaking OAuth callbacks (which arrive as navigations from the provider's
+* 302 redirect).
+*
+* Pure-frontend SPAs without any backend code keep the SPA-fallback config
+* because the worker has no responsibility for HTML routing.
+*/
+function resolveAssetConfig(opts) {
+	return opts.isSsr || opts.hasPages || opts.hasRoutes || opts.hasMiddleware || opts.hasWebSockets === true || opts.authEnabled === true ? { not_found_handling: "none" } : { not_found_handling: "single-page-application" };
+}
+function getExitCode(error) {
+	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return error.status;
+	return 1;
+}
+function resolveDeployWranglerCompat(root, config, buildOutputDir) {
+	return isNodeTarget(config.target) ? void 0 : readWranglerCompat(root, config, buildOutputDir);
+}
+/**
+* Run the full deploy pipeline:
+* 1. Check auth
+* 2. Resolve project + deploy mode
+* 3. Build (if needed)
+* 4. Package output
+* 5. Upload to platform
+* 6. Print live URL
+*/
+async function runDeploy(root, options) {
+	console.log();
+	ge(cliTitle("deploy"));
+	let reauthenticated = false;
+	while (true) try {
+		const token = getToken(root);
+		if (!token) {
+			R.error("No auth token found. Run `void auth login` first.");
+			process.exit(1);
+		}
+		const client = new PlatformClient(token, { root });
+		const requestedProjectSlug = getRequestedProjectSlug(options);
+		let config = null;
+		if (requestedProjectSlug) {
+			config = resolveProjectBySlug(await client.listProjects(), requestedProjectSlug);
+			if (!config) if (!process.stdin.isTTY) config = await createProjectFromSlug(root, client, requestedProjectSlug);
+			else {
+				const shouldCreate = await ue({ message: `Project "${requestedProjectSlug}" does not exist. Create it?` });
+				if (q(shouldCreate) || !shouldCreate) {
+					R.info("Deploy cancelled.");
+					process.exit(0);
+				}
+				config = await createProjectFromSlug(root, client, requestedProjectSlug);
+			}
+		} else config = readProjectConfig(root);
+		if (!config && !process.stdin.isTTY) {
+			R.error("No project specified. Set `VOID_PROJECT`, pass `--project <slug>`, or commit `.void/project.json`.");
+			process.exit(1);
+		}
+		if (!config) config = await promptDeployProjectConfig(root, client);
+		const voidConfig = readConfig(root);
+		const detected = detectFramework(root);
+		if (detected) {
+			const gitCommit = options?.skipBuild ? null : getGitCommit(root);
+			const fwPreset = FRAMEWORK_PRESETS[detected.name];
+			if (detected.class === "b" || detected.class === "c") {
+				if (!fwPreset) {
+					R.error(`No deploy preset found for framework "${detected.name}".`);
+					process.exit(1);
+				}
+				await runFrameworkDeploy(root, config, client, detected, fwPreset, voidConfig, options?.skipBuild, gitCommit);
+			} else await runFullDeploy(root, config, client, fwPreset, options?.skipBuild, gitCommit, detected);
+			return;
+		}
+		let preset = null;
+		const appType = voidConfig.inference?.appType;
+		if (appType && appType !== "void" && appType !== "framework") {
+			const outputDir = voidConfig.inference?.outputDir;
+			preset = {
+				buildCommand: null,
+				outputDir: outputDir ? resolve(root, outputDir) : join(root, "dist"),
+				appType
+			};
+			const detectedPreset = detectPreset(root, {
+				dir: options?.dir,
+				spa: options?.spa
+			});
+			if (detectedPreset) {
+				preset.buildCommand = detectedPreset.buildCommand;
+				if (!outputDir) preset.outputDir = detectedPreset.outputDir;
+			}
+		} else if (!appType) preset = detectPreset(root, {
+			dir: options?.dir,
+			spa: options?.spa
+		});
+		const gitCommit = options?.skipBuild ? null : getGitCommit(root);
+		if (preset) {
+			preset = {
+				...preset,
+				buildCommand: resolveStaticBuildCommand(preset, voidConfig.inference?.build, Boolean(options?.dir))
+			};
+			await runStaticDeploy(root, config, client, preset, options?.skipBuild, gitCommit, void 0, void 0, void 0, void 0, voidConfig.routing);
+		} else await runFullDeploy(root, config, client, void 0, options?.skipBuild, gitCommit);
+		return;
+	} catch (error) {
+		if (isExpiredTokenError(error)) {
+			if (getTokenSource() === "ci") throw new Error("`VOID_TOKEN` is invalid or expired. Generate a new token and try again.");
+			if (!process.stdin.isTTY || reauthenticated) throw new Error("Auth token expired. Run `void auth login` and try again.");
+			R.warn("Auth token expired. Re-authenticating...");
+			await promptForLoginToken(root);
+			R.success("Re-authenticated. Retrying deploy...");
+			reauthenticated = true;
+			continue;
+		}
+		throw error;
+	}
+}
+async function promptDeployProjectConfig(root, client) {
+	const projects = await client.listProjects();
+	if (await promptProjectSetupAction("Set up a Void project for deploy:", { includeLink: projects.length > 0 }) === "create") return promptAndCreateProject(root, client);
+	const result = await promptProjectSelection(projects, "Select a project to deploy to:", root, { includeCreate: false });
+	if (result.action === "create") throw new Error("Unexpected project selection result.");
+	const config = {
+		projectId: result.project.id,
+		slug: result.project.slug
+	};
+	writeProjectConfig(root, config);
+	R.step(`Linked to ${import_picocolors.default.blue(config.slug)}`);
+	return config;
+}
+function resolveStaticBuildCommand(preset, buildOverride, hasExplicitDir = false) {
+	if (hasExplicitDir) return null;
+	return buildOverride ?? preset.buildCommand;
+}
+/**
+* Apply the visible side effects of a streamed deploy event (spinner
+* message or log warning). Returns a discriminated result so the caller
+* advances its own state (deploymentId capture, final return, error
+* throw). Pure function of (event, s) so the switch stays unit-testable.
+*/
+function applyDeployEvent(event, s) {
+	switch (event.event) {
+		case "start":
+			s.message("Deploying...");
+			return {
+				kind: "start",
+				deploymentId: event.deploymentId
+			};
+		case "heartbeat": return { kind: "continue" };
+		case "asset_upload":
+			if (event.new > 0) s.message(`Uploading assets (${event.new} new, ${event.cached} cached)`);
+			else s.message(`Uploading assets (${event.total} cached)`);
+			return { kind: "continue" };
+		case "provisioning":
+			s.message(`Provisioning ${event.bindings.join(", ")}`);
+			return { kind: "continue" };
+		case "migration_start":
+			s.message(`Running ${event.pending} migration${event.pending > 1 ? "s" : ""}...`);
+			return { kind: "continue" };
+		case "migration":
+			s.message(`Applied migration: ${event.name} (${event.durationMs}ms)`);
+			return { kind: "continue" };
+		case "worker_upload":
+			s.message("Uploading worker...");
+			return { kind: "continue" };
+		case "queue_setup":
+			s.message(`Configuring queue consumers: ${event.queues.join(", ")}`);
+			return { kind: "continue" };
+		case "queue_consumer_conflict":
+			R.warn(`Queue consumer conflict on "${event.queue}": owned by "${event.ownerScript}". Messages for this queue will not be delivered to this deployment until the owning script is removed.`);
+			return { kind: "continue" };
+		case "prerender":
+			s.message(`Prerendering ${event.pages} pages...`);
+			return { kind: "continue" };
+		case "done":
+			s.stop("Deployed!");
+			return {
+				kind: "done",
+				event
+			};
+		case "error":
+			s.stop("Deploy failed");
+			return {
+				kind: "error",
+				message: event.message
+			};
+	}
+	return { kind: "continue" };
+}
+async function streamDeploy(client, projectId, formData, s) {
+	let deploymentId = null;
+	let interrupted = false;
+	const onSigint = () => {
+		interrupted = true;
+		s.stop("Deploy interrupted");
+		if (deploymentId) R.info(`Deployment: ${deploymentId}`);
+		else R.info("Deployment id was not received before the interrupt.");
+		process.exit(130);
+	};
+	process.once("SIGINT", onSigint);
+	try {
+		for await (const event of client.deploy(projectId, formData)) {
+			const result = applyDeployEvent(event, s);
+			if (result.kind === "start") deploymentId = result.deploymentId;
+			else if (result.kind === "done") return result.event;
+			else if (result.kind === "error") throw new DeployEventError(formatDeployFailureMessage(result.message, deploymentId));
+		}
+	} catch (err) {
+		if (err instanceof DeployEventError) throw err;
+		if (interrupted) throw err;
+		s.stop("Deploy failed");
+		throw formatStreamDeployError(err, deploymentId);
+	} finally {
+		process.removeListener("SIGINT", onSigint);
+	}
+	s.stop("Deploy failed");
+	throw new Error(formatConnectionLostMessage(deploymentId));
+}
+function formatKnownAssetSummary(result, skipped) {
+	const uploaded = result.assets - skipped;
+	return skipped > 0 ? `${result.assets} static asset(s) (${skipped} unchanged, ${uploaded} uploaded)` : `${result.assets} static asset(s)`;
+}
+async function runStaticDeploy(root, config, client, preset, skipBuild, commit, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, routing) {
+	const typeLabel = preset.appType === "spa" ? "Static SPA" : "Static Site";
+	R.info(`${typeLabel} deploy`);
+	if (preset.buildCommand && !skipBuild) {
+		R.step("Building...");
+		execSync(preset.buildCommand, {
+			cwd: root,
+			stdio: "inherit"
+		});
+	}
+	if (!existsSync(preset.outputDir)) {
+		R.error(`deploy: Output directory '${preset.outputDir}' not found. Run the build first.`);
+		process.exit(1);
+	}
+	if (routing) {
+		const merged = mergeRoutingRules({
+			dir: preset.outputDir,
+			routing
+		});
+		warnRedundantForceOn3xx(merged.redundantForceOn3xx);
+		lintDuplicateSources(merged.redirectRules, "redirects/rewrites (pre-asset)");
+		lintDuplicateSources(merged.fallbackRules, "fallbacks (post-asset)");
+		lintDestinationSplats(merged.redirectRules, "redirects/rewrites (pre-asset)");
+		lintDestinationSplats(merged.fallbackRules, "fallbacks (post-asset)");
+		headerRules = merged.headerRules;
+		redirectRules = merged.redirectRules;
+		fallbackRules = merged.fallbackRules;
+	}
+	const s = createSpinner();
+	const onProgress = (msg) => s.message(msg);
+	s.start("Checking for changes...");
+	const { assetManifest } = await collectAndHashAssets(preset.outputDir, onProgress);
+	const { needed, skipped } = await client.preflight(config.projectId, assetManifest);
+	s.stop("Checked for changes");
+	if (skipped > 0) R.info(`Skipping ${skipped} unchanged asset(s)`);
+	s.start("Packaging...");
+	const neededSet = skipped > 0 ? new Set(needed) : null;
+	const formData = await packageStaticBuild(preset.outputDir, preset.appType, neededSet, hashedAssetsPrefix ?? "assets", headerRules, redirectRules, fallbackRules, onProgress);
+	formData.append("assetManifest", JSON.stringify(assetManifest));
+	formData.append("source", getTokenSource());
+	if (commit) formData.append("commit", commit);
+	const result = await streamDeploy(client, config.projectId, formData, s);
+	Se([`${typeLabel} — ${formatKnownAssetSummary(result, skipped)}`].join("\n"), result.url);
+	ye("Done!");
+}
+/**
+* Emit a single aggregated lint warning when a `_redirects` file contains
+* one or more `!` force suffixes on 3xx entries (e.g. `301!`, `302!`).
+* The `!` is a no-op on redirects — we parse them as if the `!` weren't
+* there — but we nudge the user to clean up for clarity. Silenced when
+* `count === 0`.
+*/
+function warnRedundantForceOn3xx(count) {
+	if (count === 0) return;
+	R.warn(`Found ${count} redundant "!" on 3xx entries in _redirects (these always force by nature; safe to remove).`);
+}
+/**
+* Class B/C framework deploy: build with framework CLI, package with preset output paths.
+*/
+async function runFrameworkDeploy(root, config, client, detected, fwPreset, voidConfig, skipBuild, commit) {
+	R.info(`${detected.name} framework deploy`);
+	const dialect = getDatabaseDialect(voidConfig);
+	const buildCmd = voidConfig.inference?.build ?? formatProjectCommand(root, fwPreset.buildCommand);
+	if (!skipBuild) {
+		R.step(`Building (${buildCmd})...`);
+		execSync(voidConfig.inference?.build ?? resolveProjectCommand(root, fwPreset.buildCommand), {
+			cwd: root,
+			stdio: "inherit"
+		});
+	}
+	const workerDir = join(root, fwPreset.workerDir);
+	const assetsDir = join(root, fwPreset.assetsDir);
+	const frameworkAssetIgnorePatterns = fwPreset.workerDir === fwPreset.assetsDir && fwPreset.workerMain === "_worker.js" ? [`/${fwPreset.workerMain}`, "/_routes.json"] : [];
+	const { headerRules, redirectRules, fallbackRules, redundantForceOn3xx } = mergeRoutingRules({
+		dir: assetsDir,
+		routing: voidConfig.routing
+	});
+	warnRedundantForceOn3xx(redundantForceOn3xx);
+	lintDuplicateSources(redirectRules, "redirects/rewrites (pre-asset)");
+	lintDuplicateSources(fallbackRules, "fallbacks (post-asset)");
+	lintDestinationSplats(redirectRules, "redirects/rewrites (pre-asset)");
+	lintDestinationSplats(fallbackRules, "fallbacks (post-asset)");
+	if (!existsSync(workerDir)) {
+		R.error(`deploy: Worker output '${fwPreset.workerDir}' not found. Run '${buildCmd}' first.`);
+		process.exit(1);
+	}
+	const bindings = inferProjectBindings(root, voidConfig.inference?.bindings ? { bindings: voidConfig.inference.bindings } : void 0, voidConfig.inference?.scanDirs ?? FRAMEWORK_SCAN_DIRS);
+	if (bindings.needsAuth || findVoidAuthConfig(root) !== null || voidConfig.auth !== void 0) {
+		R.error("deploy: Void-managed Better Auth is only supported in Void apps. Use Better Auth's official integration for this framework instead.");
+		process.exit(1);
+	}
+	const migrationsDir = join(root, "db", "migrations");
+	assertDeploySchemaDriftFree(root, dialect);
+	const rawMigrations = collectMigrations(migrationsDir);
+	let validatedMigrations;
+	try {
+		assertJournalCoherence(migrationsDir, rawMigrations);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (rawMigrations.length > 0) try {
+		validatedMigrations = validateMigrations(rawMigrations);
+		R.info(`Found ${validatedMigrations.length} migration(s)`);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (dialect === "postgresql" && (bindings.needsD1 || rawMigrations.length > 0)) try {
+		if (!(await client.getResources(config.projectId)).some((resource) => resource.type === "hyperdrive")) {
+			const { text: promptText, isCancel: isCancelPrompt } = await import("./dist-Dayj3gCK.mjs").then((n) => n.p);
+			const connectionString = await promptText({
+				message: "Your project uses PostgreSQL. Enter your connection string:",
+				placeholder: "postgresql://user:pass@host:5432/dbname",
+				validate(value) {
+					if (!value?.startsWith("postgres://") && !value?.startsWith("postgresql://")) return "Must start with \"postgres://\" or \"postgresql://\"";
+				}
+			});
+			if (isCancelPrompt(connectionString)) {
+				R.info("Deploy cancelled.");
+				process.exit(0);
+			}
+			await client.provisionDatabase(config.projectId, connectionString);
+			R.success("Hyperdrive provisioned.");
+		}
+	} catch {}
+	const rawJobs = scanJobsSync(root);
+	const rawQueues = scanQueuesSync(root);
+	const originalEntry = join(workerDir, fwPreset.workerMain);
+	const wrapperFeatures = {
+		auth: null,
+		crons: rawJobs,
+		queues: rawQueues,
+		hasMigrations: validatedMigrations != null && validatedMigrations.length > 0,
+		migrationDialect: dialect
+	};
+	let actualWorkerDir = workerDir;
+	let actualWorkerMain = fwPreset.workerMain;
+	if (fwPreset.bundle) {
+		R.step("Bundling worker...");
+		const bundleResult = await bundleEntry(root, originalEntry);
+		actualWorkerDir = bundleResult.outputDir;
+		actualWorkerMain = bundleResult.entryFilename;
+		R.info("Worker bundled");
+	}
+	if (needsWrapper(wrapperFeatures)) {
+		R.step("Generating wrapper...");
+		await generateWrapper(actualWorkerDir, actualWorkerMain, root, wrapperFeatures);
+		R.info("Wrapper generated");
+	}
+	const wranglerCompat = readWranglerCompat(root, voidConfig, workerDir);
+	const revalidate = voidConfig.routing?.revalidate;
+	const prerender = voidConfig.routing?.prerender;
+	const schedules = rawJobs.flatMap((job) => job.crons.map((cron) => ({
+		name: job.name,
+		cron
+	})));
+	const queues = rawQueues.map((q) => ({
+		name: q.name,
+		bindingName: q.bindingName,
+		...q.maxBatchSize != null && { maxBatchSize: q.maxBatchSize },
+		...q.maxBatchTimeout != null && { maxBatchTimeout: q.maxBatchTimeout }
+	}));
+	const envVars = loadDeployEnv(root);
+	await assertEnvSchemaValid(root, client, config.projectId);
+	await applySchemaDefaultsToVars(root, envVars);
+	const s = createSpinner();
+	const onProgress = (msg) => s.message(msg);
+	s.start("Checking for changes...");
+	const { assetManifest } = await collectAndHashAssets(assetsDir, onProgress, { ignorePatterns: frameworkAssetIgnorePatterns });
+	const { needed, skipped } = await client.preflight(config.projectId, assetManifest, true);
+	s.stop("Checked for changes");
+	if (skipped > 0) R.info(`Skipping ${skipped} unchanged asset(s)`);
+	s.start("Packaging...");
+	const neededSet = skipped > 0 ? new Set(needed) : null;
+	const formData = await packageFrameworkBuild({
+		frameworkName: detected.name,
+		workerDir: actualWorkerDir,
+		workerMain: actualWorkerMain,
+		assetsDir,
+		bindings,
+		migrations: validatedMigrations,
+		schedules,
+		queues,
+		revalidate,
+		prerender,
+		assetConfig: { not_found_handling: "none" },
+		vars: envVars,
+		packageOptions: {
+			bindingNames: resolveBindingNames(voidConfig.inference?.bindings),
+			workerMain: actualWorkerMain,
+			compatibilityDate: wranglerCompat.compatibilityDate,
+			compatibilityFlags: wranglerCompat.compatibilityFlags
+		},
+		revalidateQueryAllowlist: voidConfig.routing?.revalidateQueryAllowlist,
+		neededAssets: neededSet,
+		hashedAssetsPrefix: fwPreset.hashedAssetsPrefix ?? "assets",
+		headerRules,
+		redirectRules,
+		fallbackRules,
+		dialect,
+		assetIgnorePatterns: frameworkAssetIgnorePatterns,
+		onProgress
+	});
+	formData.append("assetManifest", JSON.stringify(assetManifest));
+	formData.append("source", getTokenSource());
+	if (commit) formData.append("commit", commit);
+	const result = await streamDeploy(client, config.projectId, formData, s);
+	const summary = [`${result.workers} worker module(s), ${formatKnownAssetSummary(result, skipped)}`];
+	if (result.migrations) summary.push(`${result.migrations} migration(s) applied`);
+	if (schedules.length > 0) summary.push(`${schedules.length} cron job(s) scheduled`);
+	if (queues.length > 0) summary.push(`${queues.length} queue(s) configured`);
+	if (prerender && prerender.length > 0) summary.push(`${prerender.length} page(s) prerendered`);
+	if (revalidate) if (typeof revalidate === "number") summary.push(`ISR revalidate: ${revalidate}s`);
+	else summary.push(`ISR revalidate: ${Object.keys(revalidate).length} path rule(s)`);
+	summary.push(`Framework: ${detected.name}`);
+	Se(summary.join("\n"), result.url);
+	cleanupWrapper(root);
+	ye("Done!");
+}
+async function runFullDeploy(root, config, client, fwPreset, skipBuild, commit, detected) {
+	if (!skipBuild) {
+		const buildCmd = formatProjectCommand(root, "vite build");
+		R.step(`Building (${buildCmd})...`);
+		try {
+			execSync(resolveProjectCommand(root, "vite build"), {
+				cwd: root,
+				stdio: "inherit",
+				env: {
+					...process.env,
+					VOID_DEPLOY_PROJECT_ID: config.projectId
+				}
+			});
+		} catch (err) {
+			process.exit(getExitCode(err));
+		}
+	}
+	const frameworkBuildCmd = fwPreset ? formatProjectCommand(root, fwPreset.buildCommand) : void 0;
+	const distDir = resolveDistDir(root, fwPreset, frameworkBuildCmd);
+	let assetsPrefix = "assets";
+	const clientManifestPath = join(distDir, "client", ".vite", "manifest.json");
+	if (existsSync(clientManifestPath)) {
+		const manifest = JSON.parse(readFileSync(clientManifestPath, "utf-8"));
+		for (const entry of Object.values(manifest)) if (entry.file?.includes("/")) {
+			const dir = entry.file.slice(0, entry.file.indexOf("/"));
+			if (dir !== "assets") assetsPrefix = dir;
+			break;
+		}
+	}
+	const isFrameworkMode = detected != null;
+	const deployConfig = readConfig(root);
+	const dialect = getDatabaseDialect(deployConfig);
+	const bindings = inferProjectBindings(root, void 0, deployConfig.inference?.scanDirs ?? (isFrameworkMode ? FRAMEWORK_SCAN_DIRS : void 0));
+	if (isSandboxEnabled(deployConfig)) bindings.needsSandbox = true;
+	const authEnabled = bindings.needsAuth || findVoidAuthConfig(root) !== null || deployConfig.auth !== void 0;
+	const effectiveBindings = authEnabled ? {
+		...bindings,
+		needsAuth: true,
+		needsD1: true
+	} : bindings;
+	if (isFrameworkMode && authEnabled) {
+		R.error("Void-managed Better Auth is only supported in Void apps. Use Better Auth's official integration for this framework instead.");
+		process.exit(1);
+	}
+	if (isFrameworkMode && bindings.needsSandbox) {
+		R.error("deploy: Cloudflare Sandboxes are currently supported in Void apps only.");
+		process.exit(1);
+	}
+	const sandboxConfig = bindings.needsSandbox ? resolveSandboxConfig(deployConfig, root) : void 0;
+	if (bindings.needsSandbox && requiresSandboxPlatformImage(deployConfig)) {
+		R.error("deploy: `sandbox.image` points at a local Dockerfile. Add `sandbox.platformImage` with a pushed registry image for `void deploy`, or deploy this sandbox directly with Wrangler.");
+		process.exit(1);
+	}
+	const clientDir = join(distDir, "client");
+	const { headerRules, redirectRules, fallbackRules, redundantForceOn3xx } = mergeRoutingRules({
+		dir: clientDir,
+		routing: deployConfig.routing
+	});
+	warnRedundantForceOn3xx(redundantForceOn3xx);
+	lintDuplicateSources(redirectRules, "redirects/rewrites (pre-asset)");
+	lintDuplicateSources(fallbackRules, "fallbacks (post-asset)");
+	lintDestinationSplats(redirectRules, "redirects/rewrites (pre-asset)");
+	lintDestinationSplats(fallbackRules, "fallbacks (post-asset)");
+	const migrationsDir = join(root, "db", "migrations");
+	assertDeploySchemaDriftFree(root, dialect);
+	const rawMigrations = collectMigrations(migrationsDir);
+	let validatedMigrations;
+	try {
+		assertJournalCoherence(migrationsDir, rawMigrations);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (rawMigrations.length > 0) try {
+		validatedMigrations = validateMigrations(rawMigrations);
+		R.info(`Found ${validatedMigrations.length} migration(s)`);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (dialect === "postgresql" && (effectiveBindings.needsD1 || rawMigrations.length > 0)) try {
+		if (!(await client.getResources(config.projectId)).some((resource) => resource.type === "hyperdrive")) {
+			const { text: promptText, isCancel: isCancelPrompt } = await import("./dist-Dayj3gCK.mjs").then((n) => n.p);
+			const connectionString = await promptText({
+				message: "Your project uses PostgreSQL. Enter your connection string:",
+				placeholder: "postgresql://user:pass@host:5432/dbname",
+				validate(value) {
+					if (!value?.startsWith("postgres://") && !value?.startsWith("postgresql://")) return "Must start with \"postgres://\" or \"postgresql://\"";
+				}
+			});
+			if (isCancelPrompt(connectionString)) {
+				R.info("Deploy cancelled.");
+				process.exit(0);
+			}
+			await client.provisionDatabase(config.projectId, connectionString);
+			R.success("Hyperdrive provisioned.");
+		}
+	} catch {}
+	const workerDirName = resolveWorkerDirName(distDir, fwPreset, frameworkBuildCmd);
+	const schedules = scanJobsSync(root).flatMap((job) => job.crons.map((cron) => ({
+		name: job.name,
+		cron
+	})));
+	const routeScan = await scanRoutes(root, { output: deployConfig.output });
+	const webSockets = routeScan.websockets ?? scanWebSocketRoutesSync(root);
+	const queues = scanQueuesSync(root).map((q) => ({
+		name: q.name,
+		bindingName: q.bindingName,
+		...q.maxBatchSize != null && { maxBatchSize: q.maxBatchSize },
+		...q.maxBatchTimeout != null && { maxBatchTimeout: q.maxBatchTimeout }
+	}));
+	const hasPages = existsSync(join(root, "pages"));
+	const hasRoutes = routeScan.routes.length > 0;
+	const hasMiddleware = routeScan.middleware.length > 0;
+	const hasWebSockets = webSockets.length > 0;
+	const isSsr = isFrameworkMode ? true : Boolean(validateSsrEntry(root)) || hasPages && deployConfig.output !== "static";
+	const vcRevalidate = readConfig(root).routing?.revalidate;
+	let revalidate;
+	if (vcRevalidate != null) revalidate = vcRevalidate;
+	const pageScan = existsSync(join(root, "pages")) ? routeScan.pages.pages.length > 0 ? routeScan.pages : await scanPages(root, { output: deployConfig.output }) : null;
+	if (pageScan) {
+		const perPageRules = {};
+		for (const page of pageScan.pages) if (page.revalidate != null) perPageRules[page.pattern] = page.revalidate;
+		if (Object.keys(perPageRules).length > 0) if (typeof revalidate === "number") revalidate = Object.fromEntries([...Object.entries(perPageRules), ["*", revalidate]]);
+		else if (typeof revalidate === "object") revalidate = Object.fromEntries([...Object.entries(perPageRules), ...Object.entries(revalidate)]);
+		else revalidate = perPageRules;
+	}
+	if (deployConfig.output === "static" && pageScan && !isSsr) {
+		if (pageScan.pages.every((p) => p.prerender && (p.params.length === 0 && !p.catchAll || p.hasGetPrerenderPaths)) && !(hasRoutes || hasMiddleware || hasWebSockets || authEnabled) && schedules.length === 0 && queues.length === 0) {
+			R.info("All pages prerendered — deploying as static site");
+			return runStaticDeploy(root, config, client, {
+				buildCommand: null,
+				outputDir: clientDir,
+				appType: "static"
+			}, true, commit, assetsPrefix, headerRules, redirectRules, fallbackRules);
+		}
+	}
+	const uniquePrerenderPaths = deployConfig.output === "static" || isFrameworkMode ? [] : isNodeTarget(deployConfig.target) ? await collectPrerenderPathsNode({
+		root,
+		ssrDir: join(distDir, "ssr"),
+		clientDir
+	}) : await collectPrerenderPaths({
+		root,
+		workerDir: join(distDir, workerDirName),
+		clientDir,
+		persistDir: join(root, ".void"),
+		remoteMode: resolveRemoteMode(deployConfig.remote),
+		projectId: config.projectId
+	});
+	const wranglerCompat = resolveDeployWranglerCompat(root, deployConfig, join(distDir, workerDirName));
+	const envVars = loadDeployEnv(root);
+	await assertEnvSchemaValid(root, client, config.projectId);
+	await applySchemaDefaultsToVars(root, envVars);
+	const s = createSpinner();
+	const onProgress = (msg) => s.message(msg);
+	const assetConfig = resolveAssetConfig({
+		isSsr,
+		hasPages,
+		hasRoutes,
+		hasMiddleware,
+		hasWebSockets,
+		authEnabled
+	});
+	s.start("Checking for changes...");
+	const { assetManifest } = await collectAndHashAssets(clientDir, onProgress);
+	const { needed, skipped } = await client.preflight(config.projectId, assetManifest, true);
+	s.stop("Checked for changes");
+	if (skipped > 0) R.info(`Skipping ${skipped} unchanged asset(s)`);
+	s.start("Packaging...");
+	const neededSet = skipped > 0 ? new Set(needed) : null;
+	const formData = await packageBuild(distDir, workerDirName, effectiveBindings, validatedMigrations, schedules, isSsr || hasRoutes || hasMiddleware || hasWebSockets || authEnabled, isFrameworkMode ? detected.name : void 0, revalidate, envVars, queues, uniquePrerenderPaths, assetConfig, {
+		compatibilityDate: wranglerCompat?.compatibilityDate,
+		compatibilityFlags: wranglerCompat?.compatibilityFlags,
+		...sandboxConfig && { sandbox: sandboxConfig },
+		revalidateQueryAllowlist: deployConfig.routing?.revalidateQueryAllowlist
+	}, neededSet, assetsPrefix, headerRules, redirectRules, fallbackRules, dialect, webSockets, onProgress);
+	formData.append("assetManifest", JSON.stringify(assetManifest));
+	formData.append("source", getTokenSource());
+	if (commit) formData.append("commit", commit);
+	const result = await streamDeploy(client, config.projectId, formData, s);
+	const summary = [`${result.workers} worker module(s), ${formatKnownAssetSummary(result, skipped)}`];
+	if (result.migrations) summary.push(`${result.migrations} migration(s) applied`);
+	if (schedules.length > 0) summary.push(`${schedules.length} cron job(s) scheduled`);
+	if (queues.length > 0) summary.push(`${queues.length} queue(s) configured`);
+	if (uniquePrerenderPaths.length > 0) summary.push(`${uniquePrerenderPaths.length} page(s) prerendered`);
+	if (isSsr) summary.push("SSR enabled");
+	if (revalidate) if (typeof revalidate === "number") summary.push(`ISR revalidate: ${revalidate}s`);
+	else summary.push(`ISR revalidate: ${Object.keys(revalidate).length} path rule(s)`);
+	if (isFrameworkMode) summary.push("Framework mode");
+	Se(summary.join("\n"), result.url);
+	ye("Done!");
+}
+async function createProjectFromSlug(root, client, slug) {
+	R.step(`Creating project ${import_picocolors.default.blue(slug)}...`);
+	const project = await client.createProject(slug);
+	const config = {
+		projectId: project.id,
+		slug: project.slug
+	};
+	writeProjectConfig(root, config);
+	R.success(`Project created: ${import_picocolors.default.blue(config.slug)}`);
+	return config;
+}
+function getGitCommit(root) {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", {
+			cwd: root,
+			stdio: "ignore"
+		});
+		if (execSync("git status --porcelain", {
+			cwd: root,
+			encoding: "utf-8"
+		}).trim() !== "") return null;
+		return execSync("git rev-parse HEAD", {
+			cwd: root,
+			encoding: "utf-8"
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+function assertDeploySchemaDriftFree(root, dialect) {
+	try {
+		if (!hasDeploySchemaDrift(root, dialect)) return;
+	} catch (error) {
+		R.error(getErrorMessage(error));
+		process.exit(1);
+	}
+	R.error(getDeploySchemaDriftMessage());
+	process.exit(1);
+}
+function hasDeploySchemaDrift(root, dialect) {
+	if (!discoverSchema(root)) return false;
+	const driftRoot = mkDeployDriftCheckRoot();
+	const driftProjectRoot = join(driftRoot, "project");
+	rmSync(driftRoot, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(driftRoot, { recursive: true });
+	createDeployDriftProject(root, driftProjectRoot);
+	try {
+		const migrationsDir = join(driftProjectRoot, "db", "migrations");
+		const before = snapshotDir(migrationsDir);
+		const driftConfigPath = writeDrizzleConfig(driftProjectRoot, dialect === "postgresql" ? "postgresql://dummy" : ":memory:", dialect);
+		execFileSync(process.execPath, [
+			drizzleKitBin,
+			"generate",
+			"--config",
+			driftConfigPath
+		], {
+			cwd: driftProjectRoot,
+			stdio: "pipe"
+		});
+		return !migrationSnapshotsEqual(before, snapshotDir(migrationsDir));
+	} catch (error) {
+		throw new Error(formatDeploySchemaDriftCheckError(error));
+	} finally {
+		rmSync(driftRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function getDeploySchemaDriftMessage() {
+	return ["Schema drift detected between your Drizzle schema and db/migrations/.", "Run `void db generate`, review the generated migration, commit it yourself, then rerun `void deploy`."].join("\n");
+}
+function formatDeploySchemaDriftCheckError(error) {
+	const detail = extractExecErrorOutput(error);
+	return [
+		"Failed to check Drizzle schema drift during deploy.",
+		"Run `void db generate` locally, fix any reported issues, review the generated migration, commit it yourself, then rerun `void deploy`.",
+		...detail ? [detail] : []
+	].join("\n\n");
+}
+function extractExecErrorOutput(error) {
+	if (!error || typeof error !== "object") return "";
+	const details = [];
+	const stderr = "stderr" in error ? bufferToString(error.stderr) : "";
+	const stdout = "stdout" in error ? bufferToString(error.stdout) : "";
+	if (stderr) details.push(stderr);
+	if (stdout) details.push(stdout);
+	return details.join("\n").trim();
+}
+function bufferToString(value) {
+	if (typeof value === "string") return value.trim();
+	if (value instanceof Buffer) return value.toString("utf-8").trim();
+	return "";
+}
+function createDeployDriftProject(root, driftProjectRoot) {
+	mkdirSync(driftProjectRoot, { recursive: true });
+	for (const entry of readdirSync(root, { withFileTypes: true })) {
+		if (entry.name === ".git" || entry.name === ".void" || entry.name === "node_modules") continue;
+		if (entry.name === "dist" || entry.name === "build" || entry.name === ".wrangler" || entry.name === ".turbo" || entry.name === ".next" || entry.name === ".svelte-kit" || entry.name === ".output") continue;
+		const source = join(root, entry.name);
+		const target = join(driftProjectRoot, entry.name);
+		if (entry.name === "db") {
+			cpSync(source, target, { recursive: true });
+			continue;
+		}
+		symlinkSync(source, target, entry.isDirectory() ? symlinkDirType() : "file");
+	}
+	const nodeModules = findNearestNodeModules(root);
+	if (nodeModules) symlinkSync(nodeModules, join(driftProjectRoot, "node_modules"), symlinkDirType());
+}
+function findNearestNodeModules(root) {
+	let current = root;
+	while (true) {
+		const candidate = join(current, "node_modules");
+		if (existsSync(candidate)) return candidate;
+		const parent = resolve(current, "..");
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function mkDeployDriftCheckRoot() {
+	return join(tmpdir(), `${deployDriftCheckDir.replaceAll("/", "-").replaceAll("\\", "-")}-${Date.now()}`);
+}
+function symlinkDirType() {
+	return process.platform === "win32" ? "junction" : "dir";
+}
+function snapshotDir(root) {
+	if (!existsSync(root)) return {};
+	const snapshot = {};
+	collectSnapshotFiles(root, root, snapshot);
+	return snapshot;
+}
+function collectSnapshotFiles(current, root, snapshot) {
+	for (const entry of readdirSync(current, { withFileTypes: true })) {
+		const fullPath = join(current, entry.name);
+		if (entry.isDirectory()) {
+			collectSnapshotFiles(fullPath, root, snapshot);
+			continue;
+		}
+		snapshot[relative(root, fullPath)] = readFileSync(fullPath, "utf-8");
+	}
+}
+function migrationSnapshotsEqual(left, right) {
+	const leftEntries = Object.entries(left).sort(([a], [b]) => a.localeCompare(b));
+	const rightEntries = Object.entries(right).sort(([a], [b]) => a.localeCompare(b));
+	if (leftEntries.length !== rightEntries.length) return false;
+	return leftEntries.every(([leftPath, leftContent], index) => {
+		const [rightPath, rightContent] = rightEntries[index] ?? [];
+		return leftPath === rightPath && leftContent === rightContent;
+	});
+}
+/**
+* Overlay schema `.default(value)` entries onto the deploy manifest vars so
+* the deployed worker sees the same fallback as the typed `env.X` proxy at
+* runtime. User-provided `.env*` values always win — defaults only fill
+* gaps. No-op when the project has no `env.ts`.
+*/
+async function applySchemaDefaultsToVars(root, envVars) {
+	const defaults = await getDeployEnvDefaults(root);
+	for (const [key, value] of Object.entries(defaults)) if (envVars[key] === void 0) envVars[key] = value;
+}
+/**
+* If the project has an `env.ts`, validate its schema against the union of
+* production env files and remote secret names. Hard-error before upload so
+* deploys never ship missing required env vars.
+*/
+async function assertEnvSchemaValid(root, client, projectId) {
+	if (findEnvFile(root) == null) return;
+	const { hasSchema, report } = await validateProdEnv(root, {
+		productionOnly: true,
+		remoteSecrets: await fetchRemoteSecretNames(client, projectId)
+	});
+	if (!hasSchema || report.valid) return;
+	const formatted = formatEnvReport(report);
+	R.error(`Env validation failed:\n${formatted}`);
+	if (report.missing.length > 0) R.info(`Add the missing values to .env / .env.production, or upload them with \`void secret put <NAME>\`.`);
+	throw new DeployEventError("deploy: Aborting because env.ts schema is not satisfied.");
+}
+/**
+* Load env vars for deploy — only .env and .env.production (not .local files).
+* Later files win on conflict.
+*/
+function loadDeployEnv(root) {
+	const files = [".env", ".env.production"];
+	const env = {};
+	for (const file of files) {
+		const filePath = join(root, file);
+		if (!existsSync(filePath)) continue;
+		const content = readFileSync(filePath, "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;
+			const key = trimmed.slice(0, eqIndex).trim();
+			let value = trimmed.slice(eqIndex + 1).trim();
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+			env[key] = value;
+		}
+	}
+	const { sanitized, stripped } = stripInternalEnvKeys(env);
+	if (stripped.length > 0) voidWarn(`Ignoring internal env keys from .env files: ${stripped.join(", ")}. These are reserved for Void runtime use and will not be shipped in the deploy manifest.`);
+	return sanitized;
+}
+/**
+* Resolve the top-level build output directory.
+*
+* When a framework preset is available, uses its workerDir to derive the
+* parent directory (e.g. "build/server" → "build"). This gives framework-
+* specific error messages when the output is missing.
+*
+* For non-framework (Void app) deploys, defaults to "dist".
+*/
+function resolveDistDir(root, fwPreset, buildCommand) {
+	if (fwPreset) {
+		const topDir = fwPreset.workerDir.split("/")[0];
+		const distDir = join(root, topDir);
+		if (!existsSync(distDir)) throw new Error(`deploy: Build output directory '${topDir}' not found. Run '${buildCommand ?? fwPreset.buildCommand}' first.`);
+		return distDir;
+	}
+	return join(root, "dist");
+}
+/**
+* Resolve the worker output subdirectory name within the build dir.
+*
+* When a framework preset is available, uses the preset's workerDir to
+* derive the subdirectory name and gives a framework-specific error.
+*
+* For non-framework (Void app) deploys, probes for known subdirectories.
+*/
+function resolveWorkerDirName(distDir, fwPreset, buildCommand) {
+	if (fwPreset) {
+		const subDir = fwPreset.workerDir.split("/").slice(1).join("/");
+		if (!existsSync(join(distDir, subDir))) throw new Error(`deploy: Worker output '${fwPreset.workerDir}' not found. Run '${buildCommand ?? fwPreset.buildCommand}' first.`);
+		return subDir;
+	}
+	for (const name of [
+		"ssr",
+		"rsc",
+		"server"
+	]) if (existsSync(join(distDir, name))) return name;
+	throw new Error("deploy: Worker output not found. Expected dist/ssr/ or dist/rsc/.");
+}
+//#endregion
+export { resolveSandboxConfig as _, prerenderPagesNode as a, filterLoadedEnv as c, ensureWranglerCompatibilityDate as d, ensureWranglerNodejsAlsFlag as f, isSandboxEnabled as g, SANDBOX_MIGRATION_TAG as h, prerenderPages as i, resolveRemoteMode as l, syncWranglerBindings as m, resolveDistDir as n, DEFAULT_PROXY_URL as o, readWranglerCompat as p, resolveWorkerDirName as r, STAGING_PROXY_URL as s, deploy_exports as t, stripInternalEnvKeys as u };