@cloudflare/workers-utils 0.40.1 → 0.41.1

package/dist/index.mjs

@@ -1,9 +1,9 @@
 export { MetricsRegistry } from './chunk-Z62CVNHJ.mjs';
 export { _forceColour, formatZodError } from './chunk-7AX24RFK.mjs';
-import { isRedirectedRawConfig, configFileName, formatConfigSnippet, getDurableObjectExports, getContainerNameToClassNameMap, parsePackageJSON, readFileSync, ParseError, parseJSON, APIError, CONTAINER_IMAGES_BINDING, dir, parseTOML, modify, applyEdits, format, dist_default, parseJSONC } from './chunk-JGKSDUFK.mjs';
-export { APIError, CONTAINER_IMAGES_BINDING, ENVIRONMENT_TAG_PREFIX, INHERIT_SYMBOL, JSON_CONFIG_FORMATS, PATH_TO_DEPLOY_CONFIG, ParseError, SERVICE_TAG_PREFIX, configFileName, configFormat, experimental_readRawConfig, findWranglerConfig, formatConfigSnippet, getContainerDurableObjectClassNames, getContainerNameToClassNameMap, getDurableObjectClassNameToUseSQLiteMap, getDurableObjectContainerApps, getDurableObjectExports, getResolvedDurableObjectContainerApps, hasDurableObjectExports, indexLocation, isDurableObjectContainerApp, isRedirectedConfig, parseByteSize, parseHumanDuration, parseJSON, parseJSONC, parseNonHyphenedUuid, parsePackageJSON, parseTOML, partitionExports, readFileSync, readFileSyncToBuffer, resolveContainerClassName, resolveWranglerConfigPath, searchLocation, validateDurableObjectContainerApplications } from './chunk-JGKSDUFK.mjs';
-import { assertNever } from './chunk-S6ZAI5DC.mjs';
-export { DEFAULT_COMPAT_DATE, assertNever, constructWranglerConfig, mapWorkerMetadataBindings } from './chunk-S6ZAI5DC.mjs';
+import { isRedirectedRawConfig, configFileName, formatConfigSnippet, getDurableObjectExports, getContainerNameToClassNameMap, parsePackageJSON, readFileSync, ParseError, parseJSON, APIError, dir, parseTOML, modify, applyEdits, format, dist_default, parseJSONC } from './chunk-IKXB77SR.mjs';
+export { APIError, ENVIRONMENT_TAG_PREFIX, INHERIT_SYMBOL, JSON_CONFIG_FORMATS, PATH_TO_DEPLOY_CONFIG, ParseError, SERVICE_TAG_PREFIX, configFileName, configFormat, experimental_readRawConfig, findWranglerConfig, formatConfigSnippet, getContainerDurableObjectClassNames, getContainerNameToClassNameMap, getDurableObjectClassNameToUseSQLiteMap, getDurableObjectContainerApps, getDurableObjectExports, getResolvedDurableObjectContainerApps, hasDurableObjectExports, indexLocation, isDurableObjectContainerApp, isRedirectedConfig, parseByteSize, parseHumanDuration, parseJSON, parseJSONC, parseNonHyphenedUuid, parsePackageJSON, parseTOML, partitionExports, readFileSync, readFileSyncToBuffer, resolveContainerClassName, resolveWranglerConfigPath, searchLocation, validateDurableObjectContainerApplications } from './chunk-IKXB77SR.mjs';
+import { assertNever } from './chunk-4PNP2TCS.mjs';
+export { DEFAULT_COMPAT_DATE, assertNever, constructWranglerConfig, mapWorkerMetadataBindings } from './chunk-4PNP2TCS.mjs';
 export { NODEJS_COMPAT_DEFAULT_ON_DATE, NODEJS_COMPAT_V2_SWITCH_OVER_DATE, getTodaysCompatDate, isCompatDate, isNodejsCompatDefaultOn, resolveNodejsCompat, stripRedundantNodejsCompatFlags } from './chunk-C6O4ION7.mjs';
 import { getCloudflareEnv, getCloudflareContainerRegistry, getCloudflareApiBaseUrl, getTraceHeader, getCloudflaredPathFromEnv, getOutputFilePathFromEnv, getOutputFileDirectoryFromEnv, getCIOverrideName, getWranglerCacheDirFromEnv } from './chunk-IYSONYTF.mjs';
 export { COMPLIANCE_REGION_CONFIG_PUBLIC, COMPLIANCE_REGION_CONFIG_UNKNOWN, getBrowserRenderingHeadfulFromEnv, getBuildConditionsFromEnv, getBuildPlatformFromEnv, getC3CommandFromEnv, getCIGeneratePreviewAlias, getCIMatchTag, getCIOverrideName, getCIOverrideNetworkModeHost, getCfFetchEnabledFromEnv, getCfFetchPathFromEnv, getCloudflareApiBaseUrl, getCloudflareApiEnvironmentFromEnv, getCloudflareComplianceRegion, getCloudflareContainerRegistry, getCloudflareEnv, getCloudflareIncludeProcessEnvFromEnv, getCloudflareLoadDevVarsFromDotEnv, getCloudflaredPathFromEnv, getComplianceRegionSubdomain, getD1ExtraLocationChoices, getDisableConfigWatching, getLocalExplorerEnabledFromEnv, getLocalObservabilityEnabledFromEnv, getNoSkillsUpdatePromptsFromEnv, getOpenNextDeployFromEnv, getOutputFileDirectoryFromEnv, getOutputFilePathFromEnv, getRegistryPath, getSanitizeLogs, getSubdomainMixedStateCheckDisabled, getTraceHeader, getWorkersCIBranchName, getWranglerCacheDirFromEnv, getWranglerHideBanner, getWranglerSendErrorReportsFromEnv, getWranglerSendMetricsFromEnv, isDoNotTrackEnabled } from './chunk-IYSONYTF.mjs';
@@ -486,11 +486,11 @@ var require_command_exists = __commonJS({
   "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports$1, module) {
     var exec = __require("child_process").exec;
     var execSync = __require("child_process").execSync;
-    var fs3 = __require("fs");
-    var path5 = __require("path");
-    var access = fs3.access;
-    var accessSync2 = fs3.accessSync;
-    var constants2 = fs3.constants || fs3;
+    var fs4 = __require("fs");
+    var path6 = __require("path");
+    var access = fs4.access;
+    var accessSync2 = fs4.accessSync;
+    var constants2 = fs4.constants || fs4;
     var isUsingWindows = process.platform == "win32";
     var fileNotExists = /* @__PURE__ */ __name(function(commandName, callback) {
       access(
@@ -591,8 +591,8 @@ var require_command_exists = __commonJS({
       cleanInput = /* @__PURE__ */ __name(function(s) {
         var isPathName = /[\\]/.test(s);
         if (isPathName) {
-          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 + '"';
@@ -874,9 +874,9 @@ var require_strip_json_comments = __commonJS({
 // ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js
 var require_utils = __commonJS({
   "../../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 = exports$1.parse = function(content) {
       if (/^\s*{/.test(content))
@@ -890,9 +890,9 @@ var require_utils = __commonJS({
       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;
       }
@@ -927,15 +927,15 @@ var require_utils = __commonJS({
       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(find2, "find");
@@ -1425,8 +1425,8 @@ var require_registry_auth_token = __commonJS({
       return void 0;
     }
     __name(getLegacyAuthInfo, "getLegacyAuthInfo");
-    function normalizePath(path5) {
-      return path5[path5.length - 1] === "/" ? path5 : path5 + "/";
+    function normalizePath(path6) {
+      return path6[path6.length - 1] === "/" ? path6 : path6 + "/";
     }
     __name(normalizePath, "normalizePath");
     function getAuthInfoForUrl(regUrl, npmrc) {
@@ -1477,19 +1477,19 @@ var require_update_check = __commonJS({
   "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports$1, module) {
     var { URL: URL2 } = __require("url");
     var { join: join3 } = __require("path");
-    var fs3 = __require("fs");
+    var fs4 = __require("fs");
     var { promisify } = __require("util");
     var { tmpdir } = __require("os");
     var registryUrl = require_registry_url();
-    var writeFile = promisify(fs3.writeFile);
-    var mkdir = promisify(fs3.mkdir);
-    var readFile = promisify(fs3.readFile);
+    var writeFile = promisify(fs4.writeFile);
+    var mkdir = promisify(fs4.mkdir);
+    var readFile = promisify(fs4.readFile);
     var compareVersions = /* @__PURE__ */ __name((a, b) => a.localeCompare(b, "en-US", { numeric: true }), "compareVersions");
     var encode3 = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
     var getFile = /* @__PURE__ */ __name(async (details, distTag) => {
       const rootDir = tmpdir();
       const subDir = join3(rootDir, "update-check");
-      if (!fs3.existsSync(subDir)) {
+      if (!fs4.existsSync(subDir)) {
         await mkdir(subDir);
       }
       let name = `${details.name}-${distTag}.json`;
@@ -1499,7 +1499,7 @@ var require_update_check = __commonJS({
       return join3(subDir, name);
     }, "getFile");
     var evaluateCache = /* @__PURE__ */ __name(async (file2, time3, interval) => {
-      if (fs3.existsSync(file2)) {
+      if (fs4.existsSync(file2)) {
         const content = await readFile(file2, "utf8");
         const { lastUpdate, latest } = JSON.parse(content);
         const nextCheck = lastUpdate + interval;
@@ -1626,6 +1626,796 @@ var require_update_check = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/lib/path.js
+var require_path = __commonJS({
+  "../../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/lib/path.js"(exports$1, module) {
+    var isWindows = typeof process === "object" && process && process.platform === "win32";
+    module.exports = isWindows ? { sep: "\\" } : { sep: "/" };
+  }
+});
+
+// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports$1, module) {
+    module.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(balanced, "balanced");
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    __name(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(range, "range");
+  }
+});
+
+// ../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports$1, module) {
+    var balanced = require_balanced_match();
+    module.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(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    __name(numeric, "numeric");
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    __name(escapeBraces, "escapeBraces");
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    __name(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 = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+      }
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    __name(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(expandTop, "expandTop");
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    __name(embrace, "embrace");
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    __name(isPadded, "isPadded");
+    function lte(i, y) {
+      return i <= y;
+    }
+    __name(lte, "lte");
+    function gte(i, y) {
+      return i >= y;
+    }
+    __name(gte, "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) {
+                return m.pre + n2[0] + p;
+              });
+            }
+          }
+        }
+        var N;
+        if (isSequence) {
+          var x = numeric(n2[0]);
+          var y = numeric(n2[1]);
+          var width = Math.max(n2[0].length, n2[1].length);
+          var incr = n2.length == 3 ? Math.abs(numeric(n2[2])) : 1;
+          var test = lte;
+          var reverse = y < x;
+          if (reverse) {
+            incr *= -1;
+            test = gte;
+          }
+          var pad = n2.some(isPadded);
+          N = [];
+          for (var i = x; test(i, y); i += incr) {
+            var c;
+            if (isAlphaSequence) {
+              c = String.fromCharCode(i);
+              if (c === "\\")
+                c = "";
+            } else {
+              c = String(i);
+              if (pad) {
+                var need = width - c.length;
+                if (need > 0) {
+                  var z2 = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z2 + c.slice(1);
+                  else
+                    c = z2 + c;
+                }
+              }
+            }
+            N.push(c);
+          }
+        } else {
+          N = [];
+          for (var j = 0; j < n2.length; j++) {
+            N.push.apply(N, expand(n2[j], false));
+          }
+        }
+        for (var j = 0; j < N.length; j++) {
+          for (var k = 0; k < post.length; k++) {
+            var expansion = pre + N[j] + post[k];
+            if (!isTop || isSequence || expansion)
+              expansions.push(expansion);
+          }
+        }
+      }
+      return expansions;
+    }
+    __name(expand, "expand");
+  }
+});
+
+// ../../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/minimatch.js
+var require_minimatch = __commonJS({
+  "../../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/minimatch.js"(exports$1, module) {
+    var minimatch = module.exports = (p, pattern, options = {}) => {
+      assertValidPattern(pattern);
+      if (!options.nocomment && pattern.charAt(0) === "#") {
+        return false;
+      }
+      return new Minimatch2(pattern, options).match(p);
+    };
+    module.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((s) => s.split("").reduce((set2, c) => {
+      set2[c] = true;
+      return set2;
+    }, {}), "charSet");
+    var reSpecials = charSet("().*{}+?[]^$\\!");
+    var addPatternStartSet = charSet("[.(");
+    var slashSplit = /\/+/;
+    minimatch.filter = (pattern, options = {}) => (p, i, list) => minimatch(p, pattern, options);
+    var ext = /* @__PURE__ */ __name((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((p, pattern, options) => orig(p, pattern, ext(def, options)), "m");
+      m.Minimatch = class Minimatch extends orig.Minimatch {
+        static {
+          __name(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((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((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((s) => s.replace(/\\(.)/g, "$1"), "globUnescape");
+    var charUnescape = /* @__PURE__ */ __name((s) => s.replace(/\\([^-\]])/g, "$1"), "charUnescape");
+    var regExpEscape = /* @__PURE__ */ __name((s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "regExpEscape");
+    var braExpEscape = /* @__PURE__ */ __name((s) => s.replace(/[[\]\\]/g, "\\$&"), "braExpEscape");
+    var Minimatch2 = class {
+      static {
+        __name(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;
+      }
+      // set partial to true to test if, for example,
+      // "/a/b" matches the start of "/*/b/*/d"
+      // Partial means, if you run out of file before you run
+      // out of pattern, then that's fine, as long as all
+      // the parts match.
+      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 = pattern[pi];
+          var f = file2[fi];
+          this.debug(pattern, p, f);
+          if (p === false) return false;
+          if (p === GLOBSTAR) {
+            this.debug("GLOBSTAR", [pattern, p, 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 === "string") {
+            hit = f === p;
+            this.debug("string match", p, f, hit);
+          } else {
+            hit = f.match(p);
+            this.debug("pattern match", p, 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 = "";
+        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(() => dotTravAllowed ? "" : dotFileAllowed ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)", "patternStart");
+        const subPatternStart = /* @__PURE__ */ __name((p) => p.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)", "subPatternStart");
+        const clearStateChar = /* @__PURE__ */ __name(() => {
+          if (stateChar) {
+            switch (stateChar) {
+              case "*":
+                re += star;
+                hasMagic = true;
+                break;
+              case "?":
+                re += qmark;
+                hasMagic = true;
+                break;
+              default:
+                re += "\\" + stateChar;
+                break;
+            }
+            this.debug("clearStateChar %j %j", stateChar, re);
+            stateChar = false;
+          }
+        }, "clearStateChar");
+        for (let i = 0, c; i < pattern.length && (c = pattern.charAt(i)); i++) {
+          this.debug("%s	%s %s %j", pattern, i, re, c);
+          if (escaping) {
+            if (c === "/") {
+              return false;
+            }
+            if (reSpecials[c]) {
+              re += "\\";
+            }
+            re += c;
+            escaping = false;
+            continue;
+          }
+          switch (c) {
+            /* istanbul ignore next */
+            case "/": {
+              return false;
+            }
+            case "\\":
+              if (inClass && pattern.charAt(i + 1) === "-") {
+                re += c;
+                continue;
+              }
+              clearStateChar();
+              escaping = true;
+              continue;
+            // the various stateChar values
+            // for the "extglob" stuff.
+            case "?":
+            case "*":
+            case "+":
+            case "@":
+            case "!":
+              this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c);
+              if (inClass) {
+                this.debug("  in class");
+                if (c === "!" && i === classStart + 1) c = "^";
+                re += c;
+                continue;
+              }
+              this.debug("call clearStateChar %j", stateChar);
+              clearStateChar();
+              stateChar = c;
+              if (options.noext) clearStateChar();
+              continue;
+            case "(": {
+              if (inClass) {
+                re += "(";
+                continue;
+              }
+              if (!stateChar) {
+                re += "\\(";
+                continue;
+              }
+              const plEntry = {
+                type: stateChar,
+                start: i - 1,
+                reStart: re.length,
+                open: plTypes[stateChar].open,
+                close: plTypes[stateChar].close
+              };
+              this.debug(this.pattern, "	", plEntry);
+              patternListStack.push(plEntry);
+              re += plEntry.open;
+              if (plEntry.start === 0 && plEntry.type !== "!") {
+                dotTravAllowed = true;
+                re += subPatternStart(pattern.slice(i + 1));
+              }
+              this.debug("plType %j %j", stateChar, re);
+              stateChar = false;
+              continue;
+            }
+            case ")": {
+              const plEntry = patternListStack[patternListStack.length - 1];
+              if (inClass || !plEntry) {
+                re += "\\)";
+                continue;
+              }
+              patternListStack.pop();
+              clearStateChar();
+              hasMagic = true;
+              pl = plEntry;
+              re += pl.close;
+              if (pl.type === "!") {
+                negativeLists.push(Object.assign(pl, { reEnd: re.length }));
+              }
+              continue;
+            }
+            case "|": {
+              const plEntry = patternListStack[patternListStack.length - 1];
+              if (inClass || !plEntry) {
+                re += "\\|";
+                continue;
+              }
+              clearStateChar();
+              re += "|";
+              if (plEntry.start === 0 && plEntry.type !== "!") {
+                dotTravAllowed = true;
+                re += subPatternStart(pattern.slice(i + 1));
+              }
+              continue;
+            }
+            // these are mostly the same in regexp and glob
+            case "[":
+              clearStateChar();
+              if (inClass) {
+                re += "\\" + c;
+                continue;
+              }
+              inClass = true;
+              classStart = i;
+              reClassStart = re.length;
+              re += c;
+              continue;
+            case "]":
+              if (i === classStart + 1 || !inClass) {
+                re += "\\" + c;
+                continue;
+              }
+              cs = pattern.substring(classStart + 1, i);
+              try {
+                RegExp("[" + braExpEscape(charUnescape(cs)) + "]");
+                re += c;
+              } catch (er) {
+                re = re.substring(0, reClassStart) + "(?:$.)";
+              }
+              hasMagic = true;
+              inClass = false;
+              continue;
+            default:
+              clearStateChar();
+              if (reSpecials[c] && !(c === "^" && inClass)) {
+                re += "\\";
+              }
+              re += c;
+              break;
+          }
+        }
+        if (inClass) {
+          cs = pattern.slice(classStart + 1);
+          sp = this.parse(cs, SUBPARSE);
+          re = re.substring(0, reClassStart) + "\\[" + sp[0];
+          hasMagic = hasMagic || sp[1];
+        }
+        for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+          let tail;
+          tail = re.slice(pl.reStart + pl.open.length);
+          this.debug("setting tail", re, pl);
+          tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
+            if (!$2) {
+              $2 = "\\";
+            }
+            return $1 + $1 + $2 + "|";
+          });
+          this.debug("tail=%j\n   %s", tail, tail, pl, re);
+          const t2 = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+          hasMagic = true;
+          re = re.slice(0, pl.reStart) + t2 + "\\(" + tail;
+        }
+        clearStateChar();
+        if (escaping) {
+          re += "\\\\";
+        }
+        const addPatternStart = addPatternStartSet[re.charAt(0)];
+        for (let n2 = negativeLists.length - 1; n2 > -1; n2--) {
+          const nl = negativeLists[n2];
+          const nlBefore = re.slice(0, nl.reStart);
+          const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+          let nlAfter = re.slice(nl.reEnd);
+          const nlLast = re.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 = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+        }
+        if (re !== "" && hasMagic) {
+          re = "(?=.)" + re;
+        }
+        if (addPatternStart) {
+          re = patternStart() + re;
+        }
+        if (isSub === SUBPARSE) {
+          return [re, 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 + "$", flags), {
+            _glob: pattern,
+            _src: re
+          });
+        } catch (er) {
+          return 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 = set2.map((pattern) => {
+          pattern = pattern.map(
+            (p) => typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src
+          ).reduce((set3, p) => {
+            if (!(set3[set3.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+              set3.push(p);
+            }
+            return set3;
+          }, []);
+          pattern.forEach((p, i) => {
+            if (p !== 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) => p !== GLOBSTAR).join("/");
+        }).join("|");
+        re = "^(?:" + re + ")$";
+        if (this.negate) re = "^(?!" + re + ").*$";
+        try {
+          this.regexp = new RegExp(re, 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];
+          }
+          const hit = this.matchOne(file2, pattern, partial2);
+          if (hit) {
+            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;
+  }
+});
+
 // src/config/environment.ts
 var ARTIFACTS_EVENT_TYPES = [
   "cf.artifacts.repo.created",
@@ -2625,10 +3415,10 @@ function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
 __name(cloneDef, "cloneDef");
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 __name(getElementAtPath, "getElementAtPath");
 function promiseAllObject(promisesObj) {
@@ -3061,11 +3851,11 @@ function explicitlyAborted(x, startIndex = 0) {
   return false;
 }
 __name(explicitlyAborted, "explicitlyAborted");
-function prefixIssues(path5, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -3230,16 +4020,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 __name(flattenError, "flattenError");
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = /* @__PURE__ */ __name((error52, path5 = []) => {
+  const processError = /* @__PURE__ */ __name((error52, path6 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        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 {
@@ -3267,17 +4057,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 __name(formatError, "formatError");
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = /* @__PURE__ */ __name((error52, path5 = []) => {
+  const processError = /* @__PURE__ */ __name((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]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        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;
@@ -3310,8 +4100,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 __name(treeifyError, "treeifyError");
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  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")
@@ -16367,13 +17157,13 @@ 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) {
+  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}`);
     }
@@ -16945,9 +17735,9 @@ Please add "${field}" to "env.${envName}".`
   return rawEnv[field] ?? defaultValue;
 }
 __name(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;
@@ -21170,7 +21960,6 @@ var validateBindingsHaveUniqueNames = /* @__PURE__ */ __name((diagnostics, confi
     ])
   );
   bindingsGroupedByType["Secret"] = config2.secrets?.required ?? [];
-  bindingsGroupedByType["Container images"] = [CONTAINER_IMAGES_BINDING];
   const bindingsGroupedByName = {};
   for (const bindingType in bindingsGroupedByType) {
     const bindingNames = bindingsGroupedByType[bindingType];
@@ -26730,6 +27519,126 @@ function toUrlPath(filePath) {
 }
 __name(toUrlPath, "toUrlPath");
 
+// src/d1-migrations.ts
+var import_minimatch = __toESM(require_minimatch());
+var DEFAULT_MIGRATIONS_DIR = "./migrations";
+function getD1MigrationFiles(options) {
+  const migrationsDir = normalizeRelativePath(
+    options.migrationsDir ?? DEFAULT_MIGRATIONS_DIR
+  );
+  const migrationsPattern = normalizeRelativePath(
+    options.migrationsPattern ?? `${migrationsDir}/*.sql`
+  );
+  const dirRelativePattern = stripDirPrefix(migrationsPattern, migrationsDir);
+  const walkRoot = path__default.resolve(options.projectPath, migrationsDir);
+  const names = listFilesRelative(
+    walkRoot,
+    new import_minimatch.Minimatch(dirRelativePattern, { dot: false })
+  );
+  return names.map((name) => ({
+    name,
+    filePath: path__default.join(walkRoot, ...name.split("/"))
+  }));
+}
+__name(getD1MigrationFiles, "getD1MigrationFiles");
+function normalizeRelativePath(p) {
+  const forwardSlashed = p.replace(/\\/g, "/");
+  const normalized = path__default.posix.normalize(forwardSlashed);
+  if (normalized.endsWith("/")) {
+    return normalized.slice(0, -1);
+  }
+  return normalized;
+}
+__name(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(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
+          /* partial */
+        )) {
+          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(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 = compareSegments(aSegment, bSegment);
+    if (cmp !== 0) {
+      return cmp;
+    }
+  }
+  return aSegments.length - bSegments.length;
+}
+__name(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(compareSegments, "compareSegments");
+function leadingMigrationNumber(relativePath) {
+  const firstSegment = relativePath.split("/")[0];
+  return parseInt(firstSegment.split("_")[0], 10);
+}
+__name(leadingMigrationNumber, "leadingMigrationNumber");
+
 // src/index.ts
 var friendlyBindingNames2 = friendlyBindingNames;
 /*! Bundled license information:
@@ -26766,4 +27675,4 @@ safe-buffer/index.js:
   (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
 */
 
-export { ARTIFACTS_EVENT_TYPES, BunPackageManager, Diagnostics, LOGGER_LEVELS, NpmPackageManager, NubPackageManager, PatchConfigError, PnpmPackageManager, YarnPackageManager, addAuthorizationHeader, bucketFormatMessage, checkWorkerNameValidity, clearOutputFilePath, convertConfigToBindings, createConfigCache, defaultWranglerConfig, experimental_patchConfig, extractAccountTag, extractBindingsOfType, extractWAFBlockRayId, fetchInternalBase, fetchKVGetValueBase, fetchLatestNpmVersion, fetchListResultBase, fetchResultBase, formatTime, friendlyBindingNames2 as friendlyBindingNames, getBindingLocalSupport, getBindingTypeFriendlyName, getBindings, getHostFromRoute, getHostFromUrl, getInstalledPackageVersion, getPackagePath, getWorkerName, getWorkerNameFromProject, getWranglerHiddenDirPath, getWranglerTmpDir, getZoneFromRoute, hasCursor, hasMorePages, hasProperty, isCI, isDockerfile, isInteractive, isNonInteractiveOrCI, isOptionalProperty, isPackageInstalled, isPagesConfig, isRequiredProperty, isUnsafeBindingType, isValidR2BucketName, isWAFBlockResponse, maybeAddTraceHeader, normalizeAndValidateConfig, openInBrowser, parseRetryAfterMs, parseRetryAfterValue, performApiFetchBase, printBindings, renderError, resolveNamedTunnel, retryOnAPIFailure, spawnCloudflared, startTunnel, sweepStaleWranglerTmpDirs, throwFetchError, toUrlPath, toValidWorkerName, truncate, validateBindingRemoteSetting, validatePagesConfig, writeOutput };
+export { ARTIFACTS_EVENT_TYPES, BunPackageManager, Diagnostics, LOGGER_LEVELS, NpmPackageManager, NubPackageManager, PatchConfigError, PnpmPackageManager, YarnPackageManager, addAuthorizationHeader, bucketFormatMessage, checkWorkerNameValidity, clearOutputFilePath, compareMigrationPaths, convertConfigToBindings, createConfigCache, defaultWranglerConfig, experimental_patchConfig, extractAccountTag, extractBindingsOfType, extractWAFBlockRayId, fetchInternalBase, fetchKVGetValueBase, fetchLatestNpmVersion, fetchListResultBase, fetchResultBase, formatTime, friendlyBindingNames2 as friendlyBindingNames, getBindingLocalSupport, getBindingTypeFriendlyName, getBindings, getD1MigrationFiles, getHostFromRoute, getHostFromUrl, getInstalledPackageVersion, getPackagePath, getWorkerName, getWorkerNameFromProject, getWranglerHiddenDirPath, getWranglerTmpDir, getZoneFromRoute, hasCursor, hasMorePages, hasProperty, isCI, isDockerfile, isInteractive, isNonInteractiveOrCI, isOptionalProperty, isPackageInstalled, isPagesConfig, isRequiredProperty, isUnsafeBindingType, isValidR2BucketName, isWAFBlockResponse, maybeAddTraceHeader, normalizeAndValidateConfig, normalizeRelativePath, openInBrowser, parseRetryAfterMs, parseRetryAfterValue, performApiFetchBase, printBindings, renderError, resolveNamedTunnel, retryOnAPIFailure, spawnCloudflared, startTunnel, sweepStaleWranglerTmpDirs, throwFetchError, toUrlPath, toValidWorkerName, truncate, validateBindingRemoteSetting, validatePagesConfig, writeOutput };