genlayer 0.32.4 → 0.32.6

package/dist/index.js

@@ -18254,11 +18254,1831 @@ var require_semver2 = __commonJS({
   }
 });
 
+// node_modules/cli-table3/src/debug.js
+var require_debug2 = __commonJS({
+  "node_modules/cli-table3/src/debug.js"(exports, module) {
+    "use strict";
+    var messages = [];
+    var level = 0;
+    var debug = (msg, min) => {
+      if (level >= min) {
+        messages.push(msg);
+      }
+    };
+    debug.WARN = 1;
+    debug.INFO = 2;
+    debug.DEBUG = 3;
+    debug.reset = () => {
+      messages = [];
+    };
+    debug.setDebugLevel = (v) => {
+      level = v;
+    };
+    debug.warn = (msg) => debug(msg, debug.WARN);
+    debug.info = (msg) => debug(msg, debug.INFO);
+    debug.debug = (msg) => debug(msg, debug.DEBUG);
+    debug.debugMessages = () => messages;
+    module.exports = debug;
+  }
+});
+
+// node_modules/cli-table3/node_modules/ansi-regex/index.js
+var require_ansi_regex = __commonJS({
+  "node_modules/cli-table3/node_modules/ansi-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = ({ onlyFirst = false } = {}) => {
+      const pattern = [
+        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+      ].join("|");
+      return new RegExp(pattern, onlyFirst ? void 0 : "g");
+    };
+  }
+});
+
+// node_modules/cli-table3/node_modules/strip-ansi/index.js
+var require_strip_ansi = __commonJS({
+  "node_modules/cli-table3/node_modules/strip-ansi/index.js"(exports, module) {
+    "use strict";
+    var ansiRegex2 = require_ansi_regex();
+    module.exports = (string) => typeof string === "string" ? string.replace(ansiRegex2(), "") : string;
+  }
+});
+
+// node_modules/is-fullwidth-code-point/index.js
+var require_is_fullwidth_code_point = __commonJS({
+  "node_modules/is-fullwidth-code-point/index.js"(exports, module) {
+    "use strict";
+    var isFullwidthCodePoint = (codePoint) => {
+      if (Number.isNaN(codePoint)) {
+        return false;
+      }
+      if (codePoint >= 4352 && (codePoint <= 4447 || // Hangul Jamo
+      codePoint === 9001 || // LEFT-POINTING ANGLE BRACKET
+      codePoint === 9002 || // RIGHT-POINTING ANGLE BRACKET
+      // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+      11904 <= codePoint && codePoint <= 12871 && codePoint !== 12351 || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+      12880 <= codePoint && codePoint <= 19903 || // CJK Unified Ideographs .. Yi Radicals
+      19968 <= codePoint && codePoint <= 42182 || // Hangul Jamo Extended-A
+      43360 <= codePoint && codePoint <= 43388 || // Hangul Syllables
+      44032 <= codePoint && codePoint <= 55203 || // CJK Compatibility Ideographs
+      63744 <= codePoint && codePoint <= 64255 || // Vertical Forms
+      65040 <= codePoint && codePoint <= 65049 || // CJK Compatibility Forms .. Small Form Variants
+      65072 <= codePoint && codePoint <= 65131 || // Halfwidth and Fullwidth Forms
+      65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510 || // Kana Supplement
+      110592 <= codePoint && codePoint <= 110593 || // Enclosed Ideographic Supplement
+      127488 <= codePoint && codePoint <= 127569 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+      131072 <= codePoint && codePoint <= 262141)) {
+        return true;
+      }
+      return false;
+    };
+    module.exports = isFullwidthCodePoint;
+    module.exports.default = isFullwidthCodePoint;
+  }
+});
+
+// node_modules/cli-table3/node_modules/emoji-regex/index.js
+var require_emoji_regex2 = __commonJS({
+  "node_modules/cli-table3/node_modules/emoji-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = function() {
+      return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
+    };
+  }
+});
+
+// node_modules/cli-table3/node_modules/string-width/index.js
+var require_string_width = __commonJS({
+  "node_modules/cli-table3/node_modules/string-width/index.js"(exports, module) {
+    "use strict";
+    var stripAnsi2 = require_strip_ansi();
+    var isFullwidthCodePoint = require_is_fullwidth_code_point();
+    var emojiRegex2 = require_emoji_regex2();
+    var stringWidth2 = (string) => {
+      if (typeof string !== "string" || string.length === 0) {
+        return 0;
+      }
+      string = stripAnsi2(string);
+      if (string.length === 0) {
+        return 0;
+      }
+      string = string.replace(emojiRegex2(), "  ");
+      let width = 0;
+      for (let i2 = 0; i2 < string.length; i2++) {
+        const code = string.codePointAt(i2);
+        if (code <= 31 || code >= 127 && code <= 159) {
+          continue;
+        }
+        if (code >= 768 && code <= 879) {
+          continue;
+        }
+        if (code > 65535) {
+          i2++;
+        }
+        width += isFullwidthCodePoint(code) ? 2 : 1;
+      }
+      return width;
+    };
+    module.exports = stringWidth2;
+    module.exports.default = stringWidth2;
+  }
+});
+
+// node_modules/cli-table3/src/utils.js
+var require_utils = __commonJS({
+  "node_modules/cli-table3/src/utils.js"(exports, module) {
+    "use strict";
+    var stringWidth2 = require_string_width();
+    function codeRegex(capture) {
+      return capture ? /\u001b\[((?:\d*;){0,5}\d*)m/g : /\u001b\[(?:\d*;){0,5}\d*m/g;
+    }
+    function strlen(str) {
+      let code = codeRegex();
+      let stripped = ("" + str).replace(code, "");
+      let split3 = stripped.split("\n");
+      return split3.reduce(function(memo, s2) {
+        return stringWidth2(s2) > memo ? stringWidth2(s2) : memo;
+      }, 0);
+    }
+    function repeat(str, times) {
+      return Array(times + 1).join(str);
+    }
+    function pad4(str, len, pad5, dir) {
+      let length = strlen(str);
+      if (len + 1 >= length) {
+        let padlen = len - length;
+        switch (dir) {
+          case "right": {
+            str = repeat(pad5, padlen) + str;
+            break;
+          }
+          case "center": {
+            let right = Math.ceil(padlen / 2);
+            let left = padlen - right;
+            str = repeat(pad5, left) + str + repeat(pad5, right);
+            break;
+          }
+          default: {
+            str = str + repeat(pad5, padlen);
+            break;
+          }
+        }
+      }
+      return str;
+    }
+    var codeCache = {};
+    function addToCodeCache(name, on, off) {
+      on = "\x1B[" + on + "m";
+      off = "\x1B[" + off + "m";
+      codeCache[on] = { set: name, to: true };
+      codeCache[off] = { set: name, to: false };
+      codeCache[name] = { on, off };
+    }
+    addToCodeCache("bold", 1, 22);
+    addToCodeCache("italics", 3, 23);
+    addToCodeCache("underline", 4, 24);
+    addToCodeCache("inverse", 7, 27);
+    addToCodeCache("strikethrough", 9, 29);
+    function updateState(state, controlChars) {
+      let controlCode = controlChars[1] ? parseInt(controlChars[1].split(";")[0]) : 0;
+      if (controlCode >= 30 && controlCode <= 39 || controlCode >= 90 && controlCode <= 97) {
+        state.lastForegroundAdded = controlChars[0];
+        return;
+      }
+      if (controlCode >= 40 && controlCode <= 49 || controlCode >= 100 && controlCode <= 107) {
+        state.lastBackgroundAdded = controlChars[0];
+        return;
+      }
+      if (controlCode === 0) {
+        for (let i2 in state) {
+          if (Object.prototype.hasOwnProperty.call(state, i2)) {
+            delete state[i2];
+          }
+        }
+        return;
+      }
+      let info = codeCache[controlChars[0]];
+      if (info) {
+        state[info.set] = info.to;
+      }
+    }
+    function readState(line) {
+      let code = codeRegex(true);
+      let controlChars = code.exec(line);
+      let state = {};
+      while (controlChars !== null) {
+        updateState(state, controlChars);
+        controlChars = code.exec(line);
+      }
+      return state;
+    }
+    function unwindState(state, ret) {
+      let lastBackgroundAdded = state.lastBackgroundAdded;
+      let lastForegroundAdded = state.lastForegroundAdded;
+      delete state.lastBackgroundAdded;
+      delete state.lastForegroundAdded;
+      Object.keys(state).forEach(function(key) {
+        if (state[key]) {
+          ret += codeCache[key].off;
+        }
+      });
+      if (lastBackgroundAdded && lastBackgroundAdded != "\x1B[49m") {
+        ret += "\x1B[49m";
+      }
+      if (lastForegroundAdded && lastForegroundAdded != "\x1B[39m") {
+        ret += "\x1B[39m";
+      }
+      return ret;
+    }
+    function rewindState(state, ret) {
+      let lastBackgroundAdded = state.lastBackgroundAdded;
+      let lastForegroundAdded = state.lastForegroundAdded;
+      delete state.lastBackgroundAdded;
+      delete state.lastForegroundAdded;
+      Object.keys(state).forEach(function(key) {
+        if (state[key]) {
+          ret = codeCache[key].on + ret;
+        }
+      });
+      if (lastBackgroundAdded && lastBackgroundAdded != "\x1B[49m") {
+        ret = lastBackgroundAdded + ret;
+      }
+      if (lastForegroundAdded && lastForegroundAdded != "\x1B[39m") {
+        ret = lastForegroundAdded + ret;
+      }
+      return ret;
+    }
+    function truncateWidth(str, desiredLength) {
+      if (str.length === strlen(str)) {
+        return str.substr(0, desiredLength);
+      }
+      while (strlen(str) > desiredLength) {
+        str = str.slice(0, -1);
+      }
+      return str;
+    }
+    function truncateWidthWithAnsi(str, desiredLength) {
+      let code = codeRegex(true);
+      let split3 = str.split(codeRegex());
+      let splitIndex = 0;
+      let retLen = 0;
+      let ret = "";
+      let myArray;
+      let state = {};
+      while (retLen < desiredLength) {
+        myArray = code.exec(str);
+        let toAdd = split3[splitIndex];
+        splitIndex++;
+        if (retLen + strlen(toAdd) > desiredLength) {
+          toAdd = truncateWidth(toAdd, desiredLength - retLen);
+        }
+        ret += toAdd;
+        retLen += strlen(toAdd);
+        if (retLen < desiredLength) {
+          if (!myArray) {
+            break;
+          }
+          ret += myArray[0];
+          updateState(state, myArray);
+        }
+      }
+      return unwindState(state, ret);
+    }
+    function truncate(str, desiredLength, truncateChar) {
+      truncateChar = truncateChar || "\u2026";
+      let lengthOfStr = strlen(str);
+      if (lengthOfStr <= desiredLength) {
+        return str;
+      }
+      desiredLength -= strlen(truncateChar);
+      let ret = truncateWidthWithAnsi(str, desiredLength);
+      ret += truncateChar;
+      const hrefTag = "\x1B]8;;\x07";
+      if (str.includes(hrefTag) && !ret.includes(hrefTag)) {
+        ret += hrefTag;
+      }
+      return ret;
+    }
+    function defaultOptions() {
+      return {
+        chars: {
+          top: "\u2500",
+          "top-mid": "\u252C",
+          "top-left": "\u250C",
+          "top-right": "\u2510",
+          bottom: "\u2500",
+          "bottom-mid": "\u2534",
+          "bottom-left": "\u2514",
+          "bottom-right": "\u2518",
+          left: "\u2502",
+          "left-mid": "\u251C",
+          mid: "\u2500",
+          "mid-mid": "\u253C",
+          right: "\u2502",
+          "right-mid": "\u2524",
+          middle: "\u2502"
+        },
+        truncate: "\u2026",
+        colWidths: [],
+        rowHeights: [],
+        colAligns: [],
+        rowAligns: [],
+        style: {
+          "padding-left": 1,
+          "padding-right": 1,
+          head: ["red"],
+          border: ["grey"],
+          compact: false
+        },
+        head: []
+      };
+    }
+    function mergeOptions(options, defaults) {
+      options = options || {};
+      defaults = defaults || defaultOptions();
+      let ret = Object.assign({}, defaults, options);
+      ret.chars = Object.assign({}, defaults.chars, options.chars);
+      ret.style = Object.assign({}, defaults.style, options.style);
+      return ret;
+    }
+    function wordWrap(maxLength, input) {
+      let lines = [];
+      let split3 = input.split(/(\s+)/g);
+      let line = [];
+      let lineLength = 0;
+      let whitespace;
+      for (let i2 = 0; i2 < split3.length; i2 += 2) {
+        let word = split3[i2];
+        let newLength = lineLength + strlen(word);
+        if (lineLength > 0 && whitespace) {
+          newLength += whitespace.length;
+        }
+        if (newLength > maxLength) {
+          if (lineLength !== 0) {
+            lines.push(line.join(""));
+          }
+          line = [word];
+          lineLength = strlen(word);
+        } else {
+          line.push(whitespace || "", word);
+          lineLength = newLength;
+        }
+        whitespace = split3[i2 + 1];
+      }
+      if (lineLength) {
+        lines.push(line.join(""));
+      }
+      return lines;
+    }
+    function textWrap(maxLength, input) {
+      let lines = [];
+      let line = "";
+      function pushLine(str, ws) {
+        if (line.length && ws) line += ws;
+        line += str;
+        while (line.length > maxLength) {
+          lines.push(line.slice(0, maxLength));
+          line = line.slice(maxLength);
+        }
+      }
+      let split3 = input.split(/(\s+)/g);
+      for (let i2 = 0; i2 < split3.length; i2 += 2) {
+        pushLine(split3[i2], i2 && split3[i2 - 1]);
+      }
+      if (line.length) lines.push(line);
+      return lines;
+    }
+    function multiLineWordWrap(maxLength, input, wrapOnWordBoundary = true) {
+      let output = [];
+      input = input.split("\n");
+      const handler = wrapOnWordBoundary ? wordWrap : textWrap;
+      for (let i2 = 0; i2 < input.length; i2++) {
+        output.push.apply(output, handler(maxLength, input[i2]));
+      }
+      return output;
+    }
+    function colorizeLines(input) {
+      let state = {};
+      let output = [];
+      for (let i2 = 0; i2 < input.length; i2++) {
+        let line = rewindState(state, input[i2]);
+        state = readState(line);
+        let temp = Object.assign({}, state);
+        output.push(unwindState(temp, line));
+      }
+      return output;
+    }
+    function hyperlink(url, text) {
+      const OSC = "\x1B]";
+      const BEL = "\x07";
+      const SEP = ";";
+      return [OSC, "8", SEP, SEP, url || text, BEL, text, OSC, "8", SEP, SEP, BEL].join("");
+    }
+    module.exports = {
+      strlen,
+      repeat,
+      pad: pad4,
+      truncate,
+      mergeOptions,
+      wordWrap: multiLineWordWrap,
+      colorizeLines,
+      hyperlink
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/styles.js
+var require_styles = __commonJS({
+  "node_modules/@colors/colors/lib/styles.js"(exports, module) {
+    "use strict";
+    var styles3 = {};
+    module["exports"] = styles3;
+    var codes = {
+      reset: [0, 0],
+      bold: [1, 22],
+      dim: [2, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      inverse: [7, 27],
+      hidden: [8, 28],
+      strikethrough: [9, 29],
+      black: [30, 39],
+      red: [31, 39],
+      green: [32, 39],
+      yellow: [33, 39],
+      blue: [34, 39],
+      magenta: [35, 39],
+      cyan: [36, 39],
+      white: [37, 39],
+      gray: [90, 39],
+      grey: [90, 39],
+      brightRed: [91, 39],
+      brightGreen: [92, 39],
+      brightYellow: [93, 39],
+      brightBlue: [94, 39],
+      brightMagenta: [95, 39],
+      brightCyan: [96, 39],
+      brightWhite: [97, 39],
+      bgBlack: [40, 49],
+      bgRed: [41, 49],
+      bgGreen: [42, 49],
+      bgYellow: [43, 49],
+      bgBlue: [44, 49],
+      bgMagenta: [45, 49],
+      bgCyan: [46, 49],
+      bgWhite: [47, 49],
+      bgGray: [100, 49],
+      bgGrey: [100, 49],
+      bgBrightRed: [101, 49],
+      bgBrightGreen: [102, 49],
+      bgBrightYellow: [103, 49],
+      bgBrightBlue: [104, 49],
+      bgBrightMagenta: [105, 49],
+      bgBrightCyan: [106, 49],
+      bgBrightWhite: [107, 49],
+      // legacy styles for colors pre v1.0.0
+      blackBG: [40, 49],
+      redBG: [41, 49],
+      greenBG: [42, 49],
+      yellowBG: [43, 49],
+      blueBG: [44, 49],
+      magentaBG: [45, 49],
+      cyanBG: [46, 49],
+      whiteBG: [47, 49]
+    };
+    Object.keys(codes).forEach(function(key) {
+      var val = codes[key];
+      var style = styles3[key] = [];
+      style.open = "\x1B[" + val[0] + "m";
+      style.close = "\x1B[" + val[1] + "m";
+    });
+  }
+});
+
+// node_modules/@colors/colors/lib/system/has-flag.js
+var require_has_flag = __commonJS({
+  "node_modules/@colors/colors/lib/system/has-flag.js"(exports, module) {
+    "use strict";
+    module.exports = function(flag, argv) {
+      argv = argv || process.argv;
+      var terminatorPos = argv.indexOf("--");
+      var prefix = /^-{1,2}/.test(flag) ? "" : "--";
+      var pos = argv.indexOf(prefix + flag);
+      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/system/supports-colors.js
+var require_supports_colors = __commonJS({
+  "node_modules/@colors/colors/lib/system/supports-colors.js"(exports, module) {
+    "use strict";
+    var os4 = __require("os");
+    var hasFlag2 = require_has_flag();
+    var env2 = process.env;
+    var forceColor = void 0;
+    if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false")) {
+      forceColor = false;
+    } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
+      forceColor = true;
+    }
+    if ("FORCE_COLOR" in env2) {
+      forceColor = env2.FORCE_COLOR.length === 0 || parseInt(env2.FORCE_COLOR, 10) !== 0;
+    }
+    function translateLevel2(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor2(stream) {
+      if (forceColor === false) {
+        return 0;
+      }
+      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag2("color=256")) {
+        return 2;
+      }
+      if (stream && !stream.isTTY && forceColor !== true) {
+        return 0;
+      }
+      var min = forceColor ? 1 : 0;
+      if (process.platform === "win32") {
+        var osRelease = os4.release().split(".");
+        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env2) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(function(sign2) {
+          return sign2 in env2;
+        }) || env2.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env2) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if ("TERM_PROGRAM" in env2) {
+        var version5 = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env2.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version5 >= 3 ? 3 : 2;
+          case "Hyper":
+            return 3;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env2.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env2) {
+        return 1;
+      }
+      if (env2.TERM === "dumb") {
+        return min;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      var level = supportsColor2(stream);
+      return translateLevel2(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: getSupportLevel(process.stdout),
+      stderr: getSupportLevel(process.stderr)
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/custom/trap.js
+var require_trap = __commonJS({
+  "node_modules/@colors/colors/lib/custom/trap.js"(exports, module) {
+    "use strict";
+    module["exports"] = function runTheTrap(text, options) {
+      var result = "";
+      text = text || "Run the trap, drop the bass";
+      text = text.split("");
+      var trap = {
+        a: ["@", "\u0104", "\u023A", "\u0245", "\u0394", "\u039B", "\u0414"],
+        b: ["\xDF", "\u0181", "\u0243", "\u026E", "\u03B2", "\u0E3F"],
+        c: ["\xA9", "\u023B", "\u03FE"],
+        d: ["\xD0", "\u018A", "\u0500", "\u0501", "\u0502", "\u0503"],
+        e: [
+          "\xCB",
+          "\u0115",
+          "\u018E",
+          "\u0258",
+          "\u03A3",
+          "\u03BE",
+          "\u04BC",
+          "\u0A6C"
+        ],
+        f: ["\u04FA"],
+        g: ["\u0262"],
+        h: ["\u0126", "\u0195", "\u04A2", "\u04BA", "\u04C7", "\u050A"],
+        i: ["\u0F0F"],
+        j: ["\u0134"],
+        k: ["\u0138", "\u04A0", "\u04C3", "\u051E"],
+        l: ["\u0139"],
+        m: ["\u028D", "\u04CD", "\u04CE", "\u0520", "\u0521", "\u0D69"],
+        n: ["\xD1", "\u014B", "\u019D", "\u0376", "\u03A0", "\u048A"],
+        o: [
+          "\xD8",
+          "\xF5",
+          "\xF8",
+          "\u01FE",
+          "\u0298",
+          "\u047A",
+          "\u05DD",
+          "\u06DD",
+          "\u0E4F"
+        ],
+        p: ["\u01F7", "\u048E"],
+        q: ["\u09CD"],
+        r: ["\xAE", "\u01A6", "\u0210", "\u024C", "\u0280", "\u042F"],
+        s: ["\xA7", "\u03DE", "\u03DF", "\u03E8"],
+        t: ["\u0141", "\u0166", "\u0373"],
+        u: ["\u01B1", "\u054D"],
+        v: ["\u05D8"],
+        w: ["\u0428", "\u0460", "\u047C", "\u0D70"],
+        x: ["\u04B2", "\u04FE", "\u04FC", "\u04FD"],
+        y: ["\xA5", "\u04B0", "\u04CB"],
+        z: ["\u01B5", "\u0240"]
+      };
+      text.forEach(function(c) {
+        c = c.toLowerCase();
+        var chars = trap[c] || [" "];
+        var rand = Math.floor(Math.random() * chars.length);
+        if (typeof trap[c] !== "undefined") {
+          result += trap[c][rand];
+        } else {
+          result += c;
+        }
+      });
+      return result;
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/custom/zalgo.js
+var require_zalgo = __commonJS({
+  "node_modules/@colors/colors/lib/custom/zalgo.js"(exports, module) {
+    "use strict";
+    module["exports"] = function zalgo(text, options) {
+      text = text || "   he is here   ";
+      var soul = {
+        "up": [
+          "\u030D",
+          "\u030E",
+          "\u0304",
+          "\u0305",
+          "\u033F",
+          "\u0311",
+          "\u0306",
+          "\u0310",
+          "\u0352",
+          "\u0357",
+          "\u0351",
+          "\u0307",
+          "\u0308",
+          "\u030A",
+          "\u0342",
+          "\u0313",
+          "\u0308",
+          "\u034A",
+          "\u034B",
+          "\u034C",
+          "\u0303",
+          "\u0302",
+          "\u030C",
+          "\u0350",
+          "\u0300",
+          "\u0301",
+          "\u030B",
+          "\u030F",
+          "\u0312",
+          "\u0313",
+          "\u0314",
+          "\u033D",
+          "\u0309",
+          "\u0363",
+          "\u0364",
+          "\u0365",
+          "\u0366",
+          "\u0367",
+          "\u0368",
+          "\u0369",
+          "\u036A",
+          "\u036B",
+          "\u036C",
+          "\u036D",
+          "\u036E",
+          "\u036F",
+          "\u033E",
+          "\u035B",
+          "\u0346",
+          "\u031A"
+        ],
+        "down": [
+          "\u0316",
+          "\u0317",
+          "\u0318",
+          "\u0319",
+          "\u031C",
+          "\u031D",
+          "\u031E",
+          "\u031F",
+          "\u0320",
+          "\u0324",
+          "\u0325",
+          "\u0326",
+          "\u0329",
+          "\u032A",
+          "\u032B",
+          "\u032C",
+          "\u032D",
+          "\u032E",
+          "\u032F",
+          "\u0330",
+          "\u0331",
+          "\u0332",
+          "\u0333",
+          "\u0339",
+          "\u033A",
+          "\u033B",
+          "\u033C",
+          "\u0345",
+          "\u0347",
+          "\u0348",
+          "\u0349",
+          "\u034D",
+          "\u034E",
+          "\u0353",
+          "\u0354",
+          "\u0355",
+          "\u0356",
+          "\u0359",
+          "\u035A",
+          "\u0323"
+        ],
+        "mid": [
+          "\u0315",
+          "\u031B",
+          "\u0300",
+          "\u0301",
+          "\u0358",
+          "\u0321",
+          "\u0322",
+          "\u0327",
+          "\u0328",
+          "\u0334",
+          "\u0335",
+          "\u0336",
+          "\u035C",
+          "\u035D",
+          "\u035E",
+          "\u035F",
+          "\u0360",
+          "\u0362",
+          "\u0338",
+          "\u0337",
+          "\u0361",
+          " \u0489"
+        ]
+      };
+      var all = [].concat(soul.up, soul.down, soul.mid);
+      function randomNumber(range) {
+        var r2 = Math.floor(Math.random() * range);
+        return r2;
+      }
+      function isChar(character) {
+        var bool = false;
+        all.filter(function(i2) {
+          bool = i2 === character;
+        });
+        return bool;
+      }
+      function heComes(text2, options2) {
+        var result = "";
+        var counts;
+        var l;
+        options2 = options2 || {};
+        options2["up"] = typeof options2["up"] !== "undefined" ? options2["up"] : true;
+        options2["mid"] = typeof options2["mid"] !== "undefined" ? options2["mid"] : true;
+        options2["down"] = typeof options2["down"] !== "undefined" ? options2["down"] : true;
+        options2["size"] = typeof options2["size"] !== "undefined" ? options2["size"] : "maxi";
+        text2 = text2.split("");
+        for (l in text2) {
+          if (isChar(l)) {
+            continue;
+          }
+          result = result + text2[l];
+          counts = { "up": 0, "down": 0, "mid": 0 };
+          switch (options2.size) {
+            case "mini":
+              counts.up = randomNumber(8);
+              counts.mid = randomNumber(2);
+              counts.down = randomNumber(8);
+              break;
+            case "maxi":
+              counts.up = randomNumber(16) + 3;
+              counts.mid = randomNumber(4) + 1;
+              counts.down = randomNumber(64) + 3;
+              break;
+            default:
+              counts.up = randomNumber(8) + 1;
+              counts.mid = randomNumber(6) / 2;
+              counts.down = randomNumber(8) + 1;
+              break;
+          }
+          var arr = ["up", "mid", "down"];
+          for (var d in arr) {
+            var index2 = arr[d];
+            for (var i2 = 0; i2 <= counts[index2]; i2++) {
+              if (options2[index2]) {
+                result = result + soul[index2][randomNumber(soul[index2].length)];
+              }
+            }
+          }
+        }
+        return result;
+      }
+      return heComes(text, options);
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/maps/america.js
+var require_america = __commonJS({
+  "node_modules/@colors/colors/lib/maps/america.js"(exports, module) {
+    "use strict";
+    module["exports"] = function(colors) {
+      return function(letter, i2, exploded) {
+        if (letter === " ") return letter;
+        switch (i2 % 3) {
+          case 0:
+            return colors.red(letter);
+          case 1:
+            return colors.white(letter);
+          case 2:
+            return colors.blue(letter);
+        }
+      };
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/maps/zebra.js
+var require_zebra = __commonJS({
+  "node_modules/@colors/colors/lib/maps/zebra.js"(exports, module) {
+    "use strict";
+    module["exports"] = function(colors) {
+      return function(letter, i2, exploded) {
+        return i2 % 2 === 0 ? letter : colors.inverse(letter);
+      };
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/maps/rainbow.js
+var require_rainbow = __commonJS({
+  "node_modules/@colors/colors/lib/maps/rainbow.js"(exports, module) {
+    "use strict";
+    module["exports"] = function(colors) {
+      var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
+      return function(letter, i2, exploded) {
+        if (letter === " ") {
+          return letter;
+        } else {
+          return colors[rainbowColors[i2++ % rainbowColors.length]](letter);
+        }
+      };
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/maps/random.js
+var require_random = __commonJS({
+  "node_modules/@colors/colors/lib/maps/random.js"(exports, module) {
+    "use strict";
+    module["exports"] = function(colors) {
+      var available = [
+        "underline",
+        "inverse",
+        "grey",
+        "yellow",
+        "red",
+        "green",
+        "blue",
+        "white",
+        "cyan",
+        "magenta",
+        "brightYellow",
+        "brightRed",
+        "brightGreen",
+        "brightBlue",
+        "brightWhite",
+        "brightCyan",
+        "brightMagenta"
+      ];
+      return function(letter, i2, exploded) {
+        return letter === " " ? letter : colors[available[Math.round(Math.random() * (available.length - 2))]](letter);
+      };
+    };
+  }
+});
+
+// node_modules/@colors/colors/lib/colors.js
+var require_colors = __commonJS({
+  "node_modules/@colors/colors/lib/colors.js"(exports, module) {
+    "use strict";
+    var colors = {};
+    module["exports"] = colors;
+    colors.themes = {};
+    var util2 = __require("util");
+    var ansiStyles2 = colors.styles = require_styles();
+    var defineProps = Object.defineProperties;
+    var newLineRegex = new RegExp(/[\r\n]+/g);
+    colors.supportsColor = require_supports_colors().supportsColor;
+    if (typeof colors.enabled === "undefined") {
+      colors.enabled = colors.supportsColor() !== false;
+    }
+    colors.enable = function() {
+      colors.enabled = true;
+    };
+    colors.disable = function() {
+      colors.enabled = false;
+    };
+    colors.stripColors = colors.strip = function(str) {
+      return ("" + str).replace(/\x1B\[\d+m/g, "");
+    };
+    var stylize = colors.stylize = function stylize2(str, style) {
+      if (!colors.enabled) {
+        return str + "";
+      }
+      var styleMap = ansiStyles2[style];
+      if (!styleMap && style in colors) {
+        return colors[style](str);
+      }
+      return styleMap.open + str + styleMap.close;
+    };
+    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+    var escapeStringRegexp = function(str) {
+      if (typeof str !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      return str.replace(matchOperatorsRe, "\\$&");
+    };
+    function build(_styles) {
+      var builder = function builder2() {
+        return applyStyle2.apply(builder2, arguments);
+      };
+      builder._styles = _styles;
+      builder.__proto__ = proto2;
+      return builder;
+    }
+    var styles3 = (function() {
+      var ret = {};
+      ansiStyles2.grey = ansiStyles2.gray;
+      Object.keys(ansiStyles2).forEach(function(key) {
+        ansiStyles2[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles2[key].close), "g");
+        ret[key] = {
+          get: function() {
+            return build(this._styles.concat(key));
+          }
+        };
+      });
+      return ret;
+    })();
+    var proto2 = defineProps(function colors2() {
+    }, styles3);
+    function applyStyle2() {
+      var args = Array.prototype.slice.call(arguments);
+      var str = args.map(function(arg) {
+        if (arg != null && arg.constructor === String) {
+          return arg;
+        } else {
+          return util2.inspect(arg);
+        }
+      }).join(" ");
+      if (!colors.enabled || !str) {
+        return str;
+      }
+      var newLinesPresent = str.indexOf("\n") != -1;
+      var nestedStyles = this._styles;
+      var i2 = nestedStyles.length;
+      while (i2--) {
+        var code = ansiStyles2[nestedStyles[i2]];
+        str = code.open + str.replace(code.closeRe, code.open) + code.close;
+        if (newLinesPresent) {
+          str = str.replace(newLineRegex, function(match) {
+            return code.close + match + code.open;
+          });
+        }
+      }
+      return str;
+    }
+    colors.setTheme = function(theme) {
+      if (typeof theme === "string") {
+        console.log("colors.setTheme now only accepts an object, not a string.  If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file.  The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
+        return;
+      }
+      for (var style in theme) {
+        (function(style2) {
+          colors[style2] = function(str) {
+            if (typeof theme[style2] === "object") {
+              var out = str;
+              for (var i2 in theme[style2]) {
+                out = colors[theme[style2][i2]](out);
+              }
+              return out;
+            }
+            return colors[theme[style2]](str);
+          };
+        })(style);
+      }
+    };
+    function init() {
+      var ret = {};
+      Object.keys(styles3).forEach(function(name) {
+        ret[name] = {
+          get: function() {
+            return build([name]);
+          }
+        };
+      });
+      return ret;
+    }
+    var sequencer = function sequencer2(map2, str) {
+      var exploded = str.split("");
+      exploded = exploded.map(map2);
+      return exploded.join("");
+    };
+    colors.trap = require_trap();
+    colors.zalgo = require_zalgo();
+    colors.maps = {};
+    colors.maps.america = require_america()(colors);
+    colors.maps.zebra = require_zebra()(colors);
+    colors.maps.rainbow = require_rainbow()(colors);
+    colors.maps.random = require_random()(colors);
+    for (map in colors.maps) {
+      (function(map2) {
+        colors[map2] = function(str) {
+          return sequencer(colors.maps[map2], str);
+        };
+      })(map);
+    }
+    var map;
+    defineProps(colors, init());
+  }
+});
+
+// node_modules/@colors/colors/safe.js
+var require_safe = __commonJS({
+  "node_modules/@colors/colors/safe.js"(exports, module) {
+    "use strict";
+    var colors = require_colors();
+    module["exports"] = colors;
+  }
+});
+
+// node_modules/cli-table3/src/cell.js
+var require_cell = __commonJS({
+  "node_modules/cli-table3/src/cell.js"(exports, module) {
+    "use strict";
+    var { info, debug } = require_debug2();
+    var utils = require_utils();
+    var Cell = class _Cell {
+      /**
+       * A representation of a cell within the table.
+       * Implementations must have `init` and `draw` methods,
+       * as well as `colSpan`, `rowSpan`, `desiredHeight` and `desiredWidth` properties.
+       * @param options
+       * @constructor
+       */
+      constructor(options) {
+        this.setOptions(options);
+        this.x = null;
+        this.y = null;
+      }
+      setOptions(options) {
+        if (["boolean", "number", "bigint", "string"].indexOf(typeof options) !== -1) {
+          options = { content: "" + options };
+        }
+        options = options || {};
+        this.options = options;
+        let content = options.content;
+        if (["boolean", "number", "bigint", "string"].indexOf(typeof content) !== -1) {
+          this.content = String(content);
+        } else if (!content) {
+          this.content = this.options.href || "";
+        } else {
+          throw new Error("Content needs to be a primitive, got: " + typeof content);
+        }
+        this.colSpan = options.colSpan || 1;
+        this.rowSpan = options.rowSpan || 1;
+        if (this.options.href) {
+          Object.defineProperty(this, "href", {
+            get() {
+              return this.options.href;
+            }
+          });
+        }
+      }
+      mergeTableOptions(tableOptions, cells) {
+        this.cells = cells;
+        let optionsChars = this.options.chars || {};
+        let tableChars = tableOptions.chars;
+        let chars = this.chars = {};
+        CHAR_NAMES.forEach(function(name) {
+          setOption(optionsChars, tableChars, name, chars);
+        });
+        this.truncate = this.options.truncate || tableOptions.truncate;
+        let style = this.options.style = this.options.style || {};
+        let tableStyle = tableOptions.style;
+        setOption(style, tableStyle, "padding-left", this);
+        setOption(style, tableStyle, "padding-right", this);
+        this.head = style.head || tableStyle.head;
+        this.border = style.border || tableStyle.border;
+        this.fixedWidth = tableOptions.colWidths[this.x];
+        this.lines = this.computeLines(tableOptions);
+        this.desiredWidth = utils.strlen(this.content) + this.paddingLeft + this.paddingRight;
+        this.desiredHeight = this.lines.length;
+      }
+      computeLines(tableOptions) {
+        const tableWordWrap = tableOptions.wordWrap || tableOptions.textWrap;
+        const { wordWrap = tableWordWrap } = this.options;
+        if (this.fixedWidth && wordWrap) {
+          this.fixedWidth -= this.paddingLeft + this.paddingRight;
+          if (this.colSpan) {
+            let i2 = 1;
+            while (i2 < this.colSpan) {
+              this.fixedWidth += tableOptions.colWidths[this.x + i2];
+              i2++;
+            }
+          }
+          const { wrapOnWordBoundary: tableWrapOnWordBoundary = true } = tableOptions;
+          const { wrapOnWordBoundary = tableWrapOnWordBoundary } = this.options;
+          return this.wrapLines(utils.wordWrap(this.fixedWidth, this.content, wrapOnWordBoundary));
+        }
+        return this.wrapLines(this.content.split("\n"));
+      }
+      wrapLines(computedLines) {
+        const lines = utils.colorizeLines(computedLines);
+        if (this.href) {
+          return lines.map((line) => utils.hyperlink(this.href, line));
+        }
+        return lines;
+      }
+      /**
+       * Initializes the Cells data structure.
+       *
+       * @param tableOptions - A fully populated set of tableOptions.
+       * In addition to the standard default values, tableOptions must have fully populated the
+       * `colWidths` and `rowWidths` arrays. Those arrays must have lengths equal to the number
+       * of columns or rows (respectively) in this table, and each array item must be a Number.
+       *
+       */
+      init(tableOptions) {
+        let x2 = this.x;
+        let y = this.y;
+        this.widths = tableOptions.colWidths.slice(x2, x2 + this.colSpan);
+        this.heights = tableOptions.rowHeights.slice(y, y + this.rowSpan);
+        this.width = this.widths.reduce(sumPlusOne, -1);
+        this.height = this.heights.reduce(sumPlusOne, -1);
+        this.hAlign = this.options.hAlign || tableOptions.colAligns[x2];
+        this.vAlign = this.options.vAlign || tableOptions.rowAligns[y];
+        this.drawRight = x2 + this.colSpan == tableOptions.colWidths.length;
+      }
+      /**
+       * Draws the given line of the cell.
+       * This default implementation defers to methods `drawTop`, `drawBottom`, `drawLine` and `drawEmpty`.
+       * @param lineNum - can be `top`, `bottom` or a numerical line number.
+       * @param spanningCell - will be a number if being called from a RowSpanCell, and will represent how
+       * many rows below it's being called from. Otherwise it's undefined.
+       * @returns {String} The representation of this line.
+       */
+      draw(lineNum, spanningCell) {
+        if (lineNum == "top") return this.drawTop(this.drawRight);
+        if (lineNum == "bottom") return this.drawBottom(this.drawRight);
+        let content = utils.truncate(this.content, 10, this.truncate);
+        if (!lineNum) {
+          info(`${this.y}-${this.x}: ${this.rowSpan - lineNum}x${this.colSpan} Cell ${content}`);
+        } else {
+        }
+        let padLen = Math.max(this.height - this.lines.length, 0);
+        let padTop;
+        switch (this.vAlign) {
+          case "center":
+            padTop = Math.ceil(padLen / 2);
+            break;
+          case "bottom":
+            padTop = padLen;
+            break;
+          default:
+            padTop = 0;
+        }
+        if (lineNum < padTop || lineNum >= padTop + this.lines.length) {
+          return this.drawEmpty(this.drawRight, spanningCell);
+        }
+        let forceTruncation = this.lines.length > this.height && lineNum + 1 >= this.height;
+        return this.drawLine(lineNum - padTop, this.drawRight, forceTruncation, spanningCell);
+      }
+      /**
+       * Renders the top line of the cell.
+       * @param drawRight - true if this method should render the right edge of the cell.
+       * @returns {String}
+       */
+      drawTop(drawRight) {
+        let content = [];
+        if (this.cells) {
+          this.widths.forEach(function(width, index2) {
+            content.push(this._topLeftChar(index2));
+            content.push(utils.repeat(this.chars[this.y == 0 ? "top" : "mid"], width));
+          }, this);
+        } else {
+          content.push(this._topLeftChar(0));
+          content.push(utils.repeat(this.chars[this.y == 0 ? "top" : "mid"], this.width));
+        }
+        if (drawRight) {
+          content.push(this.chars[this.y == 0 ? "topRight" : "rightMid"]);
+        }
+        return this.wrapWithStyleColors("border", content.join(""));
+      }
+      _topLeftChar(offset) {
+        let x2 = this.x + offset;
+        let leftChar;
+        if (this.y == 0) {
+          leftChar = x2 == 0 ? "topLeft" : offset == 0 ? "topMid" : "top";
+        } else {
+          if (x2 == 0) {
+            leftChar = "leftMid";
+          } else {
+            leftChar = offset == 0 ? "midMid" : "bottomMid";
+            if (this.cells) {
+              let spanAbove = this.cells[this.y - 1][x2] instanceof _Cell.ColSpanCell;
+              if (spanAbove) {
+                leftChar = offset == 0 ? "topMid" : "mid";
+              }
+              if (offset == 0) {
+                let i2 = 1;
+                while (this.cells[this.y][x2 - i2] instanceof _Cell.ColSpanCell) {
+                  i2++;
+                }
+                if (this.cells[this.y][x2 - i2] instanceof _Cell.RowSpanCell) {
+                  leftChar = "leftMid";
+                }
+              }
+            }
+          }
+        }
+        return this.chars[leftChar];
+      }
+      wrapWithStyleColors(styleProperty, content) {
+        if (this[styleProperty] && this[styleProperty].length) {
+          try {
+            let colors = require_safe();
+            for (let i2 = this[styleProperty].length - 1; i2 >= 0; i2--) {
+              colors = colors[this[styleProperty][i2]];
+            }
+            return colors(content);
+          } catch (e2) {
+            return content;
+          }
+        } else {
+          return content;
+        }
+      }
+      /**
+       * Renders a line of text.
+       * @param lineNum - Which line of text to render. This is not necessarily the line within the cell.
+       * There may be top-padding above the first line of text.
+       * @param drawRight - true if this method should render the right edge of the cell.
+       * @param forceTruncationSymbol - `true` if the rendered text should end with the truncation symbol even
+       * if the text fits. This is used when the cell is vertically truncated. If `false` the text should
+       * only include the truncation symbol if the text will not fit horizontally within the cell width.
+       * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
+       * @returns {String}
+       */
+      drawLine(lineNum, drawRight, forceTruncationSymbol, spanningCell) {
+        let left = this.chars[this.x == 0 ? "left" : "middle"];
+        if (this.x && spanningCell && this.cells) {
+          let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+          while (cellLeft instanceof ColSpanCell) {
+            cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+          }
+          if (!(cellLeft instanceof RowSpanCell)) {
+            left = this.chars["rightMid"];
+          }
+        }
+        let leftPadding = utils.repeat(" ", this.paddingLeft);
+        let right = drawRight ? this.chars["right"] : "";
+        let rightPadding = utils.repeat(" ", this.paddingRight);
+        let line = this.lines[lineNum];
+        let len = this.width - (this.paddingLeft + this.paddingRight);
+        if (forceTruncationSymbol) line += this.truncate || "\u2026";
+        let content = utils.truncate(line, len, this.truncate);
+        content = utils.pad(content, len, " ", this.hAlign);
+        content = leftPadding + content + rightPadding;
+        return this.stylizeLine(left, content, right);
+      }
+      stylizeLine(left, content, right) {
+        left = this.wrapWithStyleColors("border", left);
+        right = this.wrapWithStyleColors("border", right);
+        if (this.y === 0) {
+          content = this.wrapWithStyleColors("head", content);
+        }
+        return left + content + right;
+      }
+      /**
+       * Renders the bottom line of the cell.
+       * @param drawRight - true if this method should render the right edge of the cell.
+       * @returns {String}
+       */
+      drawBottom(drawRight) {
+        let left = this.chars[this.x == 0 ? "bottomLeft" : "bottomMid"];
+        let content = utils.repeat(this.chars.bottom, this.width);
+        let right = drawRight ? this.chars["bottomRight"] : "";
+        return this.wrapWithStyleColors("border", left + content + right);
+      }
+      /**
+       * Renders a blank line of text within the cell. Used for top and/or bottom padding.
+       * @param drawRight - true if this method should render the right edge of the cell.
+       * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
+       * @returns {String}
+       */
+      drawEmpty(drawRight, spanningCell) {
+        let left = this.chars[this.x == 0 ? "left" : "middle"];
+        if (this.x && spanningCell && this.cells) {
+          let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+          while (cellLeft instanceof ColSpanCell) {
+            cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+          }
+          if (!(cellLeft instanceof RowSpanCell)) {
+            left = this.chars["rightMid"];
+          }
+        }
+        let right = drawRight ? this.chars["right"] : "";
+        let content = utils.repeat(" ", this.width);
+        return this.stylizeLine(left, content, right);
+      }
+    };
+    var ColSpanCell = class {
+      /**
+       * A Cell that doesn't do anything. It just draws empty lines.
+       * Used as a placeholder in column spanning.
+       * @constructor
+       */
+      constructor() {
+      }
+      draw(lineNum) {
+        if (typeof lineNum === "number") {
+          debug(`${this.y}-${this.x}: 1x1 ColSpanCell`);
+        }
+        return "";
+      }
+      init() {
+      }
+      mergeTableOptions() {
+      }
+    };
+    var RowSpanCell = class {
+      /**
+       * A placeholder Cell for a Cell that spans multiple rows.
+       * It delegates rendering to the original cell, but adds the appropriate offset.
+       * @param originalCell
+       * @constructor
+       */
+      constructor(originalCell) {
+        this.originalCell = originalCell;
+      }
+      init(tableOptions) {
+        let y = this.y;
+        let originalY = this.originalCell.y;
+        this.cellOffset = y - originalY;
+        this.offset = findDimension(tableOptions.rowHeights, originalY, this.cellOffset);
+      }
+      draw(lineNum) {
+        if (lineNum == "top") {
+          return this.originalCell.draw(this.offset, this.cellOffset);
+        }
+        if (lineNum == "bottom") {
+          return this.originalCell.draw("bottom");
+        }
+        debug(`${this.y}-${this.x}: 1x${this.colSpan} RowSpanCell for ${this.originalCell.content}`);
+        return this.originalCell.draw(this.offset + 1 + lineNum);
+      }
+      mergeTableOptions() {
+      }
+    };
+    function firstDefined(...args) {
+      return args.filter((v) => v !== void 0 && v !== null).shift();
+    }
+    function setOption(objA, objB, nameB, targetObj) {
+      let nameA = nameB.split("-");
+      if (nameA.length > 1) {
+        nameA[1] = nameA[1].charAt(0).toUpperCase() + nameA[1].substr(1);
+        nameA = nameA.join("");
+        targetObj[nameA] = firstDefined(objA[nameA], objA[nameB], objB[nameA], objB[nameB]);
+      } else {
+        targetObj[nameB] = firstDefined(objA[nameB], objB[nameB]);
+      }
+    }
+    function findDimension(dimensionTable, startingIndex, span) {
+      let ret = dimensionTable[startingIndex];
+      for (let i2 = 1; i2 < span; i2++) {
+        ret += 1 + dimensionTable[startingIndex + i2];
+      }
+      return ret;
+    }
+    function sumPlusOne(a, b) {
+      return a + b + 1;
+    }
+    var CHAR_NAMES = [
+      "top",
+      "top-mid",
+      "top-left",
+      "top-right",
+      "bottom",
+      "bottom-mid",
+      "bottom-left",
+      "bottom-right",
+      "left",
+      "left-mid",
+      "mid",
+      "mid-mid",
+      "right",
+      "right-mid",
+      "middle"
+    ];
+    module.exports = Cell;
+    module.exports.ColSpanCell = ColSpanCell;
+    module.exports.RowSpanCell = RowSpanCell;
+  }
+});
+
+// node_modules/cli-table3/src/layout-manager.js
+var require_layout_manager = __commonJS({
+  "node_modules/cli-table3/src/layout-manager.js"(exports, module) {
+    "use strict";
+    var { warn, debug } = require_debug2();
+    var Cell = require_cell();
+    var { ColSpanCell, RowSpanCell } = Cell;
+    (function() {
+      function next(alloc, col) {
+        if (alloc[col] > 0) {
+          return next(alloc, col + 1);
+        }
+        return col;
+      }
+      function layoutTable(table) {
+        let alloc = {};
+        table.forEach(function(row, rowIndex) {
+          let col = 0;
+          row.forEach(function(cell) {
+            cell.y = rowIndex;
+            cell.x = rowIndex ? next(alloc, col) : col;
+            const rowSpan = cell.rowSpan || 1;
+            const colSpan = cell.colSpan || 1;
+            if (rowSpan > 1) {
+              for (let cs = 0; cs < colSpan; cs++) {
+                alloc[cell.x + cs] = rowSpan;
+              }
+            }
+            col = cell.x + colSpan;
+          });
+          Object.keys(alloc).forEach((idx) => {
+            alloc[idx]--;
+            if (alloc[idx] < 1) delete alloc[idx];
+          });
+        });
+      }
+      function maxWidth(table) {
+        let mw = 0;
+        table.forEach(function(row) {
+          row.forEach(function(cell) {
+            mw = Math.max(mw, cell.x + (cell.colSpan || 1));
+          });
+        });
+        return mw;
+      }
+      function maxHeight(table) {
+        return table.length;
+      }
+      function cellsConflict(cell1, cell2) {
+        let yMin1 = cell1.y;
+        let yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
+        let yMin2 = cell2.y;
+        let yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
+        let yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
+        let xMin1 = cell1.x;
+        let xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
+        let xMin2 = cell2.x;
+        let xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
+        let xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
+        return yConflict && xConflict;
+      }
+      function conflictExists(rows, x2, y) {
+        let i_max = Math.min(rows.length - 1, y);
+        let cell = { x: x2, y };
+        for (let i2 = 0; i2 <= i_max; i2++) {
+          let row = rows[i2];
+          for (let j = 0; j < row.length; j++) {
+            if (cellsConflict(cell, row[j])) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      function allBlank(rows, y, xMin, xMax) {
+        for (let x2 = xMin; x2 < xMax; x2++) {
+          if (conflictExists(rows, x2, y)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      function addRowSpanCells(table) {
+        table.forEach(function(row, rowIndex) {
+          row.forEach(function(cell) {
+            for (let i2 = 1; i2 < cell.rowSpan; i2++) {
+              let rowSpanCell = new RowSpanCell(cell);
+              rowSpanCell.x = cell.x;
+              rowSpanCell.y = cell.y + i2;
+              rowSpanCell.colSpan = cell.colSpan;
+              insertCell(rowSpanCell, table[rowIndex + i2]);
+            }
+          });
+        });
+      }
+      function addColSpanCells(cellRows) {
+        for (let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex--) {
+          let cellColumns = cellRows[rowIndex];
+          for (let columnIndex = 0; columnIndex < cellColumns.length; columnIndex++) {
+            let cell = cellColumns[columnIndex];
+            for (let k = 1; k < cell.colSpan; k++) {
+              let colSpanCell = new ColSpanCell();
+              colSpanCell.x = cell.x + k;
+              colSpanCell.y = cell.y;
+              cellColumns.splice(columnIndex + 1, 0, colSpanCell);
+            }
+          }
+        }
+      }
+      function insertCell(cell, row) {
+        let x2 = 0;
+        while (x2 < row.length && row[x2].x < cell.x) {
+          x2++;
+        }
+        row.splice(x2, 0, cell);
+      }
+      function fillInTable(table) {
+        let h_max = maxHeight(table);
+        let w_max = maxWidth(table);
+        debug(`Max rows: ${h_max}; Max cols: ${w_max}`);
+        for (let y = 0; y < h_max; y++) {
+          for (let x2 = 0; x2 < w_max; x2++) {
+            if (!conflictExists(table, x2, y)) {
+              let opts = { x: x2, y, colSpan: 1, rowSpan: 1 };
+              x2++;
+              while (x2 < w_max && !conflictExists(table, x2, y)) {
+                opts.colSpan++;
+                x2++;
+              }
+              let y2 = y + 1;
+              while (y2 < h_max && allBlank(table, y2, opts.x, opts.x + opts.colSpan)) {
+                opts.rowSpan++;
+                y2++;
+              }
+              let cell = new Cell(opts);
+              cell.x = opts.x;
+              cell.y = opts.y;
+              warn(`Missing cell at ${cell.y}-${cell.x}.`);
+              insertCell(cell, table[y]);
+            }
+          }
+        }
+      }
+      function generateCells(rows) {
+        return rows.map(function(row) {
+          if (!Array.isArray(row)) {
+            let key = Object.keys(row)[0];
+            row = row[key];
+            if (Array.isArray(row)) {
+              row = row.slice();
+              row.unshift(key);
+            } else {
+              row = [key, row];
+            }
+          }
+          return row.map(function(cell) {
+            return new Cell(cell);
+          });
+        });
+      }
+      function makeTableLayout(rows) {
+        let cellRows = generateCells(rows);
+        layoutTable(cellRows);
+        fillInTable(cellRows);
+        addRowSpanCells(cellRows);
+        addColSpanCells(cellRows);
+        return cellRows;
+      }
+      module.exports = {
+        makeTableLayout,
+        layoutTable,
+        addRowSpanCells,
+        maxWidth,
+        fillInTable,
+        computeWidths: makeComputeWidths("colSpan", "desiredWidth", "x", 1),
+        computeHeights: makeComputeWidths("rowSpan", "desiredHeight", "y", 1)
+      };
+    })();
+    function makeComputeWidths(colSpan, desiredWidth, x2, forcedMin) {
+      return function(vals, table) {
+        let result = [];
+        let spanners = [];
+        let auto = {};
+        table.forEach(function(row) {
+          row.forEach(function(cell) {
+            if ((cell[colSpan] || 1) > 1) {
+              spanners.push(cell);
+            } else {
+              result[cell[x2]] = Math.max(result[cell[x2]] || 0, cell[desiredWidth] || 0, forcedMin);
+            }
+          });
+        });
+        vals.forEach(function(val, index2) {
+          if (typeof val === "number") {
+            result[index2] = val;
+          }
+        });
+        for (let k = spanners.length - 1; k >= 0; k--) {
+          let cell = spanners[k];
+          let span = cell[colSpan];
+          let col = cell[x2];
+          let existingWidth = result[col];
+          let editableCols = typeof vals[col] === "number" ? 0 : 1;
+          if (typeof existingWidth === "number") {
+            for (let i2 = 1; i2 < span; i2++) {
+              existingWidth += 1 + result[col + i2];
+              if (typeof vals[col + i2] !== "number") {
+                editableCols++;
+              }
+            }
+          } else {
+            existingWidth = desiredWidth === "desiredWidth" ? cell.desiredWidth - 1 : 1;
+            if (!auto[col] || auto[col] < existingWidth) {
+              auto[col] = existingWidth;
+            }
+          }
+          if (cell[desiredWidth] > existingWidth) {
+            let i2 = 0;
+            while (editableCols > 0 && cell[desiredWidth] > existingWidth) {
+              if (typeof vals[col + i2] !== "number") {
+                let dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
+                existingWidth += dif;
+                result[col + i2] += dif;
+                editableCols--;
+              }
+              i2++;
+            }
+          }
+        }
+        Object.assign(vals, result, auto);
+        for (let j = 0; j < vals.length; j++) {
+          vals[j] = Math.max(forcedMin, vals[j] || 0);
+        }
+      };
+    }
+  }
+});
+
+// node_modules/cli-table3/src/table.js
+var require_table = __commonJS({
+  "node_modules/cli-table3/src/table.js"(exports, module) {
+    "use strict";
+    var debug = require_debug2();
+    var utils = require_utils();
+    var tableLayout = require_layout_manager();
+    var Table3 = class extends Array {
+      constructor(opts) {
+        super();
+        const options = utils.mergeOptions(opts);
+        Object.defineProperty(this, "options", {
+          value: options,
+          enumerable: options.debug
+        });
+        if (options.debug) {
+          switch (typeof options.debug) {
+            case "boolean":
+              debug.setDebugLevel(debug.WARN);
+              break;
+            case "number":
+              debug.setDebugLevel(options.debug);
+              break;
+            case "string":
+              debug.setDebugLevel(parseInt(options.debug, 10));
+              break;
+            default:
+              debug.setDebugLevel(debug.WARN);
+              debug.warn(`Debug option is expected to be boolean, number, or string. Received a ${typeof options.debug}`);
+          }
+          Object.defineProperty(this, "messages", {
+            get() {
+              return debug.debugMessages();
+            }
+          });
+        }
+      }
+      toString() {
+        let array = this;
+        let headersPresent = this.options.head && this.options.head.length;
+        if (headersPresent) {
+          array = [this.options.head];
+          if (this.length) {
+            array.push.apply(array, this);
+          }
+        } else {
+          this.options.style.head = [];
+        }
+        let cells = tableLayout.makeTableLayout(array);
+        cells.forEach(function(row) {
+          row.forEach(function(cell) {
+            cell.mergeTableOptions(this.options, cells);
+          }, this);
+        }, this);
+        tableLayout.computeWidths(this.options.colWidths, cells);
+        tableLayout.computeHeights(this.options.rowHeights, cells);
+        cells.forEach(function(row) {
+          row.forEach(function(cell) {
+            cell.init(this.options);
+          }, this);
+        }, this);
+        let result = [];
+        for (let rowIndex = 0; rowIndex < cells.length; rowIndex++) {
+          let row = cells[rowIndex];
+          let heightOfRow = this.options.rowHeights[rowIndex];
+          if (rowIndex === 0 || !this.options.style.compact || rowIndex == 1 && headersPresent) {
+            doDraw(row, "top", result);
+          }
+          for (let lineNum = 0; lineNum < heightOfRow; lineNum++) {
+            doDraw(row, lineNum, result);
+          }
+          if (rowIndex + 1 == cells.length) {
+            doDraw(row, "bottom", result);
+          }
+        }
+        return result.join("\n");
+      }
+      get width() {
+        let str = this.toString().split("\n");
+        return str[0].length;
+      }
+    };
+    Table3.reset = () => debug.reset();
+    function doDraw(row, lineNum, result) {
+      let line = [];
+      row.forEach(function(cell) {
+        line.push(cell.draw(lineNum));
+      });
+      let str = line.join("");
+      if (str.length) result.push(str);
+    }
+    module.exports = Table3;
+  }
+});
+
+// node_modules/cli-table3/index.js
+var require_cli_table3 = __commonJS({
+  "node_modules/cli-table3/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_table();
+  }
+});
+
 // src/index.ts
 import { program } from "commander";
 
 // package.json
-var version = "0.32.4";
+var version = "0.32.6";
 var package_default = {
   name: "genlayer",
   version,
@@ -18321,12 +20141,13 @@ var package_default = {
   },
   dependencies: {
     chalk: "^5.4.1",
+    "cli-table3": "^0.6.5",
     commander: "^14.0.0",
     dockerode: "^4.0.2",
     dotenv: "^17.0.0",
     ethers: "^6.13.4",
     "fs-extra": "^11.3.0",
-    "genlayer-js": "^0.18.8",
+    "genlayer-js": "^0.18.9",
     inquirer: "^12.0.0",
     keytar: "^7.9.0",
     "node-fetch": "^3.0.0",
@@ -31913,7 +33734,7 @@ init_fromHex();
 init_toHex();
 init_formatEther();
 
-// node_modules/genlayer-js/dist/chunk-V4ZFI4GV.js
+// node_modules/genlayer-js/dist/chunk-V3MYVW3P.js
 var chains_exports = {};
 __export2(chains_exports, {
   localnet: () => localnet,
@@ -39948,6 +41769,9 @@ var VALIDATOR_WALLET_ABI = [
   { name: "TransferFailed", type: "error", inputs: [] },
   { name: "OperatorTransferNotReady", type: "error", inputs: [] },
   { name: "NoPendingOperator", type: "error", inputs: [] },
+  // OpenZeppelin Ownable errors
+  { name: "OwnableUnauthorizedAccount", type: "error", inputs: [{ name: "account", type: "address" }] },
+  { name: "OwnableInvalidOwner", type: "error", inputs: [{ name: "owner", type: "address" }] },
   // Functions
   {
     name: "operator",
@@ -40250,6 +42074,13 @@ var STAKING_ABI = [
     inputs: [],
     outputs: [{ name: "", type: "uint256" }]
   },
+  {
+    name: "finalized",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
   {
     name: "validatorMinStake",
     type: "function",
@@ -40297,7 +42128,8 @@ var STAKING_ABI = [
           { name: "vcount", type: "uint256" },
           { name: "claimed", type: "uint256" },
           { name: "stakeDeposit", type: "uint256" },
-          { name: "stakeWithdrawal", type: "uint256" }
+          { name: "stakeWithdrawal", type: "uint256" },
+          { name: "slashed", type: "uint256" }
         ]
       }
     ]
@@ -40321,7 +42153,8 @@ var STAKING_ABI = [
           { name: "vcount", type: "uint256" },
           { name: "claimed", type: "uint256" },
           { name: "stakeDeposit", type: "uint256" },
-          { name: "stakeWithdrawal", type: "uint256" }
+          { name: "stakeWithdrawal", type: "uint256" },
+          { name: "slashed", type: "uint256" }
         ]
       }
     ]
@@ -40561,6 +42394,33 @@ var STAKING_ABI = [
       { name: "validator", type: "address", indexed: false },
       { name: "amount", type: "uint256", indexed: false }
     ]
+  },
+  {
+    name: "ValidatorPrime",
+    type: "event",
+    inputs: [
+      { name: "validator", type: "address", indexed: false },
+      { name: "epoch", type: "uint256", indexed: false },
+      { name: "validatorRewards", type: "uint256", indexed: false },
+      { name: "delegatorRewards", type: "uint256", indexed: false }
+    ]
+  },
+  // External contracts getter
+  {
+    name: "contracts",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "gen", type: "address" },
+      { name: "transactions", type: "address" },
+      { name: "idleness", type: "address" },
+      { name: "tribunal", type: "address" },
+      { name: "slashing", type: "address" },
+      { name: "consensus", type: "address" },
+      { name: "validatorWalletFactory", type: "address" },
+      { name: "nftMinter", type: "address" }
+    ]
   }
 ];
 var TESTNET_JSON_RPC_URL = "https://genlayer-testnet.rpc.caldera.xyz/http";
@@ -45544,10 +47404,44 @@ var _sendTransaction = async ({
       data: encodedData,
       value
     });
-  } catch (error) {
-    console.warn("Gas estimation failed, using fallback value:", error);
+  } catch (err) {
+    console.error("Gas estimation failed, using default 200_000:", err);
     estimatedGas = 200000n;
   }
+  if (validatedSenderAccount?.type === "local") {
+    if (!validatedSenderAccount?.signTransaction) {
+      throw new Error("Account does not support signTransaction");
+    }
+    const gasPriceHex = await client.request({
+      method: "eth_gasPrice"
+    });
+    const transactionRequest2 = {
+      account: validatedSenderAccount,
+      to: client.chain.consensusMainContract?.address,
+      data: encodedData,
+      type: "legacy",
+      nonce: Number(nonce),
+      value,
+      gas: estimatedGas,
+      gasPrice: BigInt(gasPriceHex),
+      chainId: client.chain.id
+    };
+    const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest2);
+    const txHash = await client.sendRawTransaction({ serializedTransaction });
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status === "reverted") {
+      throw new Error("Transaction reverted");
+    }
+    const newTxEvents = parseEventLogs({
+      abi: client.chain.consensusMainContract?.abi,
+      eventName: "NewTransaction",
+      logs: receipt.logs
+    });
+    if (newTxEvents.length === 0) {
+      throw new Error("Transaction not processed by consensus");
+    }
+    return newTxEvents[0].args["txId"];
+  }
   const transactionRequest = await client.prepareTransactionRequest({
     account: validatedSenderAccount,
     to: client.chain.consensusMainContract?.address,
@@ -45557,37 +47451,17 @@ var _sendTransaction = async ({
     value,
     gas: estimatedGas
   });
-  if (validatedSenderAccount?.type !== "local") {
-    const formattedRequest = {
-      from: transactionRequest.from,
-      to: transactionRequest.to,
-      data: encodedData,
-      value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
-      gas: transactionRequest.gas ? `0x${transactionRequest.gas.toString(16)}` : "0x5208"
-    };
-    return await client.request({
-      method: "eth_sendTransaction",
-      params: [formattedRequest]
-    });
-  }
-  if (!validatedSenderAccount?.signTransaction) {
-    throw new Error("Account does not support signTransaction");
-  }
-  const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest);
-  const txHash = await client.sendRawTransaction({ serializedTransaction });
-  const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-  if (receipt.status === "reverted") {
-    throw new Error("Transaction reverted");
-  }
-  const newTxEvents = parseEventLogs({
-    abi: client.chain.consensusMainContract?.abi,
-    eventName: "NewTransaction",
-    logs: receipt.logs
+  const formattedRequest = {
+    from: transactionRequest.from,
+    to: transactionRequest.to,
+    data: encodedData,
+    value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
+    gas: transactionRequest.gas ? `0x${transactionRequest.gas.toString(16)}` : "0x5208"
+  };
+  return await client.request({
+    method: "eth_sendTransaction",
+    params: [formattedRequest]
   });
-  if (newTxEvents.length === 0) {
-    throw new Error("Transaction not processed by consensus");
-  }
-  return newTxEvents[0].args["txId"];
 };
 var transactionsConfig = {
   waitInterval: 3e3,
@@ -46448,6 +48322,7 @@ var stakingActions = (client, publicClient) => {
       const contract = getReadOnlyStakingContract();
       const [
         epoch,
+        finalized,
         validatorMinStake,
         delegatorMinStake,
         activeCount,
@@ -46457,6 +48332,7 @@ var stakingActions = (client, publicClient) => {
         epochEven
       ] = await Promise.all([
         contract.read.epoch(),
+        contract.read.finalized(),
         contract.read.validatorMinStake(),
         contract.read.delegatorMinStake(),
         contract.read.activeValidatorsCount(),
@@ -46466,8 +48342,7 @@ var stakingActions = (client, publicClient) => {
         contract.read.epochEven()
       ]);
       const currentEpochData = epoch % 2n === 0n ? epochEven : epochOdd;
-      const currentEpochStart = new Date(Number(currentEpochData.start) * 1e3);
-      const currentEpochEnd = currentEpochData.end > 0n ? new Date(Number(currentEpochData.end) * 1e3) : null;
+      const currentEpochEnd = currentEpochData.end > 0n;
       let nextEpochEstimate = null;
       if (!currentEpochEnd) {
         const duration = epoch === 0n ? epochZeroMinDuration : epochMinDuration;
@@ -46476,20 +48351,42 @@ var stakingActions = (client, publicClient) => {
       }
       return {
         currentEpoch: epoch,
+        lastFinalizedEpoch: finalized,
         validatorMinStake: formatStakingAmount(validatorMinStake),
         validatorMinStakeRaw: validatorMinStake,
         delegatorMinStake: formatStakingAmount(delegatorMinStake),
         delegatorMinStakeRaw: delegatorMinStake,
         activeValidatorsCount: activeCount,
         epochMinDuration,
-        currentEpochStart,
-        currentEpochEnd,
-        nextEpochEstimate,
-        inflation: formatStakingAmount(currentEpochData.inflation),
-        inflationRaw: currentEpochData.inflation,
-        totalWeight: currentEpochData.weight,
-        totalClaimed: formatStakingAmount(currentEpochData.claimed),
-        totalClaimedRaw: currentEpochData.claimed
+        nextEpochEstimate
+      };
+    },
+    getEpochData: async (epochNumber) => {
+      const contract = getReadOnlyStakingContract();
+      const [currentEpoch, epochOdd, epochEven] = await Promise.all([
+        contract.read.epoch(),
+        contract.read.epochOdd(),
+        contract.read.epochEven()
+      ]);
+      if (epochNumber > currentEpoch) {
+        throw new Error(`Epoch ${epochNumber} has not started yet (current: ${currentEpoch})`);
+      }
+      if (epochNumber < currentEpoch - 1n && currentEpoch > 0n) {
+        throw new Error(`Epoch ${epochNumber} data no longer available (only current and previous epoch stored)`);
+      }
+      const epochData = epochNumber % 2n === 0n ? epochEven : epochOdd;
+      return {
+        start: epochData.start,
+        end: epochData.end,
+        inflation: epochData.inflation,
+        weight: epochData.weight,
+        weightDeposit: epochData.weightDeposit,
+        weightWithdrawal: epochData.weightWithdrawal,
+        vcount: epochData.vcount,
+        claimed: epochData.claimed,
+        stakeDeposit: epochData.stakeDeposit,
+        stakeWithdrawal: epochData.stakeWithdrawal,
+        slashed: epochData.slashed
       };
     },
     getActiveValidators: async () => {
@@ -46523,6 +48420,11 @@ var stakingActions = (client, publicClient) => {
         permanentlyBanned: v.permanentlyBanned
       }));
     },
+    getSlashingAddress: async () => {
+      const contract = getReadOnlyStakingContract();
+      const externalContracts = await contract.read.contracts();
+      return externalContracts[4];
+    },
     getStakingContract,
     parseStakingAmount,
     formatStakingAmount
@@ -46557,7 +48459,7 @@ function chainActions(client) {
     }
   };
 }
-var getCustomTransportConfig = (config) => {
+var getCustomTransportConfig = (config, chainConfig) => {
   const isAddress2 = typeof config.account !== "object";
   return {
     async request({ method, params = [] }) {
@@ -46573,11 +48475,8 @@ var getCustomTransportConfig = (config) => {
         }
       }
       {
-        if (!config.chain) {
-          throw new Error("Chain is not set");
-        }
         try {
-          const response = await fetch(config.chain.rpcUrls.default.http[0], {
+          const response = await fetch(chainConfig.rpcUrls.default.http[0], {
             method: "POST",
             headers: {
               "Content-Type": "application/json"
@@ -46607,7 +48506,7 @@ var createClient2 = (config = { chain: localnet }) => {
   if (config.endpoint) {
     chainConfig.rpcUrls.default.http = [config.endpoint];
   }
-  const customTransport = custom(getCustomTransportConfig(config), { retryCount: 0, retryDelay: 0 });
+  const customTransport = custom(getCustomTransportConfig(config, chainConfig), { retryCount: 0, retryDelay: 0 });
   const publicClient = createPublicClient2(chainConfig, customTransport).extend(
     publicActions
   );
@@ -49892,6 +51791,7 @@ var DelegatorClaimAction = class extends StakingAction {
 };
 
 // src/commands/staking/stakingInfo.ts
+var import_cli_table3 = __toESM(require_cli_table3(), 1);
 var ACTIVATION_DELAY_EPOCHS = 2n;
 var UNBONDING_PERIOD_EPOCHS = 7n;
 var StakingInfoAction = class extends StakingAction {
@@ -50050,24 +51950,65 @@ var StakingInfoAction = class extends StakingAction {
         }
         return `${hours}h ${minutes}m`;
       };
+      const formatAmount = client.formatStakingAmount;
+      if (options.epoch !== void 0) {
+        const epochNum = BigInt(options.epoch);
+        const epochData = await client.getEpochData(epochNum);
+        const isFinalized = info.lastFinalizedEpoch >= epochNum;
+        const startDate = new Date(Number(epochData.start) * 1e3);
+        const endDate = epochData.end > 0n ? new Date(Number(epochData.end) * 1e3) : null;
+        this.succeedSpinner(`Epoch ${epochNum}`);
+        console.log(`
+  Epoch:      ${epochNum}`);
+        console.log(`  Started:    ${startDate.toISOString()}`);
+        console.log(`  Ended:      ${endDate?.toISOString() || "Not yet"}`);
+        console.log(`  Finalized:  ${isFinalized ? "Yes" : "No"}`);
+        console.log(`  Validators: ${epochData.vcount}`);
+        console.log(`  Weight:     ${epochData.weight}`);
+        console.log(`  Inflation:  ${formatAmount(epochData.inflation)}`);
+        console.log(`  Claimed:    ${formatAmount(epochData.claimed)}`);
+        console.log(`  Slashed:    ${formatAmount(epochData.slashed)}`);
+        console.log();
+        return;
+      }
+      const currentEpochData = await client.getEpochData(info.currentEpoch);
+      const currentStart = new Date(Number(currentEpochData.start) * 1e3);
       const now = Date.now();
+      const timeSinceStart = now - currentStart.getTime();
       const timeUntilNext = info.nextEpochEstimate ? info.nextEpochEstimate.getTime() - now : null;
-      const result = {
-        currentEpoch: info.currentEpoch.toString(),
-        epochStarted: info.currentEpochStart.toISOString(),
-        epochEnded: info.currentEpochEnd?.toISOString() || "Not ended",
-        nextEpochEstimate: info.nextEpochEstimate?.toISOString() || "N/A",
-        timeUntilNextEpoch: timeUntilNext && timeUntilNext > 0 ? formatDuration(timeUntilNext) : "N/A",
-        minEpochDuration: formatDuration(Number(info.epochMinDuration) * 1e3),
-        validatorMinStake: info.validatorMinStake,
-        delegatorMinStake: info.delegatorMinStake,
-        activeValidatorsCount: info.activeValidatorsCount.toString(),
-        // Inflation/rewards
-        epochInflation: info.inflation,
-        totalWeight: info.totalWeight.toString(),
-        totalClaimed: info.totalClaimed
-      };
-      this.succeedSpinner("Epoch info retrieved", result);
+      this.succeedSpinner("Epoch info");
+      const nextEstimate = timeUntilNext && timeUntilNext > 0 ? `in ${formatDuration(timeUntilNext)}` : currentEpochData.end > 0n ? "Next epoch started" : "N/A";
+      console.log(`
+  Current Epoch: ${info.currentEpoch} (started ${formatDuration(timeSinceStart)} ago)`);
+      console.log(`  Next Epoch:    ${nextEstimate}`);
+      console.log(`  Validators:    ${info.activeValidatorsCount}`);
+      console.log(`  Weight:        ${currentEpochData.weight}`);
+      console.log(`  Slashed:       ${formatAmount(currentEpochData.slashed)}`);
+      if (info.currentEpoch > 0n) {
+        const prevEpoch = info.currentEpoch - 1n;
+        const prevData = await client.getEpochData(prevEpoch);
+        const isFinalized = info.lastFinalizedEpoch >= prevEpoch;
+        const prevEnd = prevData.end > 0n;
+        let status;
+        if (!prevEnd) {
+          status = "still active";
+        } else if (isFinalized) {
+          status = "finalized";
+        } else {
+          status = "finalizing txs...";
+        }
+        console.log(`
+  Previous Epoch: ${prevEpoch} (${status})`);
+        console.log(`  Inflation:      ${formatAmount(prevData.inflation)}`);
+        console.log(`  Claimed:        ${formatAmount(prevData.claimed)}`);
+        console.log(`  Unclaimed:      ${formatAmount(prevData.inflation - prevData.claimed)}`);
+        console.log(`  Slashed:        ${formatAmount(prevData.slashed)}`);
+      }
+      console.log(`
+  Min Epoch Duration:   ${formatDuration(Number(info.epochMinDuration) * 1e3)}`);
+      console.log(`  Validator Min Stake:  ${info.validatorMinStake}`);
+      console.log(`  Delegator Min Stake:  ${info.delegatorMinStake}
+`);
     } catch (error) {
       this.failSpinner("Failed to get epoch info", error.message || error);
     }
@@ -50122,6 +52063,340 @@ var StakingInfoAction = class extends StakingAction {
       this.failSpinner("Failed to get banned validators", error.message || error);
     }
   }
+  async listValidators(options) {
+    this.startSpinner("Fetching validator set...");
+    try {
+      const client = await this.getReadOnlyStakingClient(options);
+      let myAddress = null;
+      try {
+        myAddress = await this.getSignerAddress();
+      } catch {
+      }
+      const [activeAddresses, quarantinedList, bannedList, epochInfo] = await Promise.all([
+        client.getActiveValidators(),
+        client.getQuarantinedValidatorsDetailed(),
+        options.all ? client.getBannedValidators() : Promise.resolve([]),
+        client.getEpochInfo()
+      ]);
+      const quarantinedSet = new Map(quarantinedList.map((v) => [v.validator.toLowerCase(), v]));
+      const bannedSet = new Map(bannedList.map((v) => [v.validator.toLowerCase(), v]));
+      const allAddresses = /* @__PURE__ */ new Set([
+        ...activeAddresses,
+        ...quarantinedList.map((v) => v.validator),
+        ...options.all ? bannedList.map((v) => v.validator) : []
+      ]);
+      this.setSpinnerText(`Fetching details for ${allAddresses.size} validators...`);
+      const BATCH_SIZE = 5;
+      const addressArray = Array.from(allAddresses);
+      const validatorInfos = [];
+      for (let i2 = 0; i2 < addressArray.length; i2 += BATCH_SIZE) {
+        const batch = addressArray.slice(i2, i2 + BATCH_SIZE);
+        const batchResults = await Promise.all(
+          batch.map((addr) => client.getValidatorInfo(addr))
+        );
+        validatorInfos.push(...batchResults);
+        if (i2 + BATCH_SIZE < addressArray.length) {
+          this.setSpinnerText(`Fetching details... ${Math.min(i2 + BATCH_SIZE, addressArray.length)}/${addressArray.length}`);
+        }
+      }
+      const rows = validatorInfos.map((info) => {
+        const addrLower = info.address.toLowerCase();
+        const isQuarantined = quarantinedSet.has(addrLower);
+        const isBanned = bannedSet.has(addrLower);
+        const isActive = activeAddresses.some((a) => a.toLowerCase() === addrLower);
+        let status = "";
+        if (isBanned) {
+          const banInfo = bannedSet.get(addrLower);
+          status = banInfo.permanentlyBanned ? "BANNED" : `banned(e${banInfo.untilEpoch})`;
+        } else if (isQuarantined) {
+          const qInfo = quarantinedSet.get(addrLower);
+          status = `quarant(e${qInfo.untilEpoch})`;
+        } else if (info.needsPriming) {
+          status = "prime!";
+        } else if (isActive) {
+          status = "active";
+        } else {
+          status = "pending";
+        }
+        const isMine = myAddress ? info.owner.toLowerCase() === myAddress.toLowerCase() || info.operator.toLowerCase() === myAddress.toLowerCase() : false;
+        return {
+          info,
+          status,
+          isMine,
+          totalStakeRaw: info.vStakeRaw + info.dStakeRaw
+        };
+      });
+      const ALPHA = 0.6;
+      const BETA = 0.5;
+      const calcWeight = (vStakeRaw, dStakeRaw) => {
+        const vStake = Number(vStakeRaw) / 1e18;
+        const dStake = Number(dStakeRaw) / 1e18;
+        const util2 = vStake * ALPHA + dStake * (1 - ALPHA);
+        return Math.pow(util2, BETA);
+      };
+      const rowsWithWeight = rows.map((r2) => ({
+        ...r2,
+        weight: calcWeight(r2.info.vStakeRaw, r2.info.dStakeRaw)
+      }));
+      rowsWithWeight.sort((a, b) => b.weight - a.weight);
+      const totalWeight = rowsWithWeight.filter((r2) => r2.status === "active").reduce((sum, r2) => sum + r2.weight, 0);
+      this.stopSpinner();
+      const formatStake = (s2) => {
+        const num2 = parseFloat(s2.replace(" GEN", ""));
+        if (num2 >= 1e6) return `${(num2 / 1e6).toFixed(1)}M`;
+        if (num2 >= 1e3) return `${(num2 / 1e3).toFixed(1)}K`;
+        if (num2 >= 1) return num2.toFixed(1);
+        if (num2 > 0) return num2.toPrecision(2);
+        return "0";
+      };
+      const table = new import_cli_table3.default({
+        head: [
+          source_default.cyan("#"),
+          source_default.cyan("Validator"),
+          source_default.cyan("Self"),
+          source_default.cyan("Deleg"),
+          source_default.cyan("Pending"),
+          source_default.cyan("Weight"),
+          source_default.cyan("Status")
+        ],
+        style: { head: [], border: [] }
+      });
+      rowsWithWeight.forEach((row, idx) => {
+        const { info, status, isMine, weight } = row;
+        const weightPct = totalWeight > 0 ? weight / totalWeight * 100 : 0;
+        const weightStr = status === "active" ? `${weightPct.toFixed(1)}%` : source_default.gray("-");
+        const currentEpoch = epochInfo.currentEpoch;
+        const trulyPendingDeposits = info.pendingDeposits.filter((d) => d.epoch + ACTIVATION_DELAY_EPOCHS > currentEpoch);
+        const trulyPendingWithdrawals = info.pendingWithdrawals.filter((w) => w.epoch + UNBONDING_PERIOD_EPOCHS > currentEpoch);
+        const pendingDepositSum = trulyPendingDeposits.reduce((sum, d) => sum + d.stakeRaw, 0n);
+        const pendingWithdrawSum = trulyPendingWithdrawals.reduce((sum, w) => sum + w.stakeRaw, 0n);
+        let pendingStr = "-";
+        if (pendingDepositSum > 0n && pendingWithdrawSum > 0n) {
+          pendingStr = source_default.green(`+${formatStake(`${Number(pendingDepositSum) / 1e18} GEN`)}`) + " " + source_default.red(`-${formatStake(`${Number(pendingWithdrawSum) / 1e18} GEN`)}`);
+        } else if (pendingDepositSum > 0n) {
+          pendingStr = source_default.green(`+${formatStake(`${Number(pendingDepositSum) / 1e18} GEN`)}`);
+        } else if (pendingWithdrawSum > 0n) {
+          pendingStr = source_default.red(`-${formatStake(`${Number(pendingWithdrawSum) / 1e18} GEN`)}`);
+        }
+        let roleTag = "";
+        if (isMine) {
+          if (myAddress && info.owner.toLowerCase() === myAddress.toLowerCase()) {
+            roleTag = info.operator.toLowerCase() === myAddress.toLowerCase() ? source_default.cyan(" [own+op]") : source_default.cyan(" [owner]");
+          } else {
+            roleTag = source_default.cyan(" [operator]");
+          }
+        }
+        let moniker = info.identity?.moniker || "";
+        if (moniker.length > 20) moniker = moniker.slice(0, 19) + "\u2026";
+        const validatorCell = moniker ? `${moniker}${roleTag}
+${source_default.gray(info.address)}` : `${source_default.gray(info.address)}${roleTag}`;
+        let statusStr = status;
+        if (status === "active") statusStr = source_default.green(status);
+        else if (status === "BANNED") statusStr = source_default.red(status);
+        else if (status.startsWith("quarant")) statusStr = source_default.yellow(status);
+        else if (status.startsWith("banned")) statusStr = source_default.red(status);
+        else if (status === "prime!") statusStr = source_default.magenta(status);
+        else if (status === "pending") statusStr = source_default.gray(status);
+        table.push([
+          (idx + 1).toString(),
+          validatorCell,
+          formatStake(info.vStake),
+          formatStake(info.dStake),
+          pendingStr,
+          weightStr,
+          statusStr
+        ]);
+      });
+      console.log("");
+      console.log(table.toString());
+      console.log("");
+      const activeCount = rowsWithWeight.filter((r2) => r2.status === "active").length;
+      console.log(source_default.gray(`Total: ${rowsWithWeight.length} validators (${activeCount} active)`));
+      console.log("");
+    } catch (error) {
+      this.failSpinner("Failed to list validators", error.message || error);
+    }
+  }
+};
+
+// src/commands/staking/validatorHistory.ts
+var import_cli_table32 = __toESM(require_cli_table3(), 1);
+var SLASH_EVENT_ABI = {
+  type: "event",
+  name: "SlashedFromIdleness",
+  inputs: [
+    { name: "validator", type: "address", indexed: true },
+    { name: "txId", type: "bytes32", indexed: false },
+    { name: "epoch", type: "uint256", indexed: false },
+    { name: "percentage", type: "uint256", indexed: false }
+  ]
+};
+var REWARD_EVENT_ABI = {
+  type: "event",
+  name: "ValidatorPrime",
+  inputs: [
+    { name: "validator", type: "address", indexed: false },
+    { name: "epoch", type: "uint256", indexed: false },
+    { name: "validatorRewards", type: "uint256", indexed: false },
+    { name: "delegatorRewards", type: "uint256", indexed: false }
+  ]
+};
+var ValidatorHistoryAction = class extends StakingAction {
+  constructor() {
+    super();
+  }
+  getNetworkForHistory(config) {
+    if (config.network) {
+      const network = BUILT_IN_NETWORKS[config.network];
+      if (!network) {
+        throw new Error(`Unknown network: ${config.network}`);
+      }
+      return network;
+    }
+    const globalNetwork = this.getConfig().network;
+    if (globalNetwork && BUILT_IN_NETWORKS[globalNetwork]) {
+      return BUILT_IN_NETWORKS[globalNetwork];
+    }
+    return BUILT_IN_NETWORKS["localnet"];
+  }
+  async execute(options) {
+    this.startSpinner("Fetching validator history...");
+    try {
+      const chain = this.getNetworkForHistory(options);
+      if (chain.id === 808080) {
+        this.failSpinner("validator-history requires testnet-asimov (localnet doesn't support event logs)");
+        return;
+      }
+      const client = await this.getReadOnlyStakingClient(options);
+      const validatorAddress = options.validator || await this.getSignerAddress();
+      const isValidator = await client.isValidator(validatorAddress);
+      if (!isValidator) {
+        this.failSpinner(`Address ${validatorAddress} is not a validator`);
+        return;
+      }
+      this.setSpinnerText("Fetching contract addresses...");
+      const stakingAddress = client.getStakingContract().address;
+      const slashingAddress = await client.getSlashingAddress();
+      const publicClient = createPublicClient({
+        chain,
+        transport: http3(chain.rpcUrls.default.http[0])
+      });
+      const fromBlock = options.fromBlock ? BigInt(options.fromBlock) : 0n;
+      const limit = options.limit ? parseInt(options.limit) : 50;
+      this.setSpinnerText("Fetching slash events...");
+      const slashLogs = await publicClient.getLogs({
+        address: slashingAddress,
+        event: SLASH_EVENT_ABI,
+        args: { validator: validatorAddress },
+        fromBlock,
+        toBlock: "latest"
+      });
+      this.setSpinnerText("Fetching reward events...");
+      const rewardLogs = await publicClient.getLogs({
+        address: stakingAddress,
+        event: REWARD_EVENT_ABI,
+        fromBlock,
+        toBlock: "latest"
+      });
+      const filteredRewardLogs = rewardLogs.filter(
+        (log) => log.args.validator?.toLowerCase() === validatorAddress.toLowerCase()
+      );
+      const allLogs = [...slashLogs, ...filteredRewardLogs];
+      const uniqueBlocks = [...new Set(allLogs.map((l) => l.blockNumber))];
+      this.setSpinnerText("Fetching block timestamps...");
+      const blockTimestamps = /* @__PURE__ */ new Map();
+      const BATCH_SIZE = 10;
+      for (let i2 = 0; i2 < uniqueBlocks.length; i2 += BATCH_SIZE) {
+        const batch = uniqueBlocks.slice(i2, i2 + BATCH_SIZE);
+        const blocks = await Promise.all(
+          batch.map((blockNumber) => publicClient.getBlock({ blockNumber }))
+        );
+        blocks.forEach((block) => {
+          blockTimestamps.set(block.number, new Date(Number(block.timestamp) * 1e3));
+        });
+      }
+      const slashEvents = slashLogs.map((log) => ({
+        type: "slash",
+        epoch: log.args.epoch,
+        txId: log.args.txId,
+        percentage: log.args.percentage,
+        blockNumber: log.blockNumber,
+        timestamp: blockTimestamps.get(log.blockNumber) || /* @__PURE__ */ new Date(0)
+      }));
+      const rewardEvents = filteredRewardLogs.map((log) => ({
+        type: "reward",
+        epoch: log.args.epoch,
+        validatorRewards: log.args.validatorRewards,
+        delegatorRewards: log.args.delegatorRewards,
+        blockNumber: log.blockNumber,
+        timestamp: blockTimestamps.get(log.blockNumber) || /* @__PURE__ */ new Date(0)
+      }));
+      const allEvents = [...slashEvents, ...rewardEvents];
+      allEvents.sort((a, b) => Number(b.blockNumber - a.blockNumber));
+      const limitedEvents = allEvents.slice(0, limit);
+      const totalValidatorRewards = rewardEvents.reduce((sum, e2) => sum + e2.validatorRewards, 0n);
+      const totalDelegatorRewards = rewardEvents.reduce((sum, e2) => sum + e2.delegatorRewards, 0n);
+      this.stopSpinner();
+      if (limitedEvents.length === 0) {
+        console.log(source_default.yellow("\nNo history events found for this validator.\n"));
+        return;
+      }
+      const formatTime = (date) => {
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const hours = String(date.getHours()).padStart(2, "0");
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        return `${month}-${day} ${hours}:${minutes}`;
+      };
+      const table = new import_cli_table32.default({
+        head: [
+          source_default.cyan("Time"),
+          source_default.cyan("Epoch"),
+          source_default.cyan("Type"),
+          source_default.cyan("Details"),
+          source_default.cyan("GL TxId / Block")
+        ],
+        style: { head: [], border: [] }
+      });
+      for (const event of limitedEvents) {
+        if (event.type === "slash") {
+          const pct = Number(event.percentage) / 100;
+          table.push([
+            formatTime(event.timestamp),
+            event.epoch.toString(),
+            source_default.red("SLASH"),
+            `${pct.toFixed(2)}%`,
+            event.txId
+          ]);
+        } else {
+          const valReward = client.formatStakingAmount(event.validatorRewards);
+          const delReward = client.formatStakingAmount(event.delegatorRewards);
+          table.push([
+            formatTime(event.timestamp),
+            event.epoch.toString(),
+            source_default.green("REWARD"),
+            `Val: ${valReward}, Del: ${delReward}`,
+            `block ${event.blockNumber}`
+          ]);
+        }
+      }
+      console.log("");
+      console.log(source_default.bold(`History for ${validatorAddress}`));
+      console.log(table.toString());
+      console.log("");
+      console.log(source_default.gray("Summary:"));
+      console.log(source_default.gray(`  Slash events: ${slashEvents.length}`));
+      console.log(source_default.gray(`  Reward events: ${rewardEvents.length}`));
+      console.log(source_default.gray(`  Total validator rewards: ${client.formatStakingAmount(totalValidatorRewards)}`));
+      console.log(source_default.gray(`  Total delegator rewards: ${client.formatStakingAmount(totalDelegatorRewards)}`));
+      if (allEvents.length > limit) {
+        console.log(source_default.gray(`  (showing ${limit} of ${allEvents.length} events)`));
+      }
+      console.log("");
+    } catch (error) {
+      this.failSpinner("Failed to get validator history", error.message || error);
+    }
+  }
 };
 
 // src/commands/staking/wizard.ts
@@ -50183,8 +52458,8 @@ var ValidatorWizardAction = class extends StakingAction {
         {
           type: "input",
           name: "accountName",
-          message: "Enter a name for your validator account:",
-          default: "validator",
+          message: "Enter a name for your owner account:",
+          default: "owner",
           validate: (input) => input.length > 0 || "Name cannot be empty"
         }
       ]);
@@ -50773,51 +53048,103 @@ function initializeStakingCommands(program2) {
     const action = new ValidatorJoinAction();
     await action.execute(options);
   });
-  staking.command("validator-deposit").description("Make an additional deposit to a validator wallet").requiredOption("--validator <address>", "Validator wallet contract address to deposit to").requiredOption("--amount <amount>", "Amount to deposit (in wei or with 'eth'/'gen' suffix)").option("--account <name>", "Account to use (must be validator owner)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (options) => {
+  staking.command("validator-deposit [validator]").description("Make an additional deposit to a validator wallet").option("--validator <address>", "Validator wallet contract address (deprecated, use positional arg)").requiredOption("--amount <amount>", "Amount to deposit (in wei or with 'eth'/'gen' suffix)").option("--account <name>", "Account to use (must be validator owner)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new ValidatorDepositAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("validator-exit").description("Exit as a validator by withdrawing shares").requiredOption("--validator <address>", "Validator wallet contract address").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--account <name>", "Account to use (must be validator owner)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (options) => {
+  staking.command("validator-exit [validator]").description("Exit as a validator by withdrawing shares").option("--validator <address>", "Validator wallet contract address (deprecated, use positional arg)").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--account <name>", "Account to use (must be validator owner)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new ValidatorExitAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("validator-claim").description("Claim validator withdrawals after unbonding period").requiredOption("--validator <address>", "Validator wallet contract address").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (options) => {
+  staking.command("validator-claim [validator]").description("Claim validator withdrawals after unbonding period").option("--validator <address>", "Validator wallet contract address (deprecated, use positional arg)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new ValidatorClaimAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("validator-prime").description("Prime a validator to prepare their stake record for the next epoch").requiredOption("--validator <address>", "Validator address to prime").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("validator-prime [validator]").description("Prime a validator to prepare their stake record for the next epoch").option("--validator <address>", "Validator address to prime (deprecated, use positional arg)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new ValidatorPrimeAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("set-operator").description("Change the operator address for a validator wallet").requiredOption("--validator <address>", "Validator wallet address").requiredOption("--operator <address>", "New operator address").option("--account <name>", "Account to use (must be validator owner)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (options) => {
+  staking.command("set-operator [validator] [operator]").description("Change the operator address for a validator wallet").option("--validator <address>", "Validator wallet address (deprecated, use positional arg)").option("--operator <address>", "New operator address (deprecated, use positional arg)").option("--account <name>", "Account to use (must be validator owner)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (validatorArg, operatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    const operator = operatorArg || options.operator;
+    if (!validator || !operator) {
+      console.error("Error: validator and operator addresses are required");
+      process.exit(1);
+    }
     const action = new SetOperatorAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator, operator });
   });
-  staking.command("set-identity").description("Set validator identity metadata (moniker, website, socials, etc.)").requiredOption("--validator <address>", "Validator wallet address").requiredOption("--moniker <name>", "Validator display name").option("--logo-uri <uri>", "Logo URI").option("--website <url>", "Website URL").option("--description <text>", "Description").option("--email <email>", "Contact email").option("--twitter <handle>", "Twitter handle").option("--telegram <handle>", "Telegram handle").option("--github <handle>", "GitHub handle").option("--extra-cid <cid>", "Extra data as IPFS CID or hex bytes (0x...)").option("--account <name>", "Account to use (must be validator operator)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (options) => {
+  staking.command("set-identity [validator]").description("Set validator identity metadata (moniker, website, socials, etc.)").option("--validator <address>", "Validator wallet address (deprecated, use positional arg)").requiredOption("--moniker <name>", "Validator display name").option("--logo-uri <uri>", "Logo URI").option("--website <url>", "Website URL").option("--description <text>", "Description").option("--email <email>", "Contact email").option("--twitter <handle>", "Twitter handle").option("--telegram <handle>", "Telegram handle").option("--github <handle>", "GitHub handle").option("--extra-cid <cid>", "Extra data as IPFS CID or hex bytes (0x...)").option("--account <name>", "Account to use (must be validator operator)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new SetIdentityAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("delegator-join").description("Join as a delegator by staking with a validator").requiredOption("--validator <address>", "Validator address to delegate to").requiredOption("--amount <amount>", "Amount to stake (in wei or with 'eth'/'gen' suffix)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegator-join [validator]").description("Join as a delegator by staking with a validator").option("--validator <address>", "Validator address to delegate to (deprecated, use positional arg)").requiredOption("--amount <amount>", "Amount to stake (in wei or with 'eth'/'gen' suffix)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new DelegatorJoinAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("delegator-exit").description("Exit as a delegator by withdrawing shares from a validator").requiredOption("--validator <address>", "Validator address to exit from").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegator-exit [validator]").description("Exit as a delegator by withdrawing shares from a validator").option("--validator <address>", "Validator address to exit from (deprecated, use positional arg)").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new DelegatorExitAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("delegator-claim").description("Claim delegator withdrawals after unbonding period").requiredOption("--validator <address>", "Validator address").option("--delegator <address>", "Delegator address (defaults to signer)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegator-claim [validator]").description("Claim delegator withdrawals after unbonding period").option("--validator <address>", "Validator address (deprecated, use positional arg)").option("--delegator <address>", "Delegator address (defaults to signer)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new DelegatorClaimAction();
-    await action.execute(options);
+    await action.execute({ ...options, validator });
   });
-  staking.command("validator-info").description("Get information about a validator").option("--validator <address>", "Validator address (defaults to signer)").option("--account <name>", "Account to use (for default validator address)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("validator-info [validator]").description("Get information about a validator").option("--validator <address>", "Validator address (deprecated, use positional arg)").option("--account <name>", "Account to use (for default validator address)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
     const action = new StakingInfoAction();
-    await action.getValidatorInfo(options);
+    await action.getValidatorInfo({ ...options, validator });
   });
-  staking.command("delegation-info").description("Get delegation info for a delegator with a validator").requiredOption("--validator <address>", "Validator address").option("--delegator <address>", "Delegator address (defaults to signer)").option("--account <name>", "Account to use (for default delegator address)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegation-info [validator]").description("Get delegation info for a delegator with a validator").option("--validator <address>", "Validator address (deprecated, use positional arg)").option("--delegator <address>", "Delegator address (defaults to signer)").option("--account <name>", "Account to use (for default delegator address)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    if (!validator) {
+      console.error("Error: validator address is required");
+      process.exit(1);
+    }
     const action = new StakingInfoAction();
-    await action.getStakeInfo(options);
+    await action.getStakeInfo({ ...options, validator });
   });
-  staking.command("epoch-info").description("Get current epoch and staking parameters").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("epoch-info").description("Get current epoch and staking parameters").option("--epoch <number>", "Show data for specific epoch (current or previous only)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new StakingInfoAction();
     await action.getEpochInfo(options);
   });
@@ -50833,6 +53160,15 @@ function initializeStakingCommands(program2) {
     const action = new StakingInfoAction();
     await action.listBannedValidators(options);
   });
+  staking.command("validators").description("Show validator set with stake, status, and voting power").option("--all", "Include banned validators").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+    const action = new StakingInfoAction();
+    await action.listValidators(options);
+  });
+  staking.command("validator-history [validator]").description("Show slash and reward history for a validator").option("--validator <address>", "Validator address (deprecated, use positional arg)").option("--from-block <block>", "Start from this block number").option("--limit <count>", "Maximum number of events to show (default: 50)").option("--account <name>", "Account to use (for default validator address)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (validatorArg, options) => {
+    const validator = validatorArg || options.validator;
+    const action = new ValidatorHistoryAction();
+    await action.execute({ ...options, validator });
+  });
   return program2;
 }