wrangler 4.27.0 → 4.28.0

package/wrangler-dist/cli.js

@@ -26164,10 +26164,10 @@ function isDir(inputPath) {
   const stats = (0, import_fs6.statSync)(inputPath);
   return stats.isDirectory();
 }
-async function getContainerIdsByImageTags(dockerPath, imageTags) {
+function getContainerIdsByImageTags(dockerPath, imageTags) {
   const ids = /* @__PURE__ */ new Set();
   for (const imageTag of imageTags) {
-    const containerIdsFromImage = await getContainerIdsFromImage(
+    const containerIdsFromImage = getContainerIdsFromImage(
       dockerPath,
       imageTag
     );
@@ -26328,27 +26328,20 @@ Other container tooling that is compatible with the Docker CLI and engine may wo
       }
       return false;
     }, "isDockerfile");
-    cleanupContainers = /* @__PURE__ */ __name(async (dockerPath, imageTags) => {
+    cleanupContainers = /* @__PURE__ */ __name((dockerPath, imageTags) => {
       try {
-        const containerIds = await getContainerIdsByImageTags(
-          dockerPath,
-          imageTags
-        );
+        const containerIds = getContainerIdsByImageTags(dockerPath, imageTags);
         if (containerIds.length === 0) {
           return true;
         }
-        await runDockerCmd(
-          dockerPath,
-          ["rm", "--force", ...containerIds],
-          ["inherit", "pipe", "pipe"]
-        );
+        runDockerCmdWithOutput(dockerPath, ["rm", "--force", ...containerIds]);
         return true;
       } catch {
         return false;
       }
     }, "cleanupContainers");
     __name(getContainerIdsByImageTags, "getContainerIdsByImageTags");
-    getContainerIdsFromImage = /* @__PURE__ */ __name(async (dockerPath, ancestorImage) => {
+    getContainerIdsFromImage = /* @__PURE__ */ __name((dockerPath, ancestorImage) => {
       const output = runDockerCmdWithOutput(dockerPath, [
         "ps",
         "-a",
@@ -30835,7 +30828,7 @@ var require_supports_colors = __commonJS({
   "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/supports-colors.js"(exports2, module3) {
     "use strict";
     init_import_meta_url();
-    var os11 = require("os");
+    var os12 = require("os");
     var hasFlag3 = require_has_flag();
     var env6 = process.env;
     var forceColor = void 0;
@@ -30874,7 +30867,7 @@ var require_supports_colors = __commonJS({
       }
       var min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        var osRelease = os11.release().split(".");
+        var osRelease = os12.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -32479,7 +32472,7 @@ var require_OSPaths = __commonJS({
     }
     __name(isEmpty, "isEmpty");
     function Adapt(adapter_) {
-      var env6 = adapter_.env, os11 = adapter_.os, path72 = adapter_.path;
+      var env6 = adapter_.env, os12 = adapter_.os, path72 = adapter_.path;
       var isWinOS = /^win/i.test(adapter_.process.platform);
       function normalizePath2(path_) {
         return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
@@ -32487,11 +32480,11 @@ var require_OSPaths = __commonJS({
       __name(normalizePath2, "normalizePath");
       function home() {
         var posix2 = /* @__PURE__ */ __name(function() {
-          return normalizePath2((typeof os11.homedir === "function" ? os11.homedir() : void 0) || env6.get("HOME"));
+          return normalizePath2((typeof os12.homedir === "function" ? os12.homedir() : void 0) || env6.get("HOME"));
         }, "posix");
         var windows = /* @__PURE__ */ __name(function() {
           var priorityList = [
-            typeof os11.homedir === "function" ? os11.homedir() : void 0,
+            typeof os12.homedir === "function" ? os12.homedir() : void 0,
             env6.get("USERPROFILE"),
             env6.get("HOME"),
             env6.get("HOMEDRIVE") || env6.get("HOMEPATH") ? path72.join(env6.get("HOMEDRIVE") || "", env6.get("HOMEPATH") || "") : void 0
@@ -32511,7 +32504,7 @@ var require_OSPaths = __commonJS({
         function posix2() {
           var fallback = "/tmp";
           var priorityList = [
-            typeof os11.tmpdir === "function" ? os11.tmpdir() : void 0,
+            typeof os12.tmpdir === "function" ? os12.tmpdir() : void 0,
             env6.get("TMPDIR"),
             env6.get("TEMP"),
             env6.get("TMP")
@@ -32524,7 +32517,7 @@ var require_OSPaths = __commonJS({
         function windows() {
           var fallback = "C:\\Temp";
           var priorityListLazy = [
-            typeof os11.tmpdir === "function" ? os11.tmpdir : function() {
+            typeof os12.tmpdir === "function" ? os12.tmpdir : function() {
               return void 0;
             },
             function() {
@@ -32611,7 +32604,7 @@ var require_node = __commonJS({
     };
     exports2.__esModule = true;
     exports2.adapter = void 0;
-    var os11 = __importStar(require("os"));
+    var os12 = __importStar(require("os"));
     var path72 = __importStar(require("path"));
     exports2.adapter = {
       atImportPermissions: { env: true },
@@ -32620,7 +32613,7 @@ var require_node = __commonJS({
           return process.env[s5];
         }, "get")
       },
-      os: os11,
+      os: os12,
       path: path72,
       process
     };
@@ -33483,8 +33476,12 @@ function readFileSyncToBuffer(file) {
 }
 function readFileSync6(file) {
   try {
-    return fs2.readFileSync(file, { encoding: "utf-8" });
+    const buffer = fs2.readFileSync(file);
+    return removeBOMAndValidate(buffer, file);
   } catch (err) {
+    if (err instanceof ParseError) {
+      throw err;
+    }
     const { message } = err;
     throw new ParseError({
       text: `Could not read file: ${file}`,
@@ -33572,7 +33569,28 @@ function parseByteSize(s5, base = void 0) {
     Number(size) * Math.pow(base ?? (binary ? 1024 : 1e3), pow)
   );
 }
-var fs2, import_node_path4, import_toml, import_esbuild2, ParseError, APIError, TOML_ERROR_NAME, TOML_ERROR_SUFFIX, units;
+function removeBOMAndValidate(buffer, file) {
+  for (const bom of UNSUPPORTED_BOMS) {
+    if (buffer.length >= bom.buffer.length && buffer.subarray(0, bom.buffer.length).equals(bom.buffer)) {
+      throw new ParseError({
+        text: `Configuration file contains ${bom.encoding} byte order marker`,
+        notes: [
+          {
+            text: `The file "${file}" appears to be encoded as ${bom.encoding}. Please save the file as UTF-8 without BOM.`
+          }
+        ],
+        location: { file, line: 1, column: 0 },
+        telemetryMessage: `${bom.encoding} BOM detected`
+      });
+    }
+  }
+  const content = buffer.toString("utf-8");
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
+var fs2, import_node_path4, import_toml, import_esbuild2, ParseError, APIError, TOML_ERROR_NAME, TOML_ERROR_SUFFIX, units, UNSUPPORTED_BOMS;
 var init_parse = __esm({
   "src/parse.ts"() {
     init_import_meta_url();
@@ -33683,6 +33701,25 @@ var init_parse = __esm({
     __name(parseHumanDuration, "parseHumanDuration");
     __name(parseNonHyphenedUuid, "parseNonHyphenedUuid");
     __name(parseByteSize, "parseByteSize");
+    UNSUPPORTED_BOMS = [
+      {
+        buffer: Buffer.from([0, 0, 254, 255]),
+        encoding: "UTF-32 BE"
+      },
+      {
+        buffer: Buffer.from([255, 254, 0, 0]),
+        encoding: "UTF-32 LE"
+      },
+      {
+        buffer: Buffer.from([254, 255]),
+        encoding: "UTF-16 BE"
+      },
+      {
+        buffer: Buffer.from([255, 254]),
+        encoding: "UTF-16 LE"
+      }
+    ];
+    __name(removeBOMAndValidate, "removeBOMAndValidate");
   }
 });
 
@@ -33715,7 +33752,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "wrangler";
-    version = "4.27.0";
+    version = "4.28.0";
   }
 });
 
@@ -38419,8 +38456,67 @@ Please add a binding for each to "${fieldPath}.bindings":
       ]);
       return isValid2;
     }, "validateDurableObjectBinding");
-    validateWorkflowBinding = /* @__PURE__ */ __name((_diagnostics, _field, _value) => {
-      return true;
+    validateWorkflowBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+      if (typeof value !== "object" || value === null) {
+        diagnostics.errors.push(
+          `"workflows" bindings should be objects, but got ${JSON.stringify(value)}`
+        );
+        return false;
+      }
+      let isValid2 = true;
+      if (!isRequiredProperty(value, "binding", "string")) {
+        diagnostics.errors.push(
+          `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+            value
+          )}.`
+        );
+        isValid2 = false;
+      }
+      if (!isRequiredProperty(value, "name", "string")) {
+        diagnostics.errors.push(
+          `"${field}" bindings should have a string "name" field but got ${JSON.stringify(
+            value
+          )}.`
+        );
+        isValid2 = false;
+      } else if (value.name.length > 64) {
+        diagnostics.errors.push(
+          `"${field}" binding "name" field must be 64 characters or less, but got ${value.name.length} characters.`
+        );
+        isValid2 = false;
+      }
+      if (!isRequiredProperty(value, "class_name", "string")) {
+        diagnostics.errors.push(
+          `"${field}" bindings should have a string "class_name" field but got ${JSON.stringify(
+            value
+          )}.`
+        );
+        isValid2 = false;
+      }
+      if (!isOptionalProperty(value, "script_name", "string")) {
+        diagnostics.errors.push(
+          `"${field}" bindings should, optionally, have a string "script_name" field but got ${JSON.stringify(
+            value
+          )}.`
+        );
+        isValid2 = false;
+      }
+      if (!isOptionalProperty(value, "experimental_remote", "boolean")) {
+        diagnostics.errors.push(
+          `"${field}" bindings should, optionally, have a boolean "experimental_remote" field but got ${JSON.stringify(
+            value
+          )}.`
+        );
+        isValid2 = false;
+      }
+      validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+        "binding",
+        "name",
+        "class_name",
+        "script_name",
+        "experimental_remote"
+      ]);
+      return isValid2;
     }, "validateWorkflowBinding");
     validateCflogfwdrObject = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, topLevelEnv) => {
       const bindingsValidation = validateBindingsProperty(
@@ -41539,6 +41635,81 @@ var init_streams = __esm({
   }
 });
 
+// ../cli/check-macos-version.ts
+function checkMacOSVersion(options) {
+  if (process.platform !== "darwin") {
+    return;
+  }
+  if (process.env.CI) {
+    return;
+  }
+  const release3 = import_node_os3.default.release();
+  const macOSVersion = darwinVersionToMacOSVersion(release3);
+  if (macOSVersion && isVersionLessThan(macOSVersion, MINIMUM_MACOS_VERSION)) {
+    if (options.shouldThrow) {
+      throw new Error(
+        `Unsupported macOS version: The Cloudflare Workers runtime cannot run on the current version of macOS (${macOSVersion}). The minimum requirement is macOS ${MINIMUM_MACOS_VERSION}+. See https://github.com/cloudflare/workerd?tab=readme-ov-file#running-workerd If you cannot upgrade your version of macOS, you could try running in a DevContainer setup with a supported version of Linux (glibc 2.35+ required).`
+      );
+    } else {
+      console.warn(
+        `\u26A0\uFE0F  Warning: Unsupported macOS version detected (${macOSVersion}). The Cloudflare Workers runtime may not work correctly on macOS versions below ${MINIMUM_MACOS_VERSION}. Consider upgrading to macOS ${MINIMUM_MACOS_VERSION}+ or using a DevContainer setup with a supported version of Linux (glibc 2.35+ required).`
+      );
+    }
+  }
+}
+function darwinVersionToMacOSVersion(darwinVersion) {
+  const match2 = darwinVersion.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match2) {
+    return null;
+  }
+  const major = parseInt(match2[1], 10);
+  if (major >= 20) {
+    const macOSMajor = major - 9;
+    const minor = parseInt(match2[2], 10);
+    const patch = parseInt(match2[3], 10);
+    return `${macOSMajor}.${minor}.${patch}`;
+  }
+  return null;
+}
+function isVersionLessThan(version1, version22) {
+  const versionRegex = /^(\d+)\.(\d+)\.(\d+)$/;
+  const match1 = version1.match(versionRegex);
+  const match2 = version22.match(versionRegex);
+  if (!match1 || !match2) {
+    throw new Error(
+      `Invalid version format. Expected M.m.p format, got: ${version1}, ${version22}`
+    );
+  }
+  const [major1, minor1, patch1] = [
+    parseInt(match1[1], 10),
+    parseInt(match1[2], 10),
+    parseInt(match1[3], 10)
+  ];
+  const [major2, minor2, patch2] = [
+    parseInt(match2[1], 10),
+    parseInt(match2[2], 10),
+    parseInt(match2[3], 10)
+  ];
+  if (major1 !== major2) {
+    return major1 < major2;
+  }
+  if (minor1 !== minor2) {
+    return minor1 < minor2;
+  }
+  return patch1 < patch2;
+}
+var import_node_os3, MINIMUM_MACOS_VERSION;
+var init_check_macos_version = __esm({
+  "../cli/check-macos-version.ts"() {
+    init_import_meta_url();
+    import_node_os3 = __toESM(require("os"));
+    MINIMUM_MACOS_VERSION = "13.5.0";
+    __name(checkMacOSVersion, "checkMacOSVersion");
+    __name(darwinVersionToMacOSVersion, "darwinVersionToMacOSVersion");
+    __name(isVersionLessThan, "isVersionLessThan");
+  }
+});
+
 // ../cli/index.ts
 var import_process, shapes, status, space, logRaw, log, newline, format6, updateStatus, startSection, endSection, cancel, warn, success, stripAnsi3, linkRegex, crash, error;
 var init_cli = __esm({
@@ -41547,6 +41718,7 @@ var init_cli = __esm({
     import_process = require("process");
     init_colors();
     init_streams();
+    init_check_macos_version();
     shapes = {
       diamond: "\u25C7",
       dash: "\u2500",
@@ -47920,14 +48092,14 @@ var require_is_wsl = __commonJS({
   "../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports2, module3) {
     "use strict";
     init_import_meta_url();
-    var os11 = require("os");
+    var os12 = require("os");
     var fs24 = require("fs");
     var isDocker = require_is_docker();
     var isWsl = /* @__PURE__ */ __name(() => {
       if (process.platform !== "linux") {
         return false;
       }
-      if (os11.release().toLowerCase().includes("microsoft")) {
+      if (os12.release().toLowerCase().includes("microsoft")) {
         if (isDocker()) {
           return false;
         }
@@ -49786,8 +49958,8 @@ var require_homedir = __commonJS({
   "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/homedir.js"(exports2, module3) {
     "use strict";
     init_import_meta_url();
-    var os11 = require("os");
-    module3.exports = os11.homedir || /* @__PURE__ */ __name(function homedir3() {
+    var os12 = require("os");
+    module3.exports = os12.homedir || /* @__PURE__ */ __name(function homedir3() {
       var home = process.env.HOME;
       var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
       if (process.platform === "win32") {
@@ -51840,6 +52012,1148 @@ export default function (env) {
   }
 });
 
+// ../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js
+var require_ini = __commonJS({
+  "../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js"(exports2) {
+    init_import_meta_url();
+    exports2.parse = exports2.decode = decode;
+    exports2.stringify = exports2.encode = encode;
+    exports2.safe = safe;
+    exports2.unsafe = unsafe;
+    var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
+    function encode(obj, opt) {
+      var children = [];
+      var out = "";
+      if (typeof opt === "string") {
+        opt = {
+          section: opt,
+          whitespace: false
+        };
+      } else {
+        opt = opt || {};
+        opt.whitespace = opt.whitespace === true;
+      }
+      var separator = opt.whitespace ? " = " : "=";
+      Object.keys(obj).forEach(function(k6, _4, __) {
+        var val2 = obj[k6];
+        if (val2 && Array.isArray(val2)) {
+          val2.forEach(function(item) {
+            out += safe(k6 + "[]") + separator + safe(item) + "\n";
+          });
+        } else if (val2 && typeof val2 === "object")
+          children.push(k6);
+        else
+          out += safe(k6) + separator + safe(val2) + eol;
+      });
+      if (opt.section && out.length)
+        out = "[" + safe(opt.section) + "]" + eol + out;
+      children.forEach(function(k6, _4, __) {
+        var nk = dotSplit(k6).join("\\.");
+        var section = (opt.section ? opt.section + "." : "") + nk;
+        var child = encode(obj[k6], {
+          section,
+          whitespace: opt.whitespace
+        });
+        if (out.length && child.length)
+          out += eol;
+        out += child;
+      });
+      return out;
+    }
+    __name(encode, "encode");
+    function dotSplit(str) {
+      return str.replace(/\1/g, "LITERAL\\1LITERAL").replace(/\\\./g, "
").split(/\./).map(function(part) {
+        return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "
");
+      });
+    }
+    __name(dotSplit, "dotSplit");
+    function decode(str) {
+      var out = {};
+      var p6 = out;
+      var section = null;
+      var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+      var lines = str.split(/[\r\n]+/g);
+      lines.forEach(function(line, _4, __) {
+        if (!line || line.match(/^\s*[;#]/))
+          return;
+        var match2 = line.match(re);
+        if (!match2)
+          return;
+        if (match2[1] !== void 0) {
+          section = unsafe(match2[1]);
+          if (section === "__proto__") {
+            p6 = {};
+            return;
+          }
+          p6 = out[section] = out[section] || {};
+          return;
+        }
+        var key = unsafe(match2[2]);
+        if (key === "__proto__")
+          return;
+        var value = match2[3] ? unsafe(match2[4]) : true;
+        switch (value) {
+          case "true":
+          case "false":
+          case "null":
+            value = JSON.parse(value);
+        }
+        if (key.length > 2 && key.slice(-2) === "[]") {
+          key = key.substring(0, key.length - 2);
+          if (key === "__proto__")
+            return;
+          if (!p6[key])
+            p6[key] = [];
+          else if (!Array.isArray(p6[key]))
+            p6[key] = [p6[key]];
+        }
+        if (Array.isArray(p6[key]))
+          p6[key].push(value);
+        else
+          p6[key] = value;
+      });
+      Object.keys(out).filter(function(k6, _4, __) {
+        if (!out[k6] || typeof out[k6] !== "object" || Array.isArray(out[k6]))
+          return false;
+        var parts = dotSplit(k6);
+        var p7 = out;
+        var l6 = parts.pop();
+        var nl = l6.replace(/\\\./g, ".");
+        parts.forEach(function(part, _5, __2) {
+          if (part === "__proto__")
+            return;
+          if (!p7[part] || typeof p7[part] !== "object")
+            p7[part] = {};
+          p7 = p7[part];
+        });
+        if (p7 === out && nl === l6)
+          return false;
+        p7[nl] = out[k6];
+        return true;
+      }).forEach(function(del, _4, __) {
+        delete out[del];
+      });
+      return out;
+    }
+    __name(decode, "decode");
+    function isQuoted(val2) {
+      return val2.charAt(0) === '"' && val2.slice(-1) === '"' || val2.charAt(0) === "'" && val2.slice(-1) === "'";
+    }
+    __name(isQuoted, "isQuoted");
+    function safe(val2) {
+      return typeof val2 !== "string" || val2.match(/[=\r\n]/) || val2.match(/^\[/) || val2.length > 1 && isQuoted(val2) || val2 !== val2.trim() ? JSON.stringify(val2) : val2.replace(/;/g, "\\;").replace(/#/g, "\\#");
+    }
+    __name(safe, "safe");
+    function unsafe(val2, doUnesc) {
+      val2 = (val2 || "").trim();
+      if (isQuoted(val2)) {
+        if (val2.charAt(0) === "'")
+          val2 = val2.substr(1, val2.length - 2);
+        try {
+          val2 = JSON.parse(val2);
+        } catch (_4) {
+        }
+      } else {
+        var esc = false;
+        var unesc = "";
+        for (var i5 = 0, l6 = val2.length; i5 < l6; i5++) {
+          var c6 = val2.charAt(i5);
+          if (esc) {
+            if ("\\;#".indexOf(c6) !== -1)
+              unesc += c6;
+            else
+              unesc += "\\" + c6;
+            esc = false;
+          } else if (";#".indexOf(c6) !== -1)
+            break;
+          else if (c6 === "\\")
+            esc = true;
+          else
+            unesc += c6;
+        }
+        if (esc)
+          unesc += "\\";
+        return unesc.trim();
+      }
+      return val2;
+    }
+    __name(unsafe, "unsafe");
+  }
+});
+
+// ../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+  "../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js"(exports2, module3) {
+    "use strict";
+    init_import_meta_url();
+    var singleComment = 1;
+    var multiComment = 2;
+    function stripWithoutWhitespace() {
+      return "";
+    }
+    __name(stripWithoutWhitespace, "stripWithoutWhitespace");
+    function stripWithWhitespace(str, start, end) {
+      return str.slice(start, end).replace(/\S/g, " ");
+    }
+    __name(stripWithWhitespace, "stripWithWhitespace");
+    module3.exports = function(str, opts) {
+      opts = opts || {};
+      var currentChar;
+      var nextChar;
+      var insideString = false;
+      var insideComment = false;
+      var offset = 0;
+      var ret = "";
+      var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+      for (var i5 = 0; i5 < str.length; i5++) {
+        currentChar = str[i5];
+        nextChar = str[i5 + 1];
+        if (!insideComment && currentChar === '"') {
+          var escaped = str[i5 - 1] === "\\" && str[i5 - 2] !== "\\";
+          if (!escaped) {
+            insideString = !insideString;
+          }
+        }
+        if (insideString) {
+          continue;
+        }
+        if (!insideComment && currentChar + nextChar === "//") {
+          ret += str.slice(offset, i5);
+          offset = i5;
+          insideComment = singleComment;
+          i5++;
+        } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
+          i5++;
+          insideComment = false;
+          ret += strip(str, offset, i5);
+          offset = i5;
+          continue;
+        } else if (insideComment === singleComment && currentChar === "\n") {
+          insideComment = false;
+          ret += strip(str, offset, i5);
+          offset = i5;
+        } else if (!insideComment && currentChar + nextChar === "/*") {
+          ret += str.slice(offset, i5);
+          offset = i5;
+          insideComment = multiComment;
+          i5++;
+          continue;
+        } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
+          i5++;
+          insideComment = false;
+          ret += strip(str, offset, i5 + 1);
+          offset = i5 + 1;
+          continue;
+        }
+      }
+      return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js
+var require_utils3 = __commonJS({
+  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports2) {
+    "use strict";
+    init_import_meta_url();
+    var fs24 = require("fs");
+    var ini = require_ini();
+    var path72 = require("path");
+    var stripJsonComments = require_strip_json_comments();
+    var parse7 = exports2.parse = function(content) {
+      if (/^\s*{/.test(content))
+        return JSON.parse(stripJsonComments(content));
+      return ini.parse(content);
+    };
+    var file = exports2.file = function() {
+      var args = [].slice.call(arguments).filter(function(arg) {
+        return arg != null;
+      });
+      for (var i5 in args)
+        if ("string" !== typeof args[i5])
+          return;
+      var file2 = path72.join.apply(null, args);
+      var content;
+      try {
+        return fs24.readFileSync(file2, "utf-8");
+      } catch (err) {
+        return;
+      }
+    };
+    var json = exports2.json = function() {
+      var content = file.apply(null, arguments);
+      return content ? parse7(content) : null;
+    };
+    var env6 = exports2.env = function(prefix, env7) {
+      env7 = env7 || process.env;
+      var obj = {};
+      var l6 = prefix.length;
+      for (var k6 in env7) {
+        if (k6.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
+          var keypath = k6.substring(l6).split("__");
+          var _emptyStringIndex;
+          while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
+            keypath.splice(_emptyStringIndex, 1);
+          }
+          var cursor = obj;
+          keypath.forEach(/* @__PURE__ */ __name(function _buildSubObj(_subkey, i5) {
+            if (!_subkey || typeof cursor !== "object")
+              return;
+            if (i5 === keypath.length - 1)
+              cursor[_subkey] = env7[k6];
+            if (cursor[_subkey] === void 0)
+              cursor[_subkey] = {};
+            cursor = cursor[_subkey];
+          }, "_buildSubObj"));
+        }
+      }
+      return obj;
+    };
+    var find = exports2.find = function() {
+      var rel = path72.join.apply(null, [].slice.call(arguments));
+      function find2(start, rel2) {
+        var file2 = path72.join(start, rel2);
+        try {
+          fs24.statSync(file2);
+          return file2;
+        } catch (err) {
+          if (path72.dirname(start) !== start)
+            return find2(path72.dirname(start), rel2);
+        }
+      }
+      __name(find2, "find");
+      return find2(process.cwd(), rel);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js
+var require_deep_extend = __commonJS({
+  "../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js"(exports2, module3) {
+    "use strict";
+    init_import_meta_url();
+    function isSpecificValue(val2) {
+      return val2 instanceof Buffer || val2 instanceof Date || val2 instanceof RegExp ? true : false;
+    }
+    __name(isSpecificValue, "isSpecificValue");
+    function cloneSpecificValue(val2) {
+      if (val2 instanceof Buffer) {
+        var x6 = Buffer.alloc ? Buffer.alloc(val2.length) : new Buffer(val2.length);
+        val2.copy(x6);
+        return x6;
+      } else if (val2 instanceof Date) {
+        return new Date(val2.getTime());
+      } else if (val2 instanceof RegExp) {
+        return new RegExp(val2);
+      } else {
+        throw new Error("Unexpected situation");
+      }
+    }
+    __name(cloneSpecificValue, "cloneSpecificValue");
+    function deepCloneArray(arr) {
+      var clone = [];
+      arr.forEach(function(item, index) {
+        if (typeof item === "object" && item !== null) {
+          if (Array.isArray(item)) {
+            clone[index] = deepCloneArray(item);
+          } else if (isSpecificValue(item)) {
+            clone[index] = cloneSpecificValue(item);
+          } else {
+            clone[index] = deepExtend({}, item);
+          }
+        } else {
+          clone[index] = item;
+        }
+      });
+      return clone;
+    }
+    __name(deepCloneArray, "deepCloneArray");
+    function safeGetProperty(object, property) {
+      return property === "__proto__" ? void 0 : object[property];
+    }
+    __name(safeGetProperty, "safeGetProperty");
+    var deepExtend = module3.exports = function() {
+      if (arguments.length < 1 || typeof arguments[0] !== "object") {
+        return false;
+      }
+      if (arguments.length < 2) {
+        return arguments[0];
+      }
+      var target = arguments[0];
+      var args = Array.prototype.slice.call(arguments, 1);
+      var val2, src, clone;
+      args.forEach(function(obj) {
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+          return;
+        }
+        Object.keys(obj).forEach(function(key) {
+          src = safeGetProperty(target, key);
+          val2 = safeGetProperty(obj, key);
+          if (val2 === target) {
+            return;
+          } else if (typeof val2 !== "object" || val2 === null) {
+            target[key] = val2;
+            return;
+          } else if (Array.isArray(val2)) {
+            target[key] = deepCloneArray(val2);
+            return;
+          } else if (isSpecificValue(val2)) {
+            target[key] = cloneSpecificValue(val2);
+            return;
+          } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
+            target[key] = deepExtend({}, val2);
+            return;
+          } else {
+            target[key] = deepExtend(src, val2);
+            return;
+          }
+        });
+      });
+      return target;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js
+var require_minimist = __commonJS({
+  "../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js"(exports2, module3) {
+    init_import_meta_url();
+    module3.exports = function(args, opts) {
+      if (!opts) opts = {};
+      var flags2 = { bools: {}, strings: {}, unknownFn: null };
+      if (typeof opts["unknown"] === "function") {
+        flags2.unknownFn = opts["unknown"];
+      }
+      if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
+        flags2.allBools = true;
+      } else {
+        [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
+          flags2.bools[key2] = true;
+        });
+      }
+      var aliases2 = {};
+      Object.keys(opts.alias || {}).forEach(function(key2) {
+        aliases2[key2] = [].concat(opts.alias[key2]);
+        aliases2[key2].forEach(function(x6) {
+          aliases2[x6] = [key2].concat(aliases2[key2].filter(function(y4) {
+            return x6 !== y4;
+          }));
+        });
+      });
+      [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+        flags2.strings[key2] = true;
+        if (aliases2[key2]) {
+          flags2.strings[aliases2[key2]] = true;
+        }
+      });
+      var defaults = opts["default"] || {};
+      var argv = { _: [] };
+      Object.keys(flags2.bools).forEach(function(key2) {
+        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
+      });
+      var notFlags = [];
+      if (args.indexOf("--") !== -1) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+      }
+      function argDefined(key2, arg2) {
+        return flags2.allBools && /^--[^=]+$/.test(arg2) || flags2.strings[key2] || flags2.bools[key2] || aliases2[key2];
+      }
+      __name(argDefined, "argDefined");
+      function setArg(key2, val2, arg2) {
+        if (arg2 && flags2.unknownFn && !argDefined(key2, arg2)) {
+          if (flags2.unknownFn(arg2) === false) return;
+        }
+        var value2 = !flags2.strings[key2] && isNumber(val2) ? Number(val2) : val2;
+        setKey(argv, key2.split("."), value2);
+        (aliases2[key2] || []).forEach(function(x6) {
+          setKey(argv, x6.split("."), value2);
+        });
+      }
+      __name(setArg, "setArg");
+      function setKey(obj, keys, value2) {
+        var o5 = obj;
+        for (var i6 = 0; i6 < keys.length - 1; i6++) {
+          var key2 = keys[i6];
+          if (isConstructorOrProto(o5, key2)) return;
+          if (o5[key2] === void 0) o5[key2] = {};
+          if (o5[key2] === Object.prototype || o5[key2] === Number.prototype || o5[key2] === String.prototype) o5[key2] = {};
+          if (o5[key2] === Array.prototype) o5[key2] = [];
+          o5 = o5[key2];
+        }
+        var key2 = keys[keys.length - 1];
+        if (isConstructorOrProto(o5, key2)) return;
+        if (o5 === Object.prototype || o5 === Number.prototype || o5 === String.prototype) o5 = {};
+        if (o5 === Array.prototype) o5 = [];
+        if (o5[key2] === void 0 || flags2.bools[key2] || typeof o5[key2] === "boolean") {
+          o5[key2] = value2;
+        } else if (Array.isArray(o5[key2])) {
+          o5[key2].push(value2);
+        } else {
+          o5[key2] = [o5[key2], value2];
+        }
+      }
+      __name(setKey, "setKey");
+      function aliasIsBoolean(key2) {
+        return aliases2[key2].some(function(x6) {
+          return flags2.bools[x6];
+        });
+      }
+      __name(aliasIsBoolean, "aliasIsBoolean");
+      for (var i5 = 0; i5 < args.length; i5++) {
+        var arg = args[i5];
+        if (/^--.+=/.test(arg)) {
+          var m6 = arg.match(/^--([^=]+)=([\s\S]*)$/);
+          var key = m6[1];
+          var value = m6[2];
+          if (flags2.bools[key]) {
+            value = value !== "false";
+          }
+          setArg(key, value, arg);
+        } else if (/^--no-.+/.test(arg)) {
+          var key = arg.match(/^--no-(.+)/)[1];
+          setArg(key, false, arg);
+        } else if (/^--.+/.test(arg)) {
+          var key = arg.match(/^--(.+)/)[1];
+          var next = args[i5 + 1];
+          if (next !== void 0 && !/^-/.test(next) && !flags2.bools[key] && !flags2.allBools && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
+            setArg(key, next, arg);
+            i5++;
+          } else if (/^(true|false)$/.test(next)) {
+            setArg(key, next === "true", arg);
+            i5++;
+          } else {
+            setArg(key, flags2.strings[key] ? "" : true, arg);
+          }
+        } else if (/^-[^-]+/.test(arg)) {
+          var letters = arg.slice(1, -1).split("");
+          var broken = false;
+          for (var j6 = 0; j6 < letters.length; j6++) {
+            var next = arg.slice(j6 + 2);
+            if (next === "-") {
+              setArg(letters[j6], next, arg);
+              continue;
+            }
+            if (/[A-Za-z]/.test(letters[j6]) && /=/.test(next)) {
+              setArg(letters[j6], next.split("=")[1], arg);
+              broken = true;
+              break;
+            }
+            if (/[A-Za-z]/.test(letters[j6]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+              setArg(letters[j6], next, arg);
+              broken = true;
+              break;
+            }
+            if (letters[j6 + 1] && letters[j6 + 1].match(/\W/)) {
+              setArg(letters[j6], arg.slice(j6 + 2), arg);
+              broken = true;
+              break;
+            } else {
+              setArg(letters[j6], flags2.strings[letters[j6]] ? "" : true, arg);
+            }
+          }
+          var key = arg.slice(-1)[0];
+          if (!broken && key !== "-") {
+            if (args[i5 + 1] && !/^(-|--)[^-]/.test(args[i5 + 1]) && !flags2.bools[key] && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
+              setArg(key, args[i5 + 1], arg);
+              i5++;
+            } else if (args[i5 + 1] && /^(true|false)$/.test(args[i5 + 1])) {
+              setArg(key, args[i5 + 1] === "true", arg);
+              i5++;
+            } else {
+              setArg(key, flags2.strings[key] ? "" : true, arg);
+            }
+          }
+        } else {
+          if (!flags2.unknownFn || flags2.unknownFn(arg) !== false) {
+            argv._.push(
+              flags2.strings["_"] || !isNumber(arg) ? arg : Number(arg)
+            );
+          }
+          if (opts.stopEarly) {
+            argv._.push.apply(argv._, args.slice(i5 + 1));
+            break;
+          }
+        }
+      }
+      Object.keys(defaults).forEach(function(key2) {
+        if (!hasKey2(argv, key2.split("."))) {
+          setKey(argv, key2.split("."), defaults[key2]);
+          (aliases2[key2] || []).forEach(function(x6) {
+            setKey(argv, x6.split("."), defaults[key2]);
+          });
+        }
+      });
+      if (opts["--"]) {
+        argv["--"] = new Array();
+        notFlags.forEach(function(key2) {
+          argv["--"].push(key2);
+        });
+      } else {
+        notFlags.forEach(function(key2) {
+          argv._.push(key2);
+        });
+      }
+      return argv;
+    };
+    function hasKey2(obj, keys) {
+      var o5 = obj;
+      keys.slice(0, -1).forEach(function(key2) {
+        o5 = o5[key2] || {};
+      });
+      var key = keys[keys.length - 1];
+      return key in o5;
+    }
+    __name(hasKey2, "hasKey");
+    function isNumber(x6) {
+      if (typeof x6 === "number") return true;
+      if (/^0x[0-9a-f]+$/i.test(x6)) return true;
+      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x6);
+    }
+    __name(isNumber, "isNumber");
+    function isConstructorOrProto(obj, key) {
+      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+    }
+    __name(isConstructorOrProto, "isConstructorOrProto");
+  }
+});
+
+// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js
+var require_rc = __commonJS({
+  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports2, module3) {
+    init_import_meta_url();
+    var cc2 = require_utils3();
+    var join24 = require("path").join;
+    var deepExtend = require_deep_extend();
+    var etc = "/etc";
+    var win = process.platform === "win32";
+    var home = win ? process.env.USERPROFILE : process.env.HOME;
+    module3.exports = function(name2, defaults, argv, parse7) {
+      if ("string" !== typeof name2)
+        throw new Error("rc(name): name *must* be string");
+      if (!argv)
+        argv = require_minimist()(process.argv.slice(2));
+      defaults = ("string" === typeof defaults ? cc2.json(defaults) : defaults) || {};
+      parse7 = parse7 || cc2.parse;
+      var env6 = cc2.env(name2 + "_");
+      var configs = [defaults];
+      var configFiles = [];
+      function addConfigFile(file) {
+        if (configFiles.indexOf(file) >= 0) return;
+        var fileConfig = cc2.file(file);
+        if (fileConfig) {
+          configs.push(parse7(fileConfig));
+          configFiles.push(file);
+        }
+      }
+      __name(addConfigFile, "addConfigFile");
+      if (!win)
+        [
+          join24(etc, name2, "config"),
+          join24(etc, name2 + "rc")
+        ].forEach(addConfigFile);
+      if (home)
+        [
+          join24(home, ".config", name2, "config"),
+          join24(home, ".config", name2),
+          join24(home, "." + name2, "config"),
+          join24(home, "." + name2 + "rc")
+        ].forEach(addConfigFile);
+      addConfigFile(cc2.find("." + name2 + "rc"));
+      if (env6.config) addConfigFile(env6.config);
+      if (argv.config) addConfigFile(argv.config);
+      return deepExtend.apply(null, configs.concat([
+        env6,
+        argv,
+        configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
+      ]));
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js
+var require_registry_url = __commonJS({
+  "../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js"(exports2, module3) {
+    "use strict";
+    init_import_meta_url();
+    module3.exports = function(scope) {
+      var rc = require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      var url4 = rc[scope + ":registry"] || rc.registry;
+      return url4.slice(-1) === "/" ? url4 : url4 + "/";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
+var require_safe_buffer = __commonJS({
+  "../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports2, module3) {
+    init_import_meta_url();
+    var buffer = require("buffer");
+    var Buffer7 = buffer.Buffer;
+    function copyProps(src, dst) {
+      for (var key in src) {
+        dst[key] = src[key];
+      }
+    }
+    __name(copyProps, "copyProps");
+    if (Buffer7.from && Buffer7.alloc && Buffer7.allocUnsafe && Buffer7.allocUnsafeSlow) {
+      module3.exports = buffer;
+    } else {
+      copyProps(buffer, exports2);
+      exports2.Buffer = SafeBuffer;
+    }
+    function SafeBuffer(arg, encodingOrOffset, length) {
+      return Buffer7(arg, encodingOrOffset, length);
+    }
+    __name(SafeBuffer, "SafeBuffer");
+    SafeBuffer.prototype = Object.create(Buffer7.prototype);
+    copyProps(Buffer7, SafeBuffer);
+    SafeBuffer.from = function(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        throw new TypeError("Argument must not be a number");
+      }
+      return Buffer7(arg, encodingOrOffset, length);
+    };
+    SafeBuffer.alloc = function(size, fill2, encoding) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      var buf = Buffer7(size);
+      if (fill2 !== void 0) {
+        if (typeof encoding === "string") {
+          buf.fill(fill2, encoding);
+        } else {
+          buf.fill(fill2);
+        }
+      } else {
+        buf.fill(0);
+      }
+      return buf;
+    };
+    SafeBuffer.allocUnsafe = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return Buffer7(size);
+    };
+    SafeBuffer.allocUnsafeSlow = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return buffer.SlowBuffer(size);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js
+var require_base64 = __commonJS({
+  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js"(exports2, module3) {
+    init_import_meta_url();
+    var safeBuffer = require_safe_buffer().Buffer;
+    function decodeBase64(base642) {
+      return safeBuffer.from(base642, "base64").toString("utf8");
+    }
+    __name(decodeBase64, "decodeBase64");
+    function encodeBase64(string) {
+      return safeBuffer.from(string, "utf8").toString("base64");
+    }
+    __name(encodeBase64, "encodeBase64");
+    module3.exports = {
+      decodeBase64,
+      encodeBase64
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js
+var require_registry_auth_token = __commonJS({
+  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js"(exports2, module3) {
+    init_import_meta_url();
+    var url4 = require("url");
+    var base642 = require_base64();
+    var decodeBase64 = base642.decodeBase64;
+    var encodeBase64 = base642.encodeBase64;
+    var tokenKey = ":_authToken";
+    var userKey = ":username";
+    var passwordKey = ":_password";
+    module3.exports = function() {
+      var checkUrl2;
+      var options;
+      if (arguments.length >= 2) {
+        checkUrl2 = arguments[0];
+        options = arguments[1];
+      } else if (typeof arguments[0] === "string") {
+        checkUrl2 = arguments[0];
+      } else {
+        options = arguments[0];
+      }
+      options = options || {};
+      options.npmrc = options.npmrc || require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      checkUrl2 = checkUrl2 || options.npmrc.registry;
+      return getRegistryAuthInfo(checkUrl2, options) || getLegacyAuthInfo(options.npmrc);
+    };
+    function getRegistryAuthInfo(checkUrl2, options) {
+      var parsed = url4.parse(checkUrl2, false, true);
+      var pathname;
+      while (pathname !== "/" && parsed.pathname !== pathname) {
+        pathname = parsed.pathname || "/";
+        var regUrl = "//" + parsed.host + pathname.replace(/\/$/, "");
+        var authInfo = getAuthInfoForUrl(regUrl, options.npmrc);
+        if (authInfo) {
+          return authInfo;
+        }
+        if (!options.recursive) {
+          return /\/$/.test(checkUrl2) ? void 0 : getRegistryAuthInfo(url4.resolve(checkUrl2, "."), options);
+        }
+        parsed.pathname = url4.resolve(normalizePath2(pathname), "..") || "/";
+      }
+      return void 0;
+    }
+    __name(getRegistryAuthInfo, "getRegistryAuthInfo");
+    function getLegacyAuthInfo(npmrc) {
+      if (npmrc._auth) {
+        return { token: npmrc._auth, type: "Basic" };
+      }
+      return void 0;
+    }
+    __name(getLegacyAuthInfo, "getLegacyAuthInfo");
+    function normalizePath2(path72) {
+      return path72[path72.length - 1] === "/" ? path72 : path72 + "/";
+    }
+    __name(normalizePath2, "normalizePath");
+    function getAuthInfoForUrl(regUrl, npmrc) {
+      var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + "/" + tokenKey]);
+      if (bearerAuth) {
+        return bearerAuth;
+      }
+      var username = npmrc[regUrl + userKey] || npmrc[regUrl + "/" + userKey];
+      var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + "/" + passwordKey];
+      var basicAuth = getTokenForUsernameAndPassword(username, password);
+      if (basicAuth) {
+        return basicAuth;
+      }
+      return void 0;
+    }
+    __name(getAuthInfoForUrl, "getAuthInfoForUrl");
+    function getBearerToken(tok) {
+      if (!tok) {
+        return void 0;
+      }
+      var token = tok.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      });
+      return { token, type: "Bearer" };
+    }
+    __name(getBearerToken, "getBearerToken");
+    function getTokenForUsernameAndPassword(username, password) {
+      if (!username || !password) {
+        return void 0;
+      }
+      var pass2 = decodeBase64(password.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      }));
+      var token = encodeBase64(username + ":" + pass2);
+      return {
+        token,
+        type: "Basic",
+        password: pass2,
+        username
+      };
+    }
+    __name(getTokenForUsernameAndPassword, "getTokenForUsernameAndPassword");
+  }
+});
+
+// ../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js
+var require_update_check = __commonJS({
+  "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports2, module3) {
+    init_import_meta_url();
+    var { URL: URL7 } = require("url");
+    var { join: join24 } = require("path");
+    var fs24 = require("fs");
+    var { promisify: promisify3 } = require("util");
+    var { tmpdir } = require("os");
+    var registryUrl = require_registry_url();
+    var writeFile11 = promisify3(fs24.writeFile);
+    var mkdir6 = promisify3(fs24.mkdir);
+    var readFile18 = promisify3(fs24.readFile);
+    var compareVersions = /* @__PURE__ */ __name((a5, b6) => a5.localeCompare(b6, "en-US", { numeric: true }), "compareVersions");
+    var encode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
+    var getFile = /* @__PURE__ */ __name(async (details, distTag) => {
+      const rootDir = tmpdir();
+      const subDir = join24(rootDir, "update-check");
+      if (!fs24.existsSync(subDir)) {
+        await mkdir6(subDir);
+      }
+      let name2 = `${details.name}-${distTag}.json`;
+      if (details.scope) {
+        name2 = `${details.scope}-${name2}`;
+      }
+      return join24(subDir, name2);
+    }, "getFile");
+    var evaluateCache = /* @__PURE__ */ __name(async (file, time, interval) => {
+      if (fs24.existsSync(file)) {
+        const content = await readFile18(file, "utf8");
+        const { lastUpdate, latest } = JSON.parse(content);
+        const nextCheck = lastUpdate + interval;
+        if (nextCheck > time) {
+          return {
+            shouldCheck: false,
+            latest
+          };
+        }
+      }
+      return {
+        shouldCheck: true,
+        latest: null
+      };
+    }, "evaluateCache");
+    var updateCache = /* @__PURE__ */ __name(async (file, latest, lastUpdate) => {
+      const content = JSON.stringify({
+        latest,
+        lastUpdate
+      });
+      await writeFile11(file, content, "utf8");
+    }, "updateCache");
+    var loadPackage = /* @__PURE__ */ __name((url4, authInfo) => new Promise((resolve25, reject) => {
+      const options = {
+        host: url4.hostname,
+        path: url4.pathname,
+        port: url4.port,
+        headers: {
+          accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+        },
+        timeout: 2e3
+      };
+      if (authInfo) {
+        options.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+      }
+      const { get: get2 } = url4.protocol === "https:" ? require("https") : require("http");
+      get2(options, (response) => {
+        const { statusCode } = response;
+        if (statusCode !== 200) {
+          const error2 = new Error(`Request failed with code ${statusCode}`);
+          error2.code = statusCode;
+          reject(error2);
+          response.resume();
+          return;
+        }
+        let rawData = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          rawData += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const parsedData = JSON.parse(rawData);
+            resolve25(parsedData);
+          } catch (e7) {
+            reject(e7);
+          }
+        });
+      }).on("error", reject).on("timeout", reject);
+    }), "loadPackage");
+    var getMostRecent = /* @__PURE__ */ __name(async ({ full, scope }, distTag) => {
+      const regURL = registryUrl(scope);
+      const url4 = new URL7(full, regURL);
+      let spec = null;
+      try {
+        spec = await loadPackage(url4);
+      } catch (err) {
+        if (err.code && String(err.code).startsWith(4)) {
+          const registryAuthToken = require_registry_auth_token();
+          const authInfo = registryAuthToken(regURL, { recursive: true });
+          spec = await loadPackage(url4, authInfo);
+        } else {
+          throw err;
+        }
+      }
+      const version5 = spec["dist-tags"][distTag];
+      if (!version5) {
+        throw new Error(`Distribution tag ${distTag} is not available`);
+      }
+      return version5;
+    }, "getMostRecent");
+    var defaultConfig = {
+      interval: 36e5,
+      distTag: "latest"
+    };
+    var getDetails = /* @__PURE__ */ __name((name2) => {
+      const spec = {
+        full: encode(name2)
+      };
+      if (name2.includes("/")) {
+        const parts = name2.split("/");
+        spec.scope = parts[0];
+        spec.name = parts[1];
+      } else {
+        spec.scope = null;
+        spec.name = name2;
+      }
+      return spec;
+    }, "getDetails");
+    module3.exports = async (pkg, config) => {
+      if (typeof pkg !== "object") {
+        throw new Error("The first parameter should be your package.json file content");
+      }
+      const details = getDetails(pkg.name);
+      const time = Date.now();
+      const { distTag, interval } = Object.assign({}, defaultConfig, config);
+      const file = await getFile(details, distTag);
+      let latest = null;
+      let shouldCheck = true;
+      ({ shouldCheck, latest } = await evaluateCache(file, time, interval));
+      if (shouldCheck) {
+        latest = await getMostRecent(details, distTag);
+        await updateCache(file, latest, time);
+      }
+      const comparision = compareVersions(pkg.version, latest);
+      if (comparision === -1) {
+        return {
+          latest,
+          fromCache: !shouldCheck
+        };
+      }
+      return null;
+    };
+  }
+});
+
+// src/update-check.ts
+async function doUpdateCheck() {
+  let update = null;
+  const pkg = { name, version };
+  try {
+    update = await (0, import_update_check.default)(pkg, {
+      distTag: pkg.version.startsWith("0.0.0") ? "beta" : "latest"
+    });
+  } catch {
+  }
+  return update?.latest;
+}
+function updateCheck() {
+  return updateCheckPromise ??= doUpdateCheck();
+}
+var import_update_check, updateCheckPromise;
+var init_update_check = __esm({
+  "src/update-check.ts"() {
+    init_import_meta_url();
+    import_update_check = __toESM(require_update_check());
+    init_package();
+    __name(doUpdateCheck, "doUpdateCheck");
+    __name(updateCheck, "updateCheck");
+  }
+});
+
+// src/vectorize/fetcher.ts
+function MakeVectorizeFetcher(complianceConfig, indexId) {
+  return async function(request4) {
+    const accountId = await getAccountId(complianceConfig);
+    request4.headers.delete("Host");
+    request4.headers.delete("Content-Length");
+    let op = request4.url.split("/").pop() || "";
+    op = URL_SUBSTITUTIONS.get(op) || op;
+    const base = `/accounts/${accountId}/vectorize/v2/indexes/${indexId}/`;
+    const url4 = base + op;
+    const res = await performApiFetch(complianceConfig, url4, {
+      method: request4.method,
+      headers: Object.fromEntries(request4.headers.entries()),
+      body: request4.body,
+      duplex: "half"
+    });
+    const respHeaders = new import_miniflare6.Headers(res.headers);
+    respHeaders.delete("Host");
+    respHeaders.delete("Content-Length");
+    const apiResponse = await res.json();
+    const newResponse = apiResponse.success ? apiResponse.result : {
+      error: apiResponse.errors[0].message,
+      code: apiResponse.errors[0].code
+    };
+    return new import_miniflare6.Response(JSON.stringify(newResponse), {
+      status: res.status,
+      headers: respHeaders
+    });
+  };
+}
+var import_miniflare6, EXTERNAL_VECTORIZE_WORKER_NAME, EXTERNAL_VECTORIZE_WORKER_SCRIPT, URL_SUBSTITUTIONS;
+var init_fetcher3 = __esm({
+  "src/vectorize/fetcher.ts"() {
+    init_import_meta_url();
+    import_miniflare6 = require("miniflare");
+    init_internal();
+    init_user2();
+    EXTERNAL_VECTORIZE_WORKER_NAME = "__WRANGLER_EXTERNAL_VECTORIZE_WORKER";
+    EXTERNAL_VECTORIZE_WORKER_SCRIPT = `
+import makeBinding from 'cloudflare-internal:vectorize-api'
+
+export default function (env) {
+    return makeBinding({
+        fetcher: env.FETCHER,
+        indexId: env.INDEX_ID,
+        indexVersion: env.INDEX_VERSION,
+        useNdJson: true,
+    });
+}
+`;
+    URL_SUBSTITUTIONS = /* @__PURE__ */ new Map([
+      ["getByIds", "get_by_ids"],
+      ["deleteByIds", "delete_by_ids"]
+    ]);
+    __name(MakeVectorizeFetcher, "MakeVectorizeFetcher");
+  }
+});
+
+// src/dev/class-names-sqlite.ts
+function getClassNamesWhichUseSQLite(migrations) {
+  const classNamesWhichUseSQLite = /* @__PURE__ */ new Map();
+  (migrations || []).forEach((migration) => {
+    migration.deleted_classes?.forEach((deleted_class) => {
+      if (!classNamesWhichUseSQLite.delete(deleted_class)) {
+        throw new UserError(
+          `Cannot apply deleted_classes migration to non-existent class ${deleted_class}`
+        );
+      }
+    });
+    migration.renamed_classes?.forEach(({ from, to }) => {
+      const useSQLite = classNamesWhichUseSQLite.get(from);
+      if (useSQLite === void 0) {
+        throw new UserError(
+          `Cannot apply renamed_classes migration to non-existent class ${from}`
+        );
+      } else {
+        classNamesWhichUseSQLite.delete(from);
+        classNamesWhichUseSQLite.set(to, useSQLite);
+      }
+    });
+    migration.new_classes?.forEach((new_class) => {
+      if (classNamesWhichUseSQLite.has(new_class)) {
+        throw new UserError(
+          `Cannot apply new_classes migration to existing class ${new_class}`
+        );
+      } else {
+        classNamesWhichUseSQLite.set(new_class, false);
+      }
+    });
+    migration.new_sqlite_classes?.forEach((new_class) => {
+      if (classNamesWhichUseSQLite.has(new_class)) {
+        throw new UserError(
+          `Cannot apply new_sqlite_classes migration to existing class ${new_class}`
+        );
+      } else {
+        classNamesWhichUseSQLite.set(new_class, true);
+      }
+    });
+  });
+  return classNamesWhichUseSQLite;
+}
+var init_class_names_sqlite = __esm({
+  "src/dev/class-names-sqlite.ts"() {
+    init_import_meta_url();
+    init_errors();
+    __name(getClassNamesWhichUseSQLite, "getClassNamesWhichUseSQLite");
+  }
+});
+
 // ../workers-shared/utils/constants.ts
 var PATH_HASH_SIZE, CONTENT_HASH_SIZE, TAIL_SIZE, ENTRY_SIZE, MAX_ASSET_COUNT2, MAX_ASSET_SIZE2, CF_ASSETS_IGNORE_FILENAME, REDIRECTS_FILENAME, HEADERS_FILENAME;
 var init_constants2 = __esm({
@@ -56560,1530 +57874,514 @@ var init_parseHeaders = __esm({
 function parseRedirects(input, {
   maxStaticRules = MAX_STATIC_REDIRECT_RULES,
   maxDynamicRules = MAX_DYNAMIC_REDIRECT_RULES,
-  maxLineLength = MAX_LINE_LENGTH
-} = {}) {
-  const lines = input.split("\n");
-  const rules = [];
-  const seen_paths = /* @__PURE__ */ new Set();
-  const invalid = [];
-  let staticRules = 0;
-  let dynamicRules = 0;
-  let canCreateStaticRule = true;
-  for (let i5 = 0; i5 < lines.length; i5++) {
-    const line = (lines[i5] || "").trim();
-    if (line.length === 0 || line.startsWith("#")) {
-      continue;
-    }
-    if (line.length > maxLineLength) {
-      invalid.push({
-        message: `Ignoring line ${i5 + 1} as it exceeds the maximum allowed length of ${maxLineLength}.`
-      });
-      continue;
-    }
-    const tokens = line.split(/\s+/);
-    if (tokens.length < 2 || tokens.length > 3) {
-      invalid.push({
-        line,
-        lineNumber: i5 + 1,
-        message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`
-      });
-      continue;
-    }
-    const [str_from, str_to, str_status = "302"] = tokens;
-    const fromResult = validateUrl(str_from, true, true, false, false);
-    if (fromResult[0] === void 0) {
-      invalid.push({
-        line,
-        lineNumber: i5 + 1,
-        message: fromResult[1]
-      });
-      continue;
-    }
-    const from = fromResult[0];
-    if (canCreateStaticRule && !from.match(SPLAT_REGEX) && !from.match(PLACEHOLDER_REGEX)) {
-      staticRules += 1;
-      if (staticRules > maxStaticRules) {
-        invalid.push({
-          message: `Maximum number of static rules supported is ${maxStaticRules}. Skipping line.`
-        });
-        continue;
-      }
-    } else {
-      dynamicRules += 1;
-      canCreateStaticRule = false;
-      if (dynamicRules > maxDynamicRules) {
-        invalid.push({
-          message: `Maximum number of dynamic rules supported is ${maxDynamicRules}. Skipping remaining ${lines.length - i5} lines of file.`
-        });
-        break;
-      }
-    }
-    const toResult = validateUrl(str_to, false, false, true, true);
-    if (toResult[0] === void 0) {
-      invalid.push({
-        line,
-        lineNumber: i5 + 1,
-        message: toResult[1]
-      });
-      continue;
-    }
-    const to = toResult[0];
-    const status2 = Number(str_status);
-    if (isNaN(status2) || !PERMITTED_STATUS_CODES.has(status2)) {
-      invalid.push({
-        line,
-        lineNumber: i5 + 1,
-        message: `Valid status codes are 200, 301, 302 (default), 303, 307, or 308. Got ${str_status}.`
-      });
-      continue;
-    }
-    if (/\/\*?$/.test(from) && /\/index(.html)?$/.test(to) && !urlHasHost(to)) {
-      invalid.push({
-        line,
-        lineNumber: i5 + 1,
-        message: "Infinite loop detected in this rule and has been ignored. This will cause a redirect to strip `.html` or `/index` and end up triggering this rule again. Please fix or remove this rule to silence this warning."
-      });
-      continue;
-    }
-    if (seen_paths.has(from)) {
-      invalid.push({
-        line,
-        lineNumber: i5 + 1,
-        message: `Ignoring duplicate rule for path ${from}.`
-      });
-      continue;
-    }
-    seen_paths.add(from);
-    if (status2 === 200) {
-      if (urlHasHost(to)) {
-        invalid.push({
-          line,
-          lineNumber: i5 + 1,
-          message: `Proxy (200) redirects can only point to relative paths. Got ${to}`
-        });
-        continue;
-      }
-    }
-    rules.push({ from, to, status: status2, lineNumber: i5 + 1 });
-  }
-  return {
-    rules,
-    invalid
-  };
-}
-var init_parseRedirects = __esm({
-  "../workers-shared/utils/configuration/parseRedirects.ts"() {
-    init_import_meta_url();
-    init_constants3();
-    init_validateURL();
-    __name(parseRedirects, "parseRedirects");
-  }
-});
-
-// ../workers-shared/utils/configuration/types.ts
-var init_types3 = __esm({
-  "../workers-shared/utils/configuration/types.ts"() {
-    init_import_meta_url();
-  }
-});
-
-// ../workers-shared/index.ts
-var init_workers_shared = __esm({
-  "../workers-shared/index.ts"() {
-    init_import_meta_url();
-    init_constants2();
-    init_types2();
-    init_helpers2();
-    init_parseHeaders();
-    init_parseRedirects();
-    init_types3();
-  }
-});
-
-// src/sourcemap.ts
-function maybeRetrieveFileSourceMap(filePath) {
-  if (filePath === void 0) {
-    return null;
-  }
-  const contents = maybeGetFile(filePath);
-  if (contents === void 0) {
-    return null;
-  }
-  const mapRegexp = /# sourceMappingURL=(.+)/g;
-  const matches = [...contents.matchAll(mapRegexp)];
-  if (matches.length === 0) {
-    return null;
-  }
-  const mapMatch = matches[matches.length - 1];
-  const fileUrl = import_node_url6.default.pathToFileURL(filePath);
-  const mapUrl = new URL(mapMatch[1], fileUrl);
-  if (mapUrl.protocol === "data:" && mapUrl.pathname.startsWith("application/json;base64,")) {
-    const base642 = mapUrl.href.substring(mapUrl.href.indexOf(",") + 1);
-    const map2 = Buffer.from(base642, "base64").toString();
-    return { map: map2, url: fileUrl.href };
-  } else {
-    const map2 = maybeGetFile(mapUrl);
-    if (map2 === void 0) {
-      return null;
-    }
-    return { map: map2, url: mapUrl.href };
-  }
-}
-function getSourceMappingPrepareStackTrace(retrieveSourceMap) {
-  retrieveSourceMapOverride = retrieveSourceMap;
-  if (sourceMappingPrepareStackTrace !== void 0) {
-    return sourceMappingPrepareStackTrace;
-  }
-  const support = (0, import_miniflare6.getFreshSourceMapSupport)();
-  const originalPrepareStackTrace = Error.prepareStackTrace;
-  support.install({
-    environment: "node",
-    // Don't add Node `uncaughtException` handler
-    handleUncaughtExceptions: false,
-    // Don't hook Node `require` function
-    hookRequire: false,
-    redirectConflictingLibrary: false,
-    // Make sure we're using fresh copies of files each time we source map
-    emptyCacheBetweenOperations: true,
-    // Allow retriever to be overridden at prepare stack trace time
-    retrieveSourceMap(path72) {
-      return retrieveSourceMapOverride?.(path72) ?? null;
-    }
-  });
-  sourceMappingPrepareStackTrace = Error.prepareStackTrace;
-  (0, import_node_assert4.default)(sourceMappingPrepareStackTrace !== void 0);
-  Error.prepareStackTrace = originalPrepareStackTrace;
-  return sourceMappingPrepareStackTrace;
-}
-function getSourceMappedStack(details) {
-  const description = details.exception?.description ?? "";
-  const callFrames = details.stackTrace?.callFrames;
-  if (callFrames === void 0) {
-    return description;
-  }
-  const nameMessage = details.exception?.description?.split("\n")[0] ?? "";
-  const colonIndex = nameMessage.indexOf(":");
-  const error2 = new Error(nameMessage.substring(colonIndex + 2));
-  error2.name = nameMessage.substring(0, colonIndex);
-  const callSites = callFrames.map(callFrameToCallSite);
-  return getSourceMappingPrepareStackTrace()(error2, callSites);
-}
-function callFrameToCallSite(frame) {
-  return new CallSite({
-    typeName: null,
-    functionName: frame.functionName,
-    methodName: null,
-    fileName: frame.url,
-    lineNumber: frame.lineNumber + 1,
-    columnNumber: frame.columnNumber + 1,
-    native: false
-  });
-}
-function getSourceMappedString(value, retrieveSourceMap) {
-  const callSiteLines = Array.from(value.matchAll(CALL_SITE_REGEXP));
-  const callSites = callSiteLines.map(lineMatchToCallSite);
-  const prepareStack = getSourceMappingPrepareStackTrace(retrieveSourceMap);
-  const sourceMappedStackTrace = prepareStack(
-    placeholderError,
-    callSites
-  );
-  const sourceMappedCallSiteLines = sourceMappedStackTrace.split("\n").slice(1);
-  for (let i5 = 0; i5 < callSiteLines.length; i5++) {
-    if (callSites[i5].getFileName() === void 0) {
-      continue;
-    }
-    const callSiteLine = callSiteLines[i5][0];
-    const callSiteAtIndex = callSiteLine.indexOf("at");
-    (0, import_node_assert4.default)(callSiteAtIndex !== -1);
-    const callSiteLineLeftPad = callSiteLine.substring(0, callSiteAtIndex);
-    value = value.replace(
-      callSiteLine,
-      callSiteLineLeftPad + sourceMappedCallSiteLines[i5].trimStart()
-    );
-  }
-  return value;
-}
-function lineMatchToCallSite(lineMatch) {
-  let object = null;
-  let method = null;
-  let functionName = null;
-  let typeName = null;
-  let methodName = null;
-  const isNative = lineMatch[5] === "native";
-  if (lineMatch[1]) {
-    functionName = lineMatch[1];
-    let methodStart = functionName.lastIndexOf(".");
-    if (functionName[methodStart - 1] == ".") {
-      methodStart--;
-    }
-    if (methodStart > 0) {
-      object = functionName.substring(0, methodStart);
-      method = functionName.substring(methodStart + 1);
-      const objectEnd = object.indexOf(".Module");
-      if (objectEnd > 0) {
-        functionName = functionName.substring(objectEnd + 1);
-        object = object.substring(0, objectEnd);
-      }
-    }
-  }
-  if (method) {
-    typeName = object;
-    methodName = method;
-  }
-  if (method === "<anonymous>") {
-    methodName = null;
-    functionName = null;
-  }
-  return new CallSite({
-    typeName,
-    functionName,
-    methodName,
-    fileName: lineMatch[2],
-    lineNumber: parseInt(lineMatch[3]) || null,
-    columnNumber: parseInt(lineMatch[4]) || null,
-    native: isNative
-  });
-}
-var import_node_assert4, import_node_url6, import_miniflare6, sourceMappingPrepareStackTrace, retrieveSourceMapOverride, placeholderError, CALL_SITE_REGEXP, CallSite;
-var init_sourcemap = __esm({
-  "src/sourcemap.ts"() {
-    init_import_meta_url();
-    import_node_assert4 = __toESM(require("assert"));
-    import_node_url6 = __toESM(require("url"));
-    init_workers_shared();
-    import_miniflare6 = require("miniflare");
-    __name(maybeRetrieveFileSourceMap, "maybeRetrieveFileSourceMap");
-    __name(getSourceMappingPrepareStackTrace, "getSourceMappingPrepareStackTrace");
-    __name(getSourceMappedStack, "getSourceMappedStack");
-    __name(callFrameToCallSite, "callFrameToCallSite");
-    placeholderError = new Error();
-    __name(getSourceMappedString, "getSourceMappedString");
-    CALL_SITE_REGEXP = // Validation errors from `wrangler deploy` have a 2 space indent, whereas
-    // regular stack traces have a 4 space indent.
-    // eslint-disable-next-line no-control-regex
-    /^(?:\s+(?:\x1B\[\d+m)?'?)? {2,4}at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/gm;
-    __name(lineMatchToCallSite, "lineMatchToCallSite");
-    CallSite = class {
-      constructor(opts) {
-        this.opts = opts;
-      }
-      static {
-        __name(this, "CallSite");
-      }
-      getScriptHash() {
-        throw new Error("Method not implemented.");
-      }
-      getEnclosingColumnNumber() {
-        throw new Error("Method not implemented.");
-      }
-      getEnclosingLineNumber() {
-        throw new Error("Method not implemented.");
-      }
-      getPosition() {
-        throw new Error("Method not implemented.");
-      }
-      getThis() {
-        return null;
-      }
-      getTypeName() {
-        return this.opts.typeName;
-      }
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-      getFunction() {
-        return void 0;
-      }
-      getFunctionName() {
-        return this.opts.functionName;
-      }
-      getMethodName() {
-        return this.opts.methodName;
-      }
-      getFileName() {
-        return this.opts.fileName ?? null;
-      }
-      getScriptNameOrSourceURL() {
-        return this.opts.fileName;
-      }
-      getLineNumber() {
-        return this.opts.lineNumber;
-      }
-      getColumnNumber() {
-        return this.opts.columnNumber;
-      }
-      getEvalOrigin() {
-        return void 0;
-      }
-      isToplevel() {
-        return false;
-      }
-      isEval() {
-        return false;
-      }
-      isNative() {
-        return this.opts.native;
-      }
-      isConstructor() {
-        return false;
-      }
-      isAsync() {
-        return false;
-      }
-      isPromiseAll() {
-        return false;
-      }
-      isPromiseAny() {
-        return false;
-      }
-      getPromiseIndex() {
-        return null;
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js
-var require_ini = __commonJS({
-  "../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js"(exports2) {
-    init_import_meta_url();
-    exports2.parse = exports2.decode = decode;
-    exports2.stringify = exports2.encode = encode;
-    exports2.safe = safe;
-    exports2.unsafe = unsafe;
-    var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
-    function encode(obj, opt) {
-      var children = [];
-      var out = "";
-      if (typeof opt === "string") {
-        opt = {
-          section: opt,
-          whitespace: false
-        };
-      } else {
-        opt = opt || {};
-        opt.whitespace = opt.whitespace === true;
-      }
-      var separator = opt.whitespace ? " = " : "=";
-      Object.keys(obj).forEach(function(k6, _4, __) {
-        var val2 = obj[k6];
-        if (val2 && Array.isArray(val2)) {
-          val2.forEach(function(item) {
-            out += safe(k6 + "[]") + separator + safe(item) + "\n";
-          });
-        } else if (val2 && typeof val2 === "object")
-          children.push(k6);
-        else
-          out += safe(k6) + separator + safe(val2) + eol;
-      });
-      if (opt.section && out.length)
-        out = "[" + safe(opt.section) + "]" + eol + out;
-      children.forEach(function(k6, _4, __) {
-        var nk = dotSplit(k6).join("\\.");
-        var section = (opt.section ? opt.section + "." : "") + nk;
-        var child = encode(obj[k6], {
-          section,
-          whitespace: opt.whitespace
-        });
-        if (out.length && child.length)
-          out += eol;
-        out += child;
-      });
-      return out;
-    }
-    __name(encode, "encode");
-    function dotSplit(str) {
-      return str.replace(/\1/g, "LITERAL\\1LITERAL").replace(/\\\./g, "
").split(/\./).map(function(part) {
-        return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "
");
-      });
-    }
-    __name(dotSplit, "dotSplit");
-    function decode(str) {
-      var out = {};
-      var p6 = out;
-      var section = null;
-      var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
-      var lines = str.split(/[\r\n]+/g);
-      lines.forEach(function(line, _4, __) {
-        if (!line || line.match(/^\s*[;#]/))
-          return;
-        var match2 = line.match(re);
-        if (!match2)
-          return;
-        if (match2[1] !== void 0) {
-          section = unsafe(match2[1]);
-          if (section === "__proto__") {
-            p6 = {};
-            return;
-          }
-          p6 = out[section] = out[section] || {};
-          return;
-        }
-        var key = unsafe(match2[2]);
-        if (key === "__proto__")
-          return;
-        var value = match2[3] ? unsafe(match2[4]) : true;
-        switch (value) {
-          case "true":
-          case "false":
-          case "null":
-            value = JSON.parse(value);
-        }
-        if (key.length > 2 && key.slice(-2) === "[]") {
-          key = key.substring(0, key.length - 2);
-          if (key === "__proto__")
-            return;
-          if (!p6[key])
-            p6[key] = [];
-          else if (!Array.isArray(p6[key]))
-            p6[key] = [p6[key]];
-        }
-        if (Array.isArray(p6[key]))
-          p6[key].push(value);
-        else
-          p6[key] = value;
-      });
-      Object.keys(out).filter(function(k6, _4, __) {
-        if (!out[k6] || typeof out[k6] !== "object" || Array.isArray(out[k6]))
-          return false;
-        var parts = dotSplit(k6);
-        var p7 = out;
-        var l6 = parts.pop();
-        var nl = l6.replace(/\\\./g, ".");
-        parts.forEach(function(part, _5, __2) {
-          if (part === "__proto__")
-            return;
-          if (!p7[part] || typeof p7[part] !== "object")
-            p7[part] = {};
-          p7 = p7[part];
-        });
-        if (p7 === out && nl === l6)
-          return false;
-        p7[nl] = out[k6];
-        return true;
-      }).forEach(function(del, _4, __) {
-        delete out[del];
-      });
-      return out;
-    }
-    __name(decode, "decode");
-    function isQuoted(val2) {
-      return val2.charAt(0) === '"' && val2.slice(-1) === '"' || val2.charAt(0) === "'" && val2.slice(-1) === "'";
-    }
-    __name(isQuoted, "isQuoted");
-    function safe(val2) {
-      return typeof val2 !== "string" || val2.match(/[=\r\n]/) || val2.match(/^\[/) || val2.length > 1 && isQuoted(val2) || val2 !== val2.trim() ? JSON.stringify(val2) : val2.replace(/;/g, "\\;").replace(/#/g, "\\#");
-    }
-    __name(safe, "safe");
-    function unsafe(val2, doUnesc) {
-      val2 = (val2 || "").trim();
-      if (isQuoted(val2)) {
-        if (val2.charAt(0) === "'")
-          val2 = val2.substr(1, val2.length - 2);
-        try {
-          val2 = JSON.parse(val2);
-        } catch (_4) {
-        }
-      } else {
-        var esc = false;
-        var unesc = "";
-        for (var i5 = 0, l6 = val2.length; i5 < l6; i5++) {
-          var c6 = val2.charAt(i5);
-          if (esc) {
-            if ("\\;#".indexOf(c6) !== -1)
-              unesc += c6;
-            else
-              unesc += "\\" + c6;
-            esc = false;
-          } else if (";#".indexOf(c6) !== -1)
-            break;
-          else if (c6 === "\\")
-            esc = true;
-          else
-            unesc += c6;
-        }
-        if (esc)
-          unesc += "\\";
-        return unesc.trim();
-      }
-      return val2;
-    }
-    __name(unsafe, "unsafe");
-  }
-});
-
-// ../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js
-var require_strip_json_comments = __commonJS({
-  "../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js"(exports2, module3) {
-    "use strict";
-    init_import_meta_url();
-    var singleComment = 1;
-    var multiComment = 2;
-    function stripWithoutWhitespace() {
-      return "";
-    }
-    __name(stripWithoutWhitespace, "stripWithoutWhitespace");
-    function stripWithWhitespace(str, start, end) {
-      return str.slice(start, end).replace(/\S/g, " ");
-    }
-    __name(stripWithWhitespace, "stripWithWhitespace");
-    module3.exports = function(str, opts) {
-      opts = opts || {};
-      var currentChar;
-      var nextChar;
-      var insideString = false;
-      var insideComment = false;
-      var offset = 0;
-      var ret = "";
-      var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
-      for (var i5 = 0; i5 < str.length; i5++) {
-        currentChar = str[i5];
-        nextChar = str[i5 + 1];
-        if (!insideComment && currentChar === '"') {
-          var escaped = str[i5 - 1] === "\\" && str[i5 - 2] !== "\\";
-          if (!escaped) {
-            insideString = !insideString;
-          }
-        }
-        if (insideString) {
-          continue;
-        }
-        if (!insideComment && currentChar + nextChar === "//") {
-          ret += str.slice(offset, i5);
-          offset = i5;
-          insideComment = singleComment;
-          i5++;
-        } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
-          i5++;
-          insideComment = false;
-          ret += strip(str, offset, i5);
-          offset = i5;
-          continue;
-        } else if (insideComment === singleComment && currentChar === "\n") {
-          insideComment = false;
-          ret += strip(str, offset, i5);
-          offset = i5;
-        } else if (!insideComment && currentChar + nextChar === "/*") {
-          ret += str.slice(offset, i5);
-          offset = i5;
-          insideComment = multiComment;
-          i5++;
-          continue;
-        } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
-          i5++;
-          insideComment = false;
-          ret += strip(str, offset, i5 + 1);
-          offset = i5 + 1;
-          continue;
-        }
-      }
-      return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js
-var require_utils3 = __commonJS({
-  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports2) {
-    "use strict";
-    init_import_meta_url();
-    var fs24 = require("fs");
-    var ini = require_ini();
-    var path72 = require("path");
-    var stripJsonComments = require_strip_json_comments();
-    var parse7 = exports2.parse = function(content) {
-      if (/^\s*{/.test(content))
-        return JSON.parse(stripJsonComments(content));
-      return ini.parse(content);
-    };
-    var file = exports2.file = function() {
-      var args = [].slice.call(arguments).filter(function(arg) {
-        return arg != null;
-      });
-      for (var i5 in args)
-        if ("string" !== typeof args[i5])
-          return;
-      var file2 = path72.join.apply(null, args);
-      var content;
-      try {
-        return fs24.readFileSync(file2, "utf-8");
-      } catch (err) {
-        return;
-      }
-    };
-    var json = exports2.json = function() {
-      var content = file.apply(null, arguments);
-      return content ? parse7(content) : null;
-    };
-    var env6 = exports2.env = function(prefix, env7) {
-      env7 = env7 || process.env;
-      var obj = {};
-      var l6 = prefix.length;
-      for (var k6 in env7) {
-        if (k6.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
-          var keypath = k6.substring(l6).split("__");
-          var _emptyStringIndex;
-          while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
-            keypath.splice(_emptyStringIndex, 1);
-          }
-          var cursor = obj;
-          keypath.forEach(/* @__PURE__ */ __name(function _buildSubObj(_subkey, i5) {
-            if (!_subkey || typeof cursor !== "object")
-              return;
-            if (i5 === keypath.length - 1)
-              cursor[_subkey] = env7[k6];
-            if (cursor[_subkey] === void 0)
-              cursor[_subkey] = {};
-            cursor = cursor[_subkey];
-          }, "_buildSubObj"));
-        }
-      }
-      return obj;
-    };
-    var find = exports2.find = function() {
-      var rel = path72.join.apply(null, [].slice.call(arguments));
-      function find2(start, rel2) {
-        var file2 = path72.join(start, rel2);
-        try {
-          fs24.statSync(file2);
-          return file2;
-        } catch (err) {
-          if (path72.dirname(start) !== start)
-            return find2(path72.dirname(start), rel2);
-        }
-      }
-      __name(find2, "find");
-      return find2(process.cwd(), rel);
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js
-var require_deep_extend = __commonJS({
-  "../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js"(exports2, module3) {
-    "use strict";
-    init_import_meta_url();
-    function isSpecificValue(val2) {
-      return val2 instanceof Buffer || val2 instanceof Date || val2 instanceof RegExp ? true : false;
-    }
-    __name(isSpecificValue, "isSpecificValue");
-    function cloneSpecificValue(val2) {
-      if (val2 instanceof Buffer) {
-        var x6 = Buffer.alloc ? Buffer.alloc(val2.length) : new Buffer(val2.length);
-        val2.copy(x6);
-        return x6;
-      } else if (val2 instanceof Date) {
-        return new Date(val2.getTime());
-      } else if (val2 instanceof RegExp) {
-        return new RegExp(val2);
-      } else {
-        throw new Error("Unexpected situation");
-      }
-    }
-    __name(cloneSpecificValue, "cloneSpecificValue");
-    function deepCloneArray(arr) {
-      var clone = [];
-      arr.forEach(function(item, index) {
-        if (typeof item === "object" && item !== null) {
-          if (Array.isArray(item)) {
-            clone[index] = deepCloneArray(item);
-          } else if (isSpecificValue(item)) {
-            clone[index] = cloneSpecificValue(item);
-          } else {
-            clone[index] = deepExtend({}, item);
-          }
-        } else {
-          clone[index] = item;
-        }
-      });
-      return clone;
-    }
-    __name(deepCloneArray, "deepCloneArray");
-    function safeGetProperty(object, property) {
-      return property === "__proto__" ? void 0 : object[property];
-    }
-    __name(safeGetProperty, "safeGetProperty");
-    var deepExtend = module3.exports = function() {
-      if (arguments.length < 1 || typeof arguments[0] !== "object") {
-        return false;
-      }
-      if (arguments.length < 2) {
-        return arguments[0];
-      }
-      var target = arguments[0];
-      var args = Array.prototype.slice.call(arguments, 1);
-      var val2, src, clone;
-      args.forEach(function(obj) {
-        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
-          return;
-        }
-        Object.keys(obj).forEach(function(key) {
-          src = safeGetProperty(target, key);
-          val2 = safeGetProperty(obj, key);
-          if (val2 === target) {
-            return;
-          } else if (typeof val2 !== "object" || val2 === null) {
-            target[key] = val2;
-            return;
-          } else if (Array.isArray(val2)) {
-            target[key] = deepCloneArray(val2);
-            return;
-          } else if (isSpecificValue(val2)) {
-            target[key] = cloneSpecificValue(val2);
-            return;
-          } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
-            target[key] = deepExtend({}, val2);
-            return;
-          } else {
-            target[key] = deepExtend(src, val2);
-            return;
-          }
-        });
-      });
-      return target;
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js
-var require_minimist = __commonJS({
-  "../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js"(exports2, module3) {
-    init_import_meta_url();
-    module3.exports = function(args, opts) {
-      if (!opts) opts = {};
-      var flags2 = { bools: {}, strings: {}, unknownFn: null };
-      if (typeof opts["unknown"] === "function") {
-        flags2.unknownFn = opts["unknown"];
-      }
-      if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
-        flags2.allBools = true;
-      } else {
-        [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
-          flags2.bools[key2] = true;
-        });
-      }
-      var aliases2 = {};
-      Object.keys(opts.alias || {}).forEach(function(key2) {
-        aliases2[key2] = [].concat(opts.alias[key2]);
-        aliases2[key2].forEach(function(x6) {
-          aliases2[x6] = [key2].concat(aliases2[key2].filter(function(y4) {
-            return x6 !== y4;
-          }));
-        });
-      });
-      [].concat(opts.string).filter(Boolean).forEach(function(key2) {
-        flags2.strings[key2] = true;
-        if (aliases2[key2]) {
-          flags2.strings[aliases2[key2]] = true;
-        }
-      });
-      var defaults = opts["default"] || {};
-      var argv = { _: [] };
-      Object.keys(flags2.bools).forEach(function(key2) {
-        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
-      });
-      var notFlags = [];
-      if (args.indexOf("--") !== -1) {
-        notFlags = args.slice(args.indexOf("--") + 1);
-        args = args.slice(0, args.indexOf("--"));
-      }
-      function argDefined(key2, arg2) {
-        return flags2.allBools && /^--[^=]+$/.test(arg2) || flags2.strings[key2] || flags2.bools[key2] || aliases2[key2];
-      }
-      __name(argDefined, "argDefined");
-      function setArg(key2, val2, arg2) {
-        if (arg2 && flags2.unknownFn && !argDefined(key2, arg2)) {
-          if (flags2.unknownFn(arg2) === false) return;
-        }
-        var value2 = !flags2.strings[key2] && isNumber(val2) ? Number(val2) : val2;
-        setKey(argv, key2.split("."), value2);
-        (aliases2[key2] || []).forEach(function(x6) {
-          setKey(argv, x6.split("."), value2);
-        });
-      }
-      __name(setArg, "setArg");
-      function setKey(obj, keys, value2) {
-        var o5 = obj;
-        for (var i6 = 0; i6 < keys.length - 1; i6++) {
-          var key2 = keys[i6];
-          if (isConstructorOrProto(o5, key2)) return;
-          if (o5[key2] === void 0) o5[key2] = {};
-          if (o5[key2] === Object.prototype || o5[key2] === Number.prototype || o5[key2] === String.prototype) o5[key2] = {};
-          if (o5[key2] === Array.prototype) o5[key2] = [];
-          o5 = o5[key2];
-        }
-        var key2 = keys[keys.length - 1];
-        if (isConstructorOrProto(o5, key2)) return;
-        if (o5 === Object.prototype || o5 === Number.prototype || o5 === String.prototype) o5 = {};
-        if (o5 === Array.prototype) o5 = [];
-        if (o5[key2] === void 0 || flags2.bools[key2] || typeof o5[key2] === "boolean") {
-          o5[key2] = value2;
-        } else if (Array.isArray(o5[key2])) {
-          o5[key2].push(value2);
-        } else {
-          o5[key2] = [o5[key2], value2];
-        }
-      }
-      __name(setKey, "setKey");
-      function aliasIsBoolean(key2) {
-        return aliases2[key2].some(function(x6) {
-          return flags2.bools[x6];
-        });
-      }
-      __name(aliasIsBoolean, "aliasIsBoolean");
-      for (var i5 = 0; i5 < args.length; i5++) {
-        var arg = args[i5];
-        if (/^--.+=/.test(arg)) {
-          var m6 = arg.match(/^--([^=]+)=([\s\S]*)$/);
-          var key = m6[1];
-          var value = m6[2];
-          if (flags2.bools[key]) {
-            value = value !== "false";
-          }
-          setArg(key, value, arg);
-        } else if (/^--no-.+/.test(arg)) {
-          var key = arg.match(/^--no-(.+)/)[1];
-          setArg(key, false, arg);
-        } else if (/^--.+/.test(arg)) {
-          var key = arg.match(/^--(.+)/)[1];
-          var next = args[i5 + 1];
-          if (next !== void 0 && !/^-/.test(next) && !flags2.bools[key] && !flags2.allBools && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
-            setArg(key, next, arg);
-            i5++;
-          } else if (/^(true|false)$/.test(next)) {
-            setArg(key, next === "true", arg);
-            i5++;
-          } else {
-            setArg(key, flags2.strings[key] ? "" : true, arg);
-          }
-        } else if (/^-[^-]+/.test(arg)) {
-          var letters = arg.slice(1, -1).split("");
-          var broken = false;
-          for (var j6 = 0; j6 < letters.length; j6++) {
-            var next = arg.slice(j6 + 2);
-            if (next === "-") {
-              setArg(letters[j6], next, arg);
-              continue;
-            }
-            if (/[A-Za-z]/.test(letters[j6]) && /=/.test(next)) {
-              setArg(letters[j6], next.split("=")[1], arg);
-              broken = true;
-              break;
-            }
-            if (/[A-Za-z]/.test(letters[j6]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
-              setArg(letters[j6], next, arg);
-              broken = true;
-              break;
-            }
-            if (letters[j6 + 1] && letters[j6 + 1].match(/\W/)) {
-              setArg(letters[j6], arg.slice(j6 + 2), arg);
-              broken = true;
-              break;
-            } else {
-              setArg(letters[j6], flags2.strings[letters[j6]] ? "" : true, arg);
-            }
-          }
-          var key = arg.slice(-1)[0];
-          if (!broken && key !== "-") {
-            if (args[i5 + 1] && !/^(-|--)[^-]/.test(args[i5 + 1]) && !flags2.bools[key] && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
-              setArg(key, args[i5 + 1], arg);
-              i5++;
-            } else if (args[i5 + 1] && /^(true|false)$/.test(args[i5 + 1])) {
-              setArg(key, args[i5 + 1] === "true", arg);
-              i5++;
-            } else {
-              setArg(key, flags2.strings[key] ? "" : true, arg);
-            }
-          }
-        } else {
-          if (!flags2.unknownFn || flags2.unknownFn(arg) !== false) {
-            argv._.push(
-              flags2.strings["_"] || !isNumber(arg) ? arg : Number(arg)
-            );
-          }
-          if (opts.stopEarly) {
-            argv._.push.apply(argv._, args.slice(i5 + 1));
-            break;
-          }
-        }
-      }
-      Object.keys(defaults).forEach(function(key2) {
-        if (!hasKey2(argv, key2.split("."))) {
-          setKey(argv, key2.split("."), defaults[key2]);
-          (aliases2[key2] || []).forEach(function(x6) {
-            setKey(argv, x6.split("."), defaults[key2]);
-          });
-        }
+  maxLineLength = MAX_LINE_LENGTH
+} = {}) {
+  const lines = input.split("\n");
+  const rules = [];
+  const seen_paths = /* @__PURE__ */ new Set();
+  const invalid = [];
+  let staticRules = 0;
+  let dynamicRules = 0;
+  let canCreateStaticRule = true;
+  for (let i5 = 0; i5 < lines.length; i5++) {
+    const line = (lines[i5] || "").trim();
+    if (line.length === 0 || line.startsWith("#")) {
+      continue;
+    }
+    if (line.length > maxLineLength) {
+      invalid.push({
+        message: `Ignoring line ${i5 + 1} as it exceeds the maximum allowed length of ${maxLineLength}.`
       });
-      if (opts["--"]) {
-        argv["--"] = new Array();
-        notFlags.forEach(function(key2) {
-          argv["--"].push(key2);
+      continue;
+    }
+    const tokens = line.split(/\s+/);
+    if (tokens.length < 2 || tokens.length > 3) {
+      invalid.push({
+        line,
+        lineNumber: i5 + 1,
+        message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`
+      });
+      continue;
+    }
+    const [str_from, str_to, str_status = "302"] = tokens;
+    const fromResult = validateUrl(str_from, true, true, false, false);
+    if (fromResult[0] === void 0) {
+      invalid.push({
+        line,
+        lineNumber: i5 + 1,
+        message: fromResult[1]
+      });
+      continue;
+    }
+    const from = fromResult[0];
+    if (canCreateStaticRule && !from.match(SPLAT_REGEX) && !from.match(PLACEHOLDER_REGEX)) {
+      staticRules += 1;
+      if (staticRules > maxStaticRules) {
+        invalid.push({
+          message: `Maximum number of static rules supported is ${maxStaticRules}. Skipping line.`
         });
-      } else {
-        notFlags.forEach(function(key2) {
-          argv._.push(key2);
+        continue;
+      }
+    } else {
+      dynamicRules += 1;
+      canCreateStaticRule = false;
+      if (dynamicRules > maxDynamicRules) {
+        invalid.push({
+          message: `Maximum number of dynamic rules supported is ${maxDynamicRules}. Skipping remaining ${lines.length - i5} lines of file.`
         });
+        break;
       }
-      return argv;
-    };
-    function hasKey2(obj, keys) {
-      var o5 = obj;
-      keys.slice(0, -1).forEach(function(key2) {
-        o5 = o5[key2] || {};
+    }
+    const toResult = validateUrl(str_to, false, false, true, true);
+    if (toResult[0] === void 0) {
+      invalid.push({
+        line,
+        lineNumber: i5 + 1,
+        message: toResult[1]
       });
-      var key = keys[keys.length - 1];
-      return key in o5;
+      continue;
     }
-    __name(hasKey2, "hasKey");
-    function isNumber(x6) {
-      if (typeof x6 === "number") return true;
-      if (/^0x[0-9a-f]+$/i.test(x6)) return true;
-      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x6);
+    const to = toResult[0];
+    const status2 = Number(str_status);
+    if (isNaN(status2) || !PERMITTED_STATUS_CODES.has(status2)) {
+      invalid.push({
+        line,
+        lineNumber: i5 + 1,
+        message: `Valid status codes are 200, 301, 302 (default), 303, 307, or 308. Got ${str_status}.`
+      });
+      continue;
     }
-    __name(isNumber, "isNumber");
-    function isConstructorOrProto(obj, key) {
-      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+    if (/\/\*?$/.test(from) && /\/index(.html)?$/.test(to) && !urlHasHost(to)) {
+      invalid.push({
+        line,
+        lineNumber: i5 + 1,
+        message: "Infinite loop detected in this rule and has been ignored. This will cause a redirect to strip `.html` or `/index` and end up triggering this rule again. Please fix or remove this rule to silence this warning."
+      });
+      continue;
     }
-    __name(isConstructorOrProto, "isConstructorOrProto");
+    if (seen_paths.has(from)) {
+      invalid.push({
+        line,
+        lineNumber: i5 + 1,
+        message: `Ignoring duplicate rule for path ${from}.`
+      });
+      continue;
+    }
+    seen_paths.add(from);
+    if (status2 === 200) {
+      if (urlHasHost(to)) {
+        invalid.push({
+          line,
+          lineNumber: i5 + 1,
+          message: `Proxy (200) redirects can only point to relative paths. Got ${to}`
+        });
+        continue;
+      }
+    }
+    rules.push({ from, to, status: status2, lineNumber: i5 + 1 });
+  }
+  return {
+    rules,
+    invalid
+  };
+}
+var init_parseRedirects = __esm({
+  "../workers-shared/utils/configuration/parseRedirects.ts"() {
+    init_import_meta_url();
+    init_constants3();
+    init_validateURL();
+    __name(parseRedirects, "parseRedirects");
   }
 });
 
-// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js
-var require_rc = __commonJS({
-  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports2, module3) {
+// ../workers-shared/utils/configuration/types.ts
+var init_types3 = __esm({
+  "../workers-shared/utils/configuration/types.ts"() {
     init_import_meta_url();
-    var cc2 = require_utils3();
-    var join24 = require("path").join;
-    var deepExtend = require_deep_extend();
-    var etc = "/etc";
-    var win = process.platform === "win32";
-    var home = win ? process.env.USERPROFILE : process.env.HOME;
-    module3.exports = function(name2, defaults, argv, parse7) {
-      if ("string" !== typeof name2)
-        throw new Error("rc(name): name *must* be string");
-      if (!argv)
-        argv = require_minimist()(process.argv.slice(2));
-      defaults = ("string" === typeof defaults ? cc2.json(defaults) : defaults) || {};
-      parse7 = parse7 || cc2.parse;
-      var env6 = cc2.env(name2 + "_");
-      var configs = [defaults];
-      var configFiles = [];
-      function addConfigFile(file) {
-        if (configFiles.indexOf(file) >= 0) return;
-        var fileConfig = cc2.file(file);
-        if (fileConfig) {
-          configs.push(parse7(fileConfig));
-          configFiles.push(file);
-        }
-      }
-      __name(addConfigFile, "addConfigFile");
-      if (!win)
-        [
-          join24(etc, name2, "config"),
-          join24(etc, name2 + "rc")
-        ].forEach(addConfigFile);
-      if (home)
-        [
-          join24(home, ".config", name2, "config"),
-          join24(home, ".config", name2),
-          join24(home, "." + name2, "config"),
-          join24(home, "." + name2 + "rc")
-        ].forEach(addConfigFile);
-      addConfigFile(cc2.find("." + name2 + "rc"));
-      if (env6.config) addConfigFile(env6.config);
-      if (argv.config) addConfigFile(argv.config);
-      return deepExtend.apply(null, configs.concat([
-        env6,
-        argv,
-        configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
-      ]));
-    };
   }
 });
 
-// ../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js
-var require_registry_url = __commonJS({
-  "../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js"(exports2, module3) {
-    "use strict";
+// ../workers-shared/index.ts
+var init_workers_shared = __esm({
+  "../workers-shared/index.ts"() {
     init_import_meta_url();
-    module3.exports = function(scope) {
-      var rc = require_rc()("npm", { registry: "https://registry.npmjs.org/" });
-      var url4 = rc[scope + ":registry"] || rc.registry;
-      return url4.slice(-1) === "/" ? url4 : url4 + "/";
-    };
+    init_constants2();
+    init_types2();
+    init_helpers2();
+    init_parseHeaders();
+    init_parseRedirects();
+    init_types3();
   }
 });
 
-// ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
-var require_safe_buffer = __commonJS({
-  "../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports2, module3) {
-    init_import_meta_url();
-    var buffer = require("buffer");
-    var Buffer7 = buffer.Buffer;
-    function copyProps(src, dst) {
-      for (var key in src) {
-        dst[key] = src[key];
-      }
+// src/sourcemap.ts
+function maybeRetrieveFileSourceMap(filePath) {
+  if (filePath === void 0) {
+    return null;
+  }
+  const contents = maybeGetFile(filePath);
+  if (contents === void 0) {
+    return null;
+  }
+  const mapRegexp = /# sourceMappingURL=(.+)/g;
+  const matches = [...contents.matchAll(mapRegexp)];
+  if (matches.length === 0) {
+    return null;
+  }
+  const mapMatch = matches[matches.length - 1];
+  const fileUrl = import_node_url6.default.pathToFileURL(filePath);
+  const mapUrl = new URL(mapMatch[1], fileUrl);
+  if (mapUrl.protocol === "data:" && mapUrl.pathname.startsWith("application/json;base64,")) {
+    const base642 = mapUrl.href.substring(mapUrl.href.indexOf(",") + 1);
+    const map2 = Buffer.from(base642, "base64").toString();
+    return { map: map2, url: fileUrl.href };
+  } else {
+    const map2 = maybeGetFile(mapUrl);
+    if (map2 === void 0) {
+      return null;
     }
-    __name(copyProps, "copyProps");
-    if (Buffer7.from && Buffer7.alloc && Buffer7.allocUnsafe && Buffer7.allocUnsafeSlow) {
-      module3.exports = buffer;
-    } else {
-      copyProps(buffer, exports2);
-      exports2.Buffer = SafeBuffer;
+    return { map: map2, url: mapUrl.href };
+  }
+}
+function getSourceMappingPrepareStackTrace(retrieveSourceMap) {
+  retrieveSourceMapOverride = retrieveSourceMap;
+  if (sourceMappingPrepareStackTrace !== void 0) {
+    return sourceMappingPrepareStackTrace;
+  }
+  const support = (0, import_miniflare7.getFreshSourceMapSupport)();
+  const originalPrepareStackTrace = Error.prepareStackTrace;
+  support.install({
+    environment: "node",
+    // Don't add Node `uncaughtException` handler
+    handleUncaughtExceptions: false,
+    // Don't hook Node `require` function
+    hookRequire: false,
+    redirectConflictingLibrary: false,
+    // Make sure we're using fresh copies of files each time we source map
+    emptyCacheBetweenOperations: true,
+    // Allow retriever to be overridden at prepare stack trace time
+    retrieveSourceMap(path72) {
+      return retrieveSourceMapOverride?.(path72) ?? null;
     }
-    function SafeBuffer(arg, encodingOrOffset, length) {
-      return Buffer7(arg, encodingOrOffset, length);
+  });
+  sourceMappingPrepareStackTrace = Error.prepareStackTrace;
+  (0, import_node_assert4.default)(sourceMappingPrepareStackTrace !== void 0);
+  Error.prepareStackTrace = originalPrepareStackTrace;
+  return sourceMappingPrepareStackTrace;
+}
+function getSourceMappedStack(details) {
+  const description = details.exception?.description ?? "";
+  const callFrames = details.stackTrace?.callFrames;
+  if (callFrames === void 0) {
+    return description;
+  }
+  const nameMessage = details.exception?.description?.split("\n")[0] ?? "";
+  const colonIndex = nameMessage.indexOf(":");
+  const error2 = new Error(nameMessage.substring(colonIndex + 2));
+  error2.name = nameMessage.substring(0, colonIndex);
+  const callSites = callFrames.map(callFrameToCallSite);
+  return getSourceMappingPrepareStackTrace()(error2, callSites);
+}
+function callFrameToCallSite(frame) {
+  return new CallSite({
+    typeName: null,
+    functionName: frame.functionName,
+    methodName: null,
+    fileName: frame.url,
+    lineNumber: frame.lineNumber + 1,
+    columnNumber: frame.columnNumber + 1,
+    native: false
+  });
+}
+function getSourceMappedString(value, retrieveSourceMap) {
+  const callSiteLines = Array.from(value.matchAll(CALL_SITE_REGEXP));
+  const callSites = callSiteLines.map(lineMatchToCallSite);
+  const prepareStack = getSourceMappingPrepareStackTrace(retrieveSourceMap);
+  const sourceMappedStackTrace = prepareStack(
+    placeholderError,
+    callSites
+  );
+  const sourceMappedCallSiteLines = sourceMappedStackTrace.split("\n").slice(1);
+  for (let i5 = 0; i5 < callSiteLines.length; i5++) {
+    if (callSites[i5].getFileName() === void 0) {
+      continue;
     }
-    __name(SafeBuffer, "SafeBuffer");
-    SafeBuffer.prototype = Object.create(Buffer7.prototype);
-    copyProps(Buffer7, SafeBuffer);
-    SafeBuffer.from = function(arg, encodingOrOffset, length) {
-      if (typeof arg === "number") {
-        throw new TypeError("Argument must not be a number");
-      }
-      return Buffer7(arg, encodingOrOffset, length);
-    };
-    SafeBuffer.alloc = function(size, fill2, encoding) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      var buf = Buffer7(size);
-      if (fill2 !== void 0) {
-        if (typeof encoding === "string") {
-          buf.fill(fill2, encoding);
-        } else {
-          buf.fill(fill2);
-        }
-      } else {
-        buf.fill(0);
-      }
-      return buf;
-    };
-    SafeBuffer.allocUnsafe = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return Buffer7(size);
-    };
-    SafeBuffer.allocUnsafeSlow = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return buffer.SlowBuffer(size);
-    };
+    const callSiteLine = callSiteLines[i5][0];
+    const callSiteAtIndex = callSiteLine.indexOf("at");
+    (0, import_node_assert4.default)(callSiteAtIndex !== -1);
+    const callSiteLineLeftPad = callSiteLine.substring(0, callSiteAtIndex);
+    value = value.replace(
+      callSiteLine,
+      callSiteLineLeftPad + sourceMappedCallSiteLines[i5].trimStart()
+    );
   }
-});
-
-// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js
-var require_base64 = __commonJS({
-  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js"(exports2, module3) {
-    init_import_meta_url();
-    var safeBuffer = require_safe_buffer().Buffer;
-    function decodeBase64(base642) {
-      return safeBuffer.from(base642, "base64").toString("utf8");
+  return value;
+}
+function lineMatchToCallSite(lineMatch) {
+  let object = null;
+  let method = null;
+  let functionName = null;
+  let typeName = null;
+  let methodName = null;
+  const isNative = lineMatch[5] === "native";
+  if (lineMatch[1]) {
+    functionName = lineMatch[1];
+    let methodStart = functionName.lastIndexOf(".");
+    if (functionName[methodStart - 1] == ".") {
+      methodStart--;
     }
-    __name(decodeBase64, "decodeBase64");
-    function encodeBase64(string) {
-      return safeBuffer.from(string, "utf8").toString("base64");
+    if (methodStart > 0) {
+      object = functionName.substring(0, methodStart);
+      method = functionName.substring(methodStart + 1);
+      const objectEnd = object.indexOf(".Module");
+      if (objectEnd > 0) {
+        functionName = functionName.substring(objectEnd + 1);
+        object = object.substring(0, objectEnd);
+      }
     }
-    __name(encodeBase64, "encodeBase64");
-    module3.exports = {
-      decodeBase64,
-      encodeBase64
-    };
   }
-});
-
-// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js
-var require_registry_auth_token = __commonJS({
-  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js"(exports2, module3) {
+  if (method) {
+    typeName = object;
+    methodName = method;
+  }
+  if (method === "<anonymous>") {
+    methodName = null;
+    functionName = null;
+  }
+  return new CallSite({
+    typeName,
+    functionName,
+    methodName,
+    fileName: lineMatch[2],
+    lineNumber: parseInt(lineMatch[3]) || null,
+    columnNumber: parseInt(lineMatch[4]) || null,
+    native: isNative
+  });
+}
+var import_node_assert4, import_node_url6, import_miniflare7, sourceMappingPrepareStackTrace, retrieveSourceMapOverride, placeholderError, CALL_SITE_REGEXP, CallSite;
+var init_sourcemap = __esm({
+  "src/sourcemap.ts"() {
     init_import_meta_url();
-    var url4 = require("url");
-    var base642 = require_base64();
-    var decodeBase64 = base642.decodeBase64;
-    var encodeBase64 = base642.encodeBase64;
-    var tokenKey = ":_authToken";
-    var userKey = ":username";
-    var passwordKey = ":_password";
-    module3.exports = function() {
-      var checkUrl2;
-      var options;
-      if (arguments.length >= 2) {
-        checkUrl2 = arguments[0];
-        options = arguments[1];
-      } else if (typeof arguments[0] === "string") {
-        checkUrl2 = arguments[0];
-      } else {
-        options = arguments[0];
+    import_node_assert4 = __toESM(require("assert"));
+    import_node_url6 = __toESM(require("url"));
+    init_workers_shared();
+    import_miniflare7 = require("miniflare");
+    __name(maybeRetrieveFileSourceMap, "maybeRetrieveFileSourceMap");
+    __name(getSourceMappingPrepareStackTrace, "getSourceMappingPrepareStackTrace");
+    __name(getSourceMappedStack, "getSourceMappedStack");
+    __name(callFrameToCallSite, "callFrameToCallSite");
+    placeholderError = new Error();
+    __name(getSourceMappedString, "getSourceMappedString");
+    CALL_SITE_REGEXP = // Validation errors from `wrangler deploy` have a 2 space indent, whereas
+    // regular stack traces have a 4 space indent.
+    // eslint-disable-next-line no-control-regex
+    /^(?:\s+(?:\x1B\[\d+m)?'?)? {2,4}at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/gm;
+    __name(lineMatchToCallSite, "lineMatchToCallSite");
+    CallSite = class {
+      constructor(opts) {
+        this.opts = opts;
       }
-      options = options || {};
-      options.npmrc = options.npmrc || require_rc()("npm", { registry: "https://registry.npmjs.org/" });
-      checkUrl2 = checkUrl2 || options.npmrc.registry;
-      return getRegistryAuthInfo(checkUrl2, options) || getLegacyAuthInfo(options.npmrc);
-    };
-    function getRegistryAuthInfo(checkUrl2, options) {
-      var parsed = url4.parse(checkUrl2, false, true);
-      var pathname;
-      while (pathname !== "/" && parsed.pathname !== pathname) {
-        pathname = parsed.pathname || "/";
-        var regUrl = "//" + parsed.host + pathname.replace(/\/$/, "");
-        var authInfo = getAuthInfoForUrl(regUrl, options.npmrc);
-        if (authInfo) {
-          return authInfo;
-        }
-        if (!options.recursive) {
-          return /\/$/.test(checkUrl2) ? void 0 : getRegistryAuthInfo(url4.resolve(checkUrl2, "."), options);
-        }
-        parsed.pathname = url4.resolve(normalizePath2(pathname), "..") || "/";
+      static {
+        __name(this, "CallSite");
       }
-      return void 0;
-    }
-    __name(getRegistryAuthInfo, "getRegistryAuthInfo");
-    function getLegacyAuthInfo(npmrc) {
-      if (npmrc._auth) {
-        return { token: npmrc._auth, type: "Basic" };
+      getScriptHash() {
+        throw new Error("Method not implemented.");
       }
-      return void 0;
-    }
-    __name(getLegacyAuthInfo, "getLegacyAuthInfo");
-    function normalizePath2(path72) {
-      return path72[path72.length - 1] === "/" ? path72 : path72 + "/";
-    }
-    __name(normalizePath2, "normalizePath");
-    function getAuthInfoForUrl(regUrl, npmrc) {
-      var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + "/" + tokenKey]);
-      if (bearerAuth) {
-        return bearerAuth;
+      getEnclosingColumnNumber() {
+        throw new Error("Method not implemented.");
       }
-      var username = npmrc[regUrl + userKey] || npmrc[regUrl + "/" + userKey];
-      var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + "/" + passwordKey];
-      var basicAuth = getTokenForUsernameAndPassword(username, password);
-      if (basicAuth) {
-        return basicAuth;
+      getEnclosingLineNumber() {
+        throw new Error("Method not implemented.");
       }
-      return void 0;
-    }
-    __name(getAuthInfoForUrl, "getAuthInfoForUrl");
-    function getBearerToken(tok) {
-      if (!tok) {
-        return void 0;
+      getPosition() {
+        throw new Error("Method not implemented.");
       }
-      var token = tok.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
-        return process.env[envVar];
-      });
-      return { token, type: "Bearer" };
-    }
-    __name(getBearerToken, "getBearerToken");
-    function getTokenForUsernameAndPassword(username, password) {
-      if (!username || !password) {
+      getThis() {
+        return null;
+      }
+      getTypeName() {
+        return this.opts.typeName;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+      getFunction() {
         return void 0;
       }
-      var pass2 = decodeBase64(password.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
-        return process.env[envVar];
-      }));
-      var token = encodeBase64(username + ":" + pass2);
-      return {
-        token,
-        type: "Basic",
-        password: pass2,
-        username
-      };
-    }
-    __name(getTokenForUsernameAndPassword, "getTokenForUsernameAndPassword");
-  }
-});
-
-// ../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js
-var require_update_check = __commonJS({
-  "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports2, module3) {
-    init_import_meta_url();
-    var { URL: URL7 } = require("url");
-    var { join: join24 } = require("path");
-    var fs24 = require("fs");
-    var { promisify: promisify3 } = require("util");
-    var { tmpdir } = require("os");
-    var registryUrl = require_registry_url();
-    var writeFile11 = promisify3(fs24.writeFile);
-    var mkdir6 = promisify3(fs24.mkdir);
-    var readFile18 = promisify3(fs24.readFile);
-    var compareVersions = /* @__PURE__ */ __name((a5, b6) => a5.localeCompare(b6, "en-US", { numeric: true }), "compareVersions");
-    var encode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
-    var getFile = /* @__PURE__ */ __name(async (details, distTag) => {
-      const rootDir = tmpdir();
-      const subDir = join24(rootDir, "update-check");
-      if (!fs24.existsSync(subDir)) {
-        await mkdir6(subDir);
+      getFunctionName() {
+        return this.opts.functionName;
       }
-      let name2 = `${details.name}-${distTag}.json`;
-      if (details.scope) {
-        name2 = `${details.scope}-${name2}`;
+      getMethodName() {
+        return this.opts.methodName;
       }
-      return join24(subDir, name2);
-    }, "getFile");
-    var evaluateCache = /* @__PURE__ */ __name(async (file, time, interval) => {
-      if (fs24.existsSync(file)) {
-        const content = await readFile18(file, "utf8");
-        const { lastUpdate, latest } = JSON.parse(content);
-        const nextCheck = lastUpdate + interval;
-        if (nextCheck > time) {
-          return {
-            shouldCheck: false,
-            latest
-          };
-        }
+      getFileName() {
+        return this.opts.fileName ?? null;
       }
-      return {
-        shouldCheck: true,
-        latest: null
-      };
-    }, "evaluateCache");
-    var updateCache = /* @__PURE__ */ __name(async (file, latest, lastUpdate) => {
-      const content = JSON.stringify({
-        latest,
-        lastUpdate
-      });
-      await writeFile11(file, content, "utf8");
-    }, "updateCache");
-    var loadPackage = /* @__PURE__ */ __name((url4, authInfo) => new Promise((resolve25, reject) => {
-      const options = {
-        host: url4.hostname,
-        path: url4.pathname,
-        port: url4.port,
-        headers: {
-          accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
-        },
-        timeout: 2e3
-      };
-      if (authInfo) {
-        options.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+      getScriptNameOrSourceURL() {
+        return this.opts.fileName;
       }
-      const { get: get2 } = url4.protocol === "https:" ? require("https") : require("http");
-      get2(options, (response) => {
-        const { statusCode } = response;
-        if (statusCode !== 200) {
-          const error2 = new Error(`Request failed with code ${statusCode}`);
-          error2.code = statusCode;
-          reject(error2);
-          response.resume();
-          return;
-        }
-        let rawData = "";
-        response.setEncoding("utf8");
-        response.on("data", (chunk) => {
-          rawData += chunk;
-        });
-        response.on("end", () => {
-          try {
-            const parsedData = JSON.parse(rawData);
-            resolve25(parsedData);
-          } catch (e7) {
-            reject(e7);
-          }
-        });
-      }).on("error", reject).on("timeout", reject);
-    }), "loadPackage");
-    var getMostRecent = /* @__PURE__ */ __name(async ({ full, scope }, distTag) => {
-      const regURL = registryUrl(scope);
-      const url4 = new URL7(full, regURL);
-      let spec = null;
-      try {
-        spec = await loadPackage(url4);
-      } catch (err) {
-        if (err.code && String(err.code).startsWith(4)) {
-          const registryAuthToken = require_registry_auth_token();
-          const authInfo = registryAuthToken(regURL, { recursive: true });
-          spec = await loadPackage(url4, authInfo);
-        } else {
-          throw err;
-        }
+      getLineNumber() {
+        return this.opts.lineNumber;
       }
-      const version5 = spec["dist-tags"][distTag];
-      if (!version5) {
-        throw new Error(`Distribution tag ${distTag} is not available`);
+      getColumnNumber() {
+        return this.opts.columnNumber;
       }
-      return version5;
-    }, "getMostRecent");
-    var defaultConfig = {
-      interval: 36e5,
-      distTag: "latest"
-    };
-    var getDetails = /* @__PURE__ */ __name((name2) => {
-      const spec = {
-        full: encode(name2)
-      };
-      if (name2.includes("/")) {
-        const parts = name2.split("/");
-        spec.scope = parts[0];
-        spec.name = parts[1];
-      } else {
-        spec.scope = null;
-        spec.name = name2;
+      getEvalOrigin() {
+        return void 0;
       }
-      return spec;
-    }, "getDetails");
-    module3.exports = async (pkg, config) => {
-      if (typeof pkg !== "object") {
-        throw new Error("The first parameter should be your package.json file content");
+      isToplevel() {
+        return false;
       }
-      const details = getDetails(pkg.name);
-      const time = Date.now();
-      const { distTag, interval } = Object.assign({}, defaultConfig, config);
-      const file = await getFile(details, distTag);
-      let latest = null;
-      let shouldCheck = true;
-      ({ shouldCheck, latest } = await evaluateCache(file, time, interval));
-      if (shouldCheck) {
-        latest = await getMostRecent(details, distTag);
-        await updateCache(file, latest, time);
+      isEval() {
+        return false;
       }
-      const comparision = compareVersions(pkg.version, latest);
-      if (comparision === -1) {
-        return {
-          latest,
-          fromCache: !shouldCheck
-        };
+      isNative() {
+        return this.opts.native;
+      }
+      isConstructor() {
+        return false;
+      }
+      isAsync() {
+        return false;
+      }
+      isPromiseAll() {
+        return false;
+      }
+      isPromiseAny() {
+        return false;
+      }
+      getPromiseIndex() {
+        return null;
       }
-      return null;
     };
   }
 });
 
-// src/update-check.ts
-async function doUpdateCheck() {
-  let update = null;
-  const pkg = { name, version };
+// src/dev/miniflare/stdio.ts
+function handleRuntimeStdioWithStructuredLogs(stdout2, stderr2) {
+  stdout2.on("data", getProcessStreamDataListener("stdout"));
+  stderr2.on("data", getProcessStreamDataListener("stderr"));
+}
+function getProcessStreamDataListener(processStream) {
+  let streamAccumulator = "";
+  return (chunk) => {
+    const fullStreamOutput = `${streamAccumulator}${chunk}`;
+    let currentLogsStr = "";
+    const lastNewlineIdx = fullStreamOutput.lastIndexOf("\n");
+    if (lastNewlineIdx > 0) {
+      currentLogsStr = fullStreamOutput.slice(0, lastNewlineIdx);
+      streamAccumulator = fullStreamOutput.slice(lastNewlineIdx + 1);
+    } else {
+      streamAccumulator = fullStreamOutput;
+    }
+    const lines = currentLogsStr.split("\n");
+    for (const line of lines) {
+      const structuredLog = parseStructuredLog(line);
+      if (structuredLog) {
+        logStructuredLog(structuredLog, processStream);
+      } else {
+        const level = processStream === "stdout" ? "log" : "error";
+        logger[level](line);
+      }
+    }
+  };
+}
+function parseStructuredLog(str) {
   try {
-    update = await (0, import_update_check.default)(pkg, {
-      distTag: pkg.version.startsWith("0.0.0") ? "beta" : "latest"
-    });
+    const maybeStructuredLog = JSON.parse(str);
+    if (typeof maybeStructuredLog !== "object" || maybeStructuredLog === null) {
+      return null;
+    }
+    const timestamp = parseInt(maybeStructuredLog.timestamp);
+    if (isNaN(timestamp) || typeof maybeStructuredLog.level !== "string" || typeof maybeStructuredLog.message !== "string") {
+      return null;
+    }
+    return {
+      timestamp,
+      level: maybeStructuredLog.level,
+      message: maybeStructuredLog.message
+    };
   } catch {
+    return null;
   }
-  return update?.latest;
 }
-function updateCheck() {
-  return updateCheckPromise ??= doUpdateCheck();
-}
-var import_update_check, updateCheckPromise;
-var init_update_check = __esm({
-  "src/update-check.ts"() {
-    init_import_meta_url();
-    import_update_check = __toESM(require_update_check());
-    init_package();
-    __name(doUpdateCheck, "doUpdateCheck");
-    __name(updateCheck, "updateCheck");
+function logStructuredLog({ level, message }, processStream) {
+  if (messageClassifiers.isBarf(message)) {
+    if (messageClassifiers.isAddressInUse(message)) {
+      const address = message.match(
+        /Address already in use; toString\(\) = (.+)\n/
+      )?.[1];
+      logger.error(
+        `Address already in use (${address}). Please check that you are not already running a server on this address or specify a different port with --port.`
+      );
+      return logger.debug(message);
+    }
+    if (messageClassifiers.isAccessViolation(message)) {
+      let error2 = "There was an access violation in the runtime.";
+      if (process.platform === "win32") {
+        error2 += "\nOn Windows, this may be caused by an outdated Microsoft Visual C++ Redistributable library.\nCheck that you have the latest version installed.\nSee https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist.";
+      }
+      logger.error(error2);
+      return logger.debug(message);
+    }
+    return logger.debug(message);
+  }
+  if ((level === "info" || level === "error") && messageClassifiers.isCodeMovedWarning(message)) {
+    return;
+  }
+  if (level === "warn") {
+    return logger.warn(message);
+  }
+  if (level === "info") {
+    return logger.info(message);
+  }
+  if (level === "debug") {
+    return logger.debug(message);
+  }
+  if (level === "error") {
+    return logger.error(getSourceMappedString(message));
+  }
+  if (processStream === "stderr") {
+    return logger.error(getSourceMappedString(message));
+  } else {
+    return logger.log(getSourceMappedString(message));
   }
-});
-
-// src/vectorize/fetcher.ts
-function MakeVectorizeFetcher(complianceConfig, indexId) {
-  return async function(request4) {
-    const accountId = await getAccountId(complianceConfig);
-    request4.headers.delete("Host");
-    request4.headers.delete("Content-Length");
-    let op = request4.url.split("/").pop() || "";
-    op = URL_SUBSTITUTIONS.get(op) || op;
-    const base = `/accounts/${accountId}/vectorize/v2/indexes/${indexId}/`;
-    const url4 = base + op;
-    const res = await performApiFetch(complianceConfig, url4, {
-      method: request4.method,
-      headers: Object.fromEntries(request4.headers.entries()),
-      body: request4.body,
-      duplex: "half"
-    });
-    const respHeaders = new import_miniflare7.Headers(res.headers);
-    respHeaders.delete("Host");
-    respHeaders.delete("Content-Length");
-    const apiResponse = await res.json();
-    const newResponse = apiResponse.success ? apiResponse.result : {
-      error: apiResponse.errors[0].message,
-      code: apiResponse.errors[0].code
-    };
-    return new import_miniflare7.Response(JSON.stringify(newResponse), {
-      status: res.status,
-      headers: respHeaders
-    });
-  };
 }
-var import_miniflare7, EXTERNAL_VECTORIZE_WORKER_NAME, EXTERNAL_VECTORIZE_WORKER_SCRIPT, URL_SUBSTITUTIONS;
-var init_fetcher3 = __esm({
-  "src/vectorize/fetcher.ts"() {
+var messageClassifiers;
+var init_stdio = __esm({
+  "src/dev/miniflare/stdio.ts"() {
     init_import_meta_url();
-    import_miniflare7 = require("miniflare");
-    init_internal();
-    init_user2();
-    EXTERNAL_VECTORIZE_WORKER_NAME = "__WRANGLER_EXTERNAL_VECTORIZE_WORKER";
-    EXTERNAL_VECTORIZE_WORKER_SCRIPT = `
-import makeBinding from 'cloudflare-internal:vectorize-api'
-
-export default function (env) {
-    return makeBinding({
-        fetcher: env.FETCHER,
-        indexId: env.INDEX_ID,
-        indexVersion: env.INDEX_VERSION,
-        useNdJson: true,
-    });
-}
-`;
-    URL_SUBSTITUTIONS = /* @__PURE__ */ new Map([
-      ["getByIds", "get_by_ids"],
-      ["deleteByIds", "delete_by_ids"]
-    ]);
-    __name(MakeVectorizeFetcher, "MakeVectorizeFetcher");
-  }
-});
-
-// src/dev/class-names-sqlite.ts
-function getClassNamesWhichUseSQLite(migrations) {
-  const classNamesWhichUseSQLite = /* @__PURE__ */ new Map();
-  (migrations || []).forEach((migration) => {
-    migration.deleted_classes?.forEach((deleted_class) => {
-      if (!classNamesWhichUseSQLite.delete(deleted_class)) {
-        throw new UserError(
-          `Cannot apply deleted_classes migration to non-existent class ${deleted_class}`
-        );
-      }
-    });
-    migration.renamed_classes?.forEach(({ from, to }) => {
-      const useSQLite = classNamesWhichUseSQLite.get(from);
-      if (useSQLite === void 0) {
-        throw new UserError(
-          `Cannot apply renamed_classes migration to non-existent class ${from}`
-        );
-      } else {
-        classNamesWhichUseSQLite.delete(from);
-        classNamesWhichUseSQLite.set(to, useSQLite);
-      }
-    });
-    migration.new_classes?.forEach((new_class) => {
-      if (classNamesWhichUseSQLite.has(new_class)) {
-        throw new UserError(
-          `Cannot apply new_classes migration to existing class ${new_class}`
+    init_logger();
+    init_sourcemap();
+    __name(handleRuntimeStdioWithStructuredLogs, "handleRuntimeStdioWithStructuredLogs");
+    __name(getProcessStreamDataListener, "getProcessStreamDataListener");
+    __name(parseStructuredLog, "parseStructuredLog");
+    __name(logStructuredLog, "logStructuredLog");
+    messageClassifiers = {
+      // Is this chunk a big chonky barf from workerd that we want to hijack to cleanup/ignore?
+      isBarf(chunk) {
+        const containsLlvmSymbolizerWarning = chunk.includes(
+          "Not symbolizing stack traces because $LLVM_SYMBOLIZER is not set"
         );
-      } else {
-        classNamesWhichUseSQLite.set(new_class, false);
-      }
-    });
-    migration.new_sqlite_classes?.forEach((new_class) => {
-      if (classNamesWhichUseSQLite.has(new_class)) {
-        throw new UserError(
-          `Cannot apply new_sqlite_classes migration to existing class ${new_class}`
+        const containsRecursiveIsolateLockWarning = chunk.includes(
+          "took recursive isolate lock"
         );
-      } else {
-        classNamesWhichUseSQLite.set(new_class, true);
+        const containsHexStack = /stack:( (0|[a-f\d]{4,})){3,}/.test(chunk);
+        return containsLlvmSymbolizerWarning || containsRecursiveIsolateLockWarning || containsHexStack;
+      },
+      // Is this chunk an Address In Use error?
+      isAddressInUse(chunk) {
+        return chunk.includes("Address already in use; toString() = ");
+      },
+      isCodeMovedWarning(chunk) {
+        return /CODE_MOVED for unknown code block/.test(chunk);
+      },
+      isAccessViolation(chunk) {
+        return chunk.includes("access violation;");
       }
-    });
-  });
-  return classNamesWhichUseSQLite;
-}
-var init_class_names_sqlite = __esm({
-  "src/dev/class-names-sqlite.ts"() {
-    init_import_meta_url();
-    init_errors();
-    __name(getClassNamesWhichUseSQLite, "getClassNamesWhichUseSQLite");
+    };
   }
 });
 
-// src/dev/miniflare.ts
+// src/dev/miniflare/index.ts
 function getName(config) {
   return config.name ?? DEFAULT_WORKER_NAME;
 }
@@ -58708,72 +59006,6 @@ function buildSitesOptions({
     };
   }
 }
-function handleRuntimeStdio(stdout2, stderr2) {
-  const classifiers = {
-    // Is this chunk a big chonky barf from workerd that we want to hijack to cleanup/ignore?
-    isBarf(chunk) {
-      const containsLlvmSymbolizerWarning = chunk.includes(
-        "Not symbolizing stack traces because $LLVM_SYMBOLIZER is not set"
-      );
-      const containsRecursiveIsolateLockWarning = chunk.includes(
-        "took recursive isolate lock"
-      );
-      const containsHexStack = /stack:( (0|[a-f\d]{4,})){3,}/.test(chunk);
-      return containsLlvmSymbolizerWarning || containsRecursiveIsolateLockWarning || containsHexStack;
-    },
-    // Is this chunk an Address In Use error?
-    isAddressInUse(chunk) {
-      return chunk.includes("Address already in use; toString() = ");
-    },
-    isWarning(chunk) {
-      return /\.c\+\+:\d+: warning:/.test(chunk);
-    },
-    isCodeMovedWarning(chunk) {
-      return /CODE_MOVED for unknown code block/.test(chunk);
-    },
-    isAccessViolation(chunk) {
-      return chunk.includes("access violation;");
-    }
-  };
-  stdout2.on("data", (chunk) => {
-    chunk = chunk.toString().trim();
-    if (classifiers.isBarf(chunk)) {
-      logger.debug(chunk);
-    } else if (classifiers.isWarning(chunk)) {
-      logger.warn(chunk);
-    } else {
-      logger.info(getSourceMappedString(chunk));
-    }
-  });
-  stderr2.on("data", (chunk) => {
-    chunk = chunk.toString().trim();
-    if (classifiers.isBarf(chunk)) {
-      if (classifiers.isAddressInUse(chunk)) {
-        const address = chunk.match(
-          /Address already in use; toString\(\) = (.+)\n/
-        )?.[1];
-        logger.error(
-          `Address already in use (${address}). Please check that you are not already running a server on this address or specify a different port with --port.`
-        );
-        logger.debug(chunk);
-      } else if (classifiers.isAccessViolation(chunk)) {
-        let error2 = "There was an access violation in the runtime.";
-        if (process.platform === "win32") {
-          error2 += "\nOn Windows, this may be caused by an outdated Microsoft Visual C++ Redistributable library.\nCheck that you have the latest version installed.\nSee https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist.";
-        }
-        logger.error(error2);
-        logger.debug(chunk);
-      } else {
-        logger.debug(chunk);
-      }
-    } else if (classifiers.isWarning(chunk)) {
-      logger.warn(chunk);
-    } else if (classifiers.isCodeMovedWarning(chunk)) {
-    } else {
-      logger.error(getSourceMappedString(chunk));
-    }
-  });
-}
 async function buildMiniflareOptions(log2, config, proxyToUserWorkerAuthenticationSecret, remoteProxyConnectionString, remoteBindingsEnabled) {
   if (config.crons?.length && !config.testScheduled) {
     if (!didWarnMiniflareCronSupport) {
@@ -58802,7 +59034,7 @@ async function buildMiniflareOptions(log2, config, proxyToUserWorkerAuthenticati
       if (!didWarnMiniflareVectorizeSupport) {
         didWarnMiniflareVectorizeSupport = true;
         logger.warn(
-          "You are using a mixed-mode binding for Vectorize (through `--experimental-vectorize-bind-to-prod`). It may incur usage charges and modify your databases even in local development. "
+          "You are using Vectorize as a remote binding (through `--experimental-vectorize-bind-to-prod`). It may incur usage charges and modify your databases even in local development. "
         );
       }
     }
@@ -58834,7 +59066,8 @@ async function buildMiniflareOptions(log2, config, proxyToUserWorkerAuthenticati
     logRequests: false,
     log: log2,
     verbose: logger.loggerLevel === "debug",
-    handleRuntimeStdio,
+    handleRuntimeStdio: handleRuntimeStdioWithStructuredLogs,
+    structuredWorkerdLogs: true,
     defaultPersistRoot,
     workers: [
       {
@@ -58878,7 +59111,7 @@ function getImageNameFromDOClassName(options) {
 }
 var import_node_assert5, import_node_crypto4, import_node_path16, import_miniflare8, EXTERNAL_SERVICE_WORKER_NAME, EXTERNAL_SERVICE_WORKER_SCRIPT, WranglerLog, DEFAULT_WORKER_NAME, IDENTIFIER_UNSAFE_REGEXP, didWarnMiniflareCronSupport, didWarnMiniflareVectorizeSupport, didWarnAiAccountUsage;
 var init_miniflare = __esm({
-  "src/dev/miniflare.ts"() {
+  "src/dev/miniflare/index.ts"() {
     init_import_meta_url();
     import_node_assert5 = __toESM(require("assert"));
     import_node_crypto4 = require("crypto");
@@ -58891,11 +59124,11 @@ var init_miniflare = __esm({
     init_errors();
     init_fetcher2();
     init_logger();
-    init_sourcemap();
     init_update_check();
     init_print_bindings();
     init_fetcher3();
     init_class_names_sqlite();
+    init_stdio();
     EXTERNAL_SERVICE_WORKER_NAME = "__WRANGLER_EXTERNAL_DURABLE_OBJECTS_WORKER";
     EXTERNAL_SERVICE_WORKER_SCRIPT = `
 import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
@@ -59053,7 +59286,6 @@ export default {
     __name(getDefaultPersistRoot, "getDefaultPersistRoot");
     __name(buildAssetOptions, "buildAssetOptions");
     __name(buildSitesOptions, "buildSitesOptions");
-    __name(handleRuntimeStdio, "handleRuntimeStdio");
     didWarnMiniflareCronSupport = false;
     didWarnMiniflareVectorizeSupport = false;
     didWarnAiAccountUsage = false;
@@ -59546,12 +59778,12 @@ async function getPorts(options) {
   }
   throw new Error("No available ports found");
 }
-var import_node_net, import_node_os3, Locked, lockedPorts, releaseOldLockedPortsIntervalMs, timeout, getLocalHosts, checkAvailablePort, getAvailablePort, portCheckSequence;
+var import_node_net, import_node_os4, Locked, lockedPorts, releaseOldLockedPortsIntervalMs, timeout, getLocalHosts, checkAvailablePort, getAvailablePort, portCheckSequence;
 var init_get_port = __esm({
   "../../node_modules/.pnpm/get-port@7.0.0/node_modules/get-port/index.js"() {
     init_import_meta_url();
     import_node_net = __toESM(require("net"), 1);
-    import_node_os3 = __toESM(require("os"), 1);
+    import_node_os4 = __toESM(require("os"), 1);
     Locked = class extends Error {
       static {
         __name(this, "Locked");
@@ -59566,7 +59798,7 @@ var init_get_port = __esm({
     };
     releaseOldLockedPortsIntervalMs = 1e3 * 15;
     getLocalHosts = /* @__PURE__ */ __name(() => {
-      const interfaces = import_node_os3.default.networkInterfaces();
+      const interfaces = import_node_os4.default.networkInterfaces();
       const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
       for (const _interface of Object.values(interfaces)) {
         for (const config of _interface) {
@@ -63476,7 +63708,7 @@ ${error2.message}` : execaMessage;
 
 // ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stdio.js
 var aliases, hasAlias, normalizeStdio;
-var init_stdio = __esm({
+var init_stdio2 = __esm({
   "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stdio.js"() {
     init_import_meta_url();
     aliases = ["stdin", "stdout", "stderr"];
@@ -63505,11 +63737,11 @@ var init_stdio = __esm({
 });
 
 // ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/kill.js
-var import_node_os4, import_signal_exit4, DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill, setKillTimeout, shouldForceKill, isSigterm, getForceKillAfterTimeout, spawnedCancel, timeoutKill, setupTimeout, validateTimeout, setExitHandler;
+var import_node_os5, import_signal_exit4, DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill, setKillTimeout, shouldForceKill, isSigterm, getForceKillAfterTimeout, spawnedCancel, timeoutKill, setupTimeout, validateTimeout, setExitHandler;
 var init_kill = __esm({
   "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/kill.js"() {
     init_import_meta_url();
-    import_node_os4 = __toESM(require("os"), 1);
+    import_node_os5 = __toESM(require("os"), 1);
     import_signal_exit4 = __toESM(require_signal_exit(), 1);
     DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
     spawnedKill = /* @__PURE__ */ __name((kill, signal = "SIGTERM", options = {}) => {
@@ -63530,7 +63762,7 @@ var init_kill = __esm({
       }
     }, "setKillTimeout");
     shouldForceKill = /* @__PURE__ */ __name((signal, { forceKillAfterTimeout }, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult, "shouldForceKill");
-    isSigterm = /* @__PURE__ */ __name((signal) => signal === import_node_os4.default.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM", "isSigterm");
+    isSigterm = /* @__PURE__ */ __name((signal) => signal === import_node_os5.default.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM", "isSigterm");
     getForceKillAfterTimeout = /* @__PURE__ */ __name(({ forceKillAfterTimeout = true }) => {
       if (forceKillAfterTimeout === true) {
         return DEFAULT_FORCE_KILL_TIMEOUT;
@@ -64040,7 +64272,7 @@ var init_execa = __esm({
     init_npm_run_path();
     init_onetime();
     init_error2();
-    init_stdio();
+    init_stdio2();
     init_kill();
     init_stream();
     init_promise();
@@ -66308,7 +66540,7 @@ function _supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (import_node_process9.default.platform === "win32") {
-    const osRelease = import_node_os5.default.release().split(".");
+    const osRelease = import_node_os6.default.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -66356,12 +66588,12 @@ function createSupportsColor2(stream2, options = {}) {
   });
   return translateLevel2(level);
 }
-var import_node_process9, import_node_os5, import_node_tty3, env3, flagForceColor2, supportsColor2, supports_color_default2;
+var import_node_process9, import_node_os6, import_node_tty3, env3, flagForceColor2, supportsColor2, supports_color_default2;
 var init_supports_color2 = __esm({
   "../../node_modules/.pnpm/supports-color@9.2.2/node_modules/supports-color/index.js"() {
     init_import_meta_url();
     import_node_process9 = __toESM(require("process"), 1);
-    import_node_os5 = __toESM(require("os"), 1);
+    import_node_os6 = __toESM(require("os"), 1);
     import_node_tty3 = __toESM(require("tty"), 1);
     __name(hasFlag2, "hasFlag");
     ({ env: env3 } = import_node_process9.default);
@@ -66952,20 +67184,19 @@ async function handleDeleteImageCommand(args, config) {
 async function handleListImagesCommand(args, config) {
   const responses = await promiseSpinner(
     getCreds().then(async (creds) => {
-      const repos = await listRepos(creds);
-      const responses_ = [];
+      const repos = await listReposWithTags(creds);
+      const processed = [];
       const accountId = config.account_id || await getAccountId(config);
       const accountIdPrefix = new RegExp(`^${accountId}/`);
       const filter = new RegExp(args.filter ?? "");
-      for (const repo of repos) {
+      for (const [repo, tags] of Object.entries(repos)) {
         const stripped = repo.replace(/^\/+/, "");
         if (filter.test(stripped)) {
-          const tags = await listTags(stripped, creds);
           const name2 = stripped.replace(accountIdPrefix, "");
-          responses_.push({ name: name2, tags });
+          processed.push({ name: name2, tags });
         }
       }
-      return responses_;
+      return processed;
     }),
     { message: "Listing" }
   );
@@ -66998,22 +67229,9 @@ async function listImages(responses, digests = false, json = false) {
     }
   }
 }
-async function listTags(repo, creds) {
-  const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
-  const baseUrl = `${url4.protocol}//${url4.host}`;
-  const tagsUrl = `${baseUrl}/v2/${repo}/tags/list`;
-  const tagsResponse = await fetch(tagsUrl, {
-    method: "GET",
-    headers: {
-      Authorization: `Basic ${creds}`
-    }
-  });
-  const tagsData = await tagsResponse.json();
-  return tagsData.tags || [];
-}
-async function listRepos(creds) {
+async function listReposWithTags(creds) {
   const url4 = new URL(`https://${getCloudflareContainerRegistry()}`);
-  const catalogUrl = `${url4.protocol}//${url4.host}/v2/_catalog`;
+  const catalogUrl = `${url4.protocol}//${url4.host}/v2/_catalog?tags=true`;
   const response = await fetch(catalogUrl, {
     method: "GET",
     headers: {
@@ -67027,7 +67245,7 @@ async function listRepos(creds) {
     );
   }
   const data = await response.json();
-  return data.repositories || [];
+  return data.repositories ?? {};
 }
 async function deleteTag(baseUrl, accountId, image, tag, creds) {
   const manifestAcceptHeader = "application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.v2+json";
@@ -67111,8 +67329,7 @@ var init_images2 = __esm({
     __name(handleDeleteImageCommand, "handleDeleteImageCommand");
     __name(handleListImagesCommand, "handleListImagesCommand");
     __name(listImages, "listImages");
-    __name(listTags, "listTags");
-    __name(listRepos, "listRepos");
+    __name(listReposWithTags, "listReposWithTags");
     __name(deleteTag, "deleteTag");
     __name(getCreds, "getCreds");
   }
@@ -69027,7 +69244,7 @@ function getWranglerVersion() {
   return version;
 }
 function getPlatform() {
-  const platform3 = import_node_os6.default.platform();
+  const platform3 = import_node_os7.default.platform();
   switch (platform3) {
     case "win32":
       return "Windows";
@@ -69043,17 +69260,17 @@ function getOS() {
   return process.platform + ":" + process.arch;
 }
 function getOSVersion() {
-  return import_node_os6.default.version();
+  return import_node_os7.default.version();
 }
 function getNodeVersion() {
   const nodeVersion2 = process.versions.node;
   return parseInt(nodeVersion2.split(".")[0]);
 }
-var import_node_os6;
+var import_node_os7;
 var init_helpers5 = __esm({
   "src/metrics/helpers.ts"() {
     init_import_meta_url();
-    import_node_os6 = __toESM(require("os"));
+    import_node_os7 = __toESM(require("os"));
     init_package();
     __name(getWranglerVersion, "getWranglerVersion");
     __name(getPlatform, "getPlatform");
@@ -69926,26 +70143,6 @@ async function printBundleSize(main2, modules) {
   const colorizedReport = percentage > 90 ? source_default.red(bundleReport) : percentage > 70 ? source_default.yellow(bundleReport) : source_default.green(bundleReport);
   logger.log(`Total Upload: ${colorizedReport}`);
 }
-function printOffendingDependencies(dependencies) {
-  const warning = [];
-  const dependenciesSorted = Object.entries(dependencies);
-  dependenciesSorted.sort(
-    ([_adep, aData], [_bdep, bData]) => bData.bytesInOutput - aData.bytesInOutput
-  );
-  const topLargest = dependenciesSorted.slice(0, 5);
-  if (topLargest.length > 0) {
-    warning.push(
-      `Here are the ${topLargest.length} largest dependencies included in your script:`
-    );
-    for (const [dep, data] of topLargest) {
-      warning.push(
-        `- ${dep} - ${(data.bytesInOutput / ONE_KIB_BYTES).toFixed(2)} KiB`
-      );
-    }
-    warning.push("If these are unnecessary, consider removing them");
-    logger.warn(warning.join("\n"));
-  }
-}
 var import_node_buffer3, import_node_zlib, ONE_KIB_BYTES, MAX_GZIP_SIZE_BYTES;
 var init_bundle_reporter = __esm({
   "src/deployment-bundle/bundle-reporter.ts"() {
@@ -69958,7 +70155,6 @@ var init_bundle_reporter = __esm({
     MAX_GZIP_SIZE_BYTES = 3 * ONE_KIB_BYTES * ONE_KIB_BYTES;
     __name(getSize, "getSize");
     __name(printBundleSize, "printBundleSize");
-    __name(printOffendingDependencies, "printOffendingDependencies");
   }
 });
 
@@ -82210,7 +82406,7 @@ var require_main = __commonJS({
     init_import_meta_url();
     var fs24 = require("fs");
     var path72 = require("path");
-    var os11 = require("os");
+    var os12 = require("os");
     var crypto8 = require("crypto");
     var packageJson = require_package();
     var version5 = packageJson.version;
@@ -82316,7 +82512,7 @@ var require_main = __commonJS({
     }
     __name(_vaultPath, "_vaultPath");
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path72.join(os11.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path72.join(os12.homedir(), envPath.slice(1)) : envPath;
     }
     __name(_resolveHome, "_resolveHome");
     function _configVault(options) {
@@ -84927,6 +85123,9 @@ function renderScriptName(details) {
 function isUsedAsServiceBinding(references) {
   return (references.services?.incoming.length || 0) > 0;
 }
+function isUsedByPagesFunction(references) {
+  return references.services?.pages_function === true;
+}
 function isUsedAsDurableObjectNamespace(references, scriptName) {
   return (references.durable_objects?.filter((ref) => ref.service !== scriptName)?.length || 0) > 0;
 }
@@ -84945,7 +85144,7 @@ async function checkAndConfirmForceDeleteIfNecessary(complianceConfig, scriptNam
     complianceConfig,
     `/accounts/${accountId}/workers/tails/by-consumer/${scriptName}`
   );
-  const isDependentService = isUsedAsServiceBinding(references) || isUsedAsDurableObjectNamespace(references, scriptName) || isUsedAsDispatchOutbound(references) || isUsedAsTailConsumer(tailProducers);
+  const isDependentService = isUsedAsServiceBinding(references) || isUsedByPagesFunction(references) || isUsedAsDurableObjectNamespace(references, scriptName) || isUsedAsDispatchOutbound(references) || isUsedAsTailConsumer(tailProducers);
   if (!isDependentService) {
     return false;
   }
@@ -84956,6 +85155,11 @@ async function checkAndConfirmForceDeleteIfNecessary(complianceConfig, scriptNam
       `- Worker ${dependentScript} uses this Worker as a Service Binding`
     );
   }
+  if (isUsedByPagesFunction(references)) {
+    dependentMessages.push(
+      `- A Pages project has a Service Binding to this Worker`
+    );
+  }
   for (const implementedDOBindingReference of references.durable_objects || []) {
     if (implementedDOBindingReference.service === scriptName) {
       continue;
@@ -85087,6 +85291,7 @@ var init_delete3 = __esm({
     __name(deleteSiteNamespaceIfExisting, "deleteSiteNamespaceIfExisting");
     __name(renderScriptName, "renderScriptName");
     __name(isUsedAsServiceBinding, "isUsedAsServiceBinding");
+    __name(isUsedByPagesFunction, "isUsedByPagesFunction");
     __name(isUsedAsDurableObjectNamespace, "isUsedAsDurableObjectNamespace");
     __name(isUsedAsDispatchOutbound, "isUsedAsDispatchOutbound");
     __name(isUsedAsTailConsumer, "isUsedAsTailConsumer");
@@ -93054,6 +93259,7 @@ var init_deploy6 = __esm({
     init_logger();
     init_metrics();
     init_output();
+    init_parse();
     init_user2();
     init_friendly_validator_errors();
     init_constants();
@@ -93382,10 +93588,18 @@ To silence this warning, pass in --commit-dirty=true`
           );
           const failureMessage = logs.data[logs.total - 1].line.replace("Error:", "").trim();
           if (failureMessage.includes("Script startup exceeded CPU time limit")) {
+            const startupError = new ParseError({ text: failureMessage });
+            Object.assign(startupError, { code: 10021 });
             const workerBundle = formData.get("_worker.bundle");
             const filePath = import_node_path47.default.join(getPagesTmpDir(), "_worker.bundle");
             await (0, import_promises22.writeFile)(filePath, workerBundle.stream());
-            await handleStartupError(filePath, getPagesProjectRoot());
+            throw new UserError(
+              await diagnoseStartupError(
+                startupError,
+                filePath,
+                getPagesProjectRoot()
+              )
+            );
           }
           throw new FatalError(
             `Deployment failed!
@@ -132786,7 +133000,7 @@ var init_bucket = __esm({
       positionalArgs: ["bucket"],
       args: {
         bucket: {
-          describe: "The name of the bucket to delete",
+          describe: "The name of the bucket to retrieve info for",
           type: "string",
           demandOption: true
         },
@@ -132795,11 +133009,21 @@ var init_bucket = __esm({
           alias: "J",
           requiresArg: true,
           type: "string"
+        },
+        json: {
+          describe: "Return the bucket information as JSON",
+          type: "boolean",
+          default: false
         }
       },
+      behaviour: {
+        printBanner: /* @__PURE__ */ __name((args) => !args.json, "printBanner")
+      },
       async handler(args, { config }) {
         const accountId = await requireAuth(config);
-        logger.log(`Getting info for '${args.bucket}'...`);
+        if (!args.json) {
+          logger.log(`Getting info for '${args.bucket}'...`);
+        }
         const bucketInfo = await getR2Bucket(
           config,
           accountId,
@@ -132820,7 +133044,11 @@ var init_bucket = __esm({
           object_count: bucketMetrics.objectCount.toLocaleString(),
           bucket_size: bucketMetrics.totalSize
         };
-        logger.log(formatLabelledValues(output));
+        if (args.json) {
+          logger.json(output);
+        } else {
+          logger.log(formatLabelledValues(output));
+        }
       }
     });
     r2BucketDeleteCommand = createCommand({
@@ -143490,11 +143718,11 @@ var init_esm8 = __esm({
 });
 
 // ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/client.js
-var os7, import_util15, NodeClient;
+var os8, import_util15, NodeClient;
 var init_client9 = __esm({
   "../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/client.js"() {
     init_import_meta_url();
-    os7 = __toESM(require("os"));
+    os8 = __toESM(require("os"));
     import_util15 = require("util");
     init_esm7();
     NodeClient = class extends ServerRuntimeClient {
@@ -143525,7 +143753,7 @@ var init_client9 = __esm({
           ...options,
           platform: "node",
           runtime: { name: "node", version: global.process.version },
-          serverName: options.serverName || global.process.env.SENTRY_NAME || os7.hostname()
+          serverName: options.serverName || global.process.env.SENTRY_NAME || os8.hostname()
         };
         super(clientOptions);
       }
@@ -145158,7 +145386,7 @@ var init_contextlines = __esm({
 
 // ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/context.js
 async function getOsContext() {
-  const platformId = os8.platform();
+  const platformId = os9.platform();
   switch (platformId) {
     case "darwin":
       return getDarwinInfo();
@@ -145167,7 +145395,7 @@ async function getOsContext() {
     default:
       return {
         name: PLATFORM_NAMES[platformId] || platformId,
-        version: os8.release()
+        version: os9.release()
       };
   }
 }
@@ -145198,19 +145426,19 @@ function getDeviceContext(deviceOpt) {
   const device = {};
   let uptime3;
   try {
-    uptime3 = os8.uptime && os8.uptime();
+    uptime3 = os9.uptime && os9.uptime();
   } catch (e7) {
   }
   if (typeof uptime3 === "number") {
     device.boot_time = new Date(Date.now() - uptime3 * 1e3).toISOString();
   }
-  device.arch = os8.arch();
+  device.arch = os9.arch();
   if (deviceOpt === true || deviceOpt.memory) {
-    device.memory_size = os8.totalmem();
-    device.free_memory = os8.freemem();
+    device.memory_size = os9.totalmem();
+    device.free_memory = os9.freemem();
   }
   if (deviceOpt === true || deviceOpt.cpu) {
-    const cpuInfo = os8.cpus();
+    const cpuInfo = os9.cpus();
     if (cpuInfo && cpuInfo.length) {
       const firstCpu = cpuInfo[0];
       device.processor_count = cpuInfo.length;
@@ -145226,9 +145454,9 @@ function matchFirst(regex2, text) {
 }
 async function getDarwinInfo() {
   const darwinInfo = {
-    kernel_version: os8.release(),
+    kernel_version: os9.release(),
     name: "Mac OS X",
-    version: `10.${Number(os8.release().split(".")[0]) - 4}`
+    version: `10.${Number(os9.release().split(".")[0]) - 4}`
   };
   try {
     const output = await new Promise((resolve25, reject) => {
@@ -145252,7 +145480,7 @@ function getLinuxDistroId(name2) {
 }
 async function getLinuxInfo() {
   const linuxInfo = {
-    kernel_version: os8.release(),
+    kernel_version: os9.release(),
     name: "Linux"
   };
   try {
@@ -145326,14 +145554,14 @@ function getCloudResourceContext() {
     return void 0;
   }
 }
-var import_child_process6, import_fs24, os8, import_path25, import_util16, readFileAsync, readDirAsync, Context, PLATFORM_NAMES, LINUX_DISTROS, LINUX_VERSIONS;
+var import_child_process6, import_fs24, os9, import_path25, import_util16, readFileAsync, readDirAsync, Context, PLATFORM_NAMES, LINUX_DISTROS, LINUX_VERSIONS;
 var init_context = __esm({
   "../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/context.js"() {
     init_import_meta_url();
     init_esm6();
     import_child_process6 = require("child_process");
     import_fs24 = require("fs");
-    os8 = __toESM(require("os"));
+    os9 = __toESM(require("os"));
     import_path25 = require("path");
     import_util16 = require("util");
     readFileAsync = (0, import_util16.promisify)(import_fs24.readFile);
@@ -145397,7 +145625,7 @@ var init_context = __esm({
           contexts.app.app_memory = process.memoryUsage().rss;
         }
         if (_optionalChain([contexts, "optionalAccess", (_13) => _13.device, "optionalAccess", (_14) => _14.free_memory])) {
-          contexts.device.free_memory = os8.freemem();
+          contexts.device.free_memory = os9.freemem();
         }
         return contexts;
       }
@@ -151326,12 +151554,15 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
             config.tail_consumers
           );
         }
-        await helpIfErrorIsSizeOrScriptStartup(
+        const message = await helpIfErrorIsSizeOrScriptStartup(
           err,
           dependencies,
           workerBundle,
           props.projectRoot
         );
+        if (message) {
+          logger.error(message);
+        }
         if (err instanceof ParseError && "code" in err && err.code === 10021 && err.notes.length > 0) {
           const maybeNameToFilePath = /* @__PURE__ */ __name((moduleName) => {
             if (bundleType === "commonjs") {
@@ -156647,6 +156878,7 @@ function createCLIParser(argv) {
 }
 async function main(argv) {
   setupSentry();
+  checkMacOSVersion({ shouldThrow: false });
   const startTime = Date.now();
   const wrangler = createCLIParser(argv);
   let command2;
@@ -156746,7 +156978,7 @@ async function main(argv) {
       logger.log(e7.message);
     } else if (e7 instanceof Error && e7.message.includes("Raw mode is not supported on")) {
       mayReport = false;
-      const currentPlatform = import_node_os7.default.platform();
+      const currentPlatform = import_node_os8.default.platform();
       const thisTerminalIsUnsupported = "This terminal doesn't support raw mode.";
       const soWranglerWontWork = "Wrangler uses raw mode to read user input and write output to the terminal, and won't function correctly without it.";
       const tryRunningItIn = "Try running your previous command in a terminal that supports raw mode";
@@ -156824,14 +157056,15 @@ ${tryRunningItIn}${oneOfThese}`
     }
   }
 }
-var import_node_assert25, import_node_os7, import_node_path55, import_promises31, import_undici20;
+var import_node_assert25, import_node_os8, import_node_path55, import_promises31, import_undici20;
 var init_src = __esm({
   "src/index.ts"() {
     init_import_meta_url();
     import_node_assert25 = __toESM(require("assert"));
-    import_node_os7 = __toESM(require("os"));
+    import_node_os8 = __toESM(require("os"));
     import_node_path55 = require("path");
     import_promises31 = require("timers/promises");
+    init_cli();
     init_containers_shared();
     init_source();
     import_undici20 = __toESM(require_undici());
@@ -157071,11 +157304,13 @@ function getModuleType(entry) {
 }
 async function convertWorkerBundleToModules(workerBundle) {
   return await Promise.all(
-    [...workerBundle.entries()].map(async (m6) => ({
-      type: getModuleType(m6[1]),
-      path: m6[0],
-      contents: await getEntryValue(m6[1])
-    }))
+    [...workerBundle.entries()].map(
+      async (m6) => ({
+        type: getModuleType(m6[1]),
+        path: m6[0],
+        contents: await getEntryValue(m6[1])
+      })
+    )
   );
 }
 async function parseFormDataFromFile(file) {
@@ -157225,48 +157460,101 @@ var init_commands9 = __esm({
 });
 
 // src/utils/friendly-validator-errors.ts
+async function helpIfErrorIsSizeOrScriptStartup(err, dependencies, workerBundle, projectRoot) {
+  if (errIsScriptSize(err)) {
+    return await diagnoseScriptSizeError(err, dependencies);
+  }
+  if (errIsStartupErr(err)) {
+    return await diagnoseStartupError(err, workerBundle, projectRoot);
+  }
+  return null;
+}
+function diagnoseScriptSizeError(err, dependencies) {
+  let message = esm_default2`
+		Your Worker failed validation because it exceeded size limits.
+
+		${err.text}
+		${err.notes.map((note) => ` - ${note.text}`).join("\n")}
+		`;
+  const dependenciesMessage = getOffendingDependenciesMessage(dependencies);
+  if (dependenciesMessage) {
+    message += dependenciesMessage;
+  }
+  return message;
+}
+async function diagnoseStartupError(err, workerBundle, projectRoot) {
+  let errorMessage = esm_default2`
+		Your Worker failed validation because it exceeded startup limits.
+
+		${err.text}
+		${err.notes.map((note) => ` - ${note.text}`).join("\n")}
+
+		To ensure fast responses, there are constraints on Worker startup, such as how much CPU it can use, or how long it can take. Your Worker has hit one of these startup limits. Try reducing the amount of work done during startup (outside the event handler), either by removing code or relocating it inside the event handler.
+
+		Refer to https://developers.cloudflare.com/workers/platform/limits/#worker-startup-time for more details`;
+  try {
+    const cpuProfile = await analyseBundle(workerBundle);
+    const tmpDir = await getWranglerTmpDir(
+      projectRoot,
+      "startup-profile",
+      false
+    );
+    const profile = import_node_path56.default.relative(
+      projectRoot ?? process.cwd(),
+      import_node_path56.default.join(tmpDir.path, `worker.cpuprofile`)
+    );
+    await (0, import_promises34.writeFile)(profile, JSON.stringify(cpuProfile));
+    errorMessage += esm_default2`
+
+			A CPU Profile of your Worker's startup phase has been written to ${profile} - load it into the Chrome DevTools profiler (or directly in VSCode) to view a flamegraph.`;
+  } catch (profilingError) {
+    logger.debug(
+      `An error occurred while trying to locally profile the Worker: ${profilingError}`
+    );
+  }
+  return errorMessage;
+}
+function getOffendingDependenciesMessage(dependencies) {
+  const dependenciesSorted = Object.entries(dependencies);
+  if (dependenciesSorted.length === 0) {
+    return null;
+  }
+  dependenciesSorted.sort(
+    ([, aData], [, bData]) => bData.bytesInOutput - aData.bytesInOutput
+  );
+  const topLargest = dependenciesSorted.slice(0, 5);
+  const ONE_KIB_BYTES2 = 1024;
+  return [
+    "",
+    `Here are the ${topLargest.length} largest dependencies included in your script:`,
+    "",
+    ...topLargest.map(
+      ([dep, data]) => `- ${dep} - ${(data.bytesInOutput / ONE_KIB_BYTES2).toFixed(2)} KiB`
+    ),
+    "",
+    "If these are unnecessary, consider removing them",
+    ""
+  ].join("\n");
+}
 function errIsScriptSize(err) {
-  if (!err) {
+  if (!(err instanceof ParseError)) {
     return false;
   }
-  if (err.code === 10027) {
+  if ("code" in err && err.code === 10027) {
     return true;
   }
   return false;
 }
 function errIsStartupErr(err) {
-  if (!err) {
+  if (!(err instanceof ParseError)) {
     return false;
   }
-  if (err.code === 10021 && err instanceof ParseError && scriptStartupErrorRegex.test(err.notes[0]?.text)) {
+  if ("code" in err && err.code === 10021 && /startup/i.test(err.notes[0]?.text)) {
     return true;
   }
   return false;
 }
-async function handleStartupError(workerBundle, projectRoot) {
-  const cpuProfile = await analyseBundle(workerBundle);
-  const tmpDir = await getWranglerTmpDir(projectRoot, "startup-profile", false);
-  const profile = import_node_path56.default.relative(
-    projectRoot ?? process.cwd(),
-    import_node_path56.default.join(tmpDir.path, `worker.cpuprofile`)
-  );
-  await (0, import_promises34.writeFile)(profile, JSON.stringify(cpuProfile));
-  throw new UserError(esm_default2`
-		Your Worker failed validation because it exceeded startup limits.
-		To ensure fast responses, there are constraints on Worker startup, such as how much CPU it can use, or how long it can take. Your Worker has hit one of these startup limits. Try reducing the amount of work done during startup (outside the event handler), either by removing code or relocating it inside the event handler.
-
-		A CPU Profile of your Worker's startup phase has been written to ${profile} - load it into the Chrome DevTools profiler (or directly in VSCode) to view a flamegraph.
-
-		Refer to https://developers.cloudflare.com/workers/platform/limits/#worker-startup-time for more details`);
-}
-async function helpIfErrorIsSizeOrScriptStartup(err, dependencies, workerBundle, projectRoot) {
-  if (errIsScriptSize(err)) {
-    printOffendingDependencies(dependencies);
-  } else if (errIsStartupErr(err)) {
-    await handleStartupError(workerBundle, projectRoot);
-  }
-}
-var import_promises34, import_node_path56, scriptStartupErrorRegex;
+var import_promises34, import_node_path56;
 var init_friendly_validator_errors = __esm({
   "src/utils/friendly-validator-errors.ts"() {
     init_import_meta_url();
@@ -157274,15 +157562,15 @@ var init_friendly_validator_errors = __esm({
     import_node_path56 = __toESM(require("path"));
     init_esm2();
     init_commands9();
-    init_bundle_reporter();
-    init_errors();
+    init_logger();
     init_parse();
     init_paths();
+    __name(helpIfErrorIsSizeOrScriptStartup, "helpIfErrorIsSizeOrScriptStartup");
+    __name(diagnoseScriptSizeError, "diagnoseScriptSizeError");
+    __name(diagnoseStartupError, "diagnoseStartupError");
+    __name(getOffendingDependenciesMessage, "getOffendingDependenciesMessage");
     __name(errIsScriptSize, "errIsScriptSize");
-    scriptStartupErrorRegex = /startup/i;
     __name(errIsStartupErr, "errIsStartupErr");
-    __name(handleStartupError, "handleStartupError");
-    __name(helpIfErrorIsSizeOrScriptStartup, "helpIfErrorIsSizeOrScriptStartup");
   }
 });
 
@@ -157835,12 +158123,15 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
             config.tail_consumers
           );
         }
-        await helpIfErrorIsSizeOrScriptStartup(
+        const message = await helpIfErrorIsSizeOrScriptStartup(
           err,
           dependencies,
           workerBundle,
           props.projectRoot
         );
+        if (message !== null) {
+          logger.error(message);
+        }
         if (err instanceof APIError && "code" in err && err.code === 10021 && err.notes.length > 0) {
           err.preventReport();
           if (err.notes[0].text === "binding DB of type d1 must have a valid `id` specified [code: 10021]") {
@@ -159416,12 +159707,12 @@ function maybeHandleNetworkLoadResource(url4, bundle, tmpDir) {
     return (0, import_fs27.readFileSync)(filePath, "utf-8");
   }
 }
-var import_fs27, import_node_os8, import_node_url11, import_path27, import_open2, mapConsoleAPIMessageTypeToConsoleMethod, openInspector;
+var import_fs27, import_node_os9, import_node_url11, import_path27, import_open2, mapConsoleAPIMessageTypeToConsoleMethod, openInspector;
 var init_inspect2 = __esm({
   "src/dev/inspect.ts"() {
     init_import_meta_url();
     import_fs27 = require("fs");
-    import_node_os8 = __toESM(require("os"));
+    import_node_os9 = __toESM(require("os"));
     import_node_url11 = require("url");
     import_path27 = __toESM(require("path"));
     import_open2 = __toESM(require_open());
@@ -159461,7 +159752,7 @@ var init_inspect2 = __esm({
       const url4 = `https://devtools.devprod.cloudflare.dev/js_app?${query.toString()}`;
       const errorMessage = "Failed to open inspector.\nInspector depends on having a Chromium-based browser installed, maybe you need to install one?";
       let braveBrowser;
-      switch (import_node_os8.default.platform()) {
+      switch (import_node_os9.default.platform()) {
         case "darwin":
         case "win32":
           braveBrowser = "Brave";
@@ -177828,6 +178119,7 @@ var init_ProxyController = __esm({
     init_wrapper();
     init_inspect2();
     init_miniflare();
+    init_stdio();
     init_https_options();
     init_logger();
     init_sourcemap();
@@ -177906,7 +178198,8 @@ var init_ProxyController = __esm({
             },
             this.localServerReady.promise
           ),
-          handleRuntimeStdio,
+          handleRuntimeStdio: handleRuntimeStdioWithStructuredLogs,
+          structuredWorkerdLogs: true,
           liveReload: false
         };
         if (this.latestConfig.dev.inspector !== false && !inVscodeJsDebugTerminal) {
@@ -179462,6 +179755,9 @@ var init_LocalRuntimeController = __esm({
       // current container that is being built
       containerBeingBuilt;
       onBundleStart(_4) {
+        process.on("exit", () => {
+          this.cleanupContainers();
+        });
       }
       async #onBundleComplete(data, id) {
         try {
@@ -179598,12 +179894,15 @@ var init_LocalRuntimeController = __esm({
       }
       onPreviewTokenExpired(_4) {
       }
-      cleanupContainers = /* @__PURE__ */ __name(async () => {
+      cleanupContainers = /* @__PURE__ */ __name(() => {
+        if (!this.containerImageTagsSeen.size) {
+          return;
+        }
         (0, import_node_assert34.default)(
           this.dockerPath,
           "Docker path should have been set if containers are enabled"
         );
-        await cleanupContainers(this.dockerPath, this.containerImageTagsSeen);
+        cleanupContainers(this.dockerPath, this.containerImageTagsSeen);
       }, "cleanupContainers");
       #teardown = /* @__PURE__ */ __name(async () => {
         logger.debug("LocalRuntimeController teardown beginning...");
@@ -179612,15 +179911,6 @@ var init_LocalRuntimeController = __esm({
         }
         await this.#mf?.dispose();
         this.#mf = void 0;
-        if (this.containerImageTagsSeen.size > 0) {
-          try {
-            await this.cleanupContainers();
-          } catch {
-            logger.warn(
-              `Failed to clean up containers. You may have to stop and remove them up manually.`
-            );
-          }
-        }
         if (this.#remoteProxySessionData) {
           logger.log(source_default.dim("\u2394 Shutting down remote connection..."));
         }
@@ -179879,15 +180169,6 @@ var init_MultiworkerRuntimeController = __esm({
         }
         await this.#mf?.dispose();
         this.#mf = void 0;
-        if (this.containerImageTagsSeen.size > 0) {
-          try {
-            await this.cleanupContainers();
-          } catch {
-            logger.warn(
-              `Failed to clean up containers. You may have to stop and remove them up manually.`
-            );
-          }
-        }
         if (this.#remoteProxySessionsData.size > 0) {
           logger.log(source_default.dim("\u2394 Shutting down remote connections..."));
         }
@@ -180279,13 +180560,11 @@ function registerDevHotKeys(devEnvs, args) {
               }
             }
           });
-          await Promise.all(
-            devEnv.runtimes.map(async (runtime) => {
-              if (runtime instanceof LocalRuntimeController) {
-                await runtime.cleanupContainers();
-              }
-            })
-          );
+          devEnv.runtimes.map((runtime) => {
+            if (runtime instanceof LocalRuntimeController) {
+              runtime.cleanupContainers();
+            }
+          });
           const newContainerBuildId = generateContainerBuildId();
           await devEnv.config.patch({
             dev: {