void 0.10.10 → 0.10.12

package/dist/deploy-B02JyKP9.mjs

@@ -1,3748 +0,0 @@
-import { n as __exportAll } from "./rolldown-runtime-DJK8HYOj.mjs";
-import { a as join, c as resolve, i as isAbsolute, n as dirname, r as extname, s as relative } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { D as outro, E as note, S as confirm, T as log, a as cliTitle, j as isCancel, o as createSpinner, u as import_picocolors, w as intro } from "./agents-Bmr5tFFb.mjs";
-import { i as resolveProjectPaths, n as readProjectPaths } from "./project-paths-tpdR1mJR.mjs";
-import { a as scanQueuesSync, i as scanWebSocketRoutesSync, o as scanJobsSync, r as scanRoutes, s as findVoidAuthConfig } from "./scan-i7Yz54fv.mjs";
-import { t as cfAccessHeaders } from "./cf-access-Bqw81xAf.mjs";
-import { C as ensureCloudflaredToken, S as writeProjectConfig, a as isExpiredTokenError, b as readProjectConfig, f as getToken, i as isCliOutdatedError, m as isStagingMode, n as PlatformClient, o as parsePlatformErrorBody, p as getTokenSource, t as PlatformApiError, u as getApiUrl } from "./client-C9FG6Vzc.mjs";
-import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-BcAeIPe3.mjs";
-import { i as inferProjectBindings, l as validateSsrEntry, n as FRAMEWORK_SCAN_DIRS, r as detectFramework } from "./plugin-inference-CJxi_fWI.mjs";
-import { i as voidWarn, r as voidLog } from "./log-ChfPKsVd.mjs";
-import { n as mergeAndExpand, r as parseDotenvFile } from "./dotenv-D_UbC_vc.mjs";
-import { t as discoverSchema } from "./discover-BuVVSAum.mjs";
-import { t as findEnvFile } from "./env-types-D51bnR-c.mjs";
-import { i as validateProdEnv, n as formatEnvReport, r as getDeployEnvDefaults, t as fetchRemoteSecretNames } from "./env-validation-CeC2FL66.mjs";
-import { n as writeDrizzleConfig } from "./config-BdUctCZD.mjs";
-import { a as buildMigrationPlanBundle, c as collectMigrations, r as validateMigrations, t as assertJournalCoherence } from "./validate-DT7nFMlf.mjs";
-import { t as scanPages } from "./scan-Dp_Gyzs3.mjs";
-import { n as STAGING_PROXY_URL, t as DEFAULT_PROXY_URL } from "./proxy-D-3_D-Gl.mjs";
-import { i as promptProjectSetupAction, n as promptAndCreateProject, r as promptProjectSelection } from "./create-project-CjYX23M_.mjs";
-import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-D2HI3TrG.mjs";
-import { t as collectGitDeployMetadata } from "./git-metadata-CBKaL0v5.mjs";
-import { n as lintDuplicateSources, r as mergeRoutingRules, t as lintDestinationSplats } from "./headers-CTAjX-UO.mjs";
-import { t as promptForLoginToken } from "./login-CrOTnR_6.mjs";
-import { i as resolveProjectCommand, n as detectPreset, r as formatProjectCommand, t as FRAMEWORK_PRESETS } from "./preset-CVvwCeIy.mjs";
-import { createRequire } from "node:module";
-import { copyFileSync, cpSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { build, loadEnv } from "vite";
-import { createHash } from "node:crypto";
-import { homedir } from "node:os";
-import { execFile, execSync, spawnSync } from "node:child_process";
-import { parse } from "jsonc-parser";
-import { hash } from "blake3-jit";
-import ignore from "ignore";
-//#region src/asset-routing.ts
-function isApiRoutePattern(pattern) {
-	return pattern === "/api" || pattern.startsWith("/api/");
-}
-function hasDocumentRoutes(routes) {
-	return routes.some((route) => !isApiRoutePattern(route.pattern));
-}
-function hasApiRoutes(routes) {
-	return routes.some((route) => isApiRoutePattern(route.pattern));
-}
-/**
-* Returns true when browser document navigations must reach the worker before
-* a static asset fallback can serve HTML.
-*/
-function workerOwnsHtmlRouting(inputs) {
-	return inputs.isSsr || inputs.hasPages || inputs.hasDocumentRoutes || inputs.hasMiddleware || inputs.hasWebSockets === true || inputs.liveEnabled === true;
-}
-function resolveAssetConfig(inputs) {
-	return resolveAssetRoutingPolicy(inputs).assetConfig;
-}
-const VOID_INTERNAL_WORKER_FIRST = ["/__void", "/__void/*"];
-function resolveAssetRoutingPolicy(inputs) {
-	const workerFirst = workerOwnsHtmlRouting(inputs);
-	const apiWorkerFirst = !workerFirst && (inputs.hasApiRoutes === true || inputs.authEnabled === true);
-	return {
-		assetConfig: workerFirst ? {
-			not_found_handling: "none",
-			run_worker_first: ["/**"]
-		} : apiWorkerFirst ? {
-			not_found_handling: "single-page-application",
-			run_worker_first: [
-				"/api",
-				"/api/*",
-				...VOID_INTERNAL_WORKER_FIRST
-			]
-		} : {
-			not_found_handling: "single-page-application",
-			run_worker_first: [...VOID_INTERNAL_WORKER_FIRST]
-		},
-		apiWorkerFirst,
-		workerFirst,
-		workerSpaFallback: workerFirst && !inputs.isSsr && !inputs.hasPages
-	};
-}
-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 NODEJS_COMPAT_FLAG = "nodejs_compat";
-const VOID_CONFIG_FILE = "void.json";
-const DEFAULT_LIVE_BINDING = "VOID_LIVE";
-const DEFAULT_LIVE_CLASS = "VoidLiveStreamDurableObject";
-const LIVE_MIGRATION_TAG = "live-v1";
-/** Latest compatibility date the Void test suite is pinned against. */
-const LATEST_KNOWN_COMPAT_DATE = "2026-02-24";
-function normalizeWranglerCompatibilityFlags(flags, options) {
-	const existingFlags = flags ?? [];
-	if (options?.needsNodejsCompat && !existingFlags.includes(NODEJS_COMPAT_FLAG)) return [...existingFlags.filter((flag) => flag !== NODEJS_ALS_FLAG), NODEJS_COMPAT_FLAG];
-	if (existingFlags.length === 0 || !existingFlags.includes(NODEJS_ALS_FLAG) && !existingFlags.includes(NODEJS_COMPAT_FLAG)) return [...existingFlags, NODEJS_ALS_FLAG];
-	return flags;
-}
-function hasDurableObjectSqliteMigration(migrations, className) {
-	return migrations.some((migration) => migration.new_sqlite_classes?.includes(className));
-}
-function nextDurableObjectMigrationTag(migrations, baseTag) {
-	const existingTags = new Set(migrations.map((migration) => migration.tag).filter(Boolean));
-	if (!existingTags.has(baseTag)) return baseTag;
-	let index = 2;
-	while (existingTags.has(`${baseTag}-${index}`)) index++;
-	return `${baseTag}-${index}`;
-}
-function resolveLiveBindingConfig(root, options) {
-	const durableObjectBindings = [...readWranglerDurableObjectBindings(root), ...options?.existingBindings ?? []];
-	const generated = findGeneratedLiveBinding(durableObjectBindings);
-	if (generated) return {
-		bindingName: generated.name,
-		className: generated.class_name
-	};
-	const usedBindings = /* @__PURE__ */ new Set([...durableObjectBindings.map((binding) => binding.name), ...(options?.reservedBindings ?? []).filter((name) => typeof name === "string")]);
-	const usedClasses = /* @__PURE__ */ new Set([...durableObjectBindings.map((binding) => binding.class_name), ...(options?.reservedClasses ?? []).filter((name) => typeof name === "string")]);
-	return {
-		bindingName: resolveGeneratedName(DEFAULT_LIVE_BINDING, usedBindings, "binding"),
-		className: resolveGeneratedName(DEFAULT_LIVE_CLASS, usedClasses, "class")
-	};
-}
-function readExistingLiveBindingConfig(root) {
-	const generated = findGeneratedLiveBinding(readWranglerDurableObjectBindings(root));
-	return generated ? {
-		bindingName: generated.name,
-		className: generated.class_name
-	} : void 0;
-}
-function readWranglerDurableObjectBindings(root) {
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) try {
-		const bindings = parseJsonc(readFileSync(join(root, name), "utf-8")).durable_objects?.bindings;
-		if (!Array.isArray(bindings)) return [];
-		return bindings.filter((binding) => typeof binding.name === "string" && typeof binding.class_name === "string");
-	} catch {}
-	return [];
-}
-function isGeneratedLiveName(name, base) {
-	return name === base || name.match(generatedLiveNamePattern(base)) !== null;
-}
-function generatedLiveNamePattern(base) {
-	return new RegExp(`^${escapeRegExp(base)}_[0-9a-f]{8}$`);
-}
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function findGeneratedLiveBinding(bindings) {
-	return bindings.find((binding) => isGeneratedLiveName(binding.name, "VOID_LIVE") && isGeneratedLiveName(binding.class_name, "VoidLiveStreamDurableObject"));
-}
-function resolveGeneratedName(base, used, kind) {
-	if (!used.has(base)) return base;
-	for (let attempt = 0;; attempt++) {
-		const candidate = `${base}_${createHash("sha256").update(`void/live:${kind}:${base}:${attempt}`).digest("hex").slice(0, 8)}`;
-		if (!used.has(candidate)) return candidate;
-	}
-}
-/**
-* Read compatibility settings from `wrangler.jsonc`/`wrangler.json`,
-* `void.json`, and build output, with priority:
-* void.json > wrangler.jsonc > build output > latest known-good date.
-*
-* This function is read-only: when no explicit `compatibility_date` exists, it
-* returns the latest known-good date without writing it anywhere. Use
-* `ensureWranglerCompat()` when the caller is in a real dev/build/deploy
-* lifecycle and wants to persist the default in `void.json`.
-*
-* @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) {
-	return resolveWranglerCompat(readWranglerCompatFields(root, config, buildOutputDir));
-}
-/**
-* Read compatibility settings and ensure the default date is pinned in
-* `void.json` when no explicit date exists in void.json, wrangler config, or
-* build output.
-*/
-function ensureWranglerCompat(root, config, buildOutputDir) {
-	const fields = readWranglerCompatFields(root, config, buildOutputDir);
-	const defaultDate = fields.voidDate ?? fields.wranglerDate ?? fields.buildDate ? void 0 : ensureVoidCompatibilityDate(root, fields.voidConfig);
-	return resolveWranglerCompat(fields, defaultDate ? { defaultDate } : void 0);
-}
-function readWranglerCompatFields(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");
-	return {
-		voidConfig,
-		voidDate,
-		voidFlags,
-		wranglerDate,
-		wranglerFlags,
-		buildDate,
-		buildFlags
-	};
-}
-function resolveWranglerCompat(fields, options) {
-	const result = { compatibilityDate: fields.voidDate ?? fields.wranglerDate ?? fields.buildDate ?? options?.defaultDate ?? "2026-02-24" };
-	const flags = fields.voidFlags ?? fields.wranglerFlags ?? fields.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 (bindings.needsLive || options?.live) {
-		const existingDurableObjectBindings = parsed.durable_objects?.bindings ?? [];
-		const liveConfig = typeof options?.live === "object" ? options.live : resolveLiveBindingConfig(root, {
-			existingBindings: existingDurableObjectBindings,
-			reservedBindings: options?.websockets?.map((route) => route.bindingName),
-			reservedClasses: [...options?.websockets?.map((route) => route.className) ?? [], options?.sandbox?.className]
-		});
-		if (!existingDurableObjectBindings.some((binding) => binding.name === liveConfig.bindingName)) {
-			parsed.durable_objects = { bindings: [...existingDurableObjectBindings, {
-				name: liveConfig.bindingName,
-				class_name: liveConfig.className
-			}] };
-			modified = true;
-		}
-		const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
-		if (!hasDurableObjectSqliteMigration(migrations, liveConfig.className)) {
-			parsed.migrations = [...migrations, {
-				tag: nextDurableObjectMigrationTag(migrations, LIVE_MIGRATION_TAG),
-				new_sqlite_classes: [liveConfig.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 = /* @__PURE__ */ 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/isr-config.ts
-/**
-* Whether a resolved `revalidate` value represents an active ISR configuration.
-*
-* Mirrors the presence check used when writing the deploy manifest
-* (`packages/void/src/cli/package.ts`): `null`/`undefined`/`0`/`{}` are treated
-* as "no ISR", a positive number or a non-empty path map is treated as "ISR on".
-*/
-function hasRevalidate(r) {
-	if (r == null) return false;
-	if (typeof r === "number") return r > 0;
-	if (typeof r === "object") return Object.keys(r).length > 0;
-	return false;
-}
-/**
-* Merge the app's `void.json` `routing.revalidate` config with per-page
-* `export const revalidate` rules discovered by the page scan, producing the
-* final revalidate map that gets baked into the deploy manifest (managed
-* `void deploy`) or the self-hosted worker build.
-*
-* This is the single source of truth for the merge so the managed and
-* self-host build paths cannot diverge. Behaviour is preserved verbatim from
-* the original inline logic in `void deploy`:
-*
-* - Config value seeds the result (`number | Record<string, number> | undefined`).
-* - Per-page rules (page pattern → revalidate seconds) are collected from the
-*   already-computed page scan (`null` when the app has no pages dir).
-* - When there are per-page rules:
-*   - config is a plain number → path map with per-page entries first and the
-*     config number applied to `"*"` as a fallback;
-*   - config is an object map → per-page entries first (higher precedence in
-*     first-match ordering), then the config entries;
-*   - config is absent → the per-page rules alone.
-* - Empty results (no config, no per-page rules) return `undefined`.
-*/
-function collectRevalidate(config, pageScan) {
-	const vcRevalidate = config.routing?.revalidate;
-	let revalidate;
-	if (vcRevalidate != null) revalidate = vcRevalidate;
-	if (pageScan) {
-		const perPageRules = {};
-		for (const page of pageScan.pages) if (page.revalidate != null) {
-			const key = page.pattern.replace(/:[A-Za-z0-9_]+\{[^}]*\}/g, "*");
-			perPageRules[key] = 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;
-	}
-	return revalidate;
-}
-//#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 = [.../* @__PURE__ */ 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 = ensureWranglerCompat(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 url = new URL(request.url);
-		const filePath = join(clientDir, 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;
-}
-function appendLogLine(message, logPath) {
-	return logPath ? `${message}\nDetailed log: ${logPath}` : message;
-}
-function appendTrailingLines(message, deploymentId, logPath) {
-	return appendLogLine(appendDeploymentLine(message, deploymentId), logPath);
-}
-/**
-* Format a server-emitted `event: 'error'` payload with an optional deployment id.
-*/
-function formatDeployFailureMessage(message, deploymentId, logPath) {
-	return appendTrailingLines(message, deploymentId, logPath);
-}
-/**
-* 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, logPath) {
-	return appendTrailingLines("deploy: Connection lost during deploy.", deploymentId, logPath);
-}
-/**
-* 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, logPath) {
-	if (err instanceof PlatformApiError) {
-		const parsed = parsePlatformErrorBody(err.body);
-		const parsedError = parsed?.error ?? parsed?.message ?? null;
-		const effectiveDeploymentId = parsed?.deployment ?? null ?? deploymentId;
-		if (isCliOutdatedError(err) && parsed?.message) return new Error(appendTrailingLines(parsed.message, effectiveDeploymentId, logPath));
-		if (err.status === 409 && parsedError) return new Error(appendTrailingLines(`deploy: Deploy failed: ${parsedError}`, effectiveDeploymentId, logPath));
-		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(appendTrailingLines(base, effectiveDeploymentId, logPath));
-	}
-	const original = err instanceof Error ? err.message : String(err);
-	return new Error(appendTrailingLines(`deploy: Connection lost during deploy: '${original}'.`, deploymentId, logPath));
-}
-/**
-* Maximum retry attempts for a single R2 PUT before giving up. Matched to
-* the design doc 0068 spec: 5xx triggers retry, 4xx surfaces immediately.
-*/
-const MAX_R2_PUT_RETRIES = 3;
-/**
-* Retry backoff delays in milliseconds. After attempt `i` fails (5xx) we
-* sleep `RETRY_BACKOFF_MS[i]` before retrying. Indexed from 0; once the
-* array is exhausted we surface the error.
-*/
-const RETRY_BACKOFF_MS = [
-	250,
-	500,
-	1e3
-];
-var DirectR2PutError = class extends Error {
-	status;
-	hash;
-	path;
-	/**
-	* `body` is the response body text (may be empty / non-text). Useful in
-	* the surface error so users can correlate against R2-side errors like
-	* `BadDigest` (Content-MD5 mismatch) or signature errors.
-	*/
-	body;
-	constructor(status, hash, path, body) {
-		super(`R2 PUT failed for ${path} (${hash}): ${status}${body ? ` ${body}` : ""}`);
-		this.name = "DirectR2PutError";
-		this.status = status;
-		this.hash = hash;
-		this.path = path;
-		this.body = body;
-	}
-};
-/**
-* Issue direct-to-R2 PUTs for every item in `items`, bounded to
-* `R2_PUT_CONCURRENCY`. Surfaces the first failure (4xx immediately, 5xx
-* after retry exhaustion) as a `DirectR2PutError` carrying the asset path
-* and hash so the user can correlate against the JSONL log.
-*
-* Logs `r2_put_start` / `r2_put_end` per asset, plus `r2_put_retry` on
-* each retry attempt. Per-asset durations help identify slow uploads.
-*
-* Memory: each successful PUT clears `item.body` and invokes `onAfterPut`
-* so the caller can drop its own ref (e.g. delete from the in-memory
-* `assetFiles` cache). For huge deploys this keeps peak memory bounded by
-* the upload concurrency rather than the total bundle size.
-*/
-async function uploadAssetsToR2(items, cliLog, fetchImpl = fetch, onAfterPut) {
-	if (items.length === 0) return;
-	let firstError = null;
-	let nextIndex = 0;
-	const workerCount = Math.min(10, items.length);
-	const workers = [];
-	for (let w = 0; w < workerCount; w++) workers.push((async () => {
-		while (firstError === null) {
-			const i = nextIndex++;
-			if (i >= items.length) return;
-			try {
-				await uploadOne(items[i], cliLog, fetchImpl);
-			} catch (err) {
-				if (firstError === null) firstError = err;
-				return;
-			}
-			items[i].body = void 0;
-			onAfterPut?.(items[i]);
-		}
-	})());
-	await Promise.all(workers);
-	if (firstError !== null) throw firstError;
-}
-async function uploadOne(item, cliLog, fetchImpl) {
-	if (!item.body) throw new Error(`internal: uploadOne invoked for ${item.path} with no body`);
-	const body = item.body;
-	const startedAt = Date.now();
-	cliLog?.info("r2_put_start", {
-		hash: item.hash,
-		path: item.path,
-		sizeBytes: body.length
-	});
-	let attempt = 0;
-	while (true) {
-		let res;
-		try {
-			res = await fetchImpl(item.url, {
-				method: "PUT",
-				body: new Uint8Array(body),
-				headers: item.headers
-			});
-		} catch (err) {
-			if (attempt < MAX_R2_PUT_RETRIES) {
-				cliLog?.warn("r2_put_retry", {
-					hash: item.hash,
-					path: item.path,
-					attempt: attempt + 1,
-					status: 0,
-					error: err instanceof Error ? err.message : String(err)
-				});
-				await sleep(RETRY_BACKOFF_MS[attempt]);
-				attempt++;
-				continue;
-			}
-			cliLog?.error("r2_put_end", err, {
-				hash: item.hash,
-				path: item.path,
-				durationMs: Date.now() - startedAt,
-				status: 0
-			});
-			throw new DirectR2PutError(0, item.hash, item.path, err instanceof Error ? err.message : String(err));
-		}
-		if (res.ok) {
-			cliLog?.info("r2_put_end", {
-				hash: item.hash,
-				path: item.path,
-				durationMs: Date.now() - startedAt,
-				status: res.status
-			});
-			return;
-		}
-		const errBody = await safeReadText(res);
-		if (res.status >= 500 && attempt < MAX_R2_PUT_RETRIES) {
-			cliLog?.warn("r2_put_retry", {
-				hash: item.hash,
-				path: item.path,
-				attempt: attempt + 1,
-				status: res.status,
-				body: truncate(errBody)
-			});
-			await sleep(RETRY_BACKOFF_MS[attempt]);
-			attempt++;
-			continue;
-		}
-		cliLog?.error("r2_put_end", void 0, {
-			hash: item.hash,
-			path: item.path,
-			durationMs: Date.now() - startedAt,
-			status: res.status,
-			body: truncate(errBody)
-		});
-		throw new DirectR2PutError(res.status, item.hash, item.path, truncate(errBody));
-	}
-}
-async function safeReadText(res) {
-	try {
-		return await res.text();
-	} catch {
-		return "";
-	}
-}
-function truncate(s) {
-	return s.length > 500 ? `${s.slice(0, 500)}...` : s;
-}
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-//#endregion
-//#region src/cli/github-oidc.ts
-/**
-* GitHub Actions OIDC → Void deploy-token exchange.
-*
-* When `void deploy` runs inside GitHub Actions with no explicit `VOID_TOKEN`,
-* the CLI mints a short-lived GitHub OIDC token (audience `void`) and exchanges
-* it at `POST $VOID_API_URL/auth/github-oidc` for a short-lived, project-scoped
-* Void deploy token. Doing the exchange in-process lets the scaffolded workflow
-* collapse to a single `void deploy` step — no curl/jq token-exchange step.
-*
-* Server contract (platform `POST /auth/github-oidc` handler):
-*   request  { oidcToken: string, project: string }   (project = slug)
-*   response { token: string, projectId, buildId }
-*/
-const OIDC_AUDIENCE = "void";
-/**
-* True when the process is running inside GitHub Actions with the OIDC token
-* request endpoint available — i.e. the workflow granted
-* `permissions: id-token: write`, so GitHub injected the request URL + token.
-*/
-function isGithubActionsOidcAvailable(env = process.env) {
-	return env.GITHUB_ACTIONS === "true" && typeof env.ACTIONS_ID_TOKEN_REQUEST_URL === "string" && env.ACTIONS_ID_TOKEN_REQUEST_URL.length > 0 && typeof env.ACTIONS_ID_TOKEN_REQUEST_TOKEN === "string" && env.ACTIONS_ID_TOKEN_REQUEST_TOKEN.length > 0;
-}
-/**
-* Mint a GitHub Actions OIDC token (audience `void`) and exchange it for a
-* short-lived, project-scoped Void deploy token.
-*
-* Two hops:
-*   1. GET  $ACTIONS_ID_TOKEN_REQUEST_URL&audience=void  (Bearer request token)
-*        → `.value` is the OIDC JWT.
-*   2. POST $apiUrl/auth/github-oidc  { oidcToken, project }
-*        → `.token` is the Void deploy token.
-*
-* Throws a clear, actionable error (including the HTTP status and server error
-* body when available) on any non-OK response or missing field.
-*/
-async function exchangeGithubOidcForDeployToken(apiUrl, project, env = process.env) {
-	const requestUrl = env.ACTIONS_ID_TOKEN_REQUEST_URL;
-	const requestToken = env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
-	if (!requestUrl || !requestToken) throw new Error("github-oidc: GitHub Actions OIDC is unavailable (missing ACTIONS_ID_TOKEN_REQUEST_URL/TOKEN). Ensure the workflow grants `permissions: id-token: write`.");
-	return exchangeOidcTokenAtApi(apiUrl, project, await requestGithubOidcToken(requestUrl, requestToken));
-}
-/**
-* GET the GitHub Actions OIDC token for audience `void`. GitHub's request URL
-* already carries a query string, so `audience` is appended alongside it.
-*/
-async function requestGithubOidcToken(requestUrl, requestToken) {
-	const url = new URL(requestUrl);
-	url.searchParams.set("audience", OIDC_AUDIENCE);
-	let res;
-	try {
-		res = await fetch(url, { headers: { Authorization: `Bearer ${requestToken}` } });
-	} catch (err) {
-		throw new Error(`github-oidc: Failed to reach the GitHub OIDC token endpoint: ${errText(err)}`);
-	}
-	if (!res.ok) {
-		const body = await safeText(res);
-		throw new Error(`github-oidc: Failed to mint a GitHub OIDC token (${res.status})${body ? `: ${body}` : ""}.`);
-	}
-	let body;
-	try {
-		body = await res.json();
-	} catch {
-		throw new Error("github-oidc: GitHub OIDC token endpoint returned an invalid response.");
-	}
-	const value = body?.value;
-	if (typeof value !== "string" || value.length === 0) throw new Error("github-oidc: GitHub OIDC token endpoint did not return a token value.");
-	return value;
-}
-/** POST the OIDC JWT to the Void API and return the minted deploy token. */
-async function exchangeOidcTokenAtApi(apiUrl, project, oidcToken) {
-	const url = `${apiUrl.endsWith("/") ? apiUrl.slice(0, -1) : apiUrl}/auth/github-oidc`;
-	ensureCloudflaredToken(apiUrl);
-	let res;
-	try {
-		res = await fetch(url, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				...cfAccessHeaders(process.env)
-			},
-			body: JSON.stringify({
-				oidcToken,
-				project
-			})
-		});
-	} catch (err) {
-		throw new Error(`github-oidc: Failed to reach ${url}: ${errText(err)}`);
-	}
-	if (!res.ok) {
-		const body = await safeText(res);
-		throw new Error(`github-oidc: OIDC token exchange failed (${res.status})${body ? `: ${body}` : ""}. Confirm the repository is connected to project "${project}" with the github_actions executor.`);
-	}
-	let body;
-	try {
-		body = await res.json();
-	} catch {
-		throw new Error("github-oidc: OIDC token exchange returned an invalid response.");
-	}
-	const token = body?.token;
-	if (typeof token !== "string" || token.length === 0) throw new Error("github-oidc: OIDC token exchange did not return a deploy token.");
-	return token;
-}
-/**
-* Emit a GitHub Actions `::add-mask::` workflow command so `value` is redacted
-* from workflow logs. No-op when not running inside GitHub Actions. GitHub reads
-* workflow commands from stdout.
-*/
-function maskGithubActionsSecret(value, env = process.env) {
-	if (env.GITHUB_ACTIONS !== "true" || !value) return;
-	process.stdout.write(`::add-mask::${value}\n`);
-}
-function errText(err) {
-	return err instanceof Error ? err.message : String(err);
-}
-async function safeText(res) {
-	try {
-		return (await res.text()).trim();
-	} catch {
-		return "";
-	}
-}
-//#endregion
-//#region src/cli/log-file.ts
-/**
-* Walk `err.cause` up to 6 levels and return a plain JSON-friendly chain.
-* Skips stack traces deliberately — keeps output line-oriented and readable.
-*/
-function describeErrorChain(err, depth = 0) {
-	if (depth > 5 || err == null) return String(err);
-	if (err instanceof Error) {
-		const node = {
-			name: err.name,
-			message: err.message
-		};
-		const code = err.code;
-		if (code !== void 0) node.code = code;
-		const errno = err.errno;
-		if (errno !== void 0) node.errno = errno;
-		const cause = err.cause;
-		if (cause != null) {
-			const sub = describeErrorChain(cause, depth + 1);
-			if (typeof sub === "object") node.cause = sub;
-			else node.cause = { message: sub };
-		}
-		return node;
-	}
-	return String(err);
-}
-/**
-* Flatten an error and its `cause` chain to a single inline string suitable
-* for stderr skimming. Mirrors `describeErrorChain`'s walk (depth cap 6,
-* same fields, no stack traces) but joins levels with ` -> ` instead of
-* nesting JSON.
-*/
-function formatErrorChainInline(err, depth = 0) {
-	if (depth > 5 || err == null) return String(err);
-	if (err instanceof Error) {
-		let head = err.name ? `${err.name}: ${err.message}` : err.message;
-		const code = err.code;
-		const errno = err.errno;
-		const tags = [];
-		if (code !== void 0) tags.push(`code=${code}`);
-		if (errno !== void 0) tags.push(`errno=${errno}`);
-		if (tags.length > 0) head = `${head} (${tags.join(" ")})`;
-		const cause = err.cause;
-		if (cause != null) return `${head} -> ${formatErrorChainInline(cause, depth + 1)}`;
-		return head;
-	}
-	return String(err);
-}
-function formatStderrLine(level, msg, err, fields) {
-	const parts = [level, msg];
-	if (fields) for (const [k, v] of Object.entries(fields)) {
-		if (v === void 0) continue;
-		let s;
-		if (v == null || typeof v === "number" || typeof v === "boolean") s = String(v);
-		else if (typeof v === "string") s = v.length > 200 ? `${v.slice(0, 200)}...` : v;
-		else try {
-			s = JSON.stringify(v);
-		} catch {
-			s = String(v);
-		}
-		parts.push(`${k}=${s}`);
-	}
-	if (err !== void 0) parts.push(`-> err=${formatErrorChainInline(err)}`);
-	return parts.join(" ");
-}
-function openDeployLog(opts) {
-	const mirror = opts?.mirrorToStderr === true;
-	const startedAt = Date.now();
-	let path = null;
-	let stream = null;
-	let broken = false;
-	let closed = false;
-	try {
-		const dir = join(homedir(), ".void", "logs");
-		mkdirSync(dir, { recursive: true });
-		const filePath = join(dir, `deploy-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`);
-		stream = createWriteStream(filePath, {
-			flags: "a",
-			autoClose: true
-		});
-		stream.on("error", () => {
-			broken = true;
-		});
-		path = filePath;
-	} catch {
-		broken = true;
-		path = null;
-		stream = null;
-	}
-	function write(level, msg, err, fields) {
-		if (mirror) try {
-			process.stderr.write(`${formatStderrLine(level, msg, err, fields)}\n`);
-		} catch {}
-		if (broken || !stream || closed) return;
-		const now = Date.now();
-		const record = {
-			ts: now,
-			elapsedMs: now - startedAt,
-			lvl: level,
-			msg
-		};
-		if (fields) {
-			for (const [k, v] of Object.entries(fields)) if (v !== void 0 && k !== "ts" && k !== "elapsedMs" && k !== "lvl" && k !== "msg" && k !== "err") record[k] = v;
-		}
-		if (err !== void 0) record.err = describeErrorChain(err);
-		let line;
-		try {
-			line = `${JSON.stringify(record)}\n`;
-		} catch {
-			line = `${JSON.stringify({
-				ts: now,
-				elapsedMs: now - startedAt,
-				lvl: level,
-				msg,
-				err: "unserializable fields"
-			})}\n`;
-		}
-		try {
-			stream.write(line);
-		} catch {
-			broken = true;
-		}
-	}
-	return {
-		get path() {
-			return path;
-		},
-		info(msg, fields) {
-			write("info", msg, void 0, fields);
-		},
-		warn(msg, fields) {
-			write("warn", msg, void 0, fields);
-		},
-		error(msg, err, fields) {
-			write("error", msg, err, fields);
-		},
-		debug(msg, fields) {
-			write("debug", msg, void 0, fields);
-		},
-		close() {
-			if (closed) return Promise.resolve();
-			closed = true;
-			if (!stream) return Promise.resolve();
-			return new Promise((resolveClose) => {
-				try {
-					stream.end(() => resolveClose());
-				} catch {
-					resolveClose();
-				}
-			});
-		}
-	};
-}
-//#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();
-const FRAMEWORK_LIVE_UNSUPPORTED_MESSAGE = "deploy: void/live is currently supported in Void apps only.";
-/**
-* 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);
-}
-/**
-* Map of common asset file extensions → content type. Mirrors
-* `packages/dispatch/src/static.ts`'s MIME_TYPES table so the value the CLI
-* declares for the R2 PUT signature matches what dispatch will serve later
-* (dispatch reads `obj.httpMetadata?.contentType` first, falling back to
-* path-based inference). Keeping the tables aligned avoids a needless
-* mismatch where R2-stored content-type and serve-time content-type
-* disagree on the same asset.
-*/
-const ASSET_MIME_TYPES = {
-	html: "text/html; charset=utf-8",
-	htm: "text/html; charset=utf-8",
-	css: "text/css; charset=utf-8",
-	js: "text/javascript; charset=utf-8",
-	mjs: "text/javascript; charset=utf-8",
-	json: "application/json; charset=utf-8",
-	xml: "application/xml; charset=utf-8",
-	svg: "image/svg+xml; charset=utf-8",
-	txt: "text/plain; charset=utf-8",
-	csv: "text/csv; charset=utf-8",
-	md: "text/markdown; charset=utf-8",
-	markdown: "text/markdown; charset=utf-8",
-	yaml: "text/yaml; charset=utf-8",
-	yml: "text/yaml; charset=utf-8",
-	toml: "application/toml",
-	png: "image/png",
-	jpg: "image/jpeg",
-	jpeg: "image/jpeg",
-	gif: "image/gif",
-	ico: "image/x-icon",
-	webp: "image/webp",
-	avif: "image/avif",
-	woff: "font/woff",
-	woff2: "font/woff2",
-	ttf: "font/ttf",
-	otf: "font/otf",
-	eot: "application/vnd.ms-fontobject",
-	pdf: "application/pdf",
-	wasm: "application/wasm",
-	webmanifest: "application/manifest+json; charset=utf-8",
-	map: "application/json; charset=utf-8",
-	mp4: "video/mp4",
-	webm: "video/webm",
-	mp3: "audio/mpeg",
-	ogg: "audio/ogg"
-};
-/**
-* Resolve the content-type to declare on a direct-to-R2 PUT for `path`.
-* The value is part of the signed Content-Type header on the presigned
-* URL — if the bytes are uploaded with a different content-type, R2
-* rejects the PUT (signature mismatch). Defaults to
-* `application/octet-stream` for unknown extensions.
-*/
-function getAssetContentType(path) {
-	const ext = path.split(".").pop()?.toLowerCase() ?? "";
-	return ASSET_MIME_TYPES[ext] ?? "application/octet-stream";
-}
-/**
-* Compute MD5 of raw content as a 32-char lowercase hex string.
-*
-* Used as the wire-level upload-integrity primitive on direct-to-R2 PUTs:
-* R2's S3 compatibility layer enforces `Content-MD5` (RFC 1864) on PutObject,
-* so the upload itself fails if uploaded bytes don't match the declared MD5.
-* MD5 collision resistance is acceptable here because (a) this hash is purely
-* an upload-integrity primitive (BLAKE3 remains the canonical content key),
-* and (b) project-scoped storage (`assets/${projectId}/${blake3}`) means any
-* collision attack is exploitable only against the attacker's own project.
-*/
-function computeMd5(content) {
-	return createHash("md5").update(content).digest("hex");
-}
-/**
-* Compute both BLAKE3 (CF-compatible asset hash) and MD5 (wire-level R2
-* upload-integrity checksum) from a single in-memory buffer. Returned in
-* the v2 manifest entry shape for direct-to-R2 deploys.
-*
-* Single-pass: callers read the file once into `content`; this function
-* then derives both digests from that buffer. The file is never read twice.
-*/
-function computeAssetHashes(content, filePath) {
-	return {
-		blake3: computeAssetHash(content, filePath),
-		md5: computeMd5(content)
-	};
-}
-/**
-* Create a filter function that excludes .assetsignore, _headers, _redirects,
-* OS metadata files, dotenv files, 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",
-		".DS_Store",
-		".env",
-		".env.*",
-		...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).
-*
-* Each file is read from disk exactly once. Both BLAKE3 (storage key) and
-* MD5 (R2 upload-integrity) digests are derived from that single buffer.
-*/
-async function collectAndHashAssets(dir, onProgress, opts = {}) {
-	const assetManifest = {};
-	const assetFiles = /* @__PURE__ */ new Map();
-	try {
-		const { isIgnored, assetsIgnoreFilePresent } = createAssetsIgnoreFunction(dir, opts.ignorePatterns);
-		const files = collectAssetFiles(dir, isIgnored);
-		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);
-			const { blake3, md5 } = computeAssetHashes(content, filePath);
-			assetManifest[relativePath] = {
-				blake3,
-				md5,
-				size: content.length,
-				hash: blake3
-			};
-			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 }
-	};
-}
-function toLiveManifest(live) {
-	const bindingName = live?.bindingName ?? "VOID_LIVE";
-	const className = live?.className ?? "VoidLiveStreamDurableObject";
-	return {
-		bindingName,
-		className,
-		storage: "sqlite",
-		classes: [className],
-		migrations: [{
-			tag: LIVE_MIGRATION_TAG,
-			newSqliteClasses: [className]
-		}]
-	};
-}
-/**
-* If the user configured `routing.fallbacks` on a non-SPA app, the platform
-* still applies the rules but no `/* -> /index.html` SPA shell is synthesised
-* — unmatched paths fall through to the platform 404. Returns the warning
-* message string when that mismatch is detected, or `null` otherwise. Pure
-* function; callers decide whether/how to surface the message (CLI progress,
-* `console.warn`, etc.).
-*/
-function detectNonSpaFallbackWarning(assetConfig, fallbackRules) {
-	if (assetConfig?.not_found_handling === "single-page-application") return null;
-	if (!fallbackRules || fallbackRules.length === 0) return null;
-	return "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.";
-}
-/**
-* Build a Void-app deploy manifest from the inferred bindings + per-feature
-* inputs. Pure shape transformation: reads no files, has no I/O.
-*
-* Note: callers are responsible for surfacing the non-SPA-fallbacks warning
-* (see `detectNonSpaFallbackWarning`) before invoking this builder. The
-* builder itself stays I/O-free.
-*/
-function buildVoidManifest(opts) {
-	const { bindings, migrations, schedules, ssr, framework, revalidate, vars, queues, prerender, assetConfig, options, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, dialect, webSockets } = opts;
-	const manifest = {
-		version: 3,
-		assetManifestVersion: 2,
-		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 (bindings.needsLive) manifest.live = toLiveManifest(options?.live);
-	if (migrations && migrations.length > 0) {
-		const planBundle = dialect === "postgresql" ? void 0 : buildMigrationPlanBundle(migrations);
-		manifest.migrations = {
-			dialect: dialect ?? "sqlite",
-			...planBundle ? {
-				classifierVersion: planBundle.classifierVersion,
-				migrationListHash: planBundle.migrationListHash,
-				protocolVersion: planBundle.protocolVersion,
-				stability: planBundle.plans.some((plan) => plan.stability === "legacy") ? "legacy" : "stable"
-			} : {},
-			pending: migrations.length
-		};
-	}
-	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;
-	}
-	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;
-	return manifest;
-}
-/**
-* Read every worker module under `workerDir` once and return them as a map
-* keyed by relative path. Skipped files (build metadata, wrangler config,
-* non-module extensions) are filtered out by `isWorkerModule`. Reads each
-* file from disk exactly once — buffer threading downstream is the caller's
-* responsibility.
-*/
-function collectWorkerFiles(workerDir) {
-	const out = /* @__PURE__ */ new Map();
-	let workerPaths;
-	try {
-		workerPaths = collectFiles(workerDir);
-	} catch (err) {
-		if (err instanceof Error && "code" in err && err.code === "ENOENT") return out;
-		throw err;
-	}
-	for (const filePath of workerPaths) {
-		const relativePath = toSlash(relative(workerDir, filePath));
-		if (!isWorkerModule(relativePath)) continue;
-		out.set(relativePath, readFileSync(filePath));
-	}
-	return out;
-}
-/**
-* Build a static-deploy manifest. Pure shape transformation — no I/O.
-*/
-function buildStaticManifest(opts) {
-	const { appType, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules } = opts;
-	const { assetConfig, fallbackRules: resolvedFallbackRules } = resolveSpaFallbackChain(appType, fallbackRules);
-	const manifest = {
-		version: 3,
-		assetManifestVersion: 2,
-		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);
-	return manifest;
-}
-/**
-* Build a framework-deploy manifest. Pure shape transformation — no I/O.
-*/
-function buildFrameworkManifest(opts) {
-	const po = opts.packageOptions;
-	const manifest = {
-		version: 3,
-		assetManifestVersion: 2,
-		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.bindings.needsLive) throw new Error(FRAMEWORK_LIVE_UNSUPPORTED_MESSAGE);
-	if (opts.migrations && opts.migrations.length > 0) {
-		const planBundle = opts.dialect === "postgresql" ? void 0 : buildMigrationPlanBundle(opts.migrations);
-		manifest.migrations = {
-			dialect: opts.dialect ?? "sqlite",
-			...planBundle ? {
-				classifierVersion: planBundle.classifierVersion,
-				migrationListHash: planBundle.migrationListHash,
-				protocolVersion: planBundle.protocolVersion,
-				stability: planBundle.plans.some((plan) => plan.stability === "legacy") ? "legacy" : "stable"
-			} : {},
-			pending: opts.migrations.length
-		};
-	}
-	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;
-	return manifest;
-}
-/**
-* 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;
-}
-/**
-* Recursively collect static asset file paths, refusing symlinks so deploys
-* cannot publish bytes from outside the intended asset root.
-*/
-function collectAssetFiles(root, isIgnored, dir = root) {
-	const files = [];
-	const entries = readdirSync(dir, { withFileTypes: true });
-	for (const entry of entries) {
-		const fullPath = join(dir, entry.name);
-		const relativePath = "/" + toSlash(relative(root, fullPath));
-		if (isIgnored(relativePath)) continue;
-		if (entry.isSymbolicLink()) throw new Error(`deploy: Refusing to upload symlink as an asset: ${relativePath}`);
-		if (entry.isDirectory()) files.push(...collectAssetFiles(root, isIgnored, 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;
-	let migrationPlanBundle;
-	if (features.hasMigrations) {
-		const { collectMigrations } = await import("./validate-DT7nFMlf.mjs").then((n) => n.l);
-		const { buildMigrationPlanBundle } = await import("./validate-DT7nFMlf.mjs").then((n) => n.s);
-		const migrationsDir = readProjectPaths(root).migrationsDir;
-		migrations = collectMigrations(migrationsDir);
-		migrationPlanBundle = features.migrationDialect === "sqlite" ? buildMigrationPlanBundle(migrations) : void 0;
-		const handlerName = features.migrationDialect === "postgresql" ? "migration-handler-pg" : "migration-handler";
-		const handlerFilename_ = `${handlerName}.mjs`;
-		let handlerPath = join(import.meta.dirname, "..", "runtime", `${handlerName}.ts`);
-		if (!existsSync(handlerPath)) 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.`);
-		await bundleMigrationHandler(root, workerDir, handlerPath, features.migrationDialect ?? "sqlite");
-	}
-	const wrapperSource = generateWrapperSource(renamedName, handlerFilename, features, migrations, migrationPlanBundle);
-	writeFileSync(join(workerDir, workerMain), wrapperSource);
-}
-async function bundleMigrationHandler(root, workerDir, handlerPath, dialect) {
-	const tmpDir = join(root, ".void", "migration-handler");
-	mkdirSync(tmpDir, { recursive: true });
-	const outDir = join(tmpDir, "out");
-	const isPostgresql = dialect === "postgresql";
-	await build({
-		root: tmpDir,
-		logLevel: "silent",
-		resolve: isPostgresql ? {
-			alias: {
-				"pg-cloudflare": resolvePgCloudflareWorkerdEntry(handlerPath),
-				"pg-pool": resolvePgCjsDependency(handlerPath, "pg-pool")
-			},
-			conditions: [
-				"workerd",
-				"worker",
-				"browser",
-				"module",
-				"import",
-				"default"
-			]
-		} : void 0,
-		ssr: isPostgresql ? {
-			noExternal: ["pg", "pg-cloudflare"],
-			resolve: { conditions: [
-				"workerd",
-				"worker",
-				"browser",
-				"module",
-				"import",
-				"default"
-			] }
-		} : void 0,
-		build: {
-			outDir,
-			emptyOutDir: true,
-			minify: false,
-			ssr: handlerPath,
-			target: "esnext",
-			rollupOptions: {
-				input: handlerPath,
-				external: [
-					/^cloudflare:/,
-					/^node:/,
-					/^pgpass$/
-				],
-				output: {
-					entryFileNames: "__void_migration_handler.mjs",
-					chunkFileNames: "__void_migration_handler-[hash].mjs"
-				}
-			}
-		}
-	});
-	if (isPostgresql) patchPgWorkerBundle(outDir);
-	for (const file of readdirSync(outDir)) copyFileSync(join(outDir, file), join(workerDir, file));
-}
-function patchPgWorkerBundle(outDir) {
-	for (const file of readdirSync(outDir)) {
-		if (!file.endsWith(".mjs") && !file.endsWith(".js")) continue;
-		const path = join(outDir, file);
-		let code = readFileSync(path, "utf-8");
-		if (!code.includes("__require(\"pgpass\")") && !code.includes("createRequire(import.meta.url)")) continue;
-		code = code.replaceAll("__require(\"pgpass\")", "__voidPgpassNoop").replace("import { createRequire } from \"node:module\";", "").replace("var __require = /* @__PURE__ */ createRequire(import.meta.url);", pgWorkerRequireShim()).replace("var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();", pgWorkerRequireShim());
-		code = `const __voidPgpassNoop = Object.assign(function pgpass(_connectionInfo, callback) { callback(undefined); }, { warnTo() {} });\n` + code;
-		writeFileSync(path, code);
-	}
-}
-function createPgPackageRequire(fromPath) {
-	return createRequire(createRequire(fromPath).resolve("pg/package.json"));
-}
-function resolvePgCjsDependency(fromPath, specifier) {
-	return createPgPackageRequire(fromPath).resolve(specifier);
-}
-function resolvePgCloudflareWorkerdEntry(fromPath) {
-	return join(dirname(createPgPackageRequire(fromPath).resolve("pg-cloudflare/package.json")), "dist", "index.js");
-}
-function pgWorkerRequireShim() {
-	return [
-		"import * as __voidNodeCrypto from \"node:crypto\";",
-		"import * as __voidNodeDns from \"node:dns\";",
-		"import * as __voidNodeEvents from \"node:events\";",
-		"import * as __voidNodeFs from \"node:fs\";",
-		"import * as __voidNodeNet from \"node:net\";",
-		"import * as __voidNodeTls from \"node:tls\";",
-		"import * as __voidNodeUtil from \"node:util\";",
-		"import * as __voidNodeUtilTypes from \"node:util/types\";",
-		"var __voidNodeRequireModules = {",
-		"  crypto: __voidNodeCrypto,",
-		"  dns: __voidNodeDns,",
-		"  events: __voidNodeEvents,",
-		"  fs: __voidNodeFs,",
-		"  net: __voidNodeNet,",
-		"  tls: __voidNodeTls,",
-		"  util: __voidNodeUtil,",
-		"  \"util/types\": __voidNodeUtilTypes,",
-		"};",
-		"var __require = (id) => {",
-		"  if (id.startsWith(\"node:\")) id = id.slice(5);",
-		"  const mod = __voidNodeRequireModules[id];",
-		"  if (mod) return mod;",
-		"  throw new Error(`Unsupported require(\"${id}\") in Void PG migration bundle`);",
-		"};"
-	].join("\n");
-}
-/**
-* 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, migrationPlanBundle) {
-	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 __migrationPlanBundle = ${JSON.stringify(migrationPlanBundle)};`);
-		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);");
-		lines.push("  if (request.method === \"GET\" && url.pathname === \"/__void/ready\") {");
-		lines.push("    return Response.json({ ready: true });");
-		lines.push("  }");
-		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("  }");
-			lines.push("  if (request.method === \"GET\" && url.pathname === \"/__void/migrate/capabilities\") {");
-			lines.push("    const handler = createMigrationHandler(env, __migrations, __migrationDialect, undefined, __migrationPlanBundle);");
-			lines.push("    return handler(request);");
-			lines.push("  }");
-			lines.push("  if (request.method === \"POST\" && url.pathname === \"/__void/migrate/app\") {");
-			lines.push("    const handler = createMigrationHandler(env, __migrations, __migrationDialect, undefined, __migrationPlanBundle);");
-			lines.push("    return handler(request);");
-			lines.push("  }");
-			lines.push("  if (request.method === \"GET\" && url.pathname.startsWith(\"/__void/migrate/app/attempt/\")) {");
-			lines.push("    const handler = createMigrationHandler(env, __migrations, __migrationDialect, undefined, __migrationPlanBundle);");
-			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 = [];
-	const paths = readProjectPaths(root);
-	if (features.crons.length > 0) {
-		for (let i = 0; i < features.crons.length; i++) {
-			const absPath = join(paths.cronsDir, 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(paths.queuesDir, 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,
-	buildEnv: () => buildEnv,
-	ensurePreviouslyDeployedLiveBindingConfig: () => ensurePreviouslyDeployedLiveBindingConfig,
-	generateDeployWrapperIfNeeded: () => generateDeployWrapperIfNeeded,
-	hasDeploySchemaDrift: () => hasDeploySchemaDrift,
-	loadDeployEnv: () => loadDeployEnv,
-	promptDeployProjectConfig: () => promptDeployProjectConfig,
-	resolveDeployLiveBindingConfig: () => resolveDeployLiveBindingConfig,
-	resolveDeployWorkerMain: () => resolveDeployWorkerMain,
-	resolveDeployWranglerCompat: () => resolveDeployWranglerCompat,
-	resolveDistDir: () => resolveDistDir,
-	resolveStaticBuildCommand: () => resolveStaticBuildCommand,
-	resolveStaticDeployPreset: () => resolveStaticDeployPreset,
-	resolveWorkerDirName: () => resolveWorkerDirName,
-	runDeploy: () => runDeploy,
-	runStaticDeploy: () => runStaticDeploy,
-	streamDeployEvents: () => streamDeployEvents,
-	warnRedundantForceOn3xx: () => warnRedundantForceOn3xx,
-	warnUnpublishedRouting: () => warnUnpublishedRouting
-});
-const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
-const deployDriftCheckDir = join(".void", "deploy-drift-check");
-var DeployEventError = class extends Error {};
-async function generateDeployWrapperIfNeeded(root, workerDir, workerMain, features) {
-	if (!needsWrapper(features)) return false;
-	await generateWrapper(workerDir, workerMain, root, features);
-	return true;
-}
-const EMPTY_BINDINGS = {
-	needsD1: false,
-	needsKV: false,
-	needsR2: false,
-	needsAuth: false,
-	needsQueues: false,
-	needsAI: false,
-	needsSandbox: false
-};
-function getErrorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function readLiveBindingConfigFromDeployment(deployment) {
-	if (!deployment?.manifest) return;
-	let manifest;
-	try {
-		manifest = JSON.parse(deployment.manifest);
-	} catch {
-		return;
-	}
-	if (typeof manifest.live?.bindingName !== "string" || typeof manifest.live.className !== "string") return;
-	return {
-		bindingName: manifest.live.bindingName,
-		className: manifest.live.className
-	};
-}
-async function ensurePreviouslyDeployedLiveBindingConfig(root, client, projectId, cliLog) {
-	if (readExistingLiveBindingConfig(root)) return false;
-	const { deployments, activeDeploymentId } = await client.listDeployments(projectId);
-	const live = readLiveBindingConfigFromDeployment(deployments.find((deployment) => deployment.id === activeDeploymentId));
-	if (!live) return false;
-	const synced = syncWranglerBindings(root, {
-		...EMPTY_BINDINGS,
-		needsLive: true
-	}, { live });
-	if (synced) cliLog?.info("live_binding_restored", {
-		bindingName: live.bindingName,
-		className: live.className
-	});
-	return synced;
-}
-async function resolveDeployLiveBindingConfig(root, client, projectId, opts) {
-	if (opts.isFrameworkMode || !opts.needsLive) return;
-	await ensurePreviouslyDeployedLiveBindingConfig(root, client, projectId, opts.cliLog);
-	return resolveLiveBindingConfig(root, {
-		reservedBindings: opts.webSockets.map((route) => route.bindingName),
-		reservedClasses: [...opts.webSockets.map((route) => route.className), opts.sandboxClassName]
-	});
-}
-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, requirements) {
-	if (isNodeTarget(config.target)) return;
-	const compat = ensureWranglerCompat(root, config, buildOutputDir);
-	const compatibilityFlags = normalizeWranglerCompatibilityFlags(compat.compatibilityFlags, { needsNodejsCompat: requirements?.authEnabled === true || requirements?.dialect === "postgresql" || requirements?.needsSandbox === true });
-	return compatibilityFlags === compat.compatibilityFlags ? compat : {
-		...compat,
-		compatibilityFlags
-	};
-}
-function resolveDeployWorkerMain(config, buildOutputDir) {
-	if (isNodeTarget(config.target)) return;
-	try {
-		const wrangler = JSON.parse(readFileSync(join(buildOutputDir, "wrangler.json"), "utf-8"));
-		return typeof wrangler.main === "string" && wrangler.main.length > 0 ? wrangler.main : void 0;
-	} catch {
-		return;
-	}
-}
-function assertWorkerMainUploaded(workerFiles, workerMain) {
-	if (!workerMain || workerFiles.size === 0) return;
-	if (!workerFiles.has(workerMain)) throw new Error(`deploy: Worker entry '${workerMain}' from wrangler.json was not found in uploaded worker modules.`);
-}
-/**
-* 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();
-	intro(cliTitle("deploy"));
-	const cliLog = openDeployLog({ mirrorToStderr: options?.debug === true || process.env.VOID_DEPLOY_DEBUG === "1" });
-	cliLog.info("deploy_start", {
-		cwd: root,
-		projectSlug: options?.projectSlug,
-		dir: options?.dir,
-		spa: options?.spa === true ? true : void 0,
-		skipBuild: options?.skipBuild === true ? true : void 0,
-		nodeVersion: process.version,
-		platform: process.platform,
-		arch: process.arch
-	});
-	try {
-		await runDeployInner(root, options, cliLog);
-		cliLog.info("deploy_end", { ok: true });
-	} catch (err) {
-		cliLog.error("deploy_end", err, { ok: false });
-		throw err;
-	} finally {
-		await cliLog.close().catch(() => {});
-	}
-}
-/**
-* Build a child-process environment with the CF Access service-token PAIR
-* removed.
-*
-* The deploy flow spawns UNTRUSTED user build code (`vite build`, framework
-* preset builds, drizzle-kit loading the user schema) which inherits the
-* spawn env. A shared, long-lived CF Access service token is needed only by
-* this CLI's own API client (which captures the Access headers once at
-* construction and reuses them for every request) — never by the build — so it
-* must not survive into those children, or it would leak to arbitrary repo
-* build scripts/plugins.
-*
-* We scrub it on the CHILD env rather than mutating `process.env`: deleting it
-* from the parent also breaks interactive expired-token re-auth, which reads
-* `cfAccessHeaders(process.env)` / the cloudflared pair-guard AFTER the build
-* step. Only the service-token pair is scrubbed; the cloudflared
-* `CF_ACCESS_TOKEN` JWT (dev path) is left untouched.
-*/
-function buildEnv(extra) {
-	const env = {
-		...process.env,
-		...extra
-	};
-	delete env.CF_ACCESS_CLIENT_ID;
-	delete env.CF_ACCESS_CLIENT_SECRET;
-	return env;
-}
-async function runDeployInner(root, options, cliLog) {
-	let reauthenticated = false;
-	while (true) try {
-		let token = process.env.VOID_TOKEN ?? null;
-		if (!token && isGithubActionsOidcAvailable()) {
-			const slug = getRequestedProjectSlug(options) ?? readProjectConfig(root)?.slug;
-			if (!slug) throw new Error("deploy: running in GitHub Actions but the project is unknown — pass --project <slug> or link the project.");
-			cliLog.info("github_oidc_exchange_start", { slug });
-			token = await exchangeGithubOidcForDeployToken(getApiUrl(root), slug);
-			maskGithubActionsSecret(token);
-			process.env.VOID_TOKEN = token;
-			cliLog.info("github_oidc_exchange_success", { slug });
-		}
-		token ??= getToken(root);
-		if (!token) {
-			log.error("No auth token found. Run `void auth login` first.");
-			process.exit(1);
-		}
-		const client = new PlatformClient(token, {
-			root,
-			cliLog
-		});
-		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, cliLog);
-			else {
-				const shouldCreate = await confirm({ message: `Project "${requestedProjectSlug}" does not exist. Create it?` });
-				if (isCancel(shouldCreate) || !shouldCreate) {
-					log.info("Deploy cancelled.");
-					process.exit(0);
-				}
-				config = await createProjectFromSlug(root, client, requestedProjectSlug, cliLog);
-			}
-		} else config = readProjectConfig(root);
-		if (!config && !process.stdin.isTTY) {
-			log.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, cliLog);
-		cliLog.info("project_resolved", {
-			projectId: config.projectId,
-			slug: config.slug
-		});
-		const voidConfig = readConfig(root);
-		cliLog.info("config_resolved", {
-			target: voidConfig.target,
-			appType: voidConfig.inference?.appType,
-			output: voidConfig.output
-		});
-		let preset = resolveStaticDeployPreset(root, voidConfig, {
-			dir: options?.dir,
-			spa: options?.spa
-		});
-		const detected = detectFramework(root);
-		if (!preset && detected) {
-			cliLog.info("framework_detected", {
-				name: detected.name,
-				class: detected.class
-			});
-			const gitMetadata = collectGitDeployMetadata(root, options?.skipBuild ? null : getGitCommit(root));
-			const fwPreset = FRAMEWORK_PRESETS[detected.name];
-			if (detected.class === "b" || detected.class === "c") {
-				if (!fwPreset) {
-					log.error(`No deploy preset found for framework "${detected.name}".`);
-					process.exit(1);
-				}
-				await runFrameworkDeploy(root, config, client, detected, fwPreset, voidConfig, options?.skipBuild, gitMetadata, cliLog);
-			} else await runFullDeploy(root, config, client, fwPreset, options?.skipBuild, gitMetadata, detected, cliLog);
-			return;
-		}
-		if (!preset && !voidConfig.inference?.appType) preset = detectPreset(root, { spa: options?.spa });
-		const gitMetadata = collectGitDeployMetadata(root, 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, gitMetadata, void 0, void 0, void 0, void 0, voidConfig.routing, cliLog);
-		} else await runFullDeploy(root, config, client, void 0, options?.skipBuild, gitMetadata, void 0, cliLog);
-		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.");
-			log.warn("Auth token expired. Re-authenticating...");
-			await promptForLoginToken(root);
-			log.success("Re-authenticated. Retrying deploy...");
-			reauthenticated = true;
-			continue;
-		}
-		throw error;
-	}
-}
-async function promptDeployProjectConfig(root, client, cliLog) {
-	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, {
-		confirmExisting: true,
-		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);
-	log.step(`Linked to ${import_picocolors.default.blue(config.slug)}`);
-	cliLog?.info("project_linked", {
-		projectId: config.projectId,
-		slug: config.slug
-	});
-	return config;
-}
-function resolveStaticBuildCommand(preset, buildOverride, hasExplicitDir = false) {
-	if (hasExplicitDir) return null;
-	return buildOverride ?? preset.buildCommand;
-}
-function resolveStaticDeployPreset(root, voidConfig, options) {
-	if (options?.dir) return detectPreset(root, {
-		dir: options.dir,
-		spa: options.spa
-	});
-	const appType = voidConfig.inference?.appType;
-	if (appType === "static" || appType === "spa") {
-		const outputDir = voidConfig.inference?.outputDir;
-		const preset = {
-			buildCommand: null,
-			outputDir: outputDir ? resolve(root, outputDir) : join(root, "dist"),
-			appType
-		};
-		const detectedPreset = detectPreset(root, { spa: options?.spa });
-		if (detectedPreset) {
-			preset.buildCommand = detectedPreset.buildCommand;
-			if (!outputDir) preset.outputDir = detectedPreset.outputDir;
-		}
-		return preset;
-	}
-	return null;
-}
-/**
-* 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 "worker_readiness":
-			s.message("Waiting for worker to become reachable...");
-			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":
-			log.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":
-			if (event.published === false) s.stop("Deployed, but routing was not published — the project may be unreachable or still serving the previous deploy. Re-run `void deploy` to publish routing.");
-			else s.stop("Deployed!");
-			return {
-				kind: "done",
-				event
-			};
-		case "error":
-			s.stop("Deploy failed");
-			return {
-				kind: "error",
-				message: event.message
-			};
-	}
-	return { kind: "continue" };
-}
-/**
-* Apply a streamed `DeployEvent` iterator to the spinner / cliLog and
-* resolve with the terminal `done` event (or throw on terminal error /
-* connection loss).
-*/
-async function streamDeployEvents(projectId, events, s, cliLog) {
-	const startedAt = Date.now();
-	let deploymentId = null;
-	let interrupted = false;
-	cliLog?.info("stream_start", { projectId });
-	const onSigint = () => {
-		interrupted = true;
-		s.stop("Deploy interrupted");
-		if (deploymentId) log.info(`Deployment: ${deploymentId}`);
-		else log.info("Deployment id was not received before the interrupt.");
-		cliLog?.warn("stream_interrupted", { deploymentId });
-		cliLog?.close().catch(() => {});
-		process.exit(130);
-	};
-	process.once("SIGINT", onSigint);
-	try {
-		for await (const event of events) {
-			const result = applyDeployEvent(event, s);
-			if (result.kind === "start") {
-				deploymentId = result.deploymentId;
-				cliLog?.info("stream_deployment_id", { deploymentId });
-			} else if (result.kind === "done") {
-				const degraded = result.event.published === false;
-				cliLog?.info(degraded ? "deploy_degraded" : "deploy_success", {
-					deploymentId,
-					url: result.event.url,
-					assets: result.event.assets,
-					workers: result.event.workers,
-					durationMs: Date.now() - startedAt,
-					degraded
-				});
-				return result.event;
-			} else if (result.kind === "error") {
-				cliLog?.error("deploy_server_error", void 0, {
-					deploymentId,
-					message: result.message
-				});
-				throw new DeployEventError(formatDeployFailureMessage(result.message, deploymentId, cliLog?.path ?? null));
-			}
-		}
-	} catch (err) {
-		if (err instanceof DeployEventError) throw err;
-		if (interrupted) throw err;
-		cliLog?.error("stream_deploy_caught", err, { deploymentId });
-		s.stop("Deploy failed");
-		throw formatStreamDeployError(err, deploymentId, cliLog?.path ?? null);
-	} finally {
-		process.removeListener("SIGINT", onSigint);
-	}
-	cliLog?.warn("stream_no_terminal_event", { deploymentId });
-	s.stop("Deploy failed");
-	throw new Error(formatConnectionLostMessage(deploymentId, cliLog?.path ?? null));
-}
-/**
-* Direct-to-R2 deploy orchestration. Issues presigned PUT URLs for each
-* needed asset, uploads bytes directly to R2, then calls the manifest-only
-* deploy endpoint to finalize.
-*
-* Key invariants:
-*   1. No needed assets → skip presign + R2 PUT phase entirely (saves a
-*      round-trip when every asset was already present from a prior deploy).
-*   2. Asset bytes come exclusively from the in-memory `assetFiles` cache
-*      computed by `collectAndHashAssets` — files are NEVER re-read from
-*      disk during this flow (Codex Finding #2 in design doc 0068 review).
-*   3. R2 PUT failures (4xx, 5xx, network) are surfaced with the asset
-*      path + hash so the user can correlate against the JSONL trace.
-*/
-async function streamDirectR2Deploy(client, projectId, manifest, assetManifest, assetFiles, needed, gitMetadata, preflightUsed, workerFiles, s, cliLog) {
-	if (needed.length > 0) {
-		const neededPaths = new Set(needed);
-		const preBufferCount = assetFiles.size;
-		const allPaths = Array.from(assetFiles.keys());
-		for (const path of allPaths) if (!neededPaths.has(path)) assetFiles.delete(path);
-		if (assetFiles.size !== preBufferCount) cliLog?.info("asset_cache_pruned", {
-			before: preBufferCount,
-			after: assetFiles.size
-		});
-		s.message(`Requesting upload URLs for ${needed.length} asset(s)...`);
-		const seenBlake3 = /* @__PURE__ */ new Set();
-		const uniqueNeeded = [];
-		for (const path of needed) {
-			const entry = assetManifest[path];
-			if (!entry) throw new Error(`internal: preflight returned ${path} but assetManifest has no entry`);
-			if (seenBlake3.has(entry.blake3)) continue;
-			seenBlake3.add(entry.blake3);
-			uniqueNeeded.push(path);
-		}
-		const assetsToUpload = uniqueNeeded.map((path) => {
-			const entry = assetManifest[path];
-			return {
-				blake3: entry.blake3,
-				md5: entry.md5,
-				size: entry.size,
-				contentType: getAssetContentType(path)
-			};
-		});
-		cliLog?.info("presign_request_start", {
-			assetCount: assetsToUpload.length,
-			dedupedFrom: needed.length
-		});
-		const presignStartedAt = Date.now();
-		const urls = await client.requestUploadUrls(projectId, assetsToUpload);
-		cliLog?.info("presign_request_end", {
-			urlsReceived: Object.keys(urls).length,
-			durationMs: Date.now() - presignStartedAt
-		});
-		const items = uniqueNeeded.map((path) => {
-			const entry = assetManifest[path];
-			const presigned = urls[entry.blake3];
-			if (!presigned) throw new Error(`Platform did not return an upload URL for ${path} (blake3=${entry.blake3}). This indicates a server-side bug or a stale client.`);
-			const body = assetFiles.get(path);
-			if (!body) throw new Error(`internal: asset ${path} declared in manifest but missing from buffer cache`);
-			return {
-				path,
-				hash: entry.blake3,
-				body,
-				url: presigned.url,
-				headers: presigned.headers
-			};
-		});
-		s.message(`Uploading ${items.length} asset(s) to R2...`);
-		await uploadAssetsToR2(items, cliLog, void 0, (item) => {
-			assetFiles.delete(item.path);
-		});
-	} else cliLog?.info("presign_skipped", { reason: "no_needed_assets" });
-	const payload = {
-		manifest,
-		assetManifest,
-		source: getTokenSource(),
-		commit: gitMetadata?.commit ?? null,
-		repositoryUrl: gitMetadata?.repositoryUrl ?? null,
-		commitUrl: gitMetadata?.commitUrl ?? null,
-		gitRef: gitMetadata?.gitRef ?? null,
-		preflight: preflightUsed ? "true" : null
-	};
-	if (workerFiles && workerFiles.size > 0) {
-		const encoded = {};
-		for (const [relPath, buf] of workerFiles) encoded[relPath] = buf.toString("base64");
-		payload.workerFiles = encoded;
-	}
-	s.message("Finalizing deploy...");
-	cliLog?.info("finalize_start", {
-		workerFileCount: workerFiles?.size ?? 0,
-		assetCount: Object.keys(assetManifest).length
-	});
-	const finalizeStartedAt = Date.now();
-	try {
-		return await streamDeployEvents(projectId, client.finalizeDeploy(projectId, payload), s, cliLog);
-	} finally {
-		cliLog?.info("finalize_end", { durationMs: Date.now() - finalizeStartedAt });
-	}
-}
-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, gitMetadata, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, routing, cliLog) {
-	const typeLabel = preset.appType === "spa" ? "Static SPA" : "Static Site";
-	log.info(`${typeLabel} deploy`);
-	cliLog?.info("deploy_mode", {
-		mode: "static",
-		appType: preset.appType
-	});
-	if (preset.buildCommand && !skipBuild) {
-		log.step("Building...");
-		cliLog?.info("build_start", { command: preset.buildCommand });
-		const buildStartedAt = Date.now();
-		execSync(preset.buildCommand, {
-			cwd: root,
-			stdio: "inherit",
-			env: buildEnv()
-		});
-		cliLog?.info("build_end", { durationMs: Date.now() - buildStartedAt });
-	} else if (skipBuild) cliLog?.info("build_skipped", { reason: "skipBuild" });
-	if (!existsSync(preset.outputDir)) {
-		log.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...");
-	cliLog?.info("preflight_start", { dir: preset.outputDir });
-	const { assetManifest, assetFiles } = await collectAndHashAssets(preset.outputDir, onProgress);
-	const { needed, skipped } = await client.preflight(config.projectId, assetManifest);
-	s.stop("Checked for changes");
-	cliLog?.info("preflight_end", {
-		total: Object.keys(assetManifest).length,
-		needed: needed.length,
-		skipped
-	});
-	if (skipped > 0) log.info(`Skipping ${skipped} unchanged asset(s)`);
-	s.start("Packaging...");
-	cliLog?.info("package_start", { mode: "static" });
-	const packageStartedAt = Date.now();
-	const neededSet = skipped > 0 ? new Set(needed) : null;
-	const manifest = buildStaticManifest({
-		appType: preset.appType,
-		hashedAssetsPrefix: hashedAssetsPrefix ?? "assets",
-		headerRules,
-		redirectRules,
-		fallbackRules
-	});
-	cliLog?.info("package_end", {
-		mode: "static",
-		durationMs: Date.now() - packageStartedAt
-	});
-	const result = await streamDirectR2Deploy(client, config.projectId, manifest, assetManifest, assetFiles, needed, gitMetadata, neededSet !== null, void 0, s, cliLog);
-	note([`${typeLabel} — ${formatKnownAssetSummary(result, skipped)}`].join("\n"), result.url);
-	warnUnpublishedRouting(result);
-	outro("Done!");
-}
-/**
-* Surface a persistent warning when a deploy committed live but its routing
-* KV was not published. Uses `log.warn` (not the spinner) so the warning
-* survives the following `note`/`outro` calls and the user sees it after the
-* deploy summary. The deploy is still committed — this is a warning, not a
-* failure, so the process exit code is unaffected.
-*/
-function warnUnpublishedRouting(result) {
-	if (result.published !== false) return;
-	log.warn("Routing was not published for this deploy. The project may be unreachable (first deploy) or still serving the previous deploy. Re-run `void deploy` to publish routing.");
-}
-/**
-* 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;
-	log.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, gitMetadata, cliLog) {
-	log.info(`${detected.name} framework deploy`);
-	cliLog?.info("deploy_mode", {
-		mode: "framework",
-		framework: detected.name
-	});
-	const dialect = getDatabaseDialect(voidConfig);
-	const buildCmd = voidConfig.inference?.build ?? formatProjectCommand(root, fwPreset.buildCommand);
-	if (!skipBuild) {
-		log.step(`Building (${buildCmd})...`);
-		cliLog?.info("build_start", { command: buildCmd });
-		const buildStartedAt = Date.now();
-		execSync(voidConfig.inference?.build ?? resolveProjectCommand(root, fwPreset.buildCommand), {
-			cwd: root,
-			stdio: "inherit",
-			env: buildEnv()
-		});
-		cliLog?.info("build_end", { durationMs: Date.now() - buildStartedAt });
-	} else cliLog?.info("build_skipped", { reason: "skipBuild" });
-	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)) {
-		log.error(`deploy: Worker output '${fwPreset.workerDir}' not found. Run '${buildCmd}' first.`);
-		process.exit(1);
-	}
-	const inferenceOptions = voidConfig.inference?.bindings ? { bindings: voidConfig.inference.bindings } : void 0;
-	const paths = resolveProjectPaths(root, voidConfig);
-	const scanDirs = voidConfig.inference?.scanDirs ?? FRAMEWORK_SCAN_DIRS;
-	const bindings = inferProjectBindings(root, {
-		...inferenceOptions,
-		paths
-	}, scanDirs);
-	if (bindings.needsAuth || findVoidAuthConfig(root, paths) !== null || voidConfig.auth !== void 0) {
-		log.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);
-	}
-	if (bindings.needsLive) {
-		log.error("deploy: void/live is currently supported in Void apps only.");
-		process.exit(1);
-	}
-	const migrationsDir = paths.migrationsDir;
-	assertDeploySchemaDriftFree(root, dialect);
-	const rawMigrations = collectMigrations(migrationsDir);
-	let validatedMigrations;
-	try {
-		assertJournalCoherence(migrationsDir, rawMigrations);
-	} catch (err) {
-		log.error(getErrorMessage(err));
-		process.exit(1);
-	}
-	if (rawMigrations.length > 0) try {
-		validatedMigrations = validateMigrations(rawMigrations);
-		log.info(`Found ${validatedMigrations.length} migration(s)`);
-	} catch (err) {
-		log.error(getErrorMessage(err));
-		process.exit(1);
-	}
-	if (dialect === "postgresql" && (bindings.needsD1 || rawMigrations.length > 0)) {
-		let resources = null;
-		try {
-			resources = await client.getResources(config.projectId);
-		} catch {}
-		if (resources) {
-			if (!resources.some((resource) => resource.type === "hyperdrive")) {
-				const { text: promptText, isCancel: isCancelPrompt } = await import("./agents-Bmr5tFFb.mjs").then((n) => n.C);
-				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)) {
-					log.info("Deploy cancelled.");
-					process.exit(0);
-				}
-				await client.provisionDatabase(config.projectId, connectionString);
-				log.success("Hyperdrive provisioned.");
-			}
-		}
-	}
-	const rawJobs = scanJobsSync(root, paths.cronsDir);
-	const rawQueues = scanQueuesSync(root, paths.queuesDir);
-	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) {
-		log.step("Bundling worker...");
-		const bundleResult = await bundleEntry(root, originalEntry);
-		actualWorkerDir = bundleResult.outputDir;
-		actualWorkerMain = bundleResult.entryFilename;
-		log.info("Worker bundled");
-	}
-	if (needsWrapper(wrapperFeatures)) {
-		log.step("Generating wrapper...");
-		await generateDeployWrapperIfNeeded(root, actualWorkerDir, actualWorkerMain, wrapperFeatures);
-		log.info("Wrapper generated");
-	}
-	const wranglerCompat = resolveDeployWranglerCompat(root, voidConfig, workerDir, { dialect });
-	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...");
-	cliLog?.info("preflight_start", { dir: assetsDir });
-	const { assetManifest, assetFiles } = await collectAndHashAssets(assetsDir, onProgress, { ignorePatterns: frameworkAssetIgnorePatterns });
-	const { needed, skipped } = await client.preflight(config.projectId, assetManifest, true);
-	s.stop("Checked for changes");
-	cliLog?.info("preflight_end", {
-		total: Object.keys(assetManifest).length,
-		needed: needed.length,
-		skipped
-	});
-	if (skipped > 0) log.info(`Skipping ${skipped} unchanged asset(s)`);
-	s.start("Packaging...");
-	cliLog?.info("package_start", {
-		mode: "framework",
-		framework: detected.name
-	});
-	const packageStartedAt = Date.now();
-	const neededSet = skipped > 0 ? new Set(needed) : null;
-	const packageOptions = {
-		bindingNames: resolveBindingNames(voidConfig.inference?.bindings),
-		workerMain: actualWorkerMain,
-		compatibilityDate: wranglerCompat?.compatibilityDate,
-		compatibilityFlags: wranglerCompat?.compatibilityFlags
-	};
-	const manifest = buildFrameworkManifest({
-		frameworkName: detected.name,
-		workerMain: actualWorkerMain,
-		bindings,
-		migrations: validatedMigrations,
-		schedules,
-		queues,
-		revalidate,
-		revalidateQueryAllowlist: voidConfig.routing?.revalidateQueryAllowlist,
-		prerender,
-		assetConfig: { not_found_handling: "none" },
-		vars: envVars,
-		packageOptions,
-		hashedAssetsPrefix: fwPreset.hashedAssetsPrefix ?? "assets",
-		headerRules,
-		redirectRules,
-		fallbackRules,
-		dialect
-	});
-	const workerFiles = collectWorkerFiles(actualWorkerDir);
-	cliLog?.info("package_end", {
-		mode: "framework",
-		durationMs: Date.now() - packageStartedAt
-	});
-	const result = await streamDirectR2Deploy(client, config.projectId, manifest, assetManifest, assetFiles, needed, gitMetadata, neededSet !== null, workerFiles, s, cliLog);
-	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}`);
-	note(summary.join("\n"), result.url);
-	cleanupWrapper(root);
-	warnUnpublishedRouting(result);
-	outro("Done!");
-}
-async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetadata, detected, cliLog) {
-	cliLog?.info("deploy_mode", {
-		mode: "full",
-		framework: detected?.name
-	});
-	if (!skipBuild) {
-		const buildCmd = formatProjectCommand(root, "vite build");
-		log.step(`Building (${buildCmd})...`);
-		cliLog?.info("build_start", { command: buildCmd });
-		const buildStartedAt = Date.now();
-		try {
-			execSync(resolveProjectCommand(root, "vite build"), {
-				cwd: root,
-				stdio: "inherit",
-				env: buildEnv({ VOID_DEPLOY_PROJECT_ID: config.projectId })
-			});
-			cliLog?.info("build_end", { durationMs: Date.now() - buildStartedAt });
-		} catch (err) {
-			cliLog?.error("build_failed", err, { durationMs: Date.now() - buildStartedAt });
-			process.exit(getExitCode(err));
-		}
-	} else cliLog?.info("build_skipped", { reason: "skipBuild" });
-	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 paths = resolveProjectPaths(root, deployConfig);
-	const dialect = getDatabaseDialect(deployConfig);
-	const deployScanDirs = deployConfig.inference?.scanDirs ?? (isFrameworkMode ? FRAMEWORK_SCAN_DIRS : void 0);
-	const bindings = inferProjectBindings(root, { paths }, deployScanDirs);
-	if (isSandboxEnabled(deployConfig)) bindings.needsSandbox = true;
-	const authEnabled = bindings.needsAuth || findVoidAuthConfig(root, paths) !== null || deployConfig.auth !== void 0;
-	const effectiveBindings = authEnabled ? {
-		...bindings,
-		needsAuth: true,
-		needsD1: true
-	} : bindings;
-	if (isFrameworkMode && authEnabled) {
-		log.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) {
-		log.error("deploy: Cloudflare Sandboxes are currently supported in Void apps only.");
-		process.exit(1);
-	}
-	if (isFrameworkMode && bindings.needsLive) {
-		log.error("deploy: void/live is currently supported in Void apps only.");
-		process.exit(1);
-	}
-	const sandboxConfig = bindings.needsSandbox ? resolveSandboxConfig(deployConfig, root) : void 0;
-	if (bindings.needsSandbox && requiresSandboxPlatformImage(deployConfig)) {
-		log.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 = paths.migrationsDir;
-	assertDeploySchemaDriftFree(root, dialect);
-	const rawMigrations = collectMigrations(migrationsDir);
-	let validatedMigrations;
-	try {
-		assertJournalCoherence(migrationsDir, rawMigrations);
-	} catch (err) {
-		log.error(getErrorMessage(err));
-		process.exit(1);
-	}
-	if (rawMigrations.length > 0) try {
-		validatedMigrations = validateMigrations(rawMigrations);
-		log.info(`Found ${validatedMigrations.length} migration(s)`);
-	} catch (err) {
-		log.error(getErrorMessage(err));
-		process.exit(1);
-	}
-	if (dialect === "postgresql" && (effectiveBindings.needsD1 || rawMigrations.length > 0)) {
-		let resources = null;
-		try {
-			resources = await client.getResources(config.projectId);
-		} catch {}
-		if (resources) {
-			if (!resources.some((resource) => resource.type === "hyperdrive")) {
-				const { text: promptText, isCancel: isCancelPrompt } = await import("./agents-Bmr5tFFb.mjs").then((n) => n.C);
-				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)) {
-					log.info("Deploy cancelled.");
-					process.exit(0);
-				}
-				await client.provisionDatabase(config.projectId, connectionString);
-				log.success("Hyperdrive provisioned.");
-			}
-		}
-	}
-	const workerDirName = resolveWorkerDirName(distDir, fwPreset, frameworkBuildCmd);
-	const rawJobs = scanJobsSync(root, paths.cronsDir);
-	const rawQueues = scanQueuesSync(root, paths.queuesDir);
-	const schedules = rawJobs.flatMap((job) => job.crons.map((cron) => ({
-		name: job.name,
-		cron
-	})));
-	const routeScan = await scanRoutes(root, {
-		output: deployConfig.output,
-		paths
-	});
-	const webSockets = routeScan.websockets ?? scanWebSocketRoutesSync(root, paths);
-	const liveConfig = await resolveDeployLiveBindingConfig(root, client, config.projectId, {
-		isFrameworkMode,
-		needsLive: effectiveBindings.needsLive,
-		webSockets,
-		sandboxClassName: sandboxConfig?.className,
-		cliLog
-	});
-	const queues = rawQueues.map((q) => ({
-		name: q.name,
-		bindingName: q.bindingName,
-		...q.maxBatchSize != null && { maxBatchSize: q.maxBatchSize },
-		...q.maxBatchTimeout != null && { maxBatchTimeout: q.maxBatchTimeout }
-	}));
-	const hasPages = existsSync(paths.pagesDir);
-	const hasRoutes = routeScan.routes.length > 0;
-	const hasApiRoutes$1 = hasApiRoutes(routeScan.routes) || hasApiRoutes(webSockets) || authEnabled;
-	const hasDocumentRoutes$1 = hasDocumentRoutes(routeScan.routes);
-	const hasMiddleware = routeScan.middleware.length > 0;
-	const hasWebSockets = webSockets.length > 0;
-	const isSsr = isFrameworkMode ? true : Boolean(validateSsrEntry(root, paths)) || hasPages && deployConfig.output !== "static";
-	const pageScan = existsSync(paths.pagesDir) ? routeScan.pages.pages.length > 0 ? routeScan.pages : await scanPages(root, {
-		output: deployConfig.output,
-		paths
-	}) : null;
-	const revalidate = collectRevalidate(deployConfig, pageScan);
-	if (deployConfig.output === "static" && pageScan && !isSsr) {
-		if (pageScan.pages.every((p) => p.shouldPrerender && (p.params.length === 0 && !p.catchAll || p.hasGetPrerenderPaths)) && !(hasRoutes || hasMiddleware || hasWebSockets || authEnabled || liveConfig !== void 0) && schedules.length === 0 && queues.length === 0) {
-			log.info("All pages prerendered — deploying as static site");
-			cliLog?.info("full_to_static_redirect", { reason: "all_pages_prerendered" });
-			return runStaticDeploy(root, config, client, {
-				buildCommand: null,
-				outputDir: clientDir,
-				appType: "static"
-			}, true, gitMetadata, assetsPrefix, headerRules, redirectRules, fallbackRules, void 0, cliLog);
-		}
-	}
-	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), {
-		authEnabled,
-		dialect,
-		needsSandbox: effectiveBindings.needsSandbox
-	});
-	const workerMain = resolveDeployWorkerMain(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,
-		hasApiRoutes: hasApiRoutes$1,
-		hasDocumentRoutes: hasDocumentRoutes$1,
-		hasMiddleware,
-		hasWebSockets: hasDocumentRoutes(webSockets),
-		authEnabled,
-		liveEnabled: liveConfig !== void 0
-	});
-	s.start("Checking for changes...");
-	cliLog?.info("preflight_start", { dir: clientDir });
-	const { assetManifest, assetFiles } = await collectAndHashAssets(clientDir, onProgress);
-	const { needed, skipped } = await client.preflight(config.projectId, assetManifest, true);
-	s.stop("Checked for changes");
-	cliLog?.info("preflight_end", {
-		total: Object.keys(assetManifest).length,
-		needed: needed.length,
-		skipped
-	});
-	if (skipped > 0) log.info(`Skipping ${skipped} unchanged asset(s)`);
-	s.start("Packaging...");
-	cliLog?.info("package_start", {
-		mode: "full",
-		isSsr,
-		hasRoutes,
-		hasMiddleware,
-		hasWebSockets,
-		authEnabled,
-		framework: detected?.name
-	});
-	const packageStartedAt = Date.now();
-	const neededSet = skipped > 0 ? new Set(needed) : null;
-	const voidPackageOptions = {
-		compatibilityDate: wranglerCompat?.compatibilityDate,
-		compatibilityFlags: wranglerCompat?.compatibilityFlags,
-		...workerMain && { workerMain },
-		...sandboxConfig && { sandbox: sandboxConfig },
-		...liveConfig && { live: liveConfig },
-		revalidateQueryAllowlist: deployConfig.routing?.revalidateQueryAllowlist
-	};
-	const fallbackWarning = detectNonSpaFallbackWarning(assetConfig, fallbackRules);
-	if (fallbackWarning) {
-		onProgress?.(fallbackWarning);
-		console.warn(`[void] ${fallbackWarning}`);
-	}
-	const manifest = buildVoidManifest({
-		bindings: liveConfig ? {
-			...effectiveBindings,
-			needsLive: true
-		} : effectiveBindings,
-		migrations: validatedMigrations,
-		schedules,
-		ssr: isSsr || hasRoutes || hasMiddleware || hasWebSockets || authEnabled,
-		framework: isFrameworkMode ? detected.name : void 0,
-		revalidate,
-		vars: envVars,
-		queues,
-		prerender: uniquePrerenderPaths,
-		assetConfig,
-		options: voidPackageOptions,
-		hashedAssetsPrefix: assetsPrefix,
-		headerRules,
-		redirectRules,
-		fallbackRules,
-		dialect,
-		webSockets
-	});
-	const workerDir = join(distDir, workerDirName);
-	if (isFrameworkMode) {
-		const wrapperFeatures = {
-			auth: null,
-			crons: rawJobs,
-			queues: rawQueues,
-			hasMigrations: validatedMigrations != null && validatedMigrations.length > 0,
-			migrationDialect: dialect
-		};
-		if (needsWrapper(wrapperFeatures)) {
-			log.step("Generating wrapper...");
-			await generateDeployWrapperIfNeeded(root, workerDir, fwPreset?.workerMain ?? "index.js", wrapperFeatures);
-			log.info("Wrapper generated");
-		}
-	}
-	const workerFiles = collectWorkerFiles(workerDir);
-	assertWorkerMainUploaded(workerFiles, workerMain);
-	cliLog?.info("package_end", {
-		mode: "full",
-		durationMs: Date.now() - packageStartedAt
-	});
-	const result = await streamDirectR2Deploy(client, config.projectId, manifest, assetManifest, assetFiles, needed, gitMetadata, neededSet !== null, workerFiles, s, cliLog);
-	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");
-	note(summary.join("\n"), result.url);
-	warnUnpublishedRouting(result);
-	outro("Done!");
-}
-async function createProjectFromSlug(root, client, slug, cliLog) {
-	log.step(`Creating project ${import_picocolors.default.blue(slug)}...`);
-	cliLog?.info("project_create_start", { slug });
-	const project = await client.createProject(slug);
-	const config = {
-		projectId: project.id,
-		slug: project.slug
-	};
-	writeProjectConfig(root, config);
-	log.success(`Project created: ${import_picocolors.default.blue(config.slug)}`);
-	cliLog?.info("project_create_success", {
-		projectId: config.projectId,
-		slug: config.slug
-	});
-	return config;
-}
-function getGitCommit(root) {
-	try {
-		const githubSha = process.env.GITHUB_SHA?.trim();
-		if (githubSha && /^[0-9a-f]{7,64}$/i.test(githubSha)) return githubSha;
-		const gitEnv = buildEnv();
-		execSync("git rev-parse --is-inside-work-tree", {
-			cwd: root,
-			stdio: "ignore",
-			env: gitEnv
-		});
-		if (execSync("git status --porcelain", {
-			cwd: root,
-			encoding: "utf-8",
-			env: gitEnv
-		}).trim() !== "") return null;
-		return execSync("git rev-parse HEAD", {
-			cwd: root,
-			encoding: "utf-8",
-			env: gitEnv
-		}).trim();
-	} catch {
-		return null;
-	}
-}
-function assertDeploySchemaDriftFree(root, dialect) {
-	try {
-		if (!hasDeploySchemaDrift(root, dialect)) return;
-	} catch (error) {
-		log.error(getErrorMessage(error));
-		process.exit(1);
-	}
-	log.error(getDeploySchemaDriftMessage());
-	process.exit(1);
-}
-function hasDeploySchemaDrift(root, dialect) {
-	if (!discoverSchema(root, readProjectPaths(root))) return false;
-	const driftRoot = mkDeployDriftCheckRoot(root);
-	const driftProjectRoot = join(driftRoot, "project");
-	createDeployDriftProject(root, driftProjectRoot);
-	try {
-		const migrationsDir = readProjectPaths(driftProjectRoot).migrationsDir;
-		const before = snapshotDir(migrationsDir);
-		const output = runDrizzleKitGenerate(driftProjectRoot, writeDrizzleConfig(driftProjectRoot, dialect === "postgresql" ? "postgresql://dummy" : ":memory:", dialect));
-		const snapshotsEqual = migrationSnapshotsEqual(before, snapshotDir(migrationsDir));
-		if (snapshotsEqual && !output.includes("No schema changes, nothing to migrate")) throw new Error(output || "drizzle-kit generate finished without reporting schema status.");
-		return !snapshotsEqual;
-	} catch (error) {
-		throw new Error(formatDeploySchemaDriftCheckError(error));
-	} finally {
-		rmSync(driftRoot, {
-			recursive: true,
-			force: true
-		});
-		cleanupDeployDriftCheckRoot(root);
-	}
-}
-function runDrizzleKitGenerate(root, configPath) {
-	const result = spawnSync(process.execPath, [
-		drizzleKitBin,
-		"generate",
-		"--config",
-		configPath
-	], {
-		cwd: root,
-		encoding: "utf-8",
-		env: buildEnv()
-	});
-	const stderr = bufferToString(result.stderr);
-	const output = [stderr, bufferToString(result.stdout)].filter(Boolean).join("\n").trim();
-	if (result.error) throw result.error;
-	if (stderr) throw new Error(output);
-	if (result.status !== 0) throw new Error(output || `drizzle-kit generate exited with code ${result.status}.`);
-	return output;
-}
-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);
-	const message = "message" in error ? bufferToString(error.message) : "";
-	if (details.length === 0 && message) details.push(message);
-	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;
-		cpSync(join(root, entry.name), join(driftProjectRoot, entry.name), { recursive: true });
-	}
-}
-function mkDeployDriftCheckRoot(root) {
-	const driftCheckDir = join(root, deployDriftCheckDir);
-	rmSync(driftCheckDir, {
-		recursive: true,
-		force: true
-	});
-	mkdirSync(driftCheckDir, { recursive: true });
-	return mkdtempSync(join(driftCheckDir, "check-"));
-}
-function cleanupDeployDriftCheckRoot(root) {
-	const driftCheckDir = join(root, deployDriftCheckDir);
-	try {
-		if (existsSync(driftCheckDir) && readdirSync(driftCheckDir).length === 0) rmSync(driftCheckDir, {
-			recursive: true,
-			force: true
-		});
-	} catch {}
-}
-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);
-	log.error(`Env validation failed:\n${formatted}`);
-	if (report.missing.length > 0) log.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 { sanitized, stripped } = stripInternalEnvKeys(mergeAndExpand([".env", ".env.production"].map((file) => parseDotenvFile(join(root, file), { expand: false })), { onWarn: (msg) => voidWarn(msg) }));
-	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 { isSandboxEnabled as C, resolveAssetRoutingPolicy as D, hasDocumentRoutes as E, SANDBOX_MIGRATION_TAG as S, hasApiRoutes as T, normalizeWranglerCompatibilityFlags as _, prerenderPagesNode as a, resolveLiveBindingConfig as b, filterLoadedEnv as c, LIVE_MIGRATION_TAG as d, ensureWranglerCompat as f, nextDurableObjectMigrationTag as g, hasDurableObjectSqliteMigration as h, prerenderPages as i, resolveRemoteMode as l, ensureWranglerNodejsAlsFlag as m, resolveDistDir as n, collectRevalidate as o, ensureWranglerCompatibilityDate as p, resolveWorkerDirName as r, hasRevalidate as s, deploy_exports as t, stripInternalEnvKeys as u, readExistingLiveBindingConfig as v, resolveSandboxConfig as w, syncWranglerBindings as x, readWranglerCompat as y };