npm - @qodalis/cli-server-jobs - Versions diffs - 2.0.0-beta.3 - Mend

@qodalis/cli-server-jobs 2.0.0-beta.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/umd/index.global.js ADDED Viewed

@@ -0,0 +1,3799 @@
+"use strict";
+var jobs = (() => {
+  // ../../../dist/core/public-api.mjs
+  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 __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.
+    !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var require_constants = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js"(exports$1, module2) {
+      var SEMVER_SPEC_VERSION = "2.0.0";
+      var MAX_LENGTH = 256;
+      var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+      9007199254740991;
+      var MAX_SAFE_COMPONENT_LENGTH = 16;
+      var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+      var RELEASE_TYPES = [
+        "major",
+        "premajor",
+        "minor",
+        "preminor",
+        "patch",
+        "prepatch",
+        "prerelease"
+      ];
+      module2.exports = {
+        MAX_LENGTH,
+        MAX_SAFE_COMPONENT_LENGTH,
+        MAX_SAFE_BUILD_LENGTH,
+        MAX_SAFE_INTEGER,
+        RELEASE_TYPES,
+        SEMVER_SPEC_VERSION,
+        FLAG_INCLUDE_PRERELEASE: 1,
+        FLAG_LOOSE: 2
+      };
+    }
+  });
+  var require_debug = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js"(exports$1, module2) {
+      var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+      };
+      module2.exports = debug;
+    }
+  });
+  var require_re = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/re.js"(exports$1, module2) {
+      var {
+        MAX_SAFE_COMPONENT_LENGTH,
+        MAX_SAFE_BUILD_LENGTH,
+        MAX_LENGTH
+      } = require_constants();
+      var debug = require_debug();
+      exports$1 = module2.exports = {};
+      var re = exports$1.re = [];
+      var safeRe = exports$1.safeRe = [];
+      var src = exports$1.src = [];
+      var safeSrc = exports$1.safeSrc = [];
+      var t = exports$1.t = {};
+      var R = 0;
+      var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+      var safeRegexReplacements = [
+        ["\\s", 1],
+        ["\\d", MAX_LENGTH],
+        [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+      ];
+      var makeSafeRegex = (value) => {
+        for (const [token, max] of safeRegexReplacements) {
+          value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+        }
+        return value;
+      };
+      var createToken = (name, value, isGlobal) => {
+        const safe = makeSafeRegex(value);
+        const index = R++;
+        debug(name, index, value);
+        t[name] = index;
+        src[index] = value;
+        safeSrc[index] = safe;
+        re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+        safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+      };
+      createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+      createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+      createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+      createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+      createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+      createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+      createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+      createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+      createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+      createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+      createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+      createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+      createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+      createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+      createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+      createToken("GTLT", "((?:<|>)?=?)");
+      createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+      createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+      createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+      createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+      createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+      createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+      createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+      createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+      createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+      createToken("COERCERTL", src[t.COERCE], true);
+      createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+      createToken("LONETILDE", "(?:~>?)");
+      createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+      exports$1.tildeTrimReplace = "$1~";
+      createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+      createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+      createToken("LONECARET", "(?:\\^)");
+      createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+      exports$1.caretTrimReplace = "$1^";
+      createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+      createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+      createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+      createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+      createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+      exports$1.comparatorTrimReplace = "$1$2$3";
+      createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+      createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+      createToken("STAR", "(<|>)?=?\\s*\\*");
+      createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+      createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+    }
+  });
+  var require_parse_options = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.js"(exports$1, module2) {
+      var looseOption = Object.freeze({ loose: true });
+      var emptyOpts = Object.freeze({});
+      var parseOptions = (options) => {
+        if (!options) {
+          return emptyOpts;
+        }
+        if (typeof options !== "object") {
+          return looseOption;
+        }
+        return options;
+      };
+      module2.exports = parseOptions;
+    }
+  });
+  var require_identifiers = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js"(exports$1, module2) {
+      var numeric = /^[0-9]+$/;
+      var compareIdentifiers = (a, b) => {
+        if (typeof a === "number" && typeof b === "number") {
+          return a === b ? 0 : a < b ? -1 : 1;
+        }
+        const anum = numeric.test(a);
+        const bnum = numeric.test(b);
+        if (anum && bnum) {
+          a = +a;
+          b = +b;
+        }
+        return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+      };
+      var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+      module2.exports = {
+        compareIdentifiers,
+        rcompareIdentifiers
+      };
+    }
+  });
+  var require_semver = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/semver.js"(exports$1, module2) {
+      var debug = require_debug();
+      var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+      var { safeRe: re, t } = require_re();
+      var parseOptions = require_parse_options();
+      var { compareIdentifiers } = require_identifiers();
+      var SemVer = class _SemVer {
+        constructor(version, options) {
+          options = parseOptions(options);
+          if (version instanceof _SemVer) {
+            if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+              return version;
+            } else {
+              version = version.version;
+            }
+          } else if (typeof version !== "string") {
+            throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+          }
+          if (version.length > MAX_LENGTH) {
+            throw new TypeError(
+              `version is longer than ${MAX_LENGTH} characters`
+            );
+          }
+          debug("SemVer", version, options);
+          this.options = options;
+          this.loose = !!options.loose;
+          this.includePrerelease = !!options.includePrerelease;
+          const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+          if (!m) {
+            throw new TypeError(`Invalid Version: ${version}`);
+          }
+          this.raw = version;
+          this.major = +m[1];
+          this.minor = +m[2];
+          this.patch = +m[3];
+          if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+            throw new TypeError("Invalid major version");
+          }
+          if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+            throw new TypeError("Invalid minor version");
+          }
+          if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+            throw new TypeError("Invalid patch version");
+          }
+          if (!m[4]) {
+            this.prerelease = [];
+          } else {
+            this.prerelease = m[4].split(".").map((id) => {
+              if (/^[0-9]+$/.test(id)) {
+                const num = +id;
+                if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                  return num;
+                }
+              }
+              return id;
+            });
+          }
+          this.build = m[5] ? m[5].split(".") : [];
+          this.format();
+        }
+        format() {
+          this.version = `${this.major}.${this.minor}.${this.patch}`;
+          if (this.prerelease.length) {
+            this.version += `-${this.prerelease.join(".")}`;
+          }
+          return this.version;
+        }
+        toString() {
+          return this.version;
+        }
+        compare(other) {
+          debug("SemVer.compare", this.version, this.options, other);
+          if (!(other instanceof _SemVer)) {
+            if (typeof other === "string" && other === this.version) {
+              return 0;
+            }
+            other = new _SemVer(other, this.options);
+          }
+          if (other.version === this.version) {
+            return 0;
+          }
+          return this.compareMain(other) || this.comparePre(other);
+        }
+        compareMain(other) {
+          if (!(other instanceof _SemVer)) {
+            other = new _SemVer(other, this.options);
+          }
+          if (this.major < other.major) {
+            return -1;
+          }
+          if (this.major > other.major) {
+            return 1;
+          }
+          if (this.minor < other.minor) {
+            return -1;
+          }
+          if (this.minor > other.minor) {
+            return 1;
+          }
+          if (this.patch < other.patch) {
+            return -1;
+          }
+          if (this.patch > other.patch) {
+            return 1;
+          }
+          return 0;
+        }
+        comparePre(other) {
+          if (!(other instanceof _SemVer)) {
+            other = new _SemVer(other, this.options);
+          }
+          if (this.prerelease.length && !other.prerelease.length) {
+            return -1;
+          } else if (!this.prerelease.length && other.prerelease.length) {
+            return 1;
+          } else if (!this.prerelease.length && !other.prerelease.length) {
+            return 0;
+          }
+          let i = 0;
+          do {
+            const a = this.prerelease[i];
+            const b = other.prerelease[i];
+            debug("prerelease compare", i, a, b);
+            if (a === void 0 && b === void 0) {
+              return 0;
+            } else if (b === void 0) {
+              return 1;
+            } else if (a === void 0) {
+              return -1;
+            } else if (a === b) {
+              continue;
+            } else {
+              return compareIdentifiers(a, b);
+            }
+          } while (++i);
+        }
+        compareBuild(other) {
+          if (!(other instanceof _SemVer)) {
+            other = new _SemVer(other, this.options);
+          }
+          let i = 0;
+          do {
+            const a = this.build[i];
+            const b = other.build[i];
+            debug("build compare", i, a, b);
+            if (a === void 0 && b === void 0) {
+              return 0;
+            } else if (b === void 0) {
+              return 1;
+            } else if (a === void 0) {
+              return -1;
+            } else if (a === b) {
+              continue;
+            } else {
+              return compareIdentifiers(a, b);
+            }
+          } while (++i);
+        }
+        // preminor will bump the version up to the next minor release, and immediately
+        // down to pre-release. premajor and prepatch work the same way.
+        inc(release, identifier, identifierBase) {
+          if (release.startsWith("pre")) {
+            if (!identifier && identifierBase === false) {
+              throw new Error("invalid increment argument: identifier is empty");
+            }
+            if (identifier) {
+              const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+              if (!match || match[1] !== identifier) {
+                throw new Error(`invalid identifier: ${identifier}`);
+              }
+            }
+          }
+          switch (release) {
+            case "premajor":
+              this.prerelease.length = 0;
+              this.patch = 0;
+              this.minor = 0;
+              this.major++;
+              this.inc("pre", identifier, identifierBase);
+              break;
+            case "preminor":
+              this.prerelease.length = 0;
+              this.patch = 0;
+              this.minor++;
+              this.inc("pre", identifier, identifierBase);
+              break;
+            case "prepatch":
+              this.prerelease.length = 0;
+              this.inc("patch", identifier, identifierBase);
+              this.inc("pre", identifier, identifierBase);
+              break;
+            // If the input is a non-prerelease version, this acts the same as
+            // prepatch.
+            case "prerelease":
+              if (this.prerelease.length === 0) {
+                this.inc("patch", identifier, identifierBase);
+              }
+              this.inc("pre", identifier, identifierBase);
+              break;
+            case "release":
+              if (this.prerelease.length === 0) {
+                throw new Error(`version ${this.raw} is not a prerelease`);
+              }
+              this.prerelease.length = 0;
+              break;
+            case "major":
+              if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+                this.major++;
+              }
+              this.minor = 0;
+              this.patch = 0;
+              this.prerelease = [];
+              break;
+            case "minor":
+              if (this.patch !== 0 || this.prerelease.length === 0) {
+                this.minor++;
+              }
+              this.patch = 0;
+              this.prerelease = [];
+              break;
+            case "patch":
+              if (this.prerelease.length === 0) {
+                this.patch++;
+              }
+              this.prerelease = [];
+              break;
+            // This probably shouldn't be used publicly.
+            // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+            case "pre": {
+              const base = Number(identifierBase) ? 1 : 0;
+              if (this.prerelease.length === 0) {
+                this.prerelease = [base];
+              } else {
+                let i = this.prerelease.length;
+                while (--i >= 0) {
+                  if (typeof this.prerelease[i] === "number") {
+                    this.prerelease[i]++;
+                    i = -2;
+                  }
+                }
+                if (i === -1) {
+                  if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                    throw new Error("invalid increment argument: identifier already exists");
+                  }
+                  this.prerelease.push(base);
+                }
+              }
+              if (identifier) {
+                let prerelease = [identifier, base];
+                if (identifierBase === false) {
+                  prerelease = [identifier];
+                }
+                if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                  if (isNaN(this.prerelease[1])) {
+                    this.prerelease = prerelease;
+                  }
+                } else {
+                  this.prerelease = prerelease;
+                }
+              }
+              break;
+            }
+            default:
+              throw new Error(`invalid increment argument: ${release}`);
+          }
+          this.raw = this.format();
+          if (this.build.length) {
+            this.raw += `+${this.build.join(".")}`;
+          }
+          return this;
+        }
+      };
+      module2.exports = SemVer;
+    }
+  });
+  var require_parse = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/parse.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var parse = (version, options, throwErrors = false) => {
+        if (version instanceof SemVer) {
+          return version;
+        }
+        try {
+          return new SemVer(version, options);
+        } catch (er) {
+          if (!throwErrors) {
+            return null;
+          }
+          throw er;
+        }
+      };
+      module2.exports = parse;
+    }
+  });
+  var require_valid = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/valid.js"(exports$1, module2) {
+      var parse = require_parse();
+      var valid2 = (version, options) => {
+        const v = parse(version, options);
+        return v ? v.version : null;
+      };
+      module2.exports = valid2;
+    }
+  });
+  var require_clean = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/clean.js"(exports$1, module2) {
+      var parse = require_parse();
+      var clean = (version, options) => {
+        const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+        return s ? s.version : null;
+      };
+      module2.exports = clean;
+    }
+  });
+  var require_inc = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/inc.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var inc = (version, release, options, identifier, identifierBase) => {
+        if (typeof options === "string") {
+          identifierBase = identifier;
+          identifier = options;
+          options = void 0;
+        }
+        try {
+          return new SemVer(
+            version instanceof SemVer ? version.version : version,
+            options
+          ).inc(release, identifier, identifierBase).version;
+        } catch (er) {
+          return null;
+        }
+      };
+      module2.exports = inc;
+    }
+  });
+  var require_diff = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/diff.js"(exports$1, module2) {
+      var parse = require_parse();
+      var diff = (version1, version2) => {
+        const v1 = parse(version1, null, true);
+        const v2 = parse(version2, null, true);
+        const comparison = v1.compare(v2);
+        if (comparison === 0) {
+          return null;
+        }
+        const v1Higher = comparison > 0;
+        const highVersion = v1Higher ? v1 : v2;
+        const lowVersion = v1Higher ? v2 : v1;
+        const highHasPre = !!highVersion.prerelease.length;
+        const lowHasPre = !!lowVersion.prerelease.length;
+        if (lowHasPre && !highHasPre) {
+          if (!lowVersion.patch && !lowVersion.minor) {
+            return "major";
+          }
+          if (lowVersion.compareMain(highVersion) === 0) {
+            if (lowVersion.minor && !lowVersion.patch) {
+              return "minor";
+            }
+            return "patch";
+          }
+        }
+        const prefix = highHasPre ? "pre" : "";
+        if (v1.major !== v2.major) {
+          return prefix + "major";
+        }
+        if (v1.minor !== v2.minor) {
+          return prefix + "minor";
+        }
+        if (v1.patch !== v2.patch) {
+          return prefix + "patch";
+        }
+        return "prerelease";
+      };
+      module2.exports = diff;
+    }
+  });
+  var require_major = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/major.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var major = (a, loose) => new SemVer(a, loose).major;
+      module2.exports = major;
+    }
+  });
+  var require_minor = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/minor.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var minor = (a, loose) => new SemVer(a, loose).minor;
+      module2.exports = minor;
+    }
+  });
+  var require_patch = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/patch.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var patch = (a, loose) => new SemVer(a, loose).patch;
+      module2.exports = patch;
+    }
+  });
+  var require_prerelease = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/prerelease.js"(exports$1, module2) {
+      var parse = require_parse();
+      var prerelease = (version, options) => {
+        const parsed = parse(version, options);
+        return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+      };
+      module2.exports = prerelease;
+    }
+  });
+  var require_compare = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var compare2 = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+      module2.exports = compare2;
+    }
+  });
+  var require_rcompare = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rcompare.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var rcompare = (a, b, loose) => compare2(b, a, loose);
+      module2.exports = rcompare;
+    }
+  });
+  var require_compare_loose = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-loose.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var compareLoose = (a, b) => compare2(a, b, true);
+      module2.exports = compareLoose;
+    }
+  });
+  var require_compare_build = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-build.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var compareBuild = (a, b, loose) => {
+        const versionA = new SemVer(a, loose);
+        const versionB = new SemVer(b, loose);
+        return versionA.compare(versionB) || versionA.compareBuild(versionB);
+      };
+      module2.exports = compareBuild;
+    }
+  });
+  var require_sort = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/sort.js"(exports$1, module2) {
+      var compareBuild = require_compare_build();
+      var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+      module2.exports = sort;
+    }
+  });
+  var require_rsort = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rsort.js"(exports$1, module2) {
+      var compareBuild = require_compare_build();
+      var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+      module2.exports = rsort;
+    }
+  });
+  var require_gt = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gt.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var gt = (a, b, loose) => compare2(a, b, loose) > 0;
+      module2.exports = gt;
+    }
+  });
+  var require_lt = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lt.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var lt = (a, b, loose) => compare2(a, b, loose) < 0;
+      module2.exports = lt;
+    }
+  });
+  var require_eq = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/eq.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var eq = (a, b, loose) => compare2(a, b, loose) === 0;
+      module2.exports = eq;
+    }
+  });
+  var require_neq = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/neq.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var neq = (a, b, loose) => compare2(a, b, loose) !== 0;
+      module2.exports = neq;
+    }
+  });
+  var require_gte = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gte.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var gte2 = (a, b, loose) => compare2(a, b, loose) >= 0;
+      module2.exports = gte2;
+    }
+  });
+  var require_lte = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lte.js"(exports$1, module2) {
+      var compare2 = require_compare();
+      var lte = (a, b, loose) => compare2(a, b, loose) <= 0;
+      module2.exports = lte;
+    }
+  });
+  var require_cmp = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/cmp.js"(exports$1, module2) {
+      var eq = require_eq();
+      var neq = require_neq();
+      var gt = require_gt();
+      var gte2 = require_gte();
+      var lt = require_lt();
+      var lte = require_lte();
+      var cmp = (a, op, b, loose) => {
+        switch (op) {
+          case "===":
+            if (typeof a === "object") {
+              a = a.version;
+            }
+            if (typeof b === "object") {
+              b = b.version;
+            }
+            return a === b;
+          case "!==":
+            if (typeof a === "object") {
+              a = a.version;
+            }
+            if (typeof b === "object") {
+              b = b.version;
+            }
+            return a !== b;
+          case "":
+          case "=":
+          case "==":
+            return eq(a, b, loose);
+          case "!=":
+            return neq(a, b, loose);
+          case ">":
+            return gt(a, b, loose);
+          case ">=":
+            return gte2(a, b, loose);
+          case "<":
+            return lt(a, b, loose);
+          case "<=":
+            return lte(a, b, loose);
+          default:
+            throw new TypeError(`Invalid operator: ${op}`);
+        }
+      };
+      module2.exports = cmp;
+    }
+  });
+  var require_coerce = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/coerce.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var parse = require_parse();
+      var { safeRe: re, t } = require_re();
+      var coerce2 = (version, options) => {
+        if (version instanceof SemVer) {
+          return version;
+        }
+        if (typeof version === "number") {
+          version = String(version);
+        }
+        if (typeof version !== "string") {
+          return null;
+        }
+        options = options || {};
+        let match = null;
+        if (!options.rtl) {
+          match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+        } else {
+          const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+          let next;
+          while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+            if (!match || next.index + next[0].length !== match.index + match[0].length) {
+              match = next;
+            }
+            coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+          }
+          coerceRtlRegex.lastIndex = -1;
+        }
+        if (match === null) {
+          return null;
+        }
+        const major = match[2];
+        const minor = match[3] || "0";
+        const patch = match[4] || "0";
+        const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+        const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+        return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+      };
+      module2.exports = coerce2;
+    }
+  });
+  var require_lrucache = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.js"(exports$1, module2) {
+      var LRUCache = class {
+        constructor() {
+          this.max = 1e3;
+          this.map = /* @__PURE__ */ new Map();
+        }
+        get(key) {
+          const value = this.map.get(key);
+          if (value === void 0) {
+            return void 0;
+          } else {
+            this.map.delete(key);
+            this.map.set(key, value);
+            return value;
+          }
+        }
+        delete(key) {
+          return this.map.delete(key);
+        }
+        set(key, value) {
+          const deleted = this.delete(key);
+          if (!deleted && value !== void 0) {
+            if (this.map.size >= this.max) {
+              const firstKey = this.map.keys().next().value;
+              this.delete(firstKey);
+            }
+            this.map.set(key, value);
+          }
+          return this;
+        }
+      };
+      module2.exports = LRUCache;
+    }
+  });
+  var require_range = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/range.js"(exports$1, module2) {
+      var SPACE_CHARACTERS = /\s+/g;
+      var Range = class _Range {
+        constructor(range, options) {
+          options = parseOptions(options);
+          if (range instanceof _Range) {
+            if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+              return range;
+            } else {
+              return new _Range(range.raw, options);
+            }
+          }
+          if (range instanceof Comparator) {
+            this.raw = range.value;
+            this.set = [[range]];
+            this.formatted = void 0;
+            return this;
+          }
+          this.options = options;
+          this.loose = !!options.loose;
+          this.includePrerelease = !!options.includePrerelease;
+          this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+          this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+          if (!this.set.length) {
+            throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+          }
+          if (this.set.length > 1) {
+            const first = this.set[0];
+            this.set = this.set.filter((c) => !isNullSet(c[0]));
+            if (this.set.length === 0) {
+              this.set = [first];
+            } else if (this.set.length > 1) {
+              for (const c of this.set) {
+                if (c.length === 1 && isAny(c[0])) {
+                  this.set = [c];
+                  break;
+                }
+              }
+            }
+          }
+          this.formatted = void 0;
+        }
+        get range() {
+          if (this.formatted === void 0) {
+            this.formatted = "";
+            for (let i = 0; i < this.set.length; i++) {
+              if (i > 0) {
+                this.formatted += "||";
+              }
+              const comps = this.set[i];
+              for (let k = 0; k < comps.length; k++) {
+                if (k > 0) {
+                  this.formatted += " ";
+                }
+                this.formatted += comps[k].toString().trim();
+              }
+            }
+          }
+          return this.formatted;
+        }
+        format() {
+          return this.range;
+        }
+        toString() {
+          return this.range;
+        }
+        parseRange(range) {
+          const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+          const memoKey = memoOpts + ":" + range;
+          const cached = cache.get(memoKey);
+          if (cached) {
+            return cached;
+          }
+          const loose = this.options.loose;
+          const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+          range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+          debug("hyphen replace", range);
+          range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+          debug("comparator trim", range);
+          range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+          debug("tilde trim", range);
+          range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+          debug("caret trim", range);
+          let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+          if (loose) {
+            rangeList = rangeList.filter((comp) => {
+              debug("loose invalid filter", comp, this.options);
+              return !!comp.match(re[t.COMPARATORLOOSE]);
+            });
+          }
+          debug("range list", rangeList);
+          const rangeMap = /* @__PURE__ */ new Map();
+          const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+          for (const comp of comparators) {
+            if (isNullSet(comp)) {
+              return [comp];
+            }
+            rangeMap.set(comp.value, comp);
+          }
+          if (rangeMap.size > 1 && rangeMap.has("")) {
+            rangeMap.delete("");
+          }
+          const result = [...rangeMap.values()];
+          cache.set(memoKey, result);
+          return result;
+        }
+        intersects(range, options) {
+          if (!(range instanceof _Range)) {
+            throw new TypeError("a Range is required");
+          }
+          return this.set.some((thisComparators) => {
+            return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+              return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+                return rangeComparators.every((rangeComparator) => {
+                  return thisComparator.intersects(rangeComparator, options);
+                });
+              });
+            });
+          });
+        }
+        // if ANY of the sets match ALL of its comparators, then pass
+        test(version) {
+          if (!version) {
+            return false;
+          }
+          if (typeof version === "string") {
+            try {
+              version = new SemVer(version, this.options);
+            } catch (er) {
+              return false;
+            }
+          }
+          for (let i = 0; i < this.set.length; i++) {
+            if (testSet(this.set[i], version, this.options)) {
+              return true;
+            }
+          }
+          return false;
+        }
+      };
+      module2.exports = Range;
+      var LRU = require_lrucache();
+      var cache = new LRU();
+      var parseOptions = require_parse_options();
+      var Comparator = require_comparator();
+      var debug = require_debug();
+      var SemVer = require_semver();
+      var {
+        safeRe: re,
+        t,
+        comparatorTrimReplace,
+        tildeTrimReplace,
+        caretTrimReplace
+      } = require_re();
+      var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+      var isNullSet = (c) => c.value === "<0.0.0-0";
+      var isAny = (c) => c.value === "";
+      var isSatisfiable = (comparators, options) => {
+        let result = true;
+        const remainingComparators = comparators.slice();
+        let testComparator = remainingComparators.pop();
+        while (result && remainingComparators.length) {
+          result = remainingComparators.every((otherComparator) => {
+            return testComparator.intersects(otherComparator, options);
+          });
+          testComparator = remainingComparators.pop();
+        }
+        return result;
+      };
+      var parseComparator = (comp, options) => {
+        comp = comp.replace(re[t.BUILD], "");
+        debug("comp", comp, options);
+        comp = replaceCarets(comp, options);
+        debug("caret", comp);
+        comp = replaceTildes(comp, options);
+        debug("tildes", comp);
+        comp = replaceXRanges(comp, options);
+        debug("xrange", comp);
+        comp = replaceStars(comp, options);
+        debug("stars", comp);
+        return comp;
+      };
+      var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+      var replaceTildes = (comp, options) => {
+        return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+      };
+      var replaceTilde = (comp, options) => {
+        const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+        return comp.replace(r, (_, M, m, p, pr) => {
+          debug("tilde", comp, _, M, m, p, pr);
+          let ret;
+          if (isX(M)) {
+            ret = "";
+          } else if (isX(m)) {
+            ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+          } else if (isX(p)) {
+            ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+          } else if (pr) {
+            debug("replaceTilde pr", pr);
+            ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+          }
+          debug("tilde return", ret);
+          return ret;
+        });
+      };
+      var replaceCarets = (comp, options) => {
+        return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+      };
+      var replaceCaret = (comp, options) => {
+        debug("caret", comp, options);
+        const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+        const z = options.includePrerelease ? "-0" : "";
+        return comp.replace(r, (_, M, m, p, pr) => {
+          debug("caret", comp, _, M, m, p, pr);
+          let ret;
+          if (isX(M)) {
+            ret = "";
+          } else if (isX(m)) {
+            ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+          } else if (isX(p)) {
+            if (M === "0") {
+              ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+            } else {
+              ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+            }
+          } else if (pr) {
+            debug("replaceCaret pr", pr);
+            if (M === "0") {
+              if (m === "0") {
+                ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+              } else {
+                ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+              }
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+            }
+          } else {
+            debug("no pr");
+            if (M === "0") {
+              if (m === "0") {
+                ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+              } else {
+                ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+              }
+            } else {
+              ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+            }
+          }
+          debug("caret return", ret);
+          return ret;
+        });
+      };
+      var replaceXRanges = (comp, options) => {
+        debug("replaceXRanges", comp, options);
+        return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+      };
+      var replaceXRange = (comp, options) => {
+        comp = comp.trim();
+        const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+        return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+          debug("xRange", comp, ret, gtlt, M, m, p, pr);
+          const xM = isX(M);
+          const xm = xM || isX(m);
+          const xp = xm || isX(p);
+          const anyX = xp;
+          if (gtlt === "=" && anyX) {
+            gtlt = "";
+          }
+          pr = options.includePrerelease ? "-0" : "";
+          if (xM) {
+            if (gtlt === ">" || gtlt === "<") {
+              ret = "<0.0.0-0";
+            } else {
+              ret = "*";
+            }
+          } else if (gtlt && anyX) {
+            if (xm) {
+              m = 0;
+            }
+            p = 0;
+            if (gtlt === ">") {
+              gtlt = ">=";
+              if (xm) {
+                M = +M + 1;
+                m = 0;
+                p = 0;
+              } else {
+                m = +m + 1;
+                p = 0;
+              }
+            } else if (gtlt === "<=") {
+              gtlt = "<";
+              if (xm) {
+                M = +M + 1;
+              } else {
+                m = +m + 1;
+              }
+            }
+            if (gtlt === "<") {
+              pr = "-0";
+            }
+            ret = `${gtlt + M}.${m}.${p}${pr}`;
+          } else if (xm) {
+            ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+          } else if (xp) {
+            ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+          }
+          debug("xRange return", ret);
+          return ret;
+        });
+      };
+      var replaceStars = (comp, options) => {
+        debug("replaceStars", comp, options);
+        return comp.trim().replace(re[t.STAR], "");
+      };
+      var replaceGTE0 = (comp, options) => {
+        debug("replaceGTE0", comp, options);
+        return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+      };
+      var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+        if (isX(fM)) {
+          from = "";
+        } else if (isX(fm)) {
+          from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+        } else if (isX(fp)) {
+          from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+        } else if (fpr) {
+          from = `>=${from}`;
+        } else {
+          from = `>=${from}${incPr ? "-0" : ""}`;
+        }
+        if (isX(tM)) {
+          to = "";
+        } else if (isX(tm)) {
+          to = `<${+tM + 1}.0.0-0`;
+        } else if (isX(tp)) {
+          to = `<${tM}.${+tm + 1}.0-0`;
+        } else if (tpr) {
+          to = `<=${tM}.${tm}.${tp}-${tpr}`;
+        } else if (incPr) {
+          to = `<${tM}.${tm}.${+tp + 1}-0`;
+        } else {
+          to = `<=${to}`;
+        }
+        return `${from} ${to}`.trim();
+      };
+      var testSet = (set, version, options) => {
+        for (let i = 0; i < set.length; i++) {
+          if (!set[i].test(version)) {
+            return false;
+          }
+        }
+        if (version.prerelease.length && !options.includePrerelease) {
+          for (let i = 0; i < set.length; i++) {
+            debug(set[i].semver);
+            if (set[i].semver === Comparator.ANY) {
+              continue;
+            }
+            if (set[i].semver.prerelease.length > 0) {
+              const allowed = set[i].semver;
+              if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+                return true;
+              }
+            }
+          }
+          return false;
+        }
+        return true;
+      };
+    }
+  });
+  var require_comparator = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/comparator.js"(exports$1, module2) {
+      var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
+      var Comparator = class _Comparator {
+        static get ANY() {
+          return ANY;
+        }
+        constructor(comp, options) {
+          options = parseOptions(options);
+          if (comp instanceof _Comparator) {
+            if (comp.loose === !!options.loose) {
+              return comp;
+            } else {
+              comp = comp.value;
+            }
+          }
+          comp = comp.trim().split(/\s+/).join(" ");
+          debug("comparator", comp, options);
+          this.options = options;
+          this.loose = !!options.loose;
+          this.parse(comp);
+          if (this.semver === ANY) {
+            this.value = "";
+          } else {
+            this.value = this.operator + this.semver.version;
+          }
+          debug("comp", this);
+        }
+        parse(comp) {
+          const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+          const m = comp.match(r);
+          if (!m) {
+            throw new TypeError(`Invalid comparator: ${comp}`);
+          }
+          this.operator = m[1] !== void 0 ? m[1] : "";
+          if (this.operator === "=") {
+            this.operator = "";
+          }
+          if (!m[2]) {
+            this.semver = ANY;
+          } else {
+            this.semver = new SemVer(m[2], this.options.loose);
+          }
+        }
+        toString() {
+          return this.value;
+        }
+        test(version) {
+          debug("Comparator.test", version, this.options.loose);
+          if (this.semver === ANY || version === ANY) {
+            return true;
+          }
+          if (typeof version === "string") {
+            try {
+              version = new SemVer(version, this.options);
+            } catch (er) {
+              return false;
+            }
+          }
+          return cmp(version, this.operator, this.semver, this.options);
+        }
+        intersects(comp, options) {
+          if (!(comp instanceof _Comparator)) {
+            throw new TypeError("a Comparator is required");
+          }
+          if (this.operator === "") {
+            if (this.value === "") {
+              return true;
+            }
+            return new Range(comp.value, options).test(this.value);
+          } else if (comp.operator === "") {
+            if (comp.value === "") {
+              return true;
+            }
+            return new Range(this.value, options).test(comp.semver);
+          }
+          options = parseOptions(options);
+          if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+            return false;
+          }
+          if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+            return false;
+          }
+          if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+            return true;
+          }
+          if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+            return true;
+          }
+          if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+            return true;
+          }
+          if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+            return true;
+          }
+          if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+            return true;
+          }
+          return false;
+        }
+      };
+      module2.exports = Comparator;
+      var parseOptions = require_parse_options();
+      var { safeRe: re, t } = require_re();
+      var cmp = require_cmp();
+      var debug = require_debug();
+      var SemVer = require_semver();
+      var Range = require_range();
+    }
+  });
+  var require_satisfies = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/satisfies.js"(exports$1, module2) {
+      var Range = require_range();
+      var satisfies2 = (version, range, options) => {
+        try {
+          range = new Range(range, options);
+        } catch (er) {
+          return false;
+        }
+        return range.test(version);
+      };
+      module2.exports = satisfies2;
+    }
+  });
+  var require_to_comparators = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/to-comparators.js"(exports$1, module2) {
+      var Range = require_range();
+      var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+      module2.exports = toComparators;
+    }
+  });
+  var require_max_satisfying = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/max-satisfying.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var Range = require_range();
+      var maxSatisfying = (versions, range, options) => {
+        let max = null;
+        let maxSV = null;
+        let rangeObj = null;
+        try {
+          rangeObj = new Range(range, options);
+        } catch (er) {
+          return null;
+        }
+        versions.forEach((v) => {
+          if (rangeObj.test(v)) {
+            if (!max || maxSV.compare(v) === -1) {
+              max = v;
+              maxSV = new SemVer(max, options);
+            }
+          }
+        });
+        return max;
+      };
+      module2.exports = maxSatisfying;
+    }
+  });
+  var require_min_satisfying = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-satisfying.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var Range = require_range();
+      var minSatisfying = (versions, range, options) => {
+        let min = null;
+        let minSV = null;
+        let rangeObj = null;
+        try {
+          rangeObj = new Range(range, options);
+        } catch (er) {
+          return null;
+        }
+        versions.forEach((v) => {
+          if (rangeObj.test(v)) {
+            if (!min || minSV.compare(v) === 1) {
+              min = v;
+              minSV = new SemVer(min, options);
+            }
+          }
+        });
+        return min;
+      };
+      module2.exports = minSatisfying;
+    }
+  });
+  var require_min_version = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-version.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var Range = require_range();
+      var gt = require_gt();
+      var minVersion = (range, loose) => {
+        range = new Range(range, loose);
+        let minver = new SemVer("0.0.0");
+        if (range.test(minver)) {
+          return minver;
+        }
+        minver = new SemVer("0.0.0-0");
+        if (range.test(minver)) {
+          return minver;
+        }
+        minver = null;
+        for (let i = 0; i < range.set.length; ++i) {
+          const comparators = range.set[i];
+          let setMin = null;
+          comparators.forEach((comparator) => {
+            const compver = new SemVer(comparator.semver.version);
+            switch (comparator.operator) {
+              case ">":
+                if (compver.prerelease.length === 0) {
+                  compver.patch++;
+                } else {
+                  compver.prerelease.push(0);
+                }
+                compver.raw = compver.format();
+              /* fallthrough */
+              case "":
+              case ">=":
+                if (!setMin || gt(compver, setMin)) {
+                  setMin = compver;
+                }
+                break;
+              case "<":
+              case "<=":
+                break;
+              /* istanbul ignore next */
+              default:
+                throw new Error(`Unexpected operation: ${comparator.operator}`);
+            }
+          });
+          if (setMin && (!minver || gt(minver, setMin))) {
+            minver = setMin;
+          }
+        }
+        if (minver && range.test(minver)) {
+          return minver;
+        }
+        return null;
+      };
+      module2.exports = minVersion;
+    }
+  });
+  var require_valid2 = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/valid.js"(exports$1, module2) {
+      var Range = require_range();
+      var validRange = (range, options) => {
+        try {
+          return new Range(range, options).range || "*";
+        } catch (er) {
+          return null;
+        }
+      };
+      module2.exports = validRange;
+    }
+  });
+  var require_outside = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/outside.js"(exports$1, module2) {
+      var SemVer = require_semver();
+      var Comparator = require_comparator();
+      var { ANY } = Comparator;
+      var Range = require_range();
+      var satisfies2 = require_satisfies();
+      var gt = require_gt();
+      var lt = require_lt();
+      var lte = require_lte();
+      var gte2 = require_gte();
+      var outside = (version, range, hilo, options) => {
+        version = new SemVer(version, options);
+        range = new Range(range, options);
+        let gtfn, ltefn, ltfn, comp, ecomp;
+        switch (hilo) {
+          case ">":
+            gtfn = gt;
+            ltefn = lte;
+            ltfn = lt;
+            comp = ">";
+            ecomp = ">=";
+            break;
+          case "<":
+            gtfn = lt;
+            ltefn = gte2;
+            ltfn = gt;
+            comp = "<";
+            ecomp = "<=";
+            break;
+          default:
+            throw new TypeError('Must provide a hilo val of "<" or ">"');
+        }
+        if (satisfies2(version, range, options)) {
+          return false;
+        }
+        for (let i = 0; i < range.set.length; ++i) {
+          const comparators = range.set[i];
+          let high = null;
+          let low = null;
+          comparators.forEach((comparator) => {
+            if (comparator.semver === ANY) {
+              comparator = new Comparator(">=0.0.0");
+            }
+            high = high || comparator;
+            low = low || comparator;
+            if (gtfn(comparator.semver, high.semver, options)) {
+              high = comparator;
+            } else if (ltfn(comparator.semver, low.semver, options)) {
+              low = comparator;
+            }
+          });
+          if (high.operator === comp || high.operator === ecomp) {
+            return false;
+          }
+          if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+            return false;
+          } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+            return false;
+          }
+        }
+        return true;
+      };
+      module2.exports = outside;
+    }
+  });
+  var require_gtr = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/gtr.js"(exports$1, module2) {
+      var outside = require_outside();
+      var gtr = (version, range, options) => outside(version, range, ">", options);
+      module2.exports = gtr;
+    }
+  });
+  var require_ltr = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/ltr.js"(exports$1, module2) {
+      var outside = require_outside();
+      var ltr = (version, range, options) => outside(version, range, "<", options);
+      module2.exports = ltr;
+    }
+  });
+  var require_intersects = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/intersects.js"(exports$1, module2) {
+      var Range = require_range();
+      var intersects = (r1, r2, options) => {
+        r1 = new Range(r1, options);
+        r2 = new Range(r2, options);
+        return r1.intersects(r2, options);
+      };
+      module2.exports = intersects;
+    }
+  });
+  var require_simplify = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/simplify.js"(exports$1, module2) {
+      var satisfies2 = require_satisfies();
+      var compare2 = require_compare();
+      module2.exports = (versions, range, options) => {
+        const set = [];
+        let first = null;
+        let prev = null;
+        const v = versions.sort((a, b) => compare2(a, b, options));
+        for (const version of v) {
+          const included = satisfies2(version, range, options);
+          if (included) {
+            prev = version;
+            if (!first) {
+              first = version;
+            }
+          } else {
+            if (prev) {
+              set.push([first, prev]);
+            }
+            prev = null;
+            first = null;
+          }
+        }
+        if (first) {
+          set.push([first, null]);
+        }
+        const ranges = [];
+        for (const [min, max] of set) {
+          if (min === max) {
+            ranges.push(min);
+          } else if (!max && min === v[0]) {
+            ranges.push("*");
+          } else if (!max) {
+            ranges.push(`>=${min}`);
+          } else if (min === v[0]) {
+            ranges.push(`<=${max}`);
+          } else {
+            ranges.push(`${min} - ${max}`);
+          }
+        }
+        const simplified = ranges.join(" || ");
+        const original = typeof range.raw === "string" ? range.raw : String(range);
+        return simplified.length < original.length ? simplified : range;
+      };
+    }
+  });
+  var require_subset = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/subset.js"(exports$1, module2) {
+      var Range = require_range();
+      var Comparator = require_comparator();
+      var { ANY } = Comparator;
+      var satisfies2 = require_satisfies();
+      var compare2 = require_compare();
+      var subset = (sub, dom, options = {}) => {
+        if (sub === dom) {
+          return true;
+        }
+        sub = new Range(sub, options);
+        dom = new Range(dom, options);
+        let sawNonNull = false;
+        OUTER: for (const simpleSub of sub.set) {
+          for (const simpleDom of dom.set) {
+            const isSub = simpleSubset(simpleSub, simpleDom, options);
+            sawNonNull = sawNonNull || isSub !== null;
+            if (isSub) {
+              continue OUTER;
+            }
+          }
+          if (sawNonNull) {
+            return false;
+          }
+        }
+        return true;
+      };
+      var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+      var minimumVersion = [new Comparator(">=0.0.0")];
+      var simpleSubset = (sub, dom, options) => {
+        if (sub === dom) {
+          return true;
+        }
+        if (sub.length === 1 && sub[0].semver === ANY) {
+          if (dom.length === 1 && dom[0].semver === ANY) {
+            return true;
+          } else if (options.includePrerelease) {
+            sub = minimumVersionWithPreRelease;
+          } else {
+            sub = minimumVersion;
+          }
+        }
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          if (options.includePrerelease) {
+            return true;
+          } else {
+            dom = minimumVersion;
+          }
+        }
+        const eqSet = /* @__PURE__ */ new Set();
+        let gt, lt;
+        for (const c of sub) {
+          if (c.operator === ">" || c.operator === ">=") {
+            gt = higherGT(gt, c, options);
+          } else if (c.operator === "<" || c.operator === "<=") {
+            lt = lowerLT(lt, c, options);
+          } else {
+            eqSet.add(c.semver);
+          }
+        }
+        if (eqSet.size > 1) {
+          return null;
+        }
+        let gtltComp;
+        if (gt && lt) {
+          gtltComp = compare2(gt.semver, lt.semver, options);
+          if (gtltComp > 0) {
+            return null;
+          } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+            return null;
+          }
+        }
+        for (const eq of eqSet) {
+          if (gt && !satisfies2(eq, String(gt), options)) {
+            return null;
+          }
+          if (lt && !satisfies2(eq, String(lt), options)) {
+            return null;
+          }
+          for (const c of dom) {
+            if (!satisfies2(eq, String(c), options)) {
+              return false;
+            }
+          }
+          return true;
+        }
+        let higher, lower;
+        let hasDomLT, hasDomGT;
+        let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+        let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+        if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+          needDomLTPre = false;
+        }
+        for (const c of dom) {
+          hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+          hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+          if (gt) {
+            if (needDomGTPre) {
+              if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+                needDomGTPre = false;
+              }
+            }
+            if (c.operator === ">" || c.operator === ">=") {
+              higher = higherGT(gt, c, options);
+              if (higher === c && higher !== gt) {
+                return false;
+              }
+            } else if (gt.operator === ">=" && !satisfies2(gt.semver, String(c), options)) {
+              return false;
+            }
+          }
+          if (lt) {
+            if (needDomLTPre) {
+              if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+                needDomLTPre = false;
+              }
+            }
+            if (c.operator === "<" || c.operator === "<=") {
+              lower = lowerLT(lt, c, options);
+              if (lower === c && lower !== lt) {
+                return false;
+              }
+            } else if (lt.operator === "<=" && !satisfies2(lt.semver, String(c), options)) {
+              return false;
+            }
+          }
+          if (!c.operator && (lt || gt) && gtltComp !== 0) {
+            return false;
+          }
+        }
+        if (gt && hasDomLT && !lt && gtltComp !== 0) {
+          return false;
+        }
+        if (lt && hasDomGT && !gt && gtltComp !== 0) {
+          return false;
+        }
+        if (needDomGTPre || needDomLTPre) {
+          return false;
+        }
+        return true;
+      };
+      var higherGT = (a, b, options) => {
+        if (!a) {
+          return b;
+        }
+        const comp = compare2(a.semver, b.semver, options);
+        return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+      };
+      var lowerLT = (a, b, options) => {
+        if (!a) {
+          return b;
+        }
+        const comp = compare2(a.semver, b.semver, options);
+        return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+      };
+      module2.exports = subset;
+    }
+  });
+  var require_semver2 = __commonJS({
+    "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js"(exports$1, module2) {
+      var internalRe = require_re();
+      var constants2 = require_constants();
+      var SemVer = require_semver();
+      var identifiers = require_identifiers();
+      var parse = require_parse();
+      var valid2 = require_valid();
+      var clean = require_clean();
+      var inc = require_inc();
+      var diff = require_diff();
+      var major = require_major();
+      var minor = require_minor();
+      var patch = require_patch();
+      var prerelease = require_prerelease();
+      var compare2 = require_compare();
+      var rcompare = require_rcompare();
+      var compareLoose = require_compare_loose();
+      var compareBuild = require_compare_build();
+      var sort = require_sort();
+      var rsort = require_rsort();
+      var gt = require_gt();
+      var lt = require_lt();
+      var eq = require_eq();
+      var neq = require_neq();
+      var gte2 = require_gte();
+      var lte = require_lte();
+      var cmp = require_cmp();
+      var coerce2 = require_coerce();
+      var Comparator = require_comparator();
+      var Range = require_range();
+      var satisfies2 = require_satisfies();
+      var toComparators = require_to_comparators();
+      var maxSatisfying = require_max_satisfying();
+      var minSatisfying = require_min_satisfying();
+      var minVersion = require_min_version();
+      var validRange = require_valid2();
+      var outside = require_outside();
+      var gtr = require_gtr();
+      var ltr = require_ltr();
+      var intersects = require_intersects();
+      var simplifyRange = require_simplify();
+      var subset = require_subset();
+      module2.exports = {
+        parse,
+        valid: valid2,
+        clean,
+        inc,
+        diff,
+        major,
+        minor,
+        patch,
+        prerelease,
+        compare: compare2,
+        rcompare,
+        compareLoose,
+        compareBuild,
+        sort,
+        rsort,
+        gt,
+        lt,
+        eq,
+        neq,
+        gte: gte2,
+        lte,
+        cmp,
+        coerce: coerce2,
+        Comparator,
+        Range,
+        satisfies: satisfies2,
+        toComparators,
+        maxSatisfying,
+        minSatisfying,
+        minVersion,
+        validRange,
+        outside,
+        gtr,
+        ltr,
+        intersects,
+        simplifyRange,
+        subset,
+        SemVer,
+        re: internalRe.re,
+        src: internalRe.src,
+        tokens: internalRe.t,
+        SEMVER_SPEC_VERSION: constants2.SEMVER_SPEC_VERSION,
+        RELEASE_TYPES: constants2.RELEASE_TYPES,
+        compareIdentifiers: identifiers.compareIdentifiers,
+        rcompareIdentifiers: identifiers.rcompareIdentifiers
+      };
+    }
+  });
+  var CliForegroundColor = /* @__PURE__ */ ((CliForegroundColor2) => {
+    CliForegroundColor2["Black"] = "\x1B[30m";
+    CliForegroundColor2["Red"] = "\x1B[31m";
+    CliForegroundColor2["Green"] = "\x1B[32m";
+    CliForegroundColor2["Yellow"] = "\x1B[33m";
+    CliForegroundColor2["Blue"] = "\x1B[34m";
+    CliForegroundColor2["Magenta"] = "\x1B[35m";
+    CliForegroundColor2["Cyan"] = "\x1B[36m";
+    CliForegroundColor2["White"] = "\x1B[37m";
+    CliForegroundColor2["Reset"] = "\x1B[0m";
+    return CliForegroundColor2;
+  })(CliForegroundColor || {});
+  var CliIcon = /* @__PURE__ */ ((CliIcon2) => {
+    CliIcon2["CheckIcon"] = "\u2714";
+    CliIcon2["CrossIcon"] = "\u2718";
+    CliIcon2["InfoIcon"] = "\u2139";
+    CliIcon2["WarningIcon"] = "\u26A0";
+    CliIcon2["QuestionMark"] = "?";
+    CliIcon2["Exclamation"] = "\u2757";
+    CliIcon2["Ellipsis"] = "\u2026";
+    CliIcon2["Dot"] = "\u2022";
+    CliIcon2["Bullet"] = "\u2023";
+    CliIcon2["ArrowRight"] = "\u2192";
+    CliIcon2["ArrowLeft"] = "\u2190";
+    CliIcon2["ArrowUp"] = "\u2191";
+    CliIcon2["ArrowDown"] = "\u2193";
+    CliIcon2["ArrowRightFilled"] = "\u25B6";
+    CliIcon2["ArrowLeftFilled"] = "\u25C0";
+    CliIcon2["ArrowUpFilled"] = "\u25B2";
+    CliIcon2["ArrowDownFilled"] = "\u25BC";
+    CliIcon2["DoubleArrowRight"] = "\xBB";
+    CliIcon2["DoubleArrowLeft"] = "\xAB";
+    CliIcon2["Star"] = "\u2605";
+    CliIcon2["StarEmpty"] = "\u2606";
+    CliIcon2["Plus"] = "+";
+    CliIcon2["Minus"] = "-";
+    CliIcon2["Progress"] = "\u23F3";
+    CliIcon2["Success"] = "\u2705";
+    CliIcon2["Failure"] = "\u274C";
+    CliIcon2["Clock"] = "\u23F0";
+    CliIcon2["Timer"] = "\u23F1";
+    CliIcon2["Alarm"] = "\u{1F514}";
+    CliIcon2["Calendar"] = "\u{1F4C5}";
+    CliIcon2["Folder"] = "\u{1F4C1}";
+    CliIcon2["FolderOpen"] = "\u{1F4C2}";
+    CliIcon2["File"] = "\u{1F4C4}";
+    CliIcon2["Archive"] = "\u{1F5C3}";
+    CliIcon2["Link"] = "\u{1F517}";
+    CliIcon2["Chain"] = "\u26D3";
+    CliIcon2["Bookmark"] = "\u{1F516}";
+    CliIcon2["Edit"] = "\u270F";
+    CliIcon2["Trash"] = "\u{1F5D1}";
+    CliIcon2["Add"] = "\u2795";
+    CliIcon2["Remove"] = "\u2796";
+    CliIcon2["Reload"] = "\u{1F504}";
+    CliIcon2["Save"] = "\u{1F4BE}";
+    CliIcon2["Undo"] = "\u21A9";
+    CliIcon2["Redo"] = "\u21AA";
+    CliIcon2["Play"] = "\u25B6";
+    CliIcon2["Pause"] = "\u23F8";
+    CliIcon2["Stop"] = "\u23F9";
+    CliIcon2["Cancel"] = "\u274E";
+    CliIcon2["User"] = "\u{1F464}";
+    CliIcon2["Group"] = "\u{1F465}";
+    CliIcon2["Lock"] = "\u{1F512}";
+    CliIcon2["Unlock"] = "\u{1F513}";
+    CliIcon2["Help"] = "\u2753";
+    CliIcon2["Key"] = "\u{1F511}";
+    CliIcon2["Shield"] = "\u{1F6E1}";
+    CliIcon2["Gear"] = "\u2699";
+    CliIcon2["Settings"] = "\u2699\uFE0F";
+    CliIcon2["Theme"] = "\u{1F3A8}";
+    CliIcon2["Light"] = "\u{1F4A1}";
+    CliIcon2["Bug"] = "\u{1F41E}";
+    CliIcon2["Wrench"] = "\u{1F527}";
+    CliIcon2["Hammer"] = "\u{1F528}";
+    CliIcon2["Terminal"] = "\u{1F4BB}";
+    CliIcon2["Database"] = "\u{1F5C4}";
+    CliIcon2["Server"] = "\u{1F5A5}";
+    CliIcon2["Cloud"] = "\u2601";
+    CliIcon2["Network"] = "\u{1F310}";
+    CliIcon2["Monitor"] = "\u{1F5A5}";
+    CliIcon2["Printer"] = "\u{1F5A8}";
+    CliIcon2["USB"] = "\u{1F50C}";
+    CliIcon2["Speaker"] = "\u{1F50A}";
+    CliIcon2["Microphone"] = "\u{1F399}";
+    CliIcon2["Camera"] = "\u{1F4F7}";
+    CliIcon2["Video"] = "\u{1F3A5}";
+    CliIcon2["Music"] = "\u{1F3B5}";
+    CliIcon2["Phone"] = "\u{1F4DE}";
+    CliIcon2["Package"] = "\u{1F4E6}";
+    CliIcon2["Plugin"] = "\u{1F50C}";
+    CliIcon2["Extension"] = "\u{1F9E9}";
+    CliIcon2["Module"] = "\u{1F4E6}";
+    CliIcon2["Evaluate"] = "\u{1F50D}";
+    CliIcon2["Variable"] = "\u{1F527}";
+    CliIcon2["Script"] = "\u{1F4DC}";
+    CliIcon2["Code"] = "\u{1F4BE}";
+    CliIcon2["Logs"] = "\u{1F4DC}";
+    CliIcon2["Power"] = "\u23FB";
+    CliIcon2["Heart"] = "\u2764";
+    CliIcon2["Flame"] = "\u{1F525}";
+    CliIcon2["Growth"] = "\u{1F4C8}";
+    CliIcon2["Decline"] = "\u{1F4C9}";
+    CliIcon2["WarningFilled"] = "\u26A0\uFE0F";
+    CliIcon2["Sun"] = "\u2600";
+    CliIcon2["Moon"] = "\u{1F319}";
+    CliIcon2["Rain"] = "\u{1F327}";
+    CliIcon2["Snow"] = "\u2744";
+    CliIcon2["Lightning"] = "\u26A1";
+    CliIcon2["Tree"] = "\u{1F332}";
+    CliIcon2["Smile"] = "\u{1F60A}";
+    CliIcon2["Sad"] = "\u{1F622}";
+    CliIcon2["Angry"] = "\u{1F621}";
+    CliIcon2["Clap"] = "\u{1F44F}";
+    CliIcon2["ThumbsUp"] = "\u{1F44D}";
+    CliIcon2["ThumbsDown"] = "\u{1F44E}";
+    CliIcon2["Rocket"] = "\u{1F680}";
+    CliIcon2["Globe"] = "\u{1F30D}";
+    CliIcon2["Medal"] = "\u{1F3C5}";
+    CliIcon2["Trophy"] = "\u{1F3C6}";
+    CliIcon2["Flag"] = "\u{1F6A9}";
+    CliIcon2["StarFilled"] = "\u2B50";
+    CliIcon2["StarOutline"] = "\u2729";
+    CliIcon2["Fireworks"] = "\u{1F386}";
+    CliIcon2["Balloon"] = "\u{1F388}";
+    CliIcon2["Gift"] = "\u{1F381}";
+    return CliIcon2;
+  })(CliIcon || {});
+  var ICliCompletionProvider_TOKEN = "cli-completion-provider";
+  var DefaultLibraryAuthor = {
+    name: "Nicolae Lupei",
+    email: "nicolae.lupei@qodalis.com"
+  };
+  var semver = __toESM(require_semver2());
+  var ServerVersionNegotiator = class {
+    static {
+      this.CLIENT_SUPPORTED_VERSIONS = [2];
+    }
+    /**
+     * Given a server's version info, pick the highest mutually compatible version.
+     * Returns null if no compatible version exists.
+     */
+    static negotiate(serverInfo) {
+      const common = this.CLIENT_SUPPORTED_VERSIONS.filter(
+        (v) => serverInfo.supportedVersions.includes(v)
+      );
+      return common.length > 0 ? Math.max(...common) : null;
+    }
+    /**
+     * Discover the server's supported versions and negotiate the best match.
+     * Returns the negotiated API version and the base path for all subsequent calls,
+     * or null if the server is unreachable or incompatible.
+     */
+    static async discover(baseUrl) {
+      try {
+        const response = await fetch(`${baseUrl}/api/qcli/versions`);
+        if (!response.ok) return null;
+        const info = await response.json();
+        const version = this.negotiate(info);
+        if (version === null) return null;
+        return {
+          apiVersion: version,
+          basePath: `${baseUrl}/api/v${version}/qcli`
+        };
+      } catch {
+        return null;
+      }
+    }
+  };
+  var bootCliModule = async (module2) => {
+    if (typeof window !== "undefined" && window.__cliModuleRegistry) {
+      await window.__cliModuleRegistry.register(module2);
+    }
+  };
+  var DefaultThemes = {
+    default: {
+      background: "#070b14",
+      foreground: "#dee2ea",
+      cursor: "#818cf8",
+      selectionBackground: "#334155",
+      selectionForeground: "#ffffff",
+      black: "#0d1117",
+      red: "#f87171",
+      green: "#4ade80",
+      yellow: "#fbbf24",
+      blue: "#818cf8",
+      magenta: "#c084fc",
+      cyan: "#67e8f9",
+      white: "#dee2ea",
+      brightBlack: "#475569",
+      brightRed: "#fca5a5",
+      brightGreen: "#86efac",
+      brightYellow: "#fde68a",
+      brightBlue: "#a5b4fc",
+      brightMagenta: "#d8b4fe",
+      brightCyan: "#a5f3fc",
+      brightWhite: "#f1f5f9"
+    },
+    classic: {
+      background: "#0c0c0c",
+      foreground: "#cccccc",
+      cursor: "#cccccc",
+      selectionBackground: "#264f78",
+      selectionForeground: "#ffffff",
+      black: "#0c0c0c",
+      red: "#c50f1f",
+      green: "#13a10e",
+      yellow: "#c19c00",
+      blue: "#0037da",
+      magenta: "#881798",
+      cyan: "#3a96dd",
+      white: "#cccccc",
+      brightBlack: "#767676",
+      brightRed: "#e74856",
+      brightGreen: "#16c60c",
+      brightYellow: "#f9f1a5",
+      brightBlue: "#3b78ff",
+      brightMagenta: "#b4009e",
+      brightCyan: "#61d6d6",
+      brightWhite: "#f2f2f2"
+    },
+    dracula: {
+      background: "#282A36",
+      foreground: "#F8F8F2",
+      cursor: "#50FA7B",
+      black: "#21222C",
+      red: "#FF5555",
+      green: "#50FA7B",
+      yellow: "#F1FA8C",
+      blue: "#BD93F9",
+      magenta: "#FF79C6",
+      cyan: "#8BE9FD",
+      white: "#F8F8F2",
+      brightBlack: "#6272A4",
+      brightRed: "#FF6E6E",
+      brightGreen: "#69FF94",
+      brightYellow: "#FFFFA5",
+      brightBlue: "#D6ACFF",
+      brightMagenta: "#FF92D0",
+      brightCyan: "#A4FFFF",
+      brightWhite: "#FFFFFF"
+    },
+    monokai: {
+      background: "#272822",
+      foreground: "#F8F8F2",
+      cursor: "#F8F8F0",
+      black: "#272822",
+      red: "#F92672",
+      green: "#A6E22E",
+      yellow: "#F4BF75",
+      blue: "#66D9EF",
+      magenta: "#AE81FF",
+      cyan: "#A1EFE4",
+      white: "#F8F8F2",
+      brightBlack: "#75715E",
+      brightRed: "#F92672",
+      brightGreen: "#A6E22E",
+      brightYellow: "#F4BF75",
+      brightBlue: "#66D9EF",
+      brightMagenta: "#AE81FF",
+      brightCyan: "#A1EFE4",
+      brightWhite: "#F9F8F5"
+    },
+    solarizedDark: {
+      background: "#002B36",
+      foreground: "#839496",
+      cursor: "#93A1A1",
+      black: "#073642",
+      red: "#DC322F",
+      green: "#859900",
+      yellow: "#B58900",
+      blue: "#268BD2",
+      magenta: "#D33682",
+      cyan: "#2AA198",
+      white: "#EEE8D5",
+      brightBlack: "#002B36",
+      brightRed: "#CB4B16",
+      brightGreen: "#586E75",
+      brightYellow: "#657B83",
+      brightBlue: "#839496",
+      brightMagenta: "#6C71C4",
+      brightCyan: "#93A1A1",
+      brightWhite: "#FDF6E3"
+    },
+    solarizedLight: {
+      background: "#FDF6E3",
+      foreground: "#657B83",
+      cursor: "#586E75",
+      black: "#073642",
+      red: "#DC322F",
+      green: "#859900",
+      yellow: "#B58900",
+      blue: "#268BD2",
+      magenta: "#D33682",
+      cyan: "#2AA198",
+      white: "#EEE8D5",
+      brightBlack: "#002B36",
+      brightRed: "#CB4B16",
+      brightGreen: "#586E75",
+      brightYellow: "#657B83",
+      brightBlue: "#839496",
+      brightMagenta: "#6C71C4",
+      brightCyan: "#93A1A1",
+      brightWhite: "#FDF6E3"
+    },
+    gruvboxDark: {
+      background: "#282828",
+      foreground: "#EBDBB2",
+      cursor: "#EBDBB2",
+      black: "#282828",
+      red: "#CC241D",
+      green: "#98971A",
+      yellow: "#D79921",
+      blue: "#458588",
+      magenta: "#B16286",
+      cyan: "#689D6A",
+      white: "#A89984",
+      brightBlack: "#928374",
+      brightRed: "#FB4934",
+      brightGreen: "#B8BB26",
+      brightYellow: "#FABD2F",
+      brightBlue: "#83A598",
+      brightMagenta: "#D3869B",
+      brightCyan: "#8EC07C",
+      brightWhite: "#EBDBB2"
+    },
+    gruvboxLight: {
+      background: "#FBF1C7",
+      foreground: "#3C3836",
+      cursor: "#3C3836",
+      black: "#FBF1C7",
+      red: "#9D0006",
+      green: "#79740E",
+      yellow: "#B57614",
+      blue: "#076678",
+      magenta: "#8F3F71",
+      cyan: "#427B58",
+      white: "#3C3836",
+      brightBlack: "#D5C4A1",
+      brightRed: "#AF3A03",
+      brightGreen: "#B8BB26",
+      brightYellow: "#FABD2F",
+      brightBlue: "#83A598",
+      brightMagenta: "#D3869B",
+      brightCyan: "#8EC07C",
+      brightWhite: "#EBDBB2"
+    },
+    nord: {
+      background: "#2E3440",
+      foreground: "#D8DEE9",
+      cursor: "#88C0D0",
+      black: "#3B4252",
+      red: "#BF616A",
+      green: "#A3BE8C",
+      yellow: "#EBCB8B",
+      blue: "#81A1C1",
+      magenta: "#B48EAD",
+      cyan: "#88C0D0",
+      white: "#E5E9F0",
+      brightBlack: "#4C566A",
+      brightRed: "#BF616A",
+      brightGreen: "#A3BE8C",
+      brightYellow: "#EBCB8B",
+      brightBlue: "#81A1C1",
+      brightMagenta: "#B48EAD",
+      brightCyan: "#8FBCBB",
+      brightWhite: "#ECEFF4"
+    },
+    oneDark: {
+      background: "#282C34",
+      foreground: "#ABB2BF",
+      cursor: "#528BFF",
+      black: "#282C34",
+      red: "#E06C75",
+      green: "#98C379",
+      yellow: "#E5C07B",
+      blue: "#61AFEF",
+      magenta: "#C678DD",
+      cyan: "#56B6C2",
+      white: "#ABB2BF",
+      brightBlack: "#5C6370",
+      brightRed: "#E06C75",
+      brightGreen: "#98C379",
+      brightYellow: "#E5C07B",
+      brightBlue: "#61AFEF",
+      brightMagenta: "#C678DD",
+      brightCyan: "#56B6C2",
+      brightWhite: "#FFFFFF"
+    },
+    material: {
+      background: "#263238",
+      foreground: "#ECEFF1",
+      cursor: "#FFCC00",
+      black: "#263238",
+      red: "#F07178",
+      green: "#C3E88D",
+      yellow: "#FFCB6B",
+      blue: "#82AAFF",
+      magenta: "#C792EA",
+      cyan: "#89DDFF",
+      white: "#EEFFFF",
+      brightBlack: "#546E7A",
+      brightRed: "#F07178",
+      brightGreen: "#C3E88D",
+      brightYellow: "#FFCB6B",
+      brightBlue: "#82AAFF",
+      brightMagenta: "#C792EA",
+      brightCyan: "#89DDFF",
+      brightWhite: "#FFFFFF"
+    },
+    highContrastLight: {
+      background: "#FFFACD",
+      foreground: "#000000",
+      cursor: "#FFA500",
+      selectionBackground: "#FFD700",
+      black: "#3B3A32",
+      red: "#D32F2F",
+      green: "#388E3C",
+      yellow: "#FBC02D",
+      blue: "#1976D2",
+      magenta: "#8E24AA",
+      cyan: "#0097A7",
+      white: "#FFFFFF",
+      brightBlack: "#616161",
+      brightRed: "#FF5252",
+      brightGreen: "#69F0AE",
+      brightYellow: "#FFEB3B",
+      brightBlue: "#64B5F6",
+      brightMagenta: "#BA68C8",
+      brightCyan: "#4DD0E1",
+      brightWhite: "#FAFAFA"
+    },
+    tokyoNight: {
+      background: "#1a1b26",
+      foreground: "#c0caf5",
+      cursor: "#c0caf5",
+      selectionBackground: "#33467c",
+      black: "#15161e",
+      red: "#f7768e",
+      green: "#9ece6a",
+      yellow: "#e0af68",
+      blue: "#7aa2f7",
+      magenta: "#bb9af7",
+      cyan: "#7dcfff",
+      white: "#a9b1d6",
+      brightBlack: "#414868",
+      brightRed: "#f7768e",
+      brightGreen: "#9ece6a",
+      brightYellow: "#e0af68",
+      brightBlue: "#7aa2f7",
+      brightMagenta: "#bb9af7",
+      brightCyan: "#7dcfff",
+      brightWhite: "#c0caf5"
+    },
+    catppuccinMocha: {
+      background: "#1e1e2e",
+      foreground: "#cdd6f4",
+      cursor: "#f5e0dc",
+      selectionBackground: "#45475a",
+      black: "#45475a",
+      red: "#f38ba8",
+      green: "#a6e3a1",
+      yellow: "#f9e2af",
+      blue: "#89b4fa",
+      magenta: "#f5c2e7",
+      cyan: "#94e2d5",
+      white: "#bac2de",
+      brightBlack: "#585b70",
+      brightRed: "#f38ba8",
+      brightGreen: "#a6e3a1",
+      brightYellow: "#f9e2af",
+      brightBlue: "#89b4fa",
+      brightMagenta: "#f5c2e7",
+      brightCyan: "#94e2d5",
+      brightWhite: "#a6adc8"
+    },
+    catppuccinFrappe: {
+      background: "#303446",
+      foreground: "#c6d0f5",
+      cursor: "#f2d5cf",
+      selectionBackground: "#51576d",
+      black: "#51576d",
+      red: "#e78284",
+      green: "#a6d189",
+      yellow: "#e5c890",
+      blue: "#8caaee",
+      magenta: "#f4b8e4",
+      cyan: "#81c8be",
+      white: "#b5bfe2",
+      brightBlack: "#626880",
+      brightRed: "#e78284",
+      brightGreen: "#a6d189",
+      brightYellow: "#e5c890",
+      brightBlue: "#8caaee",
+      brightMagenta: "#f4b8e4",
+      brightCyan: "#81c8be",
+      brightWhite: "#a5adce"
+    },
+    rosePine: {
+      background: "#191724",
+      foreground: "#e0def4",
+      cursor: "#524f67",
+      selectionBackground: "#2a283e",
+      black: "#26233a",
+      red: "#eb6f92",
+      green: "#31748f",
+      yellow: "#f6c177",
+      blue: "#9ccfd8",
+      magenta: "#c4a7e7",
+      cyan: "#ebbcba",
+      white: "#e0def4",
+      brightBlack: "#6e6a86",
+      brightRed: "#eb6f92",
+      brightGreen: "#31748f",
+      brightYellow: "#f6c177",
+      brightBlue: "#9ccfd8",
+      brightMagenta: "#c4a7e7",
+      brightCyan: "#ebbcba",
+      brightWhite: "#e0def4"
+    },
+    kanagawa: {
+      background: "#1f1f28",
+      foreground: "#dcd7ba",
+      cursor: "#c8c093",
+      selectionBackground: "#2d4f67",
+      black: "#16161d",
+      red: "#c34043",
+      green: "#76946a",
+      yellow: "#c0a36e",
+      blue: "#7e9cd8",
+      magenta: "#957fb8",
+      cyan: "#6a9589",
+      white: "#c8c093",
+      brightBlack: "#727169",
+      brightRed: "#e82424",
+      brightGreen: "#98bb6c",
+      brightYellow: "#e6c384",
+      brightBlue: "#7fb4ca",
+      brightMagenta: "#938aa9",
+      brightCyan: "#7aa89f",
+      brightWhite: "#dcd7ba"
+    },
+    everforestDark: {
+      background: "#2d353b",
+      foreground: "#d3c6aa",
+      cursor: "#d3c6aa",
+      selectionBackground: "#543a48",
+      black: "#475258",
+      red: "#e67e80",
+      green: "#a7c080",
+      yellow: "#dbbc7f",
+      blue: "#7fbbb3",
+      magenta: "#d699b6",
+      cyan: "#83c092",
+      white: "#d3c6aa",
+      brightBlack: "#475258",
+      brightRed: "#e67e80",
+      brightGreen: "#a7c080",
+      brightYellow: "#dbbc7f",
+      brightBlue: "#7fbbb3",
+      brightMagenta: "#d699b6",
+      brightCyan: "#83c092",
+      brightWhite: "#d3c6aa"
+    },
+    ayuDark: {
+      background: "#0b0e14",
+      foreground: "#bfbdb6",
+      cursor: "#e6b450",
+      selectionBackground: "#1b3a4b",
+      black: "#01060e",
+      red: "#ea6c73",
+      green: "#91b362",
+      yellow: "#f9af4f",
+      blue: "#53bdfa",
+      magenta: "#fae994",
+      cyan: "#90e1c6",
+      white: "#c7c7c7",
+      brightBlack: "#686868",
+      brightRed: "#f07178",
+      brightGreen: "#c2d94c",
+      brightYellow: "#ffb454",
+      brightBlue: "#59c2ff",
+      brightMagenta: "#ffee99",
+      brightCyan: "#95e6cb",
+      brightWhite: "#ffffff"
+    },
+    catppuccinLatte: {
+      background: "#eff1f5",
+      foreground: "#4c4f69",
+      cursor: "#dc8a78",
+      selectionBackground: "#acb0be",
+      black: "#5c5f77",
+      red: "#d20f39",
+      green: "#40a02b",
+      yellow: "#df8e1d",
+      blue: "#1e66f5",
+      magenta: "#ea76cb",
+      cyan: "#179299",
+      white: "#acb0be",
+      brightBlack: "#6c6f85",
+      brightRed: "#d20f39",
+      brightGreen: "#40a02b",
+      brightYellow: "#df8e1d",
+      brightBlue: "#1e66f5",
+      brightMagenta: "#ea76cb",
+      brightCyan: "#179299",
+      brightWhite: "#bcc0cc"
+    },
+    rosePineDawn: {
+      background: "#faf4ed",
+      foreground: "#575279",
+      cursor: "#9893a5",
+      selectionBackground: "#dfdad9",
+      black: "#f2e9e1",
+      red: "#b4637a",
+      green: "#286983",
+      yellow: "#ea9d34",
+      blue: "#56949f",
+      magenta: "#907aa9",
+      cyan: "#d7827e",
+      white: "#575279",
+      brightBlack: "#9893a5",
+      brightRed: "#b4637a",
+      brightGreen: "#286983",
+      brightYellow: "#ea9d34",
+      brightBlue: "#56949f",
+      brightMagenta: "#907aa9",
+      brightCyan: "#d7827e",
+      brightWhite: "#575279"
+    },
+    everforestLight: {
+      background: "#fdf6e3",
+      foreground: "#5c6a72",
+      cursor: "#5c6a72",
+      selectionBackground: "#e6e2cc",
+      black: "#5c6a72",
+      red: "#f85552",
+      green: "#8da101",
+      yellow: "#dfa000",
+      blue: "#3a94c5",
+      magenta: "#df69ba",
+      cyan: "#35a77c",
+      white: "#dfddc8",
+      brightBlack: "#708089",
+      brightRed: "#f85552",
+      brightGreen: "#8da101",
+      brightYellow: "#dfa000",
+      brightBlue: "#3a94c5",
+      brightMagenta: "#df69ba",
+      brightCyan: "#35a77c",
+      brightWhite: "#e8e5d0"
+    },
+    githubLight: {
+      background: "#ffffff",
+      foreground: "#24292f",
+      cursor: "#044289",
+      selectionBackground: "#0969da33",
+      black: "#24292f",
+      red: "#cf222e",
+      green: "#116329",
+      yellow: "#4d2d00",
+      blue: "#0969da",
+      magenta: "#8250df",
+      cyan: "#1b7c83",
+      white: "#6e7781",
+      brightBlack: "#57606a",
+      brightRed: "#a40e26",
+      brightGreen: "#1a7f37",
+      brightYellow: "#633c01",
+      brightBlue: "#218bff",
+      brightMagenta: "#a475f9",
+      brightCyan: "#3192aa",
+      brightWhite: "#8c959f"
+    },
+    cyberpunk: {
+      background: "#0a0a1a",
+      foreground: "#0abdc6",
+      cursor: "#ff2079",
+      selectionBackground: "#1a1a3a",
+      black: "#000000",
+      red: "#ff2079",
+      green: "#00ff9c",
+      yellow: "#fed230",
+      blue: "#0abdc6",
+      magenta: "#ea00d9",
+      cyan: "#0abdc6",
+      white: "#c7c7c7",
+      brightBlack: "#686868",
+      brightRed: "#ff4a9e",
+      brightGreen: "#3df5b6",
+      brightYellow: "#fef465",
+      brightBlue: "#3ff1de",
+      brightMagenta: "#ff79f0",
+      brightCyan: "#3ff1de",
+      brightWhite: "#ffffff"
+    },
+    retroGreen: {
+      background: "#0a0a0a",
+      foreground: "#33ff00",
+      cursor: "#33ff00",
+      selectionBackground: "#1a3a1a",
+      black: "#0a0a0a",
+      red: "#ff0000",
+      green: "#33ff00",
+      yellow: "#ffff00",
+      blue: "#0066ff",
+      magenta: "#cc00ff",
+      cyan: "#00ffff",
+      white: "#33ff00",
+      brightBlack: "#1a5c1a",
+      brightRed: "#ff3333",
+      brightGreen: "#66ff33",
+      brightYellow: "#ffff66",
+      brightBlue: "#3399ff",
+      brightMagenta: "#e550ff",
+      brightCyan: "#66ffff",
+      brightWhite: "#66ff33"
+    },
+    retroAmber: {
+      background: "#0a0a00",
+      foreground: "#ffb000",
+      cursor: "#ffb000",
+      selectionBackground: "#3a2a00",
+      black: "#0a0a00",
+      red: "#ff0000",
+      green: "#ffb000",
+      yellow: "#ffcc00",
+      blue: "#cc8800",
+      magenta: "#ff8800",
+      cyan: "#ffcc66",
+      white: "#ffb000",
+      brightBlack: "#665500",
+      brightRed: "#ff3333",
+      brightGreen: "#ffc033",
+      brightYellow: "#ffdd33",
+      brightBlue: "#ddaa33",
+      brightMagenta: "#ffaa33",
+      brightCyan: "#ffdd99",
+      brightWhite: "#ffc033"
+    },
+    matrix: {
+      background: "#000000",
+      foreground: "#00ff41",
+      cursor: "#00ff41",
+      selectionBackground: "#003300",
+      black: "#000000",
+      red: "#00ff41",
+      green: "#00ff41",
+      yellow: "#00ff41",
+      blue: "#00cc33",
+      magenta: "#009926",
+      cyan: "#00ff41",
+      white: "#00ff41",
+      brightBlack: "#005500",
+      brightRed: "#33ff66",
+      brightGreen: "#33ff66",
+      brightYellow: "#33ff66",
+      brightBlue: "#00ff41",
+      brightMagenta: "#00cc33",
+      brightCyan: "#33ff66",
+      brightWhite: "#66ff88"
+    },
+    synthwave: {
+      background: "#2b213a",
+      foreground: "#f0e4fc",
+      cursor: "#72f1b8",
+      selectionBackground: "#463465",
+      black: "#2b213a",
+      red: "#fe4450",
+      green: "#72f1b8",
+      yellow: "#fede5d",
+      blue: "#2ee2fa",
+      magenta: "#ff7edb",
+      cyan: "#03edf9",
+      white: "#f0e4fc",
+      brightBlack: "#614d85",
+      brightRed: "#fe4450",
+      brightGreen: "#72f1b8",
+      brightYellow: "#fede5d",
+      brightBlue: "#2ee2fa",
+      brightMagenta: "#ff7edb",
+      brightCyan: "#03edf9",
+      brightWhite: "#ffffff"
+    },
+    highContrastDark: {
+      background: "#000000",
+      foreground: "#ffffff",
+      cursor: "#ffffff",
+      selectionBackground: "#264f78",
+      selectionForeground: "#ffffff",
+      black: "#000000",
+      red: "#ff0000",
+      green: "#00ff00",
+      yellow: "#ffff00",
+      blue: "#3b78ff",
+      magenta: "#ff00ff",
+      cyan: "#00ffff",
+      white: "#ffffff",
+      brightBlack: "#808080",
+      brightRed: "#ff3333",
+      brightGreen: "#33ff33",
+      brightYellow: "#ffff33",
+      brightBlue: "#6699ff",
+      brightMagenta: "#ff33ff",
+      brightCyan: "#33ffff",
+      brightWhite: "#ffffff"
+    }
+  };
+  DefaultThemes.yellow = DefaultThemes.highContrastLight;
+  var DefaultThemeInfos = {
+    default: {
+      theme: DefaultThemes.default,
+      category: "dark",
+      tags: ["built-in"],
+      description: "Dark indigo theme with soft pastels"
+    },
+    classic: {
+      theme: DefaultThemes.classic,
+      category: "dark",
+      tags: ["built-in"],
+      description: "Classic Windows terminal palette"
+    },
+    dracula: {
+      theme: DefaultThemes.dracula,
+      category: "dark",
+      tags: ["popular"],
+      description: "Popular dark theme with vibrant colors"
+    },
+    monokai: {
+      theme: DefaultThemes.monokai,
+      category: "dark",
+      tags: ["popular"],
+      description: "Classic code editor dark theme"
+    },
+    solarizedDark: {
+      theme: DefaultThemes.solarizedDark,
+      category: "dark",
+      tags: ["popular"],
+      description: "Ethan Schoonover's precision dark palette"
+    },
+    solarizedLight: {
+      theme: DefaultThemes.solarizedLight,
+      category: "light",
+      tags: ["popular"],
+      description: "Ethan Schoonover's precision light palette"
+    },
+    gruvboxDark: {
+      theme: DefaultThemes.gruvboxDark,
+      category: "dark",
+      tags: ["popular"],
+      description: "Retro groove dark color scheme"
+    },
+    gruvboxLight: {
+      theme: DefaultThemes.gruvboxLight,
+      category: "light",
+      tags: ["popular"],
+      description: "Retro groove light color scheme"
+    },
+    nord: {
+      theme: DefaultThemes.nord,
+      category: "dark",
+      tags: ["popular"],
+      description: "Arctic, north-bluish clean palette"
+    },
+    oneDark: {
+      theme: DefaultThemes.oneDark,
+      category: "dark",
+      tags: ["popular"],
+      description: "Atom's iconic dark theme"
+    },
+    material: {
+      theme: DefaultThemes.material,
+      category: "dark",
+      tags: ["popular"],
+      description: "Material Design inspired dark theme"
+    },
+    highContrastLight: {
+      theme: DefaultThemes.highContrastLight,
+      category: "light",
+      tags: ["accessibility"],
+      description: "High contrast light theme for accessibility"
+    },
+    tokyoNight: {
+      theme: DefaultThemes.tokyoNight,
+      category: "dark",
+      tags: ["popular"],
+      description: "Cool blue-purple dark theme"
+    },
+    catppuccinMocha: {
+      theme: DefaultThemes.catppuccinMocha,
+      category: "dark",
+      tags: ["popular", "pastel"],
+      description: "Soothing pastel dark theme (warmest)"
+    },
+    catppuccinFrappe: {
+      theme: DefaultThemes.catppuccinFrappe,
+      category: "dark",
+      tags: ["popular", "pastel"],
+      description: "Soothing pastel mid-dark theme"
+    },
+    catppuccinLatte: {
+      theme: DefaultThemes.catppuccinLatte,
+      category: "light",
+      tags: ["popular", "pastel"],
+      description: "Soothing pastel light theme"
+    },
+    rosePine: {
+      theme: DefaultThemes.rosePine,
+      category: "dark",
+      tags: ["popular"],
+      description: "All natural pine, faux fur, and a bit of soho vibes"
+    },
+    rosePineDawn: {
+      theme: DefaultThemes.rosePineDawn,
+      category: "light",
+      tags: ["popular"],
+      description: "Rose Pine light variant"
+    },
+    kanagawa: {
+      theme: DefaultThemes.kanagawa,
+      category: "dark",
+      tags: ["popular"],
+      description: "Dark theme inspired by Katsushika Hokusai"
+    },
+    everforestDark: {
+      theme: DefaultThemes.everforestDark,
+      category: "dark",
+      tags: ["popular"],
+      description: "Comfortable green-tinted dark theme"
+    },
+    everforestLight: {
+      theme: DefaultThemes.everforestLight,
+      category: "light",
+      tags: ["popular"],
+      description: "Comfortable green-tinted light theme"
+    },
+    ayuDark: {
+      theme: DefaultThemes.ayuDark,
+      category: "dark",
+      tags: ["popular"],
+      description: "Simple, bright and elegant dark theme"
+    },
+    githubLight: {
+      theme: DefaultThemes.githubLight,
+      category: "light",
+      tags: ["popular"],
+      description: "GitHub's clean light interface theme"
+    },
+    cyberpunk: {
+      theme: DefaultThemes.cyberpunk,
+      category: "dark",
+      tags: ["retro", "fun"],
+      description: "Neon-lit cyberpunk aesthetic"
+    },
+    retroGreen: {
+      theme: DefaultThemes.retroGreen,
+      category: "dark",
+      tags: ["retro", "fun"],
+      description: "Classic green phosphor CRT monitor"
+    },
+    retroAmber: {
+      theme: DefaultThemes.retroAmber,
+      category: "dark",
+      tags: ["retro", "fun"],
+      description: "Warm amber CRT monitor"
+    },
+    matrix: {
+      theme: DefaultThemes.matrix,
+      category: "dark",
+      tags: ["retro", "fun"],
+      description: "Enter the Matrix - green on black"
+    },
+    synthwave: {
+      theme: DefaultThemes.synthwave,
+      category: "dark",
+      tags: ["retro", "fun"],
+      description: "80s synthwave purple/pink aesthetic"
+    },
+    highContrastDark: {
+      theme: DefaultThemes.highContrastDark,
+      category: "dark",
+      tags: ["accessibility"],
+      description: "Maximum contrast dark theme"
+    }
+  };
+  // src/lib/services/cli-jobs-service.ts
+  var CliJobsService = class {
+    constructor(baseUrl, headers = {}) {
+      this.baseUrl = baseUrl;
+      this.headers = headers;
+    }
+    async request(path, init) {
+      const url = `${this.baseUrl}/api/v1/qcli/jobs${path}`;
+      const response = await fetch(url, {
+        ...init,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.headers,
+          ...init?.headers ?? {}
+        }
+      });
+      if (!response.ok) {
+        let errorMessage = `${response.status} ${response.statusText}`;
+        try {
+          const body = await response.json();
+          if (body.error) {
+            errorMessage = body.error;
+          }
+        } catch {
+        }
+        throw new Error(errorMessage);
+      }
+      const text = await response.text();
+      if (!text) {
+        return void 0;
+      }
+      return JSON.parse(text);
+    }
+    async listJobs() {
+      return this.request("");
+    }
+    async getJob(id) {
+      return this.request(`/${encodeURIComponent(id)}`);
+    }
+    async triggerJob(id) {
+      await this.request(`/${encodeURIComponent(id)}/trigger`, {
+        method: "POST"
+      });
+    }
+    async pauseJob(id) {
+      await this.request(`/${encodeURIComponent(id)}/pause`, {
+        method: "POST"
+      });
+    }
+    async resumeJob(id) {
+      await this.request(`/${encodeURIComponent(id)}/resume`, {
+        method: "POST"
+      });
+    }
+    async stopJob(id) {
+      await this.request(`/${encodeURIComponent(id)}/stop`, {
+        method: "POST"
+      });
+    }
+    async cancelJob(id) {
+      await this.request(`/${encodeURIComponent(id)}/cancel`, {
+        method: "POST"
+      });
+    }
+    async updateJob(id, request) {
+      await this.request(`/${encodeURIComponent(id)}`, {
+        method: "PUT",
+        body: JSON.stringify(request)
+      });
+    }
+    async getHistory(id, opts) {
+      const params = new URLSearchParams();
+      if (opts?.limit != null) params.set("limit", String(opts.limit));
+      if (opts?.offset != null) params.set("offset", String(opts.offset));
+      if (opts?.status) params.set("status", opts.status);
+      const qs = params.toString();
+      return this.request(
+        `/${encodeURIComponent(id)}/history${qs ? `?${qs}` : ""}`
+      );
+    }
+    async getExecution(jobId, execId) {
+      return this.request(
+        `/${encodeURIComponent(jobId)}/history/${encodeURIComponent(execId)}`
+      );
+    }
+  };
+  // src/lib/processors/cli-jobs-command-processor.ts
+  function getServices(context, args) {
+    const manager = context.services.get("cli-server-manager");
+    if (!manager || !manager.connections) {
+      return [];
+    }
+    const targetServer = args["server"];
+    const results = [];
+    for (const [name, connection] of manager.connections) {
+      if (targetServer && name !== targetServer) continue;
+      if (!connection.connected) continue;
+      const config = connection.config;
+      const baseUrl = config.url.endsWith("/") ? config.url.slice(0, -1) : config.url;
+      const headers = config.headers ?? {};
+      results.push({ name, service: new CliJobsService(baseUrl, headers) });
+    }
+    return results;
+  }
+  async function resolveJobId(service, nameOrId) {
+    if (/^[0-9a-f-]{8,}$/i.test(nameOrId)) {
+      try {
+        return await service.getJob(nameOrId);
+      } catch {
+      }
+    }
+    const jobs = await service.listJobs();
+    const match = jobs.find(
+      (j) => j.name.toLowerCase() === nameOrId.toLowerCase() || j.id === nameOrId
+    );
+    return match ?? null;
+  }
+  function formatRelativeTime(isoString) {
+    if (!isoString) return "-";
+    const diff = Date.now() - new Date(isoString).getTime();
+    if (diff < 0) {
+      const absDiff = -diff;
+      if (absDiff < 6e4) return `in ${Math.round(absDiff / 1e3)}s`;
+      if (absDiff < 36e5) return `in ${Math.round(absDiff / 6e4)}m`;
+      if (absDiff < 864e5) return `in ${Math.round(absDiff / 36e5)}h`;
+      return `in ${Math.round(absDiff / 864e5)}d`;
+    }
+    if (diff < 6e4) return `${Math.round(diff / 1e3)}s ago`;
+    if (diff < 36e5) return `${Math.round(diff / 6e4)}m ago`;
+    if (diff < 864e5) return `${Math.round(diff / 36e5)}h ago`;
+    return `${Math.round(diff / 864e5)}d ago`;
+  }
+  function formatDuration(ms) {
+    if (ms == null) return "-";
+    if (ms < 1e3) return `${ms}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    return `${(ms / 6e4).toFixed(1)}m`;
+  }
+  function statusColor(status, writer) {
+    switch (status) {
+      case "active":
+      case "completed":
+      case "running":
+        return writer.wrapInColor(status, CliForegroundColor.Green);
+      case "paused":
+        return writer.wrapInColor(status, CliForegroundColor.Yellow);
+      case "stopped":
+      case "failed":
+      case "timed_out":
+      case "cancelled":
+        return writer.wrapInColor(status, CliForegroundColor.Red);
+      default:
+        return status;
+    }
+  }
+  function logLevelColor(level, writer) {
+    switch (level) {
+      case "debug":
+        return writer.wrapInColor(level, CliForegroundColor.Cyan);
+      case "info":
+        return writer.wrapInColor(level, CliForegroundColor.Green);
+      case "warning":
+        return writer.wrapInColor(level, CliForegroundColor.Yellow);
+      case "error":
+        return writer.wrapInColor(level, CliForegroundColor.Red);
+      default:
+        return level;
+    }
+  }
+  var serverParam = {
+    name: "server",
+    description: "Target a specific server by name",
+    required: false,
+    type: "string"
+  };
+  var CliJobsCommandProcessor = class {
+    constructor() {
+      this.command = "server";
+      this.extendsProcessor = true;
+      this.description = "Manage background jobs on connected servers";
+      this.author = DefaultLibraryAuthor;
+      this.metadata = {
+        icon: CliIcon.Gear,
+        module: "@qodalis/cli-server-jobs"
+      };
+      this.processors = [
+        {
+          command: "jobs",
+          description: "Manage background jobs on connected servers",
+          author: DefaultLibraryAuthor,
+          metadata: {
+            icon: CliIcon.Gear,
+            module: "@qodalis/cli-server-jobs"
+          },
+          parameters: [serverParam],
+          processors: [
+            // list
+            {
+              command: "list",
+              description: "List all jobs across connected servers",
+              aliases: ["ls"],
+              parameters: [
+                serverParam,
+                {
+                  name: "group",
+                  description: "Filter jobs by group",
+                  required: false,
+                  type: "string"
+                }
+              ],
+              processCommand: async (cmd, context) => {
+                await this.handleList(cmd, context);
+              }
+            },
+            // info
+            {
+              command: "info",
+              description: "Show detailed information about a job",
+              valueRequired: true,
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleInfo(cmd, context);
+              }
+            },
+            // trigger
+            {
+              command: "trigger",
+              description: "Trigger immediate execution of a job",
+              valueRequired: true,
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleAction(cmd, context, "trigger");
+              }
+            },
+            // pause
+            {
+              command: "pause",
+              description: "Pause scheduled execution of a job",
+              valueRequired: true,
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleAction(cmd, context, "pause");
+              }
+            },
+            // resume
+            {
+              command: "resume",
+              description: "Resume a paused job",
+              valueRequired: true,
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleAction(cmd, context, "resume");
+              }
+            },
+            // stop
+            {
+              command: "stop",
+              description: "Stop a job and cancel current execution if running",
+              valueRequired: true,
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleAction(cmd, context, "stop");
+              }
+            },
+            // cancel
+            {
+              command: "cancel",
+              description: "Cancel the current execution of a job",
+              valueRequired: true,
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleAction(cmd, context, "cancel");
+              }
+            },
+            // history
+            {
+              command: "history",
+              description: "Show execution history for a job",
+              valueRequired: true,
+              parameters: [
+                serverParam,
+                {
+                  name: "limit",
+                  description: "Number of entries to show (default 20)",
+                  required: false,
+                  type: "number",
+                  defaultValue: 20
+                },
+                {
+                  name: "offset",
+                  description: "Offset for pagination",
+                  required: false,
+                  type: "number",
+                  defaultValue: 0
+                },
+                {
+                  name: "status",
+                  description: "Filter by execution status",
+                  required: false,
+                  type: "string"
+                }
+              ],
+              processCommand: async (cmd, context) => {
+                await this.handleHistory(cmd, context);
+              }
+            },
+            // logs
+            {
+              command: "logs",
+              description: "Show logs from the latest or a specific execution",
+              valueRequired: true,
+              parameters: [
+                serverParam,
+                {
+                  name: "exec",
+                  description: "Specific execution ID to show logs for",
+                  required: false,
+                  type: "string"
+                }
+              ],
+              processCommand: async (cmd, context) => {
+                await this.handleLogs(cmd, context);
+              }
+            },
+            // edit
+            {
+              command: "edit",
+              description: "Interactively edit job settings",
+              valueRequired: true,
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleEdit(cmd, context);
+              }
+            },
+            // watch
+            {
+              command: "watch",
+              description: "Live view of job events via WebSocket",
+              parameters: [serverParam],
+              processCommand: async (cmd, context) => {
+                await this.handleWatch(cmd, context);
+              }
+            }
+          ],
+          processCommand: async (cmd, context) => {
+            await this.handleList(cmd, context);
+          }
+        }
+      ];
+    }
+    async processCommand(_cmd, _context) {
+    }
+    // ── List ──────────────────────────────────────────────────────────
+    async handleList(cmd, context) {
+      const services = getServices(context, cmd.args);
+      if (services.length === 0) {
+        context.writer.writeInfo(
+          'No connected servers. Use "server list" to check connections.'
+        );
+        return;
+      }
+      const groupFilter = cmd.args["group"];
+      const multiServer = services.length > 1;
+      for (const { name, service } of services) {
+        try {
+          let jobs = await service.listJobs();
+          if (groupFilter) {
+            jobs = jobs.filter(
+              (j) => j.group?.toLowerCase() === groupFilter.toLowerCase()
+            );
+          }
+          if (multiServer) {
+            context.writer.writeln(
+              context.writer.wrapInColor(
+                `Server: ${name}`,
+                CliForegroundColor.Cyan
+              )
+            );
+          }
+          if (jobs.length === 0) {
+            context.writer.writeInfo("  No jobs found.");
+            continue;
+          }
+          const headers = [
+            "Name",
+            "Group",
+            "Status",
+            "Schedule",
+            "Last Run",
+            "Next Run",
+            "Duration"
+          ];
+          const rows = jobs.map((j) => [
+            j.name,
+            j.group ?? "-",
+            statusColor(j.status, context.writer),
+            j.schedule ?? (j.interval ? `every ${j.interval}ms` : "-"),
+            formatRelativeTime(j.lastRunAt),
+            formatRelativeTime(j.nextRunAt),
+            formatDuration(j.lastRunDuration)
+          ]);
+          context.writer.writeTable(headers, rows);
+        } catch (e) {
+          context.writer.writeError(
+            `Failed to list jobs on ${name}: ${e.message}`
+          );
+        }
+      }
+    }
+    // ── Info ──────────────────────────────────────────────────────────
+    async handleInfo(cmd, context) {
+      const nameOrId = (cmd.value ?? "").trim();
+      if (!nameOrId) {
+        context.writer.writeError("Usage: jobs info <id|name>");
+        return;
+      }
+      const services = getServices(context, cmd.args);
+      if (services.length === 0) {
+        context.writer.writeInfo("No connected servers.");
+        return;
+      }
+      for (const { name, service } of services) {
+        try {
+          const job = await resolveJobId(service, nameOrId);
+          if (!job) {
+            if (services.length === 1) {
+              context.writer.writeError(
+                `Job "${nameOrId}" not found on server ${name}.`
+              );
+            }
+            continue;
+          }
+          if (services.length > 1) {
+            context.writer.writeln(
+              context.writer.wrapInColor(
+                `Server: ${name}`,
+                CliForegroundColor.Cyan
+              )
+            );
+          }
+          const lines = [
+            ["ID", job.id],
+            ["Name", job.name],
+            ["Description", job.description],
+            ["Group", job.group ?? "-"],
+            ["Status", statusColor(job.status, context.writer)],
+            [
+              "Schedule",
+              job.schedule ?? (job.interval ? `every ${job.interval}ms` : "-")
+            ],
+            ["Max Retries", String(job.maxRetries)],
+            [
+              "Timeout",
+              job.timeout ? `${job.timeout}ms` : "none"
+            ],
+            ["Overlap Policy", job.overlapPolicy],
+            [
+              "Current Execution",
+              job.currentExecutionId ?? "none"
+            ],
+            ["Next Run", formatRelativeTime(job.nextRunAt)],
+            ["Last Run", formatRelativeTime(job.lastRunAt)],
+            [
+              "Last Run Status",
+              job.lastRunStatus ? statusColor(job.lastRunStatus, context.writer) : "-"
+            ],
+            ["Last Run Duration", formatDuration(job.lastRunDuration)]
+          ];
+          for (const [label, value] of lines) {
+            context.writer.writeln(
+              `  ${context.writer.wrapInColor(
+                label.padEnd(20),
+                CliForegroundColor.Yellow
+              )} ${value}`
+            );
+          }
+          return;
+        } catch (e) {
+          context.writer.writeError(
+            `Error on server ${name}: ${e.message}`
+          );
+        }
+      }
+    }
+    // ── Action (trigger/pause/resume/stop/cancel) ────────────────────
+    async handleAction(cmd, context, action) {
+      const nameOrId = (cmd.value ?? "").trim();
+      if (!nameOrId) {
+        context.writer.writeError(`Usage: jobs ${action} <id|name>`);
+        return;
+      }
+      const services = getServices(context, cmd.args);
+      if (services.length === 0) {
+        context.writer.writeInfo("No connected servers.");
+        return;
+      }
+      for (const { name, service } of services) {
+        try {
+          const job = await resolveJobId(service, nameOrId);
+          if (!job) {
+            if (services.length === 1) {
+              context.writer.writeError(
+                `Job "${nameOrId}" not found on server ${name}.`
+              );
+            }
+            continue;
+          }
+          switch (action) {
+            case "trigger":
+              await service.triggerJob(job.id);
+              break;
+            case "pause":
+              await service.pauseJob(job.id);
+              break;
+            case "resume":
+              await service.resumeJob(job.id);
+              break;
+            case "stop":
+              await service.stopJob(job.id);
+              break;
+            case "cancel":
+              await service.cancelJob(job.id);
+              break;
+          }
+          const serverSuffix = services.length > 1 ? ` on server ${name}` : "";
+          context.writer.writeSuccess(
+            `Job "${job.name}" ${action}${action.endsWith("e") ? "d" : "ed"}${serverSuffix}.`
+          );
+          return;
+        } catch (e) {
+          context.writer.writeError(
+            `Failed to ${action} job on ${name}: ${e.message}`
+          );
+        }
+      }
+    }
+    // ── History ──────────────────────────────────────────────────────
+    async handleHistory(cmd, context) {
+      const nameOrId = (cmd.value ?? "").trim();
+      if (!nameOrId) {
+        context.writer.writeError("Usage: jobs history <id|name>");
+        return;
+      }
+      const services = getServices(context, cmd.args);
+      if (services.length === 0) {
+        context.writer.writeInfo("No connected servers.");
+        return;
+      }
+      const limit = cmd.args["limit"] ?? 20;
+      const offset = cmd.args["offset"] ?? 0;
+      const status = cmd.args["status"];
+      for (const { name, service } of services) {
+        try {
+          const job = await resolveJobId(service, nameOrId);
+          if (!job) {
+            if (services.length === 1) {
+              context.writer.writeError(
+                `Job "${nameOrId}" not found on server ${name}.`
+              );
+            }
+            continue;
+          }
+          if (services.length > 1) {
+            context.writer.writeln(
+              context.writer.wrapInColor(
+                `Server: ${name}`,
+                CliForegroundColor.Cyan
+              )
+            );
+          }
+          const history = await service.getHistory(job.id, {
+            limit,
+            offset,
+            status
+          });
+          if (history.items.length === 0) {
+            context.writer.writeInfo(
+              `No execution history for "${job.name}".`
+            );
+            return;
+          }
+          context.writer.writeln(
+            `Showing ${history.items.length} of ${history.total} executions for "${job.name}":`
+          );
+          const headers = [
+            "ID",
+            "Status",
+            "Started",
+            "Duration",
+            "Retry",
+            "Error"
+          ];
+          const rows = history.items.map((exec) => [
+            exec.id.substring(0, 8),
+            statusColor(exec.status, context.writer),
+            formatRelativeTime(exec.startedAt),
+            formatDuration(exec.duration),
+            String(exec.retryAttempt),
+            exec.error ? exec.error.substring(0, 40) : "-"
+          ]);
+          context.writer.writeTable(headers, rows);
+          return;
+        } catch (e) {
+          context.writer.writeError(
+            `Error on server ${name}: ${e.message}`
+          );
+        }
+      }
+    }
+    // ── Logs ─────────────────────────────────────────────────────────
+    async handleLogs(cmd, context) {
+      const nameOrId = (cmd.value ?? "").trim();
+      if (!nameOrId) {
+        context.writer.writeError("Usage: jobs logs <id|name>");
+        return;
+      }
+      const services = getServices(context, cmd.args);
+      if (services.length === 0) {
+        context.writer.writeInfo("No connected servers.");
+        return;
+      }
+      const execId = cmd.args["exec"];
+      for (const { name, service } of services) {
+        try {
+          const job = await resolveJobId(service, nameOrId);
+          if (!job) {
+            if (services.length === 1) {
+              context.writer.writeError(
+                `Job "${nameOrId}" not found on server ${name}.`
+              );
+            }
+            continue;
+          }
+          let execution;
+          if (execId) {
+            execution = await service.getExecution(job.id, execId);
+          } else {
+            const history = await service.getHistory(job.id, {
+              limit: 1
+            });
+            if (history.items.length === 0) {
+              context.writer.writeInfo(
+                `No executions found for "${job.name}".`
+              );
+              return;
+            }
+            execution = await service.getExecution(
+              job.id,
+              history.items[0].id
+            );
+          }
+          if (services.length > 1) {
+            context.writer.writeln(
+              context.writer.wrapInColor(
+                `Server: ${name}`,
+                CliForegroundColor.Cyan
+              )
+            );
+          }
+          context.writer.writeln(
+            `Logs for "${job.name}" execution ${execution.id.substring(0, 8)} (${statusColor(execution.status, context.writer)}):`
+          );
+          if (!execution.logs || execution.logs.length === 0) {
+            context.writer.writeInfo("  No log entries.");
+            return;
+          }
+          for (const entry of execution.logs) {
+            const ts = new Date(entry.timestamp).toLocaleTimeString();
+            const level = logLevelColor(
+              entry.level,
+              context.writer
+            ).padEnd(12);
+            context.writer.writeln(
+              `  ${context.writer.wrapInColor(ts, CliForegroundColor.White)} ${level} ${entry.message}`
+            );
+          }
+          return;
+        } catch (e) {
+          context.writer.writeError(
+            `Error on server ${name}: ${e.message}`
+          );
+        }
+      }
+    }
+    // ── Edit ─────────────────────────────────────────────────────────
+    async handleEdit(cmd, context) {
+      const nameOrId = (cmd.value ?? "").trim();
+      if (!nameOrId) {
+        context.writer.writeError("Usage: jobs edit <id|name>");
+        return;
+      }
+      const services = getServices(context, cmd.args);
+      if (services.length === 0) {
+        context.writer.writeInfo("No connected servers.");
+        return;
+      }
+      for (const { name, service } of services) {
+        try {
+          const job = await resolveJobId(service, nameOrId);
+          if (!job) {
+            if (services.length === 1) {
+              context.writer.writeError(
+                `Job "${nameOrId}" not found on server ${name}.`
+              );
+            }
+            continue;
+          }
+          context.writer.writeln(
+            `Editing job "${context.writer.wrapInColor(job.name, CliForegroundColor.Cyan)}" on server ${name}`
+          );
+          context.writer.writeln(
+            "Press Enter to keep current value, or type a new value."
+          );
+          context.writer.writeln("");
+          const update = {};
+          const newDesc = await context.reader.readLine(
+            `Description [${job.description}]: `
+          );
+          if (newDesc == null) {
+            context.writer.writeInfo("Edit cancelled.");
+            return;
+          }
+          if (newDesc.trim()) {
+            update.description = newDesc.trim();
+          }
+          const newGroup = await context.reader.readLine(
+            `Group [${job.group ?? "none"}]: `
+          );
+          if (newGroup == null) {
+            context.writer.writeInfo("Edit cancelled.");
+            return;
+          }
+          if (newGroup.trim()) {
+            update.group = newGroup.trim();
+          }
+          const currentSchedule = job.schedule ?? (job.interval ? `interval: ${job.interval}ms` : "none");
+          const newSchedule = await context.reader.readLine(
+            `Cron schedule [${currentSchedule}]: `
+          );
+          if (newSchedule == null) {
+            context.writer.writeInfo("Edit cancelled.");
+            return;
+          }
+          if (newSchedule.trim()) {
+            update.schedule = newSchedule.trim();
+          }
+          if (!newSchedule.trim()) {
+            const newInterval = await context.reader.readLine(
+              `Interval (e.g. 30s, 5m) [${job.interval ? `${job.interval}ms` : "none"}]: `
+            );
+            if (newInterval != null && newInterval.trim()) {
+              update.interval = newInterval.trim();
+            }
+          }
+          const newRetries = await context.reader.readLine(
+            `Max retries [${job.maxRetries}]: `
+          );
+          if (newRetries != null && newRetries.trim()) {
+            const parsed = parseInt(newRetries.trim(), 10);
+            if (!isNaN(parsed)) {
+              update.maxRetries = parsed;
+            }
+          }
+          const newTimeout = await context.reader.readLine(
+            `Timeout (e.g. 5m, 1h) [${job.timeout ? `${job.timeout}ms` : "none"}]: `
+          );
+          if (newTimeout != null && newTimeout.trim()) {
+            update.timeout = newTimeout.trim();
+          }
+          const newOverlap = await context.reader.readLine(
+            `Overlap policy (skip/queue/cancel) [${job.overlapPolicy}]: `
+          );
+          if (newOverlap != null && newOverlap.trim() && ["skip", "queue", "cancel"].includes(
+            newOverlap.trim().toLowerCase()
+          )) {
+            update.overlapPolicy = newOverlap.trim().toLowerCase();
+          }
+          if (Object.keys(update).length === 0) {
+            context.writer.writeInfo("No changes made.");
+            return;
+          }
+          const confirm = await context.reader.readConfirm(
+            "Apply changes?"
+          );
+          if (!confirm) {
+            context.writer.writeInfo("Edit cancelled.");
+            return;
+          }
+          await service.updateJob(job.id, update);
+          context.writer.writeSuccess(
+            `Job "${job.name}" updated successfully.`
+          );
+          return;
+        } catch (e) {
+          context.writer.writeError(
+            `Error on server ${name}: ${e.message}`
+          );
+        }
+      }
+    }
+    // ── Watch ────────────────────────────────────────────────────────
+    async handleWatch(cmd, context) {
+      const manager = context.services.get("cli-server-manager");
+      if (!manager || !manager.connections) {
+        context.writer.writeInfo("No connected servers.");
+        return;
+      }
+      const targetServer = cmd.args["server"];
+      context.writer.writeln(
+        context.writer.wrapInColor(
+          "Watching job events... (press Ctrl+C to stop)",
+          CliForegroundColor.Cyan
+        )
+      );
+      context.writer.writeln("");
+      const sockets = [];
+      const abortHandler = () => {
+        for (const ws of sockets) {
+          try {
+            ws.close();
+          } catch {
+          }
+        }
+      };
+      context.onAbort.subscribe(abortHandler);
+      for (const [serverName, connection] of manager.connections) {
+        if (targetServer && serverName !== targetServer) continue;
+        if (!connection.connected) continue;
+        const config = connection.config;
+        const baseUrl = config.url.endsWith("/") ? config.url.slice(0, -1) : config.url;
+        const wsUrl = baseUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:") + "/ws/v1/qcli/events";
+        try {
+          const ws = new WebSocket(wsUrl);
+          sockets.push(ws);
+          ws.onmessage = (event) => {
+            try {
+              const data = JSON.parse(event.data);
+              if (!data.type || !data.type.startsWith("job:")) {
+                return;
+              }
+              const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+              const serverPrefix = manager.connections.size > 1 ? context.writer.wrapInColor(
+                `[${serverName}] `,
+                CliForegroundColor.Cyan
+              ) : "";
+              let detail = "";
+              if (data.jobId) {
+                detail += ` jobId=${data.jobId}`;
+              }
+              if (data.executionId) {
+                detail += ` execId=${data.executionId.substring(0, 8)}`;
+              }
+              if (data.duration != null) {
+                detail += ` duration=${formatDuration(data.duration)}`;
+              }
+              if (data.error) {
+                detail += ` error="${data.error}"`;
+              }
+              const eventType = statusColor(
+                data.type.replace("job:", ""),
+                context.writer
+              );
+              context.writer.writeln(
+                `${context.writer.wrapInColor(ts, CliForegroundColor.White)} ${serverPrefix}${eventType}${detail}`
+              );
+            } catch {
+            }
+          };
+          ws.onerror = () => {
+            context.writer.writeError(
+              `WebSocket error on server ${serverName}`
+            );
+          };
+          ws.onclose = () => {
+          };
+        } catch (e) {
+          context.writer.writeError(
+            `Failed to connect to ${serverName}: ${e.message}`
+          );
+        }
+      }
+      await new Promise((resolve) => {
+        const sub = context.onAbort.subscribe(() => {
+          sub.unsubscribe();
+          resolve();
+        });
+        if (context.signal) {
+          context.signal.addEventListener("abort", () => {
+            sub.unsubscribe();
+            resolve();
+          });
+        }
+      });
+      context.writer.writeln("");
+      context.writer.writeInfo("Stopped watching job events.");
+    }
+  };
+  // src/lib/completion/cli-job-name-completion-provider.ts
+  var JOB_NAME_SUBCOMMANDS = /* @__PURE__ */ new Set([
+    "info",
+    "trigger",
+    "pause",
+    "resume",
+    "stop",
+    "cancel",
+    "history",
+    "logs",
+    "edit"
+  ]);
+  var CliJobNameCompletionProvider = class {
+    constructor() {
+      this.priority = 50;
+      this.services = null;
+    }
+    setServices(services) {
+      this.services = services;
+    }
+    async getCompletions(context) {
+      const { tokens, tokenIndex, token } = context;
+      if (tokenIndex !== 3 || tokens.length < 3) {
+        return [];
+      }
+      if (tokens[0].toLowerCase() !== "server") {
+        return [];
+      }
+      if (tokens[1].toLowerCase() !== "jobs") {
+        return [];
+      }
+      const subCommand = tokens[2].toLowerCase();
+      if (!JOB_NAME_SUBCOMMANDS.has(subCommand)) {
+        return [];
+      }
+      if (!this.services) {
+        return [];
+      }
+      const lowerPrefix = token.toLowerCase();
+      try {
+        const manager = this.services.get("cli-server-manager");
+        if (!manager?.connections) {
+          return [];
+        }
+        const names = [];
+        for (const [, connection] of manager.connections) {
+          if (!connection.connected) continue;
+          const config = connection.config;
+          const baseUrl = config.url.endsWith("/") ? config.url.slice(0, -1) : config.url;
+          const headers = config.headers ?? {};
+          const service = new CliJobsService(baseUrl, headers);
+          try {
+            const jobs = await service.listJobs();
+            for (const job of jobs) {
+              if (!names.includes(job.name)) {
+                names.push(job.name);
+              }
+            }
+          } catch {
+          }
+        }
+        return names.filter((name) => name.toLowerCase().startsWith(lowerPrefix)).sort();
+      } catch {
+        return [];
+      }
+    }
+  };
+  // src/lib/version.ts
+  var API_VERSION = 2;
+  // src/cli-entrypoint.ts
+  var completionProvider = new CliJobNameCompletionProvider();
+  var module = {
+    apiVersion: API_VERSION,
+    name: "@qodalis/cli-server-jobs",
+    processors: [new CliJobsCommandProcessor()],
+    services: [
+      {
+        provide: ICliCompletionProvider_TOKEN,
+        useValue: completionProvider,
+        multi: true
+      }
+    ],
+    async onInit(context) {
+      completionProvider.setServices(context.services);
+    }
+  };
+  bootCliModule(module);
+})();