@cloudflare/config 0.14.0 → 0.16.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 defineContainer, t as defineSettings } from "./public-Dyr8BJqf.mjs";
+import { a as triggers, i as exports$1, n as defineContainer, o as bindings, r as defineWorker, t as defineConfig } from "./public-BMg6-Hxh.mjs";
 import * as nodeModule from "node:module";
 import * as z from "zod";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -322,14 +322,13 @@ 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 StandardContainerObservabilitySchema = 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({
+	observability: StandardContainerObservabilitySchema.optional(),
 	maxInstances: z.number().int().nonnegative().default(20),
 	instanceType: z.union([z.enum([
 		"basic",
@@ -376,16 +375,18 @@ const StandardContainerBaseSchema = BaseContainerSchema.extend({
 		activeGracePeriod: z.number().nonnegative().optional()
 	}).optional()
 });
-const DurableObjectContainerBaseSchema = BaseContainerSchema.extend({ schedulingPolicy: z.literal("durable-object") });
+const DurableObjectContainerBaseSchema = BaseContainerSchema.extend({
+	schedulingPolicy: z.literal("durable-object"),
+	observability: ContainerObservabilityBaseSchema.optional()
+});
 /**
-* Input Container schema — validates user-authored `cloudflare.config.ts`
-* Container exports. Dockerfiles are built by the consuming build tool.
+* Input Container schema — parses user-authored `cloudflare.config.ts`
+* Container objects. 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.
+* Output Container schema — parses `container.config.json` files in the Build
+* Output Specification, after any Dockerfile has been built into a local 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({
@@ -527,7 +528,6 @@ const UnsafeSchema = z.strictObject({
 * (user-authored) and output (on-disk) Worker configs.
 */
 const BaseWorkerSchema = z.strictObject({
-	type: z.literal("worker"),
 	name: z.string(),
 	compatibilityDate: z.string(),
 	compatibilityFlags: z.array(z.string()).optional(),
@@ -548,72 +548,37 @@ const BaseWorkerSchema = z.strictObject({
 	exports: z.record(z.string(), ExportSchema).optional()
 });
 /**
-* Input Worker schema — the shape that user-authored `cloudflare.config.ts`
-* files are validated against. Adds an optional `entrypoint` field to the
-* base schema.
+* Input Worker schema — parses Worker definitions from user-authored
+* `cloudflare.config.ts` files. Adds an optional `entrypoint` field to the base
+* schema.
 */
 const InputWorkerSchema = BaseWorkerSchema.extend({ entrypoint: z.union([z.string(), z.strictObject({ default: z.string() })]).transform((value) => typeof value === "string" ? value : value.default).optional() });
 /**
-* Input settings schema — validates the named `settings` export of a
-* `cloudflare.config.ts`. Holds account/deployment settings shared by the other exports.
+* Input settings schema — parses the account settings at the top level of
+* `cloudflare.config.ts`.
 */
-const InputSettingsSchema = z.strictObject({
-	type: z.literal("settings"),
+const InputSettingsSchema = z.object({
 	accountId: z.string().optional(),
 	complianceRegion: z.enum(["public", "fedramp-high"]).optional()
 });
+/** The resolved, user-authored project configuration. */
+const InputConfigSchema = z.strictObject({
+	...InputSettingsSchema.shape,
+	worker: InputWorkerSchema.optional(),
+	containers: z.array(InputContainerSchema).default([])
+});
+const BuildContextSchema = z.strictObject({
+	isPreview: z.boolean(),
+	mode: z.string().optional()
+});
 /**
-* Output settings schema — the shape of the top-level `config.json` in the
-* Build Output Specification. Adds the `mode` the build was produced in.
+* The shape of the root `config.json` in the Build Output Specification.
+* Account settings remain at the top level while build context is grouped
+* under `buildContext`.
 */
-const OutputSettingsSchema = InputSettingsSchema.extend({ mode: z.string().optional() });
-const DEFAULT_EXPORT_NAME = "default";
-const SETTINGS_EXPORT_NAME = "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.`;
-}
-const ConfigExportsTypeSchema = z.record(z.string(), z.unknown()).check((ctx) => {
-	for (const [key, value] of Object.entries(ctx.value)) {
-		const isObject = typeof value === "object" && value !== null;
-		const type = isObject && "type" in value ? value.type : void 0;
-		if (typeof type !== "string" || !SUPPORTED_EXPORT_TYPES.has(type)) {
-			ctx.issues.push({
-				code: "custom",
-				input: value,
-				path: isObject ? [key, "type"] : [key],
-				message: invalidConfigExportMessage(key)
-			});
-			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({
-			code: "custom",
-			input: value,
-			path: [key],
-			message: `A \`settings\` config is only allowed on the \`${SETTINGS_EXPORT_NAME}\` export; found one on the \`${key}\` export.`
-		});
-		else if (isSettingsName && !isSettingsType) ctx.issues.push({
-			code: "custom",
-			input: value,
-			path: [key],
-			message: `The \`${SETTINGS_EXPORT_NAME}\` export is reserved for a \`settings\` config; found a \`${type}\` config.`
-		});
-	}
+const OutputRootConfigSchema = z.strictObject({
+	...InputSettingsSchema.shape,
+	buildContext: BuildContextSchema
 });
 const ModuleTypeSchema = z.enum([
 	"esm",
@@ -645,9 +610,9 @@ const ManifestSchema = z.strictObject({
 	});
 });
 /**
-* Output Worker schema — the shape of the Worker's `config.json` in the
-* Build Output Specification. Adds an optional `manifest` field to the
-* base schema.
+* Output Worker schema — the shape of the Worker's `worker.config.json` in the
+* Build Output Specification. Adds an optional `manifest` field to the base
+* schema.
 */
 const OutputWorkerSchema = BaseWorkerSchema.extend({ manifest: ManifestSchema.optional() });
 
@@ -713,7 +678,8 @@ function generateTypes({ configPath, packageName = "@cloudflare/config" }) {
 	return import_dist.dedent`
 		/* eslint-disable */
 		// Generated by @cloudflare/config
-		type __WorkerConfig = import("${packageName}").UnwrapConfig<typeof import("${configPath.replace(/\.(ts|js|mts|mjs)$/, "")}").default>;
+		type __Config = import("${packageName}").UnwrapConfig<typeof import("${configPath.replace(/\.(ts|js|mts|mjs)$/, "")}").default>;
+		type __WorkerConfig = import("${packageName}").UnwrapConfig<__Config["worker"]>;
 		type __Env = import("${packageName}").InferEnv<__WorkerConfig>;
 
 		declare namespace Cloudflare {
@@ -804,34 +770,36 @@ const ROLLOUT_KIND_MAP = {
 /**
 * Convert a parsed `@cloudflare/config` config into a Wrangler `RawConfig`.
 *
-* The caller is responsible for unwrapping any function/promise wrappers and
-* validating the configs against their corresponding input schemas before
-* passing them in.
+* The caller is responsible for resolving any function/promise wrappers and
+* parsing the configuration before passing it 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.
+* @param config The parsed configuration.
 * @returns The corresponding Wrangler `RawConfig`.
 */
-function convertToWranglerConfig(workerConfig, settingsConfig, containerExports = []) {
+function convertToWranglerConfig(config) {
 	const result = {};
-	convertTopLevel(workerConfig, result);
-	convertBindingsAndAssets(workerConfig, result);
-	convertExports(workerConfig, result);
-	convertDomains(workerConfig, result);
-	convertTriggers(workerConfig, result);
-	convertTailConsumers(workerConfig, result);
-	if (settingsConfig !== void 0) convertSettings(settingsConfig, result);
-	if (containerExports.length > 0) result.containers = containerExports.map((container) => convertContainer(container));
+	const { worker, containers } = config;
+	if (worker !== void 0) {
+		convertTopLevel(worker, result);
+		convertBindingsAndAssets(worker, result);
+		convertExports(worker, result);
+		convertDomains(worker, result);
+		convertTriggers(worker, result);
+		convertTailConsumers(worker, result);
+	}
+	convertSettings(config, result);
+	if (containers.length > 0) result.containers = containers.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;
+	if (container.schedulingPolicy === "durable-object") {
+		converted.scheduling_policy = "durable_object";
+		if (container.images !== void 0) converted.images = Object.fromEntries(Object.entries(container.images).map(([name, image]) => [name, convertDurableObjectContainerImage(image)]));
+		return converted;
+	}
 	converted.image = "dockerfile" in container.image ? container.image.dockerfile : container.image.reference;
 	converted.max_instances = container.maxInstances;
 	if ("dockerfile" in container.image) {
@@ -860,6 +828,13 @@ function convertContainer(container) {
 	}
 	return converted;
 }
+function convertDurableObjectContainerImage(image) {
+	if ("reference" in image) return { image: image.reference };
+	const converted = { dockerfile: image.dockerfile };
+	if (image.buildContext !== void 0) converted.build_context = image.buildContext;
+	if (image.buildVars !== void 0) converted.build_vars = image.buildVars;
+	return converted;
+}
 function convertContainerObservability(observability) {
 	const converted = {};
 	if (observability.enabled !== void 0) converted.enabled = observability.enabled;
@@ -1414,31 +1389,22 @@ const CF_NO_CACHE_QUERY_KEY = "cf-no-cache";
 const RE_NODE_MODULES = /[/\\]node_modules[/\\]/;
 const depsStore = new AsyncLocalStorage();
 /**
-* Dynamically import a worker config file from disk.
+* Dynamically import a Cloudflare config file from disk.
 *
-* Returns all of the module's exports (keyed by export name, including
-* `default`), plus the set of file paths imported during resolution. Callers
-* are responsible for unwrapping function/promise/definition wrappers around
-* each export and validating them.
+* Returns the module's default export plus the set of file paths imported
+* during resolution.
 *
 * @param configPath Filesystem path to the config file. Relative paths are
 *   resolved against `process.cwd()`.
-* @param options.include When provided, only exports whose names are listed
-*   survive into the returned `exports` map. Filtering happens before any
-*   resolution or validation.
 */
-async function loadConfig(configPath, options) {
+async function loadConfig(configPath) {
 	registerConfigHooks();
 	const url = pathToFileURL(configPath).href;
 	const dependencies = /* @__PURE__ */ new Set();
 	const mod = await depsStore.run(dependencies, () => import(url, { with: { [CF_ATTR]: CF_NO_CACHE_VALUE } }));
-	const exports$2 = {};
-	for (const [name, value] of Object.entries(mod)) {
-		if (options?.include && !options.include.includes(name)) continue;
-		exports$2[name] = value;
-	}
+	if (!("default" in mod)) throw new Error(`The config file "${configPath}" does not have a default export. Export your configuration with \`export default defineConfig({ ... })\`.`);
 	return {
-		exports: exports$2,
+		config: mod.default,
 		dependencies
 	};
 }
@@ -1533,11 +1499,8 @@ const CROSS_WORKER_BINDING_TYPES = new Set([
 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 normalizeConfigReference(reference, resolved) {
+	return isRecord(resolved) && typeof resolved.name === "string" ? resolved.name : reference;
 }
 function createDefinitionResolver(ctx) {
 	const resolvedDefinitions = /* @__PURE__ */ new Map();
@@ -1555,11 +1518,11 @@ 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;
+		if (!isRecord(binding) || typeof binding.type !== "string" || !CROSS_WORKER_BINDING_TYPES.has(binding.type) || typeof binding.worker === "string") continue;
 		const target = await resolveDefinition(binding.worker);
 		env[bindingName] = {
 			...binding,
-			worker: normalizeConfigReference(binding.worker, target, "worker")
+			worker: normalizeConfigReference(binding.worker, target)
 		};
 	}
 	return {
@@ -1567,7 +1530,7 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 		env
 	};
 }
-async function normalizeContainerReferences(resolved, resolveDefinition, resolvedExports) {
+async function normalizeContainerReferences(resolved, resolveDefinition, containers) {
 	const issues = [];
 	if (!isRecord(resolved) || !isRecord(resolved.exports)) return {
 		value: resolved,
@@ -1586,7 +1549,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 					exportName,
 					"container"
 				],
-				message: "Container provided as a string. Reference an exported Container definition instead."
+				message: "Container provided as a string. Reference a Container definition instead, for example `container: myContainer`."
 			});
 			workerExports[exportName] = {
 				...workerExport,
@@ -1595,7 +1558,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 			continue;
 		}
 		const target = await resolveDefinition(reference);
-		if (isRecord(target) && target.type === "container" && typeof target.name === "string" && !Object.values(resolvedExports).includes(target)) {
+		if (isRecord(target) && typeof target.name === "string" && !containers.includes(target)) {
 			issues.push({
 				code: "custom",
 				input: reference,
@@ -1604,7 +1567,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 					exportName,
 					"container"
 				],
-				message: `The referenced Container "${target.name}" is not exported.`
+				message: `The referenced Container "${target.name}" is not included in the \`containers\` array.`
 			});
 			workerExports[exportName] = {
 				...workerExport,
@@ -1614,7 +1577,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 		}
 		workerExports[exportName] = {
 			...workerExport,
-			container: normalizeConfigReference(reference, target, "container")
+			container: normalizeConfigReference(reference, target)
 		};
 	}
 	return {
@@ -1625,8 +1588,8 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 		issues
 	};
 }
-async function normalizeConfigReferences(resolved, resolveDefinition, resolvedExports) {
-	return normalizeContainerReferences(await normalizeWorkerReferences(resolved, resolveDefinition), resolveDefinition, resolvedExports);
+async function normalizeWorkerConfig(resolved, resolveDefinition, containers) {
+	return normalizeContainerReferences(await normalizeWorkerReferences(resolved, resolveDefinition), resolveDefinition, containers);
 }
 function prefixIssues(issues, prefix) {
 	return issues.map((issue) => ({
@@ -1634,129 +1597,99 @@ function prefixIssues(issues, prefix) {
 		path: [prefix, ...issue.path]
 	}));
 }
-function validateUniqueResourceNames(configExports) {
+function validateUniqueContainerNames(config) {
 	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) {
+	const firstIndexByName = /* @__PURE__ */ new Map();
+	for (const [index, container] of config.containers.entries()) {
+		const firstIndex = firstIndexByName.get(container.name);
+		if (firstIndex !== 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.`
+				input: container.name,
+				path: [
+					"containers",
+					index,
+					"name"
+				],
+				message: `The Container name "${container.name}" is also used by \`containers[${firstIndex}]\`. Container names must be unique.`
 			});
 			continue;
 		}
-		exportNames.set(config.name, exportName);
+		firstIndexByName.set(container.name, index);
 	}
 	return issues;
 }
-function validateContainerExportLinks(configExports) {
+function validateContainerLinks(config) {
 	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
+	const firstExportByContainerName = /* @__PURE__ */ new Map();
+	for (const [exportName, workerExport] of Object.entries(config.worker?.exports ?? {})) {
+		if (workerExport.type !== "durable-object" || !("container" in workerExport) || workerExport.container === void 0) continue;
+		const containerName = workerExport.container;
+		const firstExportName = firstExportByContainerName.get(containerName);
+		if (firstExportName !== void 0) {
+			issues.push({
+				code: "custom",
+				input: containerName,
+				path: [
+					"worker",
+					"exports",
+					exportName,
+					"container"
+				],
+				message: `The Container "${containerName}" is already referenced by \`worker.exports.${firstExportName}\`. A Container can only be linked to one Durable Object.`
 			});
+			continue;
 		}
+		firstExportByContainerName.set(containerName, exportName);
 	}
 	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) {
+/** Resolve and parse the default configuration export. */
+async function resolveAndParseConfig(input, 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));
+	const resolved = await resolveDefinition(input);
+	if (!isRecord(resolved)) return InputConfigSchema.safeParse(resolved);
+	const containerInputs = Array.isArray(resolved.containers) ? resolved.containers : [];
+	const containers = await Promise.all(containerInputs.map((container) => resolveDefinition(container)));
+	const normalizedWorker = resolved.worker === void 0 ? {
+		value: void 0,
+		issues: []
+	} : await normalizeWorkerConfig(await resolveDefinition(resolved.worker), resolveDefinition, containers);
+	const candidate = {
+		...resolved,
+		...resolved.worker === void 0 ? {} : { worker: normalizedWorker.value },
+		...Array.isArray(resolved.containers) ? { containers } : {}
+	};
+	const result = InputConfigSchema.safeParse(candidate);
+	const issues = [...prefixIssues(normalizedWorker.issues, "worker")];
+	if (!result.success) issues.push(...result.error.issues);
+	else issues.push(...validateUniqueContainerNames(result.data), ...validateContainerLinks(result.data));
 	return issues.length > 0 ? {
 		success: false,
 		error: new z.ZodError(issues)
-	} : {
-		success: true,
-		data
+	} : result;
+}
+/** Resolve and parse only the account settings in a configuration definition. */
+async function resolveAndParseConfigSettings(input, ctx) {
+	const resolved = await createDefinitionResolver(ctx)(input);
+	return InputSettingsSchema.safeParse(resolved);
+}
+/** Load and parse `cloudflare.config.ts`'s default export. */
+async function loadAndParseConfig(configPath, ctx) {
+	const { config, dependencies } = await loadConfig(configPath);
+	return {
+		result: await resolveAndParseConfig(config, ctx),
+		dependencies
 	};
 }
-/**
-* 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);
+/** Load and parse only account settings from the default export. */
+async function loadAndParseConfigSettings(configPath, ctx) {
+	const { config, dependencies } = await loadConfig(configPath);
 	return {
-		result: await resolveAndValidateConfigExports(exports$2, ctx),
+		result: await resolveAndParseConfigSettings(config, ctx),
 		dependencies
 	};
 }
 
 //#endregion
-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 };
+export { AnalyticsEngineDatasetBindingSchema, AssetsSchema, BindingSchema, BrowserBindingSchema, D1BindingSchema, DurableObjectCreatedExportSchema, DurableObjectDeletedExportSchema, DurableObjectExpectingTransferExportSchema, DurableObjectRenamedExportSchema, DurableObjectTransferredExportSchema, ExportSchema, FlagshipBindingSchema, HyperdriveBindingSchema, InputConfigSchema, InputContainerSchema, InputSettingsSchema, InputWorkerSchema, KVBindingSchema, KnownBindingSchema, ModuleTypeSchema, OutputContainerSchema, OutputRootConfigSchema, OutputWorkerSchema, QueueBindingSchema, R2BindingSchema, TailConsumerSchema, UnsafeBindingSchema, WorkerBindingSchema, WorkerEntrypointExportSchema, bindings, convertToWranglerConfig, defineConfig, defineContainer, defineWorker, exports$1 as exports, generateTypes, loadAndParseConfig, loadAndParseConfigSettings, loadConfig, registerConfigHooks, resolveAndParseConfig, resolveAndParseConfigSettings, triggers, validateSingletonBindings };