@cloudflare/vite-plugin 1.54.8 → 1.54.9

package/dist/index.mjs

@@ -137,7 +137,7 @@ function createFatalError$1(message, isJson, options) {
 __name$6(createFatalError$1, "createFatalError");
 
 //#endregion
-//#region ../workers-utils/dist/chunk-R5MIV2EH.mjs
+//#region ../workers-utils/dist/chunk-T5JQYOMX.mjs
 function hasKnownExportType(entry) {
 	const type = entry?.type;
 	return type === "durable-object" || type === "worker";
@@ -225,9 +225,9 @@ function getDurableObjectClassNameToUseSQLiteMap(migrations, exports$1) {
 	return durableObjectClassNameToUseSQLiteMap;
 }
 __name$6(getDurableObjectClassNameToUseSQLiteMap, "getDurableObjectClassNameToUseSQLiteMap");
-function validateDurableObjectContainerApplications(config$2) {
+function validateDurableObjectContainerApplications(config$2, containers = getDurableObjectContainerApps(config$2.containers)) {
 	const allDOs = getDurableObjectClassNameToUseSQLiteMap(config$2.migrations, config$2.exports);
-	for (const container of getDurableObjectContainerApps(config$2.containers)) {
+	for (const container of containers) {
 		const maybeBoundDO = config$2.durable_objects.bindings.find((durableObject) => durableObject.class_name === container.class_name);
 		const useSQLite = allDOs.get(container.class_name);
 		if (useSQLite === void 0 && maybeBoundDO === void 0) throw new UserError(`The container class_name ${container.class_name} does not match any durable object class_name defined in your Wrangler config file. Note that the durable object must be defined in the same script as the container.`, { telemetryMessage: "no DO defined that matches container class_name" });
@@ -41939,7 +41939,7 @@ function normalizeAndValidateEnvironment(diagnostics, configPath, rawEnv, isDisp
 	warnIfDurableObjectsHaveNoLifecycleConfig(diagnostics, environment.durable_objects, environment.migrations, environment.exports, configPath);
 	errorIfMigrationsAndExportsBothSet(diagnostics, environment.migrations, environment.exports);
 	const containersDeclaredElsewhere = rawConfig !== void 0 ? rawConfig.containers !== void 0 : Object.values("env" in rawEnv ? rawEnv.env ?? {} : {}).some((rawNamedEnv) => rawNamedEnv?.containers !== void 0);
-	validateContainerExportLinks(diagnostics, environment.containers, environment.exports, containersDeclaredElsewhere);
+	validateContainerExportLinks$1(diagnostics, environment.containers, environment.exports, containersDeclaredElsewhere);
 	if (envName !== "top level") validateAdditionalProperties(diagnostics, "env." + envName, Object.keys(rawEnv), Object.keys(environment));
 	return environment;
 }
@@ -44149,7 +44149,7 @@ function errorIfMigrationsAndExportsBothSet(diagnostics, migrations, exports$1)
 	if (migrations.length > 0 && exports$1 !== void 0 && Object.values(exports$1).some((entry) => entry.type === "durable-object")) diagnostics.errors.push(`\`migrations\` and \`exports\` are mutually exclusive. Choose one or the other to declare your Durable Object lifecycle, but not both.`);
 }
 __name$6(errorIfMigrationsAndExportsBothSet, "errorIfMigrationsAndExportsBothSet");
-function validateContainerExportLinks(diagnostics, containers, exports$1, containersDeclaredElsewhere) {
+function validateContainerExportLinks$1(diagnostics, containers, exports$1, containersDeclaredElsewhere) {
 	if (containers !== void 0 && !Array.isArray(containers)) return;
 	if (containers === void 0 && containersDeclaredElsewhere) return;
 	const containersByName = /* @__PURE__ */ new Map();
@@ -44209,7 +44209,7 @@ function validateContainerExportLinks(diagnostics, containers, exports$1, contai
 		if (referencedContainerName === void 0 && exportEntry !== void 0 && "storage" in exportEntry && exportEntry.storage === "legacy-kv") diagnostics.errors.push(`The container "${container.name}" sets "class_name" to "${container.class_name}", but "exports.${container.class_name}.storage" is "legacy-kv". Containers are not supported on Durable Objects using the "legacy-kv" storage backend.`);
 	}
 }
-__name$6(validateContainerExportLinks, "validateContainerExportLinks");
+__name$6(validateContainerExportLinks$1, "validateContainerExportLinks");
 var validatePythonModules = /* @__PURE__ */ __name$6((diagnostics, field, value, topLevelEnv) => {
 	if (value === void 0) return true;
 	if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -55504,6 +55504,136 @@ function validateSingletonBindings(env$3, ctx) {
 	});
 }
 const EnvSchema = record(string(), BindingSchema).superRefine(validateSingletonBindings).optional();
+const ContainerImageDockerfileSchema = strictObject({
+	dockerfile: string().min(1),
+	buildContext: string().optional(),
+	buildVars: record(string(), string()).optional()
+});
+const ContainerImageReferenceSchema = strictObject({ reference: string().min(1) });
+const ContainerImageLocalReferenceSchema = strictObject({ localReference: string().min(1) });
+const InputContainerImageSchema = union([ContainerImageDockerfileSchema, ContainerImageReferenceSchema]);
+const OutputContainerImageSchema = union([ContainerImageReferenceSchema, ContainerImageLocalReferenceSchema]);
+const VALID_ROLLOUT_STEP_PERCENTAGES = new Set([
+	5,
+	10,
+	20,
+	25,
+	50,
+	100
+]);
+const ContainerRolloutStepPercentageSchema = union([number(), array(number())]).superRefine((stepPercentage, ctx) => {
+	if (typeof stepPercentage === "number") {
+		if (!VALID_ROLLOUT_STEP_PERCENTAGES.has(stepPercentage)) ctx.addIssue({
+			code: "custom",
+			message: "A rollout step percentage must be one of 5, 10, 20, 25, 50, or 100"
+		});
+		return;
+	}
+	if (stepPercentage.length === 0) {
+		ctx.addIssue({
+			code: "custom",
+			message: "A rollout must contain at least one step percentage"
+		});
+		return;
+	}
+	for (const [index, step] of stepPercentage.entries()) {
+		if (step < 10 || step > 100) ctx.addIssue({
+			code: "custom",
+			path: [index],
+			message: "Rollout step percentages must be between 10 and 100"
+		});
+		const previousStep = stepPercentage[index - 1];
+		if (previousStep !== void 0 && step < previousStep) ctx.addIssue({
+			code: "custom",
+			path: [index],
+			message: "Rollout step percentages must be in ascending order"
+		});
+	}
+	const lastIndex = stepPercentage.length - 1;
+	if (stepPercentage[lastIndex] !== 100) ctx.addIssue({
+		code: "custom",
+		path: [lastIndex],
+		message: "The final rollout step percentage must be 100"
+	});
+});
+function validateContainerRelationships(container, ctx) {
+	const stepPercentage = container.rollout?.stepPercentage;
+	if (Array.isArray(stepPercentage) && container.maxInstances !== void 0 && stepPercentage.length > container.maxInstances) ctx.addIssue({
+		code: "custom",
+		path: ["rollout", "stepPercentage"],
+		message: "A rollout cannot contain more steps than the maximum number of instances"
+	});
+}
+const ContainerObservabilityBaseSchema = strictObject({
+	enabled: boolean().optional(),
+	logs: strictObject({ enabled: boolean().optional() }).optional()
+});
+const ContainerObservabilitySchema = union([ContainerObservabilityBaseSchema.extend({ targetInstancePercentage: number().min(0).max(100).optional() }), ContainerObservabilityBaseSchema.extend({ targetInstanceCount: number().int().nonnegative().optional() })]);
+const BaseContainerSchema = strictObject({
+	type: literal$1("container"),
+	name: string().min(1),
+	observability: ContainerObservabilitySchema.optional(),
+	unsafe: record(string(), unknown()).optional()
+});
+const StandardContainerBaseSchema = BaseContainerSchema.extend({
+	maxInstances: number().int().nonnegative().default(20),
+	instanceType: union([_enum([
+		"basic",
+		"lite",
+		"standard-1",
+		"standard-2",
+		"standard-3",
+		"standard-4"
+	]), strictObject({
+		vcpu: number().min(.0625).optional(),
+		memoryMib: number().nonnegative().optional(),
+		diskMb: number().nonnegative().optional()
+	})]).optional(),
+	schedulingPolicy: _enum(["default", "regional"]).optional(),
+	ssh: strictObject({
+		enabled: boolean(),
+		port: number().int().min(1).max(65535).optional()
+	}).optional(),
+	authorizedKeys: array(strictObject({
+		name: string(),
+		publicKey: string()
+	})).optional(),
+	constraints: strictObject({
+		regions: array(_enum([
+			"ENAM",
+			"WNAM",
+			"EEUR",
+			"WEUR",
+			"APAC",
+			"SAM",
+			"ME",
+			"OC",
+			"AFR"
+		])).optional(),
+		jurisdiction: _enum(["eu", "fedramp"]).optional()
+	}).optional(),
+	rollout: strictObject({
+		kind: _enum([
+			"full-auto",
+			"none",
+			"full-manual"
+		]).optional(),
+		stepPercentage: ContainerRolloutStepPercentageSchema.optional(),
+		activeGracePeriod: number().nonnegative().optional()
+	}).optional()
+});
+const DurableObjectContainerBaseSchema = BaseContainerSchema.extend({ schedulingPolicy: literal$1("durable-object") });
+/**
+* Input Container schema — validates user-authored `cloudflare.config.ts`
+* Container exports. Dockerfiles are built by the consuming build tool.
+*/
+const InputContainerSchema = union([StandardContainerBaseSchema.extend({ image: InputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: record(string(), InputContainerImageSchema).optional() })]);
+/**
+* Output Container schema — validates Container configs in the Build Output
+* Specification, after any Dockerfile has been built into a local or remote
+* image reference.
+*/
+const OutputContainerSchema = union([StandardContainerBaseSchema.extend({ image: OutputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: record(string(), OutputContainerImageSchema).optional() })]);
 const DurableObjectCreatedExportSchema = strictObject({
 	type: literal$1("durable-object"),
 	state: literal$1("created").optional(),
@@ -55682,8 +55812,13 @@ const InputSettingsSchema = strictObject({
 * Build Output Specification. Adds the `mode` the build was produced in.
 */
 const OutputSettingsSchema = InputSettingsSchema.extend({ mode: string().optional() });
+const DEFAULT_EXPORT_NAME = "default";
 const SETTINGS_EXPORT_NAME = "settings";
-const SUPPORTED_EXPORT_TYPES = new Set(["worker", "settings"]);
+const SUPPORTED_EXPORT_TYPES = new Set([
+	"container",
+	"worker",
+	"settings"
+]);
 function invalidConfigExportMessage(exportName) {
 	return `The \`${exportName}\` export is not a supported export type. Move constants, helper functions, and other unsupported exports to a separate module.`;
 }
@@ -55700,6 +55835,15 @@ const ConfigExportsTypeSchema = record(string(), unknown()).check((ctx) => {
 			});
 			continue;
 		}
+		if (key === DEFAULT_EXPORT_NAME && type !== "worker") {
+			ctx.issues.push({
+				code: "custom",
+				input: value,
+				path: [key],
+				message: `The \`${DEFAULT_EXPORT_NAME}\` export is reserved for a \`worker\` config; found a \`${type}\` config.`
+			});
+			continue;
+		}
 		const isSettingsName = key === SETTINGS_EXPORT_NAME;
 		const isSettingsType = type === "settings";
 		if (isSettingsType && !isSettingsName) ctx.issues.push({
@@ -55881,18 +56025,26 @@ function createFatalError(message, isJson, options) {
 	return new FatalError$1(`${message}`, options);
 }
 __name$5(createFatalError, "createFatalError");
+const ROLLOUT_KIND_MAP = {
+	"full-auto": "full_auto",
+	"full-manual": "full_manual",
+	none: "none"
+};
 /**
 * Convert a parsed `@cloudflare/config` config into a Wrangler `RawConfig`.
 *
-* The caller is responsible for unwrapping any function/promise wrapper around
-* the config and validating it against `InputWorkerSchema` before passing it in.
+* The caller is responsible for unwrapping any function/promise wrappers and
+* validating the configs against their corresponding input schemas before
+* passing them in.
 *
 * @param workerConfig The parsed (post-validation) Worker config.
 * @param settingsConfig The optional parsed settings config, whose fields
 * are merged onto the result.
+* @param containerExports The parsed Container exports to include in the
+* result.
 * @returns The corresponding Wrangler `RawConfig`.
 */
-function convertToWranglerConfig(workerConfig, settingsConfig) {
+function convertToWranglerConfig(workerConfig, settingsConfig, containerExports = []) {
 	const result = {};
 	convertTopLevel(workerConfig, result);
 	convertBindingsAndAssets(workerConfig, result);
@@ -55901,8 +56053,50 @@ function convertToWranglerConfig(workerConfig, settingsConfig) {
 	convertTriggers(workerConfig, result);
 	convertTailConsumers(workerConfig, result);
 	if (settingsConfig !== void 0) convertSettings(settingsConfig, result);
+	if (containerExports.length > 0) result.containers = containerExports.map((container) => convertContainer(container));
 	return result;
 }
+function convertContainer(container) {
+	if (container.schedulingPolicy === "durable-object") throw new UserError$1("Durable Object-managed Containers are not currently supported by `convertToWranglerConfig()`.", { telemetryMessage: false });
+	const converted = { name: container.name };
+	if (container.observability !== void 0) converted.observability = convertContainerObservability(container.observability);
+	if (container.unsafe !== void 0) converted.unsafe = container.unsafe;
+	converted.image = "dockerfile" in container.image ? container.image.dockerfile : container.image.reference;
+	converted.max_instances = container.maxInstances;
+	if ("dockerfile" in container.image) {
+		if (container.image.buildContext !== void 0) converted.image_build_context = container.image.buildContext;
+		if (container.image.buildVars !== void 0) converted.image_vars = container.image.buildVars;
+	}
+	if (container.instanceType !== void 0) if (typeof container.instanceType === "string") converted.instance_type = container.instanceType;
+	else {
+		const instanceType = {};
+		if (container.instanceType.vcpu !== void 0) instanceType.vcpu = container.instanceType.vcpu;
+		if (container.instanceType.memoryMib !== void 0) instanceType.memory_mib = container.instanceType.memoryMib;
+		if (container.instanceType.diskMb !== void 0) instanceType.disk_mb = container.instanceType.diskMb;
+		converted.instance_type = instanceType;
+	}
+	if (container.schedulingPolicy !== void 0) converted.scheduling_policy = container.schedulingPolicy;
+	if (container.ssh !== void 0) converted.ssh = container.ssh;
+	if (container.authorizedKeys !== void 0) converted.authorized_keys = container.authorizedKeys.map(({ name, publicKey }) => ({
+		name,
+		public_key: publicKey
+	}));
+	if (container.constraints !== void 0) converted.constraints = container.constraints;
+	if (container.rollout !== void 0) {
+		if (container.rollout.kind !== void 0) converted.rollout_kind = ROLLOUT_KIND_MAP[container.rollout.kind];
+		if (container.rollout.stepPercentage !== void 0) converted.rollout_step_percentage = container.rollout.stepPercentage;
+		if (container.rollout.activeGracePeriod !== void 0) converted.rollout_active_grace_period = container.rollout.activeGracePeriod;
+	}
+	return converted;
+}
+function convertContainerObservability(observability) {
+	const converted = {};
+	if (observability.enabled !== void 0) converted.enabled = observability.enabled;
+	if (observability.logs !== void 0) converted.logs = observability.logs;
+	if ("targetInstancePercentage" in observability && observability.targetInstancePercentage !== void 0) converted.target_instance_percentage = observability.targetInstancePercentage;
+	if ("targetInstanceCount" in observability && observability.targetInstanceCount !== void 0) converted.target_instance_count = observability.targetInstanceCount;
+	return converted;
+}
 /**
 * Merge a parsed settings config's fields (`account_id`, `compliance_region`)
 * onto an existing Wrangler `RawConfig`.
@@ -56570,6 +56764,9 @@ function isRecord(value) {
 function isConfigReference(value) {
 	return typeof value === "function" || isRecord(value);
 }
+function normalizeConfigReference(reference, resolved, expectedType) {
+	return isRecord(resolved) && resolved.type === expectedType && typeof resolved.name === "string" ? resolved.name : reference;
+}
 function createDefinitionResolver(ctx) {
 	const resolvedDefinitions = /* @__PURE__ */ new Map();
 	return (input) => {
@@ -56590,7 +56787,7 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 		const target$1 = await resolveDefinition(binding.worker);
 		env$3[bindingName] = {
 			...binding,
-			worker: isRecord(target$1) ? target$1.name : void 0
+			worker: normalizeConfigReference(binding.worker, target$1, "worker")
 		};
 	}
 	return {
@@ -56598,22 +56795,151 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 		env: env$3
 	};
 }
+async function normalizeContainerReferences(resolved, resolveDefinition, resolvedExports) {
+	const issues = [];
+	if (!isRecord(resolved) || !isRecord(resolved.exports)) return {
+		value: resolved,
+		issues
+	};
+	const workerExports = { ...resolved.exports };
+	for (const [exportName, workerExport] of Object.entries(workerExports)) {
+		if (!isRecord(workerExport) || workerExport.type !== "durable-object" || workerExport.container === void 0) continue;
+		const reference = workerExport.container;
+		if (typeof reference === "string") {
+			issues.push({
+				code: "custom",
+				input: reference,
+				path: [
+					"exports",
+					exportName,
+					"container"
+				],
+				message: "Container provided as a string. Reference an exported Container definition instead."
+			});
+			workerExports[exportName] = {
+				...workerExport,
+				container: void 0
+			};
+			continue;
+		}
+		const target$1 = await resolveDefinition(reference);
+		if (isRecord(target$1) && target$1.type === "container" && typeof target$1.name === "string" && !Object.values(resolvedExports).includes(target$1)) {
+			issues.push({
+				code: "custom",
+				input: reference,
+				path: [
+					"exports",
+					exportName,
+					"container"
+				],
+				message: `The referenced Container "${target$1.name}" is not exported.`
+			});
+			workerExports[exportName] = {
+				...workerExport,
+				container: void 0
+			};
+			continue;
+		}
+		workerExports[exportName] = {
+			...workerExport,
+			container: normalizeConfigReference(reference, target$1, "container")
+		};
+	}
+	return {
+		value: {
+			...resolved,
+			exports: workerExports
+		},
+		issues
+	};
+}
+async function normalizeConfigReferences(resolved, resolveDefinition, resolvedExports) {
+	return normalizeContainerReferences(await normalizeWorkerReferences(resolved, resolveDefinition), resolveDefinition, resolvedExports);
+}
 function prefixIssues(issues, prefix) {
 	return issues.map((issue$2) => ({
 		...issue$2,
 		path: [prefix, ...issue$2.path]
 	}));
 }
+function validateUniqueResourceNames(configExports) {
+	const issues = [];
+	const exportNameByResourceName = {
+		container: /* @__PURE__ */ new Map(),
+		worker: /* @__PURE__ */ new Map()
+	};
+	for (const [exportName, config$2] of Object.entries(configExports)) {
+		if (config$2.type !== "container" && config$2.type !== "worker") continue;
+		const resourceType = config$2.type === "container" ? "Container" : "Worker";
+		const exportNames = exportNameByResourceName[config$2.type];
+		const previousExportName = exportNames.get(config$2.name);
+		if (previousExportName !== void 0) {
+			issues.push({
+				code: "custom",
+				input: config$2.name,
+				path: [exportName, "name"],
+				message: `The ${resourceType} name "${config$2.name}" is also used by the "${previousExportName}" export. ${resourceType} names must be unique.`
+			});
+			continue;
+		}
+		exportNames.set(config$2.name, exportName);
+	}
+	return issues;
+}
+function validateContainerExportLinks(configExports) {
+	const issues = [];
+	const containerNames = /* @__PURE__ */ new Set();
+	for (const config$2 of Object.values(configExports)) if (config$2.type === "container") containerNames.add(config$2.name);
+	const firstReferenceByContainerName = /* @__PURE__ */ new Map();
+	for (const [workerExportName, config$2] of Object.entries(configExports)) {
+		if (config$2.type !== "worker") continue;
+		for (const [durableObjectExportName, workerExport] of Object.entries(config$2.exports ?? {})) {
+			if (workerExport.type !== "durable-object" || !("container" in workerExport) || workerExport.container === void 0) continue;
+			const containerName = workerExport.container;
+			const path$2 = [
+				workerExportName,
+				"exports",
+				durableObjectExportName,
+				"container"
+			];
+			if (!containerNames.has(containerName)) {
+				issues.push({
+					code: "custom",
+					input: containerName,
+					path: path$2,
+					message: `The Container "${containerName}" is not exported from this configuration.`
+				});
+				continue;
+			}
+			const firstReference = firstReferenceByContainerName.get(containerName);
+			if (firstReference !== void 0) {
+				issues.push({
+					code: "custom",
+					input: containerName,
+					path: path$2,
+					message: `The Container "${containerName}" is already referenced by "${firstReference.workerExportName}.exports.${firstReference.durableObjectExportName}". A Container can only be linked to one Durable Object.`
+				});
+				continue;
+			}
+			firstReferenceByContainerName.set(containerName, {
+				workerExportName,
+				durableObjectExportName
+			});
+		}
+	}
+	return issues;
+}
 /**
 * Resolve and validate loaded `cloudflare.config.ts` exports.
 *
-* Config inputs are resolved once by identity. Top-level Worker exports are
-* also parsed once by identity; unexported references are resolved only far
-* enough to replace the reference with the Worker's name.
+* Config inputs are resolved once by identity. Top-level Worker and Container
+* exports are also parsed once by identity. References are resolved only far
+* enough to replace them with resource names, then Container links are
+* validated across the exported resources.
 */
 async function resolveAndValidateConfigExports(exports$2, ctx) {
 	const resolveDefinition = createDefinitionResolver(ctx);
-	const parsedWorkers = /* @__PURE__ */ new Map();
+	const parsedResources = /* @__PURE__ */ new Map();
 	const resolvedExports = {};
 	for (const [name, input] of Object.entries(exports$2)) resolvedExports[name] = await resolveDefinition(input);
 	const typeResult = ConfigExportsTypeSchema.safeParse(resolvedExports);
@@ -56627,17 +56953,20 @@ async function resolveAndValidateConfigExports(exports$2, ctx) {
 	for (const [name, input] of Object.entries(exports$2)) {
 		const resolved = resolvedExports[name];
 		if (!isRecord(resolved)) continue;
-		if (resolved.type === "worker") {
-			let result = parsedWorkers.get(input);
-			if (!result) {
-				result = InputWorkerSchema.safeParse(await normalizeWorkerReferences(resolved, resolveDefinition));
-				parsedWorkers.set(input, result);
-				if (!result.success) issues.push(...prefixIssues(result.error.issues, name));
-			}
-			if (result.success) data$1[name] = result.data;
-			continue;
-		}
-	}
+		if (resolved.type !== "worker" && resolved.type !== "container") continue;
+		let result = parsedResources.get(input);
+		if (!result) {
+			if (resolved.type === "worker") {
+				const normalized = await normalizeConfigReferences(resolved, resolveDefinition, resolvedExports);
+				issues.push(...prefixIssues(normalized.issues, name));
+				result = InputWorkerSchema.safeParse(normalized.value);
+			} else result = InputContainerSchema.safeParse(resolved);
+			parsedResources.set(input, result);
+			if (!result.success) issues.push(...prefixIssues(result.error.issues, name));
+		}
+		if (result.success) data$1[name] = result.data;
+	}
+	issues.push(...validateUniqueResourceNames(data$1), ...validateContainerExportLinks(data$1));
 	return issues.length > 0 ? {
 		success: false,
 		error: new ZodError(issues)
@@ -56946,13 +57275,36 @@ function getWorkersDir(root) {
 	return path.join(getBuildOutputDir(root), BUILD_OUTPUT_VERSION, "workers");
 }
 /**
+* Absolute path to the Containers output directory.
+*/
+function getContainersDir(root) {
+	return path.join(getBuildOutputDir(root), BUILD_OUTPUT_VERSION, "containers");
+}
+function validateDirectoryName(name, resourceName) {
+	if (name.length === 0 || name === "." || name === ".." || name.includes("/") || name.includes("\\") || name.includes("\0")) throw new Error(`${resourceName} directory names must be non-empty, single path segments. Received ${JSON.stringify(name)}.`);
+}
+/**
 * Absolute path to a Worker's directory (`workers/<worker-directory-name>`).
 */
 function getWorkerDir(root, workerDirectoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
-	if (workerDirectoryName.length === 0 || workerDirectoryName === "." || workerDirectoryName === ".." || workerDirectoryName.includes("/") || workerDirectoryName.includes("\\") || workerDirectoryName.includes("\0")) throw new Error("Worker directory names must be non-empty, single path segments.");
+	validateDirectoryName(workerDirectoryName, "Worker");
 	return path.join(getWorkersDir(root), workerDirectoryName);
 }
 /**
+* Absolute path to a Container's directory
+* (`containers/<container-directory-name>`).
+*/
+function getContainerDir(root, containerDirectoryName) {
+	validateDirectoryName(containerDirectoryName, "Container");
+	return path.join(getContainersDir(root), containerDirectoryName);
+}
+/**
+* Absolute path to the Container's config file.
+*/
+function getContainerConfigPath(root, containerDirectoryName) {
+	return path.join(getContainerDir(root, containerDirectoryName), CONFIG_FILENAME);
+}
+/**
 * Absolute path to the Worker's config file.
 */
 function getWorkerConfigPath(root, workerDirectoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
@@ -57011,14 +57363,14 @@ async function cleanBuildOutputDir(root) {
 * - Workers mode: `manifest` is provided (bundle/ present on disk).
 * - Assets-only mode: `manifest` is omitted (no bundle/ directory).
 */
-async function writeWorkerConfig({ root, config: config$2, manifest, workerDirectoryName = DEFAULT_WORKER_DIRECTORY_NAME }) {
+async function writeWorkerConfig({ root, config: config$2, manifest, directoryName = DEFAULT_WORKER_DIRECTORY_NAME }) {
 	const { entrypoint: _entrypoint,...rest } = config$2;
 	const outputConfig = {
 		...rest,
 		manifest
 	};
-	await fsp.mkdir(getWorkerDir(root, workerDirectoryName), { recursive: true });
-	await fsp.writeFile(getWorkerConfigPath(root, workerDirectoryName), JSON.stringify(outputConfig));
+	await fsp.mkdir(getWorkerDir(root, directoryName), { recursive: true });
+	await fsp.writeFile(getWorkerConfigPath(root, directoryName), JSON.stringify(outputConfig));
 }
 /**
 * Write the top-level `config.json` to the Build Output Specification tree.
@@ -57057,12 +57409,13 @@ var BuildOutputError = class extends Error {
 * `<root>/.cloudflare/output/v0/`.
 *
 * Reads the optional top-level settings `config.json`, then reads and
-* schema-validates the Worker's `config.json` and resolves its
-* `bundle/` / `assets/` directories. Partial manifests are resolved into
-* complete manifests using the files in `bundle/`.
+* schema-validates each Worker and Container `config.json`, and resolves each
+* Worker's `bundle/` / `assets/` directories. Partial manifests are resolved
+* into complete manifests using the files in `bundle/`.
 *
 * @throws {BuildOutputError} if the top-level `config.json` is invalid, or if
-* the Worker config is missing, is not valid JSON, or fails schema validation.
+* a Worker or Container config is missing, is not valid JSON, or fails schema
+* validation.
 */
 async function readBuildOutput(root) {
 	const settings = await readSettings(root);
@@ -57076,7 +57429,28 @@ async function readBuildOutput(root) {
 		workers: {
 			default: defaultWorker,
 			...Object.fromEntries(additionalWorkers)
-		}
+		},
+		containers: await readContainers(root)
+	};
+}
+/** Read and schema-validate all Container configs, if any. */
+async function readContainers(root) {
+	const containersDir = getContainersDir(root);
+	if (!fs$1.existsSync(containersDir)) return {};
+	const containerDirectoryNames = (await fsp.readdir(containersDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+	const containers = await Promise.all(containerDirectoryNames.map(async (containerDirectoryName) => [containerDirectoryName, await readContainer(root, containerDirectoryName)]));
+	return Object.fromEntries(containers);
+}
+/** Read and schema-validate one Container config. */
+async function readContainer(root, containerDirectoryName) {
+	const configPath = getContainerConfigPath(root, containerDirectoryName);
+	if (!fs$1.existsSync(configPath)) throw new BuildOutputError(`no Container config found at ${configPath}.`);
+	const contents = await fsp.readFile(configPath, "utf-8");
+	const result = OutputContainerSchema.safeParse(parseJson(contents, configPath));
+	if (!result.success) throw new BuildOutputError(`invalid Container config at ${configPath}.\n${result.error.message}`);
+	return {
+		configPath,
+		config: result.data
 	};
 }
 /**
@@ -68562,6 +68936,39 @@ function validateWorkerEnvironmentOptions(resolvedPluginConfig, resolvedViteConf
 	}
 }
 
+//#endregion
+//#region src/plugins/wrangler-watch-ignore.ts
+const WRANGLER_STATE_WATCH_IGNORE = "**/.wrangler/**";
+/**
+* Keep Miniflare persistence writes out of Vite's file watcher without
+* replacing any ignore patterns the user already configured.
+*
+* @param userIgnored - Existing `server.watch.ignored` patterns, if any
+* @returns Ignore patterns that always include `.wrangler` directories
+*/
+function withWranglerStateIgnored(userIgnored) {
+	if (userIgnored == null) return WRANGLER_STATE_WATCH_IGNORE;
+	if (Array.isArray(userIgnored)) return [...userIgnored, WRANGLER_STATE_WATCH_IGNORE];
+	return [userIgnored, WRANGLER_STATE_WATCH_IGNORE];
+}
+/**
+* Merge `.wrangler` into Vite's `server.watch` config.
+*
+* Returns `null` when the user disabled watching with `server.watch: null`,
+* so this plugin does not turn the watcher back on.
+*
+* @param userWatch - The user's `server.watch` value from Vite config
+* @returns `null` when watching is disabled, otherwise a watch object whose
+*   `ignored` list includes `.wrangler` directories
+*/
+function getServerWatchConfig(userWatch) {
+	if (userWatch === null) return null;
+	return {
+		...userWatch,
+		ignored: withWranglerStateIgnored(userWatch?.ignored)
+	};
+}
+
 //#endregion
 //#region src/plugins/config.ts
 /**
@@ -68580,6 +68987,7 @@ const configPlugin = createPlugin("config", (ctx) => {
 				appType: "custom",
 				server: {
 					allowedHosts: getAllowedHosts(ctx.getTunnelHostnames(), userConfig.server?.allowedHosts),
+					watch: getServerWatchConfig(userConfig.server?.watch),
 					fs: { deny: [...[
 						".env",
 						".env.*",
@@ -74143,7 +74551,7 @@ async function buildContainerImage(containerConfig, pathToDocker, verifyDockerIs
 			}
 		})).ready;
 		return {
-			containerConfig,
+			container: containerConfig,
 			localTag
 		};
 	} catch (error$2) {
@@ -74156,12 +74564,14 @@ async function buildContainerImage(containerConfig, pathToDocker, verifyDockerIs
 }
 __name$2(buildContainerImage, "buildContainerImage");
 async function buildContainerImages(containers, pathToDocker, verifyDockerIsRunning) {
-	const builtContainerDeployments = [];
-	for (const container of containers.filter(isDockerfileContainerConfig)) builtContainerDeployments.push({
-		container,
-		builtImage: await buildContainerImage(container, pathToDocker, verifyDockerIsRunning)
-	});
-	return builtContainerDeployments;
+	const builtImages = [];
+	try {
+		for (const container of containers.filter(isDockerfileContainerConfig)) builtImages.push(await buildContainerImage(container, pathToDocker, verifyDockerIsRunning));
+	} catch (error$2) {
+		await cleanupBuiltImages(builtImages, pathToDocker);
+		throw error$2;
+	}
+	return builtImages;
 }
 __name$2(buildContainerImages, "buildContainerImages");
 async function pushBuiltContainerImage(builtImage, versionId, pathToDocker, accountId, complianceConfig) {
@@ -74169,8 +74579,8 @@ async function pushBuiltContainerImage(builtImage, versionId, pathToDocker, acco
 		const imageRef = await pushImageIfChanged({
 			pathToDocker,
 			sourceTag: builtImage.localTag,
-			targetTag: getContainerImageTag(builtImage.containerConfig, versionId),
-			containerConfig: builtImage.containerConfig,
+			targetTag: getContainerImageTag(builtImage.container, versionId),
+			containerConfig: builtImage.container,
 			accountId,
 			complianceConfig,
 			cleanupSourceTag: true
@@ -74186,8 +74596,8 @@ async function pushBuiltContainerImage(builtImage, versionId, pathToDocker, acco
 	}
 }
 __name$2(pushBuiltContainerImage, "pushBuiltContainerImage");
-async function cleanupBuiltContainerImages(builtContainerDeployments, pathToDocker) {
-	for (const { builtImage } of builtContainerDeployments) {
+async function cleanupBuiltImages(builtImages, pathToDocker) {
+	for (const builtImage of builtImages) {
 		if (builtImage.localTagCleaned) continue;
 		try {
 			logger$1.debug(`Untagging built image: ${builtImage.localTag}.`);
@@ -74202,7 +74612,7 @@ async function cleanupBuiltContainerImages(builtContainerDeployments, pathToDock
 		}
 	}
 }
-__name$2(cleanupBuiltContainerImages, "cleanupBuiltContainerImages");
+__name$2(cleanupBuiltImages, "cleanupBuiltImages");
 function getContainerImageTag(containerConfig, imageTag) {
 	return `${getContainerImageRepositoryName(containerConfig)}:${imageTag.split("-")[0]}`;
 }
@@ -80117,7 +80527,7 @@ __name(createWorkerUploadForm, "createWorkerUploadForm");
 //#endregion
 //#region ../remote-bindings/dist/index.mjs
 var import_undici = require_undici();
-var version$2 = "0.0.23";
+var version$2 = "0.0.24";
 var NoDefaultValueProvided = class extends UserError {
 	constructor() {
 		super("This command cannot be run in a non-interactive context", { telemetryMessage: "remote bindings prompt default missing" });