@cloudflare/vite-plugin 1.56.0 → 1.57.0

package/dist/index.mjs

@@ -136,7 +136,7 @@ function createFatalError$1(message, isJson, options) {
 __name$6(createFatalError$1, "createFatalError");
 
 //#endregion
-//#region ../workers-utils/dist/chunk-JGKSDUFK.mjs
+//#region ../workers-utils/dist/chunk-JTB7VJSC.mjs
 function hasKnownExportType(entry) {
 	const type = entry?.type;
 	return type === "durable-object" || type === "worker";
@@ -163,7 +163,6 @@ function hasDurableObjectExports(exports$1) {
 	return Object.keys(getDurableObjectExports(exports$1)).length > 0;
 }
 __name$6(hasDurableObjectExports, "hasDurableObjectExports");
-var CONTAINER_IMAGES_BINDING = "EXPERIMENTAL_CLOUDFLARE_CONTAINER_IMAGES";
 function isDurableObjectContainerApp(container) {
 	return container.scheduling_policy === "durable_object";
 }
@@ -2614,8 +2613,8 @@ function formatConfigSnippet(snippet, configPath, formatted = true) {
 __name$6(formatConfigSnippet, "formatConfigSnippet");
 
 //#endregion
-//#region ../workers-utils/dist/chunk-S6ZAI5DC.mjs
-var DEFAULT_COMPAT_DATE = "2026-09-18";
+//#region ../workers-utils/dist/chunk-4PNP2TCS.mjs
+var DEFAULT_COMPAT_DATE = "2026-09-21";
 function assertNever(_value) {}
 __name$6(assertNever, "assertNever");
 function mapWorkerMetadataBindings(bindings) {
@@ -26328,11 +26327,11 @@ var require_ci_info$1 = __commonJS$1({ "../../node_modules/.pnpm/ci-info@4.4.0/n
 var require_command_exists$2 = __commonJS$1({ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports$1, module$1) {
 	var exec$3 = __require$1("child_process").exec;
 	var execSync$2 = __require$1("child_process").execSync;
-	var fs3 = __require$1("fs");
-	var path5 = __require$1("path");
-	var access$1 = fs3.access;
-	var accessSync2 = fs3.accessSync;
-	var constants2 = fs3.constants || fs3;
+	var fs4 = __require$1("fs");
+	var path6 = __require$1("path");
+	var access$1 = fs4.access;
+	var accessSync2 = fs4.accessSync;
+	var constants2 = fs4.constants || fs4;
 	var isUsingWindows$1 = process.platform == "win32";
 	var fileNotExists$1 = /* @__PURE__ */ __name$6(function(commandName, callback$1) {
 		access$1(commandName, constants2.F_OK, function(err) {
@@ -26406,8 +26405,8 @@ var require_command_exists$2 = __commonJS$1({ "../../node_modules/.pnpm/command-
 	}, "cleanInput");
 	if (isUsingWindows$1) cleanInput$1 = /* @__PURE__ */ __name$6(function(s) {
 		if (/[\\]/.test(s)) {
-			var dirname4 = "\"" + path5.dirname(s) + "\"";
-			var basename2 = "\"" + path5.basename(s) + "\"";
+			var dirname4 = "\"" + path6.dirname(s) + "\"";
+			var basename2 = "\"" + path6.basename(s) + "\"";
 			return dirname4 + ":" + basename2;
 		}
 		return "\"" + s + "\"";
@@ -26628,9 +26627,9 @@ var require_strip_json_comments = __commonJS$1({ "../../node_modules/.pnpm/strip
 	};
 } });
 var require_utils$1 = __commonJS$1({ "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports$1) {
-	var fs3 = __require$1("fs");
+	var fs4 = __require$1("fs");
 	var ini = require_ini();
-	var path5 = __require$1("path");
+	var path6 = __require$1("path");
 	var stripJsonComments = require_strip_json_comments();
 	var parse3$1 = exports$1.parse = function(content) {
 		if (/^\s*{/.test(content)) return JSON.parse(stripJsonComments(content));
@@ -26641,9 +26640,9 @@ var require_utils$1 = __commonJS$1({ "../../node_modules/.pnpm/rc@1.2.8/node_mod
 			return arg != null;
 		});
 		for (var i$1 in args) if ("string" !== typeof args[i$1]) return;
-		var file3 = path5.join.apply(null, args);
+		var file3 = path6.join.apply(null, args);
 		try {
-			return fs3.readFileSync(file3, "utf-8");
+			return fs4.readFileSync(file3, "utf-8");
 		} catch (err) {
 			return;
 		}
@@ -26671,14 +26670,14 @@ var require_utils$1 = __commonJS$1({ "../../node_modules/.pnpm/rc@1.2.8/node_mod
 		return obj;
 	};
 	exports$1.find = function() {
-		var rel = path5.join.apply(null, [].slice.call(arguments));
+		var rel = path6.join.apply(null, [].slice.call(arguments));
 		function find2(start, rel2) {
-			var file3 = path5.join(start, rel2);
+			var file3 = path6.join(start, rel2);
 			try {
-				fs3.statSync(file3);
+				fs4.statSync(file3);
 				return file3;
 			} catch (err) {
-				if (path5.dirname(start) !== start) return find2(path5.dirname(start), rel2);
+				if (path6.dirname(start) !== start) return find2(path6.dirname(start), rel2);
 			}
 		}
 		__name$6(find2, "find");
@@ -27068,8 +27067,8 @@ var require_registry_auth_token = __commonJS$1({ "../../node_modules/.pnpm/regis
 		};
 	}
 	__name$6(getLegacyAuthInfo, "getLegacyAuthInfo");
-	function normalizePath$3(path5) {
-		return path5[path5.length - 1] === "/" ? path5 : path5 + "/";
+	function normalizePath$3(path6) {
+		return path6[path6.length - 1] === "/" ? path6 : path6 + "/";
 	}
 	__name$6(normalizePath$3, "normalizePath");
 	function getAuthInfoForUrl(regUrl, npmrc) {
@@ -27106,24 +27105,24 @@ var require_registry_auth_token = __commonJS$1({ "../../node_modules/.pnpm/regis
 var require_update_check = __commonJS$1({ "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports$1, module$1) {
 	var { URL: URL2 } = __require$1("url");
 	var { join: join3 } = __require$1("path");
-	var fs3 = __require$1("fs");
+	var fs4 = __require$1("fs");
 	var { promisify: promisify$3 } = __require$1("util");
 	var { tmpdir } = __require$1("os");
 	var registryUrl = require_registry_url();
-	var writeFile$1 = promisify$3(fs3.writeFile);
-	var mkdir$1 = promisify$3(fs3.mkdir);
-	var readFile$1 = promisify$3(fs3.readFile);
+	var writeFile$1 = promisify$3(fs4.writeFile);
+	var mkdir$1 = promisify$3(fs4.mkdir);
+	var readFile$1 = promisify$3(fs4.readFile);
 	var compareVersions = /* @__PURE__ */ __name$6((a, b) => a.localeCompare(b, "en-US", { numeric: true }), "compareVersions");
 	var encode3 = /* @__PURE__ */ __name$6((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
 	var getFile = /* @__PURE__ */ __name$6(async (details, distTag) => {
 		const subDir = join3(tmpdir(), "update-check");
-		if (!fs3.existsSync(subDir)) await mkdir$1(subDir);
+		if (!fs4.existsSync(subDir)) await mkdir$1(subDir);
 		let name = `${details.name}-${distTag}.json`;
 		if (details.scope) name = `${details.scope}-${name}`;
 		return join3(subDir, name);
 	}, "getFile");
 	var evaluateCache = /* @__PURE__ */ __name$6(async (file2, time3, interval) => {
-		if (fs3.existsSync(file2)) {
+		if (fs4.existsSync(file2)) {
 			const content = await readFile$1(file2, "utf8");
 			const { lastUpdate, latest } = JSON.parse(content);
 			if (lastUpdate + interval > time3) return {
@@ -27225,6 +27224,700 @@ var require_update_check = __commonJS$1({ "../../node_modules/.pnpm/update-check
 		return null;
 	};
 } });
+var require_path = __commonJS$1({ "../../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/lib/path.js"(exports$1, module$1) {
+	module$1.exports = typeof process === "object" && process && process.platform === "win32" ? { sep: "\\" } : { sep: "/" };
+} });
+var require_balanced_match = __commonJS$1({ "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports$1, module$1) {
+	module$1.exports = balanced;
+	function balanced(a, b, str) {
+		if (a instanceof RegExp) a = maybeMatch(a, str);
+		if (b instanceof RegExp) b = maybeMatch(b, str);
+		var r2 = range(a, b, str);
+		return r2 && {
+			start: r2[0],
+			end: r2[1],
+			pre: str.slice(0, r2[0]),
+			body: str.slice(r2[0] + a.length, r2[1]),
+			post: str.slice(r2[1] + b.length)
+		};
+	}
+	__name$6(balanced, "balanced");
+	function maybeMatch(reg, str) {
+		var m = str.match(reg);
+		return m ? m[0] : null;
+	}
+	__name$6(maybeMatch, "maybeMatch");
+	balanced.range = range;
+	function range(a, b, str) {
+		var begs, beg, left, right, result;
+		var ai = str.indexOf(a);
+		var bi = str.indexOf(b, ai + 1);
+		var i$1 = ai;
+		if (ai >= 0 && bi > 0) {
+			if (a === b) return [ai, bi];
+			begs = [];
+			left = str.length;
+			while (i$1 >= 0 && !result) {
+				if (i$1 == ai) {
+					begs.push(i$1);
+					ai = str.indexOf(a, i$1 + 1);
+				} else if (begs.length == 1) result = [begs.pop(), bi];
+				else {
+					beg = begs.pop();
+					if (beg < left) {
+						left = beg;
+						right = bi;
+					}
+					bi = str.indexOf(b, i$1 + 1);
+				}
+				i$1 = ai < bi && ai >= 0 ? ai : bi;
+			}
+			if (begs.length) result = [left, right];
+		}
+		return result;
+	}
+	__name$6(range, "range");
+} });
+var require_brace_expansion = __commonJS$1({ "../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports$1, module$1) {
+	var balanced = require_balanced_match();
+	module$1.exports = expandTop;
+	var escSlash = "\0SLASH" + Math.random() + "\0";
+	var escOpen = "\0OPEN" + Math.random() + "\0";
+	var escClose = "\0CLOSE" + Math.random() + "\0";
+	var escComma = "\0COMMA" + Math.random() + "\0";
+	var escPeriod = "\0PERIOD" + Math.random() + "\0";
+	function numeric$1(str) {
+		return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+	}
+	__name$6(numeric$1, "numeric");
+	function escapeBraces(str) {
+		return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+	}
+	__name$6(escapeBraces, "escapeBraces");
+	function unescapeBraces(str) {
+		return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+	}
+	__name$6(unescapeBraces, "unescapeBraces");
+	function parseCommaParts(str) {
+		if (!str) return [""];
+		var parts = [];
+		var m = balanced("{", "}", str);
+		if (!m) return str.split(",");
+		var pre = m.pre;
+		var body = m.body;
+		var post = m.post;
+		var p$2 = pre.split(",");
+		p$2[p$2.length - 1] += "{" + body + "}";
+		var postParts = parseCommaParts(post);
+		if (post.length) {
+			p$2[p$2.length - 1] += postParts.shift();
+			p$2.push.apply(p$2, postParts);
+		}
+		parts.push.apply(parts, p$2);
+		return parts;
+	}
+	__name$6(parseCommaParts, "parseCommaParts");
+	function expandTop(str) {
+		if (!str) return [];
+		if (str.substr(0, 2) === "{}") str = "\\{\\}" + str.substr(2);
+		return expand(escapeBraces(str), true).map(unescapeBraces);
+	}
+	__name$6(expandTop, "expandTop");
+	function embrace(str) {
+		return "{" + str + "}";
+	}
+	__name$6(embrace, "embrace");
+	function isPadded(el) {
+		return /^-?0\d/.test(el);
+	}
+	__name$6(isPadded, "isPadded");
+	function lte$4(i$1, y) {
+		return i$1 <= y;
+	}
+	__name$6(lte$4, "lte");
+	function gte$4(i$1, y) {
+		return i$1 >= y;
+	}
+	__name$6(gte$4, "gte");
+	function expand(str, isTop) {
+		var expansions = [];
+		var m = balanced("{", "}", str);
+		if (!m) return [str];
+		var pre = m.pre;
+		var post = m.post.length ? expand(m.post, false) : [""];
+		if (/\$$/.test(m.pre)) for (var k = 0; k < post.length; k++) {
+			var expansion = pre + "{" + m.body + "}" + post[k];
+			expansions.push(expansion);
+		}
+		else {
+			var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+			var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+			var isSequence = isNumericSequence || isAlphaSequence;
+			var isOptions = m.body.indexOf(",") >= 0;
+			if (!isSequence && !isOptions) {
+				if (m.post.match(/,.*\}/)) {
+					str = m.pre + "{" + m.body + escClose + m.post;
+					return expand(str);
+				}
+				return [str];
+			}
+			var n2;
+			if (isSequence) n2 = m.body.split(/\.\./);
+			else {
+				n2 = parseCommaParts(m.body);
+				if (n2.length === 1) {
+					n2 = expand(n2[0], false).map(embrace);
+					if (n2.length === 1) return post.map(function(p$2) {
+						return m.pre + n2[0] + p$2;
+					});
+				}
+			}
+			var N;
+			if (isSequence) {
+				var x = numeric$1(n2[0]);
+				var y = numeric$1(n2[1]);
+				var width = Math.max(n2[0].length, n2[1].length);
+				var incr = n2.length == 3 ? Math.abs(numeric$1(n2[2])) : 1;
+				var test = lte$4;
+				if (y < x) {
+					incr *= -1;
+					test = gte$4;
+				}
+				var pad = n2.some(isPadded);
+				N = [];
+				for (var i$1 = x; test(i$1, y); i$1 += incr) {
+					var c$1;
+					if (isAlphaSequence) {
+						c$1 = String.fromCharCode(i$1);
+						if (c$1 === "\\") c$1 = "";
+					} else {
+						c$1 = String(i$1);
+						if (pad) {
+							var need = width - c$1.length;
+							if (need > 0) {
+								var z2 = new Array(need + 1).join("0");
+								if (i$1 < 0) c$1 = "-" + z2 + c$1.slice(1);
+								else c$1 = z2 + c$1;
+							}
+						}
+					}
+					N.push(c$1);
+				}
+			} else {
+				N = [];
+				for (var j$1 = 0; j$1 < n2.length; j$1++) N.push.apply(N, expand(n2[j$1], false));
+			}
+			for (var j$1 = 0; j$1 < N.length; j$1++) for (var k = 0; k < post.length; k++) {
+				var expansion = pre + N[j$1] + post[k];
+				if (!isTop || isSequence || expansion) expansions.push(expansion);
+			}
+		}
+		return expansions;
+	}
+	__name$6(expand, "expand");
+} });
+var require_minimatch = __commonJS$1({ "../../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/minimatch.js"(exports$1, module$1) {
+	var minimatch = module$1.exports = (p$2, pattern, options = {}) => {
+		assertValidPattern(pattern);
+		if (!options.nocomment && pattern.charAt(0) === "#") return false;
+		return new Minimatch2(pattern, options).match(p$2);
+	};
+	module$1.exports = minimatch;
+	var path6 = require_path();
+	minimatch.sep = path6.sep;
+	var GLOBSTAR = Symbol("globstar **");
+	minimatch.GLOBSTAR = GLOBSTAR;
+	var expand = require_brace_expansion();
+	var plTypes = {
+		"!": {
+			open: "(?:(?!(?:",
+			close: "))[^/]*?)"
+		},
+		"?": {
+			open: "(?:",
+			close: ")?"
+		},
+		"+": {
+			open: "(?:",
+			close: ")+"
+		},
+		"*": {
+			open: "(?:",
+			close: ")*"
+		},
+		"@": {
+			open: "(?:",
+			close: ")"
+		}
+	};
+	var qmark = "[^/]";
+	var star = qmark + "*?";
+	var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+	var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+	var charSet = /* @__PURE__ */ __name$6((s) => s.split("").reduce((set2, c$1) => {
+		set2[c$1] = true;
+		return set2;
+	}, {}), "charSet");
+	var reSpecials = charSet("().*{}+?[]^$\\!");
+	var addPatternStartSet = charSet("[.(");
+	var slashSplit = /\/+/;
+	minimatch.filter = (pattern, options = {}) => (p$2, i$1, list$1) => minimatch(p$2, pattern, options);
+	var ext = /* @__PURE__ */ __name$6((a, b = {}) => {
+		const t2 = {};
+		Object.keys(a).forEach((k) => t2[k] = a[k]);
+		Object.keys(b).forEach((k) => t2[k] = b[k]);
+		return t2;
+	}, "ext");
+	minimatch.defaults = (def) => {
+		if (!def || typeof def !== "object" || !Object.keys(def).length) return minimatch;
+		const orig = minimatch;
+		const m = /* @__PURE__ */ __name$6((p$2, pattern, options) => orig(p$2, pattern, ext(def, options)), "m");
+		m.Minimatch = class Minimatch extends orig.Minimatch {
+			static {
+				__name$6(this, "Minimatch");
+			}
+			constructor(pattern, options) {
+				super(pattern, ext(def, options));
+			}
+		};
+		m.Minimatch.defaults = (options) => orig.defaults(ext(def, options)).Minimatch;
+		m.filter = (pattern, options) => orig.filter(pattern, ext(def, options));
+		m.defaults = (options) => orig.defaults(ext(def, options));
+		m.makeRe = (pattern, options) => orig.makeRe(pattern, ext(def, options));
+		m.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext(def, options));
+		m.match = (list$1, pattern, options) => orig.match(list$1, pattern, ext(def, options));
+		return m;
+	};
+	minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options);
+	var braceExpand = /* @__PURE__ */ __name$6((pattern, options = {}) => {
+		assertValidPattern(pattern);
+		if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) return [pattern];
+		return expand(pattern);
+	}, "braceExpand");
+	var MAX_PATTERN_LENGTH = 1024 * 64;
+	var assertValidPattern = /* @__PURE__ */ __name$6((pattern) => {
+		if (typeof pattern !== "string") throw new TypeError("invalid pattern");
+		if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
+	}, "assertValidPattern");
+	var SUBPARSE = Symbol("subparse");
+	minimatch.makeRe = (pattern, options) => new Minimatch2(pattern, options || {}).makeRe();
+	minimatch.match = (list$1, pattern, options = {}) => {
+		const mm = new Minimatch2(pattern, options);
+		list$1 = list$1.filter((f) => mm.match(f));
+		if (mm.options.nonull && !list$1.length) list$1.push(pattern);
+		return list$1;
+	};
+	var globUnescape = /* @__PURE__ */ __name$6((s) => s.replace(/\\(.)/g, "$1"), "globUnescape");
+	var charUnescape = /* @__PURE__ */ __name$6((s) => s.replace(/\\([^-\]])/g, "$1"), "charUnescape");
+	var regExpEscape = /* @__PURE__ */ __name$6((s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "regExpEscape");
+	var braExpEscape = /* @__PURE__ */ __name$6((s) => s.replace(/[[\]\\]/g, "\\$&"), "braExpEscape");
+	var Minimatch2 = class {
+		static {
+			__name$6(this, "Minimatch");
+		}
+		constructor(pattern, options) {
+			assertValidPattern(pattern);
+			if (!options) options = {};
+			this.options = options;
+			this.set = [];
+			this.pattern = pattern;
+			this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+			if (this.windowsPathsNoEscape) this.pattern = this.pattern.replace(/\\/g, "/");
+			this.regexp = null;
+			this.negate = false;
+			this.comment = false;
+			this.empty = false;
+			this.partial = !!options.partial;
+			this.make();
+		}
+		debug() {}
+		make() {
+			const pattern = this.pattern;
+			const options = this.options;
+			if (!options.nocomment && pattern.charAt(0) === "#") {
+				this.comment = true;
+				return;
+			}
+			if (!pattern) {
+				this.empty = true;
+				return;
+			}
+			this.parseNegate();
+			let set2 = this.globSet = this.braceExpand();
+			if (options.debug) this.debug = (...args) => console.error(...args);
+			this.debug(this.pattern, set2);
+			set2 = this.globParts = set2.map((s) => s.split(slashSplit));
+			this.debug(this.pattern, set2);
+			set2 = set2.map((s, si, set3) => s.map(this.parse, this));
+			this.debug(this.pattern, set2);
+			set2 = set2.filter((s) => s.indexOf(false) === -1);
+			this.debug(this.pattern, set2);
+			this.set = set2;
+		}
+		parseNegate() {
+			if (this.options.nonegate) return;
+			const pattern = this.pattern;
+			let negate = false;
+			let negateOffset = 0;
+			for (let i$1 = 0; i$1 < pattern.length && pattern.charAt(i$1) === "!"; i$1++) {
+				negate = !negate;
+				negateOffset++;
+			}
+			if (negateOffset) this.pattern = pattern.slice(negateOffset);
+			this.negate = negate;
+		}
+		matchOne(file2, pattern, partial2) {
+			var options = this.options;
+			this.debug("matchOne", {
+				"this": this,
+				file: file2,
+				pattern
+			});
+			this.debug("matchOne", file2.length, pattern.length);
+			for (var fi = 0, pi = 0, fl = file2.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+				this.debug("matchOne loop");
+				var p$2 = pattern[pi];
+				var f = file2[fi];
+				this.debug(pattern, p$2, f);
+				if (p$2 === false) return false;
+				if (p$2 === GLOBSTAR) {
+					this.debug("GLOBSTAR", [
+						pattern,
+						p$2,
+						f
+					]);
+					var fr = fi;
+					var pr = pi + 1;
+					if (pr === pl) {
+						this.debug("** at the end");
+						for (; fi < fl; fi++) if (file2[fi] === "." || file2[fi] === ".." || !options.dot && file2[fi].charAt(0) === ".") return false;
+						return true;
+					}
+					while (fr < fl) {
+						var swallowee = file2[fr];
+						this.debug("\nglobstar while", file2, fr, pattern, pr, swallowee);
+						if (this.matchOne(file2.slice(fr), pattern.slice(pr), partial2)) {
+							this.debug("globstar found match!", fr, fl, swallowee);
+							return true;
+						} else {
+							if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+								this.debug("dot detected!", file2, fr, pattern, pr);
+								break;
+							}
+							this.debug("globstar swallow a segment, and continue");
+							fr++;
+						}
+					}
+					if (partial2) {
+						this.debug("\n>>> no match, partial?", file2, fr, pattern, pr);
+						if (fr === fl) return true;
+					}
+					return false;
+				}
+				var hit;
+				if (typeof p$2 === "string") {
+					hit = f === p$2;
+					this.debug("string match", p$2, f, hit);
+				} else {
+					hit = f.match(p$2);
+					this.debug("pattern match", p$2, f, hit);
+				}
+				if (!hit) return false;
+			}
+			if (fi === fl && pi === pl) return true;
+			else if (fi === fl) return partial2;
+			else if (pi === pl) return fi === fl - 1 && file2[fi] === "";
+			throw new Error("wtf?");
+		}
+		braceExpand() {
+			return braceExpand(this.pattern, this.options);
+		}
+		parse(pattern, isSub) {
+			assertValidPattern(pattern);
+			const options = this.options;
+			if (pattern === "**") if (!options.noglobstar) return GLOBSTAR;
+			else pattern = "*";
+			if (pattern === "") return "";
+			let re$5 = "";
+			let hasMagic = false;
+			let escaping = false;
+			const patternListStack = [];
+			const negativeLists = [];
+			let stateChar;
+			let inClass = false;
+			let reClassStart = -1;
+			let classStart = -1;
+			let cs;
+			let pl;
+			let sp;
+			let dotTravAllowed = pattern.charAt(0) === ".";
+			let dotFileAllowed = options.dot || dotTravAllowed;
+			const patternStart = /* @__PURE__ */ __name$6(() => dotTravAllowed ? "" : dotFileAllowed ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)", "patternStart");
+			const subPatternStart = /* @__PURE__ */ __name$6((p$2) => p$2.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)", "subPatternStart");
+			const clearStateChar = /* @__PURE__ */ __name$6(() => {
+				if (stateChar) {
+					switch (stateChar) {
+						case "*":
+							re$5 += star;
+							hasMagic = true;
+							break;
+						case "?":
+							re$5 += qmark;
+							hasMagic = true;
+							break;
+						default:
+							re$5 += "\\" + stateChar;
+							break;
+					}
+					this.debug("clearStateChar %j %j", stateChar, re$5);
+					stateChar = false;
+				}
+			}, "clearStateChar");
+			for (let i$1 = 0, c$1; i$1 < pattern.length && (c$1 = pattern.charAt(i$1)); i$1++) {
+				this.debug("%s	%s %s %j", pattern, i$1, re$5, c$1);
+				if (escaping) {
+					if (c$1 === "/") return false;
+					if (reSpecials[c$1]) re$5 += "\\";
+					re$5 += c$1;
+					escaping = false;
+					continue;
+				}
+				switch (c$1) {
+					case "/": return false;
+					case "\\":
+						if (inClass && pattern.charAt(i$1 + 1) === "-") {
+							re$5 += c$1;
+							continue;
+						}
+						clearStateChar();
+						escaping = true;
+						continue;
+					case "?":
+					case "*":
+					case "+":
+					case "@":
+					case "!":
+						this.debug("%s	%s %s %j <-- stateChar", pattern, i$1, re$5, c$1);
+						if (inClass) {
+							this.debug("  in class");
+							if (c$1 === "!" && i$1 === classStart + 1) c$1 = "^";
+							re$5 += c$1;
+							continue;
+						}
+						this.debug("call clearStateChar %j", stateChar);
+						clearStateChar();
+						stateChar = c$1;
+						if (options.noext) clearStateChar();
+						continue;
+					case "(": {
+						if (inClass) {
+							re$5 += "(";
+							continue;
+						}
+						if (!stateChar) {
+							re$5 += "\\(";
+							continue;
+						}
+						const plEntry = {
+							type: stateChar,
+							start: i$1 - 1,
+							reStart: re$5.length,
+							open: plTypes[stateChar].open,
+							close: plTypes[stateChar].close
+						};
+						this.debug(this.pattern, "	", plEntry);
+						patternListStack.push(plEntry);
+						re$5 += plEntry.open;
+						if (plEntry.start === 0 && plEntry.type !== "!") {
+							dotTravAllowed = true;
+							re$5 += subPatternStart(pattern.slice(i$1 + 1));
+						}
+						this.debug("plType %j %j", stateChar, re$5);
+						stateChar = false;
+						continue;
+					}
+					case ")": {
+						const plEntry = patternListStack[patternListStack.length - 1];
+						if (inClass || !plEntry) {
+							re$5 += "\\)";
+							continue;
+						}
+						patternListStack.pop();
+						clearStateChar();
+						hasMagic = true;
+						pl = plEntry;
+						re$5 += pl.close;
+						if (pl.type === "!") negativeLists.push(Object.assign(pl, { reEnd: re$5.length }));
+						continue;
+					}
+					case "|": {
+						const plEntry = patternListStack[patternListStack.length - 1];
+						if (inClass || !plEntry) {
+							re$5 += "\\|";
+							continue;
+						}
+						clearStateChar();
+						re$5 += "|";
+						if (plEntry.start === 0 && plEntry.type !== "!") {
+							dotTravAllowed = true;
+							re$5 += subPatternStart(pattern.slice(i$1 + 1));
+						}
+						continue;
+					}
+					case "[":
+						clearStateChar();
+						if (inClass) {
+							re$5 += "\\" + c$1;
+							continue;
+						}
+						inClass = true;
+						classStart = i$1;
+						reClassStart = re$5.length;
+						re$5 += c$1;
+						continue;
+					case "]":
+						if (i$1 === classStart + 1 || !inClass) {
+							re$5 += "\\" + c$1;
+							continue;
+						}
+						cs = pattern.substring(classStart + 1, i$1);
+						try {
+							RegExp("[" + braExpEscape(charUnescape(cs)) + "]");
+							re$5 += c$1;
+						} catch (er) {
+							re$5 = re$5.substring(0, reClassStart) + "(?:$.)";
+						}
+						hasMagic = true;
+						inClass = false;
+						continue;
+					default:
+						clearStateChar();
+						if (reSpecials[c$1] && !(c$1 === "^" && inClass)) re$5 += "\\";
+						re$5 += c$1;
+						break;
+				}
+			}
+			if (inClass) {
+				cs = pattern.slice(classStart + 1);
+				sp = this.parse(cs, SUBPARSE);
+				re$5 = re$5.substring(0, reClassStart) + "\\[" + sp[0];
+				hasMagic = hasMagic || sp[1];
+			}
+			for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+				let tail$1;
+				tail$1 = re$5.slice(pl.reStart + pl.open.length);
+				this.debug("setting tail", re$5, pl);
+				tail$1 = tail$1.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
+					if (!$2) $2 = "\\";
+					return $1 + $1 + $2 + "|";
+				});
+				this.debug("tail=%j\n   %s", tail$1, tail$1, pl, re$5);
+				const t2 = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+				hasMagic = true;
+				re$5 = re$5.slice(0, pl.reStart) + t2 + "\\(" + tail$1;
+			}
+			clearStateChar();
+			if (escaping) re$5 += "\\\\";
+			const addPatternStart = addPatternStartSet[re$5.charAt(0)];
+			for (let n2 = negativeLists.length - 1; n2 > -1; n2--) {
+				const nl = negativeLists[n2];
+				const nlBefore = re$5.slice(0, nl.reStart);
+				const nlFirst = re$5.slice(nl.reStart, nl.reEnd - 8);
+				let nlAfter = re$5.slice(nl.reEnd);
+				const nlLast = re$5.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
+				const closeParensBefore = nlBefore.split(")").length;
+				const openParensBefore = nlBefore.split("(").length - closeParensBefore;
+				let cleanAfter = nlAfter;
+				for (let i$1 = 0; i$1 < openParensBefore; i$1++) cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+				nlAfter = cleanAfter;
+				const dollar = nlAfter === "" && isSub !== SUBPARSE ? "(?:$|\\/)" : "";
+				re$5 = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+			}
+			if (re$5 !== "" && hasMagic) re$5 = "(?=.)" + re$5;
+			if (addPatternStart) re$5 = patternStart() + re$5;
+			if (isSub === SUBPARSE) return [re$5, hasMagic];
+			if (options.nocase && !hasMagic) hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();
+			if (!hasMagic) return globUnescape(pattern);
+			const flags = options.nocase ? "i" : "";
+			try {
+				return Object.assign(new RegExp("^" + re$5 + "$", flags), {
+					_glob: pattern,
+					_src: re$5
+				});
+			} catch (er) {
+				return /* @__PURE__ */ new RegExp("$.");
+			}
+		}
+		makeRe() {
+			if (this.regexp || this.regexp === false) return this.regexp;
+			const set2 = this.set;
+			if (!set2.length) {
+				this.regexp = false;
+				return this.regexp;
+			}
+			const options = this.options;
+			const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+			const flags = options.nocase ? "i" : "";
+			let re$5 = set2.map((pattern) => {
+				pattern = pattern.map((p$2) => typeof p$2 === "string" ? regExpEscape(p$2) : p$2 === GLOBSTAR ? GLOBSTAR : p$2._src).reduce((set3, p$2) => {
+					if (!(set3[set3.length - 1] === GLOBSTAR && p$2 === GLOBSTAR)) set3.push(p$2);
+					return set3;
+				}, []);
+				pattern.forEach((p$2, i$1) => {
+					if (p$2 !== GLOBSTAR || pattern[i$1 - 1] === GLOBSTAR) return;
+					if (i$1 === 0) if (pattern.length > 1) pattern[i$1 + 1] = "(?:\\/|" + twoStar + "\\/)?" + pattern[i$1 + 1];
+					else pattern[i$1] = twoStar;
+					else if (i$1 === pattern.length - 1) pattern[i$1 - 1] += "(?:\\/|" + twoStar + ")?";
+					else {
+						pattern[i$1 - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i$1 + 1];
+						pattern[i$1 + 1] = GLOBSTAR;
+					}
+				});
+				return pattern.filter((p$2) => p$2 !== GLOBSTAR).join("/");
+			}).join("|");
+			re$5 = "^(?:" + re$5 + ")$";
+			if (this.negate) re$5 = "^(?!" + re$5 + ").*$";
+			try {
+				this.regexp = new RegExp(re$5, flags);
+			} catch (ex) {
+				this.regexp = false;
+			}
+			return this.regexp;
+		}
+		match(f, partial2 = this.partial) {
+			this.debug("match", f, this.pattern);
+			if (this.comment) return false;
+			if (this.empty) return f === "";
+			if (f === "/" && partial2) return true;
+			const options = this.options;
+			if (path6.sep !== "/") f = f.split(path6.sep).join("/");
+			f = f.split(slashSplit);
+			this.debug(this.pattern, "split", f);
+			const set2 = this.set;
+			this.debug(this.pattern, "set", set2);
+			let filename;
+			for (let i$1 = f.length - 1; i$1 >= 0; i$1--) {
+				filename = f[i$1];
+				if (filename) break;
+			}
+			for (let i$1 = 0; i$1 < set2.length; i$1++) {
+				const pattern = set2[i$1];
+				let file2 = f;
+				if (options.matchBase && pattern.length === 1) file2 = [filename];
+				if (this.matchOne(file2, pattern, partial2)) {
+					if (options.flipNegate) return true;
+					return !this.negate;
+				}
+			}
+			if (options.flipNegate) return false;
+			return this.negate;
+		}
+		static defaults(def) {
+			return minimatch.defaults(def).Minimatch;
+		}
+	};
+	minimatch.Minimatch = Minimatch2;
+} });
 var ARTIFACTS_EVENT_TYPES = [
 	"cf.artifacts.repo.created",
 	"cf.artifacts.repo.deleted",
@@ -28113,9 +28806,9 @@ function cloneDef(schema) {
 	return mergeDefs$1(schema._zod.def);
 }
 __name$6(cloneDef, "cloneDef");
-function getElementAtPath(obj, path5) {
-	if (!path5) return obj;
-	return path5.reduce((acc, key) => acc?.[key], obj);
+function getElementAtPath(obj, path6) {
+	if (!path6) return obj;
+	return path6.reduce((acc, key) => acc?.[key], obj);
 }
 __name$6(getElementAtPath, "getElementAtPath");
 function promiseAllObject(promisesObj) {
@@ -28445,11 +29138,11 @@ function explicitlyAborted$1(x, startIndex = 0) {
 	return false;
 }
 __name$6(explicitlyAborted$1, "explicitlyAborted");
-function prefixIssues$2(path5, issues) {
+function prefixIssues$2(path6, issues) {
 	return issues.map((iss) => {
 		var _a3;
 		(_a3 = iss).path ?? (_a3.path = []);
-		iss.path.unshift(path5);
+		iss.path.unshift(path6);
 		return iss;
 	});
 }
@@ -28584,12 +29277,12 @@ function flattenError$1(error51, mapper = (issue2) => issue2.message) {
 __name$6(flattenError$1, "flattenError");
 function formatError$2(error51, mapper = (issue2) => issue2.message) {
 	const fieldErrors = { _errors: [] };
-	const processError = /* @__PURE__ */ __name$6((error52, path5 = []) => {
-		for (const issue2 of error52.issues) if (issue2.code === "invalid_union" && issue2.errors.length) issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
-		else if (issue2.code === "invalid_key") processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
-		else if (issue2.code === "invalid_element") processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+	const processError = /* @__PURE__ */ __name$6((error52, path6 = []) => {
+		for (const issue2 of error52.issues) if (issue2.code === "invalid_union" && issue2.errors.length) issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+		else if (issue2.code === "invalid_key") processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+		else if (issue2.code === "invalid_element") processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
 		else {
-			const fullpath = [...path5, ...issue2.path];
+			const fullpath = [...path6, ...issue2.path];
 			if (fullpath.length === 0) fieldErrors._errors.push(mapper(issue2));
 			else {
 				let curr = fieldErrors;
@@ -28613,13 +29306,13 @@ function formatError$2(error51, mapper = (issue2) => issue2.message) {
 __name$6(formatError$2, "formatError");
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
 	const result = { errors: [] };
-	const processError = /* @__PURE__ */ __name$6((error52, path5 = []) => {
+	const processError = /* @__PURE__ */ __name$6((error52, path6 = []) => {
 		var _a3, _b;
-		for (const issue2 of error52.issues) if (issue2.code === "invalid_union" && issue2.errors.length) issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
-		else if (issue2.code === "invalid_key") processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
-		else if (issue2.code === "invalid_element") processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+		for (const issue2 of error52.issues) if (issue2.code === "invalid_union" && issue2.errors.length) issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+		else if (issue2.code === "invalid_key") processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+		else if (issue2.code === "invalid_element") processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
 		else {
-			const fullpath = [...path5, ...issue2.path];
+			const fullpath = [...path6, ...issue2.path];
 			if (fullpath.length === 0) {
 				result.errors.push(mapper(issue2));
 				continue;
@@ -28649,8 +29342,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 __name$6(treeifyError, "treeifyError");
 function toDotPath(_path) {
 	const segs = [];
-	const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-	for (const seg of path5) if (typeof seg === "number") segs.push(`[${seg}]`);
+	const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+	for (const seg of path6) if (typeof seg === "number") segs.push(`[${seg}]`);
 	else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
 	else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
 	else {
@@ -40782,11 +41475,11 @@ function detectVersion(schema, defaultTarget) {
 __name$6(detectVersion, "detectVersion");
 function resolveRef(ref$1, ctx) {
 	if (!ref$1.startsWith("#")) throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
-	const path5 = ref$1.slice(1).split("/").filter(Boolean);
-	if (path5.length === 0) return ctx.rootSchema;
+	const path6 = ref$1.slice(1).split("/").filter(Boolean);
+	if (path6.length === 0) return ctx.rootSchema;
 	const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-	if (path5[0] === defsKey) {
-		const key = path5[1];
+	if (path6[0] === defsKey) {
+		const key = path6[1];
 		if (!key || !ctx.defs[key]) throw new Error(`Reference not found: ${ref$1}`);
 		return ctx.defs[key];
 	}
@@ -41175,9 +41868,9 @@ Please add "${field}" to "env.${envName}".`);
 	return rawEnv[field] ?? defaultValue;
 }
 __name$6(notInheritable, "notInheritable");
-function unwindPropertyPath(root, path5) {
+function unwindPropertyPath(root, path6) {
 	let container = root;
-	const parts = path5.split(".");
+	const parts = path6.split(".");
 	for (let i$1 = 0; i$1 < parts.length - 1; i$1++) {
 		if (!hasProperty(container, parts[i$1])) return;
 		container = container[parts[i$1]];
@@ -41963,7 +42656,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$1(diagnostics, environment.containers, environment.exports, containersDeclaredElsewhere);
+	validateContainerExportLinks(diagnostics, environment.containers, environment.exports, containersDeclaredElsewhere);
 	if (envName !== "top level") validateAdditionalProperties(diagnostics, "env." + envName, Object.keys(rawEnv), Object.keys(environment));
 	return environment;
 }
@@ -43255,7 +43948,6 @@ var validateBindingsHaveUniqueNames = /* @__PURE__ */ __name$6((diagnostics, con
 	const bindingNamesArray = Object.entries(friendlyBindingNames);
 	const bindingsGroupedByType = Object.fromEntries(bindingNamesArray.map(([bindingType, binding]) => [binding, getBindingNames(bindingType === "queues" ? config2[bindingType]?.producers : config2[bindingType])]));
 	bindingsGroupedByType["Secret"] = config2.secrets?.required ?? [];
-	bindingsGroupedByType["Container images"] = [CONTAINER_IMAGES_BINDING];
 	const bindingsGroupedByName = {};
 	for (const bindingType in bindingsGroupedByType) {
 		const bindingNames = bindingsGroupedByType[bindingType];
@@ -44226,7 +44918,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$1(diagnostics, containers, exports$1, containersDeclaredElsewhere) {
+function validateContainerExportLinks(diagnostics, containers, exports$1, containersDeclaredElsewhere) {
 	if (containers !== void 0 && !Array.isArray(containers)) return;
 	if (containers === void 0 && containersDeclaredElsewhere) return;
 	const containersByName = /* @__PURE__ */ new Map();
@@ -44286,7 +44978,7 @@ function validateContainerExportLinks$1(diagnostics, containers, exports$1, cont
 		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$1, "validateContainerExportLinks");
+__name$6(validateContainerExportLinks, "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)) {
@@ -46718,6 +47410,91 @@ function toUrlPath(filePath) {
 	return filePath.replace(/\\/g, "/");
 }
 __name$6(toUrlPath, "toUrlPath");
+var import_minimatch = __toESM(require_minimatch());
+var DEFAULT_MIGRATIONS_DIR = "./migrations";
+function getD1MigrationFiles(options) {
+	const migrationsDir = normalizeRelativePath(options.migrationsDir ?? DEFAULT_MIGRATIONS_DIR);
+	const dirRelativePattern = stripDirPrefix(normalizeRelativePath(options.migrationsPattern ?? `${migrationsDir}/*.sql`), migrationsDir);
+	const walkRoot = path__default.resolve(options.projectPath, migrationsDir);
+	return listFilesRelative(walkRoot, new import_minimatch.Minimatch(dirRelativePattern, { dot: false })).map((name) => ({
+		name,
+		filePath: path__default.join(walkRoot, ...name.split("/"))
+	}));
+}
+__name$6(getD1MigrationFiles, "getD1MigrationFiles");
+function normalizeRelativePath(p$2) {
+	const forwardSlashed = p$2.replace(/\\/g, "/");
+	const normalized = path__default.posix.normalize(forwardSlashed);
+	if (normalized.endsWith("/")) return normalized.slice(0, -1);
+	return normalized;
+}
+__name$6(normalizeRelativePath, "normalizeRelativePath");
+function stripDirPrefix(pattern, dir2) {
+	if (dir2 === ".") return pattern;
+	const prefix = `${dir2}/`;
+	if (!pattern.startsWith(prefix)) throw new Error(`Expected migrations pattern ${JSON.stringify(pattern)} to start with ${JSON.stringify(prefix)}`);
+	return pattern.slice(prefix.length);
+}
+__name$6(stripDirPrefix, "stripDirPrefix");
+function listFilesRelative(dir2, matcher) {
+	const out = [];
+	const stack = [{
+		abs: dir2,
+		rel: ""
+	}];
+	while (stack.length > 0) {
+		const { abs, rel } = stack.pop();
+		let entries;
+		try {
+			entries = fs2.readdirSync(abs, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const childRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
+			if (entry.isDirectory()) {
+				if (matcher.match(childRel, true)) stack.push({
+					abs: path__default.join(abs, entry.name),
+					rel: childRel
+				});
+			} else if (entry.isFile() && matcher.match(childRel)) out.push(childRel);
+		}
+	}
+	return out.sort(compareMigrationPaths);
+}
+__name$6(listFilesRelative, "listFilesRelative");
+function compareMigrationPaths(a, b) {
+	const aSegments = a.split("/");
+	const bSegments = b.split("/");
+	const shared = Math.min(aSegments.length, bSegments.length);
+	for (let i$1 = 0; i$1 < shared; i$1++) {
+		const aSegment = aSegments[i$1];
+		const bSegment = bSegments[i$1];
+		if (aSegment === void 0 || bSegment === void 0) break;
+		const cmp$3 = compareSegments(aSegment, bSegment);
+		if (cmp$3 !== 0) return cmp$3;
+	}
+	return aSegments.length - bSegments.length;
+}
+__name$6(compareMigrationPaths, "compareMigrationPaths");
+function compareSegments(a, b) {
+	const aNum = leadingMigrationNumber(a);
+	const bNum = leadingMigrationNumber(b);
+	if (aNum !== bNum) {
+		if (Number.isFinite(aNum) && Number.isFinite(bNum)) return aNum - bNum;
+		if (Number.isFinite(aNum)) return -1;
+		if (Number.isFinite(bNum)) return 1;
+	}
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+__name$6(compareSegments, "compareSegments");
+function leadingMigrationNumber(relativePath) {
+	const firstSegment = relativePath.split("/")[0];
+	return parseInt(firstSegment.split("_")[0], 10);
+}
+__name$6(leadingMigrationNumber, "leadingMigrationNumber");
 
 //#endregion
 //#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js
@@ -55630,7 +56407,6 @@ const ContainerObservabilityBaseSchema = strictObject({
 });
 const StandardContainerObservabilitySchema = 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),
 	unsafe: record(string(), unknown()).optional()
 });
@@ -55687,14 +56463,13 @@ const DurableObjectContainerBaseSchema = BaseContainerSchema.extend({
 	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 = 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.
+* 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 = union([StandardContainerBaseSchema.extend({ image: OutputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: record(string(), OutputContainerImageSchema).optional() })]);
 const DurableObjectCreatedExportSchema = strictObject({
@@ -55836,7 +56611,6 @@ const UnsafeSchema = strictObject({
 * (user-authored) and output (on-disk) Worker configs.
 */
 const BaseWorkerSchema = strictObject({
-	type: literal$1("worker"),
 	name: string(),
 	compatibilityDate: string(),
 	compatibilityFlags: array(string()).optional(),
@@ -55857,75 +56631,37 @@ const BaseWorkerSchema = strictObject({
 	exports: record(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: union([string(), strictObject({ default: 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 = strictObject({
-	type: literal$1("settings"),
+const InputSettingsSchema = object({
 	accountId: string().optional(),
 	complianceRegion: _enum(["public", "fedramp-high"]).optional()
 });
-/**
-* Output settings schema — the shape of the top-level `config.json` in the
-* Build Output Specification. Adds the build mode and Preview intent.
-*/
-const OutputSettingsSchema = InputSettingsSchema.extend({
-	isPreview: boolean().optional(),
+/** The resolved, user-authored project configuration. */
+const InputConfigSchema = strictObject({
+	...InputSettingsSchema.shape,
+	worker: InputWorkerSchema.optional(),
+	containers: array(InputContainerSchema).default([])
+});
+const BuildContextSchema = strictObject({
+	isPreview: boolean(),
 	mode: 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 = record(string(), unknown()).check((ctx) => {
-	for (const [key, value] of Object.entries(ctx.value)) {
-		const isObject$5 = typeof value === "object" && value !== null;
-		const type = isObject$5 && "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$5 ? [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.`
-		});
-	}
+/**
+* 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 OutputRootConfigSchema = strictObject({
+	...InputSettingsSchema.shape,
+	buildContext: BuildContextSchema
 });
 const ModuleTypeSchema = _enum([
 	"esm",
@@ -55957,9 +56693,9 @@ const ManifestSchema = 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() });
 var import_dist = (/* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/ts-dedent@2.2.0/node_modules/ts-dedent/dist/index.js": ((exports$1) => {
@@ -56018,7 +56754,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 {
@@ -56100,27 +56837,25 @@ 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$2) {
 	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$2;
+	if (worker !== void 0) {
+		convertTopLevel(worker, result);
+		convertBindingsAndAssets(worker, result);
+		convertExports(worker, result);
+		convertDomains(worker, result);
+		convertTriggers(worker, result);
+		convertTailConsumers(worker, result);
+	}
+	convertSettings(config$2, result);
+	if (containers.length > 0) result.containers = containers.map((container) => convertContainer(container));
 	return result;
 }
 function convertContainer(container) {
@@ -56718,31 +57453,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$2 = pathToFileURL(configPath).href;
 	const dependencies = /* @__PURE__ */ new Set();
 	const mod$1 = await depsStore.run(dependencies, () => import(url$2, { with: { [CF_ATTR]: CF_NO_CACHE_VALUE } }));
-	const exports$2 = {};
-	for (const [name, value] of Object.entries(mod$1)) {
-		if (options?.include && !options.include.includes(name)) continue;
-		exports$2[name] = value;
-	}
+	if (!("default" in mod$1)) 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$1.default,
 		dependencies
 	};
 }
@@ -56831,23 +57557,11 @@ const CROSS_WORKER_BINDING_TYPES = new Set([
 	"worker",
 	"workflow"
 ]);
-/**
-* Selects the Container exports from a validated project configuration.
-*
-* @param config - Validated exports keyed by their JavaScript export names.
-* @returns Container configurations keyed by those same export names.
-*/
-function getContainerConfigExports(config$2) {
-	return Object.fromEntries(Object.entries(config$2).filter((entry) => entry[1]?.type === "container"));
-}
 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();
@@ -56865,11 +57579,11 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 	if (!isRecord(resolved) || !isRecord(resolved.env)) return resolved;
 	const env$3 = { ...resolved.env };
 	for (const [bindingName, binding] of Object.entries(env$3)) {
-		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$1 = await resolveDefinition(binding.worker);
 		env$3[bindingName] = {
 			...binding,
-			worker: normalizeConfigReference(binding.worker, target$1, "worker")
+			worker: normalizeConfigReference(binding.worker, target$1)
 		};
 	}
 	return {
@@ -56877,7 +57591,7 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 		env: env$3
 	};
 }
-async function normalizeContainerReferences(resolved, resolveDefinition, resolvedExports) {
+async function normalizeContainerReferences(resolved, resolveDefinition, containers) {
 	const issues = [];
 	if (!isRecord(resolved) || !isRecord(resolved.exports)) return {
 		value: resolved,
@@ -56896,7 +57610,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,
@@ -56905,7 +57619,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 			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)) {
+		if (isRecord(target$1) && typeof target$1.name === "string" && !containers.includes(target$1)) {
 			issues.push({
 				code: "custom",
 				input: reference,
@@ -56914,7 +57628,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 					exportName,
 					"container"
 				],
-				message: `The referenced Container "${target$1.name}" is not exported.`
+				message: `The referenced Container "${target$1.name}" is not included in the \`containers\` array.`
 			});
 			workerExports[exportName] = {
 				...workerExport,
@@ -56924,7 +57638,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 		}
 		workerExports[exportName] = {
 			...workerExport,
-			container: normalizeConfigReference(reference, target$1, "container")
+			container: normalizeConfigReference(reference, target$1)
 		};
 	}
 	return {
@@ -56935,8 +57649,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$2) => ({
@@ -56944,126 +57658,83 @@ function prefixIssues(issues, prefix) {
 		path: [prefix, ...issue$2.path]
 	}));
 }
-function validateUniqueResourceNames(configExports) {
+function validateUniqueContainerNames(config$2) {
 	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) {
+	const firstIndexByName = /* @__PURE__ */ new Map();
+	for (const [index, container] of config$2.containers.entries()) {
+		const firstIndex = firstIndexByName.get(container.name);
+		if (firstIndex !== 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.`
+				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$2.name, exportName);
+		firstIndexByName.set(container.name, index);
 	}
 	return issues;
 }
-function validateContainerExportLinks(configExports) {
+function validateContainerLinks(config$2) {
 	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
+	const firstExportByContainerName = /* @__PURE__ */ new Map();
+	for (const [exportName, workerExport] of Object.entries(config$2.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$1 = {};
-	const resolvedSettings = resolvedExports.settings;
-	const settingsResult = resolvedSettings ? InputSettingsSchema.safeParse(resolvedSettings) : void 0;
-	if (settingsResult) if (settingsResult.success) data$1.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$1[name] = result.data;
-	}
-	issues.push(...validateUniqueResourceNames(data$1), ...validateContainerExportLinks(data$1));
+	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 ZodError(issues)
-	} : {
-		success: true,
-		data: data$1
-	};
+	} : result;
 }
-/**
-* 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 `cloudflare.config.ts`'s default export. */
+async function loadAndParseConfig(configPath, ctx) {
+	const { config: config$2, dependencies } = await loadConfig(configPath);
 	return {
-		result: await resolveAndValidateConfigExports(exports$2, ctx),
+		result: await resolveAndParseConfig(config$2, ctx),
 		dependencies
 	};
 }
@@ -57336,35 +58007,31 @@ const defuArrayFn = createDefu((object$2, key, currentValue) => {
 * Will move to `v1` when the spec stabilises.
 */
 const BUILD_OUTPUT_VERSION = "v0";
-/**
-* Project-relative root.
-*/
+/** Build output directory relative to the project root. */
 const BUILD_OUTPUT_ROOT = ".cloudflare/output";
-/**
-* Filename shared by every config in the Build Output Specification.
-*
-* Configs are discriminated by their `type` field.
-*/
-const CONFIG_FILENAME = "config.json";
-/**
-* Name of the sub-directory under `workers/` holding the default Worker.
-*/
+/** Filename of the root config in the Build Output Specification. */
+const ROOT_CONFIG_FILENAME = "config.json";
+/** Filename of each Worker config in the Build Output Specification. */
+const WORKER_CONFIG_FILENAME = "worker.config.json";
+/** Filename of each Container config in the Build Output Specification. */
+const CONTAINER_CONFIG_FILENAME = "container.config.json";
+/** Name of the directory containing the default Worker. */
 const DEFAULT_WORKER_DIRECTORY_NAME = "default";
-/**
-* Absolute path to the Build Output Specification root for the current project.
-*/
+const INVALID_DIRECTORY_NAME_CHARACTERS = /[\s<>:"/\\|?*\u0000-\u001f]+|\.+$/g;
+const WINDOWS_RESERVED_NAME = /^(?:con|prn|aux|nul|conin\$|conout\$|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/;
+const MAX_DIRECTORY_NAME_BYTES = 254;
+/** Absolute path to the Build Output Specification directory. */
 function getBuildOutputDir(root) {
 	return path.resolve(root, BUILD_OUTPUT_ROOT);
 }
 /**
-* Absolute path to the top-level `config.json` for the current project.
+* Absolute path to the root `config.json`.
 *
-* Holds the project-level settings shared by every Worker: those declared by
-* the `settings` export of the input `cloudflare.config.ts`, including the
-* mode the build was produced in.
+* Holds the settings declared at the top level of `cloudflare.config.ts` and
+* build context.
 */
-function getSettingsConfigPath(root) {
-	return path.join(getBuildOutputDir(root), BUILD_OUTPUT_VERSION, CONFIG_FILENAME);
+function getRootConfigPath(root) {
+	return path.join(getBuildOutputDir(root), BUILD_OUTPUT_VERSION, ROOT_CONFIG_FILENAME);
 }
 /**
 * Absolute path to the Workers output directory.
@@ -57378,47 +58045,68 @@ function getWorkersDir(root) {
 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)}.`);
+/**
+* Convert a Cloudflare resource name into a portable, case-insensitive
+* directory name.
+*
+* The original resource name remains in its config file. Callers must reject
+* collisions when multiple resource names normalise to the same directory.
+*/
+function normalizeDirectoryName(name) {
+	const directoryName = truncateUtf8(name.toLowerCase(), MAX_DIRECTORY_NAME_BYTES).replace(INVALID_DIRECTORY_NAME_CHARACTERS, "-");
+	return WINDOWS_RESERVED_NAME.test(directoryName) ? `_${directoryName}` : directoryName;
+}
+function truncateUtf8(value, maxBytes) {
+	let result = "";
+	let byteLength = 0;
+	for (const character of value) {
+		const characterByteLength = Buffer.byteLength(character);
+		if (byteLength + characterByteLength > maxBytes) break;
+		result += character;
+		byteLength += characterByteLength;
+	}
+	return result;
+}
+function validateDirectoryName(name, resourceType) {
+	if (name.length === 0 || name === "." || name === ".." || name.includes("/") || name.includes("\\") || name.includes("\0")) throw new Error(`${resourceType} directory names must be non-empty, single path segments. Received ${JSON.stringify(name)}.`);
 }
 /**
-* Absolute path to a Worker's directory (`workers/<worker-directory-name>`).
+* Absolute path to a Worker's directory (`workers/<directory-name>`).
 */
-function getWorkerDir(root, workerDirectoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
-	validateDirectoryName(workerDirectoryName, "Worker");
-	return path.join(getWorkersDir(root), workerDirectoryName);
+function getWorkerDir(root, directoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
+	validateDirectoryName(directoryName, "Worker");
+	return path.join(getWorkersDir(root), directoryName);
 }
 /**
-* Absolute path to a Container's directory
-* (`containers/<container-directory-name>`).
+* Absolute path to a Container's directory (`containers/<directory-name>`).
 */
-function getContainerDir(root, containerDirectoryName) {
-	validateDirectoryName(containerDirectoryName, "Container");
-	return path.join(getContainersDir(root), containerDirectoryName);
+function getContainerDir(root, directoryName) {
+	validateDirectoryName(directoryName, "Container");
+	return path.join(getContainersDir(root), directoryName);
 }
 /**
 * Absolute path to the Container's config file.
 */
-function getContainerConfigPath(root, containerDirectoryName) {
-	return path.join(getContainerDir(root, containerDirectoryName), CONFIG_FILENAME);
+function getContainerConfigPath(root, directoryName) {
+	return path.join(getContainerDir(root, directoryName), CONTAINER_CONFIG_FILENAME);
 }
 /**
 * Absolute path to the Worker's config file.
 */
-function getWorkerConfigPath(root, workerDirectoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
-	return path.join(getWorkerDir(root, workerDirectoryName), CONFIG_FILENAME);
+function getWorkerConfigPath(root, directoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
+	return path.join(getWorkerDir(root, directoryName), WORKER_CONFIG_FILENAME);
 }
 /**
 * Absolute path to the Worker's bundle directory.
 */
-function getWorkerBundleDir(root, workerDirectoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
-	return path.join(getWorkerDir(root, workerDirectoryName), "bundle");
+function getWorkerBundleDir(root, directoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
+	return path.join(getWorkerDir(root, directoryName), "bundle");
 }
 /**
 * Absolute path to the Worker's assets directory.
 */
-function getWorkerAssetsDir(root, workerDirectoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
-	return path.join(getWorkerDir(root, workerDirectoryName), "assets");
+function getWorkerAssetsDir(root, directoryName = DEFAULT_WORKER_DIRECTORY_NAME) {
+	return path.join(getWorkerDir(root, directoryName), "assets");
 }
 var __defProp$3 = Object.defineProperty;
 var __name$3 = (target$1, value) => __defProp$3(target$1, "name", {
@@ -57456,7 +58144,8 @@ async function cleanBuildOutputDir(root) {
 	await removeDir(getBuildOutputDir(root));
 }
 /**
-* Write an output Worker `config.json` to the Build Output Specification tree.
+* Write an output Worker `worker.config.json` to the Build Output Specification
+* tree.
 *
 * - Workers mode: `manifest` is provided (bundle/ present on disk).
 * - Assets-only mode: `manifest` is omitted (no bundle/ directory).
@@ -57471,8 +58160,8 @@ async function writeWorkerConfig({ root, config: config$2, manifest, directoryNa
 	await fsp.writeFile(getWorkerConfigPath(root, directoryName), JSON.stringify(outputConfig));
 }
 /**
-* Write an output Container `config.json` to the Build Output Specification
-* tree.
+* Write an output Container `container.config.json` to the Build Output
+* Specification tree.
 *
 * Local Dockerfiles must already have been built and represented by a
 * `localReference` in the output config.
@@ -57482,30 +58171,24 @@ async function writeContainerConfig({ root, config: config$2, directoryName }) {
 	await fsp.writeFile(getContainerConfigPath(root, directoryName), JSON.stringify(config$2));
 }
 /**
-* Write the top-level `config.json` to the Build Output Specification tree.
-*
-* Holds the project settings shared by every Worker, plus the build mode and
-* whether the build is for a Preview. Always written, even without declared
-* settings or a mode.
+* Write the root `config.json` to the Build Output Specification tree.
 *
-* `mode` is omitted when undefined, which is the case for Wrangler builds that
-* selected no mode (Vite always resolves one).
+* Holds the settings declared at the top level of `cloudflare.config.ts` and
+* build context supplied at build time.
 */
-async function writeSettingsConfig(root, settings, mode, isPreview = false) {
+async function writeRootConfig(root, settings, buildContext) {
 	const outputConfig = {
 		...settings,
-		type: "settings",
-		...isPreview ? { isPreview: true } : {},
-		...mode !== void 0 ? { mode } : {}
+		buildContext
 	};
-	const configPath = getSettingsConfigPath(root);
+	const configPath = getRootConfigPath(root);
 	await fsp.mkdir(path.dirname(configPath), { recursive: true });
 	await fsp.writeFile(configPath, JSON.stringify(outputConfig));
 }
 const BUILD_OUTPUT_ERROR_PREFIX = "Build Output Specification: ";
 /**
 * Thrown when the Build Output Specification tree is missing, malformed, or
-* fails schema validation while being read.
+* internally inconsistent.
 */
 var BuildOutputError = class extends Error {
 	constructor(message) {
@@ -57514,43 +58197,51 @@ var BuildOutputError = class extends Error {
 	}
 };
 /**
-* Read and validate the Build Output Specification tree at
+* Read and parse the Build Output Specification tree at
 * `<root>/.cloudflare/output/v0/`.
 *
-* Reads the optional top-level settings `config.json`, then reads and
-* 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/`.
+* Reads the root `config.json`, then reads and parses each
+* `worker.config.json` 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
-* a Worker or Container config is missing, is not valid JSON, or fails schema
-* validation.
+* @throws {BuildOutputError} if the root `config.json` is missing or
+* invalid, or if a Worker or Container config is missing, is not valid JSON,
+* or does not match its schema.
 */
 async function readBuildOutput(root) {
-	const settings = await readSettings(root);
-	const defaultWorker = await readWorker(root, DEFAULT_WORKER_DIRECTORY_NAME);
-	const additionalWorkerDirectoryNames = (await fsp.readdir(getWorkersDir(root), { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name !== DEFAULT_WORKER_DIRECTORY_NAME).map((entry) => entry.name).sort();
-	const additionalWorkers = await Promise.all(additionalWorkerDirectoryNames.map(async (workerDirectoryName) => [workerDirectoryName, await readWorker(root, workerDirectoryName)]));
+	const absoluteRoot = path.resolve(root);
+	const rootConfig = await readRootConfig(absoluteRoot);
+	const [workers, containers] = await Promise.all([readWorkers(absoluteRoot), readContainers(absoluteRoot)]);
 	return {
-		root,
+		root: absoluteRoot,
 		version: BUILD_OUTPUT_VERSION,
-		settings,
-		workers: {
-			default: defaultWorker,
-			...Object.fromEntries(additionalWorkers)
-		},
-		containers: await readContainers(root)
+		rootConfig,
+		workers,
+		containers
 	};
 }
-/** Read and schema-validate all Container configs, if any. */
+/** Read and parse the default Worker and any additional Worker configs. */
+async function readWorkers(root) {
+	const workersDir = getWorkersDir(root);
+	const defaultWorker = await readWorker(root, DEFAULT_WORKER_DIRECTORY_NAME);
+	const additionalWorkerDirectoryNames = (await fsp.readdir(workersDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name !== DEFAULT_WORKER_DIRECTORY_NAME).map((entry) => entry.name);
+	const additionalWorkers = await Promise.all(additionalWorkerDirectoryNames.map(async (workerDirectoryName) => {
+		return [workerDirectoryName, await readWorker(root, workerDirectoryName)];
+	}));
+	return {
+		default: defaultWorker,
+		...Object.fromEntries(additionalWorkers)
+	};
+}
+/** Read and parse 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);
+	if (!fs$1.existsSync(containersDir)) return [];
+	const containerDirectoryNames = (await fsp.readdir(containersDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	return Promise.all(containerDirectoryNames.map((containerDirectoryName) => readContainer(root, containerDirectoryName)));
 }
-/** Read and schema-validate one Container config. */
+/** Read and parse 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}.`);
@@ -57563,12 +58254,12 @@ async function readContainer(root, containerDirectoryName) {
 	};
 }
 /**
-* Read and schema-validate the Worker's `config.json` and resolve its
+* Read and parse the Worker's `worker.config.json` and resolve its
 * `bundle/` / `assets/` directories.
 *
 * @returns the Worker, with whichever of its directories exist resolved.
 * @throws {BuildOutputError} if the config is missing, is not valid JSON, or
-* fails schema validation.
+* does not match its schema.
 */
 async function readWorker(root, workerDirectoryName) {
 	const configPath = getWorkerConfigPath(root, workerDirectoryName);
@@ -57649,23 +58340,18 @@ function inferModuleType(modulePath) {
 	}
 }
 /**
-* Read and schema-validate the optional top-level `config.json` holding the
-* project-level settings shared by every Worker, including the mode the build
-* was produced in.
-*
-* Returned whole: consumers that need only the settings the user declared
-* narrow it themselves.
+* Read and parse the root `config.json`.
 *
-* @returns the parsed settings, or `undefined` when the file is absent.
-* @throws {BuildOutputError} if the file is not valid JSON or fails schema
-* validation.
+* @returns the parsed root config.
+* @throws {BuildOutputError} if the file is missing, is not valid JSON, or
+* does not match its schema.
 */
-async function readSettings(root) {
-	const configPath = getSettingsConfigPath(root);
-	if (!fs$1.existsSync(configPath)) return;
+async function readRootConfig(root) {
+	const configPath = getRootConfigPath(root);
+	if (!fs$1.existsSync(configPath)) throw new BuildOutputError(`no root config found at ${configPath}.`);
 	const contents = await fsp.readFile(configPath, "utf-8");
-	const result = OutputSettingsSchema.safeParse(parseJson(contents, configPath));
-	if (!result.success) throw new BuildOutputError(`invalid settings config at ${configPath}.\n${result.error.message}`);
+	const result = OutputRootConfigSchema.safeParse(parseJson(contents, configPath));
+	if (!result.success) throw new BuildOutputError(`invalid root config at ${configPath}.\n${result.error.message}`);
 	return result.data;
 }
 function parseJson(contents, configPath) {
@@ -57687,10 +58373,15 @@ function parseJson(contents, configPath) {
 * single-element array.
 */
 async function readBuildOutputWorkers(root) {
-	const { workers, settings, containers } = await readBuildOutput(root);
+	const { workers, rootConfig, containers } = await readBuildOutput(root);
 	const worker = workers[DEFAULT_WORKER_DIRECTORY_NAME];
 	const { manifest,...inputShape } = worker.config;
-	const { config: config$2, diagnostics } = normalizeAndValidateConfig(convertToWranglerConfig(inputShape, settings, Object.values(containers).map(({ config: config$3 }) => convertOutputContainerToInput(config$3))), void 0, void 0, { enableContainers: false }, true);
+	const { buildContext: _buildContext,...settings } = rootConfig;
+	const { config: config$2, diagnostics } = normalizeAndValidateConfig(convertToWranglerConfig({
+		...settings,
+		worker: inputShape,
+		containers: containers.map(({ config: config$3 }) => convertOutputContainerToInput(config$3))
+	}), void 0, void 0, { enableContainers: false }, true);
 	if (diagnostics.hasWarnings()) console.warn(diagnostics.renderWarnings());
 	if (diagnostics.hasErrors()) throw new Error(diagnostics.renderErrors());
 	if (worker.assetsDir) config$2.assets = {
@@ -64783,7 +65474,7 @@ async function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	if (Array.isArray(entryWorkerResolvedConfig.config.assets?.run_worker_first)) staticRouting = parseStaticRouting(entryWorkerResolvedConfig.config.assets.run_worker_first);
 	const entryWorkerEnvironmentName = pluginConfig.viteEnvironment?.name ?? workerNameToEnvironmentName(entryWorkerResolvedConfig.config.topLevelName);
 	validateAndAddEnvironmentName(entryWorkerEnvironmentName);
-	const entryWorkerNewConfig = parsedNewConfig?.default?.type === "worker" ? parsedNewConfig.default : void 0;
+	const entryWorkerNewConfig = parsedNewConfig?.worker;
 	environmentNameToWorkerMap.set(entryWorkerEnvironmentName, resolveWorker(entryWorkerResolvedConfig.config, pluginConfig.assetsOnly, entryWorkerNewConfig));
 	const entryWorkerChildEnvironments = pluginConfig.viteEnvironment?.childEnvironments;
 	if (entryWorkerChildEnvironments) {
@@ -64873,14 +65564,14 @@ const EXPERIMENTAL_CONFIG_PKG = "@cloudflare/vite-plugin/experimental-config";
 async function loadNewConfig(options) {
 	const configPath = path.resolve(options.root, NEW_CONFIG_FILENAME);
 	if (!fs$1.existsSync(configPath)) throw new Error(`\`experimental.newConfig\` is enabled but no \`${NEW_CONFIG_FILENAME}\` was found at ${configPath}.`);
-	const { result, dependencies } = await loadAndValidateConfig(configPath, {
+	const { result, dependencies } = await loadAndParseConfig(configPath, {
 		isPreview: isPreviewBuild(),
 		mode: options.mode
 	});
 	if (!result.success) throw new Error(`Invalid \`${NEW_CONFIG_FILENAME}\`:\n${result.error.message}`);
-	const worker = result.data.default?.type === "worker" ? result.data.default : void 0;
-	if (worker === void 0) throw new Error(`\`${NEW_CONFIG_FILENAME}\` must have a default worker export.`);
-	const rawConfig = convertToWranglerConfig(worker, result.data.settings?.type === "settings" ? result.data.settings : void 0, Object.values(getContainerConfigExports(result.data)));
+	const worker = result.data.worker;
+	if (worker === void 0) throw new Error(`\`${NEW_CONFIG_FILENAME}\` must define a Worker using the \`worker\` property.`);
+	const rawConfig = convertToWranglerConfig(result.data);
 	if (options.command === "serve" && options.types.generate) await writeWorkerConfigurationDts({
 		root: options.root,
 		configPath,
@@ -66749,14 +67440,13 @@ const buildOutputPlugin = createPlugin("build-output", (ctx) => {
 	return { async writeBundle(_, bundle) {
 		if (ctx.isChildEnvironment(this.environment.name)) return;
 		if (ctx.resolvedPluginConfig.type === "assets-only" && this.environment.name === "client") {
-			const defaultExport = ctx.resolvedPluginConfig.parsedNewConfig?.default;
-			const workerNewConfig$1 = defaultExport?.type === "worker" ? defaultExport : void 0;
-			assert2(workerNewConfig$1, "Expected a default worker export on assets-only resolved config");
+			const workerNewConfig$1 = ctx.resolvedPluginConfig.parsedNewConfig?.worker;
+			assert2(workerNewConfig$1, "Expected a Worker on assets-only resolved config");
 			await writeWorkerConfig({
 				root: ctx.resolvedViteConfig.root,
 				config: workerNewConfig$1
 			});
-			await writeSettings();
+			await writeRoot();
 			return;
 		}
 		if (ctx.resolvedPluginConfig.type === "workers" && this.environment.name !== ctx.resolvedPluginConfig.entryWorkerEnvironmentName) return;
@@ -66781,20 +67471,26 @@ const buildOutputPlugin = createPlugin("build-output", (ctx) => {
 				modules
 			}
 		});
-		await writeSettings();
+		await writeRoot();
 	} };
 	/**
-	* Write the top-level `config.json`, recording the settings shared by every
+	* Write the root `config.json`, recording the settings shared by every
 	* Worker, including the Vite mode the build ran in.
 	*
-	* Written even when there is no `settings` export, so the mode is always
-	* captured.
+	* Written even when there are no account settings, so the build context is
+	* always captured.
 	*/
-	async function writeSettings() {
+	async function writeRoot() {
 		if (ctx.resolvedPluginConfig.type === "preview") return;
-		const settingsExport = ctx.resolvedPluginConfig.parsedNewConfig?.settings;
-		const settings = settingsExport?.type === "settings" ? settingsExport : void 0;
-		await writeSettingsConfig(ctx.resolvedViteConfig.root, settings, ctx.resolvedViteConfig.mode, isPreviewBuild());
+		const config$2 = ctx.resolvedPluginConfig.parsedNewConfig;
+		const settings = config$2 && {
+			accountId: config$2.accountId,
+			complianceRegion: config$2.complianceRegion
+		};
+		await writeRootConfig(ctx.resolvedViteConfig.root, settings, {
+			isPreview: isPreviewBuild(),
+			mode: ctx.resolvedViteConfig.mode
+		});
 	}
 });
 /**
@@ -73498,31 +74194,6 @@ async function dockerLoginImageRegistry(pathToDocker, domain$1) {
 	});
 }
 __name$2(dockerLoginImageRegistry, "dockerLoginImageRegistry");
-async function dockerImageInspect(dockerPath, options) {
-	return new Promise((resolve2, reject) => {
-		const proc = spawn(dockerPath, [
-			"image",
-			"inspect",
-			options.imageTag,
-			"--format",
-			options.formatString
-		], { stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		] });
-		let stdout$2 = "";
-		let stderr$1 = "";
-		proc.stdout.on("data", (chunk) => stdout$2 += chunk);
-		proc.stderr.on("data", (chunk) => stderr$1 += chunk);
-		proc.on("close", (code) => {
-			if (code !== 0) return reject(new UserError(`failed inspecting image locally: ${stderr$1.trim()}`, { telemetryMessage: false }));
-			resolve2(stdout$2.trim());
-		});
-		proc.on("error", (err) => reject(err));
-	});
-}
-__name$2(dockerImageInspect, "dockerImageInspect");
 var runDockerCmd = /* @__PURE__ */ __name$2((dockerPath, args, stdio) => {
 	let aborted$2 = false;
 	let resolve2;
@@ -73680,15 +74351,6 @@ var getContainerIdsFromImage = /* @__PURE__ */ __name$2((dockerPath, ancestorIma
 		"{{.ID}}"
 	]).split("\n").filter((line) => line.trim());
 }, "getContainerIdsFromImage");
-async function checkExposedPorts(dockerPath, options) {
-	if (await dockerImageInspect(dockerPath, {
-		imageTag: options.image_tag,
-		formatString: "{{ len .Config.ExposedPorts }}"
-	}) === "0") throw new UserError(`The container "${options.image_name === void 0 ? options.class_name : `${options.class_name}.${options.image_name}`}" does not expose any ports. In your Dockerfile, please expose any ports you intend to connect to.
-For additional information please see: https://developers.cloudflare.com/containers/local-dev/#exposing-ports.
-`, { telemetryMessage: false });
-}
-__name$2(checkExposedPorts, "checkExposedPorts");
 function generateContainerBuildId() {
 	return randomUUID().slice(0, 8);
 }
@@ -73808,7 +74470,6 @@ async function prepareContainerImagesForDev(args) {
 			onContainerImagePreparationEnd({ containerOptions: options });
 		}
 		if (aborted$2) break;
-		await checkExposedPorts(dockerPath, options);
 	}
 	if (!aborted$2) await pullEgressInterceptorImage(dockerPath);
 	return { aborted: aborted$2 };
@@ -73895,6 +74556,31 @@ function validateAndEncodeGarKey(rawKey, expectedEmail) {
 	return base64Key;
 }
 __name$2(validateAndEncodeGarKey, "validateAndEncodeGarKey");
+async function dockerImageInspect(dockerPath, options) {
+	return new Promise((resolve2, reject) => {
+		const proc = spawn(dockerPath, [
+			"image",
+			"inspect",
+			options.imageTag,
+			"--format",
+			options.formatString
+		], { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		let stdout$2 = "";
+		let stderr$1 = "";
+		proc.stdout.on("data", (chunk) => stdout$2 += chunk);
+		proc.stderr.on("data", (chunk) => stderr$1 += chunk);
+		proc.on("close", (code) => {
+			if (code !== 0) return reject(new UserError(`failed inspecting image locally: ${stderr$1.trim()}`, { telemetryMessage: false }));
+			resolve2(stdout$2.trim());
+		});
+		proc.on("error", (err) => reject(err));
+	});
+}
+__name$2(dockerImageInspect, "dockerImageInspect");
 var MB = 1e3 * 1e3;
 var MiB = 1024 * 1024;
 var instanceTypes = {
@@ -74409,15 +75095,15 @@ __name$2(dockerBuild, "dockerBuild");
 var BUILD_OUTPUT_IMAGE_NAMESPACE = "cloudflare-build";
 var DOCKER_REPOSITORY_NAME_LENGTH = 255;
 async function buildAndWriteContainerOutput(options) {
-	const containers = Object.entries(options.containers);
-	await cleanupPreviousBuildOutputImageTags({
-		root: options.root,
-		pathToDocker: options.pathToDocker
-	});
-	const buildId = createBuildId();
 	const localTags = /* @__PURE__ */ new Set();
 	try {
-		const dockerfileCount = countDockerfiles(containers);
+		const containers = resolveContainerDirectories(options.containers);
+		await cleanupPreviousBuildOutputImageTags({
+			root: options.root,
+			pathToDocker: options.pathToDocker
+		});
+		const buildId = createBuildId();
+		const dockerfileCount = countDockerfiles(options.containers);
 		if (dockerfileCount > 0) await verifyDockerInstalled({
 			dockerPath: options.pathToDocker,
 			operation: "building the project",
@@ -74425,7 +75111,7 @@ async function buildAndWriteContainerOutput(options) {
 		});
 		const outputConfigs = [];
 		try {
-			for (const [directoryName, config$2] of containers) outputConfigs.push({
+			for (const { config: config$2, directoryName } of containers) outputConfigs.push({
 				root: options.root,
 				directoryName,
 				config: await buildContainerOutputConfig({
@@ -74446,6 +75132,20 @@ async function buildAndWriteContainerOutput(options) {
 	}
 }
 __name$2(buildAndWriteContainerOutput, "buildAndWriteContainerOutput");
+function resolveContainerDirectories(containers) {
+	const containerNameByDirectory = /* @__PURE__ */ new Map();
+	return containers.map((config$2) => {
+		const directoryName = normalizeDirectoryName(config$2.name);
+		const conflictingName = containerNameByDirectory.get(directoryName);
+		if (conflictingName !== void 0) throw new UserError(`Container names ${JSON.stringify(conflictingName)} and ${JSON.stringify(config$2.name)} resolve to the same Build Output directory ${JSON.stringify(directoryName)}. Rename one of the Containers.`, { telemetryMessage: "container build output directory name conflict" });
+		containerNameByDirectory.set(directoryName, config$2.name);
+		return {
+			config: config$2,
+			directoryName
+		};
+	});
+}
+__name$2(resolveContainerDirectories, "resolveContainerDirectories");
 async function buildContainerOutputConfig(options) {
 	if (options.config.schedulingPolicy === "durable-object") {
 		if (options.config.images === void 0) return {
@@ -74543,7 +75243,7 @@ function createBuildId() {
 __name$2(createBuildId, "createBuildId");
 function countDockerfiles(containers) {
 	let count = 0;
-	for (const [, config$2] of containers) if (config$2.schedulingPolicy === "durable-object") count += Object.values(config$2.images ?? {}).filter((image) => "dockerfile" in image).length;
+	for (const config$2 of containers) if (config$2.schedulingPolicy === "durable-object") count += Object.values(config$2.images ?? {}).filter((image) => "dockerfile" in image).length;
 	else if ("dockerfile" in config$2.image) count++;
 	return count;
 }
@@ -75350,7 +76050,7 @@ async function buildOutputContainers(resolvedPluginConfig, root) {
 	const config$2 = resolvedPluginConfig.parsedNewConfig;
 	if (config$2 === void 0) return;
 	await buildAndWriteContainerOutput({
-		containers: getContainerConfigExports(config$2),
+		containers: config$2.containers,
 		root,
 		pathToDocker: getDockerPath$1()
 	});
@@ -81392,7 +82092,7 @@ __name(createWorkerUploadForm, "createWorkerUploadForm");
 //#endregion
 //#region ../remote-bindings/dist/index.mjs
 var import_undici = require_undici();
-var version$2 = "0.0.28";
+var version$2 = "0.0.29";
 var NoDefaultValueProvided = class extends UserError {
 	constructor() {
 		super("This command cannot be run in a non-interactive context", { telemetryMessage: "remote bindings prompt default missing" });