void 0.10.8 → 0.10.11

package/dist/deploy-C4PbkFyE.mjs

@@ -1,3705 +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-Cj96iiBH.mjs";
-import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-1twldYCW.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-DD9n8Ho-.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-BwvFGhkx.mjs";
-import { t as promptForLoginToken } from "./login-DJReaT_Q.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/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 vcRevalidate = readConfig(root).routing?.revalidate;
-	let revalidate;
-	if (vcRevalidate != null) revalidate = vcRevalidate;
-	const pageScan = existsSync(paths.pagesDir) ? routeScan.pages.pages.length > 0 ? routeScan.pages : await scanPages(root, {
-		output: deployConfig.output,
-		paths
-	}) : null;
-	if (pageScan) {
-		const perPageRules = {};
-		for (const page of pageScan.pages) if (page.revalidate != null) perPageRules[page.pattern] = page.revalidate;
-		if (Object.keys(perPageRules).length > 0) if (typeof revalidate === "number") revalidate = Object.fromEntries([...Object.entries(perPageRules), ["*", revalidate]]);
-		else if (typeof revalidate === "object") revalidate = Object.fromEntries([...Object.entries(perPageRules), ...Object.entries(revalidate)]);
-		else revalidate = perPageRules;
-	}
-	if (deployConfig.output === "static" && pageScan && !isSsr) {
-		if (pageScan.pages.every((p) => p.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 { hasApiRoutes as C, resolveSandboxConfig as S, resolveAssetRoutingPolicy as T, readWranglerCompat as _, prerenderPagesNode as a, SANDBOX_MIGRATION_TAG as b, stripInternalEnvKeys as c, ensureWranglerCompatibilityDate as d, ensureWranglerNodejsAlsFlag as f, readExistingLiveBindingConfig as g, normalizeWranglerCompatibilityFlags as h, prerenderPages as i, LIVE_MIGRATION_TAG as l, nextDurableObjectMigrationTag as m, resolveDistDir as n, filterLoadedEnv as o, hasDurableObjectSqliteMigration as p, resolveWorkerDirName as r, resolveRemoteMode as s, deploy_exports as t, ensureWranglerCompat as u, resolveLiveBindingConfig as v, hasDocumentRoutes as w, isSandboxEnabled as x, syncWranglerBindings as y };