securewithtrace 0.18.1 → 0.19.0

package/dist/index.js

@@ -1079,35 +1079,35 @@ var require_suggestSimilar = __commonJS({
     function editDistance(a, b) {
       if (Math.abs(a.length - b.length) > maxDistance)
         return Math.max(a.length, b.length);
-      const d = [];
+      const d3 = [];
       for (let i = 0; i <= a.length; i++) {
-        d[i] = [i];
+        d3[i] = [i];
       }
-      for (let j = 0; j <= b.length; j++) {
-        d[0][j] = j;
+      for (let j2 = 0; j2 <= b.length; j2++) {
+        d3[0][j2] = j2;
       }
-      for (let j = 1; j <= b.length; j++) {
+      for (let j2 = 1; j2 <= b.length; j2++) {
         for (let i = 1; i <= a.length; i++) {
           let cost = 1;
-          if (a[i - 1] === b[j - 1]) {
+          if (a[i - 1] === b[j2 - 1]) {
             cost = 0;
           } else {
             cost = 1;
           }
-          d[i][j] = Math.min(
-            d[i - 1][j] + 1,
+          d3[i][j2] = Math.min(
+            d3[i - 1][j2] + 1,
             // deletion
-            d[i][j - 1] + 1,
+            d3[i][j2 - 1] + 1,
             // insertion
-            d[i - 1][j - 1] + cost
+            d3[i - 1][j2 - 1] + cost
             // substitution
           );
-          if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-            d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+          if (i > 1 && j2 > 1 && a[i - 1] === b[j2 - 2] && a[i - 2] === b[j2 - 1]) {
+            d3[i][j2] = Math.min(d3[i][j2], d3[i - 2][j2 - 2] + 1);
           }
         }
       }
-      return d[a.length][b.length];
+      return d3[a.length][b.length];
     }
     function suggestSimilar(word, candidates) {
       if (!candidates || candidates.length === 0) return "";
@@ -1160,7 +1160,7 @@ var require_command = __commonJS({
     var childProcess = __require("child_process");
     var path = __require("path");
     var fs = __require("fs");
-    var process3 = __require("process");
+    var process4 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
     var { Help: Help2, stripColor } = require_help();
@@ -1207,13 +1207,13 @@ var require_command = __commonJS({
         this._showSuggestionAfterError = true;
         this._savedState = null;
         this._outputConfiguration = {
-          writeOut: (str) => process3.stdout.write(str),
-          writeErr: (str) => process3.stderr.write(str),
+          writeOut: (str) => process4.stdout.write(str),
+          writeErr: (str) => process4.stderr.write(str),
           outputError: (str, write) => write(str),
-          getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : void 0,
-          getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : void 0,
-          getOutHasColors: () => useColor() ?? (process3.stdout.isTTY && process3.stdout.hasColors?.()),
-          getErrHasColors: () => useColor() ?? (process3.stderr.isTTY && process3.stderr.hasColors?.()),
+          getOutHelpWidth: () => process4.stdout.isTTY ? process4.stdout.columns : void 0,
+          getErrHelpWidth: () => process4.stderr.isTTY ? process4.stderr.columns : void 0,
+          getOutHasColors: () => useColor() ?? (process4.stdout.isTTY && process4.stdout.hasColors?.()),
+          getErrHasColors: () => useColor() ?? (process4.stderr.isTTY && process4.stderr.hasColors?.()),
           stripColor: (str) => stripColor(str)
         };
         this._hidden = false;
@@ -1596,7 +1596,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._exitCallback) {
           this._exitCallback(new CommanderError2(exitCode, code, message));
         }
-        process3.exit(exitCode);
+        process4.exit(exitCode);
       }
       /**
        * Register callback `fn` for the command.
@@ -1994,16 +1994,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         parseOptions = parseOptions || {};
         if (argv === void 0 && parseOptions.from === void 0) {
-          if (process3.versions?.electron) {
+          if (process4.versions?.electron) {
             parseOptions.from = "electron";
           }
-          const execArgv = process3.execArgv ?? [];
+          const execArgv = process4.execArgv ?? [];
           if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
             parseOptions.from = "eval";
           }
         }
         if (argv === void 0) {
-          argv = process3.argv;
+          argv = process4.argv;
         }
         this.rawArgs = argv.slice();
         let userArgs;
@@ -2014,7 +2014,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             userArgs = argv.slice(2);
             break;
           case "electron":
-            if (process3.defaultApp) {
+            if (process4.defaultApp) {
               this._scriptPath = argv[1];
               userArgs = argv.slice(2);
             } else {
@@ -2201,11 +2201,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         launchWithNode = sourceExt.includes(path.extname(executableFile));
         let proc;
-        if (process3.platform !== "win32") {
+        if (process4.platform !== "win32") {
           if (launchWithNode) {
             args.unshift(executableFile);
-            args = incrementNodeInspectorPort(process3.execArgv).concat(args);
-            proc = childProcess.spawn(process3.argv[0], args, { stdio: "inherit" });
+            args = incrementNodeInspectorPort(process4.execArgv).concat(args);
+            proc = childProcess.spawn(process4.argv[0], args, { stdio: "inherit" });
           } else {
             proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
           }
@@ -2216,13 +2216,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
             subcommand._name
           );
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process3.execArgv).concat(args);
-          proc = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process4.execArgv).concat(args);
+          proc = childProcess.spawn(process4.execPath, args, { stdio: "inherit" });
         }
         if (!proc.killed) {
           const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
           signals.forEach((signal) => {
-            process3.on(signal, () => {
+            process4.on(signal, () => {
               if (proc.killed === false && proc.exitCode === null) {
                 proc.kill(signal);
               }
@@ -2233,7 +2233,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         proc.on("close", (code) => {
           code = code ?? 1;
           if (!exitCallback) {
-            process3.exit(code);
+            process4.exit(code);
           } else {
             exitCallback(
               new CommanderError2(
@@ -2255,7 +2255,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             throw new Error(`'${executableFile}' not executable`);
           }
           if (!exitCallback) {
-            process3.exit(1);
+            process4.exit(1);
           } else {
             const wrappedError = new CommanderError2(
               1,
@@ -2750,13 +2750,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       _parseOptionsEnv() {
         this.options.forEach((option) => {
-          if (option.envVar && option.envVar in process3.env) {
+          if (option.envVar && option.envVar in process4.env) {
             const optionKey = option.attributeName();
             if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(
               this.getOptionValueSource(optionKey)
             )) {
               if (option.required || option.optional) {
-                this.emit(`optionEnv:${option.name()}`, process3.env[option.envVar]);
+                this.emit(`optionEnv:${option.name()}`, process4.env[option.envVar]);
               } else {
                 this.emit(`optionEnv:${option.name()}`);
               }
@@ -3211,7 +3211,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       help(contextOptions) {
         this.outputHelp(contextOptions);
-        let exitCode = Number(process3.exitCode ?? 0);
+        let exitCode = Number(process4.exitCode ?? 0);
         if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
           exitCode = 1;
         }
@@ -3301,9 +3301,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
     }
     function useColor() {
-      if (process3.env.NO_COLOR || process3.env.FORCE_COLOR === "0" || process3.env.FORCE_COLOR === "false")
+      if (process4.env.NO_COLOR || process4.env.FORCE_COLOR === "0" || process4.env.FORCE_COLOR === "false")
         return false;
-      if (process3.env.FORCE_COLOR || process3.env.CLICOLOR_FORCE !== void 0)
+      if (process4.env.FORCE_COLOR || process4.env.CLICOLOR_FORCE !== void 0)
         return true;
       return void 0;
     }
@@ -3335,6 +3335,62 @@ var require_commander = __commonJS({
   }
 });
 
+// ../../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x, y2) {
+        if (!y2) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y2 + 1};${x + 1}H`;
+      },
+      move(x, y2) {
+        let ret = "";
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
+        if (y2 < 0) ret += `${CSI2}${-y2}A`;
+        else if (y2 > 0) ret += `${CSI2}${y2}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i = 0; i < count; i++)
+          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        if (count)
+          clear += cursor.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor, scroll, erase, beep };
+  }
+});
+
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
@@ -3353,7 +3409,725 @@ var {
 } = import_index.default;
 
 // src/auth/commands.ts
-import { createInterface } from "readline/promises";
+import { createInterface as createInterface2 } from "readline/promises";
+
+// ../../node_modules/.bun/@clack+core@1.2.0/node_modules/@clack/core/dist/index.mjs
+import { styleText as y } from "util";
+import { stdout as S, stdin as $ } from "process";
+import * as _ from "readline";
+import P from "readline";
+
+// ../../node_modules/.bun/fast-string-truncated-width@1.2.1/node_modules/fast-string-truncated-width/dist/utils.js
+var isAmbiguous = (x) => {
+  return x === 161 || x === 164 || x === 167 || x === 168 || x === 170 || x === 173 || x === 174 || x >= 176 && x <= 180 || x >= 182 && x <= 186 || x >= 188 && x <= 191 || x === 198 || x === 208 || x === 215 || x === 216 || x >= 222 && x <= 225 || x === 230 || x >= 232 && x <= 234 || x === 236 || x === 237 || x === 240 || x === 242 || x === 243 || x >= 247 && x <= 250 || x === 252 || x === 254 || x === 257 || x === 273 || x === 275 || x === 283 || x === 294 || x === 295 || x === 299 || x >= 305 && x <= 307 || x === 312 || x >= 319 && x <= 322 || x === 324 || x >= 328 && x <= 331 || x === 333 || x === 338 || x === 339 || x === 358 || x === 359 || x === 363 || x === 462 || x === 464 || x === 466 || x === 468 || x === 470 || x === 472 || x === 474 || x === 476 || x === 593 || x === 609 || x === 708 || x === 711 || x >= 713 && x <= 715 || x === 717 || x === 720 || x >= 728 && x <= 731 || x === 733 || x === 735 || x >= 768 && x <= 879 || x >= 913 && x <= 929 || x >= 931 && x <= 937 || x >= 945 && x <= 961 || x >= 963 && x <= 969 || x === 1025 || x >= 1040 && x <= 1103 || x === 1105 || x === 8208 || x >= 8211 && x <= 8214 || x === 8216 || x === 8217 || x === 8220 || x === 8221 || x >= 8224 && x <= 8226 || x >= 8228 && x <= 8231 || x === 8240 || x === 8242 || x === 8243 || x === 8245 || x === 8251 || x === 8254 || x === 8308 || x === 8319 || x >= 8321 && x <= 8324 || x === 8364 || x === 8451 || x === 8453 || x === 8457 || x === 8467 || x === 8470 || x === 8481 || x === 8482 || x === 8486 || x === 8491 || x === 8531 || x === 8532 || x >= 8539 && x <= 8542 || x >= 8544 && x <= 8555 || x >= 8560 && x <= 8569 || x === 8585 || x >= 8592 && x <= 8601 || x === 8632 || x === 8633 || x === 8658 || x === 8660 || x === 8679 || x === 8704 || x === 8706 || x === 8707 || x === 8711 || x === 8712 || x === 8715 || x === 8719 || x === 8721 || x === 8725 || x === 8730 || x >= 8733 && x <= 8736 || x === 8739 || x === 8741 || x >= 8743 && x <= 8748 || x === 8750 || x >= 8756 && x <= 8759 || x === 8764 || x === 8765 || x === 8776 || x === 8780 || x === 8786 || x === 8800 || x === 8801 || x >= 8804 && x <= 8807 || x === 8810 || x === 8811 || x === 8814 || x === 8815 || x === 8834 || x === 8835 || x === 8838 || x === 8839 || x === 8853 || x === 8857 || x === 8869 || x === 8895 || x === 8978 || x >= 9312 && x <= 9449 || x >= 9451 && x <= 9547 || x >= 9552 && x <= 9587 || x >= 9600 && x <= 9615 || x >= 9618 && x <= 9621 || x === 9632 || x === 9633 || x >= 9635 && x <= 9641 || x === 9650 || x === 9651 || x === 9654 || x === 9655 || x === 9660 || x === 9661 || x === 9664 || x === 9665 || x >= 9670 && x <= 9672 || x === 9675 || x >= 9678 && x <= 9681 || x >= 9698 && x <= 9701 || x === 9711 || x === 9733 || x === 9734 || x === 9737 || x === 9742 || x === 9743 || x === 9756 || x === 9758 || x === 9792 || x === 9794 || x === 9824 || x === 9825 || x >= 9827 && x <= 9829 || x >= 9831 && x <= 9834 || x === 9836 || x === 9837 || x === 9839 || x === 9886 || x === 9887 || x === 9919 || x >= 9926 && x <= 9933 || x >= 9935 && x <= 9939 || x >= 9941 && x <= 9953 || x === 9955 || x === 9960 || x === 9961 || x >= 9963 && x <= 9969 || x === 9972 || x >= 9974 && x <= 9977 || x === 9979 || x === 9980 || x === 9982 || x === 9983 || x === 10045 || x >= 10102 && x <= 10111 || x >= 11094 && x <= 11097 || x >= 12872 && x <= 12879 || x >= 57344 && x <= 63743 || x >= 65024 && x <= 65039 || x === 65533 || x >= 127232 && x <= 127242 || x >= 127248 && x <= 127277 || x >= 127280 && x <= 127337 || x >= 127344 && x <= 127373 || x === 127375 || x === 127376 || x >= 127387 && x <= 127404 || x >= 917760 && x <= 917999 || x >= 983040 && x <= 1048573 || x >= 1048576 && x <= 1114109;
+};
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWide = (x) => {
+  return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9800 && x <= 9811 || x === 9855 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 19968 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101632 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129672 || x >= 129680 && x <= 129725 || x >= 129727 && x <= 129733 || x >= 129742 && x <= 129755 || x >= 129760 && x <= 129768 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../node_modules/.bun/fast-string-truncated-width@1.2.1/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = widthOptions.ansiWidth ?? 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const AMBIGUOUS_WIDTH = widthOptions.ambiguousWidth ?? 1;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = widthOptions.fullWidthWidth ?? 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? 2;
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWide(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else if (AMBIGUOUS_WIDTH !== REGULAR_WIDTH && isAmbiguous(codePoint)) {
+          widthExtra = AMBIGUOUS_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length)
+      break;
+    LATIN_RE.lastIndex = index;
+    if (LATIN_RE.test(input)) {
+      lengthExtra = LATIN_RE.lastIndex - index;
+      widthExtra = lengthExtra * REGULAR_WIDTH;
+      if (width + widthExtra > truncationLimit) {
+        truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / REGULAR_WIDTH));
+      }
+      if (width + widthExtra > LIMIT) {
+        truncationEnabled = true;
+        break;
+      }
+      width += widthExtra;
+      unmatchedStart = indexPrev;
+      unmatchedEnd = index;
+      index = indexPrev = LATIN_RE.lastIndex;
+      continue;
+    }
+    ANSI_RE.lastIndex = index;
+    if (ANSI_RE.test(input)) {
+      if (width + ANSI_WIDTH > truncationLimit) {
+        truncationIndex = Math.min(truncationIndex, index);
+      }
+      if (width + ANSI_WIDTH > LIMIT) {
+        truncationEnabled = true;
+        break;
+      }
+      width += ANSI_WIDTH;
+      unmatchedStart = indexPrev;
+      unmatchedEnd = index;
+      index = indexPrev = ANSI_RE.lastIndex;
+      continue;
+    }
+    CONTROL_RE.lastIndex = index;
+    if (CONTROL_RE.test(input)) {
+      lengthExtra = CONTROL_RE.lastIndex - index;
+      widthExtra = lengthExtra * CONTROL_WIDTH;
+      if (width + widthExtra > truncationLimit) {
+        truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / CONTROL_WIDTH));
+      }
+      if (width + widthExtra > LIMIT) {
+        truncationEnabled = true;
+        break;
+      }
+      width += widthExtra;
+      unmatchedStart = indexPrev;
+      unmatchedEnd = index;
+      index = indexPrev = CONTROL_RE.lastIndex;
+      continue;
+    }
+    TAB_RE.lastIndex = index;
+    if (TAB_RE.test(input)) {
+      lengthExtra = TAB_RE.lastIndex - index;
+      widthExtra = lengthExtra * TAB_WIDTH;
+      if (width + widthExtra > truncationLimit) {
+        truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / TAB_WIDTH));
+      }
+      if (width + widthExtra > LIMIT) {
+        truncationEnabled = true;
+        break;
+      }
+      width += widthExtra;
+      unmatchedStart = indexPrev;
+      unmatchedEnd = index;
+      index = indexPrev = TAB_RE.lastIndex;
+      continue;
+    }
+    EMOJI_RE.lastIndex = index;
+    if (EMOJI_RE.test(input)) {
+      if (width + EMOJI_WIDTH > truncationLimit) {
+        truncationIndex = Math.min(truncationIndex, index);
+      }
+      if (width + EMOJI_WIDTH > LIMIT) {
+        truncationEnabled = true;
+        break;
+      }
+      width += EMOJI_WIDTH;
+      unmatchedStart = indexPrev;
+      unmatchedEnd = index;
+      index = indexPrev = EMOJI_RE.lastIndex;
+      continue;
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/.bun/fast-string-width@1.1.0/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../../node_modules/.bun/fast-wrap-ansi@0.1.6/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url2) => `${ESC}${ANSI_ESCAPE_LINK}${url2}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === void 0 ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string4) => {
+  const words = string4.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string4;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string4, columns, options = {}) => {
+  if (options.trim !== false && string4.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string4.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i = 0; i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+    } else {
+      continue;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string4, columns, options) {
+  return String(string4).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// ../../node_modules/.bun/@clack+core@1.2.0/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream as D } from "tty";
+function d(r, t2, e) {
+  if (!e.some((o) => !o.disabled)) return r;
+  const s = r + t2, i = Math.max(e.length - 1, 0), n = s < 0 ? i : s > i ? 0 : s;
+  return e[n].disabled ? d(n, t2 < 0 ? -1 : 1, e) : n;
+}
+var E = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var G = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var u = { actions: new Set(E), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...G], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t2) => `There are only ${r} days in ${t2}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
+function V(r, t2) {
+  if (typeof r == "string") return u.aliases.get(r) === t2;
+  for (const e of r) if (e !== void 0 && V(e, t2)) return true;
+  return false;
+}
+function j(r, t2) {
+  if (r === t2) return;
+  const e = r.split(`
+`), s = t2.split(`
+`), i = Math.max(e.length, s.length), n = [];
+  for (let o = 0; o < i; o++) e[o] !== s[o] && n.push(o);
+  return { lines: n, numLinesBefore: e.length, numLinesAfter: s.length, numLines: i };
+}
+var Y = globalThis.process.platform.startsWith("win");
+var C = /* @__PURE__ */ Symbol("clack:cancel");
+function q(r) {
+  return r === C;
+}
+function w(r, t2) {
+  const e = r;
+  e.isTTY && e.setRawMode(t2);
+}
+var O = (r) => "columns" in r && typeof r.columns == "number" ? r.columns : 80;
+var A = (r) => "rows" in r && typeof r.rows == "number" ? r.rows : 20;
+function R(r, t2, e, s = e) {
+  const i = O(r ?? S);
+  return wrapAnsi(t2, i - e.length, { hard: true, trim: false }).split(`
+`).map((n, o) => `${o === 0 ? s : e}${n}`).join(`
+`);
+}
+var p = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: s = $, output: i = S, render: n, signal: o, ...a } = t2;
+    this.opts = a, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = n.bind(this), this._track = e, this._abortSignal = o, this.input = s, this.output = i;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t2, e) {
+    const s = this._subscribers.get(t2) ?? [];
+    s.push(e), this._subscribers.set(t2, s);
+  }
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  emit(t2, ...e) {
+    const s = this._subscribers.get(t2) ?? [], i = [];
+    for (const n of s) n.cb(...e), n.once && i.push(() => s.splice(s.indexOf(n), 1));
+    for (const n of i) n();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted) return this.state = "cancel", this.close(), t2(C);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = P.createInterface({ input: this.input, tabSize: 2, prompt: "", escapeCodeTimeout: 50, terminal: true }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), w(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t2(C);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "	";
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && u.aliases.has(e.name) && this.emit("cursor", u.aliases.get(e.name)), u.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2?.toLowerCase(), e), e?.name === "return") {
+      if (this.opts.validate) {
+        const s = this.opts.validate(this.value);
+        s && (this.error = s instanceof Error ? s.message : s, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    V([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), w(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, { hard: true, trim: false });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial") this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = j(this._prevFrame, t2), s = A(this.output);
+        if (this.restoreCursor(), e) {
+          const i = Math.max(0, e.numLinesAfter - s), n = Math.max(0, e.numLinesBefore - s);
+          let o = e.lines.find((a) => a >= i);
+          if (o === void 0) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, o - n)), this.output.write(import_sisteransi.erase.lines(1));
+            const a = t2.split(`
+`);
+            this.output.write(a[o]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, a.length - o - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (i < n) o = i;
+            else {
+              const h = o - n;
+              h > 0 && this.output.write(import_sisteransi.cursor.move(0, h));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const a = t2.split(`
+`).slice(o);
+            this.output.write(a.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+};
+var nt = class extends p {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._selectedValue.value;
+  }
+  constructor(t2) {
+    super(t2, false), this.options = t2.options;
+    const e = this.options.findIndex(({ value: i }) => i === t2.initialValue), s = e === -1 ? 0 : e;
+    this.cursor = this.options[s].disabled ? d(s, 1, this.options) : s, this.changeValue(), this.on("cursor", (i) => {
+      switch (i) {
+        case "left":
+        case "up":
+          this.cursor = d(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = d(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+
+// ../../node_modules/.bun/@clack+prompts@1.2.0/node_modules/@clack/prompts/dist/index.mjs
+import { styleText as t, stripVTControlCharacters as ne } from "util";
+import P2 from "process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+import { existsSync as Xe, lstatSync as we, readdirSync as ze } from "fs";
+import { dirname as be, join as Qe } from "path";
+function Ze() {
+  return P2.platform !== "win32" ? P2.env.TERM !== "linux" : !!P2.env.CI || !!P2.env.WT_SESSION || !!P2.env.TERMINUS_SUBLIME || P2.env.ConEmuTask === "{cmd::Cmder}" || P2.env.TERM_PROGRAM === "Terminus-Sublime" || P2.env.TERM_PROGRAM === "vscode" || P2.env.TERM === "xterm-256color" || P2.env.TERM === "alacritty" || P2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var ee = Ze();
+var w2 = (e, i) => ee ? e : i;
+var _e = w2("\u25C6", "*");
+var oe = w2("\u25A0", "x");
+var ue = w2("\u25B2", "x");
+var F = w2("\u25C7", "o");
+var le = w2("\u250C", "T");
+var d2 = w2("\u2502", "|");
+var E2 = w2("\u2514", "\u2014");
+var Ie = w2("\u2510", "T");
+var Ee = w2("\u2518", "\u2014");
+var z2 = w2("\u25CF", ">");
+var H2 = w2("\u25CB", " ");
+var te = w2("\u25FB", "[\u2022]");
+var U = w2("\u25FC", "[+]");
+var J = w2("\u25FB", "[ ]");
+var xe = w2("\u25AA", "\u2022");
+var se = w2("\u2500", "-");
+var ce = w2("\u256E", "+");
+var Ge = w2("\u251C", "+");
+var $e = w2("\u256F", "+");
+var de = w2("\u2570", "+");
+var Oe = w2("\u256D", "+");
+var he = w2("\u25CF", "\u2022");
+var pe = w2("\u25C6", "*");
+var me = w2("\u25B2", "!");
+var ge = w2("\u25A0", "x");
+var V2 = (e) => {
+  switch (e) {
+    case "initial":
+    case "active":
+      return t("cyan", _e);
+    case "cancel":
+      return t("red", oe);
+    case "error":
+      return t("yellow", ue);
+    case "submit":
+      return t("green", F);
+  }
+};
+var ye = (e) => {
+  switch (e) {
+    case "initial":
+    case "active":
+      return t("cyan", d2);
+    case "cancel":
+      return t("red", d2);
+    case "error":
+      return t("yellow", d2);
+    case "submit":
+      return t("green", d2);
+  }
+};
+var et2 = (e, i, s, r, u2) => {
+  let n = i, o = 0;
+  for (let c26 = s; c26 < r; c26++) {
+    const a = e[c26];
+    if (n = n - a.length, o++, n <= u2) break;
+  }
+  return { lineCount: n, removals: o };
+};
+var Y2 = ({ cursor: e, options: i, style: s, output: r = process.stdout, maxItems: u2 = Number.POSITIVE_INFINITY, columnPadding: n = 0, rowPadding: o = 4 }) => {
+  const c26 = O(r) - n, a = A(r), l = t("dim", "..."), $2 = Math.max(a - o, 0), y2 = Math.max(Math.min(u2, $2), 5);
+  let p2 = 0;
+  e >= y2 - 3 && (p2 = Math.max(Math.min(e - y2 + 3, i.length - y2), 0));
+  let m = y2 < i.length && p2 > 0, g = y2 < i.length && p2 + y2 < i.length;
+  const S2 = Math.min(p2 + y2, i.length), h = [];
+  let f = 0;
+  m && f++, g && f++;
+  const v = p2 + (m ? 1 : 0), T = S2 - (g ? 1 : 0);
+  for (let b = v; b < T; b++) {
+    const x = wrapAnsi(s(i[b], b === e), c26, { hard: true, trim: false }).split(`
+`);
+    h.push(x), f += x.length;
+  }
+  if (f > $2) {
+    let b = 0, x = 0, G2 = f;
+    const M2 = e - v, R2 = (j2, D2) => et2(h, G2, j2, D2, $2);
+    m ? ({ lineCount: G2, removals: b } = R2(0, M2), G2 > $2 && ({ lineCount: G2, removals: x } = R2(M2 + 1, h.length))) : ({ lineCount: G2, removals: x } = R2(M2 + 1, h.length), G2 > $2 && ({ lineCount: G2, removals: b } = R2(0, M2))), b > 0 && (m = true, h.splice(0, b)), x > 0 && (g = true, h.splice(h.length - x, x));
+  }
+  const C2 = [];
+  m && C2.push(l);
+  for (const b of h) for (const x of b) C2.push(x);
+  return g && C2.push(l), C2;
+};
+var Ve = { light: w2("\u2500", "-"), heavy: w2("\u2501", "="), block: w2("\u2588", "#") };
+var re = (e, i) => e.includes(`
+`) ? e.split(`
+`).map((s) => i(s)).join(`
+`) : i(e);
+var _t = (e) => {
+  const i = (s, r) => {
+    const u2 = s.label ?? String(s.value);
+    switch (r) {
+      case "disabled":
+        return `${t("gray", H2)} ${re(u2, (n) => t("gray", n))}${s.hint ? ` ${t("dim", `(${s.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${re(u2, (n) => t("dim", n))}`;
+      case "active":
+        return `${t("green", z2)} ${u2}${s.hint ? ` ${t("dim", `(${s.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${re(u2, (n) => t(["strikethrough", "dim"], n))}`;
+      default:
+        return `${t("dim", H2)} ${re(u2, (n) => t("dim", n))}`;
+    }
+  };
+  return new nt({ options: e.options, signal: e.signal, input: e.input, output: e.output, initialValue: e.initialValue, render() {
+    const s = e.withGuide ?? u.withGuide, r = `${V2(this.state)}  `, u2 = `${ye(this.state)}  `, n = R(e.output, e.message, u2, r), o = `${s ? `${t("gray", d2)}
+` : ""}${n}
+`;
+    switch (this.state) {
+      case "submit": {
+        const c26 = s ? `${t("gray", d2)}  ` : "", a = R(e.output, i(this.options[this.cursor], "selected"), c26);
+        return `${o}${a}`;
+      }
+      case "cancel": {
+        const c26 = s ? `${t("gray", d2)}  ` : "", a = R(e.output, i(this.options[this.cursor], "cancelled"), c26);
+        return `${o}${a}${s ? `
+${t("gray", d2)}` : ""}`;
+      }
+      default: {
+        const c26 = s ? `${t("cyan", d2)}  ` : "", a = s ? t("cyan", E2) : "", l = o.split(`
+`).length, $2 = s ? 2 : 1;
+        return `${o}${c26}${Y2({ output: e.output, cursor: this.cursor, options: this.options, maxItems: e.maxItems, columnPadding: c26.length, rowPadding: l + $2, style: (y2, p2) => i(y2, y2.disabled ? "disabled" : p2 ? "active" : "inactive") }).join(`
+${c26}`)}
+${a}
+`;
+      }
+    }
+  } }).prompt();
+};
+var je = `${t("gray", d2)}  `;
 
 // ../../node_modules/.bun/@ts-rest+core@3.53.0-rc.1+f9199aabcde8d6a0/node_modules/@ts-rest/core/index.esm.mjs
 var util;
@@ -3407,7 +4181,7 @@ var util;
     return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
   util2.joinValues = joinValues2;
-  util2.jsonStringifyReplacer = (_, value) => {
+  util2.jsonStringifyReplacer = (_2, value) => {
     if (typeof value === "bigint") {
       return value.toString();
     }
@@ -3447,8 +4221,8 @@ var ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 var getParsedType = (data) => {
-  const t = typeof data;
-  switch (t) {
+  const t2 = typeof data;
+  switch (t2) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -6269,29 +7043,29 @@ var ZodFunction = class _ZodFunction extends ZodType {
     const params = { errorMap: ctx.common.contextualErrorMap };
     const fn = ctx.data;
     if (this._def.returns instanceof ZodPromise) {
-      const me = this;
+      const me2 = this;
       return OK(async function(...args) {
         const error48 = new ZodError([]);
-        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
+        const parsedArgs = await me2._def.args.parseAsync(args, params).catch((e) => {
           error48.addIssue(makeArgsIssue(args, e));
           throw error48;
         });
         const result = await Reflect.apply(fn, this, parsedArgs);
-        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
+        const parsedReturns = await me2._def.returns._def.type.parseAsync(result, params).catch((e) => {
           error48.addIssue(makeReturnsIssue(result, e));
           throw error48;
         });
         return parsedReturns;
       });
     } else {
-      const me = this;
+      const me2 = this;
       return OK(function(...args) {
-        const parsedArgs = me._def.args.safeParse(args, params);
+        const parsedArgs = me2._def.args.safeParse(args, params);
         if (!parsedArgs.success) {
           throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
         }
         const result = Reflect.apply(fn, this, parsedArgs.data);
-        const parsedReturns = me._def.returns.safeParse(result, params);
+        const parsedReturns = me2._def.returns.safeParse(result, params);
         if (!parsedReturns.success) {
           throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
         }
@@ -6855,10 +7629,10 @@ var custom = (check2, params = {}, fatal) => {
     return ZodAny.create().superRefine((data, ctx) => {
       var _a2, _b;
       if (!check2(data)) {
-        const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-        const _fatal = (_b = (_a2 = p.fatal) !== null && _a2 !== void 0 ? _a2 : fatal) !== null && _b !== void 0 ? _b : true;
-        const p2 = typeof p === "string" ? { message: p } : p;
-        ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
+        const p2 = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+        const _fatal = (_b = (_a2 = p2.fatal) !== null && _a2 !== void 0 ? _a2 : fatal) !== null && _b !== void 0 ? _b : true;
+        const p22 = typeof p2 === "string" ? { message: p2 } : p2;
+        ctx.addIssue({ code: "custom", ...p22, fatal: _fatal });
       }
     });
   return ZodAny.create();
@@ -6956,7 +7730,7 @@ var coerce = {
   date: ((arg) => ZodDate.create({ ...arg, coerce: true }))
 };
 var NEVER = INVALID;
-var z = /* @__PURE__ */ Object.freeze({
+var z3 = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   defaultErrorMap: errorMap,
   setErrorMap,
@@ -7089,17 +7863,17 @@ var zodMerge = (objectA, objectB) => {
   }
   return Object.assign({}, objectA, objectB);
 };
-var ZodErrorSchema = z.object({
-  name: z.literal("ZodError"),
-  issues: z.array(z.object({
-    path: z.array(z.union([z.string(), z.number()])),
-    message: z.string().optional(),
-    code: z.nativeEnum(z.ZodIssueCode)
-  }).catchall(z.any()))
+var ZodErrorSchema = z3.object({
+  name: z3.literal("ZodError"),
+  issues: z3.array(z3.object({
+    path: z3.array(z3.union([z3.string(), z3.number()])),
+    message: z3.string().optional(),
+    code: z3.nativeEnum(z3.ZodIssueCode)
+  }).catchall(z3.any()))
 });
 var StandardSchemaError = class extends Error {
   constructor(issues) {
-    const message = JSON.stringify(issues, (_, value) => typeof value === "bigint" ? value.toString() : value, 2);
+    const message = JSON.stringify(issues, (_2, value) => typeof value === "bigint" ? value.toString() : value, 2);
     super(message);
     this.name = "ValidationError";
     this.issues = issues;
@@ -7112,21 +7886,21 @@ var StandardSchemaError = class extends Error {
     return this.message;
   }
 };
-var RequestValidationErrorSchema = z.object({
-  message: z.literal("Request validation failed"),
+var RequestValidationErrorSchema = z3.object({
+  message: z3.literal("Request validation failed"),
   pathParameterErrors: ZodErrorSchema.nullable(),
   headerErrors: ZodErrorSchema.nullable(),
   queryParameterErrors: ZodErrorSchema.nullable(),
   bodyErrors: ZodErrorSchema.nullable()
 });
-var RequestValidationErrorSchemaWithoutMessage = z.object({
+var RequestValidationErrorSchemaWithoutMessage = z3.object({
   // No message, express never had this implemented
   pathParameterErrors: ZodErrorSchema.nullable(),
   headerErrors: ZodErrorSchema.nullable(),
   queryParameterErrors: ZodErrorSchema.nullable(),
   bodyErrors: ZodErrorSchema.nullable()
 });
-var RequestValidationErrorSchemaForNest = z.object({
+var RequestValidationErrorSchemaForNest = z3.object({
   paramsResult: ZodErrorSchema.nullable(),
   headersResult: ZodErrorSchema.nullable(),
   queryResult: ZodErrorSchema.nullable(),
@@ -7263,7 +8037,7 @@ var initContract = () => {
 };
 var insertParamsIntoPath = ({ path, params }) => {
   const pathParams = params;
-  return path.replace(/\/?:([^/?]+)\??/g, (matched, p) => pathParams[p] ? `${matched.startsWith("/") ? "/" : ""}${pathParams[p]}` : "");
+  return path.replace(/\/?:([^/?]+)\??/g, (matched, p2) => pathParams[p2] ? `${matched.startsWith("/") ? "/" : ""}${pathParams[p2]}` : "");
 };
 var convertQueryParamsToUrlString = (query, json2 = false) => {
   const queryString = json2 ? encodeQueryParamsJson(query) : encodeQueryParams(query);
@@ -8060,7 +8834,7 @@ function $constructor(name, initializer3, params) {
       Object.defineProperty(inst, "_zod", {
         value: {
           def,
-          constr: _,
+          constr: _2,
           traits: /* @__PURE__ */ new Set()
         },
         enumerable: false
@@ -8071,12 +8845,12 @@ function $constructor(name, initializer3, params) {
     }
     inst._zod.traits.add(name);
     initializer3(inst, def);
-    const proto = _.prototype;
-    const keys = Object.keys(proto);
+    const proto2 = _2.prototype;
+    const keys = Object.keys(proto2);
     for (let i = 0; i < keys.length; i++) {
       const k = keys[i];
       if (!(k in inst)) {
-        inst[k] = proto[k].bind(inst);
+        inst[k] = proto2[k].bind(inst);
       }
     }
   }
@@ -8084,7 +8858,7 @@ function $constructor(name, initializer3, params) {
   class Definition extends Parent {
   }
   Object.defineProperty(Definition, "name", { value: name });
-  function _(def) {
+  function _2(def) {
     var _a2;
     const inst = params?.Parent ? new Definition() : this;
     init(inst, def);
@@ -8094,16 +8868,16 @@ function $constructor(name, initializer3, params) {
     }
     return inst;
   }
-  Object.defineProperty(_, "init", { value: init });
-  Object.defineProperty(_, Symbol.hasInstance, {
+  Object.defineProperty(_2, "init", { value: init });
+  Object.defineProperty(_2, Symbol.hasInstance, {
     value: (inst) => {
       if (params?.Parent && inst instanceof params.Parent)
         return true;
       return inst?._zod?.traits?.has(name);
     }
   });
-  Object.defineProperty(_, "name", { value: name });
-  return _;
+  Object.defineProperty(_2, "name", { value: name });
+  return _2;
 }
 var $brand = /* @__PURE__ */ Symbol("zod_brand");
 var $ZodAsyncError = class extends Error {
@@ -8201,17 +8975,17 @@ function assertIs(_arg) {
 function assertNever(_x) {
   throw new Error("Unexpected value in exhaustive check");
 }
-function assert(_) {
+function assert(_2) {
 }
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  const values = Object.entries(entries).filter(([k, _2]) => numericValues.indexOf(+k) === -1).map(([_2, v]) => v);
   return values;
 }
 function joinValues(array2, separator = "|") {
   return array2.map((val) => stringifyPrimitive(val)).join(separator);
 }
-function jsonStringifyReplacer(_, value) {
+function jsonStringifyReplacer(_2, value) {
   if (typeof value === "bigint")
     return value.toString();
   return value;
@@ -8337,10 +9111,10 @@ var allowsEval = cached(() => {
     return false;
   }
   try {
-    const F = Function;
-    new F("");
+    const F2 = Function;
+    new F2("");
     return true;
-  } catch (_) {
+  } catch (_2) {
     return false;
   }
 });
@@ -8377,8 +9151,8 @@ function numKeys(data) {
   return keyCount;
 }
 var getParsedType2 = (data) => {
-  const t = typeof data;
-  switch (t) {
+  const t2 = typeof data;
+  switch (t2) {
     case "undefined":
       return "undefined";
     case "string":
@@ -8417,7 +9191,7 @@ var getParsedType2 = (data) => {
       }
       return "object";
     default:
-      throw new Error(`Unknown data type: ${t}`);
+      throw new Error(`Unknown data type: ${t2}`);
   }
 };
 var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
@@ -8450,31 +9224,31 @@ function normalizeParams(_params) {
 function createTransparentProxy(getter) {
   let target;
   return new Proxy({}, {
-    get(_, prop, receiver) {
+    get(_2, prop, receiver) {
       target ?? (target = getter());
       return Reflect.get(target, prop, receiver);
     },
-    set(_, prop, value, receiver) {
+    set(_2, prop, value, receiver) {
       target ?? (target = getter());
       return Reflect.set(target, prop, value, receiver);
     },
-    has(_, prop) {
+    has(_2, prop) {
       target ?? (target = getter());
       return Reflect.has(target, prop);
     },
-    deleteProperty(_, prop) {
+    deleteProperty(_2, prop) {
       target ?? (target = getter());
       return Reflect.deleteProperty(target, prop);
     },
-    ownKeys(_) {
+    ownKeys(_2) {
       target ?? (target = getter());
       return Reflect.ownKeys(target);
     },
-    getOwnPropertyDescriptor(_, prop) {
+    getOwnPropertyDescriptor(_2, prop) {
       target ?? (target = getter());
       return Reflect.getOwnPropertyDescriptor(target, prop);
     },
-    defineProperty(_, prop, descriptor) {
+    defineProperty(_2, prop, descriptor) {
       target ?? (target = getter());
       return Reflect.defineProperty(target, prop, descriptor);
     }
@@ -8724,8 +9498,8 @@ function getLengthableOrigin(input) {
   return "unknown";
 }
 function parsedType(data) {
-  const t = typeof data;
-  switch (t) {
+  const t2 = typeof data;
+  switch (t2) {
     case "number": {
       return Number.isNaN(data) ? "nan" : "number";
     }
@@ -8742,7 +9516,7 @@ function parsedType(data) {
       }
     }
   }
-  return t;
+  return t2;
 }
 function issue(...args) {
   const [iss, input, inst] = args;
@@ -8757,7 +9531,7 @@ function issue(...args) {
   return { ...iss };
 }
 function cleanEnum(obj) {
-  return Object.entries(obj).filter(([k, _]) => {
+  return Object.entries(obj).filter(([k, _2]) => {
     return Number.isNaN(Number.parseInt(k, 10));
   }).map((el) => el[1]);
 }
@@ -9760,11 +10534,11 @@ var Doc = class {
     }
   }
   compile() {
-    const F = Function;
+    const F2 = Function;
     const args = this?.args;
     const content = this?.content ?? [``];
     const lines = [...content.map((x) => `  ${x}`)];
-    return new F(...args, lines.join("\n"));
+    return new F2(...args, lines.join("\n"));
   }
 };
 
@@ -9809,13 +10583,13 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
           continue;
         }
         const currLen = payload.issues.length;
-        const _ = ch._zod.check(payload);
-        if (_ instanceof Promise && ctx?.async === false) {
+        const _2 = ch._zod.check(payload);
+        if (_2 instanceof Promise && ctx?.async === false) {
           throw new $ZodAsyncError();
         }
-        if (asyncResult || _ instanceof Promise) {
+        if (asyncResult || _2 instanceof Promise) {
           asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
-            await _;
+            await _2;
             const nextLen = payload.issues.length;
             if (nextLen === currLen)
               return;
@@ -9877,7 +10651,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
       try {
         const r = safeParse(inst, value);
         return r.success ? { value: r.data } : { issues: r.error?.issues };
-      } catch (_) {
+      } catch (_2) {
         return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
       }
     },
@@ -9888,11 +10662,11 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
-  inst._zod.parse = (payload, _) => {
+  inst._zod.parse = (payload, _2) => {
     if (def.coerce)
       try {
         payload.value = String(payload.value);
-      } catch (_2) {
+      } catch (_3) {
       }
     if (typeof payload.value === "string")
       return payload;
@@ -9977,7 +10751,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
         payload.value = trimmed;
       }
       return;
-    } catch (_) {
+    } catch (_2) {
       payload.issues.push({
         code: "invalid_format",
         format: "url",
@@ -10123,7 +10897,7 @@ var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
 function isValidBase64URL(data) {
   if (!base64url.test(data))
     return false;
-  const base643 = data.replace(/[-_]/g, (c25) => c25 === "-" ? "+" : "/");
+  const base643 = data.replace(/[-_]/g, (c26) => c26 === "-" ? "+" : "/");
   const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, "=");
   return isValidBase64(padded);
 }
@@ -10202,7 +10976,7 @@ var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
     if (def.coerce)
       try {
         payload.value = Number(payload.value);
-      } catch (_) {
+      } catch (_2) {
       }
     const input = payload.value;
     if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
@@ -10230,7 +11004,7 @@ var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
     if (def.coerce)
       try {
         payload.value = Boolean(payload.value);
-      } catch (_) {
+      } catch (_2) {
       }
     const input = payload.value;
     if (typeof input === "boolean")
@@ -10251,7 +11025,7 @@ var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
     if (def.coerce)
       try {
         payload.value = BigInt(payload.value);
-      } catch (_) {
+      } catch (_2) {
       }
     if (typeof payload.value === "bigint")
       return payload;
@@ -10452,12 +11226,12 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
   const unrecognized = [];
   const keySet = def.keySet;
   const _catchall = def.catchall._zod;
-  const t = _catchall.def.type;
+  const t2 = _catchall.def.type;
   const isOptionalOut = _catchall.optout === "optional";
   for (const key in input) {
     if (keySet.has(key))
       continue;
-    if (t === "never") {
+    if (t2 === "never") {
       unrecognized.push(key);
       continue;
     }
@@ -10677,7 +11451,7 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
   defineLazy(inst._zod, "pattern", () => {
     if (def.options.every((o) => o._zod.pattern)) {
       const patterns = def.options.map((o) => o._zod.pattern);
-      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+      return new RegExp(`^(${patterns.map((p2) => cleanRegex(p2.source)).join("|")})$`);
     }
     return void 0;
   });
@@ -11666,9 +12440,9 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
     return payload;
   };
   inst.input = (...args) => {
-    const F = inst.constructor;
+    const F2 = inst.constructor;
     if (Array.isArray(args[0])) {
-      return new F({
+      return new F2({
         type: "function",
         input: new $ZodTuple({
           type: "tuple",
@@ -11678,15 +12452,15 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
         output: inst._def.output
       });
     }
-    return new F({
+    return new F2({
       type: "function",
       input: args[0],
       output: inst._def.output
     });
   };
   inst.output = (output) => {
-    const F = inst.constructor;
-    return new F({
+    const F2 = inst.constructor;
+    return new F2({
       type: "function",
       input: inst._def.input,
       output
@@ -11715,7 +12489,7 @@ var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
 var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
   $ZodCheck.init(inst, def);
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _) => {
+  inst._zod.parse = (payload, _2) => {
     return payload;
   };
   inst._zod.check = (payload) => {
@@ -13564,16 +14338,16 @@ var error16 = () => {
     number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
     // no unit
   };
-  const typeEntry = (t) => t ? TypeNames[t] : void 0;
-  const typeLabel = (t) => {
-    const e = typeEntry(t);
+  const typeEntry = (t2) => t2 ? TypeNames[t2] : void 0;
+  const typeLabel = (t2) => {
+    const e = typeEntry(t2);
     if (e)
       return e.label;
-    return t ?? TypeNames.unknown.label;
+    return t2 ?? TypeNames.unknown.label;
   };
-  const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
-  const verbFor = (t) => {
-    const e = typeEntry(t);
+  const withDefinite = (t2) => `\u05D4${typeLabel(t2)}`;
+  const verbFor = (t2) => {
+    const e = typeEntry(t2);
     const gender = e?.gender ?? "m";
     return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
   };
@@ -13657,11 +14431,11 @@ var error16 = () => {
           return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
         }
         const adj = issue2.inclusive ? "<=" : "<";
-        const be = verbFor(issue2.origin ?? "value");
+        const be2 = verbFor(issue2.origin ?? "value");
         if (sizing?.unit) {
-          return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
+          return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
         }
-        return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`;
+        return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.maximum.toString()}`;
       }
       case "too_small": {
         const sizing = getSizing(issue2.origin);
@@ -13683,11 +14457,11 @@ var error16 = () => {
           return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
         }
         const adj = issue2.inclusive ? ">=" : ">";
-        const be = verbFor(issue2.origin ?? "value");
+        const be2 = verbFor(issue2.origin ?? "value");
         if (sizing?.unit) {
-          return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
         }
-        return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`;
+        return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.minimum.toString()}`;
       }
       case "invalid_format": {
         const _issue = issue2;
@@ -17354,9 +18128,9 @@ var $ZodRegistry = class {
     return this;
   }
   get(schema) {
-    const p = schema._zod.parent;
-    if (p) {
-      const pm = { ...this.get(p) ?? {} };
+    const p2 = schema._zod.parent;
+    if (p2) {
+      const pm = { ...this.get(p2) ?? {} };
       delete pm.id;
       const f = { ...pm, ...this._map.get(schema) };
       return Object.keys(f).length ? f : void 0;
@@ -19286,7 +20060,7 @@ function toJSONSchema(input, params) {
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
-      const [_, schema] = entry;
+      const [_2, schema] = entry;
       process2(schema, ctx2);
     }
     const schemas = {};
@@ -19385,7 +20159,7 @@ var JSONSchemaGenerator = class {
     }
     extractDefs(this.ctx, schema);
     const result = finalize(this.ctx, schema);
-    const { "~standard": _, ...plainResult } = result;
+    const { "~standard": _2, ...plainResult } = result;
     return plainResult;
   }
 };
@@ -20167,9 +20941,9 @@ var ZodDate2 = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
   inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
   inst.min = (value, params) => inst.check(_gte(value, params));
   inst.max = (value, params) => inst.check(_lte(value, params));
-  const c25 = inst._zod.bag;
-  inst.minDate = c25.minimum ? new Date(c25.minimum) : null;
-  inst.maxDate = c25.maximum ? new Date(c25.maximum) : null;
+  const c26 = inst._zod.bag;
+  inst.minDate = c26.minimum ? new Date(c26.minimum) : null;
+  inst.maxDate = c26.maximum ? new Date(c26.maximum) : null;
 });
 function date3(params) {
   return _date(ZodDate2, params);
@@ -20797,7 +21571,7 @@ var ZodFirstPartyTypeKind2;
 })(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {}));
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js
-var z2 = {
+var z4 = {
   ...schemas_exports2,
   ...checks_exports2,
   iso: iso_exports
@@ -20907,7 +21681,7 @@ function resolveRef(ref, ctx) {
 function convertBaseSchema(schema, ctx) {
   if (schema.not !== void 0) {
     if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-      return z2.never();
+      return z4.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -20929,7 +21703,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z2.lazy(() => {
+      return z4.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -20946,95 +21720,95 @@ function convertBaseSchema(schema, ctx) {
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
     if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-      return z2.null();
+      return z4.null();
     }
     if (enumValues.length === 0) {
-      return z2.never();
+      return z4.never();
     }
     if (enumValues.length === 1) {
-      return z2.literal(enumValues[0]);
+      return z4.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z2.enum(enumValues);
+      return z4.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z2.literal(v));
+    const literalSchemas = enumValues.map((v) => z4.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z2.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z4.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z2.literal(schema.const);
+    return z4.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
-    const typeSchemas = type.map((t) => {
-      const typeSchema = { ...schema, type: t };
+    const typeSchemas = type.map((t2) => {
+      const typeSchema = { ...schema, type: t2 };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z2.never();
+      return z4.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z2.union(typeSchemas);
+    return z4.union(typeSchemas);
   }
   if (!type) {
-    return z2.any();
+    return z4.any();
   }
   let zodSchema;
   switch (type) {
     case "string": {
-      let stringSchema = z2.string();
+      let stringSchema = z4.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z2.email());
+          stringSchema = stringSchema.check(z4.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z2.url());
+          stringSchema = stringSchema.check(z4.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z2.uuid());
+          stringSchema = stringSchema.check(z4.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z2.iso.datetime());
+          stringSchema = stringSchema.check(z4.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z2.iso.date());
+          stringSchema = stringSchema.check(z4.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z2.iso.time());
+          stringSchema = stringSchema.check(z4.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z2.iso.duration());
+          stringSchema = stringSchema.check(z4.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z2.ipv4());
+          stringSchema = stringSchema.check(z4.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z2.ipv6());
+          stringSchema = stringSchema.check(z4.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z2.mac());
+          stringSchema = stringSchema.check(z4.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z2.cidrv4());
+          stringSchema = stringSchema.check(z4.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z2.cidrv6());
+          stringSchema = stringSchema.check(z4.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z2.base64());
+          stringSchema = stringSchema.check(z4.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z2.base64url());
+          stringSchema = stringSchema.check(z4.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z2.e164());
+          stringSchema = stringSchema.check(z4.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z2.jwt());
+          stringSchema = stringSchema.check(z4.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z2.emoji());
+          stringSchema = stringSchema.check(z4.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z2.nanoid());
+          stringSchema = stringSchema.check(z4.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z2.cuid());
+          stringSchema = stringSchema.check(z4.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z2.cuid2());
+          stringSchema = stringSchema.check(z4.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z2.ulid());
+          stringSchema = stringSchema.check(z4.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z2.xid());
+          stringSchema = stringSchema.check(z4.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z2.ksuid());
+          stringSchema = stringSchema.check(z4.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -21051,7 +21825,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z2.number().int() : z2.number();
+      let numberSchema = type === "integer" ? z4.number().int() : z4.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -21075,11 +21849,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema = z2.boolean();
+      zodSchema = z4.boolean();
       break;
     }
     case "null": {
-      zodSchema = z2.null();
+      zodSchema = z4.null();
       break;
     }
     case "object": {
@@ -21092,14 +21866,14 @@ function convertBaseSchema(schema, ctx) {
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z2.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z4.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema = z2.record(keySchema, valueSchema);
+          zodSchema = z4.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z2.object(shape).passthrough();
-        const recordSchema = z2.looseRecord(keySchema, valueSchema);
-        zodSchema = z2.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z4.object(shape).passthrough();
+        const recordSchema = z4.looseRecord(keySchema, valueSchema);
+        zodSchema = z4.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -21108,28 +21882,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z2.string().regex(new RegExp(pattern));
-          looseRecords.push(z2.looseRecord(keySchema, patternValue));
+          const keySchema = z4.string().regex(new RegExp(pattern));
+          looseRecords.push(z4.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z2.object(shape).passthrough());
+          schemasToIntersect.push(z4.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema = z2.object({}).passthrough();
+          zodSchema = z4.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema = schemasToIntersect[0];
         } else {
-          let result = z2.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z4.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z2.intersection(result, schemasToIntersect[i]);
+            result = z4.intersection(result, schemasToIntersect[i]);
           }
           zodSchema = result;
         }
         break;
       }
-      const objectSchema = z2.object(shape);
+      const objectSchema = z4.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -21146,33 +21920,33 @@ function convertBaseSchema(schema, ctx) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
         if (rest) {
-          zodSchema = z2.tuple(tupleItems).rest(rest);
+          zodSchema = z4.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema = z2.tuple(tupleItems);
+          zodSchema = z4.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+          zodSchema = zodSchema.check(z4.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+          zodSchema = zodSchema.check(z4.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
         if (rest) {
-          zodSchema = z2.tuple(tupleItems).rest(rest);
+          zodSchema = z4.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema = z2.tuple(tupleItems);
+          zodSchema = z4.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+          zodSchema = zodSchema.check(z4.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+          zodSchema = zodSchema.check(z4.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z2.array(element);
+        let arraySchema = z4.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -21181,7 +21955,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema = arraySchema;
       } else {
-        zodSchema = z2.array(z2.any());
+        zodSchema = z4.array(z4.any());
       }
       break;
     }
@@ -21198,37 +21972,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z2.any() : z2.never();
+    return schema ? z4.any() : z4.never();
   }
   let baseSchema = convertBaseSchema(schema, ctx);
   const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
   if (schema.anyOf && Array.isArray(schema.anyOf)) {
     const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z2.union(options);
-    baseSchema = hasExplicitType ? z2.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z4.union(options);
+    baseSchema = hasExplicitType ? z4.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z2.xor(options);
-    baseSchema = hasExplicitType ? z2.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z4.xor(options);
+    baseSchema = hasExplicitType ? z4.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z2.any();
+      baseSchema = hasExplicitType ? baseSchema : z4.any();
     } else {
       let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z2.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z4.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z2.nullable(baseSchema);
+    baseSchema = z4.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z2.readonly(baseSchema);
+    baseSchema = z4.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -21255,7 +22029,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z2.any() : z2.never();
+    return schema ? z4.any() : z4.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -21324,8 +22098,8 @@ var DeleteResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/admin.ts
-var c = initContract();
-var adminContract = c.router({
+var c2 = initContract();
+var adminContract = c2.router({
   approveCheckRun: {
     method: "POST",
     path: "/organizations/:organizationId/admin/check-runs/approve",
@@ -21397,8 +22171,8 @@ var ListChatSessionsResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/chat-session.ts
-var c2 = initContract();
-var chatSessionContract = c2.router({
+var c3 = initContract();
+var chatSessionContract = c3.router({
   createSession: {
     method: "POST",
     path: "/organizations/:organizationId/chat/sessions",
@@ -21679,8 +22453,8 @@ var DependencySummaryResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/dependency.ts
-var c3 = initContract();
-var dependencyContract = c3.router({
+var c4 = initContract();
+var dependencyContract = c4.router({
   /** Cross-repo dependency search. Two-phase: pg_trgm on Package, then join repos. */
   searchDependencies: {
     method: "POST",
@@ -21825,8 +22599,8 @@ var DockerScoutIntegrationResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/docker-scout-integration.ts
-var c4 = initContract();
-var dockerScoutIntegrationContract = c4.router({
+var c5 = initContract();
+var dockerScoutIntegrationContract = c5.router({
   createDockerScoutIntegration: {
     method: "POST",
     path: "/organizations/:organizationId/docker-scout-integration",
@@ -21923,8 +22697,8 @@ var GitHubRepoSchema = external_exports.object({
 var ListGitHubInstallationReposResponseSchema = external_exports.array(GitHubRepoSchema);
 
 // ../../packages/api-contracts/src/contracts/v1/github.ts
-var c5 = initContract();
-var githubCallbackContract = c5.router(
+var c6 = initContract();
+var githubCallbackContract = c6.router(
   {
     handleCallback: {
       method: "POST",
@@ -21944,7 +22718,7 @@ var githubCallbackContract = c5.router(
     pathPrefix: "/v1/github"
   }
 );
-var githubContract = c5.router({
+var githubContract = c6.router({
   generateInstallLink: {
     method: "POST",
     path: "/organizations/:organizationId/github/install-link",
@@ -22014,8 +22788,8 @@ var UpdateKnowledgeBaseResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/knowledge-base.ts
-var c6 = initContract();
-var knowledgeBaseContract = c6.router({
+var c7 = initContract();
+var knowledgeBaseContract = c7.router({
   getKnowledgeBase: {
     method: "GET",
     path: "/organizations/:organizationId/knowledge-base",
@@ -22236,8 +23010,8 @@ var UpdateRepoDocumentContentResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/knowledge-document.ts
-var c7 = initContract();
-var knowledgeDocumentContract = c7.router({
+var c8 = initContract();
+var knowledgeDocumentContract = c8.router({
   createDocument: {
     method: "POST",
     path: "/organizations/:organizationId/knowledge-documents",
@@ -22546,8 +23320,8 @@ var LlmProviderKeyResponseSchema = external_exports.object({
 var ListLlmProviderKeysResponseSchema = external_exports.array(LlmProviderKeyResponseSchema);
 
 // ../../packages/api-contracts/src/contracts/v1/llm-provider-key.ts
-var c8 = initContract();
-var llmProviderKeyContract = c8.router({
+var c9 = initContract();
+var llmProviderKeyContract = c9.router({
   createLlmProviderKey: {
     method: "POST",
     path: "/organizations/:organizationId/llm-provider-keys",
@@ -22663,8 +23437,8 @@ var LogoDeleteRequestSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/organization.ts
-var c9 = initContract();
-var organizationContract = c9.router({
+var c10 = initContract();
+var organizationContract = c10.router({
   listOrganizations: {
     method: "GET",
     path: "/organizations",
@@ -22826,8 +23600,8 @@ var UpdatePentestRequestSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/pentest.ts
-var c10 = initContract();
-var pentestContract = c10.router({
+var c11 = initContract();
+var pentestContract = c11.router({
   listPentests: {
     method: "GET",
     path: "/organizations/:organizationId/pentests",
@@ -23085,8 +23859,8 @@ var GetParseTaskStatusResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/pentest-finding.ts
-var c11 = initContract();
-var pentestFindingContract = c11.router({
+var c12 = initContract();
+var pentestFindingContract = c12.router({
   // ─── Findings ───
   listFindings: {
     method: "GET",
@@ -23356,8 +24130,8 @@ var CloneTokenResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/repository.ts
-var c12 = initContract();
-var repositoryContract = c12.router({
+var c13 = initContract();
+var repositoryContract = c13.router({
   createRepository: {
     method: "POST",
     path: "/organizations/:organizationId/repositories",
@@ -23555,8 +24329,8 @@ var ListScanLogsResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/scan.ts
-var c13 = initContract();
-var scanContract = c13.router({
+var c14 = initContract();
+var scanContract = c14.router({
   createScan: {
     method: "POST",
     path: "/organizations/:organizationId/scans",
@@ -23661,8 +24435,8 @@ var UserResponseSchema = external_exports.object({
 var ListUsersResponseSchema = external_exports.array(UserResponseSchema);
 
 // ../../packages/api-contracts/src/contracts/v1/user.ts
-var c14 = initContract();
-var userContract = c14.router({
+var c15 = initContract();
+var userContract = c15.router({
   listUsers: {
     method: "GET",
     path: "/organizations/:organizationId/users",
@@ -23734,8 +24508,8 @@ var VantaIntegrationResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/vanta-integration.ts
-var c15 = initContract();
-var vantaIntegrationContract = c15.router({
+var c16 = initContract();
+var vantaIntegrationContract = c16.router({
   createVantaIntegration: {
     method: "POST",
     path: "/organizations/:organizationId/vanta-integration",
@@ -23977,8 +24751,8 @@ var BulkUpdateVulnerabilitiesResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/vulnerability.ts
-var c16 = initContract();
-var vulnerabilityContract = c16.router({
+var c17 = initContract();
+var vulnerabilityContract = c17.router({
   filterVulnerabilities: {
     method: "POST",
     path: "/organizations/:organizationId/vulnerabilities/filter",
@@ -24137,8 +24911,8 @@ var UpdateVulnerabilityNoteRequestSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/vulnerability-note.ts
-var c17 = initContract();
-var vulnerabilityNoteContract = c17.router({
+var c18 = initContract();
+var vulnerabilityNoteContract = c18.router({
   listNotes: {
     method: "GET",
     path: "/organizations/:organizationId/vulnerabilities/:vulnerabilityId/notes",
@@ -24210,8 +24984,8 @@ var WebApplicationResponseSchema = external_exports.object({
 var ListWebApplicationsResponseSchema = external_exports.array(WebApplicationResponseSchema);
 
 // ../../packages/api-contracts/src/contracts/v1/web-application.ts
-var c18 = initContract();
-var webApplicationContract = c18.router({
+var c19 = initContract();
+var webApplicationContract = c19.router({
   listWebApplications: {
     method: "GET",
     path: "/organizations/:organizationId/web-applications",
@@ -24350,8 +25124,8 @@ var ListWebhookDeliveriesResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/webhook-settings.ts
-var c19 = initContract();
-var webhookSettingsContract = c19.router({
+var c20 = initContract();
+var webhookSettingsContract = c20.router({
   listWebhookEndpoints: {
     method: "GET",
     path: "/organizations/:organizationId/webhook-settings/endpoints",
@@ -24489,8 +25263,8 @@ var webhookSettingsContract = c19.router({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/index.ts
-var c20 = initContract();
-var v1Contract = c20.router(
+var c21 = initContract();
+var v1Contract = c21.router(
   {
     admin: adminContract,
     scan: scanContract,
@@ -24518,8 +25292,8 @@ var v1Contract = c20.router(
 );
 
 // ../../packages/api-contracts/src/contracts/index.ts
-var c21 = initContract();
-var contract = c21.router({
+var c22 = initContract();
+var contract = c22.router({
   v1: v1Contract
 });
 
@@ -24529,8 +25303,8 @@ var GitHubWebhookResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/webhooks/github.ts
-var c22 = initContract();
-var githubWebhookContract = c22.router(
+var c23 = initContract();
+var githubWebhookContract = c23.router(
   {
     handleWebhook: {
       method: "POST",
@@ -24555,8 +25329,8 @@ var HealthResponseSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/health.ts
-var c23 = initContract();
-var healthContract = c23.router({
+var c24 = initContract();
+var healthContract = c24.router({
   getHealth: {
     method: "GET",
     path: "/health",
@@ -24605,8 +25379,8 @@ var UpdatePrVulnerabilityRequestSchema = external_exports.object({
 });
 
 // ../../packages/api-contracts/src/contracts/v1/pr-vulnerability.ts
-var c24 = initContract();
-var prVulnerabilityContract = c24.router(
+var c25 = initContract();
+var prVulnerabilityContract = c25.router(
   {
     listPrVulnerabilities: {
       method: "GET",
@@ -24759,6 +25533,9 @@ function getRefreshTokenPath() {
 function getSelectedOrganizationPath() {
   return join(resolveTraceDir(), SELECTED_ORGANIZATION_FILENAME);
 }
+function getTraceDir() {
+  return resolveTraceDir();
+}
 function readToken() {
   const tokenPath = getTokenPath();
   try {
@@ -25108,6 +25885,540 @@ function tsvSafe(value) {
   return (value ?? "").replace(/[\t\r\n]/g, " ");
 }
 
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex3) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex3.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer2 = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer2 >> 16 & 255,
+          integer2 >> 8 & 255,
+          integer2 & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex3) => styles.rgbToAnsi256(...styles.hexToRgb(hex3)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex3) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex3)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+import process3 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process3.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process3;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process3.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version2 >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string4, substring, replacer) {
+  let index = string4.indexOf(substring);
+  if (index === -1) {
+    return string4;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string4.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string4.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string4.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string4, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string4[index - 1] === "\r";
+    returnValue += string4.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string4.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string4.slice(endIndex);
+  return returnValue;
+}
+
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object2, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object2.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string4) => {
+  if (self.level <= 0 || !string4) {
+    return self[IS_EMPTY] ? "" : string4;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string4;
+  }
+  const { openAll, closeAll } = styler;
+  if (string4.includes("\x1B")) {
+    while (styler !== void 0) {
+      string4 = stringReplaceAll(string4, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string4.indexOf("\n");
+  if (lfIndex !== -1) {
+    string4 = stringEncaseCRLFWithFirstIndex(string4, closeAll, openAll, lfIndex);
+  }
+  return openAll + string4 + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/theme.ts
+function colorSeverity(severity, text, colorizer = source_default) {
+  switch (severity) {
+    case "CRITICAL":
+      return colorizer.red.bold(text);
+    case "HIGH":
+      return colorizer.hex("#ff6b00").bold(text);
+    case "MEDIUM":
+      return colorizer.yellow(text);
+    case "LOW":
+      return colorizer.cyan(text);
+    case "INFORMATIONAL":
+      return colorizer.gray(text);
+    default:
+      return text;
+  }
+}
+function colorBanner(text, colorizer = source_default) {
+  return colorizer.cyan.bold(text);
+}
+function colorMuted(text, colorizer = source_default) {
+  return colorizer.dim(text);
+}
+function colorSuccess(text, colorizer = source_default) {
+  return colorizer.green(text);
+}
+function colorError(text, colorizer = source_default) {
+  return colorizer.red(text);
+}
+function colorWarning(text, colorizer = source_default) {
+  return colorizer.yellow(text);
+}
+function colorAccentBold(text, colorizer = source_default) {
+  return colorizer.bold.cyan(text);
+}
+function colorAccentUnderline(text, colorizer = source_default) {
+  return colorizer.underline.cyan(text);
+}
+
 // src/auth/commands.ts
 function getClientId() {
   const clientId = "client_01KEZ01W5Q3107GTBY51WQ67HT";
@@ -25285,35 +26596,56 @@ function resolveOrganizationSelectionInput(organizations, input) {
   return findOrganizationByInput(organizations, trimmedInput);
 }
 async function promptForOrganizationSelection(organizations, activeOrganizationId) {
-  console.log("Select an organization:");
-  for (const [index, organization] of organizations.entries()) {
-    const marker = organization.organizationId === activeOrganizationId ? "*" : " ";
-    console.log(
-      `${marker} ${index + 1}) ${sanitizeForOutput(organization.name)} (${sanitizeForOutput(organization.slug)}) - ${organization.organizationId}`
-    );
+  if (organizations.length === 0) {
+    return null;
   }
-  console.log("");
-  const readline = createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  try {
-    while (true) {
-      const input = await readline.question(
-        "Enter number, organization ID, slug, or name (press Enter to cancel): "
-      );
-      if (input.trim().length === 0) {
-        return null;
-      }
-      const selection = resolveOrganizationSelectionInput(organizations, input);
-      if ("organization" in selection) {
-        return selection.organization;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    const readline = createInterface2({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      while (true) {
+        const input = await readline.question(
+          "Enter number, organization ID, slug, or name (press Enter to cancel): "
+        );
+        if (input.trim().length === 0) {
+          return null;
+        }
+        const selection = resolveOrganizationSelectionInput(organizations, input);
+        if ("organization" in selection) {
+          return selection.organization;
+        }
+        console.error(selection.error);
       }
-      console.error(selection.error);
+    } finally {
+      readline.close();
     }
-  } finally {
-    readline.close();
   }
+  const activeIndex = organizations.findIndex(
+    (organization) => organization.organizationId === activeOrganizationId
+  );
+  const choices = organizations.map((organization) => {
+    const isActive = organization.organizationId === activeOrganizationId;
+    const label = `${sanitizeForOutput(organization.name)} (${sanitizeForOutput(organization.slug)})`;
+    return {
+      value: organization.organizationId,
+      label: isActive ? `${label} (current)` : label,
+      hint: organization.organizationId
+    };
+  });
+  const selected = await _t({
+    message: "Switch organization",
+    options: choices,
+    initialValue: activeIndex >= 0 ? organizations[activeIndex]?.organizationId : void 0
+  });
+  if (q(selected)) {
+    return null;
+  }
+  const selectedOrganization = organizations.find(
+    (organization) => organization.organizationId === selected
+  );
+  return selectedOrganization ?? null;
 }
 async function refreshAfterOrganizationSwitch(workosOrganizationId, refreshForOrganization = (organizationId) => refreshStoredAccessTokenForOrganization(organizationId)) {
   if (!workosOrganizationId || workosOrganizationId.trim().length === 0) {
@@ -25331,22 +26663,24 @@ Examples:
   ).action(async () => {
     const existingToken = readToken();
     if (existingToken) {
-      console.log("You are already logged in. Run `trace auth logout` first to re-authenticate.");
+      console.log(
+        `${colorWarning("You are already logged in.")} Run \`trace auth logout\` first to re-authenticate.`
+      );
       return;
     }
     const clientId = getClientId();
     console.log("Initiating device authorization...\n");
     const auth = await requestDeviceAuthorization(clientId);
     console.log("Your one-time code is:\n");
-    console.log(`  ${auth.user_code}
+    console.log(`  ${colorAccentBold(auth.user_code)}
 `);
-    console.log(`Open this URL in your browser: ${auth.verification_uri}`);
+    console.log(`Open this URL in your browser: ${colorAccentUnderline(auth.verification_uri)}`);
     console.log("");
     const opened = await openBrowser(auth.verification_uri_complete);
     if (opened) {
-      console.log("A browser window has been opened for you.");
+      console.log(colorSuccess("A browser window has been opened for you."));
     } else {
-      console.log(`Or visit: ${auth.verification_uri_complete}`);
+      console.log(`Or visit: ${colorAccentUnderline(auth.verification_uri_complete)}`);
     }
     console.log("\nWaiting for authorization...");
     const tokenResponse = await pollForToken(clientId, auth.device_code, {
@@ -25356,9 +26690,11 @@ Examples:
     writeTokens(tokenResponse.access_token, tokenResponse.refresh_token);
     const name = [tokenResponse.user.first_name, tokenResponse.user.last_name].filter(Boolean).join(" ");
     const displayName = name || tokenResponse.user.email;
-    console.log(`
-Authenticated as ${displayName} (${tokenResponse.user.email})`);
-    console.log("Tokens saved to ~/.trace");
+    console.log(
+      `
+${colorSuccess(`Authenticated as ${displayName} (${tokenResponse.user.email})`)}`
+    );
+    console.log(colorSuccess("Tokens saved to ~/.trace"));
   });
 }
 function createLogoutCommand() {
@@ -25370,9 +26706,11 @@ Examples:
   ).action(() => {
     const removed = removeToken();
     if (removed) {
-      console.log("Logged out successfully. Local session data removed from ~/.trace/");
+      console.log(
+        colorSuccess("Logged out successfully. Local session data removed from ~/.trace/")
+      );
     } else {
-      console.log("No active session found.");
+      console.log(colorWarning("No active session found."));
     }
   });
 }
@@ -25437,7 +26775,7 @@ Examples:
       return;
     }
     if (!info.loggedIn) {
-      console.log("Not logged in. Run `tracecli auth login` to authenticate.");
+      console.log(colorError("Not logged in. Run `tracecli auth login` to authenticate."));
       return;
     }
     console.log("Logged in to Trace");
@@ -25451,7 +26789,9 @@ Examples:
       console.log(`  Active Org (CLI): ${info.activeOrg}`);
     }
     if (info.expires) {
-      console.log(`  Expires: ${info.expires}${info.expired ? " (EXPIRED)" : ""}`);
+      console.log(
+        info.expired ? `  Expires: ${info.expires} ${colorError("(EXPIRED)")}` : `  Expires: ${info.expires}`
+      );
     }
     console.log(
       `  Refresh: ${info.hasRefreshToken ? "Available (auto-refresh enabled)" : "Not available"}`
@@ -25637,10 +26977,6 @@ function createAuthCommand() {
 }
 
 // src/banner.ts
-var ESC = "\x1B";
-var RESET = `${ESC}[0m`;
-var CYAN_BOLD = `${ESC}[1;36m`;
-var DIM = `${ESC}[2m`;
 var BANNER = `
  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
  \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
@@ -25650,8 +26986,8 @@ var BANNER = `
     \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 `;
 function showBanner() {
-  console.log(`${CYAN_BOLD}${BANNER}${RESET}`);
-  console.log(`${DIM}  Continuous security vulnerability intelligence${RESET}
+  console.log(colorBanner(BANNER));
+  console.log(`${colorMuted("  Continuous security vulnerability intelligence")}
 `);
 }
 
@@ -25665,7 +27001,7 @@ function extractCommandTree(cmd) {
     description: o.description,
     takesValue: o.required || o.optional
   }));
-  const subcommands = cmd.commands.filter((c25) => !c25._hidden).map((c25) => extractCommandTree(c25));
+  const subcommands = cmd.commands.filter((c26) => !c26._hidden).map((c26) => extractCommandTree(c26));
   return {
     name: cmd.name(),
     description: cmd.description(),
@@ -25731,7 +27067,7 @@ function generateBashCompletion(tree, binName) {
 }
 function collectBashCases(tree, prefix) {
   const cases = /* @__PURE__ */ new Map();
-  const subcommandNames = tree.subcommands.map((c25) => c25.name);
+  const subcommandNames = tree.subcommands.map((c26) => c26.name);
   const optionNames = tree.options.flatMap((o) => o.short ? [o.long, o.short] : [o.long]);
   const extraOptions = prefix === "" ? ["--help", "--version"] : ["--help"];
   const allOptions = [.../* @__PURE__ */ new Set([...optionNames, ...extraOptions])];
@@ -25900,7 +27236,7 @@ function buildFishCondition(binName, parentPath) {
   if (parentPath.length === 1) {
     return `-n '__fish_seen_subcommand_from ${parentPath[0]}'`;
   }
-  const conditions = parentPath.map((p) => `__fish_seen_subcommand_from ${p}`);
+  const conditions = parentPath.map((p2) => `__fish_seen_subcommand_from ${p2}`);
   return `-n '${conditions.join("; and ")}'`;
 }
 function generateCompletion(program3, shell, binName) {
@@ -25931,14 +27267,14 @@ function completionFileName(shell) {
       return "tracecli-completion.fish";
   }
 }
-function getTraceDir() {
+function getTraceDir2() {
   return join2(homedir2(), TRACE_DIR);
 }
 function getCompletionFilePath(shell) {
-  return join2(getTraceDir(), completionFileName(shell));
+  return join2(getTraceDir2(), completionFileName(shell));
 }
 function writeCompletionFile(shell, script) {
-  const dir = getTraceDir();
+  const dir = getTraceDir2();
   if (!existsSync2(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
@@ -26018,6 +27354,33 @@ function createCompletionCommand(program3) {
   });
 }
 
+// src/metadata.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_PACKAGE_NAME = "securewithtrace";
+var DEFAULT_VERSION = "0.0.1";
+function readPackageMetadata() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const packageJsonPath = join3(dirname(currentFilePath), "..", "package.json");
+  try {
+    const rawPackageJson = readFileSync2(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(rawPackageJson);
+    if (typeof parsed !== "object" || parsed === null) {
+      return { name: DEFAULT_PACKAGE_NAME, version: DEFAULT_VERSION };
+    }
+    const metadata = parsed;
+    const name = typeof metadata.name === "string" && metadata.name.trim().length > 0 ? metadata.name : DEFAULT_PACKAGE_NAME;
+    const version2 = typeof metadata.version === "string" && metadata.version.trim().length > 0 ? metadata.version : DEFAULT_VERSION;
+    return { name, version: version2 };
+  } catch {
+    return { name: DEFAULT_PACKAGE_NAME, version: DEFAULT_VERSION };
+  }
+}
+var packageMetadata = readPackageMetadata();
+var CLI_PACKAGE_NAME = packageMetadata.name;
+var CLI_VERSION = packageMetadata.version;
+
 // src/pentest/commands.ts
 var DEFAULT_LIMIT = 30;
 var MAX_LIMIT = 100;
@@ -26028,8 +27391,8 @@ function formatDate(date5) {
   if (!date5) {
     return "\u2014";
   }
-  const d = typeof date5 === "string" ? new Date(date5) : date5;
-  return d.toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
+  const d3 = typeof date5 === "string" ? new Date(date5) : date5;
+  return d3.toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
 }
 function formatFindingSeverity(severity) {
   switch (severity) {
@@ -26073,7 +27436,7 @@ async function resolvePentestId(organizationId, identifier) {
     console.error(`Failed to list pentests (status ${result.status}).`);
     process.exit(1);
   }
-  const pentest = result.body.find((p) => p.displayId === displayId);
+  const pentest = result.body.find((p2) => p2.displayId === displayId);
   if (!pentest) {
     console.error(
       `Pentest with display ID ${displayId} not found.
@@ -26236,10 +27599,11 @@ Examples:
 `);
     for (const finding of sorted) {
       const sev = formatFindingSeverity(finding.severity);
+      const severityLabel = colorSeverity(finding.severity, sev);
       const status = formatStatus(finding.status);
       const cwes = finding.cweIds.length > 0 ? ` | ${finding.cweIds.join(", ")}` : "";
       const score = finding.cvssScore != null ? ` | CVSS ${finding.cvssScore.toFixed(1)}` : "";
-      console.log(`  [${sev}] ${finding.title}`);
+      console.log(`  [${severityLabel}] ${finding.title}`);
       console.log(`         ${finding.category} \xB7 ${status}${cwes}${score}`);
       if (finding.repositories.length > 0) {
         for (const repo of finding.repositories) {
@@ -26266,12 +27630,12 @@ function createPentestCommand() {
 // src/repo/commands.ts
 import { chmodSync, mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function stripAnsi(str) {
   const ESC2 = String.fromCharCode(27);
-  const CSI = String.fromCharCode(155);
+  const CSI2 = String.fromCharCode(155);
   const BEL = String.fromCharCode(7);
-  const csi = `[${ESC2}${CSI}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`;
+  const csi = `[${ESC2}${CSI2}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`;
   const osc = `${ESC2}\\].*?(?:${BEL}|${ESC2}\\\\)`;
   const pattern = new RegExp(`${osc}|${csi}`, "g");
   return str.replace(pattern, "");
@@ -26838,8 +28202,8 @@ function urlWithUsername(httpsUrl) {
   return url2.toString();
 }
 function createAskPassScript() {
-  const dir = mkdtempSync(join3(tmpdir(), "trace-askpass-"));
-  const scriptPath = join3(dir, "askpass.sh");
+  const dir = mkdtempSync(join4(tmpdir(), "trace-askpass-"));
+  const scriptPath = join4(dir, "askpass.sh");
   writeFileSync3(
     scriptPath,
     `#!/bin/sh
@@ -27007,6 +28371,311 @@ function createRepoCommand() {
   return repo;
 }
 
+// src/update/commands.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
+import { createInterface as createInterface3 } from "readline/promises";
+var UPDATE_CACHE_FILE = "update-check.json";
+var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_CHECK_TIMEOUT_MS = 1500;
+var DISABLE_UPDATE_NOTIFIER_ENV = "TRACECLI_DISABLE_UPDATE_NOTIFIER";
+var REGISTRY_URL_ENV = "TRACECLI_NPM_REGISTRY_URL";
+var noticePrinted = false;
+function getUpdateCheckCachePath() {
+  return join5(getTraceDir(), UPDATE_CACHE_FILE);
+}
+function readUpdateCheckCache() {
+  const cachePath = getUpdateCheckCachePath();
+  if (!existsSync3(cachePath)) {
+    return null;
+  }
+  try {
+    const rawCache = readFileSync3(cachePath, "utf-8");
+    const parsed = JSON.parse(rawCache);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const cache = parsed;
+    if (typeof cache.checkedAt !== "number" || !Number.isFinite(cache.checkedAt)) {
+      return null;
+    }
+    if (typeof cache.latestVersion === "string" && cache.latestVersion.trim().length > 0) {
+      return { checkedAt: cache.checkedAt, latestVersion: cache.latestVersion };
+    }
+    return { checkedAt: cache.checkedAt };
+  } catch {
+    return null;
+  }
+}
+function writeUpdateCheckCache(cache) {
+  const cachePath = getUpdateCheckCachePath();
+  mkdirSync3(dirname2(cachePath), { recursive: true, mode: 448 });
+  writeFileSync4(cachePath, `${JSON.stringify(cache, null, 2)}
+`, {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function parseSemver(version2) {
+  const normalized = version2.trim();
+  const match = normalized.match(
+    /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-.]+)?$/
+  );
+  if (!match?.[1] || !match[2] || !match[3]) {
+    return null;
+  }
+  const major = Number.parseInt(match[1], 10);
+  const minor = Number.parseInt(match[2], 10);
+  const patch = Number.parseInt(match[3], 10);
+  if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch)) {
+    return null;
+  }
+  const prerelease = match[4] ? match[4].split(".") : [];
+  return { major, minor, patch, prerelease };
+}
+function comparePrerelease(a, b) {
+  const maxLength = Math.max(a.length, b.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const aPart = a[index];
+    const bPart = b[index];
+    if (aPart === void 0 && bPart === void 0) {
+      return 0;
+    }
+    if (aPart === void 0) {
+      return -1;
+    }
+    if (bPart === void 0) {
+      return 1;
+    }
+    const aIsNumeric = /^\d+$/.test(aPart);
+    const bIsNumeric = /^\d+$/.test(bPart);
+    if (aIsNumeric && bIsNumeric) {
+      const aValue = Number.parseInt(aPart, 10);
+      const bValue = Number.parseInt(bPart, 10);
+      if (aValue !== bValue) {
+        return aValue > bValue ? 1 : -1;
+      }
+      continue;
+    }
+    if (aIsNumeric) {
+      return -1;
+    }
+    if (bIsNumeric) {
+      return 1;
+    }
+    if (aPart !== bPart) {
+      return aPart > bPart ? 1 : -1;
+    }
+  }
+  return 0;
+}
+function compareSemver(a, b) {
+  const aSemver = parseSemver(a);
+  const bSemver = parseSemver(b);
+  if (!aSemver || !bSemver) {
+    return null;
+  }
+  if (aSemver.major !== bSemver.major) {
+    return aSemver.major > bSemver.major ? 1 : -1;
+  }
+  if (aSemver.minor !== bSemver.minor) {
+    return aSemver.minor > bSemver.minor ? 1 : -1;
+  }
+  if (aSemver.patch !== bSemver.patch) {
+    return aSemver.patch > bSemver.patch ? 1 : -1;
+  }
+  if (aSemver.prerelease.length === 0 && bSemver.prerelease.length === 0) {
+    return 0;
+  }
+  if (aSemver.prerelease.length === 0) {
+    return 1;
+  }
+  if (bSemver.prerelease.length === 0) {
+    return -1;
+  }
+  return comparePrerelease(aSemver.prerelease, bSemver.prerelease);
+}
+function isVersionNewer(currentVersion, candidateVersion) {
+  const comparison = compareSemver(candidateVersion, currentVersion);
+  return comparison !== null && comparison > 0;
+}
+function resolveRegistryUrl() {
+  const override = process.env[REGISTRY_URL_ENV];
+  if (typeof override === "string" && override.trim().length > 0) {
+    return override;
+  }
+  return `https://registry.npmjs.org/${encodeURIComponent(CLI_PACKAGE_NAME)}/latest`;
+}
+function extractLatestVersionFromRegistryPayload(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return null;
+  }
+  if ("version" in payload && typeof payload.version === "string" && payload.version.trim().length > 0) {
+    return payload.version;
+  }
+  return null;
+}
+async function fetchLatestVersionFromRegistry() {
+  try {
+    const response = await fetch(resolveRegistryUrl(), {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const payload = await response.json();
+    return extractLatestVersionFromRegistryPayload(payload);
+  } catch {
+    return null;
+  }
+}
+async function getLatestVersion(forceRefresh) {
+  const now = Date.now();
+  const cached2 = readUpdateCheckCache();
+  if (!forceRefresh && cached2 && now - cached2.checkedAt < UPDATE_CHECK_TTL_MS) {
+    return cached2.latestVersion ?? null;
+  }
+  const latestVersion = await fetchLatestVersionFromRegistry();
+  if (latestVersion) {
+    writeUpdateCheckCache({ checkedAt: now, latestVersion });
+    return latestVersion;
+  }
+  if (cached2?.latestVersion) {
+    writeUpdateCheckCache({ checkedAt: now, latestVersion: cached2.latestVersion });
+    return cached2.latestVersion;
+  }
+  writeUpdateCheckCache({ checkedAt: now });
+  return null;
+}
+async function getUpdateAvailability(forceRefresh) {
+  const latestVersion = await getLatestVersion(forceRefresh);
+  return {
+    currentVersion: CLI_VERSION,
+    latestVersion,
+    isUpdateAvailable: latestVersion ? isVersionNewer(CLI_VERSION, latestVersion) : false
+  };
+}
+function shouldSkipUpdateNotifier(commandName) {
+  if (process.env[DISABLE_UPDATE_NOTIFIER_ENV] === "1") {
+    return true;
+  }
+  if (process.env["CI"] === "true") {
+    return true;
+  }
+  if (!process.stdout.isTTY) {
+    return true;
+  }
+  if (commandName === "upgrade") {
+    return true;
+  }
+  return false;
+}
+async function maybeNotifyUpdateAvailable(commandName) {
+  if (noticePrinted || shouldSkipUpdateNotifier(commandName)) {
+    return;
+  }
+  const availability = await getUpdateAvailability(false);
+  if (!availability.isUpdateAvailable || !availability.latestVersion) {
+    return;
+  }
+  noticePrinted = true;
+  console.error("");
+  console.error(
+    `A new tracecli version is available: ${availability.currentVersion} -> ${availability.latestVersion}`
+  );
+  console.error("Run `tracecli upgrade` to install the latest version.");
+  console.error("");
+}
+function resolveUpgradePlan() {
+  const packageSpec = `${CLI_PACKAGE_NAME}@latest`;
+  if (Bun.which("npm")) {
+    return { command: "npm", args: ["install", "-g", packageSpec] };
+  }
+  if (Bun.which("bun")) {
+    return { command: "bun", args: ["add", "-g", packageSpec] };
+  }
+  if (Bun.which("pnpm")) {
+    return { command: "pnpm", args: ["add", "-g", packageSpec] };
+  }
+  return null;
+}
+async function promptForUpgradeConfirmation(latestVersion) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return true;
+  }
+  const readline = createInterface3({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const input = await readline.question(`Install tracecli ${latestVersion} now? [Y/n] `);
+    const normalized = input.trim().toLowerCase();
+    if (normalized === "n" || normalized === "no") {
+      return false;
+    }
+    return true;
+  } finally {
+    readline.close();
+  }
+}
+function createUpgradeCommand() {
+  return new Command("upgrade").alias("self-update").description("Upgrade tracecli to the latest version").option("--check", "Check whether an update is available").option("-y, --yes", "Skip upgrade confirmation prompt").addHelpText(
+    "after",
+    `
+Examples:
+  tracecli upgrade
+  tracecli upgrade --check
+  tracecli self-update`
+  ).action(async (options) => {
+    const availability = await getUpdateAvailability(true);
+    if (availability.latestVersion) {
+      if (availability.isUpdateAvailable) {
+        console.log(
+          `Update available: ${availability.currentVersion} -> ${availability.latestVersion}`
+        );
+      } else {
+        console.log(`tracecli is up to date (${availability.currentVersion}).`);
+        return;
+      }
+    } else {
+      console.warn(
+        "Could not determine the latest published version from npm. Proceeding with best-effort upgrade."
+      );
+    }
+    if (options.check) {
+      return;
+    }
+    const versionLabel = availability.latestVersion ?? "the latest available version";
+    const shouldUpgrade = options.yes ? true : await promptForUpgradeConfirmation(versionLabel);
+    if (!shouldUpgrade) {
+      console.log("Upgrade cancelled.");
+      return;
+    }
+    const plan = resolveUpgradePlan();
+    if (!plan) {
+      console.error(
+        `No supported package manager found (npm, bun, pnpm). Install the latest version manually from https://www.npmjs.com/package/${CLI_PACKAGE_NAME}`
+      );
+      process.exit(1);
+    }
+    console.log(`Running: ${plan.command} ${plan.args.join(" ")}`);
+    const proc = Bun.spawn([plan.command, ...plan.args], {
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      console.error(
+        `Upgrade failed while running '${plan.command} ${plan.args.join(" ")}' (exit code ${exitCode}).`
+      );
+      process.exit(1);
+    }
+    console.log("tracecli upgrade completed.");
+    console.log("Run `tracecli --version` to verify the installed version.");
+  });
+}
+
 // src/vulnerabilities/commands.ts
 var DEFAULT_LIMIT3 = 30;
 var MAX_LIMIT3 = 100;
@@ -27076,11 +28745,12 @@ function printVulnerabilities(vulnerabilities) {
   );
   for (const vuln of sorted) {
     const sev = formatSeverity(vuln.severity);
+    const displaySeverity = colorSeverity(vuln.severity, sev);
     const status = formatStatus(vuln.status);
     const repo = vuln.repositoryName;
     const file2 = vuln.codeSnippet.filePath;
     const line = vuln.codeSnippet.startLine;
-    console.log(`  [${sev}] ${vuln.title}`);
+    console.log(`  [${displaySeverity}] ${vuln.title}`);
     console.log(`         ${repo} \xB7 ${file2}:${line} \xB7 ${status}`);
     console.log(`         ${vuln.traceId}`);
     console.log("");
@@ -27215,7 +28885,10 @@ function createVulnerabilitiesCommand() {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("tracecli").description("Trace CLI").version("0.0.1");
+program2.name("tracecli").description("Trace CLI").version(CLI_VERSION);
+program2.hook("preAction", async (_thisCommand, actionCommand) => {
+  await maybeNotifyUpdateAvailable(actionCommand.name());
+});
 program2.action(() => {
   showBanner();
   program2.outputHelp();
@@ -27226,4 +28899,5 @@ program2.addCommand(createRepoCommand());
 program2.addCommand(createVulnerabilitiesCommand());
 program2.addCommand(createPentestCommand());
 program2.addCommand(createCompletionCommand(program2));
-program2.parse();
+program2.addCommand(createUpgradeCommand());
+await program2.parseAsync();