@cloudflare/vitest-plugin 1.1.13 → 1.2.0

package/dist/pool/index.mjs

@@ -324,7 +324,7 @@ function createFatalError$1(message, isJson, options) {
 __name$3(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";
@@ -351,7 +351,6 @@ function hasDurableObjectExports(exports$1) {
 	return Object.keys(getDurableObjectExports(exports$1)).length > 0;
 }
 __name$3(hasDurableObjectExports, "hasDurableObjectExports");
-var CONTAINER_IMAGES_BINDING = "EXPERIMENTAL_CLOUDFLARE_CONTAINER_IMAGES";
 function isDurableObjectContainerApp(container) {
 	return container.scheduling_policy === "durable_object";
 }
@@ -2802,8 +2801,8 @@ function formatConfigSnippet(snippet, configPath, formatted = true) {
 __name$3(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$3(assertNever, "assertNever");
 function mapWorkerMetadataBindings(bindings) {
@@ -26554,11 +26553,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("child_process").exec;
 	var execSync$1 = __require("child_process").execSync;
-	var fs3 = __require("fs");
-	var path5 = __require("path");
-	var access$1 = fs3.access;
-	var accessSync2 = fs3.accessSync;
-	var constants2 = fs3.constants || fs3;
+	var fs4 = __require("fs");
+	var path6 = __require("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$3(function(commandName, callback) {
 		access$1(commandName, constants2.F_OK, function(err) {
@@ -26632,8 +26631,8 @@ var require_command_exists$2 = __commonJS$1({ "../../node_modules/.pnpm/command-
 	}, "cleanInput");
 	if (isUsingWindows$1) cleanInput$1 = /* @__PURE__ */ __name$3(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 + "\"";
@@ -26854,9 +26853,9 @@ var require_strip_json_comments = __commonJS$1({ "../../node_modules/.pnpm/strip
 	};
 } });
 var require_utils = __commonJS$1({ "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports$1) {
-	var fs3 = __require("fs");
+	var fs4 = __require("fs");
 	var ini = require_ini();
-	var path5 = __require("path");
+	var path6 = __require("path");
 	var stripJsonComments = require_strip_json_comments();
 	var parse3$1 = exports$1.parse = function(content) {
 		if (/^\s*{/.test(content)) return JSON.parse(stripJsonComments(content));
@@ -26867,9 +26866,9 @@ var require_utils = __commonJS$1({ "../../node_modules/.pnpm/rc@1.2.8/node_modul
 			return arg != null;
 		});
 		for (var i in args) if ("string" !== typeof args[i]) 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;
 		}
@@ -26897,14 +26896,14 @@ var require_utils = __commonJS$1({ "../../node_modules/.pnpm/rc@1.2.8/node_modul
 		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$3(find2, "find");
@@ -27294,8 +27293,8 @@ var require_registry_auth_token = __commonJS$1({ "../../node_modules/.pnpm/regis
 		};
 	}
 	__name$3(getLegacyAuthInfo, "getLegacyAuthInfo");
-	function normalizePath$1(path5) {
-		return path5[path5.length - 1] === "/" ? path5 : path5 + "/";
+	function normalizePath$1(path6) {
+		return path6[path6.length - 1] === "/" ? path6 : path6 + "/";
 	}
 	__name$3(normalizePath$1, "normalizePath");
 	function getAuthInfoForUrl(regUrl, npmrc) {
@@ -27332,24 +27331,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("url");
 	var { join: join3 } = __require("path");
-	var fs3 = __require("fs");
+	var fs4 = __require("fs");
 	var { promisify: promisify$3 } = __require("util");
 	var { tmpdir } = __require("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$3((a, b) => a.localeCompare(b, "en-US", { numeric: true }), "compareVersions");
 	var encode3 = /* @__PURE__ */ __name$3((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
 	var getFile = /* @__PURE__ */ __name$3(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$3(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 {
@@ -27451,6 +27450,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$3(balanced, "balanced");
+	function maybeMatch(reg, str) {
+		var m = str.match(reg);
+		return m ? m[0] : null;
+	}
+	__name$3(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 = ai;
+		if (ai >= 0 && bi > 0) {
+			if (a === b) return [ai, bi];
+			begs = [];
+			left = str.length;
+			while (i >= 0 && !result) {
+				if (i == ai) {
+					begs.push(i);
+					ai = str.indexOf(a, i + 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);
+				}
+				i = ai < bi && ai >= 0 ? ai : bi;
+			}
+			if (begs.length) result = [left, right];
+		}
+		return result;
+	}
+	__name$3(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$3(numeric$1, "numeric");
+	function escapeBraces(str) {
+		return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+	}
+	__name$3(escapeBraces, "escapeBraces");
+	function unescapeBraces(str) {
+		return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+	}
+	__name$3(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$1 = pre.split(",");
+		p$1[p$1.length - 1] += "{" + body + "}";
+		var postParts = parseCommaParts(post);
+		if (post.length) {
+			p$1[p$1.length - 1] += postParts.shift();
+			p$1.push.apply(p$1, postParts);
+		}
+		parts.push.apply(parts, p$1);
+		return parts;
+	}
+	__name$3(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$3(expandTop, "expandTop");
+	function embrace(str) {
+		return "{" + str + "}";
+	}
+	__name$3(embrace, "embrace");
+	function isPadded(el) {
+		return /^-?0\d/.test(el);
+	}
+	__name$3(isPadded, "isPadded");
+	function lte$2(i, y) {
+		return i <= y;
+	}
+	__name$3(lte$2, "lte");
+	function gte$2(i, y) {
+		return i >= y;
+	}
+	__name$3(gte$2, "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$1) {
+						return m.pre + n2[0] + p$1;
+					});
+				}
+			}
+			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$2;
+				if (y < x) {
+					incr *= -1;
+					test = gte$2;
+				}
+				var pad = n2.some(isPadded);
+				N = [];
+				for (var i = x; test(i, y); i += incr) {
+					var c$1;
+					if (isAlphaSequence) {
+						c$1 = String.fromCharCode(i);
+						if (c$1 === "\\") c$1 = "";
+					} else {
+						c$1 = String(i);
+						if (pad) {
+							var need = width - c$1.length;
+							if (need > 0) {
+								var z2 = new Array(need + 1).join("0");
+								if (i < 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$3(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$1, pattern, options = {}) => {
+		assertValidPattern(pattern);
+		if (!options.nocomment && pattern.charAt(0) === "#") return false;
+		return new Minimatch2(pattern, options).match(p$1);
+	};
+	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$3((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$1, i, list) => minimatch(p$1, pattern, options);
+	var ext = /* @__PURE__ */ __name$3((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$3((p$1, pattern, options) => orig(p$1, pattern, ext(def, options)), "m");
+		m.Minimatch = class Minimatch extends orig.Minimatch {
+			static {
+				__name$3(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, pattern, options) => orig.match(list, pattern, ext(def, options));
+		return m;
+	};
+	minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options);
+	var braceExpand = /* @__PURE__ */ __name$3((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$3((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, pattern, options = {}) => {
+		const mm = new Minimatch2(pattern, options);
+		list = list.filter((f) => mm.match(f));
+		if (mm.options.nonull && !list.length) list.push(pattern);
+		return list;
+	};
+	var globUnescape = /* @__PURE__ */ __name$3((s) => s.replace(/\\(.)/g, "$1"), "globUnescape");
+	var charUnescape = /* @__PURE__ */ __name$3((s) => s.replace(/\\([^-\]])/g, "$1"), "charUnescape");
+	var regExpEscape = /* @__PURE__ */ __name$3((s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "regExpEscape");
+	var braExpEscape = /* @__PURE__ */ __name$3((s) => s.replace(/[[\]\\]/g, "\\$&"), "braExpEscape");
+	var Minimatch2 = class {
+		static {
+			__name$3(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 = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+				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$1 = pattern[pi];
+				var f = file2[fi];
+				this.debug(pattern, p$1, f);
+				if (p$1 === false) return false;
+				if (p$1 === GLOBSTAR) {
+					this.debug("GLOBSTAR", [
+						pattern,
+						p$1,
+						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$1 === "string") {
+					hit = f === p$1;
+					this.debug("string match", p$1, f, hit);
+				} else {
+					hit = f.match(p$1);
+					this.debug("pattern match", p$1, 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$4 = "";
+			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$3(() => dotTravAllowed ? "" : dotFileAllowed ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)", "patternStart");
+			const subPatternStart = /* @__PURE__ */ __name$3((p$1) => p$1.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)", "subPatternStart");
+			const clearStateChar = /* @__PURE__ */ __name$3(() => {
+				if (stateChar) {
+					switch (stateChar) {
+						case "*":
+							re$4 += star;
+							hasMagic = true;
+							break;
+						case "?":
+							re$4 += qmark;
+							hasMagic = true;
+							break;
+						default:
+							re$4 += "\\" + stateChar;
+							break;
+					}
+					this.debug("clearStateChar %j %j", stateChar, re$4);
+					stateChar = false;
+				}
+			}, "clearStateChar");
+			for (let i = 0, c$1; i < pattern.length && (c$1 = pattern.charAt(i)); i++) {
+				this.debug("%s	%s %s %j", pattern, i, re$4, c$1);
+				if (escaping) {
+					if (c$1 === "/") return false;
+					if (reSpecials[c$1]) re$4 += "\\";
+					re$4 += c$1;
+					escaping = false;
+					continue;
+				}
+				switch (c$1) {
+					case "/": return false;
+					case "\\":
+						if (inClass && pattern.charAt(i + 1) === "-") {
+							re$4 += c$1;
+							continue;
+						}
+						clearStateChar();
+						escaping = true;
+						continue;
+					case "?":
+					case "*":
+					case "+":
+					case "@":
+					case "!":
+						this.debug("%s	%s %s %j <-- stateChar", pattern, i, re$4, c$1);
+						if (inClass) {
+							this.debug("  in class");
+							if (c$1 === "!" && i === classStart + 1) c$1 = "^";
+							re$4 += c$1;
+							continue;
+						}
+						this.debug("call clearStateChar %j", stateChar);
+						clearStateChar();
+						stateChar = c$1;
+						if (options.noext) clearStateChar();
+						continue;
+					case "(": {
+						if (inClass) {
+							re$4 += "(";
+							continue;
+						}
+						if (!stateChar) {
+							re$4 += "\\(";
+							continue;
+						}
+						const plEntry = {
+							type: stateChar,
+							start: i - 1,
+							reStart: re$4.length,
+							open: plTypes[stateChar].open,
+							close: plTypes[stateChar].close
+						};
+						this.debug(this.pattern, "	", plEntry);
+						patternListStack.push(plEntry);
+						re$4 += plEntry.open;
+						if (plEntry.start === 0 && plEntry.type !== "!") {
+							dotTravAllowed = true;
+							re$4 += subPatternStart(pattern.slice(i + 1));
+						}
+						this.debug("plType %j %j", stateChar, re$4);
+						stateChar = false;
+						continue;
+					}
+					case ")": {
+						const plEntry = patternListStack[patternListStack.length - 1];
+						if (inClass || !plEntry) {
+							re$4 += "\\)";
+							continue;
+						}
+						patternListStack.pop();
+						clearStateChar();
+						hasMagic = true;
+						pl = plEntry;
+						re$4 += pl.close;
+						if (pl.type === "!") negativeLists.push(Object.assign(pl, { reEnd: re$4.length }));
+						continue;
+					}
+					case "|": {
+						const plEntry = patternListStack[patternListStack.length - 1];
+						if (inClass || !plEntry) {
+							re$4 += "\\|";
+							continue;
+						}
+						clearStateChar();
+						re$4 += "|";
+						if (plEntry.start === 0 && plEntry.type !== "!") {
+							dotTravAllowed = true;
+							re$4 += subPatternStart(pattern.slice(i + 1));
+						}
+						continue;
+					}
+					case "[":
+						clearStateChar();
+						if (inClass) {
+							re$4 += "\\" + c$1;
+							continue;
+						}
+						inClass = true;
+						classStart = i;
+						reClassStart = re$4.length;
+						re$4 += c$1;
+						continue;
+					case "]":
+						if (i === classStart + 1 || !inClass) {
+							re$4 += "\\" + c$1;
+							continue;
+						}
+						cs = pattern.substring(classStart + 1, i);
+						try {
+							RegExp("[" + braExpEscape(charUnescape(cs)) + "]");
+							re$4 += c$1;
+						} catch (er) {
+							re$4 = re$4.substring(0, reClassStart) + "(?:$.)";
+						}
+						hasMagic = true;
+						inClass = false;
+						continue;
+					default:
+						clearStateChar();
+						if (reSpecials[c$1] && !(c$1 === "^" && inClass)) re$4 += "\\";
+						re$4 += c$1;
+						break;
+				}
+			}
+			if (inClass) {
+				cs = pattern.slice(classStart + 1);
+				sp = this.parse(cs, SUBPARSE);
+				re$4 = re$4.substring(0, reClassStart) + "\\[" + sp[0];
+				hasMagic = hasMagic || sp[1];
+			}
+			for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+				let tail$1;
+				tail$1 = re$4.slice(pl.reStart + pl.open.length);
+				this.debug("setting tail", re$4, 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$4);
+				const t2 = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+				hasMagic = true;
+				re$4 = re$4.slice(0, pl.reStart) + t2 + "\\(" + tail$1;
+			}
+			clearStateChar();
+			if (escaping) re$4 += "\\\\";
+			const addPatternStart = addPatternStartSet[re$4.charAt(0)];
+			for (let n2 = negativeLists.length - 1; n2 > -1; n2--) {
+				const nl = negativeLists[n2];
+				const nlBefore = re$4.slice(0, nl.reStart);
+				const nlFirst = re$4.slice(nl.reStart, nl.reEnd - 8);
+				let nlAfter = re$4.slice(nl.reEnd);
+				const nlLast = re$4.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
+				const closeParensBefore = nlBefore.split(")").length;
+				const openParensBefore = nlBefore.split("(").length - closeParensBefore;
+				let cleanAfter = nlAfter;
+				for (let i = 0; i < openParensBefore; i++) cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+				nlAfter = cleanAfter;
+				const dollar = nlAfter === "" && isSub !== SUBPARSE ? "(?:$|\\/)" : "";
+				re$4 = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+			}
+			if (re$4 !== "" && hasMagic) re$4 = "(?=.)" + re$4;
+			if (addPatternStart) re$4 = patternStart() + re$4;
+			if (isSub === SUBPARSE) return [re$4, 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$4 + "$", flags), {
+					_glob: pattern,
+					_src: re$4
+				});
+			} 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$4 = set2.map((pattern) => {
+				pattern = pattern.map((p$1) => typeof p$1 === "string" ? regExpEscape(p$1) : p$1 === GLOBSTAR ? GLOBSTAR : p$1._src).reduce((set3, p$1) => {
+					if (!(set3[set3.length - 1] === GLOBSTAR && p$1 === GLOBSTAR)) set3.push(p$1);
+					return set3;
+				}, []);
+				pattern.forEach((p$1, i) => {
+					if (p$1 !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) return;
+					if (i === 0) if (pattern.length > 1) pattern[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + pattern[i + 1];
+					else pattern[i] = twoStar;
+					else if (i === pattern.length - 1) pattern[i - 1] += "(?:\\/|" + twoStar + ")?";
+					else {
+						pattern[i - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i + 1];
+						pattern[i + 1] = GLOBSTAR;
+					}
+				});
+				return pattern.filter((p$1) => p$1 !== GLOBSTAR).join("/");
+			}).join("|");
+			re$4 = "^(?:" + re$4 + ")$";
+			if (this.negate) re$4 = "^(?!" + re$4 + ").*$";
+			try {
+				this.regexp = new RegExp(re$4, 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 = f.length - 1; i >= 0; i--) {
+				filename = f[i];
+				if (filename) break;
+			}
+			for (let i = 0; i < set2.length; i++) {
+				const pattern = set2[i];
+				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",
@@ -28339,9 +29032,9 @@ function cloneDef(schema) {
 	return mergeDefs(schema._zod.def);
 }
 __name$3(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$3(getElementAtPath, "getElementAtPath");
 function promiseAllObject(promisesObj) {
@@ -28671,11 +29364,11 @@ function explicitlyAborted(x, startIndex = 0) {
 	return false;
 }
 __name$3(explicitlyAborted, "explicitlyAborted");
-function prefixIssues$1(path5, issues) {
+function prefixIssues$1(path6, issues) {
 	return issues.map((iss) => {
 		var _a3;
 		(_a3 = iss).path ?? (_a3.path = []);
-		iss.path.unshift(path5);
+		iss.path.unshift(path6);
 		return iss;
 	});
 }
@@ -28810,12 +29503,12 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 __name$3(flattenError, "flattenError");
 function formatError(error51, mapper = (issue2) => issue2.message) {
 	const fieldErrors = { _errors: [] };
-	const processError = /* @__PURE__ */ __name$3((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$3((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;
@@ -28839,13 +29532,13 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 __name$3(formatError, "formatError");
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
 	const result = { errors: [] };
-	const processError = /* @__PURE__ */ __name$3((error52, path5 = []) => {
+	const processError = /* @__PURE__ */ __name$3((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;
@@ -28875,8 +29568,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 __name$3(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 {
@@ -41008,11 +41701,11 @@ function detectVersion(schema, defaultTarget) {
 __name$3(detectVersion, "detectVersion");
 function resolveRef(ref, ctx) {
 	if (!ref.startsWith("#")) throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
-	const path5 = ref.slice(1).split("/").filter(Boolean);
-	if (path5.length === 0) return ctx.rootSchema;
+	const path6 = ref.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}`);
 		return ctx.defs[key];
 	}
@@ -41401,9 +42094,9 @@ Please add "${field}" to "env.${envName}".`);
 	return rawEnv[field] ?? defaultValue;
 }
 __name$3(notInheritable, "notInheritable");
-function unwindPropertyPath(root, path5) {
+function unwindPropertyPath(root, path6) {
 	let container = root;
-	const parts = path5.split(".");
+	const parts = path6.split(".");
 	for (let i = 0; i < parts.length - 1; i++) {
 		if (!hasProperty(container, parts[i])) return;
 		container = container[parts[i]];
@@ -42189,7 +42882,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;
 }
@@ -43481,7 +44174,6 @@ var validateBindingsHaveUniqueNames = /* @__PURE__ */ __name$3((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];
@@ -44452,7 +45144,7 @@ function errorIfMigrationsAndExportsBothSet(diagnostics, migrations, exports$1)
 	if (migrations.length > 0 && exports$1 !== void 0 && Object.values(exports$1).some((entry) => entry.type === "durable-object")) diagnostics.errors.push(`\`migrations\` and \`exports\` are mutually exclusive. Choose one or the other to declare your Durable Object lifecycle, but not both.`);
 }
 __name$3(errorIfMigrationsAndExportsBothSet, "errorIfMigrationsAndExportsBothSet");
-function validateContainerExportLinks$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();
@@ -44512,7 +45204,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$3(validateContainerExportLinks$1, "validateContainerExportLinks");
+__name$3(validateContainerExportLinks, "validateContainerExportLinks");
 var validatePythonModules = /* @__PURE__ */ __name$3((diagnostics, field, value, topLevelEnv) => {
 	if (value === void 0) return true;
 	if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -46944,6 +47636,91 @@ function toUrlPath(filePath) {
 	return filePath.replace(/\\/g, "/");
 }
 __name$3(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.resolve(options.projectPath, migrationsDir);
+	return listFilesRelative(walkRoot, new import_minimatch.Minimatch(dirRelativePattern, { dot: false })).map((name) => ({
+		name,
+		filePath: path.join(walkRoot, ...name.split("/"))
+	}));
+}
+__name$3(getD1MigrationFiles, "getD1MigrationFiles");
+function normalizeRelativePath(p$1) {
+	const forwardSlashed = p$1.replace(/\\/g, "/");
+	const normalized = path.posix.normalize(forwardSlashed);
+	if (normalized.endsWith("/")) return normalized.slice(0, -1);
+	return normalized;
+}
+__name$3(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$3(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 = fs.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.join(abs, entry.name),
+					rel: childRel
+				});
+			} else if (entry.isFile() && matcher.match(childRel)) out.push(childRel);
+		}
+	}
+	return out.sort(compareMigrationPaths);
+}
+__name$3(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 = 0; i < shared; i++) {
+		const aSegment = aSegments[i];
+		const bSegment = bSegments[i];
+		if (aSegment === void 0 || bSegment === void 0) break;
+		const cmp$2 = compareSegments(aSegment, bSegment);
+		if (cmp$2 !== 0) return cmp$2;
+	}
+	return aSegments.length - bSegments.length;
+}
+__name$3(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$3(compareSegments, "compareSegments");
+function leadingMigrationNumber(relativePath) {
+	const firstSegment = relativePath.split("/")[0];
+	return parseInt(firstSegment.split("_")[0], 10);
+}
+__name$3(leadingMigrationNumber, "leadingMigrationNumber");
 
 //#endregion
 //#region ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/utils.js
@@ -61073,7 +61850,7 @@ __name$1(createWorkerUploadForm, "createWorkerUploadForm");
 //#endregion
 //#region ../remote-bindings/dist/index.mjs
 var import_undici = require_undici();
-var version = "0.0.28";
+var version = "0.0.29";
 var NoDefaultValueProvided = class extends UserError$1 {
 	constructor() {
 		super("This command cannot be run in a non-interactive context", { telemetryMessage: "remote bindings prompt default missing" });
@@ -62301,7 +63078,6 @@ const ContainerObservabilityBaseSchema = z$1.strictObject({
 });
 const StandardContainerObservabilitySchema = z$1.union([ContainerObservabilityBaseSchema.extend({ targetInstancePercentage: z$1.number().min(0).max(100).optional() }), ContainerObservabilityBaseSchema.extend({ targetInstanceCount: z$1.number().int().nonnegative().optional() })]);
 const BaseContainerSchema = z$1.strictObject({
-	type: z$1.literal("container"),
 	name: z$1.string().min(1),
 	unsafe: z$1.record(z$1.string(), z$1.unknown()).optional()
 });
@@ -62358,14 +63134,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 = z$1.union([StandardContainerBaseSchema.extend({ image: InputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: z$1.record(z$1.string(), InputContainerImageSchema).optional() })]);
 /**
-* Output Container schema — validates Container configs in the Build Output
-* Specification, after any Dockerfile has been built into a local or remote
-* image reference.
+* Output Container schema — parses `container.config.json` files in the Build
+* Output Specification, after any Dockerfile has been built into a local image reference.
 */
 const OutputContainerSchema = z$1.union([StandardContainerBaseSchema.extend({ image: OutputContainerImageSchema }).superRefine(validateContainerRelationships), DurableObjectContainerBaseSchema.extend({ images: z$1.record(z$1.string(), OutputContainerImageSchema).optional() })]);
 const DurableObjectCreatedExportSchema = z$1.strictObject({
@@ -62507,7 +63282,6 @@ const UnsafeSchema = z$1.strictObject({
 * (user-authored) and output (on-disk) Worker configs.
 */
 const BaseWorkerSchema = z$1.strictObject({
-	type: z$1.literal("worker"),
 	name: z$1.string(),
 	compatibilityDate: z$1.string(),
 	compatibilityFlags: z$1.array(z$1.string()).optional(),
@@ -62528,75 +63302,37 @@ const BaseWorkerSchema = z$1.strictObject({
 	exports: z$1.record(z$1.string(), ExportSchema).optional()
 });
 /**
-* Input Worker schema — the shape that user-authored `cloudflare.config.ts`
-* files are validated against. Adds an optional `entrypoint` field to the
-* base schema.
+* Input Worker schema — parses Worker definitions from user-authored
+* `cloudflare.config.ts` files. Adds an optional `entrypoint` field to the base
+* schema.
 */
 const InputWorkerSchema = BaseWorkerSchema.extend({ entrypoint: z$1.union([z$1.string(), z$1.strictObject({ default: z$1.string() })]).transform((value) => typeof value === "string" ? value : value.default).optional() });
 /**
-* Input settings schema — validates the named `settings` export of a
-* `cloudflare.config.ts`. Holds account/deployment settings shared by the other exports.
+* Input settings schema — parses the account settings at the top level of
+* `cloudflare.config.ts`.
 */
-const InputSettingsSchema = z$1.strictObject({
-	type: z$1.literal("settings"),
+const InputSettingsSchema = z$1.object({
 	accountId: z$1.string().optional(),
 	complianceRegion: z$1.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: z$1.boolean().optional(),
+/** The resolved, user-authored project configuration. */
+const InputConfigSchema = z$1.strictObject({
+	...InputSettingsSchema.shape,
+	worker: InputWorkerSchema.optional(),
+	containers: z$1.array(InputContainerSchema).default([])
+});
+const BuildContextSchema = z$1.strictObject({
+	isPreview: z$1.boolean(),
 	mode: z$1.string().optional()
 });
-const DEFAULT_EXPORT_NAME = "default";
-const SETTINGS_EXPORT_NAME = "settings";
-const SUPPORTED_EXPORT_TYPES = new Set([
-	"container",
-	"worker",
-	"settings"
-]);
-function invalidConfigExportMessage(exportName) {
-	return `The \`${exportName}\` export is not a supported export type. Move constants, helper functions, and other unsupported exports to a separate module.`;
-}
-const ConfigExportsTypeSchema = z$1.record(z$1.string(), z$1.unknown()).check((ctx) => {
-	for (const [key, value] of Object.entries(ctx.value)) {
-		const isObject$1 = typeof value === "object" && value !== null;
-		const type = isObject$1 && "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$1 ? [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 = z$1.strictObject({
+	...InputSettingsSchema.shape,
+	buildContext: BuildContextSchema
 });
 const ModuleTypeSchema = z$1.enum([
 	"esm",
@@ -62628,9 +63364,9 @@ const ManifestSchema = z$1.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) => {
@@ -62738,27 +63474,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$1) {
 	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$1;
+	if (worker !== void 0) {
+		convertTopLevel(worker, result);
+		convertBindingsAndAssets(worker, result);
+		convertExports(worker, result);
+		convertDomains(worker, result);
+		convertTriggers(worker, result);
+		convertTailConsumers(worker, result);
+	}
+	convertSettings(config$1, result);
+	if (containers.length > 0) result.containers = containers.map((container) => convertContainer(container));
 	return result;
 }
 function convertContainer(container) {
@@ -63356,31 +64090,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 = 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)) {
-		if (options?.include && !options.include.includes(name)) continue;
-		exports$2[name] = value;
-	}
+	if (!("default" in mod)) throw new Error(`The config file "${configPath}" does not have a default export. Export your configuration with \`export default defineConfig({ ... })\`.`);
 	return {
-		exports: exports$2,
+		config: mod.default,
 		dependencies
 	};
 }
@@ -63472,11 +64197,8 @@ const CROSS_WORKER_BINDING_TYPES = new Set([
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
 }
-function isConfigReference(value) {
-	return typeof value === "function" || isRecord(value);
-}
-function normalizeConfigReference(reference, resolved, expectedType) {
-	return isRecord(resolved) && resolved.type === expectedType && typeof resolved.name === "string" ? resolved.name : reference;
+function normalizeConfigReference(reference, resolved) {
+	return isRecord(resolved) && typeof resolved.name === "string" ? resolved.name : reference;
 }
 function createDefinitionResolver(ctx) {
 	const resolvedDefinitions = /* @__PURE__ */ new Map();
@@ -63494,11 +64216,11 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 	if (!isRecord(resolved) || !isRecord(resolved.env)) return resolved;
 	const env$2 = { ...resolved.env };
 	for (const [bindingName, binding] of Object.entries(env$2)) {
-		if (!isRecord(binding) || typeof binding.type !== "string" || !CROSS_WORKER_BINDING_TYPES.has(binding.type) || !isConfigReference(binding.worker)) continue;
+		if (!isRecord(binding) || typeof binding.type !== "string" || !CROSS_WORKER_BINDING_TYPES.has(binding.type) || typeof binding.worker === "string") continue;
 		const target = await resolveDefinition(binding.worker);
 		env$2[bindingName] = {
 			...binding,
-			worker: normalizeConfigReference(binding.worker, target, "worker")
+			worker: normalizeConfigReference(binding.worker, target)
 		};
 	}
 	return {
@@ -63506,7 +64228,7 @@ async function normalizeWorkerReferences(resolved, resolveDefinition) {
 		env: env$2
 	};
 }
-async function normalizeContainerReferences(resolved, resolveDefinition, resolvedExports) {
+async function normalizeContainerReferences(resolved, resolveDefinition, containers) {
 	const issues = [];
 	if (!isRecord(resolved) || !isRecord(resolved.exports)) return {
 		value: resolved,
@@ -63525,7 +64247,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,
@@ -63534,7 +64256,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 			continue;
 		}
 		const target = await resolveDefinition(reference);
-		if (isRecord(target) && target.type === "container" && typeof target.name === "string" && !Object.values(resolvedExports).includes(target)) {
+		if (isRecord(target) && typeof target.name === "string" && !containers.includes(target)) {
 			issues.push({
 				code: "custom",
 				input: reference,
@@ -63543,7 +64265,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 					exportName,
 					"container"
 				],
-				message: `The referenced Container "${target.name}" is not exported.`
+				message: `The referenced Container "${target.name}" is not included in the \`containers\` array.`
 			});
 			workerExports[exportName] = {
 				...workerExport,
@@ -63553,7 +64275,7 @@ async function normalizeContainerReferences(resolved, resolveDefinition, resolve
 		}
 		workerExports[exportName] = {
 			...workerExport,
-			container: normalizeConfigReference(reference, target, "container")
+			container: normalizeConfigReference(reference, target)
 		};
 	}
 	return {
@@ -63564,8 +64286,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$1) => ({
@@ -63573,126 +64295,83 @@ function prefixIssues(issues, prefix) {
 		path: [prefix, ...issue$1.path]
 	}));
 }
-function validateUniqueResourceNames(configExports) {
+function validateUniqueContainerNames(config$1) {
 	const issues = [];
-	const exportNameByResourceName = {
-		container: /* @__PURE__ */ new Map(),
-		worker: /* @__PURE__ */ new Map()
-	};
-	for (const [exportName, config$1] of Object.entries(configExports)) {
-		if (config$1.type !== "container" && config$1.type !== "worker") continue;
-		const resourceType = config$1.type === "container" ? "Container" : "Worker";
-		const exportNames = exportNameByResourceName[config$1.type];
-		const previousExportName = exportNames.get(config$1.name);
-		if (previousExportName !== void 0) {
+	const firstIndexByName = /* @__PURE__ */ new Map();
+	for (const [index, container] of config$1.containers.entries()) {
+		const firstIndex = firstIndexByName.get(container.name);
+		if (firstIndex !== void 0) {
 			issues.push({
 				code: "custom",
-				input: config$1.name,
-				path: [exportName, "name"],
-				message: `The ${resourceType} name "${config$1.name}" is also used by the "${previousExportName}" export. ${resourceType} names must be unique.`
+				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$1.name, exportName);
+		firstIndexByName.set(container.name, index);
 	}
 	return issues;
 }
-function validateContainerExportLinks(configExports) {
+function validateContainerLinks(config$1) {
 	const issues = [];
-	const containerNames = /* @__PURE__ */ new Set();
-	for (const config$1 of Object.values(configExports)) if (config$1.type === "container") containerNames.add(config$1.name);
-	const firstReferenceByContainerName = /* @__PURE__ */ new Map();
-	for (const [workerExportName, config$1] of Object.entries(configExports)) {
-		if (config$1.type !== "worker") continue;
-		for (const [durableObjectExportName, workerExport] of Object.entries(config$1.exports ?? {})) {
-			if (workerExport.type !== "durable-object" || !("container" in workerExport) || workerExport.container === void 0) continue;
-			const containerName = workerExport.container;
-			const path$3 = [
-				workerExportName,
-				"exports",
-				durableObjectExportName,
-				"container"
-			];
-			if (!containerNames.has(containerName)) {
-				issues.push({
-					code: "custom",
-					input: containerName,
-					path: path$3,
-					message: `The Container "${containerName}" is not exported from this configuration.`
-				});
-				continue;
-			}
-			const firstReference = firstReferenceByContainerName.get(containerName);
-			if (firstReference !== void 0) {
-				issues.push({
-					code: "custom",
-					input: containerName,
-					path: path$3,
-					message: `The Container "${containerName}" is already referenced by "${firstReference.workerExportName}.exports.${firstReference.durableObjectExportName}". A Container can only be linked to one Durable Object.`
-				});
-				continue;
-			}
-			firstReferenceByContainerName.set(containerName, {
-				workerExportName,
-				durableObjectExportName
+	const firstExportByContainerName = /* @__PURE__ */ new Map();
+	for (const [exportName, workerExport] of Object.entries(config$1.worker?.exports ?? {})) {
+		if (workerExport.type !== "durable-object" || !("container" in workerExport) || workerExport.container === void 0) continue;
+		const containerName = workerExport.container;
+		const firstExportName = firstExportByContainerName.get(containerName);
+		if (firstExportName !== void 0) {
+			issues.push({
+				code: "custom",
+				input: containerName,
+				path: [
+					"worker",
+					"exports",
+					exportName,
+					"container"
+				],
+				message: `The Container "${containerName}" is already referenced by \`worker.exports.${firstExportName}\`. A Container can only be linked to one Durable Object.`
 			});
+			continue;
 		}
+		firstExportByContainerName.set(containerName, exportName);
 	}
 	return issues;
 }
-/**
-* Resolve and validate loaded `cloudflare.config.ts` exports.
-*
-* Config inputs are resolved once by identity. Top-level Worker and Container
-* exports are also parsed once by identity. References are resolved only far
-* enough to replace them with resource names, then Container links are
-* validated across the exported resources.
-*/
-async function resolveAndValidateConfigExports(exports$2, ctx) {
+/** Resolve and parse the default configuration export. */
+async function resolveAndParseConfig(input, ctx) {
 	const resolveDefinition = createDefinitionResolver(ctx);
-	const parsedResources = /* @__PURE__ */ new Map();
-	const resolvedExports = {};
-	for (const [name, input] of Object.entries(exports$2)) resolvedExports[name] = await resolveDefinition(input);
-	const typeResult = ConfigExportsTypeSchema.safeParse(resolvedExports);
-	if (!typeResult.success) return typeResult;
-	const issues = [];
-	const data = {};
-	const resolvedSettings = resolvedExports.settings;
-	const settingsResult = resolvedSettings ? InputSettingsSchema.safeParse(resolvedSettings) : void 0;
-	if (settingsResult) if (settingsResult.success) data.settings = settingsResult.data;
-	else issues.push(...prefixIssues(settingsResult.error.issues, "settings"));
-	for (const [name, input] of Object.entries(exports$2)) {
-		const resolved = resolvedExports[name];
-		if (!isRecord(resolved)) continue;
-		if (resolved.type !== "worker" && resolved.type !== "container") continue;
-		let result = parsedResources.get(input);
-		if (!result) {
-			if (resolved.type === "worker") {
-				const normalized = await normalizeConfigReferences(resolved, resolveDefinition, resolvedExports);
-				issues.push(...prefixIssues(normalized.issues, name));
-				result = InputWorkerSchema.safeParse(normalized.value);
-			} else result = InputContainerSchema.safeParse(resolved);
-			parsedResources.set(input, result);
-			if (!result.success) issues.push(...prefixIssues(result.error.issues, name));
-		}
-		if (result.success) data[name] = result.data;
-	}
-	issues.push(...validateUniqueResourceNames(data), ...validateContainerExportLinks(data));
+	const resolved = await resolveDefinition(input);
+	if (!isRecord(resolved)) return InputConfigSchema.safeParse(resolved);
+	const containerInputs = Array.isArray(resolved.containers) ? resolved.containers : [];
+	const containers = await Promise.all(containerInputs.map((container) => resolveDefinition(container)));
+	const normalizedWorker = resolved.worker === void 0 ? {
+		value: void 0,
+		issues: []
+	} : await normalizeWorkerConfig(await resolveDefinition(resolved.worker), resolveDefinition, containers);
+	const candidate = {
+		...resolved,
+		...resolved.worker === void 0 ? {} : { worker: normalizedWorker.value },
+		...Array.isArray(resolved.containers) ? { containers } : {}
+	};
+	const result = InputConfigSchema.safeParse(candidate);
+	const issues = [...prefixIssues(normalizedWorker.issues, "worker")];
+	if (!result.success) issues.push(...result.error.issues);
+	else issues.push(...validateUniqueContainerNames(result.data), ...validateContainerLinks(result.data));
 	return issues.length > 0 ? {
 		success: false,
 		error: new z$1.ZodError(issues)
-	} : {
-		success: true,
-		data
-	};
+	} : 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$1, dependencies } = await loadConfig(configPath);
 	return {
-		result: await resolveAndValidateConfigExports(exports$2, ctx),
+		result: await resolveAndParseConfig(config$1, ctx),
 		dependencies
 	};
 }
@@ -63708,7 +64387,7 @@ const NEW_CONFIG_FILENAME = "cloudflare.config.ts";
 * the project uses.
 *
 * This mirrors the `@cloudflare/vite-plugin` implementation of
-* `experimental.newConfig`: load and validate via `@cloudflare/config`, convert
+* `experimental.newConfig`: load and parse via `@cloudflare/config`, convert
 * the result to a Wrangler `RawConfig`, then run it through the standard
 * Wrangler normalisation/validation pipeline.
 *
@@ -63718,14 +64397,13 @@ const NEW_CONFIG_FILENAME = "cloudflare.config.ts";
 */
 async function loadNewConfig(configPath, mode) {
 	if (!existsSync(configPath)) throw new TypeError(`\`experimental.newConfig\` is enabled but no \`${NEW_CONFIG_FILENAME}\` was found at ${configPath}.`);
-	const { result } = await loadAndValidateConfig(configPath, {
+	const { result } = await loadAndParseConfig(configPath, {
 		isPreview: false,
 		mode
 	});
 	if (!result.success) throw new TypeError(`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 TypeError(`\`${NEW_CONFIG_FILENAME}\` must have a default worker export.`);
-	const { config: config$1, diagnostics } = normalizeAndValidateConfig(convertToWranglerConfig(worker, result.data.settings?.type === "settings" ? result.data.settings : void 0), configPath, configPath, {});
+	if (result.data.worker === void 0) throw new TypeError(`\`${NEW_CONFIG_FILENAME}\` must define a Worker using the \`worker\` property.`);
+	const { config: config$1, diagnostics } = normalizeAndValidateConfig(convertToWranglerConfig(result.data), configPath, configPath, {});
 	if (diagnostics.hasWarnings()) console.warn(diagnostics.renderWarnings());
 	if (diagnostics.hasErrors()) throw new TypeError(diagnostics.renderErrors());
 	return config$1;
@@ -64216,24 +64894,40 @@ function cloudflareTest(options) {
 //#endregion
 //#region src/pool/d1.ts
 /**
-* Reads all migrations in `migrationsPath`, ordered by migration number.
-* Each migration will have its contents split into an array of SQL queries.
+* Reads D1 migration files, ordered by migration number. Each migration has
+* its contents split into an array of SQL queries.
+*
+* Pass a directory path to keep the historical behaviour of reading top-level
+* `*.sql` files in that directory. Pass options to discover files the same way
+* Wrangler does, including nested layouts such as
+* `0001_init/migration.sql` via `migrationsPattern`.
 */
-async function readD1Migrations(migrationsPath) {
-	if (typeof migrationsPath !== "string") throw new TypeError("Failed to execute 'readD1Migrations': parameter 1 is not of type 'string'.");
+async function readD1Migrations(migrationsPathOrOptions) {
+	const files = listD1MigrationFiles(migrationsPathOrOptions);
 	const { unstable_splitSqlQuery } = await import("wrangler");
-	const names = fs.readdirSync(migrationsPath).filter((name) => name.endsWith(".sql"));
-	names.sort((a, b) => {
-		return parseInt(a.split("_")[0]) - parseInt(b.split("_")[0]);
-	});
-	return names.map((name) => {
-		const migrationPath = path.join(migrationsPath, name);
+	return files.map(({ name, filePath }) => {
 		return {
 			name,
-			queries: unstable_splitSqlQuery(fs.readFileSync(migrationPath, "utf8"))
+			queries: unstable_splitSqlQuery(fs.readFileSync(filePath, "utf8"))
 		};
 	});
 }
+function listD1MigrationFiles(migrationsPathOrOptions) {
+	if (typeof migrationsPathOrOptions === "string") {
+		fs.readdirSync(migrationsPathOrOptions);
+		return getD1MigrationFiles({
+			projectPath: migrationsPathOrOptions,
+			migrationsDir: ".",
+			migrationsPattern: "*.sql"
+		});
+	}
+	if (migrationsPathOrOptions !== null && typeof migrationsPathOrOptions === "object") return getD1MigrationFiles({
+		projectPath: migrationsPathOrOptions.projectPath ?? process.cwd(),
+		migrationsDir: migrationsPathOrOptions.migrationsDir,
+		migrationsPattern: migrationsPathOrOptions.migrationsPattern
+	});
+	throw new TypeError("Failed to execute 'readD1Migrations': parameter 1 is not of type 'string' or 'object'.");
+}
 
 //#endregion
 //#region src/pool/index.ts