void 0.10.12 → 0.20.0

package/dist/wrangler--imS8n0d.mjs

@@ -0,0 +1,1796 @@
+import { a as isAbsolute, n as dirname, o as join, s as normalize } from "./dist-BrsS7cai.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { appendSqliteClassMigration } from "@void/deploy-core";
+import { createHash } from "node:crypto";
+import { SyntaxKind, applyEdits, createScanner, findNodeAtLocation, modify, parse, parseTree } from "jsonc-parser";
+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 getDefaultSandboxPlatformImage();
+}
+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}$/;
+/** UTF-8 byte-order mark. Node's utf-8 read preserves a leading one. */
+const UTF8_BOM = "";
+const NODEJS_ALS_FLAG = "nodejs_als";
+const NODEJS_COMPAT_FLAG = "nodejs_compat";
+const VOID_CONFIG_FILE = "void.json";
+const MANAGED_QUEUES_MARKER = /^\s*\/\/ void:managed-queues:v1:([A-Za-z0-9_-]+)\s*$/m;
+const PUBLISHED_TRAFFIC_MARKER = /^\s*\/\/ void:published-traffic:v1:([A-Za-z0-9_-]+)\s*$/m;
+const DEFAULT_LIVE_BINDING = "VOID_LIVE";
+const DEFAULT_LIVE_CLASS = "VoidLiveStreamDurableObject";
+const LIVE_MIGRATION_TAG = "live-v1";
+/** Read the root Wrangler config with the same JSONC parser used by binding sync. */
+function readRootWranglerConfig(root) {
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const configPath = join(root, name);
+		if (!existsSync(configPath)) continue;
+		const parsed = parseJsonc(readFileSync(configPath, "utf-8"));
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new SyntaxError(`Failed to parse ${configPath}: expected a JSON object.`);
+		return {
+			configPath,
+			config: parsed
+		};
+	}
+}
+/** Read the last traffic attachment state Void successfully published remotely. */
+function readWranglerPublishedTrafficSnapshot(configPath) {
+	if (!existsSync(configPath)) return;
+	const encoded = PUBLISHED_TRAFFIC_MARKER.exec(readFileSync(configPath, "utf-8"))?.[1];
+	if (!encoded) return;
+	try {
+		const value = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+		if (!isRecord(value) || typeof value.workers_dev !== "boolean" || typeof value.preview_urls !== "boolean" || !Array.isArray(value.routes)) return;
+		return {
+			workers_dev: value.workers_dev,
+			preview_urls: value.preview_urls,
+			routes: value.routes
+		};
+	} catch {
+		return;
+	}
+}
+/** Persist traffic attachment provenance without adding unsupported Wrangler fields. */
+function writeWranglerPublishedTrafficSnapshot(configPath, snapshot, options) {
+	if (!existsSync(configPath)) return;
+	const raw = readFileSync(configPath, "utf-8");
+	const marker = `// void:published-traffic:v1:${Buffer.from(JSON.stringify(snapshot), "utf8").toString("base64url")}`;
+	const existing = PUBLISHED_TRAFFIC_MARKER.exec(raw);
+	if (!existing && options?.create === false) return;
+	const next = existing ? raw.slice(0, existing.index) + marker + raw.slice(existing.index + existing[0].length) : `${marker}${raw.includes("\r\n") ? "\r\n" : "\n"}${raw}`;
+	if (next !== raw) writeFileSync(configPath, next);
+}
+/** 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) {
+		const existing = parsed.durable_objects?.bindings ?? [];
+		const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
+		const retained = existing;
+		for (const route of options.websockets) {
+			const conflict = retained.find((binding) => binding.name === route.bindingName && binding.class_name !== route.className);
+			if (conflict) throw new Error(`websocket: binding '${route.bindingName}' is already configured for class '${conflict.class_name}', but '${route.filePath}' requires '${route.className}'.`);
+		}
+		const additions = options.websockets.filter((route) => !retained.some((binding) => binding.name === route.bindingName)).map((route) => ({
+			name: route.bindingName,
+			class_name: route.className
+		}));
+		const nextBindings = [...retained, ...additions];
+		if (nextBindings.length !== existing.length || nextBindings.some((binding, index) => binding.name !== existing[index]?.name || binding.class_name !== existing[index]?.class_name)) {
+			parsed.durable_objects = {
+				...parsed.durable_objects ?? {},
+				bindings: nextBindings
+			};
+			modified = true;
+		}
+		const planned = appendSqliteClassMigration(migrations, options.websockets.map((route) => route.className), "void-ws-v1", retained.map((binding) => binding.class_name));
+		if (planned.added) {
+			parsed.migrations = planned.migrations;
+			modified = true;
+		}
+	}
+	if (options?.durableObjects && options.durableObjects.length > 0) {
+		const existingBindings = parsed.durable_objects?.bindings ?? [];
+		for (const module of options.durableObjects) {
+			const conflict = existingBindings.find((binding) => binding.name === module.bindingName && binding.class_name !== module.className);
+			if (conflict) throw new Error(`durable: binding '${module.bindingName}' is already configured for class '${conflict.class_name}', but durable-objects/ requires '${module.className}'.`);
+		}
+		const additions = options.durableObjects.filter((module) => !existingBindings.some((binding) => binding.name === module.bindingName)).map((module) => ({
+			name: module.bindingName,
+			class_name: module.className
+		}));
+		if (additions.length > 0) {
+			parsed.durable_objects = { bindings: [...existingBindings, ...additions] };
+			modified = true;
+		}
+		const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
+		for (const module of options.durableObjects) {
+			if (migrations.find((migration) => migration.tag === module.migrationTag && !migration.new_sqlite_classes?.includes(module.className))) throw new Error(`durable: migration tag '${module.migrationTag}' is already used by another Durable Object migration.`);
+			if (!hasDurableObjectSqliteMigration(migrations, module.className)) {
+				migrations.push({
+					tag: module.migrationTag,
+					new_sqlite_classes: [module.className]
+				});
+				modified = true;
+			}
+		}
+		if (modified) parsed.migrations = migrations;
+	}
+	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;
+}
+const NO_INFERRED_BINDINGS = {
+	needsD1: false,
+	needsKV: false,
+	needsR2: false,
+	needsAuth: false,
+	needsQueues: false,
+	needsAI: false,
+	needsSandbox: false,
+	needsLive: false
+};
+/** Persist convention-derived Durable Object bindings and append-only migration history. */
+function syncWranglerDurableObjects(root, durableObjects) {
+	if (durableObjects.length === 0) return false;
+	return syncWranglerBindings(root, NO_INFERRED_BINDINGS, { durableObjects });
+}
+/** Persist WebSocket Durable Object bindings and SQLite migration history. */
+function syncWranglerWebSockets(root, websockets) {
+	if (websockets.length === 0 && !["wrangler.jsonc", "wrangler.json"].some((name) => existsSync(join(root, name)))) return false;
+	return writeProvisionedWranglerConfig(root, { webSockets: websockets }).modified;
+}
+/**
+* Return registered WebSocket classes that no longer have a source route.
+* These classes must remain exported while their data-bearing bindings remain
+* in Wrangler configuration. Arbitrary user Durable Objects are excluded by
+* requiring provenance from Void's WebSocket migration tag.
+*/
+function readWranglerWebSocketTombstones(root, websockets) {
+	const configPath = ["wrangler.jsonc", "wrangler.json"].map((name) => join(root, name)).find((path) => existsSync(path));
+	if (!configPath) return [];
+	const parsed = parseJsonc(readFileSync(configPath, "utf-8"));
+	const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
+	const historicalClasses = new Set(migrations.filter((migration) => /^void-ws-v1(?:-\d+)?$/.test(migration.tag ?? "")).flatMap((migration) => [...migration.new_classes ?? [], ...migration.new_sqlite_classes ?? []]));
+	const currentClasses = new Set(websockets.map((route) => route.className));
+	const bindings = parsed.durable_objects?.bindings;
+	return [...new Set((Array.isArray(bindings) ? bindings : []).flatMap((binding) => typeof binding.class_name === "string" && historicalClasses.has(binding.class_name) && !currentClasses.has(binding.class_name) ? [binding.class_name] : []))].sort();
+}
+/**
+* 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 readManagedQueueProvenance(text) {
+	const encoded = MANAGED_QUEUES_MARKER.exec(text)?.[1];
+	if (!encoded) return {
+		producerBindings: [],
+		consumerQueues: [],
+		pendingConsumerRemovals: []
+	};
+	try {
+		const parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+		if (!isRecord(parsed)) return {
+			producerBindings: [],
+			consumerQueues: [],
+			pendingConsumerRemovals: []
+		};
+		return {
+			producerBindings: Array.isArray(parsed.producerBindings) ? parsed.producerBindings.filter((value) => typeof value === "string") : [],
+			consumerQueues: Array.isArray(parsed.consumerQueues) ? parsed.consumerQueues.filter((value) => typeof value === "string") : [],
+			pendingConsumerRemovals: Array.isArray(parsed.pendingConsumerRemovals) ? parsed.pendingConsumerRemovals.filter((value) => typeof value === "string") : []
+		};
+	} catch {
+		return {
+			producerBindings: [],
+			consumerQueues: [],
+			pendingConsumerRemovals: []
+		};
+	}
+}
+function writeManagedQueueProvenance(text, provenance) {
+	const normalized = {
+		producerBindings: [...new Set(provenance.producerBindings)].sort(),
+		consumerQueues: [...new Set(provenance.consumerQueues)].sort(),
+		pendingConsumerRemovals: [...new Set(provenance.pendingConsumerRemovals)].sort()
+	};
+	const existing = MANAGED_QUEUES_MARKER.exec(text);
+	if (normalized.producerBindings.length === 0 && normalized.consumerQueues.length === 0 && normalized.pendingConsumerRemovals.length === 0) {
+		if (!existing) return text;
+		const start = existing.index;
+		const end = start + existing[0].length;
+		const trailingNewline = text.slice(end).match(/^(\r?\n)/)?.[1] ?? "";
+		return text.slice(0, start) + text.slice(end + trailingNewline.length);
+	}
+	const marker = `// void:managed-queues:v1:${Buffer.from(JSON.stringify(normalized), "utf8").toString("base64url")}`;
+	if (existing) return text.slice(0, existing.index) + marker + text.slice(existing.index + existing[0].length);
+	return `${marker}${text.includes("\r\n") ? "\r\n" : "\n"}${text}`;
+}
+/**
+* Return explicitly Void-owned consumer names that may need remote cleanup.
+*
+* Current managed consumers are included for schema-1 upgrades; the activation layer subtracts
+* consumers still present in the desired config. Pending removals survive failed deploys so a
+* later retry can finish cleanup without inferring ownership from queue naming conventions.
+*/
+function readWranglerManagedQueueCleanupCandidates(configPath) {
+	if (!existsSync(configPath)) return [];
+	const raw = readFileSync(configPath, "utf-8");
+	const provenance = readManagedQueueProvenance(raw.startsWith(UTF8_BOM) ? raw.slice(1) : raw);
+	return [.../* @__PURE__ */ new Set([...provenance.consumerQueues, ...provenance.pendingConsumerRemovals])].sort();
+}
+/** Clear only cleanup tombstones confirmed by a successful trigger reconciliation. */
+function acknowledgeWranglerManagedQueueRemovals(configPath, removedQueues) {
+	if (!existsSync(configPath) || removedQueues.length === 0) return;
+	const raw = readFileSync(configPath, "utf-8");
+	const hasBom = raw.startsWith(UTF8_BOM);
+	const text = hasBom ? raw.slice(1) : raw;
+	const provenance = readManagedQueueProvenance(text);
+	const removed = new Set(removedQueues);
+	const updated = writeManagedQueueProvenance(text, {
+		...provenance,
+		pendingConsumerRemovals: provenance.pendingConsumerRemovals.filter((queue) => !removed.has(queue))
+	});
+	const finalText = hasBom ? `${UTF8_BOM}${updated}` : updated;
+	if (finalText !== raw) writeFileSync(configPath, finalText);
+}
+/**
+* Fill root Wrangler config fields required by generated/provisioned resources, including
+* append-only WebSocket Durable Object bindings and migrations, and Mode B email fields
+* (`send_email`, `addresses`, `vars`) that have no Wrangler command.
+*
+* Comment-preserving: uses `jsonc-parser` `modify()` + `applyEdits()` so
+* comments and unrelated content survive (unlike `syncWranglerBindings`, which
+* round-trips through `JSON.stringify` and strips comments). Every edit is an
+* idempotent upsert — running twice produces byte-identical output.
+*/
+function writeProvisionedWranglerConfig(root, patch, options) {
+	let configPath = options?.configPath;
+	if (configPath === void 0) {
+		for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+			const p = join(root, name);
+			if (existsSync(p)) {
+				configPath = p;
+				break;
+			}
+		}
+		configPath ??= join(root, "wrangler.jsonc");
+	}
+	const rawContent = existsSync(configPath) ? readFileSync(configPath, "utf-8") : "{}";
+	const hasBom = rawContent.startsWith(UTF8_BOM);
+	const original = hasBom ? rawContent.slice(1) : rawContent;
+	let parsed;
+	try {
+		parsed = parseJsonc(original);
+	} catch (error) {
+		throw new Error(`deploy: cannot update "${configPath}" — it is not valid JSON/JSONC. Fix the file and retry. (${error.message})`);
+	}
+	assertNoDuplicateMembers(original, configPath);
+	const formattingOptions = detectFormattingOptions(original);
+	let text = original;
+	const scalarSetPaths = [];
+	const set = (path, value) => {
+		scalarSetPaths.push(path);
+		text = applyMemberEdit(text, path, value, { formattingOptions });
+	};
+	if (patch.accountId !== void 0) set(["account_id"], patch.accountId);
+	if (patch.name !== void 0 && parsed.name === void 0) set(["name"], patch.name);
+	if (patch.compatibilityDate !== void 0 && parsed.compatibility_date === void 0) set(["compatibility_date"], patch.compatibilityDate);
+	if (patch.compatibilityFlags !== void 0) {
+		const existingFlags = parsed.compatibility_flags;
+		if (existingFlags !== void 0 && (!Array.isArray(existingFlags) || !existingFlags.every((flag) => typeof flag === "string"))) throw new Error(`deploy: cannot update "${configPath}" — "compatibility_flags" must be an array of strings.`);
+		const flags = existingFlags ?? [];
+		for (const flag of patch.compatibilityFlags) if (!flags.includes(flag)) {
+			text = applyMemberEdit(text, ["compatibility_flags", flags.length], flag, {
+				formattingOptions,
+				isArrayInsertion: true
+			});
+			flags.push(flag);
+		}
+	}
+	let workerBindingOwners;
+	if (patch.webSockets && patch.webSockets.length > 0) {
+		const requested = /* @__PURE__ */ new Map();
+		for (const route of patch.webSockets) {
+			const existing = requested.get(route.bindingName);
+			if (existing && existing.className !== route.className) throw new Error(`websocket: binding '${route.bindingName}' resolves to both '${existing.className}' and '${route.className}'. Rename one of the route files.`);
+			requested.set(route.bindingName, route);
+		}
+		const knownExistingClasses = bindingEntriesForField("durable_objects", parseJsonc(text).durable_objects).map(({ entry }, index) => {
+			if (typeof entry.class_name !== "string" || entry.class_name.length === 0) throw new Error(`deploy: cannot update "${configPath}" — "durable_objects.bindings" entry at index ${index} is missing a non-empty string "class_name".`);
+			return entry.class_name;
+		});
+		for (const route of requested.values()) {
+			const currentConfig = parseJsonc(text);
+			const durableObjectBindings = bindingEntriesForField("durable_objects", currentConfig.durable_objects);
+			const matches = durableObjectBindings.filter(({ name }) => name === route.bindingName);
+			if (matches.length > 1) throw new Error(`deploy: cannot update "${configPath}" — Durable Object binding '${route.bindingName}' is declared more than once.`);
+			if (matches.length === 1) {
+				const entry = matches[0].entry;
+				if (entry.class_name !== route.className || entry.script_name !== void 0 || entry.environment !== void 0) throw new Error(`websocket: binding '${route.bindingName}' is already configured for another class, script, or environment, but '${route.filePath}' requires the local class '${route.className}'.`);
+				continue;
+			}
+			const owners = collectWorkerBindingNames(configWithoutField(currentConfig, "durable_objects"));
+			addQueueProducerOwners(owners, currentConfig);
+			const owner = owners.get(route.bindingName);
+			if (owner) throw new Error(`deploy: cannot update "${configPath}" — WebSocket binding '${route.bindingName}' is already used by a ${owner} binding.`);
+			text = applyMemberEdit(text, [
+				"durable_objects",
+				"bindings",
+				durableObjectBindings.length
+			], {
+				name: route.bindingName,
+				class_name: route.className
+			}, {
+				formattingOptions,
+				isArrayInsertion: true
+			});
+		}
+		const rawMigrations = parseJsonc(text).migrations;
+		const migrations = validateDurableObjectMigrations(rawMigrations, configPath);
+		const planned = appendSqliteClassMigration(migrations, [...requested.values()].map((route) => route.className), "void-ws-v1", knownExistingClasses);
+		if (planned.added) text = applyMemberEdit(text, ["migrations", migrations.length], planned.migrations[planned.migrations.length - 1], {
+			formattingOptions,
+			isArrayInsertion: true
+		});
+	}
+	const upsertAdoptedBinding = (field, binding, properties, identityKey = "binding") => {
+		const currentConfig = parseJsonc(text);
+		const rawList = currentConfig[field];
+		bindingNamesForField(field, rawList);
+		const currentList = Array.isArray(rawList) ? [...rawList] : [];
+		const matches = [];
+		for (let i = 0; i < currentList.length; i++) {
+			const entry = currentList[i];
+			if (isRecord(entry) && entry[identityKey] === binding) matches.push(i);
+		}
+		if (matches.length > 1) throw new Error(`deploy: cannot update "${configPath}" — binding ${JSON.stringify(binding)} is declared ${matches.length} times in "${field}". Void cannot choose which entry to update, and wrangler rejects duplicate binding names. Remove the duplicate and retry.`);
+		const owners = collectWorkerBindingNames(configWithoutField(currentConfig, field));
+		addQueueProducerOwners(owners, currentConfig);
+		const owner = owners.get(binding);
+		if (owner !== void 0) throw new Error(`deploy: cannot update "${configPath}" — cannot adopt ${JSON.stringify(binding)} into "${field}" because that binding name is already used by a ${owner} binding. Wrangler requires every binding name to be unique across the whole worker, so this would make the config undeployable. Rename the conflicting binding and retry.`);
+		if (matches.length === 1) {
+			const index = matches[0];
+			const existing = isRecord(currentList[index]) ? currentList[index] : {};
+			for (const [key, value] of Object.entries(properties)) if (!jsonEqual(existing[key], value)) set([
+				field,
+				index,
+				key
+			], value);
+		} else text = applyMemberEdit(text, [field, currentList.length], {
+			[identityKey]: binding,
+			...properties
+		}, {
+			formattingOptions,
+			isArrayInsertion: true
+		});
+	};
+	if (patch.d1) upsertAdoptedBinding("d1_databases", patch.d1.binding, {
+		database_name: patch.d1.databaseName,
+		database_id: patch.d1.databaseId
+	});
+	if (patch.kv) upsertAdoptedBinding("kv_namespaces", patch.kv.binding, { id: patch.kv.id });
+	if (patch.r2) upsertAdoptedBinding("r2_buckets", patch.r2.binding, { bucket_name: patch.r2.bucketName });
+	if (patch.hyperdrive) upsertAdoptedBinding("hyperdrive", patch.hyperdrive.binding, { id: patch.hyperdrive.id });
+	if (patch.sendEmail) upsertAdoptedBinding("send_email", patch.sendEmail.name, {}, "name");
+	let d1MigrationsDirSkipped = false;
+	if (patch.d1MigrationsDir) {
+		const currentD1 = parseJsonc(text).d1_databases;
+		const d1Entries = Array.isArray(currentD1) ? currentD1 : [];
+		const matchIndices = [];
+		d1Entries.forEach((entry, i) => {
+			if (entry.binding === patch.d1MigrationsDir.binding) matchIndices.push(i);
+		});
+		if (matchIndices.length > 1) throw new Error(`deploy: cannot update "${configPath}" — binding ${JSON.stringify(patch.d1MigrationsDir.binding)} is declared ${matchIndices.length} times in "d1_databases". A binding name must be unique across the worker (wrangler rejects the config otherwise), so migrations_dir cannot be attached unambiguously. Remove the duplicate D1 entry and retry.`);
+		const index = matchIndices.length === 1 ? matchIndices[0] : -1;
+		if (index >= 0) {
+			const existingPattern = d1Entries[index].migrations_pattern;
+			if (existingPattern !== void 0 && typeof existingPattern !== "string") throw new Error(`deploy: cannot update "${configPath}" — the D1 entry for binding ${JSON.stringify(patch.d1MigrationsDir.binding)} has a non-string "migrations_pattern" value; expected a string. Wrangler rejects such a config, so filling "migrations_dir" beside it would commit an invalid file. Fix the config and retry.`);
+			const existingDir = d1Entries[index].migrations_dir;
+			if (existingDir !== void 0 && typeof existingDir !== "string") throw new Error(`deploy: cannot update "${configPath}" — the D1 entry for binding ${JSON.stringify(patch.d1MigrationsDir.binding)} has a non-string "migrations_dir" value; expected a string. Fix the config and retry.`);
+			if (typeof existingDir === "string") {
+				if (normalizeMigrationsPath(existingDir) !== normalizeMigrationsPath(patch.d1MigrationsDir.dir)) throw new Error(`deploy: cannot update "${configPath}" — the D1 entry for binding ${JSON.stringify(patch.d1MigrationsDir.binding)} already sets "migrations_dir": ${JSON.stringify(existingDir)}, but Void keeps this database's migrations in ${JSON.stringify(patch.d1MigrationsDir.dir)}. Refusing to overwrite an explicit different migrations directory. Either remove "migrations_dir" from the entry (or set it to ${JSON.stringify(patch.d1MigrationsDir.dir)}) to let Void manage it, or move the migrations and keep your directory, then retry.`);
+			} else {
+				if (existingPattern !== void 0 && !migrationsPatternMatchesDir(existingPattern, patch.d1MigrationsDir.dir)) throw new Error(`deploy: cannot update "${configPath}" — the D1 entry for binding ${JSON.stringify(patch.d1MigrationsDir.binding)} has "migrations_pattern": ${JSON.stringify(existingPattern)}, which is not under the requested "migrations_dir": ${JSON.stringify(patch.d1MigrationsDir.dir)}. Wrangler requires the pattern to start with the migrations dir, so this change would break \`wrangler d1 migrations\`. Align "migrations_pattern" with the dir (or remove it) and retry.`);
+				set([
+					"d1_databases",
+					index,
+					"migrations_dir"
+				], patch.d1MigrationsDir.dir);
+			}
+		} else d1MigrationsDirSkipped = true;
+	}
+	const reconcileManagedQueues = patch.queues?.reconcileVoidOwned === true;
+	const managedQueueProvenance = readManagedQueueProvenance(text);
+	const managedProducerBindings = new Set(managedQueueProvenance.producerBindings);
+	const managedConsumerQueues = new Set(managedQueueProvenance.consumerQueues);
+	const pendingConsumerRemovals = new Set(managedQueueProvenance.pendingConsumerRemovals);
+	const upsertQueueEntries = (section, entries) => {
+		if (!entries || entries.length === 0) return;
+		const currentQueues = assertObjectContainer(parseJsonc(text).queues, "queues");
+		if (section === "producers") assertValidQueueProducers(currentQueues?.producers);
+		const currentList = Array.isArray(currentQueues?.[section]) ? [...currentQueues[section]] : [];
+		for (const entry of entries) {
+			let index;
+			if (section === "producers") {
+				const matches = [];
+				for (let i = 0; i < currentList.length; i++) {
+					const existing = currentList[i];
+					if (isRecord(existing) && existing.binding === entry.binding) matches.push(i);
+				}
+				if (matches.length > 1) throw new Error(`deploy: cannot update "${configPath}" — queue producer binding ${JSON.stringify(entry.binding)} is declared ${matches.length} times across producers. A producer binding must map to exactly one queue, so wrangler rejects this config. Remove the duplicate producers and retry.`);
+				if (matches.length === 1) {
+					const existing = currentList[matches[0]];
+					if (isRecord(existing) && existing.queue !== entry.queue) throw new Error(`deploy: cannot update "${configPath}" — queue producer binding ${JSON.stringify(entry.binding)} is already bound to queue ${JSON.stringify(existing.queue)}, but queue ${JSON.stringify(entry.queue)} also requests it. A producer binding must map to exactly one queue. Rename or remove the conflicting producer and retry.`);
+				}
+				index = matches.length === 1 ? matches[0] : -1;
+				workerBindingOwners ??= collectWorkerBindingNames(parseJsonc(text));
+				const bindingName = String(entry.binding);
+				const owner = workerBindingOwners.get(bindingName);
+				if (owner !== void 0) throw new Error(`deploy: cannot update "${configPath}" — queue producer binding ${JSON.stringify(bindingName)} is already used by a ${owner} binding. Wrangler requires every binding name to be unique across the whole worker, so this producer would make the config undeployable. Rename the conflicting binding (or the queue) and retry.`);
+			} else index = currentList.findIndex((existing) => isRecord(existing) && existing.queue === entry.queue);
+			if (index >= 0) {
+				const existing = isRecord(currentList[index]) ? currentList[index] : {};
+				for (const [key, value] of Object.entries(entry)) {
+					if (value === void 0) continue;
+					if (!jsonEqual(existing[key], value)) set([
+						"queues",
+						section,
+						index,
+						key
+					], value);
+				}
+				currentList[index] = {
+					...existing,
+					...entry
+				};
+			} else {
+				text = applyMemberEdit(text, [
+					"queues",
+					section,
+					currentList.length
+				], entry, {
+					formattingOptions,
+					isArrayInsertion: true
+				});
+				currentList.push(entry);
+				if (reconcileManagedQueues) {
+					if (section === "producers" && typeof entry.binding === "string") managedProducerBindings.add(entry.binding);
+					else if (section === "consumers" && typeof entry.queue === "string") managedConsumerQueues.add(entry.queue);
+				}
+			}
+		}
+	};
+	if (patch.queues) {
+		if (patch.queues.reconcileVoidOwned) {
+			const queues = assertObjectContainer(parseJsonc(text).queues, "queues");
+			assertValidQueueProducers(queues?.producers);
+			const producers = Array.isArray(queues?.producers) ? queues.producers : [];
+			const desiredBindings = new Set((patch.queues.producers ?? []).map((producer) => producer.binding));
+			const staleProducerIndexes = [];
+			for (let index = 0; index < producers.length; index++) {
+				const producer = producers[index];
+				if (typeof producer.binding === "string" && managedProducerBindings.has(producer.binding) && !desiredBindings.has(producer.binding)) {
+					staleProducerIndexes.push(index);
+					managedProducerBindings.delete(producer.binding);
+				}
+			}
+			for (const index of staleProducerIndexes.reverse()) set([
+				"queues",
+				"producers",
+				index
+			], void 0);
+			const consumers = Array.isArray(queues?.consumers) ? queues.consumers : [];
+			const desiredConsumerQueues = new Set((patch.queues.consumers ?? []).map((consumer) => consumer.queue));
+			const staleConsumerIndexes = consumers.flatMap((consumer, index) => {
+				if (typeof consumer.queue === "string" && managedConsumerQueues.has(consumer.queue) && !desiredConsumerQueues.has(consumer.queue)) {
+					managedConsumerQueues.delete(consumer.queue);
+					pendingConsumerRemovals.add(consumer.queue);
+					return [index];
+				}
+				return [];
+			});
+			for (const index of staleConsumerIndexes.reverse()) set([
+				"queues",
+				"consumers",
+				index
+			], void 0);
+		}
+		upsertQueueEntries("producers", patch.queues.producers);
+		upsertQueueEntries("consumers", patch.queues.consumers);
+		for (const consumer of patch.queues.consumers ?? []) pendingConsumerRemovals.delete(consumer.queue);
+	}
+	if (patch.vars) {
+		const currentConfig = parseJsonc(text);
+		bindingNamesForField("vars", currentConfig.vars);
+		const currentVars = isRecord(currentConfig.vars) ? currentConfig.vars : {};
+		const owners = collectWorkerBindingNames(configWithoutField(currentConfig, "vars"));
+		addQueueProducerOwners(owners, currentConfig);
+		for (const [key, value] of Object.entries(patch.vars)) {
+			const owner = owners.get(key);
+			if (owner !== void 0) throw new Error(`deploy: cannot update "${configPath}" — cannot write var ${JSON.stringify(key)} because that binding name is already used by a ${owner} binding. Wrangler requires every binding name to be unique across the whole worker, so this would make the config undeployable. Rename the conflicting binding and retry.`);
+			if (!jsonEqual(currentVars[key], value)) set(["vars", key], value);
+		}
+	}
+	if (patch.addresses !== void 0) {
+		const currentAddresses = parseJsonc(text).addresses;
+		if (patch.addresses === null) text = removeMember(text, ["addresses"], { formattingOptions });
+		else if (!jsonEqual(currentAddresses, patch.addresses)) text = applyMemberEdit(text, ["addresses"], patch.addresses, { formattingOptions });
+	}
+	const droppedComment = findDroppedComment(extractCommentTokens(original), extractCommentTokens(text));
+	if (droppedComment !== void 0) {
+		const originalRoot = parseTree(original, void 0, { allowTrailingComma: true });
+		const compositeField = originalRoot ? scalarSetPaths.find((path) => {
+			const node = findNodeAtLocation(originalRoot, path);
+			return node?.type === "object" || node?.type === "array";
+		}) : void 0;
+		if (compositeField) {
+			const field = String(compositeField[compositeField.length - 1]);
+			throw new Error(`deploy: cannot update "${configPath}" — "${field}" has an object/array value; expected a string. Fix the config and retry.`);
+		}
+		throw new Error(`deploy: cannot update "${configPath}" — this edit would drop a comment (${droppedComment}); the writer refuses to corrupt the file — simplify the surrounding structure and retry.`);
+	}
+	if (reconcileManagedQueues) {
+		const finalQueues = assertObjectContainer(parseJsonc(text).queues, "queues");
+		const finalProducerBindings = new Set((Array.isArray(finalQueues?.producers) ? finalQueues.producers : []).flatMap((entry) => isRecord(entry) && typeof entry.binding === "string" ? [entry.binding] : []));
+		const finalConsumerQueues = new Set((Array.isArray(finalQueues?.consumers) ? finalQueues.consumers : []).flatMap((entry) => isRecord(entry) && typeof entry.queue === "string" ? [entry.queue] : []));
+		text = writeManagedQueueProvenance(text, {
+			producerBindings: [...managedProducerBindings].filter((binding) => finalProducerBindings.has(binding)),
+			consumerQueues: [...managedConsumerQueues].filter((queue) => finalConsumerQueues.has(queue)),
+			pendingConsumerRemovals: [...pendingConsumerRemovals]
+		});
+	}
+	const finalText = hasBom ? `${UTF8_BOM}${text}` : text;
+	const modified = finalText !== rawContent;
+	if (modified) writeFileSync(configPath, finalText);
+	return {
+		configPath,
+		modified,
+		d1MigrationsDirSkipped
+	};
+}
+/** Read the custom-domain routes owned by the root Wrangler config. */
+function readWranglerCustomDomains(root) {
+	const configPath = discoverWranglerConfigPath(root);
+	const raw = existsSync(configPath) ? readFileSync(configPath, "utf-8") : "{}";
+	const text = raw.startsWith(UTF8_BOM) ? raw.slice(1) : raw;
+	const parsed = parseJsonc(text);
+	assertNoDuplicateMembers(text, configPath);
+	return {
+		configPath,
+		domains: parseCustomDomains(parsed.routes, configPath),
+		modified: false
+	};
+}
+/**
+* Add or remove one Wrangler `custom_domain` route without rewriting unrelated
+* configuration. The returned domain list is the post-edit source of truth used
+* by `void domain list|status` on direct Cloudflare projects.
+*/
+function updateWranglerCustomDomain(root, hostname, action) {
+	const configPath = discoverWranglerConfigPath(root);
+	if (!existsSync(configPath)) throw new Error(`domain: No Wrangler config found at "${configPath}". Run \`void init\` first.`);
+	const raw = readFileSync(configPath, "utf-8");
+	const hasBom = raw.startsWith(UTF8_BOM);
+	const original = hasBom ? raw.slice(1) : raw;
+	const parsed = parseJsonc(original);
+	assertNoDuplicateMembers(original, configPath);
+	if (parsed.route !== void 0) throw new Error(`domain: "${configPath}" uses the singular "route" field. Convert it to a "routes" array before managing custom domains so the existing route cannot be shadowed.`);
+	const routes = parsed.routes;
+	if (routes !== void 0 && !Array.isArray(routes)) throw new Error(`domain: "routes" in "${configPath}" must be an array.`);
+	const routeArray = routes ?? [];
+	const matches = [];
+	for (let index = 0; index < routeArray.length; index++) {
+		const route = routeArray[index];
+		if (typeof route === "string") {
+			if (route === hostname) throw new Error(`domain: ${JSON.stringify(hostname)} already exists as a non-custom route in "${configPath}". Remove or convert that route first.`);
+			continue;
+		}
+		if (typeof route !== "object" || route === null || Array.isArray(route)) throw new Error(`domain: "routes[${index}]" in "${configPath}" is malformed.`);
+		const entry = route;
+		if (entry.pattern !== hostname) continue;
+		if (entry.custom_domain !== true) throw new Error(`domain: ${JSON.stringify(hostname)} already exists as a non-custom route in "${configPath}". Remove or convert that route first.`);
+		matches.push(index);
+	}
+	if (matches.length > 1) throw new Error(`domain: ${JSON.stringify(hostname)} is declared more than once in "${configPath}". Remove the duplicate before continuing.`);
+	let text = original;
+	const formattingOptions = detectFormattingOptions(original);
+	if (action === "add" && matches.length === 0) {
+		text = applyMemberEdit(text, ["routes", routeArray.length], {
+			pattern: hostname,
+			custom_domain: true
+		}, {
+			formattingOptions,
+			isArrayInsertion: true
+		});
+		const dropped = findDroppedComment(extractCommentTokens(original), extractCommentTokens(text));
+		if (dropped !== void 0) throw new Error(`domain: cannot update "${configPath}" because the edit would drop a comment (${dropped}).`);
+	} else if (action === "delete" && matches.length === 1) text = applyEdits(text, modify(text, ["routes", matches[0]], void 0, { formattingOptions }));
+	const finalText = hasBom ? `${UTF8_BOM}${text}` : text;
+	const modified = finalText !== raw;
+	if (modified) writeFileSync(configPath, finalText);
+	return {
+		configPath,
+		domains: parseCustomDomains(parseJsonc(text).routes, configPath),
+		modified
+	};
+}
+function discoverWranglerConfigPath(root) {
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const path = join(root, name);
+		if (existsSync(path)) return path;
+	}
+	return join(root, "wrangler.jsonc");
+}
+function parseCustomDomains(value, configPath) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`domain: "routes" in "${configPath}" must be an array.`);
+	const domains = [];
+	for (let index = 0; index < value.length; index++) {
+		const route = value[index];
+		if (typeof route === "string") continue;
+		if (typeof route !== "object" || route === null || Array.isArray(route)) throw new Error(`domain: "routes[${index}]" in "${configPath}" is malformed.`);
+		const entry = route;
+		if (entry.custom_domain !== true) continue;
+		if (typeof entry.pattern !== "string" || entry.pattern.length === 0) throw new Error(`domain: custom domain route "routes[${index}]" in "${configPath}" needs a non-empty pattern.`);
+		domains.push({
+			pattern: entry.pattern,
+			customDomain: true
+		});
+	}
+	return domains;
+}
+/**
+* Extract the multiset of comment TOKENS (line + block) from JSONC source using
+* jsonc-parser's scanner — exact by construction, no regex. Each token is its
+* verbatim source slice, so a relocated comment keeps identical text (its
+* multiset entry is unchanged) while a dropped comment removes one.
+*/
+function extractCommentTokens(text) {
+	const scanner = createScanner(text, false);
+	const tokens = [];
+	let kind = scanner.scan();
+	while (kind !== SyntaxKind.EOF) {
+		if (kind === SyntaxKind.LineCommentTrivia || kind === SyntaxKind.BlockCommentTrivia) {
+			const offset = scanner.getTokenOffset();
+			tokens.push(text.slice(offset, offset + scanner.getTokenLength()));
+		}
+		kind = scanner.scan();
+	}
+	return tokens;
+}
+/**
+* Multiset-subset check: return the first comment token present in `before` but
+* missing (accounting for repeats) from `after`, or `undefined` when `after` is
+* a superset of `before`. The final gate uses this to prove no comment TEXT was
+* dropped by the edits.
+*/
+function findDroppedComment(before, after) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const token of after) counts.set(token, (counts.get(token) ?? 0) + 1);
+	for (const token of before) {
+		const remaining = counts.get(token) ?? 0;
+		if (remaining <= 0) return token;
+		counts.set(token, remaining - 1);
+	}
+}
+/**
+* Detect indentation from an existing config so `jsonc-parser` formats inserted
+* content to match. Falls back to two-space indentation (the repo default).
+*/
+function detectFormattingOptions(text) {
+	const match = text.match(/^([ \t]+)\S/m);
+	if (match) {
+		const indent = match[1];
+		if (indent.startsWith("	")) return {
+			tabSize: 1,
+			insertSpaces: false
+		};
+		return {
+			tabSize: indent.length,
+			insertSpaces: true
+		};
+	}
+	return {
+		tabSize: 2,
+		insertSpaces: 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;
+}
+/**
+* `modify()` + `applyEdits()`, but when the edit APPENDS a new member after a
+* sibling that carries a trailing inline comment, keep that comment attached to
+* the sibling it documented.
+*
+* jsonc-parser's formatting `modify()` reflows the whole enclosing member/entry
+* region and re-emits a trailing inline comment at the END of that region — so
+* inserting `migrations_dir` after `"database_id": "id" // production db` (or
+* appending a queue entry after `{ … } // jobs producer`) silently reassociates
+* the comment onto the NEWLY inserted member. That violates the writer's
+* comment-preservation contract. Here we detect that exact case, run the
+* (comment-free) formatting edit on a stripped copy, then splice the comment
+* back right after the sibling's separating comma so it stays put.
+*
+* Every other edit (value replacement, append after a comment-free sibling,
+* first insertion into a missing container) falls through to the plain path, so
+* behavior is byte-identical to before outside the trailing-comment case.
+*/
+function applyMemberEdit(text, path, value, options) {
+	const plain = () => applyEdits(text, modify(text, path, value, options));
+	const root = parseTree(text, void 0, { allowTrailingComma: true });
+	if (!root) return plain();
+	if (!options.isArrayInsertion && findNodeAtLocation(root, path) !== void 0) return plain();
+	let receivingPath = path.slice(0, -1);
+	let container = findNodeAtLocation(root, receivingPath);
+	while (!container && receivingPath.length > 0) {
+		receivingPath = receivingPath.slice(0, -1);
+		container = findNodeAtLocation(root, receivingPath);
+	}
+	const members = container?.children;
+	if (!container || !members || members.length === 0) return plain();
+	const last = members[members.length - 1];
+	const trailing = readTrailingComment(text, last.offset + last.length);
+	if (!trailing) return plain();
+	const stripped = text.slice(0, last.offset + last.length) + text.slice(trailing.end);
+	const rewritten = applyEdits(stripped, modify(stripped, path, value, options));
+	const newRoot = parseTree(rewritten, void 0, { allowTrailingComma: true });
+	const newContainer = newRoot ? findNodeAtLocation(newRoot, receivingPath) : void 0;
+	const newMembers = newContainer?.children;
+	if (!newRoot || !newContainer || !newMembers || newMembers.length < 2) return plain();
+	const sibling = newMembers[newMembers.length - 2];
+	const commaPos = rewritten.indexOf(",", sibling.offset + sibling.length);
+	if (commaPos === -1) return plain();
+	const relocated = `${rewritten.slice(0, commaPos + 1)} ${trailing.text}${rewritten.slice(commaPos + 1)}`;
+	const plainResult = plain();
+	let relocatedParsed;
+	try {
+		relocatedParsed = parseJsonc(relocated);
+	} catch {
+		return plainResult;
+	}
+	if (!jsonEqual(relocatedParsed, parseJsonc(plainResult))) return plainResult;
+	return relocated;
+}
+/**
+* Remove one object member (the property at `path`), keeping every comment.
+*
+* jsonc-parser's `modify(text, path, undefined)` deletes from the END of the
+* previous member to the end of the removed one — so the previous sibling's
+* trailing comment, a full-line comment above the member, and the member's own
+* trailing comment all vanish (measured on 4.x). The final comment gate would
+* then refuse the write for the common `"name": "app", // worker` shape. Here
+* the property node's exact source range is spliced out instead, plus ONE
+* separating comma (the following one when present, else the preceding one so
+* a strict `.json` file never gains a trailing comma) and the now-blank line it
+* sat on. Comments are never inside those ranges, so they all stay put; a
+* comment that was attached to the removed member is left orphaned on its line.
+*
+* Validate-before-return backstop: the spliced text must parse and equal the
+* plain `modify()` result's data; otherwise the plain edit is returned and the
+* final gate decides. An absent member is a no-op.
+*/
+function removeMember(text, path, options) {
+	const root = parseTree(text, void 0, { allowTrailingComma: true });
+	const valueNode = root ? findNodeAtLocation(root, path) : void 0;
+	const property = valueNode?.parent;
+	if (!root || !valueNode || !property || property.type !== "property") return valueNode ? applyEdits(text, modify(text, path, void 0, options)) : text;
+	const start = property.offset;
+	const end = property.offset + property.length;
+	const scanner = createScanner(text, false);
+	const tokens = [];
+	for (let kind = scanner.scan(); kind !== SyntaxKind.EOF; kind = scanner.scan()) tokens.push({
+		kind,
+		offset: scanner.getTokenOffset(),
+		length: scanner.getTokenLength()
+	});
+	const isTrivia = (kind) => kind === SyntaxKind.Trivia || kind === SyntaxKind.LineBreakTrivia || kind === SyntaxKind.LineCommentTrivia || kind === SyntaxKind.BlockCommentTrivia;
+	const following = tokens.find((token) => token.offset >= end && !isTrivia(token.kind));
+	const preceding = [...tokens].reverse().find((token) => token.offset + token.length <= start && !isTrivia(token.kind));
+	const comma = following?.kind === SyntaxKind.CommaToken ? following : preceding?.kind === SyntaxKind.CommaToken ? preceding : void 0;
+	const ranges = [{
+		offset: start,
+		length: end - start
+	}];
+	if (comma) ranges.push({
+		offset: comma.offset,
+		length: comma.length
+	});
+	ranges.sort((a, b) => b.offset - a.offset);
+	let spliced = text;
+	for (const range of ranges) spliced = spliced.slice(0, range.offset) + spliced.slice(range.offset + range.length);
+	const cursor = comma && comma.offset < start ? start - comma.length : start;
+	let lineStart = cursor;
+	while (lineStart > 0 && spliced[lineStart - 1] !== "\n" && spliced[lineStart - 1] !== "\r") lineStart--;
+	let lineEnd = cursor;
+	while (lineEnd < spliced.length && spliced[lineEnd] !== "\n" && spliced[lineEnd] !== "\r") lineEnd++;
+	if (spliced.slice(lineStart, lineEnd).trim() === "") {
+		const terminator = spliced.startsWith("\r\n", lineEnd) ? 2 : lineEnd < spliced.length ? 1 : 0;
+		spliced = spliced.slice(0, lineStart) + spliced.slice(lineEnd + terminator);
+	}
+	const plainResult = applyEdits(text, modify(text, path, void 0, options));
+	let splicedParsed;
+	try {
+		splicedParsed = parseJsonc(spliced);
+	} catch {
+		return plainResult;
+	}
+	if (!jsonEqual(splicedParsed, parseJsonc(plainResult))) return plainResult;
+	return spliced;
+}
+/**
+* If a trailing inline comment sits on the same line right after `offset`,
+* return its text and end offset. Only whitespace and an OPTIONAL single
+* separator comma may sit between the sibling's value and the comment — so both
+* `"id": "x" // c` and `"id": "x", // c` (a JSONC trailing comma, or the
+* separator once a sibling follows) are recognized. A `//` line comment or a
+* single-line `/* *\/` block comment counts; a newline or closing bracket first
+* means there is no trailing comment (returns undefined). `offset` points just
+* past the sibling's value, and the sibling is always its container's LAST
+* member, so any comma here is a trailing/separator comma — never a boundary to
+* an existing following member.
+*/
+function readTrailingComment(text, offset) {
+	let i = offset;
+	while (i < text.length && (text[i] === " " || text[i] === "	")) i++;
+	if (text[i] === ",") {
+		i++;
+		while (i < text.length && (text[i] === " " || text[i] === "	")) i++;
+	}
+	if (text[i] === "/" && text[i + 1] === "/") {
+		let end = i;
+		while (end < text.length && text[end] !== "\n" && text[end] !== "\r") end++;
+		return {
+			text: text.slice(i, end),
+			end
+		};
+	}
+	if (text[i] === "/" && text[i + 1] === "*") {
+		const close = text.indexOf("*/", i + 2);
+		if (close === -1) return;
+		const end = close + 2;
+		const slice = text.slice(i, end);
+		if (slice.includes("\n") || slice.includes("\r")) return;
+		return {
+			text: slice,
+			end
+		};
+	}
+}
+/**
+* Throw (without writing) if any object in the config declares the same member
+* name twice. See the call site for why a duplicate makes property-level upserts
+* silently ineffective. Walks the jsonc AST so nested objects (queue consumers,
+* D1 entries, …) are covered, not just the top level.
+*/
+function assertNoDuplicateMembers(text, configPath) {
+	const root = parseTree(text, void 0, { allowTrailingComma: true });
+	if (!root) return;
+	const walk = (node) => {
+		if (node.type === "object" && node.children) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const property of node.children) {
+				const keyNode = property.children?.[0];
+				const key = keyNode?.value;
+				if (typeof key !== "string") continue;
+				if (seen.has(key)) {
+					const { line, column } = offsetToLineColumn(text, keyNode.offset);
+					throw new Error(`deploy: cannot update "${configPath}" — duplicate key ${JSON.stringify(key)} at line ${line}, column ${column}. Wrangler reads the last of two duplicate members, but this writer edits the first, so the update would silently not apply. Remove the duplicate and retry.`);
+				}
+				seen.add(key);
+			}
+		}
+		if (node.children) for (const child of node.children) walk(child);
+	};
+	walk(root);
+}
+/** 1-based line/column for a byte offset — used in duplicate-key error messages. */
+function offsetToLineColumn(text, offset) {
+	let line = 1;
+	let column = 1;
+	const limit = Math.min(offset, text.length);
+	for (let i = 0; i < limit; i++) if (text[i] === "\n") {
+		line += 1;
+		column = 1;
+	} else column += 1;
+	return {
+		line,
+		column
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateDurableObjectMigrations(value, configPath) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`deploy: cannot update "${configPath}" — "migrations" must be an array of Durable Object migration steps.`);
+	const tags = /* @__PURE__ */ new Set();
+	for (const [index, migration] of value.entries()) {
+		if (!isRecord(migration) || typeof migration.tag !== "string" || migration.tag.length === 0) throw new Error(`deploy: cannot update "${configPath}" — migration at index ${index} must be an object with a non-empty string "tag".`);
+		if (tags.has(migration.tag)) throw new Error(`deploy: cannot update "${configPath}" — migration tag '${migration.tag}' is declared more than once.`);
+		tags.add(migration.tag);
+		for (const field of [
+			"new_classes",
+			"new_sqlite_classes",
+			"deleted_classes"
+		]) {
+			const classes = migration[field];
+			if (classes !== void 0 && (!Array.isArray(classes) || classes.some((className) => typeof className !== "string"))) throw new Error(`deploy: cannot update "${configPath}" — "migrations[${index}].${field}" must be an array of class names.`);
+		}
+		const renamed = migration.renamed_classes;
+		if (renamed !== void 0 && (!Array.isArray(renamed) || renamed.some((entry) => !isRecord(entry) || typeof entry.from !== "string" || typeof entry.to !== "string"))) throw new Error(`deploy: cannot update "${configPath}" — "migrations[${index}].renamed_classes" has an invalid entry.`);
+		const transferred = migration.transferred_classes;
+		if (transferred !== void 0 && (!Array.isArray(transferred) || transferred.some((entry) => !isRecord(entry) || typeof entry.from !== "string" || typeof entry.from_script !== "string" || typeof entry.to !== "string"))) throw new Error(`deploy: cannot update "${configPath}" — "migrations[${index}].transferred_classes" has an invalid entry.`);
+	}
+	return value;
+}
+/**
+* wrangler's friendly label for each binding namespace. Mirrors
+* `friendlyBindingNames` in `wrangler-dist/cli.js` — the map
+* `validateBindingsHaveUniqueNames` iterates to gather every worker-wide binding
+* name. Drives the owner name in the worker-wide producer-collision error.
+*
+* This is a 1:1 copy of wrangler's `friendlyBindingNames` EXCEPT `queues`, which
+* is intentionally ABSENT: wrangler folds in `queues.producers`, but here producer
+* identity is handled by the upsert's own binding-match logic (and consumers carry
+* no binding), so including it would flag the very producer we are about to append
+* as a self-collision. Every OTHER field wrangler enumerates is present (including
+* `unsafe_hello_world`). `secrets.required` — which wrangler folds in separately
+* under the label "Secret", not via this map — is handled in
+* `collectWorkerBindingNames`.
+*/
+const FRIENDLY_BINDING_NAMES = {
+	data_blobs: "Data Blob",
+	durable_objects: "Durable Object",
+	kv_namespaces: "KV Namespace",
+	send_email: "Send Email",
+	d1_databases: "D1 Database",
+	vectorize: "Vectorize Index",
+	ai_search_namespaces: "AI Search Namespace",
+	ai_search: "AI Search Instance",
+	websearch: "Web Search",
+	agent_memory: "Agent Memory",
+	hyperdrive: "Hyperdrive Config",
+	r2_buckets: "R2 Bucket",
+	logfwdr: "logfwdr",
+	services: "Worker",
+	analytics_engine_datasets: "Analytics Engine Dataset",
+	text_blobs: "Text Blob",
+	browser: "Browser Run",
+	ai: "AI",
+	images: "Images",
+	stream: "Stream",
+	media: "Media",
+	version_metadata: "Worker Version Metadata",
+	unsafe: "Unsafe Metadata",
+	vars: "Environment Variable",
+	wasm_modules: "Wasm Module",
+	dispatch_namespaces: "Dispatch Namespace",
+	mtls_certificates: "mTLS Certificate",
+	workflows: "Workflow",
+	pipelines: "Pipeline",
+	secrets_store_secrets: "Secrets Store Secret",
+	artifacts: "Artifacts",
+	ratelimits: "Rate Limit",
+	assets: "Assets",
+	unsafe_hello_world: "Hello World",
+	flagship: "Flagship",
+	worker_loaders: "Worker Loader",
+	vpc_services: "VPC Service",
+	vpc_networks: "VPC Network"
+};
+/**
+* Collect every binding NAME already used across the worker config, mapped to
+* wrangler's friendly owner label (first writer wins on ties). Mirrors the exact
+* name set `validateBindingsHaveUniqueNames` builds in `wrangler-dist/cli.js`:
+* `getBindingNames(config[field])` for every `friendlyBindingNames` field, PLUS
+* `config.secrets.required` under the label "Secret" — minus `queues` (see
+* FRIENDLY_BINDING_NAMES for why). Used to fail closed before appending a queue
+* producer whose binding collides with any other worker-wide binding.
+*/
+function collectWorkerBindingNames(config) {
+	const owners = /* @__PURE__ */ new Map();
+	const claim = (name, friendly) => {
+		if (!owners.has(name)) owners.set(name, friendly);
+	};
+	for (const [field, friendly] of Object.entries(FRIENDLY_BINDING_NAMES)) for (const name of bindingNamesForField(field, config[field])) claim(name, friendly);
+	const secrets = assertObjectContainer(config.secrets, "secrets");
+	if (secrets && secrets.required !== void 0) {
+		if (!Array.isArray(secrets.required)) throw new Error("deploy: cannot verify binding-name uniqueness — \"secrets.required\" must be an array of secret names. Fix the wrangler config and retry.");
+		secrets.required.forEach((name, index) => {
+			if (typeof name !== "string" || name.length === 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "secrets.required" contains a malformed entry at index ${index} (expected a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped entry could hide a real collision). Fix the wrangler config and retry.`);
+			claim(name, "Secret");
+		});
+	}
+	return owners;
+}
+/** A shallow copy of `config` with one field omitted (never mutates the input). */
+function configWithoutField(config, field) {
+	const { [field]: _omit, ...rest } = config;
+	return rest;
+}
+/**
+* Add every `queues.producers[].binding` to an existing worker-binding owner map,
+* under the friendly label "Queue" (first-writer-wins). The base
+* `collectWorkerBindingNames` deliberately OMITS queues so the producer-append
+* path does not flag the producer it is adding as a self-collision — but for the
+* ADOPT path a producer binding sharing the adopted binding IS a real cross-type
+* collision wrangler rejects at deploy, so the adopt guard layers producers on
+* top of the reused collector.
+*/
+function addQueueProducerOwners(owners, config) {
+	const queues = assertObjectContainer(config.queues, "queues");
+	if (!queues || queues.producers === void 0) return;
+	for (const producer of assertValidQueueProducers(queues.producers)) {
+		const binding = producer.binding;
+		if (!owners.has(binding)) owners.set(binding, "Queue");
+	}
+}
+/**
+* The ONE strict `queues.producers` validator, shared by BOTH the adopt-guard's
+* owner collection ({@link addQueueProducerOwners}) and the producer-upsert path (which
+* otherwise clones the list and silently skips non-record members, committing a new
+* producer beside a corrupt list). A non-array, or any member that is not a record with
+* a non-empty string `binding`, THROWS (fail closed) rather than being dropped — a
+* dropped/hidden producer could mask a real binding collision. Returns the validated
+* producer records (each guaranteed to carry a non-empty string `binding`).
+*/
+function assertValidQueueProducers(producers) {
+	if (producers === void 0) return [];
+	if (!Array.isArray(producers)) throw new Error("deploy: cannot verify binding-name uniqueness — \"queues.producers\" must be an array. Fix the wrangler config and retry.");
+	return producers.map((producer, index) => {
+		if (!isRecord(producer) || typeof producer.binding !== "string" || producer.binding.length === 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "queues.producers" contains a malformed entry at index ${index} (missing a non-empty string "binding"). Refusing to proceed on a partially-readable binding set (a dropped producer could hide a real collision). Fix the wrangler config and retry.`);
+		return producer;
+	});
+}
+/**
+* Validate the OUTER shape of a wrangler container field that wrangler 4.131
+* requires to be an OBJECT (`queues`, `secrets`). A PRESENT-but-non-object container
+* (array/string/number/null) is malformed for wrangler AND would bypass the binding
+* collectors, HIDING a real cross-type binding collision — so it THROWS (fail closed).
+* An ABSENT container (undefined) returns undefined (a no-op, NOT an error).
+* Returns the container as a record when present-and-object.
+*
+* NOTE: `null` is `typeof 'object'` but `isRecord(null)` is false, so `secrets: null` /
+* `queues: null` (present but null) THROWS — correct (wrangler requires an object).
+* Absent (`undefined`) is the only no-op.
+*/
+function assertObjectContainer(value, field) {
+	if (value === void 0) return;
+	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object. Refusing to proceed on a partially-readable binding set (a wrong-shaped container could hide a real collision). Fix the wrangler config and retry.`);
+	return value;
+}
+/**
+* The worker-wide OWNER of a binding name as the writer's adopt / `vars` guards see it:
+* validates `field`'s own outer shape (throws on a malformed target, fail closed), then
+* looks `name` up among every OTHER binding type — `queues.producers` included — and
+* returns wrangler's friendly label for the owner, or `undefined` when the name is free
+* (or held only by `field` itself). Lets a caller refuse a doomed write BEFORE side
+* effects the write would otherwise follow (the Mode B email step). Reuses the ONE
+* collector — never fork it.
+*/
+function findBindingNameOwner(config, field, name) {
+	bindingNamesForField(field, config[field]);
+	const owners = collectWorkerBindingNames(configWithoutField(config, field));
+	addQueueProducerOwners(owners, config);
+	return owners.get(name);
+}
+/**
+* The STRICT canonical reader for a single provisioned binding entry in a wrangler
+* config field (`d1_databases` / `kv_namespaces` / `r2_buckets` / `hyperdrive`). Replaces
+* the provisioner's loose first-match `.find()` — which validated no outer shape,
+* silently picked among duplicates, and bypassed the worker-wide collision check, so a
+* duplicate/cross-type-collision config could be reported `reused` or pass a create
+* postcondition though it is undeployable. Fails closed on:
+*   1. a malformed TARGET field (reuses {@link bindingNamesForField}: a non-array outer
+*      shape, or any member without a non-empty string `binding`, throws);
+*   2. MORE THAN ONE entry in the target field sharing `binding` (ambiguous identity —
+*      wrangler also rejects duplicate binding names);
+*   3. a worker-wide CROSS-TYPE collision — `binding` is ALSO owned by any OTHER binding
+*      type (reuses the {@link collectWorkerBindingNames} Task-3 collector, EXCLUDING the
+*      target field so the entry never self-collides, and INCLUDING `queues.producers`).
+* Returns the single matching entry, or `undefined` when the binding is absent.
+*/
+function readProvisionedBindingEntry(config, field, binding, configPath) {
+	bindingNamesForField(field, config[field]);
+	const rawList = config[field];
+	const matches = (Array.isArray(rawList) ? rawList : []).filter((entry) => isRecord(entry) && entry.binding === binding);
+	if (matches.length > 1) throw new Error(`provision: cannot read "${configPath}" — binding ${JSON.stringify(binding)} is declared ${matches.length} times in "${field}". Cannot pick one to reuse/verify, and wrangler rejects duplicate binding names. Remove the duplicate and retry.`);
+	const owners = collectWorkerBindingNames(configWithoutField(config, field));
+	addQueueProducerOwners(owners, config);
+	const owner = owners.get(binding);
+	if (owner !== void 0) throw new Error(`provision: cannot read "${configPath}" — binding ${JSON.stringify(binding)} in "${field}" is also used by a ${owner} binding. Wrangler requires every binding name to be unique across the whole worker, so this config is undeployable. Rename the conflicting binding and retry.`);
+	return matches[0];
+}
+/**
+* Explicit per-field shape metadata (see {@link BindingFieldShape}), transcribed
+* from wrangler 4.131's config schema. Any `FRIENDLY_BINDING_NAMES` field absent here is
+* a `namespace-array` (`[{ binding }]`) — the shape wrangler's `getBindingNames` reads
+* via its `isNamespaceList` branch.
+*/
+const BINDING_FIELD_SHAPES = {
+	vars: { kind: "key-map" },
+	wasm_modules: { kind: "key-map" },
+	text_blobs: { kind: "key-map" },
+	data_blobs: { kind: "key-map" },
+	send_email: { kind: "name-keyed-array" },
+	ratelimits: { kind: "name-keyed-array" },
+	addresses: { kind: "whole-object" },
+	ai: {
+		kind: "singleton",
+		bindingRequired: true
+	},
+	browser: {
+		kind: "singleton",
+		bindingRequired: true
+	},
+	images: {
+		kind: "singleton",
+		bindingRequired: true
+	},
+	stream: {
+		kind: "singleton",
+		bindingRequired: true
+	},
+	media: {
+		kind: "singleton",
+		bindingRequired: true
+	},
+	websearch: {
+		kind: "singleton",
+		bindingRequired: true
+	},
+	version_metadata: {
+		kind: "singleton",
+		bindingRequired: true
+	},
+	assets: {
+		kind: "singleton",
+		bindingRequired: false
+	},
+	durable_objects: {
+		kind: "binding-list",
+		bindingsRequired: true
+	},
+	logfwdr: {
+		kind: "binding-list",
+		bindingsRequired: true
+	},
+	unsafe: {
+		kind: "binding-list",
+		bindingsRequired: false
+	}
+};
+/**
+* The ONE field-aware strict binding-name reader for a single config field. Routes
+* each field to its KNOWN shape (see {@link BINDING_FIELD_SHAPES}) and FAILS CLOSED on
+* any malformed/missing REQUIRED identity or wrong outer shape — never content-guessing.
+* wrangler is lenient and would silently drop such a member, letting the worker-wide
+* uniqueness guard miss (or invent) a collision.
+*
+* Exported so the deploy orchestrator's pass-through assert-set check reads a resource field's
+* per-entry identity keys through the SAME wrangler-schema shapes (handling `send_email` /
+* `ratelimits` name-keying and `logfwdr`'s nested `.bindings`, among others).
+*/
+function bindingNamesForField(field, value) {
+	const shape = BINDING_FIELD_SHAPES[field] ?? { kind: "namespace-array" };
+	switch (shape.kind) {
+		case "key-map": return keyMapBindingNames(field, value);
+		case "name-keyed-array": return nameKeyedBindingNames(field, value);
+		case "namespace-array": return namespaceArrayBindingNames(field, value);
+		case "singleton": return singletonBindingName(field, value, shape.bindingRequired);
+		case "binding-list": return bindingListNames(field, value, shape.bindingsRequired);
+		case "whole-object": return [];
+	}
+}
+/**
+* The entry-shaped sibling of {@link bindingNamesForField}: routes each field to its KNOWN
+* shape and returns every binding's NAME **paired with its full config ENTRY object**, so a
+* caller can compare not just WHICH bindings a field declares but the TARGET each one points
+* at (a `services` binding's `service`, an `unsafe` binding's `type`, …). Same fail-closed
+* philosophy as {@link bindingNamesForField} — a malformed/missing REQUIRED identity or wrong
+* outer shape THROWS. By construction `bindingEntriesForField(f, v).map((e) => e.name)` equals
+* `bindingNamesForField(f, v)` for every field (both read identity through the same shapes).
+*
+* Exported so the deploy orchestrator's pass-through assert-set check can pin a legitimately
+* hand-declared binding's ENTRY pre-build and reject a build that KEEPS the name but REWRITES
+* the target.
+*/
+function bindingEntriesForField(field, value) {
+	const shape = BINDING_FIELD_SHAPES[field] ?? { kind: "namespace-array" };
+	switch (shape.kind) {
+		case "key-map": return keyMapBindingEntries(field);
+		case "name-keyed-array": return nameKeyedBindingEntries(field, value);
+		case "namespace-array": return namespaceArrayBindingEntries(field, value);
+		case "singleton": return singletonBindingEntry(field, value, shape.bindingRequired);
+		case "binding-list": return bindingListEntries(field, value, shape.bindingsRequired);
+		case "whole-object": return [];
+	}
+}
+/**
+* Entry-shaped reader for a KEY-MAP field. Key-map fields (vars/wasm_modules/text_blobs/
+* data_blobs) carry no per-binding config ENTRY object — the binding name is the KEY and the
+* VALUE is arbitrary content — and all four are excluded from the pass-through assert-set, so
+* this branch is never reached in the normal flow. It THROWS the same wrong-shape message the
+* name reader raises, so a FUTURE misclassification that routed a key-map field here fails
+* CLOSED rather than silently reading no entries.
+*/
+function keyMapBindingEntries(field) {
+	throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object mapping names to values. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+}
+/**
+* Entry-shaped reader for a NAMESPACE-array field (mirror of {@link namespaceArrayBindingNames}):
+* a PRESENT non-array THROWS; every member is strictly validated for a non-empty string
+* `.binding` and returned with its full entry object.
+*/
+function namespaceArrayBindingEntries(field, value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an array of binding entries. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	return strictBindingEntries(value, "binding", field);
+}
+/**
+* Entry-shaped reader for a NAME-keyed array field (mirror of {@link nameKeyedBindingNames}):
+* identity is `.name` only; a PRESENT non-array THROWS; every member is strictly validated.
+*/
+function nameKeyedBindingEntries(field, value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an array of binding entries. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	return strictBindingEntries(value, "name", field);
+}
+/**
+* Entry-shaped reader for a binding-LIST field (mirror of {@link bindingListNames}): the entry
+* of each member is the member itself (`{ name, ... }`), keyed on `.name`. Same throw semantics
+* as the name reader — a wrong outer shape, or a required-but-missing `bindings`, THROWS; a
+* `bindings`-less `unsafe` (optional) contributes nothing.
+*/
+function bindingListEntries(field, value, bindingsRequired) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object with a "bindings" array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (value.bindings === void 0) {
+		if (bindingsRequired) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" requires a "bindings" array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+		return [];
+	}
+	if (!Array.isArray(value.bindings)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}.bindings" must be an array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	return strictBindingEntries(value.bindings, "name", `${field}.bindings`);
+}
+/**
+* Entry-shaped reader for a SINGLETON field (mirror of {@link singletonBindingName}): the entry
+* is the singleton value itself. A PRESENT non-object THROWS; a present-but-malformed `binding`
+* THROWS; a required-but-absent `binding` THROWS; a binding-optional `assets` with no binding
+* contributes nothing.
+*/
+function singletonBindingEntry(field, value, bindingRequired) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object with a "binding". Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (typeof value.binding === "string" && value.binding.length > 0) return [{
+		name: value.binding,
+		entry: value
+	}];
+	if (value.binding !== void 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" has a malformed "binding" (expected a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped binding could hide a real collision). Fix the wrangler config and retry.`);
+	if (bindingRequired) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" requires a "binding" (a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped binding could hide a real collision). Fix the wrangler config and retry.`);
+	return [];
+}
+/**
+* Read binding names from a KEY-MAP field (`vars`/`wasm_modules`/`text_blobs`/
+* `data_blobs`): the object's KEYS are the binding names. Reads ONLY the keys — never
+* the values — so a value that happens to look like a binding list (`{bindings:[…]}`)
+* or a singleton (`{binding:'x'}`) is NOT misread (the old generic path returned the
+* VALUE, or a nested `name`, instead of the real KEY). A PRESENT value that is not a
+* plain object is the wrong outer shape and THROWS (fail closed). An explicitly
+* `undefined`-valued key is not a real binding and is skipped.
+*/
+function keyMapBindingNames(field, value) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object mapping names to values. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	return Object.keys(value).filter((key) => value[key] !== void 0);
+}
+/**
+* Read binding names from a NAMESPACE-array field (`[{ binding }]`: kv_namespaces,
+* d1_databases, r2_buckets, hyperdrive, services, vectorize, …). A PRESENT value that
+* is not an array is the wrong outer shape and THROWS rather than being re-read as a
+* key-map (which could under-collect and hide a real collision); every member is
+* strictly validated for a non-empty string `.binding`.
+*/
+function namespaceArrayBindingNames(field, value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an array of binding entries. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	return strictBindingArray(value, "binding", field);
+}
+/**
+* Read binding names from a NAME-keyed array field (`send_email` / `ratelimits`:
+* an array of `{ name }`). Encodes the field's REQUIRED outer shape: a PRESENT value that
+* is not an array THROWS (fail closed) rather than falling back to generic key collection —
+* wrangler validates these via `validateBindingArray`, so a non-array is malformed and
+* could hide a real collision if silently re-read as a key-map. An ABSENT value contributes
+* nothing. Every array member is strictly validated (a malformed one rejects the whole
+* config).
+*
+* Identity is the `.name` ONLY. Verified against wrangler 4.131's bundle +
+* `config-schema.json`: NEITHER `send_email` NOR `ratelimits` has a `.binding` property in
+* the schema, and on UPLOAD wrangler keys them by `.name` (send_email:
+* `output[name] = { type: "send_email", ...}`; ratelimits push `{ name: binding.name, … }`).
+* An optional `.binding` that happens to sit on such an entry is NOT a binding identity
+* wrangler recognizes, so unioning it invents a PHANTOM collision — e.g. a
+* `send_email:[{name:"EMAIL_A",binding:"QUEUE_JOBS"}]` would falsely block a legitimate
+* `QUEUE_JOBS` queue producer / adopt / read-first. We therefore collect ONLY the `.name`
+* of every member (a genuine same-`name` collision is still caught).
+*/
+function nameKeyedBindingNames(field, value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an array of binding entries. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	return strictBindingArray(value, "name", field);
+}
+/**
+* Read the binding names from a binding-LIST field (`{ bindings: [{ name }] }`:
+* durable_objects / logfwdr / unsafe). A PRESENT value that is not an object is the
+* wrong outer shape and THROWS. When `bindingsRequired` (durable_objects / logfwdr per
+* schema), a MISSING `bindings` array THROWS (never a silent empty read); `unsafe` is
+* optional, so a `bindings`-less `{ metadata }` contributes nothing. A PRESENT
+* `bindings` array has EVERY member strictly validated for a non-empty string `name`.
+*/
+function bindingListNames(field, value, bindingsRequired) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object with a "bindings" array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (value.bindings === void 0) {
+		if (bindingsRequired) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" requires a "bindings" array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+		return [];
+	}
+	if (!Array.isArray(value.bindings)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}.bindings" must be an array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	return strictBindingArray(value.bindings, "name", `${field}.bindings`);
+}
+/**
+* Read the binding name from a SINGLETON field (`{ binding }`: ai / browser /
+* images / stream / media / websearch / version_metadata / assets). A PRESENT value
+* that is not an object is the wrong outer shape and THROWS. A PRESENT-but-malformed
+* `binding` (non-string / empty) THROWS. When `bindingRequired` (every singleton except
+* `assets`, per schema), an ABSENT `binding` also THROWS — never a silent empty read,
+* and never a fall-through that would mis-collect the object's OTHER keys (e.g.
+* `{ staging: true }`) as bogus binding names. `assets` is binding-optional, so an
+* absent binding (e.g. `{ directory }`) contributes nothing.
+*/
+function singletonBindingName(field, value, bindingRequired) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object with a "binding". Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (typeof value.binding === "string" && value.binding.length > 0) return [value.binding];
+	if (value.binding !== void 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" has a malformed "binding" (expected a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped binding could hide a real collision). Fix the wrangler config and retry.`);
+	if (bindingRequired) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" requires a "binding" (a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped binding could hide a real collision). Fix the wrangler config and retry.`);
+	return [];
+}
+/**
+* Strictly read `keyField` (a non-empty string) from EVERY member of a
+* binding-bearing array. THROWS (fail closed) on ANY malformed member — never
+* silently drops one. Dropping a malformed member could convert a mixed-validity
+* array (e.g. `[null, { binding: 'DB', id: '…' }]`) into an empty/partial binding
+* set, so the worker-wide uniqueness guard would MISS the existing `DB` and commit
+* a conflicting binding — a fail-open in a documented invariant. Mirrors the
+* writer's existing fail-closed-on-malformed-config philosophy.
+*/
+function strictBindingArray(members, keyField, field) {
+	return strictBindingEntries(members, keyField, field).map((e) => e.name);
+}
+/**
+* The entry-shaped sibling of {@link strictBindingArray}: reads `keyField` (a non-empty string)
+* from EVERY member and returns it PAIRED with the member's full entry object. Same fail-closed
+* validation — a non-record member, or one missing a non-empty string `keyField`, THROWS (never
+* silently dropped). {@link strictBindingArray} is defined in terms of this, so the two agree on
+* names and error messages for every field.
+*/
+function strictBindingEntries(members, keyField, field) {
+	return members.map((member, index) => {
+		if (!isRecord(member) || typeof member[keyField] !== "string" || member[keyField].length === 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" contains a malformed entry at index ${index} (missing a non-empty string "${keyField}"). Refusing to proceed on a partially-readable binding set (a dropped entry could hide a real collision). Fix the wrangler config and retry.`);
+		return {
+			name: member[keyField],
+			entry: member
+		};
+	});
+}
+/**
+* True when a D1 `migrations_pattern` is valid under `dir` per wrangler's rule:
+* the normalized pattern must start with `${normalized dir}/` (or the dir
+* normalizes to "."). Mirrors wrangler's `resolveMigrationsConfig` /
+* `stripDirPrefix`.
+*/
+function migrationsPatternMatchesDir(pattern, dir) {
+	const normalizedDir = normalizeMigrationsPath(dir);
+	if (normalizedDir === ".") return true;
+	return normalizeMigrationsPath(pattern).startsWith(`${normalizedDir}/`);
+}
+/**
+* Mirror wrangler's `normalizeRelativePath`: forward-slash, posix-normalize, then
+* drop a trailing slash. Keeps the migrations validity check byte-identical with
+* wrangler's own.
+*/
+function normalizeMigrationsPath(p) {
+	const normalized = normalize(p.replace(/\\/g, "/"));
+	return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+/** Order-insensitive structural equality — avoids rewriting an entry that only
+* differs in key order (preserves the file's bytes/comments on that entry). */
+function jsonEqual(a, b) {
+	return JSON.stringify(canonicalize(a)) === JSON.stringify(canonicalize(b));
+}
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (isRecord(value)) return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+	return value;
+}
+//#endregion
+export { writeWranglerPublishedTrafficSnapshot as A, readWranglerWebSocketTombstones as C, syncWranglerWebSockets as D, syncWranglerDurableObjects as E, isSandboxEnabled as M, requiresSandboxPlatformImage as N, updateWranglerCustomDomain as O, resolveSandboxConfig as P, readWranglerPublishedTrafficSnapshot as S, syncWranglerBindings as T, readProvisionedBindingEntry as _, LIVE_MIGRATION_TAG as a, readWranglerCustomDomains as b, bindingEntriesForField as c, ensureWranglerNodejsAlsFlag as d, findBindingNameOwner as f, readExistingLiveBindingConfig as g, normalizeWranglerCompatibilityFlags as h, LATEST_KNOWN_COMPAT_DATE as i, SANDBOX_MIGRATION_TAG as j, writeProvisionedWranglerConfig as k, ensureWranglerCompat as l, nextDurableObjectMigrationTag as m, DEFAULT_LIVE_CLASS as n, acknowledgeWranglerManagedQueueRemovals as o, hasDurableObjectSqliteMigration as p, FRIENDLY_BINDING_NAMES as r, assertNoDuplicateMembers as s, DEFAULT_LIVE_BINDING as t, ensureWranglerCompatibilityDate as u, readRootWranglerConfig as v, resolveLiveBindingConfig as w, readWranglerManagedQueueCleanupCandidates as x, readWranglerCompat as y };