@cloudflare/config 0.10.0 → 0.12.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as triggers, i as exports$1, n as defineWorker, o as bindings, r as resolveExportDefinition, t as defineSettings } from "./public-BwQqexwo.mjs";
+import { a as triggers, i as exports$1, n as defineWorker, o as bindings, r as defineContainer, t as defineSettings } from "./public-BYCVISMH.mjs";
 import * as nodeModule from "node:module";
 import * as z from "zod";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -263,6 +263,136 @@ function validateSingletonBindings(env, ctx) {
 	});
 }
 const EnvSchema = z.record(z.string(), BindingSchema).superRefine(validateSingletonBindings).optional();
+const ContainerImageDockerfileSchema = z.strictObject({
+	dockerfile: z.string().min(1),
+	buildContext: z.string().optional(),
+	buildVars: z.record(z.string(), z.string()).optional()
+});
+const ContainerImageReferenceSchema = z.strictObject({ reference: z.string().min(1) });
+const ContainerImageLocalReferenceSchema = z.strictObject({ localReference: z.string().min(1) });
+const InputContainerImageSchema = z.union([ContainerImageDockerfileSchema, ContainerImageReferenceSchema]);
+const OutputContainerImageSchema = z.union([ContainerImageReferenceSchema, ContainerImageLocalReferenceSchema]);
+const VALID_ROLLOUT_STEP_PERCENTAGES = new Set([
+	5,
+	10,
+	20,
+	25,
+	50,
+	100
+]);
+const ContainerRolloutStepPercentageSchema = z.union([z.number(), z.array(z.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.strictObject({
+	enabled: z.boolean().optional(),
+	logs: z.strictObject({ enabled: z.boolean().optional() }).optional()
+});
+const ContainerObservabilitySchema = z.union([ContainerObservabilityBaseSchema.extend({ targetInstancePercentage: z.number().min(0).max(100).optional() }), ContainerObservabilityBaseSchema.extend({ targetInstanceCount: z.number().int().nonnegative().optional() })]);
+const BaseContainerSchema = z.strictObject({
+	type: z.literal("container"),
+	name: z.string().min(1),
+	observability: ContainerObservabilitySchema.optional(),
+	unsafe: z.record(z.string(), z.unknown()).optional()
+});
+const StandardContainerBaseSchema = BaseContainerSchema.extend({
+	maxInstances: z.number().int().nonnegative().default(20),
+	instanceType: z.union([z.enum([
+		"basic",
+		"lite",
+		"standard-1",
+		"standard-2",
+		"standard-3",
+		"standard-4"
+	]), z.strictObject({
+		vcpu: z.number().min(.0625).optional(),
+		memoryMib: z.number().nonnegative().optional(),
+		diskMb: z.number().nonnegative().optional()
+	})]).optional(),
+	schedulingPolicy: z.enum(["default", "regional"]).optional(),
+	ssh: z.strictObject({
+		enabled: z.boolean(),
+		port: z.number().int().min(1).max(65535).optional()
+	}).optional(),
+	authorizedKeys: z.array(z.strictObject({
+		name: z.string(),
+		publicKey: z.string()
+	})).optional(),
+	constraints: z.strictObject({
+		regions: z.array(z.enum([
+			"ENAM",
+			"WNAM",
+			"EEUR",
+			"WEUR",
+			"APAC",
+			"SAM",
+			"ME",
+			"OC",
+			"AFR"
+		])).optional(),
+		jurisdiction: z.enum(["eu", "fedramp"]).optional()
+	}).optional(),
+	rollout: z.strictObject({
+		kind: z.enum([
+			"full-auto",
+			"none",
+			"full-manual"
+		]).optional(),
+		stepPercentage: ContainerRolloutStepPercentageSchema.optional(),
+		activeGracePeriod: z.number().nonnegative().optional()
+	}).optional()
+});
+const DurableObjectContainerBaseSchema = BaseContainerSchema.extend({ schedulingPolicy: z.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.union([StandardContainerBaseSchema.extend({ image: InputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: z.record(z.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.union([StandardContainerBaseSchema.extend({ image: OutputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: z.record(z.string(), OutputContainerImageSchema).optional() })]);
 const DurableObjectCreatedExportSchema = z.strictObject({
 	type: z.literal("durable-object"),
 	state: z.literal("created").optional(),
@@ -441,8 +571,13 @@ const InputSettingsSchema = z.strictObject({
 * Build Output Specification. Adds the `mode` the build was produced in.
 */
 const OutputSettingsSchema = InputSettingsSchema.extend({ mode: z.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.`;
 }
@@ -459,6 +594,15 @@ const ConfigExportsTypeSchema = z.record(z.string(), z.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({
@@ -475,15 +619,6 @@ const ConfigExportsTypeSchema = z.record(z.string(), z.unknown()).check((ctx) =>
 		});
 	}
 });
-const ConfigExportsObjectSchema = z.object({ settings: InputSettingsSchema.optional() }).catchall(InputWorkerSchema);
-/**
-* Schema for the resolved config exports, keyed by export
-* name. Each value is discriminated on its `type` field. Reserves the
-* `settings` export name exclusively for settings configs: a `settings`
-* config must live on the `settings` export, and the `settings` export
-* may only hold a `settings` config.
-*/
-const ConfigExportsSchema = ConfigExportsTypeSchema.pipe(ConfigExportsObjectSchema);
 const ModuleTypeSchema = z.enum([
 	"esm",
 	"cjs",
@@ -665,18 +800,26 @@ __name(createFatalError, "createFatalError");
 
 //#endregion
 //#region src/convert.ts
+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);
@@ -685,8 +828,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`.
@@ -1349,18 +1534,238 @@ function cleanupImportAttributes(context) {
 
 //#endregion
 //#region src/config-loader.ts
+const CROSS_WORKER_BINDING_TYPES = new Set([
+	"durable-object",
+	"worker",
+	"workflow"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+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) => {
+		const cached = resolvedDefinitions.get(input);
+		if (cached) return cached;
+		const resolved = (async () => {
+			return await (typeof input === "function" ? input(ctx) : input);
+		})();
+		resolvedDefinitions.set(input, resolved);
+		return resolved;
+	};
+}
+async function normalizeWorkerReferences(resolved, resolveDefinition) {
+	if (!isRecord(resolved) || !isRecord(resolved.env)) return resolved;
+	const env = { ...resolved.env };
+	for (const [bindingName, binding] of Object.entries(env)) {
+		if (!isRecord(binding) || typeof binding.type !== "string" || !CROSS_WORKER_BINDING_TYPES.has(binding.type) || !isConfigReference(binding.worker)) continue;
+		const target = await resolveDefinition(binding.worker);
+		env[bindingName] = {
+			...binding,
+			worker: normalizeConfigReference(binding.worker, target, "worker")
+		};
+	}
+	return {
+		...resolved,
+		env
+	};
+}
+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) => ({
+		...issue,
+		path: [prefix, ...issue.path]
+	}));
+}
+function validateUniqueResourceNames(configExports) {
+	const issues = [];
+	const exportNameByResourceName = {
+		container: /* @__PURE__ */ new Map(),
+		worker: /* @__PURE__ */ new Map()
+	};
+	for (const [exportName, config] of Object.entries(configExports)) {
+		if (config.type !== "container" && config.type !== "worker") continue;
+		const resourceType = config.type === "container" ? "Container" : "Worker";
+		const exportNames = exportNameByResourceName[config.type];
+		const previousExportName = exportNames.get(config.name);
+		if (previousExportName !== void 0) {
+			issues.push({
+				code: "custom",
+				input: config.name,
+				path: [exportName, "name"],
+				message: `The ${resourceType} name "${config.name}" is also used by the "${previousExportName}" export. ${resourceType} names must be unique.`
+			});
+			continue;
+		}
+		exportNames.set(config.name, exportName);
+	}
+	return issues;
+}
+function validateContainerExportLinks(configExports) {
+	const issues = [];
+	const containerNames = /* @__PURE__ */ new Set();
+	for (const config of Object.values(configExports)) if (config.type === "container") containerNames.add(config.name);
+	const firstReferenceByContainerName = /* @__PURE__ */ new Map();
+	for (const [workerExportName, config] of Object.entries(configExports)) {
+		if (config.type !== "worker") continue;
+		for (const [durableObjectExportName, workerExport] of Object.entries(config.exports ?? {})) {
+			if (workerExport.type !== "durable-object" || !("container" in workerExport) || workerExport.container === void 0) continue;
+			const containerName = workerExport.container;
+			const path = [
+				workerExportName,
+				"exports",
+				durableObjectExportName,
+				"container"
+			];
+			if (!containerNames.has(containerName)) {
+				issues.push({
+					code: "custom",
+					input: containerName,
+					path,
+					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,
+					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 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 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);
+	if (!typeResult.success) return typeResult;
+	const issues = [];
+	const data = {};
+	const resolvedSettings = resolvedExports.settings;
+	const settingsResult = resolvedSettings ? InputSettingsSchema.safeParse(resolvedSettings) : void 0;
+	if (settingsResult) if (settingsResult.success) data.settings = settingsResult.data;
+	else issues.push(...prefixIssues(settingsResult.error.issues, "settings"));
+	for (const [name, input] of Object.entries(exports$2)) {
+		const resolved = resolvedExports[name];
+		if (!isRecord(resolved)) 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.ZodError(issues)
+	} : {
+		success: true,
+		data
+	};
+}
 /**
-* Load a `cloudflare.config.ts`, resolve all exports, and validate against {@link ConfigExportsSchema}.
+* Load a `cloudflare.config.ts`, resolve all exports, and validate them.
 */
 async function loadAndValidateConfig(configPath, ctx, options) {
 	const { exports: exports$2, dependencies } = await loadConfig(configPath, options);
-	const resolved = {};
-	for (const [name, value] of Object.entries(exports$2)) resolved[name] = await resolveExportDefinition(value, ctx);
 	return {
-		result: ConfigExportsSchema.safeParse(resolved),
+		result: await resolveAndValidateConfigExports(exports$2, ctx),
 		dependencies
 	};
 }
 
 //#endregion
-export { AnalyticsEngineDatasetBindingSchema, AssetsSchema, BindingSchema, BrowserBindingSchema, ConfigExportsSchema, D1BindingSchema, DurableObjectCreatedExportSchema, DurableObjectDeletedExportSchema, DurableObjectExpectingTransferExportSchema, DurableObjectRenamedExportSchema, DurableObjectTransferredExportSchema, ExportSchema, FlagshipBindingSchema, HyperdriveBindingSchema, InputSettingsSchema, InputWorkerSchema, KVBindingSchema, KnownBindingSchema, ModuleTypeSchema, OutputSettingsSchema, OutputWorkerSchema, QueueBindingSchema, R2BindingSchema, TailConsumerSchema, UnsafeBindingSchema, WorkerBindingSchema, WorkerEntrypointExportSchema, bindings, convertToWranglerConfig, defineSettings, defineWorker, exports$1 as exports, generateTypes, loadAndValidateConfig, loadConfig, registerConfigHooks, resolveExportDefinition, triggers, validateSingletonBindings };
+export { AnalyticsEngineDatasetBindingSchema, AssetsSchema, BindingSchema, BrowserBindingSchema, D1BindingSchema, DurableObjectCreatedExportSchema, DurableObjectDeletedExportSchema, DurableObjectExpectingTransferExportSchema, DurableObjectRenamedExportSchema, DurableObjectTransferredExportSchema, ExportSchema, FlagshipBindingSchema, HyperdriveBindingSchema, InputContainerSchema, InputSettingsSchema, InputWorkerSchema, KVBindingSchema, KnownBindingSchema, ModuleTypeSchema, OutputContainerSchema, OutputSettingsSchema, OutputWorkerSchema, QueueBindingSchema, R2BindingSchema, TailConsumerSchema, UnsafeBindingSchema, WorkerBindingSchema, WorkerEntrypointExportSchema, bindings, convertToWranglerConfig, defineContainer, defineSettings, defineWorker, exports$1 as exports, generateTypes, loadAndValidateConfig, loadConfig, registerConfigHooks, resolveAndValidateConfigExports, triggers, validateSingletonBindings };

package/dist/{public-BwQqexwo.mjs → public-BYCVISMH.mjs}

@@ -193,12 +193,17 @@ function worker(options = {}) {
 *
 * @example
 * ```typescript
-* import { defineWorker, exports } from "@cloudflare/config";
+* import { defineContainer, defineWorker, exports } from "@cloudflare/config";
+*
+* const myContainer = defineContainer({
+*   name: "my-container",
+*   image: { dockerfile: "./Dockerfile" },
+* });
 *
 * export default defineWorker({
 *   exports: {
 *     MyDurableObject: exports.durableObject({ storage: "sqlite" }),
-*     MyContainerDO:   exports.durableObject({ storage: "sqlite", container: "my-container" }),
+*     MyContainerDO:   exports.durableObject({ storage: "sqlite", container: myContainer }),
 *     OldClass:        exports.durableObject({ state: "deleted" }),
 *     OldName:         exports.durableObject({ state: "renamed", renamedTo: "NewName" }),
 *     Outgoing:        exports.durableObject({ state: "transferred", transferredTo: "target-worker" }),
@@ -214,55 +219,36 @@ const exports = {
 
 //#endregion
 //#region src/definition.ts
-const DEFINITION = Symbol.for("@cloudflare/config:definition");
-/**
-* Unwrap an authored config from its value / promise / function shape, awaiting
-* the result. A function config is invoked with {@link ConfigContext}.
-*/
-async function unwrap(config, ctx) {
-	return typeof config === "function" ? await config(ctx) : await config;
-}
-/**
-* Resolve any `cloudflare.config.ts` export to its plain config value.
-*
-* A `define*` helper stores its authored config plus `type` under the
-* {@link DEFINITION} symbol; here we unwrap the config and stamp `type` back on.
-* Every other export — a raw object/promise/function — is unwrapped as-is and
-* already carries its own `type`. Discrimination happens afterwards via `type`.
-*/
-async function resolveExportDefinition(def, ctx) {
-	if (typeof def === "object" && def !== null && DEFINITION in def) {
-		const { config, type } = def[DEFINITION];
+/** Add a config type while preserving its value, promise, or function shape. */
+function addConfigType(config, type) {
+	function addType(value) {
 		return {
-			...await unwrap(config, ctx),
+			...value,
 			type
 		};
 	}
-	return await unwrap(def, ctx);
+	if (typeof config === "function") return (ctx) => {
+		const result = config(ctx);
+		return result instanceof Promise ? result.then(addType) : addType(result);
+	};
+	return config instanceof Promise ? config.then(addType) : addType(config);
 }
+/** Create a type-safe config helper for a particular export type. */
+function createConfigDefiner(type) {
+	function define(config) {
+		return addConfigType(config, type);
+	}
+	return define;
+}
+
+//#endregion
+//#region src/container-definition.ts
+/** Declare a Container application. */
+const defineContainer = createConfigDefiner("container");
 
 //#endregion
 //#region src/worker-definition.ts
-function defineWorker(config) {
-	return {
-		[DEFINITION]: {
-			config,
-			type: "worker"
-		},
-		durableObject(options) {
-			return {
-				type: "durable-object",
-				...options
-			};
-		},
-		worker(options) {
-			return {
-				type: "worker",
-				...options
-			};
-		}
-	};
-}
+const defineWorker = createConfigDefiner("worker");
 
 //#endregion
 //#region src/settings-definition.ts
@@ -270,12 +256,7 @@ function defineWorker(config) {
 * Declare shared settings.
 * Authored as a named `settings` export.
 */
-function defineSettings(config) {
-	return { [DEFINITION]: {
-		config,
-		type: "settings"
-	} };
-}
+const defineSettings = createConfigDefiner("settings");
 
 //#endregion
-export { triggers as a, exports as i, defineWorker as n, bindings as o, resolveExportDefinition as r, defineSettings as t };
+export { triggers as a, exports as i, defineWorker as n, bindings as o, defineContainer as r, defineSettings as t };