@cloudflare/vitest-plugin 1.1.7 → 1.1.9

package/dist/pool/index.mjs

@@ -325,7 +325,7 @@ function createFatalError$1(message, isJson, options) {
 __name$3(createFatalError$1, "createFatalError");
 
 //#endregion
-//#region ../workers-utils/dist/chunk-IQDQ5WRD.mjs
+//#region ../workers-utils/dist/chunk-T5JQYOMX.mjs
 function hasKnownExportType(entry) {
 	const type = entry?.type;
 	return type === "durable-object" || type === "worker";
@@ -382,6 +382,48 @@ function getContainerDurableObjectClassNames(containers, exports$1) {
 	return classNames;
 }
 __name$3(getContainerDurableObjectClassNames, "getContainerDurableObjectClassNames");
+function getDurableObjectClassNameToUseSQLiteMap(migrations, exports$1) {
+	const durableObjectClassNameToUseSQLiteMap = /* @__PURE__ */ new Map();
+	(migrations ?? []).forEach((migration) => {
+		migration.deleted_classes?.forEach((deleted_class) => {
+			if (!durableObjectClassNameToUseSQLiteMap.delete(deleted_class)) throw new UserError$1(`Cannot apply deleted_classes migration to non-existent class ${deleted_class}`, { telemetryMessage: "durable object deleted class migration missing class" });
+		});
+		migration.renamed_classes?.forEach(({ from, to }) => {
+			const useSQLite = durableObjectClassNameToUseSQLiteMap.get(from);
+			if (useSQLite === void 0) throw new UserError$1(`Cannot apply renamed_classes migration to non-existent class ${from}`, { telemetryMessage: "durable object renamed class migration missing class" });
+			else {
+				durableObjectClassNameToUseSQLiteMap.delete(from);
+				durableObjectClassNameToUseSQLiteMap.set(to, useSQLite);
+			}
+		});
+		migration.new_classes?.forEach((new_class) => {
+			if (durableObjectClassNameToUseSQLiteMap.has(new_class)) throw new UserError$1(`Cannot apply new_classes migration to existing class ${new_class}`, { telemetryMessage: "durable object new class migration existing class" });
+			else durableObjectClassNameToUseSQLiteMap.set(new_class, false);
+		});
+		migration.new_sqlite_classes?.forEach((new_class) => {
+			if (durableObjectClassNameToUseSQLiteMap.has(new_class)) throw new UserError$1(`Cannot apply new_sqlite_classes migration to existing class ${new_class}`, { telemetryMessage: "durable object new sqlite class migration existing class" });
+			else durableObjectClassNameToUseSQLiteMap.set(new_class, true);
+		});
+	});
+	const durableObjectExports = getDurableObjectExports(exports$1 ?? {});
+	for (const [className, entry] of Object.entries(durableObjectExports)) {
+		if (entry.type !== "durable-object") continue;
+		if (entry.state === void 0 || entry.state === "created" || entry.state === "expecting-transfer") durableObjectClassNameToUseSQLiteMap.set(className, entry.storage === "sqlite");
+	}
+	return durableObjectClassNameToUseSQLiteMap;
+}
+__name$3(getDurableObjectClassNameToUseSQLiteMap, "getDurableObjectClassNameToUseSQLiteMap");
+function validateDurableObjectContainerApplications(config$1, containers = getDurableObjectContainerApps(config$1.containers)) {
+	const allDOs = getDurableObjectClassNameToUseSQLiteMap(config$1.migrations, config$1.exports);
+	for (const container of containers) {
+		const maybeBoundDO = config$1.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$1(`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" });
+		if (maybeBoundDO?.script_name !== void 0) throw new UserError$1(`The container ${container.name} is referencing the durable object ${container.class_name}, which appears to be defined on the ${maybeBoundDO.script_name} Worker instead (via the 'script_name' field). You cannot configure a container on a Durable Object that is defined in another Worker.`, { telemetryMessage: "container class_name refers to an external durable object" });
+		if (useSQLite === false) throw new UserError$1(`The container ${container.name} references Durable Object class ${container.class_name}, which uses the legacy KV storage backend. Durable Object-managed Containers require SQLite-backed Durable Objects.`, { telemetryMessage: "durable object container class uses legacy storage" });
+	}
+}
+__name$3(validateDurableObjectContainerApplications, "validateDurableObjectContainerApplications");
 function createScanner(text, ignoreTrivia = false) {
 	const len = text.length;
 	let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
@@ -2745,8 +2787,8 @@ function formatConfigSnippet(snippet, configPath, formatted = true) {
 __name$3(formatConfigSnippet, "formatConfigSnippet");
 
 //#endregion
-//#region ../workers-utils/dist/chunk-S3ANQ67D.mjs
-var DEFAULT_COMPAT_DATE = "2026-09-10";
+//#region ../workers-utils/dist/chunk-KBTXSRPS.mjs
+var DEFAULT_COMPAT_DATE = "2026-09-11";
 function assertNever(_value) {}
 __name$3(assertNever, "assertNever");
 function mapWorkerMetadataBindings(bindings) {
@@ -42123,7 +42165,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;
 }
@@ -44333,7 +44375,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$3(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();
@@ -44393,7 +44435,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$3(validateContainerExportLinks, "validateContainerExportLinks");
+__name$3(validateContainerExportLinks$1, "validateContainerExportLinks");
 var validatePythonModules = /* @__PURE__ */ __name$3((diagnostics, field, value, topLevelEnv) => {
 	if (value === void 0) return true;
 	if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -60500,7 +60542,7 @@ __name$1(createWorkerUploadForm, "createWorkerUploadForm");
 //#endregion
 //#region ../remote-bindings/dist/index.mjs
 var import_undici = require_undici();
-var version = "0.0.22";
+var version = "0.0.24";
 var NoDefaultValueProvided = class extends UserError$1 {
 	constructor() {
 		super("This command cannot be run in a non-interactive context", { telemetryMessage: "remote bindings prompt default missing" });
@@ -61667,6 +61709,136 @@ function validateSingletonBindings(env$2, ctx) {
 	});
 }
 const EnvSchema = z$1.record(z$1.string(), BindingSchema).superRefine(validateSingletonBindings).optional();
+const ContainerImageDockerfileSchema = z$1.strictObject({
+	dockerfile: z$1.string().min(1),
+	buildContext: z$1.string().optional(),
+	buildVars: z$1.record(z$1.string(), z$1.string()).optional()
+});
+const ContainerImageReferenceSchema = z$1.strictObject({ reference: z$1.string().min(1) });
+const ContainerImageLocalReferenceSchema = z$1.strictObject({ localReference: z$1.string().min(1) });
+const InputContainerImageSchema = z$1.union([ContainerImageDockerfileSchema, ContainerImageReferenceSchema]);
+const OutputContainerImageSchema = z$1.union([ContainerImageReferenceSchema, ContainerImageLocalReferenceSchema]);
+const VALID_ROLLOUT_STEP_PERCENTAGES = new Set([
+	5,
+	10,
+	20,
+	25,
+	50,
+	100
+]);
+const ContainerRolloutStepPercentageSchema = z$1.union([z$1.number(), z$1.array(z$1.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 = z$1.strictObject({
+	enabled: z$1.boolean().optional(),
+	logs: z$1.strictObject({ enabled: z$1.boolean().optional() }).optional()
+});
+const ContainerObservabilitySchema = z$1.union([ContainerObservabilityBaseSchema.extend({ targetInstancePercentage: z$1.number().min(0).max(100).optional() }), ContainerObservabilityBaseSchema.extend({ targetInstanceCount: z$1.number().int().nonnegative().optional() })]);
+const BaseContainerSchema = z$1.strictObject({
+	type: z$1.literal("container"),
+	name: z$1.string().min(1),
+	observability: ContainerObservabilitySchema.optional(),
+	unsafe: z$1.record(z$1.string(), z$1.unknown()).optional()
+});
+const StandardContainerBaseSchema = BaseContainerSchema.extend({
+	maxInstances: z$1.number().int().nonnegative().default(20),
+	instanceType: z$1.union([z$1.enum([
+		"basic",
+		"lite",
+		"standard-1",
+		"standard-2",
+		"standard-3",
+		"standard-4"
+	]), z$1.strictObject({
+		vcpu: z$1.number().min(.0625).optional(),
+		memoryMib: z$1.number().nonnegative().optional(),
+		diskMb: z$1.number().nonnegative().optional()
+	})]).optional(),
+	schedulingPolicy: z$1.enum(["default", "regional"]).optional(),
+	ssh: z$1.strictObject({
+		enabled: z$1.boolean(),
+		port: z$1.number().int().min(1).max(65535).optional()
+	}).optional(),
+	authorizedKeys: z$1.array(z$1.strictObject({
+		name: z$1.string(),
+		publicKey: z$1.string()
+	})).optional(),
+	constraints: z$1.strictObject({
+		regions: z$1.array(z$1.enum([
+			"ENAM",
+			"WNAM",
+			"EEUR",
+			"WEUR",
+			"APAC",
+			"SAM",
+			"ME",
+			"OC",
+			"AFR"
+		])).optional(),
+		jurisdiction: z$1.enum(["eu", "fedramp"]).optional()
+	}).optional(),
+	rollout: z$1.strictObject({
+		kind: z$1.enum([
+			"full-auto",
+			"none",
+			"full-manual"
+		]).optional(),
+		stepPercentage: ContainerRolloutStepPercentageSchema.optional(),
+		activeGracePeriod: z$1.number().nonnegative().optional()
+	}).optional()
+});
+const DurableObjectContainerBaseSchema = BaseContainerSchema.extend({ schedulingPolicy: z$1.literal("durable-object") });
+/**
+* Input Container schema — validates user-authored `cloudflare.config.ts`
+* Container exports. Dockerfiles are built by the consuming build tool.
+*/
+const InputContainerSchema = z$1.union([StandardContainerBaseSchema.extend({ image: InputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: z$1.record(z$1.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 = z$1.union([StandardContainerBaseSchema.extend({ image: OutputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: z$1.record(z$1.string(), OutputContainerImageSchema).optional() })]);
 const DurableObjectCreatedExportSchema = z$1.strictObject({
 	type: z$1.literal("durable-object"),
 	state: z$1.literal("created").optional(),
@@ -61845,8 +62017,13 @@ const InputSettingsSchema = z$1.strictObject({
 * Build Output Specification. Adds the `mode` the build was produced in.
 */
 const OutputSettingsSchema = InputSettingsSchema.extend({ mode: z$1.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.`;
 }
@@ -61863,6 +62040,15 @@ const ConfigExportsTypeSchema = z$1.record(z$1.string(), z$1.unknown()).check((c
 			});
 			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({
@@ -62011,18 +62197,26 @@ function createFatalError(message, isJson, options) {
 	return new FatalError(`${message}`, options);
 }
 __name(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);
@@ -62031,8 +62225,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("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`.
@@ -62700,6 +62936,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) => {
@@ -62720,7 +62959,7 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 		const target = await resolveDefinition(binding.worker);
 		env$2[bindingName] = {
 			...binding,
-			worker: isRecord(target) ? target.name : void 0
+			worker: normalizeConfigReference(binding.worker, target, "worker")
 		};
 	}
 	return {
@@ -62728,22 +62967,151 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 		env: env$2
 	};
 }
+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 = await resolveDefinition(reference);
+		if (isRecord(target) && target.type === "container" && typeof target.name === "string" && !Object.values(resolvedExports).includes(target)) {
+			issues.push({
+				code: "custom",
+				input: reference,
+				path: [
+					"exports",
+					exportName,
+					"container"
+				],
+				message: `The referenced Container "${target.name}" is not exported.`
+			});
+			workerExports[exportName] = {
+				...workerExport,
+				container: void 0
+			};
+			continue;
+		}
+		workerExports[exportName] = {
+			...workerExport,
+			container: normalizeConfigReference(reference, target, "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$1) => ({
 		...issue$1,
 		path: [prefix, ...issue$1.path]
 	}));
 }
+function validateUniqueResourceNames(configExports) {
+	const issues = [];
+	const exportNameByResourceName = {
+		container: /* @__PURE__ */ new Map(),
+		worker: /* @__PURE__ */ new Map()
+	};
+	for (const [exportName, config$1] of Object.entries(configExports)) {
+		if (config$1.type !== "container" && config$1.type !== "worker") continue;
+		const resourceType = config$1.type === "container" ? "Container" : "Worker";
+		const exportNames = exportNameByResourceName[config$1.type];
+		const previousExportName = exportNames.get(config$1.name);
+		if (previousExportName !== void 0) {
+			issues.push({
+				code: "custom",
+				input: config$1.name,
+				path: [exportName, "name"],
+				message: `The ${resourceType} name "${config$1.name}" is also used by the "${previousExportName}" export. ${resourceType} names must be unique.`
+			});
+			continue;
+		}
+		exportNames.set(config$1.name, exportName);
+	}
+	return issues;
+}
+function validateContainerExportLinks(configExports) {
+	const issues = [];
+	const containerNames = /* @__PURE__ */ new Set();
+	for (const config$1 of Object.values(configExports)) if (config$1.type === "container") containerNames.add(config$1.name);
+	const firstReferenceByContainerName = /* @__PURE__ */ new Map();
+	for (const [workerExportName, config$1] of Object.entries(configExports)) {
+		if (config$1.type !== "worker") continue;
+		for (const [durableObjectExportName, workerExport] of Object.entries(config$1.exports ?? {})) {
+			if (workerExport.type !== "durable-object" || !("container" in workerExport) || workerExport.container === void 0) continue;
+			const containerName = workerExport.container;
+			const path$3 = [
+				workerExportName,
+				"exports",
+				durableObjectExportName,
+				"container"
+			];
+			if (!containerNames.has(containerName)) {
+				issues.push({
+					code: "custom",
+					input: containerName,
+					path: path$3,
+					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$3,
+					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);
@@ -62757,17 +63125,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[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[name] = result.data;
+	}
+	issues.push(...validateUniqueResourceNames(data), ...validateContainerExportLinks(data));
 	return issues.length > 0 ? {
 		success: false,
 		error: new z$1.ZodError(issues)