@cloudflare/deploy-helpers 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1 +1,2526 @@
+import { getHostFromRoute, retryOnAPIFailure, UserError, getComplianceRegionSubdomain, configFileName, formatTime, ParseError, getSubdomainMixedStateCheckDisabled } from '@cloudflare/workers-utils';
+import process2 from 'node:process';
+import os from 'node:os';
+import tty from 'node:tty';
 
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js"(exports, module) {
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    __name(Events, "Events");
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    __name(EE, "EE");
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    __name(addListener, "addListener");
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    __name(clearEvent, "clearEvent");
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    __name(EventEmitter2, "EventEmitter");
+    EventEmitter2.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    }, "eventNames");
+    EventEmitter2.prototype.listeners = /* @__PURE__ */ __name(function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    }, "listeners");
+    EventEmitter2.prototype.listenerCount = /* @__PURE__ */ __name(function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    }, "listenerCount");
+    EventEmitter2.prototype.emit = /* @__PURE__ */ __name(function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    }, "emit");
+    EventEmitter2.prototype.on = /* @__PURE__ */ __name(function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    }, "on");
+    EventEmitter2.prototype.once = /* @__PURE__ */ __name(function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    }, "once");
+    EventEmitter2.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    }, "removeListener");
+    EventEmitter2.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    }, "removeAllListeners");
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${code + offset}m`, "wrapAnsi16");
+var wrapAnsi256 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, "wrapAnsi256");
+var wrapAnsi16m = /* @__PURE__ */ __name((offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, "wrapAnsi16m");
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: /* @__PURE__ */ __name((hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)), "value"),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: /* @__PURE__ */ __name((red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), "value"),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: /* @__PURE__ */ __name((hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), "value"),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+__name(assembleStyles, "assembleStyles");
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+__name(hasFlag, "hasFlag");
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+__name(envForceColor, "envForceColor");
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+__name(translateLevel, "translateLevel");
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) {
+      return 3;
+    }
+    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+__name(_supportsColor, "_supportsColor");
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+__name(createSupportsColor, "createSupportsColor");
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+__name(stringReplaceAll, "stringReplaceAll");
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+__name(stringEncaseCRLFWithFirstIndex, "stringEncaseCRLFWithFirstIndex");
+
+// ../../node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = /* @__PURE__ */ __name((object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+}, "applyOptions");
+var chalkFactory = /* @__PURE__ */ __name((options) => {
+  const chalk2 = /* @__PURE__ */ __name((...strings) => strings.join(" "), "chalk");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+}, "chalkFactory");
+function createChalk(options) {
+  return chalkFactory(options);
+}
+__name(createChalk, "createChalk");
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = /* @__PURE__ */ __name((model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+}, "getModelAnsi");
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = /* @__PURE__ */ __name((open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+}, "createStyler");
+var createBuilder = /* @__PURE__ */ __name((self, _styler, _isEmpty) => {
+  const builder = /* @__PURE__ */ __name((...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" ")), "builder");
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+}, "createBuilder");
+var applyStyle = /* @__PURE__ */ __name((self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+}, "applyStyle");
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3());
+
+// ../../node_modules/.pnpm/p-timeout@7.0.1/node_modules/p-timeout/index.js
+var TimeoutError = class _TimeoutError extends Error {
+  static {
+    __name(this, "TimeoutError");
+  }
+  name = "TimeoutError";
+  constructor(message, options) {
+    super(message, options);
+    Error.captureStackTrace?.(this, _TimeoutError);
+  }
+};
+var getAbortedReason = /* @__PURE__ */ __name((signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError"), "getAbortedReason");
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout },
+    signal
+  } = options;
+  let timer;
+  let abortHandler;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (signal?.aborted) {
+      reject(getAbortedReason(signal));
+      return;
+    }
+    if (signal) {
+      abortHandler = /* @__PURE__ */ __name(() => {
+        reject(getAbortedReason(signal));
+      }, "abortHandler");
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    promise.then(resolve, reject);
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+        reject(timeoutError);
+      }
+    }, milliseconds);
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+    if (abortHandler && signal) {
+      signal.removeEventListener("abort", abortHandler);
+    }
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+__name(pTimeout, "pTimeout");
+
+// ../../node_modules/.pnpm/p-queue@9.0.0/node_modules/p-queue/dist/lower-bound.js
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+__name(lowerBound, "lowerBound");
+
+// ../../node_modules/.pnpm/p-queue@9.0.0/node_modules/p-queue/dist/priority-queue.js
+var PriorityQueue = class {
+  static {
+    __name(this, "PriorityQueue");
+  }
+  #queue = [];
+  enqueue(run, options) {
+    const { priority = 0, id } = options ?? {};
+    const element = {
+      priority,
+      id,
+      run
+    };
+    if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
+      this.#queue.push(element);
+      return;
+    }
+    const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+    this.#queue.splice(index, 0, element);
+  }
+  setPriority(id, priority) {
+    const index = this.#queue.findIndex((element) => element.id === id);
+    if (index === -1) {
+      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
+    }
+    const [item] = this.#queue.splice(index, 1);
+    this.enqueue(item.run, { priority, id });
+  }
+  dequeue() {
+    const item = this.#queue.shift();
+    return item?.run;
+  }
+  filter(options) {
+    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return this.#queue.length;
+  }
+};
+
+// ../../node_modules/.pnpm/p-queue@9.0.0/node_modules/p-queue/dist/index.js
+var PQueue = class extends import_index.default {
+  static {
+    __name(this, "PQueue");
+  }
+  #carryoverIntervalCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #rateLimitedInInterval = false;
+  #rateLimitFlushScheduled = false;
+  #interval;
+  #intervalEnd = 0;
+  #lastExecutionTime = 0;
+  #intervalId;
+  #timeoutId;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+  #concurrency;
+  #isPaused;
+  // Use to assign a unique identifier to a promise function, if not explicitly specified
+  #idAssigner = 1n;
+  // Track currently running tasks for debugging
+  #runningTasks = /* @__PURE__ */ new Map();
+  /**
+      Get or set the default timeout for all tasks. Can be changed at runtime.
+  
+      Operations will throw a `TimeoutError` if they don't complete within the specified time.
+  
+      The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+  
+      @example
+      ```
+      const queue = new PQueue({timeout: 5000});
+  
+      // Change timeout for all future tasks
+      queue.timeout = 10000;
+      ```
+      */
+  timeout;
+  constructor(options) {
+    super();
+    options = {
+      carryoverIntervalCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
+    }
+    this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#queue = new options.queueClass();
+    this.#queueClass = options.queueClass;
+    this.concurrency = options.concurrency;
+    if (options.timeout !== void 0 && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+    }
+    this.timeout = options.timeout;
+    this.#isPaused = options.autoStart === false;
+    this.#setupRateLimitTracking();
+  }
+  get #doesIntervalAllowAnother() {
+    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+    this.#timeoutId = void 0;
+  }
+  get #isIntervalPaused() {
+    const now = Date.now();
+    if (this.#intervalId === void 0) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        if (this.#lastExecutionTime > 0) {
+          const timeSinceLastExecution = now - this.#lastExecutionTime;
+          if (timeSinceLastExecution < this.#interval) {
+            this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
+            return true;
+          }
+        }
+        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      } else {
+        this.#createIntervalTimeout(delay);
+        return true;
+      }
+    }
+    return false;
+  }
+  #createIntervalTimeout(delay) {
+    if (this.#timeoutId !== void 0) {
+      return;
+    }
+    this.#timeoutId = setTimeout(() => {
+      this.#onResumeInterval();
+    }, delay);
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = void 0;
+    }
+  }
+  #clearTimeoutTimer() {
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId);
+      this.#timeoutId = void 0;
+    }
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      this.#clearIntervalTimer();
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.#clearTimeoutTimer();
+        this.emit("idle");
+      }
+      return false;
+    }
+    let taskStarted = false;
+    if (!this.#isPaused) {
+      const canInitializeInterval = !this.#isIntervalPaused;
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!this.#isIntervalIgnored) {
+          this.#intervalCount++;
+          this.#scheduleRateLimitUpdate();
+        }
+        this.emit("active");
+        this.#lastExecutionTime = Date.now();
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        taskStarted = true;
+      }
+    }
+    return taskStarted;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+      this.#clearIntervalTimer();
+    }
+    this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+    this.#processQueue();
+    this.#scheduleRateLimitUpdate();
+  }
+  /**
+  Executes all queued functions until it reaches the limit.
+  */
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  async #throwOnAbort(signal) {
+    return new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+      }, { once: true });
+    });
+  }
+  /**
+      Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+  
+      For example, this can be used to prioritize a promise function to run earlier.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦄', {priority: 1});
+  
+      queue.setPriority('🦀', 2);
+      ```
+  
+      In this case, the promise function with `id: '🦀'` runs second.
+  
+      You can also deprioritize a promise function to delay its execution:
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+      queue.add(async () => '🦄');
+      queue.add(async () => '🦄', {priority: 0});
+  
+      queue.setPriority('🦀', -1);
+      ```
+      Here, the promise function with `id: '🦀'` executes last.
+      */
+  setPriority(id, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+    }
+    this.#queue.setPriority(id, priority);
+  }
+  async add(function_, options = {}) {
+    options.id ??= (this.#idAssigner++).toString();
+    options = {
+      timeout: this.timeout,
+      ...options
+    };
+    return new Promise((resolve, reject) => {
+      const taskSymbol = Symbol(`task-${options.id}`);
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        this.#runningTasks.set(taskSymbol, {
+          id: options.id,
+          priority: options.priority ?? 0,
+          // Match priority-queue default
+          startTime: Date.now(),
+          timeout: options.timeout
+        });
+        try {
+          try {
+            options.signal?.throwIfAborted();
+          } catch (error) {
+            if (!this.#isIntervalIgnored) {
+              this.#intervalCount--;
+            }
+            this.#runningTasks.delete(taskSymbol);
+            throw error;
+          }
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), {
+              milliseconds: options.timeout,
+              message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
+            });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
+          }
+          const result = await operation;
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
+        }
+      }, options);
+      this.emit("add");
+      this.#tryToStartAnother();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    this.#isPaused = true;
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    this.#queue = new this.#queueClass();
+    this.#updateRateLimitState();
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (this.#pending === 0 && this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  /**
+      The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+  
+      @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+      */
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  /**
+  @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+  */
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  /**
+  @returns A promise that settles when the queue is no longer rate-limited.
+  */
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  /**
+      @returns A promise that rejects when any task in the queue errors.
+  
+      Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+  
+      Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+  
+      @example
+      ```
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      queue.add(() => fetchData(1)).catch(() => {});
+      queue.add(() => fetchData(2)).catch(() => {});
+      queue.add(() => fetchData(3)).catch(() => {});
+  
+      // Stop processing on first error
+      try {
+          await Promise.race([
+              queue.onError(),
+              queue.onIdle()
+          ]);
+      } catch (error) {
+          queue.pause(); // Stop processing remaining tasks
+          console.error('Queue failed:', error);
+      }
+      ```
+      */
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
+  async onError() {
+    return new Promise((_resolve, reject) => {
+      const handleError = /* @__PURE__ */ __name((error) => {
+        this.off("error", handleError);
+        reject(error);
+      }, "handleError");
+      this.on("error", handleError);
+    });
+  }
+  async #onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = /* @__PURE__ */ __name(() => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      }, "listener");
+      this.on(event, listener);
+    });
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return this.#queue.size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return this.#pending;
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return this.#isPaused;
+  }
+  #setupRateLimitTracking() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.on("add", () => {
+      if (this.#queue.size > 0) {
+        this.#scheduleRateLimitUpdate();
+      }
+    });
+    this.on("next", () => {
+      this.#scheduleRateLimitUpdate();
+    });
+  }
+  #scheduleRateLimitUpdate() {
+    if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+      return;
+    }
+    this.#rateLimitFlushScheduled = true;
+    queueMicrotask(() => {
+      this.#rateLimitFlushScheduled = false;
+      this.#updateRateLimitState();
+    });
+  }
+  #updateRateLimitState() {
+    const previous = this.#rateLimitedInInterval;
+    const shouldBeRateLimited = !this.#isIntervalIgnored && this.#intervalCount >= this.#intervalCap && this.#queue.size > 0;
+    if (shouldBeRateLimited !== previous) {
+      this.#rateLimitedInInterval = shouldBeRateLimited;
+      this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+  }
+  /**
+  Whether the queue is currently rate-limited due to intervalCap.
+  */
+  get isRateLimited() {
+    return this.#rateLimitedInInterval;
+  }
+  /**
+      Whether the queue is saturated. Returns `true` when:
+      - All concurrency slots are occupied and tasks are waiting, OR
+      - The queue is rate-limited and tasks are waiting
+  
+      Useful for detecting backpressure and potential hanging tasks.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Backpressure handling
+      if (queue.isSaturated) {
+          console.log('Queue is saturated, waiting for capacity...');
+          await queue.onSizeLessThan(queue.concurrency);
+      }
+  
+      // Monitoring for stuck tasks
+      setInterval(() => {
+          if (queue.isSaturated) {
+              console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+          }
+      }, 60000);
+      ```
+      */
+  get isSaturated() {
+    return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  /**
+      The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, and `timeout` (if set).
+  
+      Returns an array of task info objects.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Add tasks with IDs for better debugging
+      queue.add(() => fetchUser(123), {id: 'user-123'});
+      queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+  
+      // Check what's running
+      console.log(queue.runningTasks);
+      // => [{
+      //   id: 'user-123',
+      //   priority: 0,
+      //   startTime: 1759253001716,
+      //   timeout: undefined
+      // }, {
+      //   id: 'posts-456',
+      //   priority: 1,
+      //   startTime: 1759253001916,
+      //   timeout: undefined
+      // }]
+      ```
+      */
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
+};
+async function getZoneForRoute(complianceConfig, from, ctx, zoneIdCache = /* @__PURE__ */ new Map()) {
+  const { route, accountId } = from;
+  const host = getHostFromRoute(route);
+  let id;
+  if (typeof route === "object" && "zone_id" in route) {
+    id = route.zone_id;
+  } else if (typeof route === "object" && "zone_name" in route) {
+    id = await getZoneIdFromHost(
+      complianceConfig,
+      { host: route.zone_name, accountId },
+      ctx,
+      zoneIdCache
+    );
+  } else if (host) {
+    id = await getZoneIdFromHost(
+      complianceConfig,
+      { host, accountId },
+      ctx,
+      zoneIdCache
+    );
+  }
+  return id && host ? { id, host } : void 0;
+}
+__name(getZoneForRoute, "getZoneForRoute");
+async function getZoneIdFromHost(complianceConfig, from, ctx, zoneIdCache = /* @__PURE__ */ new Map()) {
+  const hostPieces = from.host.split(".");
+  while (hostPieces.length > 1) {
+    const cacheKey = `${from.accountId}:${hostPieces.join(".")}`;
+    if (!zoneIdCache.has(cacheKey)) {
+      zoneIdCache.set(
+        cacheKey,
+        retryOnAPIFailure(
+          () => ctx.fetchListResult(
+            complianceConfig,
+            `/zones`,
+            {},
+            new URLSearchParams({
+              name: hostPieces.join("."),
+              "account.id": from.accountId
+            })
+          ),
+          ctx.logger
+        ).then((zones) => zones[0]?.id ?? null)
+      );
+    }
+    const cachedZone = await zoneIdCache.get(cacheKey);
+    if (cachedZone) {
+      return cachedZone;
+    }
+    hostPieces.shift();
+  }
+  throw new UserError(
+    `Could not find zone for \`${from.host}\`. Make sure the domain is set up to be proxied by Cloudflare.
+For more details, refer to https://developers.cloudflare.com/workers/configuration/routing/routes/#set-up-a-route`,
+    { telemetryMessage: "zones route zone not found" }
+  );
+}
+__name(getZoneIdFromHost, "getZoneIdFromHost");
+
+// src/triggers/publish-routes.ts
+function renderRoute(route) {
+  let result = "";
+  if (typeof route === "string") {
+    result = route;
+  } else {
+    result = route.pattern;
+    const isCustomDomain = Boolean(
+      "custom_domain" in route && route.custom_domain
+    );
+    if (isCustomDomain && "zone_id" in route) {
+      result += ` (custom domain - zone id: ${route.zone_id})`;
+    } else if (isCustomDomain && "zone_name" in route) {
+      result += ` (custom domain - zone name: ${route.zone_name})`;
+    } else if (isCustomDomain) {
+      result += ` (custom domain)`;
+    } else if ("zone_id" in route) {
+      result += ` (zone id: ${route.zone_id})`;
+    } else if ("zone_name" in route) {
+      result += ` (zone name: ${route.zone_name})`;
+    }
+    if (isCustomDomain) {
+      const flags = [];
+      if ("enabled" in route && route.enabled !== void 0) {
+        flags.push(route.enabled ? "enabled" : "disabled");
+      }
+      if ("previews_enabled" in route && route.previews_enabled !== void 0) {
+        flags.push(
+          route.previews_enabled ? "previews: enabled" : "previews: disabled"
+        );
+      }
+      if (flags.length > 0) {
+        result += ` [${flags.join(", ")}]`;
+      }
+    }
+  }
+  return result;
+}
+__name(renderRoute, "renderRoute");
+function isAuthenticationError(e) {
+  return e instanceof ParseError && e.code === 1e4;
+}
+__name(isAuthenticationError, "isAuthenticationError");
+async function publishRoutes(complianceConfig, routes, {
+  workerUrl,
+  scriptName,
+  useServiceEnvironments,
+  accountId
+}, ctx) {
+  try {
+    return await ctx.fetchResult(complianceConfig, `${workerUrl}/routes`, {
+      // Note: PUT will delete previous routes on this script.
+      method: "PUT",
+      body: JSON.stringify(
+        routes.map(
+          (route) => typeof route !== "object" ? { pattern: route } : route
+        )
+      ),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  } catch (e) {
+    if (isAuthenticationError(e)) {
+      return await publishRoutesFallback(
+        complianceConfig,
+        routes,
+        {
+          scriptName,
+          useServiceEnvironments,
+          accountId
+        },
+        ctx
+      );
+    } else {
+      throw e;
+    }
+  }
+}
+__name(publishRoutes, "publishRoutes");
+async function publishRoutesFallback(complianceConfig, routes, {
+  scriptName,
+  useServiceEnvironments,
+  accountId
+}, ctx) {
+  if (useServiceEnvironments) {
+    throw new UserError(
+      "Service environments combined with an API token that doesn't have 'All Zones' permissions is not supported.\nEither turn off service environments by setting `legacy_env = true`, creating an API token with 'All Zones' permissions, or logging in via OAuth",
+      {
+        telemetryMessage: "deploy service environments require all zones permission"
+      }
+    );
+  }
+  ctx.logger.info(
+    "The current authentication token does not have 'All Zones' permissions.\nFalling back to using the zone-based API endpoint to update each route individually.\nNote that there is no access to routes associated with zones that the API token does not have permission for.\nExisting routes for this Worker in such zones will not be deleted."
+  );
+  const deployedRoutes = [];
+  const queue = new PQueue({ concurrency: 10 });
+  const queuePromises = [];
+  const zoneIdCache = /* @__PURE__ */ new Map();
+  const activeZones = /* @__PURE__ */ new Map();
+  const routesToDeploy = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    queuePromises.push(
+      queue.add(async () => {
+        const zone = await getZoneForRoute(
+          complianceConfig,
+          { route, accountId },
+          ctx,
+          zoneIdCache
+        );
+        if (zone) {
+          activeZones.set(zone.id, zone.host);
+          routesToDeploy.set(
+            typeof route === "string" ? route : route.pattern,
+            zone.id
+          );
+        }
+      })
+    );
+  }
+  await Promise.all(queuePromises.splice(0, queuePromises.length));
+  const allRoutes = /* @__PURE__ */ new Map();
+  const alreadyDeployedRoutes = /* @__PURE__ */ new Set();
+  for (const [zone, host] of activeZones) {
+    queuePromises.push(
+      queue.add(async () => {
+        try {
+          for (const { pattern, script } of await ctx.fetchListResult(complianceConfig, `/zones/${zone}/workers/routes`)) {
+            allRoutes.set(pattern, script);
+            if (script === scriptName) {
+              alreadyDeployedRoutes.add(pattern);
+            }
+          }
+        } catch (e) {
+          if (isAuthenticationError(e)) {
+            e.notes.push({
+              text: `This could be because the API token being used does not have permission to access the zone "${host}" (${zone}).`
+            });
+          }
+          throw e;
+        }
+      })
+    );
+  }
+  await Promise.all(queuePromises);
+  for (const [routePattern, zoneId] of routesToDeploy.entries()) {
+    if (allRoutes.has(routePattern)) {
+      const knownScript = allRoutes.get(routePattern);
+      if (knownScript === scriptName) {
+        alreadyDeployedRoutes.delete(routePattern);
+        continue;
+      } else {
+        throw new UserError(
+          `The route with pattern "${routePattern}" is already associated with another worker called "${knownScript}".`,
+          { telemetryMessage: "route already associated with another worker" }
+        );
+      }
+    }
+    const { pattern } = await ctx.fetchResult(
+      complianceConfig,
+      `/zones/${zoneId}/workers/routes`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          pattern: routePattern,
+          script: scriptName
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    deployedRoutes.push(pattern);
+  }
+  if (alreadyDeployedRoutes.size) {
+    ctx.logger.warn(
+      "Previously deployed routes:\nThe following routes were already associated with this worker, and have not been deleted:\n" + [...alreadyDeployedRoutes.values()].map((route) => ` - "${route}"
+`) + "If these routes are not wanted then you can remove them in the dashboard."
+    );
+  }
+  return deployedRoutes;
+}
+__name(publishRoutesFallback, "publishRoutesFallback");
+async function publishCustomDomains(complianceConfig, workerUrl, accountId, domains, ctx) {
+  const options = {
+    override_scope: true,
+    override_existing_origin: false,
+    override_existing_dns_record: false
+  };
+  const origins = domains.map((domainRoute) => {
+    return {
+      hostname: domainRoute.pattern,
+      zone_id: "zone_id" in domainRoute ? domainRoute.zone_id : void 0,
+      zone_name: "zone_name" in domainRoute ? domainRoute.zone_name : void 0,
+      enabled: "enabled" in domainRoute ? domainRoute.enabled : void 0,
+      previews_enabled: "previews_enabled" in domainRoute ? domainRoute.previews_enabled : void 0
+    };
+  });
+  const fail = /* @__PURE__ */ __name(() => {
+    return {
+      targets: [],
+      error: new UserError(
+        domains.length > 1 ? `Publishing to ${domains.length} Custom Domains was skipped, fix conflicts and try again` : `Publishing to Custom Domain "${domains[0].pattern}" was skipped, fix conflict and try again`,
+        { telemetryMessage: "deploy custom domains skipped" }
+      )
+    };
+  }, "fail");
+  if (!process.stdout.isTTY) {
+    options.override_existing_origin = true;
+    options.override_existing_dns_record = true;
+  } else {
+    const changeset = await ctx.fetchResult(
+      complianceConfig,
+      `${workerUrl}/domains/changeset?replace_state=true`,
+      {
+        method: "POST",
+        body: JSON.stringify(origins),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    const updatesRequired = changeset.updated.filter(
+      (domain) => domain.modified
+    );
+    if (updatesRequired.length > 0) {
+      const existing = await Promise.all(
+        updatesRequired.map(
+          (domain) => ctx.fetchResult(
+            complianceConfig,
+            `/accounts/${accountId}/workers/domains/records/${domain.id}`
+          )
+        )
+      );
+      const existingRendered = existing.map(
+        (domain) => `	\u2022 ${domain.hostname} (used as a domain for "${domain.service}")`
+      ).join("\n");
+      const message = `Custom Domains already exist for these domains:
+${existingRendered}
+Update them to point to this script instead?`;
+      if (!await ctx.confirm(message)) {
+        return fail();
+      }
+      options.override_existing_origin = true;
+    }
+    if (changeset.conflicting.length > 0) {
+      const conflicitingRendered = changeset.conflicting.map((domain) => `	\u2022 ${domain.hostname}`).join("\n");
+      const message = `You already have DNS records that conflict for these Custom Domains:
+${conflicitingRendered}
+Update them to point to this script instead?`;
+      if (!await ctx.confirm(message)) {
+        return fail();
+      }
+      options.override_existing_dns_record = true;
+    }
+  }
+  await ctx.fetchResult(complianceConfig, `${workerUrl}/domains/records`, {
+    method: "PUT",
+    body: JSON.stringify({ ...options, origins }),
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  return { targets: domains.map((domain) => renderRoute(domain)) };
+}
+__name(publishCustomDomains, "publishCustomDomains");
+async function listQueues(complianceConfig, accountId, ctx, page, name) {
+  page = page ?? 1;
+  const params = new URLSearchParams({ page: page.toString() });
+  if (name) {
+    params.append("name", name);
+  }
+  return ctx.fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/queues`,
+    {},
+    params
+  );
+}
+__name(listQueues, "listQueues");
+async function getQueue(complianceConfig, accountId, queueName, ctx) {
+  const queues = await listQueues(
+    complianceConfig,
+    accountId,
+    ctx,
+    1,
+    queueName
+  );
+  if (queues.length === 0) {
+    throw new UserError(
+      `Queue "${queueName}" does not exist. To create it, run: wrangler queues create ${queueName}`,
+      { telemetryMessage: "queues lookup missing queue" }
+    );
+  }
+  return queues[0];
+}
+__name(getQueue, "getQueue");
+async function postConsumer(complianceConfig, accountId, queueName, body, ctx) {
+  const queue = await getQueue(complianceConfig, accountId, queueName, ctx);
+  return postConsumerById(
+    complianceConfig,
+    accountId,
+    ctx,
+    queue.queue_id,
+    body
+  );
+}
+__name(postConsumer, "postConsumer");
+async function postConsumerById(config, accountId, ctx, queueId, body) {
+  return ctx.fetchResult(
+    config,
+    `/accounts/${accountId}/queues/${queueId}/consumers`,
+    {
+      method: "POST",
+      body: JSON.stringify(body)
+    }
+  );
+}
+__name(postConsumerById, "postConsumerById");
+async function putConsumerById(complianceConfig, accountId, queueId, consumerId, body, ctx) {
+  return ctx.fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/queues/${queueId}/consumers/${consumerId}`,
+    {
+      method: "PUT",
+      body: JSON.stringify(body)
+    }
+  );
+}
+__name(putConsumerById, "putConsumerById");
+async function putConsumer(complianceConfig, accountId, queueName, scriptName, envName, body, ctx) {
+  const queue = await getQueue(complianceConfig, accountId, queueName, ctx);
+  const targetConsumer = await resolveWorkerConsumerByName(
+    complianceConfig,
+    accountId,
+    scriptName,
+    envName,
+    queue,
+    ctx
+  );
+  return putConsumerById(
+    complianceConfig,
+    accountId,
+    queue.queue_id,
+    targetConsumer.consumer_id,
+    body,
+    ctx
+  );
+}
+__name(putConsumer, "putConsumer");
+async function resolveWorkerConsumerByName(complianceConfig, accountId, consumerName, envName, queue, ctx) {
+  const queueName = queue.queue_name;
+  const consumers = queue.consumers.filter(
+    (c) => c.type === "worker" && (c.script === consumerName || c.service === consumerName)
+  );
+  if (consumers.length === 0) {
+    throw new UserError(
+      `No worker consumer '${consumerName}' exists for queue ${queue.queue_name}`,
+      { telemetryMessage: "queues worker consumer missing" }
+    );
+  }
+  if (consumers.length > 1) {
+    const targetEnv = envName ?? await getDefaultService(complianceConfig, accountId, consumerName, ctx);
+    const targetConsumers = consumers.filter(
+      (c) => c.environment === targetEnv
+    );
+    if (targetConsumers.length === 0) {
+      throw new UserError(
+        `No worker consumer '${consumerName}' exists for queue ${queueName}`,
+        { telemetryMessage: "queues worker consumer missing environment" }
+      );
+    }
+    return targetConsumers[0];
+  }
+  if (consumers[0].service) {
+    const targetEnv = envName ?? await getDefaultService(complianceConfig, accountId, consumerName, ctx);
+    if (targetEnv != consumers[0].environment) {
+      throw new UserError(
+        `No worker consumer '${consumerName}' exists for queue ${queueName}`,
+        { telemetryMessage: "queues worker consumer environment mismatch" }
+      );
+    }
+  }
+  return consumers[0];
+}
+__name(resolveWorkerConsumerByName, "resolveWorkerConsumerByName");
+async function getDefaultService(complianceConfig, accountId, serviceName, ctx) {
+  const service = await ctx.fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/services/${serviceName}`,
+    {
+      method: "GET"
+    }
+  );
+  ctx.logger.info(service);
+  return service.default_environment.environment;
+}
+__name(getDefaultService, "getDefaultService");
+async function deleteConsumerById(complianceConfig, accountId, queueId, consumerId, ctx) {
+  return ctx.fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/queues/${queueId}/consumers/${consumerId}`,
+    {
+      method: "DELETE"
+    }
+  );
+}
+__name(deleteConsumerById, "deleteConsumerById");
+async function deletePullConsumer(complianceConfig, accountId, queueName, ctx) {
+  const queue = await getQueue(complianceConfig, accountId, queueName, ctx);
+  const consumer = queue.consumers[0];
+  if (consumer?.type !== "http_pull") {
+    throw new UserError(`No http_pull consumer exists for queue ${queueName}`, {
+      telemetryMessage: "queues http pull consumer missing"
+    });
+  }
+  return deleteConsumerById(
+    complianceConfig,
+    accountId,
+    queue.queue_id,
+    consumer.consumer_id,
+    ctx
+  );
+}
+__name(deletePullConsumer, "deletePullConsumer");
+async function listConsumers(complianceConfig, accountId, queueName, ctx) {
+  const queue = await getQueue(complianceConfig, accountId, queueName, ctx);
+  return queue.consumers;
+}
+__name(listConsumers, "listConsumers");
+async function deleteWorkerConsumer(complianceConfig, accountId, queueName, scriptName, envName, ctx) {
+  const queue = await getQueue(complianceConfig, accountId, queueName, ctx);
+  const targetConsumer = await resolveWorkerConsumerByName(
+    complianceConfig,
+    accountId,
+    scriptName,
+    envName,
+    queue,
+    ctx
+  );
+  return deleteConsumerById(
+    complianceConfig,
+    accountId,
+    queue.queue_id,
+    targetConsumer.consumer_id,
+    ctx
+  );
+}
+__name(deleteWorkerConsumer, "deleteWorkerConsumer");
+async function updateQueueConsumers(complianceConfig, accountId, scriptName, config, ctx) {
+  const consumers = config.queues.consumers || [];
+  const updateConsumers = [];
+  for (const consumer of consumers) {
+    const queue = await getQueue(
+      complianceConfig,
+      accountId,
+      consumer.queue,
+      ctx
+    );
+    const body = {
+      type: "worker",
+      dead_letter_queue: consumer.dead_letter_queue,
+      script_name: scriptName,
+      settings: {
+        batch_size: consumer.max_batch_size,
+        max_retries: consumer.max_retries,
+        max_wait_time_ms: consumer.max_batch_timeout !== void 0 ? 1e3 * consumer.max_batch_timeout : void 0,
+        max_concurrency: consumer.max_concurrency,
+        retry_delay: consumer.retry_delay
+      }
+    };
+    const existingConsumer = queue.consumers.filter(
+      (c) => c.script === scriptName || c.service === scriptName
+    ).length > 0;
+    const envName = void 0;
+    if (existingConsumer) {
+      updateConsumers.push(
+        putConsumer(
+          complianceConfig,
+          accountId,
+          consumer.queue,
+          scriptName,
+          envName,
+          body,
+          ctx
+        ).then(
+          () => ({ targets: [`Consumer for ${consumer.queue}`] }),
+          (error) => ({ targets: [], error })
+        )
+      );
+      continue;
+    }
+    updateConsumers.push(
+      postConsumer(complianceConfig, accountId, consumer.queue, body, ctx).then(
+        () => ({
+          targets: [`Consumer for ${consumer.queue}`]
+        }),
+        (error) => ({ targets: [], error })
+      )
+    );
+  }
+  return updateConsumers;
+}
+__name(updateQueueConsumers, "updateQueueConsumers");
+async function getWorkersDevSubdomain(complianceConfig, accountId, ctx, options = {}) {
+  const {
+    configPath,
+    abortSignal,
+    registrationContext = "workers_dev"
+  } = options;
+  try {
+    const { subdomain } = await ctx.fetchResult(
+      complianceConfig,
+      `/accounts/${accountId}/workers/subdomain`,
+      void 0,
+      void 0,
+      abortSignal
+    );
+    return `${subdomain}${getComplianceRegionSubdomain(complianceConfig)}.workers.dev`;
+  } catch (e) {
+    const error = e;
+    if (typeof error !== "object" || !error || error.code !== 10007) {
+      throw e;
+    }
+    ctx.logger.warn(getRegistrationWarning(registrationContext));
+    const wantsToRegister = await ctx.confirm(
+      "Would you like to register a workers.dev subdomain now?",
+      { fallbackValue: false }
+    );
+    if (!wantsToRegister) {
+      throw getRegistrationDeclinedError(
+        registrationContext,
+        accountId,
+        configPath
+      );
+    }
+    return await registerSubdomain(
+      complianceConfig,
+      accountId,
+      configPath,
+      registrationContext,
+      ctx
+    );
+  }
+}
+__name(getWorkersDevSubdomain, "getWorkersDevSubdomain");
+function getRegistrationWarning(registrationContext) {
+  switch (registrationContext) {
+    case "workflows":
+      return "You need to register a workers.dev subdomain before deploying Workflows";
+    case "workers_dev":
+      return "You need to register a workers.dev subdomain before publishing to workers.dev";
+    default: {
+      const _exhaustive = registrationContext;
+      return _exhaustive;
+    }
+  }
+}
+__name(getRegistrationWarning, "getRegistrationWarning");
+function getRegistrationDeclinedError(registrationContext, accountId, configPath) {
+  const onboardingLink = `https://dash.cloudflare.com/${accountId}/workers/onboarding`;
+  switch (registrationContext) {
+    case "workflows":
+      return new UserError(
+        `Workflows require your account to have a workers.dev subdomain. Register a workers.dev subdomain here:
+${onboardingLink}`,
+        {
+          telemetryMessage: "workflows workers dev registration declined"
+        }
+      );
+    case "workers_dev": {
+      const solutionMessage = `You can either deploy your worker to one or more routes by specifying them in your ${configFileName(configPath)} file, or register a workers.dev subdomain here:`;
+      return new UserError(`${solutionMessage}
+${onboardingLink}`, {
+        telemetryMessage: "routes workers dev registration declined"
+      });
+    }
+    default: {
+      const _exhaustive = registrationContext;
+      return _exhaustive;
+    }
+  }
+}
+__name(getRegistrationDeclinedError, "getRegistrationDeclinedError");
+async function registerSubdomain(complianceConfig, accountId, configPath, registrationContext, ctx) {
+  let subdomain;
+  while (subdomain === void 0) {
+    const potentialName = await ctx.prompt(
+      "What would you like your workers.dev subdomain to be? It will be accessible at https://<subdomain>.workers.dev"
+    );
+    if (!/^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/.test(potentialName)) {
+      ctx.logger.warn(
+        `${potentialName} is invalid, please choose another subdomain.`
+      );
+      continue;
+    }
+    try {
+      await ctx.fetchResult(
+        complianceConfig,
+        `/accounts/${accountId}/workers/subdomains/${potentialName}`
+      );
+    } catch (err) {
+      const subdomainAvailabilityCheckError = err;
+      if (typeof subdomainAvailabilityCheckError === "object" && !!subdomainAvailabilityCheckError) {
+        if (subdomainAvailabilityCheckError.code === 10032) ; else if (subdomainAvailabilityCheckError.code === 10031) {
+          ctx.logger.error(
+            "Subdomain is unavailable, please try a different subdomain"
+          );
+          continue;
+        } else {
+          ctx.logger.error("An unexpected error occurred, please try again.");
+          continue;
+        }
+      }
+    }
+    const ok = await ctx.confirm(
+      `Creating a workers.dev subdomain for your account at ${source_default.blue(
+        source_default.underline(
+          `https://${potentialName}${getComplianceRegionSubdomain(complianceConfig)}.workers.dev`
+        )
+      )}. Ok to proceed?`
+    );
+    if (!ok) {
+      throw getRegistrationDeclinedError(
+        registrationContext,
+        accountId,
+        configPath
+      );
+    }
+    try {
+      const result = await ctx.fetchResult(
+        complianceConfig,
+        `/accounts/${accountId}/workers/subdomain`,
+        {
+          method: "PUT",
+          body: JSON.stringify({ subdomain: potentialName })
+        }
+      );
+      subdomain = result.subdomain;
+    } catch (err) {
+      const subdomainCreationError = err;
+      if (typeof subdomainCreationError === "object" && !!subdomainCreationError && subdomainCreationError.code !== void 0) {
+        switch (subdomainCreationError.code) {
+          case 10031:
+            ctx.logger.error(
+              "Subdomain is unavailable, please try a different subdomain."
+            );
+            break;
+          default:
+            ctx.logger.error("An unexpected error occurred, please try again.");
+            break;
+        }
+      }
+    }
+  }
+  ctx.logger.log(
+    "Success! It may take a few minutes for DNS records to update."
+  );
+  ctx.logger.log(
+    `Visit ${source_default.blue(
+      source_default.underline(
+        `https://dash.cloudflare.com/${accountId}/workers/subdomain`
+      )
+    )} to edit your workers.dev subdomain`
+  );
+  return `${subdomain}${getComplianceRegionSubdomain(complianceConfig)}.workers.dev`;
+}
+__name(registerSubdomain, "registerSubdomain");
+
+// src/triggers/deploy.ts
+async function triggersDeploy(props, ctx) {
+  const { config, accountId, scriptName, routes, crons } = props;
+  const routesOnly = [];
+  const customDomainsOnly = [];
+  for (const route of routes) {
+    if (typeof route !== "string" && route.custom_domain) {
+      customDomainsOnly.push(route);
+    } else {
+      routesOnly.push(route);
+    }
+  }
+  const envName = props.env ?? "production";
+  const start = Date.now();
+  const workerUrl = props.useServiceEnvironments ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}` : `/accounts/${accountId}/workers/scripts/${scriptName}`;
+  const uploadMs = Date.now() - start;
+  const deployments = [];
+  const hasWorkflowsDefinedInThisScript = config.workflows.some(
+    (workflow) => isWorkflowDefinedInThisScript(workflow, scriptName)
+  );
+  const { wantWorkersDev, workersDevInSync } = await subdomainDeploy(
+    props,
+    accountId,
+    scriptName,
+    envName,
+    workerUrl,
+    routes,
+    deployments,
+    props.firstDeploy,
+    ctx
+  );
+  if (!wantWorkersDev && workersDevInSync && routes.length !== 0) {
+    const routesWithOtherBindings = {};
+    const queue = new PQueue({ concurrency: 10 });
+    const queuePromises = [];
+    const zoneRoutesCache = /* @__PURE__ */ new Map();
+    const zoneIdCache = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      queuePromises.push(
+        queue.add(async () => {
+          const zone = await getZoneForRoute(
+            config,
+            { route, accountId },
+            ctx,
+            zoneIdCache
+          );
+          if (!zone) {
+            return;
+          }
+          const routePattern = typeof route === "string" ? route : route.pattern;
+          let routesInZone = zoneRoutesCache.get(zone.id);
+          if (!routesInZone) {
+            routesInZone = retryOnAPIFailure(
+              () => ctx.fetchListResult(config, `/zones/${zone.id}/workers/routes`),
+              ctx.logger
+            );
+            zoneRoutesCache.set(zone.id, routesInZone);
+          }
+          (await routesInZone).forEach(({ script, pattern }) => {
+            if (pattern === routePattern && script !== scriptName) {
+              if (!(script in routesWithOtherBindings)) {
+                routesWithOtherBindings[script] = [];
+              }
+              routesWithOtherBindings[script].push(pattern);
+            }
+          });
+        })
+      );
+    }
+    await Promise.all(queuePromises);
+    if (Object.keys(routesWithOtherBindings).length > 0) {
+      let errorMessage = "Can't deploy routes that are assigned to another worker.\n";
+      for (const worker in routesWithOtherBindings) {
+        const assignedRoutes = routesWithOtherBindings[worker];
+        errorMessage += `"${worker}" is already assigned to routes:
+${assignedRoutes.map(
+          (r) => `  - ${source_default.underline(r)}
+`
+        )}`;
+      }
+      const resolution = "Unassign other workers from the routes you want to deploy to, and then try again.";
+      const dashHref = source_default.blue.underline(
+        `https://dash.cloudflare.com/${accountId}/workers/overview`
+      );
+      const dashLink = `Visit ${dashHref} to unassign a worker from a route.`;
+      throw new UserError(`${errorMessage}
+${resolution}
+${dashLink}`, {
+        telemetryMessage: "triggers deploy routes assigned"
+      });
+    }
+  }
+  if (!wantWorkersDev && hasWorkflowsDefinedInThisScript) {
+    await getWorkersDevSubdomain(config, accountId, ctx, {
+      configPath: config.configPath,
+      registrationContext: "workflows"
+    });
+  }
+  if (routesOnly.length > 0) {
+    deployments.push(
+      publishRoutes(
+        config,
+        routesOnly,
+        {
+          workerUrl,
+          scriptName,
+          useServiceEnvironments: props.useServiceEnvironments,
+          accountId
+        },
+        ctx
+      ).then(
+        () => {
+          if (routesOnly.length > 10) {
+            return {
+              targets: routesOnly.slice(0, 9).map((route) => renderRoute(route)).concat([`...and ${routesOnly.length - 9} more routes`])
+            };
+          }
+          return { targets: routesOnly.map((route) => renderRoute(route)) };
+        },
+        (error) => ({ targets: [], error })
+      )
+    );
+  }
+  if (customDomainsOnly.length > 0) {
+    deployments.push(
+      publishCustomDomains(
+        config,
+        workerUrl,
+        accountId,
+        customDomainsOnly,
+        ctx
+      ).catch((error) => ({ targets: [], error }))
+    );
+  }
+  if (crons) {
+    deployments.push(
+      ctx.fetchResult(config, `${workerUrl}/schedules`, {
+        // Note: PUT will override previous schedules on this script.
+        method: "PUT",
+        body: JSON.stringify(crons.map((cron) => ({ cron }))),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }).then(
+        () => ({
+          targets: crons.map((trigger) => `schedule: ${trigger}`)
+        }),
+        (error) => ({ targets: [], error })
+      )
+    );
+  }
+  if (config.queues.producers && config.queues.producers.length) {
+    deployments.push(
+      ...config.queues.producers.map(
+        (producer) => Promise.resolve({ targets: [`Producer for ${producer.queue}`] })
+      )
+    );
+  }
+  if (config.queues.consumers && config.queues.consumers.length) {
+    const consumerUpdates = await updateQueueConsumers(
+      config,
+      accountId,
+      scriptName,
+      config,
+      ctx
+    );
+    deployments.push(...consumerUpdates);
+  }
+  if (config.workflows?.length) {
+    for (const workflow of config.workflows) {
+      if (!isWorkflowDefinedInThisScript(workflow, scriptName)) {
+        if (workflow.limits) {
+          throw new UserError(
+            `Workflow "${workflow.name}" has "limits" configured but references external script "${workflow.script_name}". Configure limits on the worker that defines the workflow.`,
+            {
+              telemetryMessage: "triggers deploy workflow limits external script"
+            }
+          );
+        }
+        if (workflow.schedules) {
+          throw new UserError(
+            `Workflow "${workflow.name}" has "schedules" configured but references external script "${workflow.script_name}". Configure schedules on the worker that defines the workflow.`,
+            {
+              telemetryMessage: "triggers deploy workflow schedules external script"
+            }
+          );
+        }
+        continue;
+      }
+      deployments.push(
+        ctx.fetchResult(
+          config,
+          `/accounts/${accountId}/workflows/${workflow.name}`,
+          {
+            method: "PUT",
+            body: JSON.stringify({
+              script_name: scriptName,
+              class_name: workflow.class_name,
+              ...workflow.limits && { limits: workflow.limits },
+              ...workflow.schedules && {
+                schedules: (Array.isArray(workflow.schedules) ? workflow.schedules : [workflow.schedules]).map((cron) => ({ cron }))
+              }
+            }),
+            headers: {
+              "Content-Type": "application/json"
+            }
+          }
+        ).then(
+          () => ({ targets: [`workflow: ${workflow.name}`] }),
+          (error) => ({ targets: [], error })
+        )
+      );
+    }
+  }
+  const completedDeployments = await Promise.all(deployments);
+  const deployMs = Date.now() - start - uploadMs;
+  const workerName = props.useServiceEnvironments ? `${scriptName} (${envName})` : scriptName;
+  const targets = completedDeployments.flatMap((deployment) => deployment.targets).map(
+    // Append protocol only on workers.dev domains
+    (target) => (target.endsWith("workers.dev") ? "https://" : "") + target
+  );
+  if (targets.length > 0) {
+    ctx.logger.log(`Deployed ${workerName} triggers`, formatTime(deployMs));
+    for (const target of targets) {
+      ctx.logger.log(" ", target);
+    }
+  } else {
+    ctx.logger.log("No targets deployed for", workerName, formatTime(deployMs));
+  }
+  const errors = completedDeployments.map((deployment) => deployment.error).filter((error) => error !== void 0);
+  if (errors.length > 0) {
+    throw new UserError(
+      `Some triggers failed to deploy for ${workerName}:
+` + errors.map((error) => `  - ${error.message}`).join("\n"),
+      {
+        // Preserve the original errors (with stacks and subclass info) for
+        // debugging, while still presenting a single aggregated message.
+        cause: new AggregateError(errors),
+        // Aggregate the inner telemetry labels into a single deterministic,
+        // low-cardinality label so failures still group meaningfully. Non-
+        // UserError causes contribute a generic "non-user error" marker.
+        telemetryMessage: `triggers deploy partial failure: ${aggregateTelemetryMessages(errors)}`
+      }
+    );
+  }
+  return targets;
+}
+__name(triggersDeploy, "triggersDeploy");
+function aggregateTelemetryMessages(errors) {
+  const labels = errors.map(
+    (error) => error instanceof UserError && error.telemetryMessage ? error.telemetryMessage : "non-user error"
+  );
+  return Array.from(new Set(labels)).sort().join(", ");
+}
+__name(aggregateTelemetryMessages, "aggregateTelemetryMessages");
+function getSubdomainValues(config_workers_dev, config_preview_urls, routes) {
+  const defaultWorkersDev = routes.length === 0;
+  const workers_dev = config_workers_dev ?? defaultWorkersDev;
+  const defaultPreviewUrls = void 0;
+  const preview_urls = config_preview_urls ?? defaultPreviewUrls;
+  return {
+    workers_dev,
+    preview_urls
+  };
+}
+__name(getSubdomainValues, "getSubdomainValues");
+function getSubdomainValuesAPIMock(config_workers_dev, config_preview_urls, routes) {
+  const defaultWorkersDev = routes.length === 0;
+  const workers_dev = config_workers_dev ?? defaultWorkersDev;
+  const defaultPreviewUrls = defaultWorkersDev;
+  const preview_urls = config_preview_urls ?? defaultPreviewUrls;
+  return {
+    workers_dev,
+    preview_urls
+  };
+}
+__name(getSubdomainValuesAPIMock, "getSubdomainValuesAPIMock");
+async function validateSubdomainMixedState(props, accountId, scriptName, before, after, firstDeploy, ctx) {
+  const { config } = props;
+  const changed = after.workers_dev !== before.workers_dev || after.preview_urls !== before.preview_urls;
+  if (!changed) {
+    return after;
+  }
+  if (getSubdomainMixedStateCheckDisabled()) {
+    return after;
+  }
+  if (ctx.isNonInteractiveOrCI()) {
+    return after;
+  }
+  if (firstDeploy) {
+    return after;
+  }
+  if (after.workers_dev === after.preview_urls) {
+    return after;
+  }
+  const userSubdomain = await getWorkersDevSubdomain(config, accountId, ctx, {
+    configPath: config.configPath
+  });
+  const previewUrl = `https://<VERSION_PREFIX>-${scriptName}.${userSubdomain}`;
+  if (!after.workers_dev && after.preview_urls) {
+    ctx.logger.warn(
+      [
+        "You are disabling the 'workers.dev' subdomain for this Worker, but Preview URLs are still enabled.",
+        "Preview URLs will automatically generate a unique, shareable link for each new version which will be accessible at:",
+        `  ${previewUrl}`,
+        "",
+        "To prevent this Worker from being unintentionally public, you may want to disable the Preview URLs as well by setting `preview_urls = false` in your Wrangler config file."
+      ].join("\n")
+    );
+  }
+  if (after.workers_dev && !after.preview_urls) {
+    ctx.logger.warn(
+      [
+        "You are enabling the 'workers.dev' subdomain for this Worker, but Preview URLs are still disabled.",
+        "Preview URLs will automatically generate a unique, shareable link for each new version which will be accessible at:",
+        `  ${previewUrl}`,
+        "",
+        "You may want to enable the Preview URLs as well by setting `preview_urls = true` in your Wrangler config file."
+      ].join("\n")
+    );
+  }
+  return after;
+}
+__name(validateSubdomainMixedState, "validateSubdomainMixedState");
+async function subdomainDeploy(props, accountId, scriptName, envName, workerUrl, routes, deployments, firstDeploy, ctx) {
+  const { config } = props;
+  const { workers_dev: wantWorkersDev, preview_urls: wantPreviews } = getSubdomainValues(config.workers_dev, config.preview_urls, routes);
+  if (wantWorkersDev) {
+    const userSubdomain = await getWorkersDevSubdomain(config, accountId, ctx, {
+      configPath: config.configPath
+    });
+    const workersDevURL = !props.useServiceEnvironments || !props.env ? `${scriptName}.${userSubdomain}` : `${envName}.${scriptName}.${userSubdomain}`;
+    deployments.push(Promise.resolve({ targets: [workersDevURL] }));
+  }
+  const before = await ctx.fetchResult(config, `${workerUrl}/subdomain`);
+  const after = await retryOnAPIFailure(
+    async () => ctx.fetchResult(config, `${workerUrl}/subdomain`, {
+      method: "POST",
+      body: JSON.stringify({
+        enabled: wantWorkersDev,
+        previews_enabled: wantPreviews
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        "Cloudflare-Workers-Script-Api-Date": "2025-08-01"
+      }
+    }),
+    ctx.logger
+  );
+  if (!firstDeploy && config.workers_dev == void 0 && after.enabled !== before.enabled) {
+    const status = /* @__PURE__ */ __name((enabled, past) => {
+      if (past) {
+        return enabled ? "enabled" : "disabled";
+      } else {
+        return enabled ? "enable" : "disable";
+      }
+    }, "status");
+    ctx.logger.warn(
+      [
+        `Because 'workers_dev' is not in your Wrangler file, it will be ${status(after.enabled, true)} for this deployment by default.`,
+        `To override this setting, you can ${status(before.enabled, false)} workers.dev by explicitly setting 'workers_dev = ${before.enabled}' in your Wrangler file.`
+      ].join("\n")
+    );
+  }
+  if (!firstDeploy && config.preview_urls == void 0 && after.previews_enabled !== before.previews_enabled) {
+    const status = /* @__PURE__ */ __name((enabled, past) => {
+      if (past) {
+        return enabled ? "enabled" : "disabled";
+      } else {
+        return enabled ? "enable" : "disable";
+      }
+    }, "status");
+    ctx.logger.warn(
+      [
+        `Because your 'workers.dev' route is ${status(after.enabled, true)} and your 'preview_urls' setting is not in your Wrangler file, Preview URLs will be ${status(after.previews_enabled, true)} for this deployment by default.`,
+        `To override this setting, you can ${status(before.previews_enabled, false)} Preview URLs by explicitly setting 'preview_urls = ${before.previews_enabled}' in your Wrangler file.`
+      ].join("\n")
+    );
+  }
+  await validateSubdomainMixedState(
+    props,
+    accountId,
+    scriptName,
+    { workers_dev: before.enabled, preview_urls: before.previews_enabled },
+    { workers_dev: after.enabled, preview_urls: after.previews_enabled },
+    firstDeploy,
+    ctx
+  );
+  return {
+    wantWorkersDev,
+    wantPreviews,
+    workersDevInSync: before.enabled === after.enabled,
+    previewsInSync: before.previews_enabled === after.previews_enabled
+  };
+}
+__name(subdomainDeploy, "subdomainDeploy");
+function isWorkflowDefinedInThisScript(workflow, scriptName) {
+  return workflow.script_name === void 0 || workflow.script_name === scriptName;
+}
+__name(isWorkflowDefinedInThisScript, "isWorkflowDefinedInThisScript");
+
+export { deletePullConsumer, deleteWorkerConsumer, getQueue, getSubdomainValues, getSubdomainValuesAPIMock, getWorkersDevSubdomain, getZoneForRoute, getZoneIdFromHost, listConsumers, listQueues, postConsumer, publishCustomDomains, publishRoutes, putConsumer, putConsumerById, renderRoute, triggersDeploy, updateQueueConsumers };