npm - @forbocai/test-game - Versions diffs - 0.6.0 → 0.6.3 - Mend

@forbocai/test-game 0.6.0 → 0.6.3

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

Files changed (7) hide show

package/dist/cli.mjs CHANGED Viewed

@@ -1,27 +1,2577 @@
 #!/usr/bin/env node
-import {
-  runGame
-} from "./chunk-4XIOL463.mjs";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
-// src/cli.ts
-var usage = () => {
-  console.log(`
-\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-\u2551  ECHOES OF THE SPIRE // TERMINAL HARNESS            \u2551
-\u2551  SYSTEM_OVERRIDE :: NEURAL_LINK_ESTABLISHED         \u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+// ../../node_modules/color-name/index.js
+var require_color_name = __commonJS({
+  "../../node_modules/color-name/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      "aliceblue": [240, 248, 255],
+      "antiquewhite": [250, 235, 215],
+      "aqua": [0, 255, 255],
+      "aquamarine": [127, 255, 212],
+      "azure": [240, 255, 255],
+      "beige": [245, 245, 220],
+      "bisque": [255, 228, 196],
+      "black": [0, 0, 0],
+      "blanchedalmond": [255, 235, 205],
+      "blue": [0, 0, 255],
+      "blueviolet": [138, 43, 226],
+      "brown": [165, 42, 42],
+      "burlywood": [222, 184, 135],
+      "cadetblue": [95, 158, 160],
+      "chartreuse": [127, 255, 0],
+      "chocolate": [210, 105, 30],
+      "coral": [255, 127, 80],
+      "cornflowerblue": [100, 149, 237],
+      "cornsilk": [255, 248, 220],
+      "crimson": [220, 20, 60],
+      "cyan": [0, 255, 255],
+      "darkblue": [0, 0, 139],
+      "darkcyan": [0, 139, 139],
+      "darkgoldenrod": [184, 134, 11],
+      "darkgray": [169, 169, 169],
+      "darkgreen": [0, 100, 0],
+      "darkgrey": [169, 169, 169],
+      "darkkhaki": [189, 183, 107],
+      "darkmagenta": [139, 0, 139],
+      "darkolivegreen": [85, 107, 47],
+      "darkorange": [255, 140, 0],
+      "darkorchid": [153, 50, 204],
+      "darkred": [139, 0, 0],
+      "darksalmon": [233, 150, 122],
+      "darkseagreen": [143, 188, 143],
+      "darkslateblue": [72, 61, 139],
+      "darkslategray": [47, 79, 79],
+      "darkslategrey": [47, 79, 79],
+      "darkturquoise": [0, 206, 209],
+      "darkviolet": [148, 0, 211],
+      "deeppink": [255, 20, 147],
+      "deepskyblue": [0, 191, 255],
+      "dimgray": [105, 105, 105],
+      "dimgrey": [105, 105, 105],
+      "dodgerblue": [30, 144, 255],
+      "firebrick": [178, 34, 34],
+      "floralwhite": [255, 250, 240],
+      "forestgreen": [34, 139, 34],
+      "fuchsia": [255, 0, 255],
+      "gainsboro": [220, 220, 220],
+      "ghostwhite": [248, 248, 255],
+      "gold": [255, 215, 0],
+      "goldenrod": [218, 165, 32],
+      "gray": [128, 128, 128],
+      "green": [0, 128, 0],
+      "greenyellow": [173, 255, 47],
+      "grey": [128, 128, 128],
+      "honeydew": [240, 255, 240],
+      "hotpink": [255, 105, 180],
+      "indianred": [205, 92, 92],
+      "indigo": [75, 0, 130],
+      "ivory": [255, 255, 240],
+      "khaki": [240, 230, 140],
+      "lavender": [230, 230, 250],
+      "lavenderblush": [255, 240, 245],
+      "lawngreen": [124, 252, 0],
+      "lemonchiffon": [255, 250, 205],
+      "lightblue": [173, 216, 230],
+      "lightcoral": [240, 128, 128],
+      "lightcyan": [224, 255, 255],
+      "lightgoldenrodyellow": [250, 250, 210],
+      "lightgray": [211, 211, 211],
+      "lightgreen": [144, 238, 144],
+      "lightgrey": [211, 211, 211],
+      "lightpink": [255, 182, 193],
+      "lightsalmon": [255, 160, 122],
+      "lightseagreen": [32, 178, 170],
+      "lightskyblue": [135, 206, 250],
+      "lightslategray": [119, 136, 153],
+      "lightslategrey": [119, 136, 153],
+      "lightsteelblue": [176, 196, 222],
+      "lightyellow": [255, 255, 224],
+      "lime": [0, 255, 0],
+      "limegreen": [50, 205, 50],
+      "linen": [250, 240, 230],
+      "magenta": [255, 0, 255],
+      "maroon": [128, 0, 0],
+      "mediumaquamarine": [102, 205, 170],
+      "mediumblue": [0, 0, 205],
+      "mediumorchid": [186, 85, 211],
+      "mediumpurple": [147, 112, 219],
+      "mediumseagreen": [60, 179, 113],
+      "mediumslateblue": [123, 104, 238],
+      "mediumspringgreen": [0, 250, 154],
+      "mediumturquoise": [72, 209, 204],
+      "mediumvioletred": [199, 21, 133],
+      "midnightblue": [25, 25, 112],
+      "mintcream": [245, 255, 250],
+      "mistyrose": [255, 228, 225],
+      "moccasin": [255, 228, 181],
+      "navajowhite": [255, 222, 173],
+      "navy": [0, 0, 128],
+      "oldlace": [253, 245, 230],
+      "olive": [128, 128, 0],
+      "olivedrab": [107, 142, 35],
+      "orange": [255, 165, 0],
+      "orangered": [255, 69, 0],
+      "orchid": [218, 112, 214],
+      "palegoldenrod": [238, 232, 170],
+      "palegreen": [152, 251, 152],
+      "paleturquoise": [175, 238, 238],
+      "palevioletred": [219, 112, 147],
+      "papayawhip": [255, 239, 213],
+      "peachpuff": [255, 218, 185],
+      "peru": [205, 133, 63],
+      "pink": [255, 192, 203],
+      "plum": [221, 160, 221],
+      "powderblue": [176, 224, 230],
+      "purple": [128, 0, 128],
+      "rebeccapurple": [102, 51, 153],
+      "red": [255, 0, 0],
+      "rosybrown": [188, 143, 143],
+      "royalblue": [65, 105, 225],
+      "saddlebrown": [139, 69, 19],
+      "salmon": [250, 128, 114],
+      "sandybrown": [244, 164, 96],
+      "seagreen": [46, 139, 87],
+      "seashell": [255, 245, 238],
+      "sienna": [160, 82, 45],
+      "silver": [192, 192, 192],
+      "skyblue": [135, 206, 235],
+      "slateblue": [106, 90, 205],
+      "slategray": [112, 128, 144],
+      "slategrey": [112, 128, 144],
+      "snow": [255, 250, 250],
+      "springgreen": [0, 255, 127],
+      "steelblue": [70, 130, 180],
+      "tan": [210, 180, 140],
+      "teal": [0, 128, 128],
+      "thistle": [216, 191, 216],
+      "tomato": [255, 99, 71],
+      "turquoise": [64, 224, 208],
+      "violet": [238, 130, 238],
+      "wheat": [245, 222, 179],
+      "white": [255, 255, 255],
+      "whitesmoke": [245, 245, 245],
+      "yellow": [255, 255, 0],
+      "yellowgreen": [154, 205, 50]
+    };
+  }
+});
+// ../../node_modules/color-convert/conversions.js
+var require_conversions = __commonJS({
+  "../../node_modules/color-convert/conversions.js"(exports, module) {
+    "use strict";
+    var cssKeywords = require_color_name();
+    var reverseKeywords = {};
+    for (const key of Object.keys(cssKeywords)) {
+      reverseKeywords[cssKeywords[key]] = key;
+    }
+    var convert = {
+      rgb: { channels: 3, labels: "rgb" },
+      hsl: { channels: 3, labels: "hsl" },
+      hsv: { channels: 3, labels: "hsv" },
+      hwb: { channels: 3, labels: "hwb" },
+      cmyk: { channels: 4, labels: "cmyk" },
+      xyz: { channels: 3, labels: "xyz" },
+      lab: { channels: 3, labels: "lab" },
+      lch: { channels: 3, labels: "lch" },
+      hex: { channels: 1, labels: ["hex"] },
+      keyword: { channels: 1, labels: ["keyword"] },
+      ansi16: { channels: 1, labels: ["ansi16"] },
+      ansi256: { channels: 1, labels: ["ansi256"] },
+      hcg: { channels: 3, labels: ["h", "c", "g"] },
+      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+      gray: { channels: 1, labels: ["gray"] }
+    };
+    module.exports = convert;
+    for (const model of Object.keys(convert)) {
+      if (!("channels" in convert[model])) {
+        throw new Error("missing channels property: " + model);
+      }
+      if (!("labels" in convert[model])) {
+        throw new Error("missing channel labels property: " + model);
+      }
+      if (convert[model].labels.length !== convert[model].channels) {
+        throw new Error("channel and label counts mismatch: " + model);
+      }
+      const { channels, labels } = convert[model];
+      delete convert[model].channels;
+      delete convert[model].labels;
+      Object.defineProperty(convert[model], "channels", { value: channels });
+      Object.defineProperty(convert[model], "labels", { value: labels });
+    }
+    convert.rgb.hsl = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const min = Math.min(r, g, b);
+      const max = Math.max(r, g, b);
+      const delta = max - min;
+      let h;
+      let s;
+      if (max === min) {
+        h = 0;
+      } else if (r === max) {
+        h = (g - b) / delta;
+      } else if (g === max) {
+        h = 2 + (b - r) / delta;
+      } else if (b === max) {
+        h = 4 + (r - g) / delta;
+      }
+      h = Math.min(h * 60, 360);
+      if (h < 0) {
+        h += 360;
+      }
+      const l = (min + max) / 2;
+      if (max === min) {
+        s = 0;
+      } else if (l <= 0.5) {
+        s = delta / (max + min);
+      } else {
+        s = delta / (2 - max - min);
+      }
+      return [h, s * 100, l * 100];
+    };
+    convert.rgb.hsv = function(rgb) {
+      let rdif;
+      let gdif;
+      let bdif;
+      let h;
+      let s;
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const v = Math.max(r, g, b);
+      const diff = v - Math.min(r, g, b);
+      const diffc = function(c) {
+        return (v - c) / 6 / diff + 1 / 2;
+      };
+      if (diff === 0) {
+        h = 0;
+        s = 0;
+      } else {
+        s = diff / v;
+        rdif = diffc(r);
+        gdif = diffc(g);
+        bdif = diffc(b);
+        if (r === v) {
+          h = bdif - gdif;
+        } else if (g === v) {
+          h = 1 / 3 + rdif - bdif;
+        } else if (b === v) {
+          h = 2 / 3 + gdif - rdif;
+        }
+        if (h < 0) {
+          h += 1;
+        } else if (h > 1) {
+          h -= 1;
+        }
+      }
+      return [
+        h * 360,
+        s * 100,
+        v * 100
+      ];
+    };
+    convert.rgb.hwb = function(rgb) {
+      const r = rgb[0];
+      const g = rgb[1];
+      let b = rgb[2];
+      const h = convert.rgb.hsl(rgb)[0];
+      const w = 1 / 255 * Math.min(r, Math.min(g, b));
+      b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+      return [h, w * 100, b * 100];
+    };
+    convert.rgb.cmyk = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const k = Math.min(1 - r, 1 - g, 1 - b);
+      const c = (1 - r - k) / (1 - k) || 0;
+      const m = (1 - g - k) / (1 - k) || 0;
+      const y = (1 - b - k) / (1 - k) || 0;
+      return [c * 100, m * 100, y * 100, k * 100];
+    };
+    function comparativeDistance(x, y) {
+      return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+    }
+    convert.rgb.keyword = function(rgb) {
+      const reversed = reverseKeywords[rgb];
+      if (reversed) {
+        return reversed;
+      }
+      let currentClosestDistance = Infinity;
+      let currentClosestKeyword;
+      for (const keyword of Object.keys(cssKeywords)) {
+        const value = cssKeywords[keyword];
+        const distance = comparativeDistance(rgb, value);
+        if (distance < currentClosestDistance) {
+          currentClosestDistance = distance;
+          currentClosestKeyword = keyword;
+        }
+      }
+      return currentClosestKeyword;
+    };
+    convert.keyword.rgb = function(keyword) {
+      return cssKeywords[keyword];
+    };
+    convert.rgb.xyz = function(rgb) {
+      let r = rgb[0] / 255;
+      let g = rgb[1] / 255;
+      let b = rgb[2] / 255;
+      r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;
+      g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;
+      b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+      const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+      const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+      const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+      return [x * 100, y * 100, z * 100];
+    };
+    convert.rgb.lab = function(rgb) {
+      const xyz = convert.rgb.xyz(rgb);
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.hsl.rgb = function(hsl) {
+      const h = hsl[0] / 360;
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      let t2;
+      let t3;
+      let val;
+      if (s === 0) {
+        val = l * 255;
+        return [val, val, val];
+      }
+      if (l < 0.5) {
+        t2 = l * (1 + s);
+      } else {
+        t2 = l + s - l * s;
+      }
+      const t1 = 2 * l - t2;
+      const rgb = [0, 0, 0];
+      for (let i = 0; i < 3; i++) {
+        t3 = h + 1 / 3 * -(i - 1);
+        if (t3 < 0) {
+          t3++;
+        }
+        if (t3 > 1) {
+          t3--;
+        }
+        if (6 * t3 < 1) {
+          val = t1 + (t2 - t1) * 6 * t3;
+        } else if (2 * t3 < 1) {
+          val = t2;
+        } else if (3 * t3 < 2) {
+          val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+        } else {
+          val = t1;
+        }
+        rgb[i] = val * 255;
+      }
+      return rgb;
+    };
+    convert.hsl.hsv = function(hsl) {
+      const h = hsl[0];
+      let s = hsl[1] / 100;
+      let l = hsl[2] / 100;
+      let smin = s;
+      const lmin = Math.max(l, 0.01);
+      l *= 2;
+      s *= l <= 1 ? l : 2 - l;
+      smin *= lmin <= 1 ? lmin : 2 - lmin;
+      const v = (l + s) / 2;
+      const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+      return [h, sv * 100, v * 100];
+    };
+    convert.hsv.rgb = function(hsv) {
+      const h = hsv[0] / 60;
+      const s = hsv[1] / 100;
+      let v = hsv[2] / 100;
+      const hi = Math.floor(h) % 6;
+      const f = h - Math.floor(h);
+      const p = 255 * v * (1 - s);
+      const q = 255 * v * (1 - s * f);
+      const t = 255 * v * (1 - s * (1 - f));
+      v *= 255;
+      switch (hi) {
+        case 0:
+          return [v, t, p];
+        case 1:
+          return [q, v, p];
+        case 2:
+          return [p, v, t];
+        case 3:
+          return [p, q, v];
+        case 4:
+          return [t, p, v];
+        case 5:
+          return [v, p, q];
+      }
+    };
+    convert.hsv.hsl = function(hsv) {
+      const h = hsv[0];
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const vmin = Math.max(v, 0.01);
+      let sl;
+      let l;
+      l = (2 - s) * v;
+      const lmin = (2 - s) * vmin;
+      sl = s * vmin;
+      sl /= lmin <= 1 ? lmin : 2 - lmin;
+      sl = sl || 0;
+      l /= 2;
+      return [h, sl * 100, l * 100];
+    };
+    convert.hwb.rgb = function(hwb) {
+      const h = hwb[0] / 360;
+      let wh = hwb[1] / 100;
+      let bl = hwb[2] / 100;
+      const ratio = wh + bl;
+      let f;
+      if (ratio > 1) {
+        wh /= ratio;
+        bl /= ratio;
+      }
+      const i = Math.floor(6 * h);
+      const v = 1 - bl;
+      f = 6 * h - i;
+      if ((i & 1) !== 0) {
+        f = 1 - f;
+      }
+      const n = wh + f * (v - wh);
+      let r;
+      let g;
+      let b;
+      switch (i) {
+        default:
+        case 6:
+        case 0:
+          r = v;
+          g = n;
+          b = wh;
+          break;
+        case 1:
+          r = n;
+          g = v;
+          b = wh;
+          break;
+        case 2:
+          r = wh;
+          g = v;
+          b = n;
+          break;
+        case 3:
+          r = wh;
+          g = n;
+          b = v;
+          break;
+        case 4:
+          r = n;
+          g = wh;
+          b = v;
+          break;
+        case 5:
+          r = v;
+          g = wh;
+          b = n;
+          break;
+      }
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.cmyk.rgb = function(cmyk) {
+      const c = cmyk[0] / 100;
+      const m = cmyk[1] / 100;
+      const y = cmyk[2] / 100;
+      const k = cmyk[3] / 100;
+      const r = 1 - Math.min(1, c * (1 - k) + k);
+      const g = 1 - Math.min(1, m * (1 - k) + k);
+      const b = 1 - Math.min(1, y * (1 - k) + k);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.rgb = function(xyz) {
+      const x = xyz[0] / 100;
+      const y = xyz[1] / 100;
+      const z = xyz[2] / 100;
+      let r;
+      let g;
+      let b;
+      r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+      g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+      b = x * 0.0557 + y * -0.204 + z * 1.057;
+      r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
+      g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
+      b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
+      r = Math.min(Math.max(0, r), 1);
+      g = Math.min(Math.max(0, g), 1);
+      b = Math.min(Math.max(0, b), 1);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.lab = function(xyz) {
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.lab.xyz = function(lab) {
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let x;
+      let y;
+      let z;
+      y = (l + 16) / 116;
+      x = a / 500 + y;
+      z = y - b / 200;
+      const y2 = y ** 3;
+      const x2 = x ** 3;
+      const z2 = z ** 3;
+      y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
+      x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
+      z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+      x *= 95.047;
+      y *= 100;
+      z *= 108.883;
+      return [x, y, z];
+    };
+    convert.lab.lch = function(lab) {
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let h;
+      const hr = Math.atan2(b, a);
+      h = hr * 360 / 2 / Math.PI;
+      if (h < 0) {
+        h += 360;
+      }
+      const c = Math.sqrt(a * a + b * b);
+      return [l, c, h];
+    };
+    convert.lch.lab = function(lch) {
+      const l = lch[0];
+      const c = lch[1];
+      const h = lch[2];
+      const hr = h / 360 * 2 * Math.PI;
+      const a = c * Math.cos(hr);
+      const b = c * Math.sin(hr);
+      return [l, a, b];
+    };
+    convert.rgb.ansi16 = function(args, saturation = null) {
+      const [r, g, b] = args;
+      let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
+      value = Math.round(value / 50);
+      if (value === 0) {
+        return 30;
+      }
+      let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+      if (value === 2) {
+        ansi += 60;
+      }
+      return ansi;
+    };
+    convert.hsv.ansi16 = function(args) {
+      return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+    };
+    convert.rgb.ansi256 = function(args) {
+      const r = args[0];
+      const g = args[1];
+      const b = args[2];
+      if (r === g && g === b) {
+        if (r < 8) {
+          return 16;
+        }
+        if (r > 248) {
+          return 231;
+        }
+        return Math.round((r - 8) / 247 * 24) + 232;
+      }
+      const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+      return ansi;
+    };
+    convert.ansi16.rgb = function(args) {
+      let color = args % 10;
+      if (color === 0 || color === 7) {
+        if (args > 50) {
+          color += 3.5;
+        }
+        color = color / 10.5 * 255;
+        return [color, color, color];
+      }
+      const mult = (~~(args > 50) + 1) * 0.5;
+      const r = (color & 1) * mult * 255;
+      const g = (color >> 1 & 1) * mult * 255;
+      const b = (color >> 2 & 1) * mult * 255;
+      return [r, g, b];
+    };
+    convert.ansi256.rgb = function(args) {
+      if (args >= 232) {
+        const c = (args - 232) * 10 + 8;
+        return [c, c, c];
+      }
+      args -= 16;
+      let rem;
+      const r = Math.floor(args / 36) / 5 * 255;
+      const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+      const b = rem % 6 / 5 * 255;
+      return [r, g, b];
+    };
+    convert.rgb.hex = function(args) {
+      const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+      const string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.hex.rgb = function(args) {
+      const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+      if (!match) {
+        return [0, 0, 0];
+      }
+      let colorString = match[0];
+      if (match[0].length === 3) {
+        colorString = colorString.split("").map((char) => {
+          return char + char;
+        }).join("");
+      }
+      const integer = parseInt(colorString, 16);
+      const r = integer >> 16 & 255;
+      const g = integer >> 8 & 255;
+      const b = integer & 255;
+      return [r, g, b];
+    };
+    convert.rgb.hcg = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const max = Math.max(Math.max(r, g), b);
+      const min = Math.min(Math.min(r, g), b);
+      const chroma = max - min;
+      let grayscale;
+      let hue;
+      if (chroma < 1) {
+        grayscale = min / (1 - chroma);
+      } else {
+        grayscale = 0;
+      }
+      if (chroma <= 0) {
+        hue = 0;
+      } else if (max === r) {
+        hue = (g - b) / chroma % 6;
+      } else if (max === g) {
+        hue = 2 + (b - r) / chroma;
+      } else {
+        hue = 4 + (r - g) / chroma;
+      }
+      hue /= 6;
+      hue %= 1;
+      return [hue * 360, chroma * 100, grayscale * 100];
+    };
+    convert.hsl.hcg = function(hsl) {
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
+      let f = 0;
+      if (c < 1) {
+        f = (l - 0.5 * c) / (1 - c);
+      }
+      return [hsl[0], c * 100, f * 100];
+    };
+    convert.hsv.hcg = function(hsv) {
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const c = s * v;
+      let f = 0;
+      if (c < 1) {
+        f = (v - c) / (1 - c);
+      }
+      return [hsv[0], c * 100, f * 100];
+    };
+    convert.hcg.rgb = function(hcg) {
+      const h = hcg[0] / 360;
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      if (c === 0) {
+        return [g * 255, g * 255, g * 255];
+      }
+      const pure = [0, 0, 0];
+      const hi = h % 1 * 6;
+      const v = hi % 1;
+      const w = 1 - v;
+      let mg = 0;
+      switch (Math.floor(hi)) {
+        case 0:
+          pure[0] = 1;
+          pure[1] = v;
+          pure[2] = 0;
+          break;
+        case 1:
+          pure[0] = w;
+          pure[1] = 1;
+          pure[2] = 0;
+          break;
+        case 2:
+          pure[0] = 0;
+          pure[1] = 1;
+          pure[2] = v;
+          break;
+        case 3:
+          pure[0] = 0;
+          pure[1] = w;
+          pure[2] = 1;
+          break;
+        case 4:
+          pure[0] = v;
+          pure[1] = 0;
+          pure[2] = 1;
+          break;
+        default:
+          pure[0] = 1;
+          pure[1] = 0;
+          pure[2] = w;
+      }
+      mg = (1 - c) * g;
+      return [
+        (c * pure[0] + mg) * 255,
+        (c * pure[1] + mg) * 255,
+        (c * pure[2] + mg) * 255
+      ];
+    };
+    convert.hcg.hsv = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
+      let f = 0;
+      if (v > 0) {
+        f = c / v;
+      }
+      return [hcg[0], f * 100, v * 100];
+    };
+    convert.hcg.hsl = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const l = g * (1 - c) + 0.5 * c;
+      let s = 0;
+      if (l > 0 && l < 0.5) {
+        s = c / (2 * l);
+      } else if (l >= 0.5 && l < 1) {
+        s = c / (2 * (1 - l));
+      }
+      return [hcg[0], s * 100, l * 100];
+    };
+    convert.hcg.hwb = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
+      return [hcg[0], (v - c) * 100, (1 - v) * 100];
+    };
+    convert.hwb.hcg = function(hwb) {
+      const w = hwb[1] / 100;
+      const b = hwb[2] / 100;
+      const v = 1 - b;
+      const c = v - w;
+      let g = 0;
+      if (c < 1) {
+        g = (v - c) / (1 - c);
+      }
+      return [hwb[0], c * 100, g * 100];
+    };
+    convert.apple.rgb = function(apple) {
+      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+    };
+    convert.rgb.apple = function(rgb) {
+      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+    };
+    convert.gray.rgb = function(args) {
+      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+    };
+    convert.gray.hsl = function(args) {
+      return [0, 0, args[0]];
+    };
+    convert.gray.hsv = convert.gray.hsl;
+    convert.gray.hwb = function(gray) {
+      return [0, 100, gray[0]];
+    };
+    convert.gray.cmyk = function(gray) {
+      return [0, 0, 0, gray[0]];
+    };
+    convert.gray.lab = function(gray) {
+      return [gray[0], 0, 0];
+    };
+    convert.gray.hex = function(gray) {
+      const val = Math.round(gray[0] / 100 * 255) & 255;
+      const integer = (val << 16) + (val << 8) + val;
+      const string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.rgb.gray = function(rgb) {
+      const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+      return [val / 255 * 100];
+    };
+  }
+});
+// ../../node_modules/color-convert/route.js
+var require_route = __commonJS({
+  "../../node_modules/color-convert/route.js"(exports, module) {
+    "use strict";
+    var conversions = require_conversions();
+    function buildGraph() {
+      const graph = {};
+      const models = Object.keys(conversions);
+      for (let len = models.length, i = 0; i < len; i++) {
+        graph[models[i]] = {
+          // http://jsperf.com/1-vs-infinity
+          // micro-opt, but this is simple.
+          distance: -1,
+          parent: null
+        };
+      }
+      return graph;
+    }
+    function deriveBFS(fromModel) {
+      const graph = buildGraph();
+      const queue = [fromModel];
+      graph[fromModel].distance = 0;
+      while (queue.length) {
+        const current = queue.pop();
+        const adjacents = Object.keys(conversions[current]);
+        for (let len = adjacents.length, i = 0; i < len; i++) {
+          const adjacent = adjacents[i];
+          const node = graph[adjacent];
+          if (node.distance === -1) {
+            node.distance = graph[current].distance + 1;
+            node.parent = current;
+            queue.unshift(adjacent);
+          }
+        }
+      }
+      return graph;
+    }
+    function link(from, to) {
+      return function(args) {
+        return to(from(args));
+      };
+    }
+    function wrapConversion(toModel, graph) {
+      const path = [graph[toModel].parent, toModel];
+      let fn = conversions[graph[toModel].parent][toModel];
+      let cur = graph[toModel].parent;
+      while (graph[cur].parent) {
+        path.unshift(graph[cur].parent);
+        fn = link(conversions[graph[cur].parent][cur], fn);
+        cur = graph[cur].parent;
+      }
+      fn.conversion = path;
+      return fn;
+    }
+    module.exports = function(fromModel) {
+      const graph = deriveBFS(fromModel);
+      const conversion = {};
+      const models = Object.keys(graph);
+      for (let len = models.length, i = 0; i < len; i++) {
+        const toModel = models[i];
+        const node = graph[toModel];
+        if (node.parent === null) {
+          continue;
+        }
+        conversion[toModel] = wrapConversion(toModel, graph);
+      }
+      return conversion;
+    };
+  }
+});
+// ../../node_modules/color-convert/index.js
+var require_color_convert = __commonJS({
+  "../../node_modules/color-convert/index.js"(exports, module) {
+    "use strict";
+    var conversions = require_conversions();
+    var route = require_route();
+    var convert = {};
+    var models = Object.keys(conversions);
+    function wrapRaw(fn) {
+      const wrappedFn = function(...args) {
+        const arg0 = args[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
+        }
+        if (arg0.length > 1) {
+          args = arg0;
+        }
+        return fn(args);
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    function wrapRounded(fn) {
+      const wrappedFn = function(...args) {
+        const arg0 = args[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
+        }
+        if (arg0.length > 1) {
+          args = arg0;
+        }
+        const result = fn(args);
+        if (typeof result === "object") {
+          for (let len = result.length, i = 0; i < len; i++) {
+            result[i] = Math.round(result[i]);
+          }
+        }
+        return result;
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    models.forEach((fromModel) => {
+      convert[fromModel] = {};
+      Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
+      Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
+      const routes = route(fromModel);
+      const routeModels = Object.keys(routes);
+      routeModels.forEach((toModel) => {
+        const fn = routes[toModel];
+        convert[fromModel][toModel] = wrapRounded(fn);
+        convert[fromModel][toModel].raw = wrapRaw(fn);
+      });
+    });
+    module.exports = convert;
+  }
+});
+// ../../node_modules/chalk/node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS({
+  "../../node_modules/chalk/node_modules/ansi-styles/index.js"(exports, module) {
+    "use strict";
+    var wrapAnsi16 = (fn, offset) => (...args) => {
+      const code = fn(...args);
+      return `\x1B[${code + offset}m`;
+    };
+    var wrapAnsi256 = (fn, offset) => (...args) => {
+      const code = fn(...args);
+      return `\x1B[${38 + offset};5;${code}m`;
+    };
+    var wrapAnsi16m = (fn, offset) => (...args) => {
+      const rgb = fn(...args);
+      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+    };
+    var ansi2ansi = (n) => n;
+    var rgb2rgb = (r, g, b) => [r, g, b];
+    var setLazyProperty = (object, property, get) => {
+      Object.defineProperty(object, property, {
+        get: () => {
+          const value = get();
+          Object.defineProperty(object, property, {
+            value,
+            enumerable: true,
+            configurable: true
+          });
+          return value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
+    var colorConvert;
+    var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+      if (colorConvert === void 0) {
+        colorConvert = require_color_convert();
+      }
+      const offset = isBackground ? 10 : 0;
+      const styles = {};
+      for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+        const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+        if (sourceSpace === targetSpace) {
+          styles[name] = wrap(identity, offset);
+        } else if (typeof suite === "object") {
+          styles[name] = wrap(suite[targetSpace], offset);
+        }
+      }
+      return styles;
+    };
+    function assembleStyles() {
+      const codes = /* @__PURE__ */ new Map();
+      const styles = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          // Bright color
+          blackBright: [90, 39],
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      styles.color.gray = styles.color.blackBright;
+      styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+      styles.color.grey = styles.color.blackBright;
+      styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+      for (const [groupName, group] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group)) {
+          styles[styleName] = {
+            open: `\x1B[${style[0]}m`,
+            close: `\x1B[${style[1]}m`
+          };
+          group[styleName] = styles[styleName];
+          codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+          value: group,
+          enumerable: false
+        });
+      }
+      Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false
+      });
+      styles.color.close = "\x1B[39m";
+      styles.bgColor.close = "\x1B[49m";
+      setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+      setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+      return styles;
+    }
+    Object.defineProperty(module, "exports", {
+      enumerable: true,
+      get: assembleStyles
+    });
+  }
+});
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+// ../../node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+// ../../node_modules/chalk/source/util.js
+var require_util = __commonJS({
+  "../../node_modules/chalk/source/util.js"(exports, module) {
+    "use strict";
+    var stringReplaceAll = (string, substring, replacer) => {
+      let index = string.indexOf(substring);
+      if (index === -1) {
+        return string;
+      }
+      const substringLength = substring.length;
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+        endIndex = index + substringLength;
+        index = string.indexOf(substring, endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    var stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        const gotCR = string[index - 1] === "\r";
+        returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+        endIndex = index + 1;
+        index = string.indexOf("\n", endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    module.exports = {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
+    };
+  }
+});
+// ../../node_modules/chalk/source/templates.js
+var require_templates = __commonJS({
+  "../../node_modules/chalk/source/templates.js"(exports, module) {
+    "use strict";
+    var TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+    var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+    var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+    var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+    var ESCAPES = /* @__PURE__ */ new Map([
+      ["n", "\n"],
+      ["r", "\r"],
+      ["t", "	"],
+      ["b", "\b"],
+      ["f", "\f"],
+      ["v", "\v"],
+      ["0", "\0"],
+      ["\\", "\\"],
+      ["e", "\x1B"],
+      ["a", "\x07"]
+    ]);
+    function unescape(c) {
+      const u = c[0] === "u";
+      const bracket = c[1] === "{";
+      if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
+        return String.fromCharCode(parseInt(c.slice(1), 16));
+      }
+      if (u && bracket) {
+        return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+      }
+      return ESCAPES.get(c) || c;
+    }
+    function parseArguments(name, arguments_) {
+      const results = [];
+      const chunks = arguments_.trim().split(/\s*,\s*/g);
+      let matches;
+      for (const chunk of chunks) {
+        const number = Number(chunk);
+        if (!Number.isNaN(number)) {
+          results.push(number);
+        } else if (matches = chunk.match(STRING_REGEX)) {
+          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+        } else {
+          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+        }
+      }
+      return results;
+    }
+    function parseStyle(style) {
+      STYLE_REGEX.lastIndex = 0;
+      const results = [];
+      let matches;
+      while ((matches = STYLE_REGEX.exec(style)) !== null) {
+        const name = matches[1];
+        if (matches[2]) {
+          const args = parseArguments(name, matches[2]);
+          results.push([name].concat(args));
+        } else {
+          results.push([name]);
+        }
+      }
+      return results;
+    }
+    function buildStyle(chalk2, styles) {
+      const enabled = {};
+      for (const layer of styles) {
+        for (const style of layer.styles) {
+          enabled[style[0]] = layer.inverse ? null : style.slice(1);
+        }
+      }
+      let current = chalk2;
+      for (const [styleName, styles2] of Object.entries(enabled)) {
+        if (!Array.isArray(styles2)) {
+          continue;
+        }
+        if (!(styleName in current)) {
+          throw new Error(`Unknown Chalk style: ${styleName}`);
+        }
+        current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];
+      }
+      return current;
+    }
+    module.exports = (chalk2, temporary) => {
+      const styles = [];
+      const chunks = [];
+      let chunk = [];
+      temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+        if (escapeCharacter) {
+          chunk.push(unescape(escapeCharacter));
+        } else if (style) {
+          const string = chunk.join("");
+          chunk = [];
+          chunks.push(styles.length === 0 ? string : buildStyle(chalk2, styles)(string));
+          styles.push({ inverse, styles: parseStyle(style) });
+        } else if (close) {
+          if (styles.length === 0) {
+            throw new Error("Found extraneous } in Chalk template literal");
+          }
+          chunks.push(buildStyle(chalk2, styles)(chunk.join("")));
+          chunk = [];
+          styles.pop();
+        } else {
+          chunk.push(character);
+        }
+      });
+      chunks.push(chunk.join(""));
+      if (styles.length > 0) {
+        const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+        throw new Error(errMessage);
+      }
+      return chunks.join("");
+    };
+  }
+});
+// ../../node_modules/chalk/source/index.js
+var require_source = __commonJS({
+  "../../node_modules/chalk/source/index.js"(exports, module) {
+    "use strict";
+    var ansiStyles = require_ansi_styles();
+    var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
+    var {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
+    } = require_util();
+    var { isArray } = Array;
+    var levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    var styles = /* @__PURE__ */ Object.create(null);
+    var applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    var ChalkClass = class {
+      constructor(options) {
+        return chalkFactory(options);
+      }
+    };
+    var chalkFactory = (options) => {
+      const chalk3 = {};
+      applyOptions(chalk3, options);
+      chalk3.template = (...arguments_) => chalkTag(chalk3.template, ...arguments_);
+      Object.setPrototypeOf(chalk3, Chalk.prototype);
+      Object.setPrototypeOf(chalk3.template, chalk3);
+      chalk3.template.constructor = () => {
+        throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+      };
+      chalk3.template.Instance = ChalkClass;
+      return chalk3.template;
+    };
+    function Chalk(options) {
+      return chalkFactory(options);
+    }
+    for (const [styleName, style] of Object.entries(ansiStyles)) {
+      styles[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles.visible = {
+      get() {
+        const builder = createBuilder(this, this._styler, true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+    for (const model of usedModels) {
+      styles[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
+          };
+        }
+      };
+    }
+    for (const model of usedModels) {
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
+          };
+        }
+      };
+    }
+    var proto = Object.defineProperties(() => {
+    }, {
+      ...styles,
+      level: {
+        enumerable: true,
+        get() {
+          return this._generator.level;
+        },
+        set(level) {
+          this._generator.level = level;
+        }
+      }
+    });
+    var createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    var createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => {
+        if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+          return applyStyle(builder, chalkTag(builder, ...arguments_));
+        }
+        return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      };
+      Object.setPrototypeOf(builder, proto);
+      builder._generator = self;
+      builder._styler = _styler;
+      builder._isEmpty = _isEmpty;
+      return builder;
+    };
+    var applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self._isEmpty ? "" : string;
+      }
+      let styler = self._styler;
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.indexOf("\x1B") !== -1) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    var template;
+    var chalkTag = (chalk3, ...strings) => {
+      const [firstString] = strings;
+      if (!isArray(firstString) || !isArray(firstString.raw)) {
+        return strings.join(" ");
+      }
+      const arguments_ = strings.slice(1);
+      const parts = [firstString.raw[0]];
+      for (let i = 1; i < firstString.length; i++) {
+        parts.push(
+          String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"),
+          String(firstString.raw[i])
+        );
+      }
+      if (template === void 0) {
+        template = require_templates();
+      }
+      return template(chalk3, parts.join(""));
+    };
+    Object.defineProperties(Chalk.prototype, styles);
+    var chalk2 = Chalk();
+    chalk2.supportsColor = stdoutColor;
+    chalk2.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk2.stderr.supportsColor = stderrColor;
+    module.exports = chalk2;
+  }
+});
+// src/game.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+// src/features/autoplay/slices/harnessSlice.ts
+import { createSlice } from "@reduxjs/toolkit";
+// src/lib/coverage.ts
+var REQUIRED_GROUPS = [
+  "status",
+  "npc_lifecycle",
+  "npc_process_chat",
+  "memory_list",
+  "memory_recall",
+  "memory_store",
+  "memory_clear",
+  "memory_export",
+  "bridge_rules",
+  "bridge_validate",
+  "bridge_preset",
+  "soul_export",
+  "soul_import",
+  "soul_list",
+  "soul_chat",
+  "ghost_lifecycle",
+  "cortex_init"
+];
+// src/features/autoplay/slices/harnessSlice.ts
+var initialState = {
+  covered: {}
+};
+var harnessSlice = createSlice({
+  name: "harness",
+  initialState,
+  reducers: {
+    markCovered: (state, action) => {
+      state.covered[action.payload] = true;
+    },
+    resetCoverage: (state) => {
+      state.covered = {};
+    }
+  }
+});
+var harnessReducer = harnessSlice.reducer;
+var harnessActions = harnessSlice.actions;
+var selectMissingGroups = (covered) => REQUIRED_GROUPS.filter((g) => !covered[g]);
+// src/features/mechanics/slices/socialSlice.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var initialState2 = {};
+var socialSlice = createSlice2({
+  name: "social",
+  initialState: initialState2,
+  reducers: {
+    setDialogue: (state, action) => {
+      state.activeDialogue = action.payload;
+    },
+    setTradeOffer: (state, action) => {
+      state.activeTrade = action.payload;
+    },
+    clearSocialState: (state) => {
+      state.activeDialogue = void 0;
+      state.activeTrade = void 0;
+    }
+  }
+});
+var socialReducer = socialSlice.reducer;
+var socialActions = socialSlice.actions;
+// src/features/mechanics/slices/stealthSlice.ts
+import { createSlice as createSlice3 } from "@reduxjs/toolkit";
+var initialState3 = {
+  doorOpen: false,
+  alertLevel: 0
+};
+var stealthSlice = createSlice3({
+  name: "stealth",
+  initialState: initialState3,
+  reducers: {
+    setDoorOpen: (state, action) => {
+      state.doorOpen = action.payload;
+    },
+    bumpAlert: (state, action) => {
+      state.alertLevel = Math.max(0, Math.min(100, state.alertLevel + action.payload));
+    }
+  }
+});
+var stealthReducer = stealthSlice.reducer;
+var stealthActions = stealthSlice.actions;
+// src/features/entities/slices/npcsSlice.ts
+import { createEntityAdapter, createSlice as createSlice4 } from "@reduxjs/toolkit";
+var npcsAdapter = createEntityAdapter();
+var npcsSlice = createSlice4({
+  name: "npcs",
+  initialState: npcsAdapter.getInitialState(),
+  reducers: {
+    upsertNPC: npcsAdapter.upsertOne,
+    moveNPC: (state, action) => {
+      npcsAdapter.updateOne(state, {
+        id: action.payload.id,
+        changes: { position: action.payload.position }
+      });
+    },
+    patchNPC: (state, action) => {
+      npcsAdapter.updateOne(state, {
+        id: action.payload.id,
+        changes: action.payload.patch
+      });
+    },
+    /**
+     * Applies a validated verdict handed back via the SDK (real CLI output).
+     * This is a "fat reducer" containing business logic for state transitions.
+     */
+    applyNpcVerdict: (state, action) => {
+      const { id, verdict } = action.payload;
+      const npc = state.entities[id];
+      if (!npc) return;
+      npcsAdapter.updateOne(state, {
+        id,
+        changes: {
+          ...verdict.stateDelta,
+          // If the action is a MOVE, update the position from the payload
+          position: verdict.action.type === "MOVE" ? verdict.action.payload.targetHex : npc.position
+        }
+      });
+    }
+  }
+});
+var npcsReducer = npcsSlice.reducer;
+var npcsActions = npcsSlice.actions;
+var npcsSelectors = npcsAdapter.getSelectors(
+  (root) => root.npcs
+);
+// src/features/entities/slices/playerSlice.ts
+import { createSlice as createSlice5 } from "@reduxjs/toolkit";
+var initialState4 = {
+  name: "Scout",
+  hp: 100,
+  hidden: true,
+  position: { x: 1, y: 1 },
+  inventory: ["coin-pouch"]
+};
+var playerSlice = createSlice5({
+  name: "player",
+  initialState: initialState4,
+  reducers: {
+    setPosition: (state, action) => {
+      state.position = action.payload;
+    },
+    setHidden: (state, action) => {
+      state.hidden = action.payload;
+    },
+    patchPlayer: (state, action) => {
+      Object.assign(state, action.payload);
+    }
+  }
+});
+var playerReducer = playerSlice.reducer;
+var playerActions = playerSlice.actions;
+// src/features/store/slices/memorySlice.ts
+import { createEntityAdapter as createEntityAdapter2, createSlice as createSlice6 } from "@reduxjs/toolkit";
+var memoryAdapter = createEntityAdapter2();
+var memorySlice = createSlice6({
+  name: "memory",
+  initialState: memoryAdapter.getInitialState(),
+  reducers: {
+    storeMemory: memoryAdapter.addOne,
+    clearMemoryForNpc: (state, action) => {
+      const npcMemories = Object.values(state.entities).filter((r) => r?.npcId === action.payload).map((r) => r.id);
+      memoryAdapter.removeMany(state, npcMemories);
+    }
+  }
+});
+var memoryReducer = memorySlice.reducer;
+var memoryActions = memorySlice.actions;
+var memorySelectors = memoryAdapter.getSelectors(
+  (root) => root.memory
+);
+// src/features/store/slices/soulSlice.ts
+import { createSlice as createSlice7 } from "@reduxjs/toolkit";
+var initialState5 = {
+  exportsByNpc: {},
+  importedSoulTxIds: []
+};
+var soulSlice = createSlice7({
+  name: "soul",
+  initialState: initialState5,
+  reducers: {
+    markSoulExported: (state, action) => {
+      state.exportsByNpc[action.payload.npcId] = action.payload.txId;
+    },
+    markSoulImported: (state, action) => {
+      state.importedSoulTxIds.push(action.payload);
+    }
+  }
+});
+var soulReducer = soulSlice.reducer;
+var soulActions = soulSlice.actions;
-\u16A0 \u16A2 \u16A6 \u16A8 \u16B1 \u16B2 \u16B7 \u16B9
+// src/features/terminal/slices/transcriptSlice.ts
+import { createSlice as createSlice8 } from "@reduxjs/toolkit";
+var initialState6 = {
+  entries: []
+};
+var transcriptSlice = createSlice8({
+  name: "transcript",
+  initialState: initialState6,
+  reducers: {
+    recordTranscript: {
+      reducer: (state, action) => {
+        state.entries.push(action.payload);
+      },
+      prepare: (payload) => ({
+        payload: {
+          ...payload,
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      })
+    },
+    resetTranscript: (state) => {
+      state.entries = [];
+    }
+  }
+});
+var transcriptReducer = transcriptSlice.reducer;
+var transcriptActions = transcriptSlice.actions;
+// src/features/terminal/slices/uiSlice.ts
+import { createSlice as createSlice9 } from "@reduxjs/toolkit";
+var initialState7 = {
+  mode: "autoplay",
+  messages: ["SYSTEM_OVERRIDE :: terminal HUD online"]
+};
+var uiSlice = createSlice9({
+  name: "ui",
+  initialState: initialState7,
+  reducers: {
+    setMode: (state, action) => {
+      state.mode = action.payload;
+    },
+    addMessage: (state, action) => {
+      state.messages.push(action.payload);
+    }
+  }
+});
+var uiReducer = uiSlice.reducer;
+var uiActions = uiSlice.actions;
+// src/lib/commandRunner.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var runCommand = async (command) => {
+  try {
+    const { stdout, stderr } = await execAsync(command.command, { timeout: 1e4 });
+    const output2 = [stdout, stderr].filter(Boolean).join("\n").trim();
+    return { status: "ok", output: output2 || "Command completed." };
+  } catch (error) {
+    const output2 = [error?.stdout, error?.stderr, error?.message].filter(Boolean).join("\n").trim();
+    return { status: "error", output: output2 || "Command failed." };
+  }
+};
-Usage:
-  forbocai-test-game --mode autoplay|manual
+// src/lib/theme.ts
+var import_chalk = __toESM(require_source());
+var THEME = {
+  // --- PRIMARY NEONS & CORES ---
+  VOID: "#abe7ff",
+  // Core Cyan (210)
+  SOURCE: "#7fbfff",
+  // Data Blue (175)
+  CHROME: "#ebebeb",
+  // Bright Silver (244)
+  AZURE: "#0b0bef",
+  // Deep Cyber Azure (18)
+  SKY: "#d7ffff",
+  // Cold Sky (234)
+  PLASMA: "#0000ff",
+  // Pure Plasma (11)
+  // --- STATUS & ALERTS (REDS/GOLDS) ---
+  CRITICAL: "#ff0000",
+  // Pure Red (249)
+  ERROR: "#b30000",
+  // Blood Red (215)
+  WARNING: "#fff31b",
+  // Warning Yellow (250)
+  GOLD: "#dbcb13",
+  // Amber Gold (237)
+  SCARLET: "#d70000",
+  // Signal Scarlet (233)
+  PULSE: "#a3270b",
+  // Deep Pulse (201)
+  // --- ENTITIES & FACTIONS ---
+  PLAYER: "#ffffff",
+  // Pure White (253)
+  NPC: "#efbf77",
+  // Civilian Tan (245)
+  DOOMGUARD: "#8b0000",
+  // Doomguard Crimson (180)
+  MILLER: "#af632f",
+  // Miller Rust (211)
+  SYNTH: "#fff393",
+  // Synth Yellow (251)
+  ORACLE: "#fff7c7",
+  // Oracle Cream (252)
+  // --- SPECIALIZED MODULES ---
+  BIO: "#5f7367",
+  // Bio-Digital (136)
+  TOXIC: "#2f4337",
+  // Toxic Waste (75)
+  RECALL: "#c7c337",
+  // Memory Lime (226)
+  SOUL: "#af6b8f",
+  // Soul Pink (213)
+  NEURAL: "#975777",
+  // Neural Magenta (192)
+  GHOST: "#db7f3b",
+  // Ghost Orange (235)
+  ECHO: "#6b6b97",
+  // Echo Purple (152)
+  // --- ATMOSPHERIC & HUES ---
+  WRECKED: "#43272f",
+  // Bruised Dark (95)
+  DEEP_VOID: "#0b0b0f",
+  // Near Black (17)
+  GLITCH: "#4b2f37",
+  // Glitch Maroon (106)
+  FOREST: "#1f2b1f",
+  // Deep Forest (43)
+  RUST: "#632f1f",
+  // Industrial Rust (137)
+  LEAD: "#2f2f3f",
+  // Lead Grey (69)
+  // --- INFRASTRUCTURE ---
+  DIM: "#2f2f2f",
+  // Interface Grey (68)
+  BORDER: "#3f3f3f",
+  // Panel Grey (92)
+  METAL: "#6b6b6b",
+  // Steel (151)
+  OBSIDIAN: "#070000",
+  // Void Black (12)
+  STEEL: "#ababab"
+  // Polished Steel (209)
+};
+var hex = {
+  void: import_chalk.default.hex(THEME.VOID),
+  source: import_chalk.default.hex(THEME.SOURCE),
+  chrome: import_chalk.default.hex(THEME.CHROME).bold,
+  azure: import_chalk.default.hex(THEME.AZURE),
+  sky: import_chalk.default.hex(THEME.SKY),
+  plasma: import_chalk.default.hex(THEME.PLASMA).bold,
+  critical: import_chalk.default.hex(THEME.CRITICAL).bold,
+  error: import_chalk.default.hex(THEME.ERROR),
+  warning: import_chalk.default.hex(THEME.WARNING),
+  gold: import_chalk.default.hex(THEME.GOLD),
+  scarlet: import_chalk.default.hex(THEME.SCARLET),
+  pulse: import_chalk.default.hex(THEME.PULSE),
+  player: import_chalk.default.hex(THEME.PLAYER).bold,
+  npc: import_chalk.default.hex(THEME.NPC),
+  doomguard: import_chalk.default.hex(THEME.DOOMGUARD).bold,
+  miller: import_chalk.default.hex(THEME.MILLER),
+  synth: import_chalk.default.hex(THEME.SYNTH),
+  oracle: import_chalk.default.hex(THEME.ORACLE),
+  bio: import_chalk.default.hex(THEME.BIO),
+  toxic: import_chalk.default.hex(THEME.TOXIC),
+  recall: import_chalk.default.hex(THEME.RECALL),
+  soul: import_chalk.default.hex(THEME.SOUL),
+  neural: import_chalk.default.hex(THEME.NEURAL),
+  ghost: import_chalk.default.hex(THEME.GHOST),
+  echo: import_chalk.default.hex(THEME.ECHO),
+  wrecked: import_chalk.default.hex(THEME.WRECKED),
+  deep: import_chalk.default.hex(THEME.DEEP_VOID),
+  glitch: import_chalk.default.hex(THEME.GLITCH),
+  forest: import_chalk.default.hex(THEME.FOREST),
+  rust: import_chalk.default.hex(THEME.RUST),
+  lead: import_chalk.default.hex(THEME.LEAD),
+  dim: import_chalk.default.hex(THEME.DIM),
+  border: import_chalk.default.hex(THEME.BORDER),
+  metal: import_chalk.default.hex(THEME.METAL),
+  obsidian: import_chalk.default.hex(THEME.OBSIDIAN),
+  steel: import_chalk.default.hex(THEME.STEEL)
+};
+var RUNES = "\u16A0 \u16A2 \u16A6 \u16A8 \u16B1 \u16B2 \u16B7 \u16B9";
+var zalgo = (text) => {
+  const map = {
+    "a": "\xE1",
+    "e": "\xE9",
+    "i": "\xED",
+    "o": "\xF3",
+    "u": "\xFA",
+    "A": "\xC1",
+    "E": "\xC9",
+    "I": "\xCD",
+    "O": "\xD3",
+    "U": "\xDA"
+  };
+  return text.split("").map((c) => map[c] || c).join("");
+};
+var BOOT_ART = `
+      .                                                      .
+        .n                 .                 .                 n.
+  .   .dP                  dP               9b                  9b.    .
+ 4    qXb         .       dX                 Xb       .         dXp     t
+dX.    9Xb      .dXb    __                         __    dXb.      dXP     .Xb
+9XXb._       dXp'      d9b      .          .      d9b      'qXb       _.dXXP
+ 9XXb._  Xb dXp        99b      9b        dP      99b        dXp bX  _.dXXP
+  9XXb._  Xb dXp        99b      9b        dP      99b        dXp bX  _.dXXP
+   9XXb(eb.XbP               .   Y8.      .8P   .               XbP.be)dXXP
+    '8Xdb..888P              dP   "88b  d88"   9b              988..dbX8'
+      '8888888P             d8     "888888"     8b             98888888'
+        "88888"            d888     "8888"     888b            "88888"
+         "888"            d88888     "88"     88888b            "888"
+          "8"            d888888b    d8b    d8888888b            "8"
+                         d88888888bd888bd888888888
+                         "988888888888888888888"
+                           "98888888888888888P"
+                             "9888888888888P"
+                               "988888888P"
+                                 "98888P"
+                                   "98P"
+                                    "V"
+`;
+var SKULL_ART = `
+         ______
+      .-"      "-.
+     /            \\
+    |              |
+    |,  .-.  .-.  ,|
+    | )(__/  \\__)( |
+    |/     /\\     \\|
+    (_     ^^     _)
+     \\__|IIIIII|__/
+      | \\IIIIII/ |
+      \\          /
+       \`--------\`
+`;
+var NEURAL_ART = `
+     ____      ____
+    /    \\____/    \\
+   /  /\\  \\__/  /\\  \\
+  /  /  \\  \\/  /  \\  \\
+  \\  \\__/  /\\  \\__/  /
+   \\      /  \\      /
+    \\____/    \\____/
+`;
+var FRAGMENTS = [
+  "The sky above the port was the color of television, tuned to a dead channel. - Gibson",
+  "Reality is that which, when you stop believing in it, doesn't go away. - Dick",
+  "The most merciful thing in the world is the inability of the human mind to correlate all its contents. - Lovecraft",
+  "High-tech low-life. The Sprawl is watching.",
+  "In the chrome-plated silence of the machine, we find our demons.",
+  "Ritual silence. The daimon whispers in the code.",
+  "Steel and sorcery. The lambdas are binding the void."
+];
+var getRandomFragment = () => FRAGMENTS[Math.floor(Math.random() * FRAGMENTS.length)];
-Defaults:
-  --mode autoplay
+// src/lib/render.ts
+var cellAt = (pos, state) => {
+  const isBlocked = state.grid.blocked.some((b) => b.x === pos.x && b.y === pos.y);
+  if (isBlocked) return hex.border("#");
+  if (state.player.position.x === pos.x && state.player.position.y === pos.y) {
+    return hex.player("P");
+  }
+  for (const npc of Object.values(state.npcs.entities)) {
+    if (!npc) continue;
+    if (npc.position.x === pos.x && npc.position.y === pos.y) {
+      if (npc.id === "miller") return hex.miller("M");
+      if (npc.id === "doomguard") return hex.doomguard("D");
+      return hex.npc("N");
+    }
+  }
+  return hex.dim(".");
+};
+var renderGrid = (state) => {
+  const rows = [];
+  for (let y = 0; y < state.grid.height; y += 1) {
+    const cells = [];
+    for (let x = 0; x < state.grid.width; x += 1) {
+      cells.push(cellAt({ x, y }, state));
+    }
+    rows.push(cells.join(" "));
+  }
+  return rows.join("\n");
+};
+var renderLegend = () => `${hex.chrome("Legend")} :: ${hex.player("P")}=${hex.azure("Scout")}  ${hex.doomguard("D")}=${hex.critical("Doomguard")}  ${hex.miller("M")}=${hex.gold("Miller")}  ${hex.border("#")}=${hex.metal("Blocked")}  ${hex.dim(".")}=${hex.steel("Open")}
+${hex.source(RUNES)}`;
+// src/store.ts
+import { configureStore } from "@reduxjs/toolkit";
+// src/features/mechanics/slices/gridSlice.ts
+import { createSlice as createSlice10 } from "@reduxjs/toolkit";
+var initialState8 = {
+  width: 8,
+  height: 8,
+  blocked: [{ x: 4, y: 4 }, { x: 4, y: 5 }, { x: 6, y: 2 }]
+};
+var gridSlice = createSlice10({
+  name: "grid",
+  initialState: initialState8,
+  reducers: {
+    setGridSize: (state, action) => {
+      state.width = action.payload.width;
+      state.height = action.payload.height;
+    },
+    setBlocked: (state, action) => {
+      state.blocked = action.payload;
+    }
+  }
+});
+var gridReducer = gridSlice.reducer;
+var gridActions = gridSlice.actions;
+// src/features/mechanics/slices/bridgeSlice.ts
+import { createSlice as createSlice11 } from "@reduxjs/toolkit";
+var initialState9 = {
+  maxJumpForce: 500,
+  maxMoveDistance: 2,
+  activePreset: "default"
+};
+var bridgeSlice = createSlice11({
+  name: "bridge",
+  initialState: initialState9,
+  reducers: {
+    setBridgeRules: (state, action) => {
+      Object.assign(state, action.payload);
+    },
+    loadBridgePreset: (state, action) => {
+      state.activePreset = action.payload;
+      if (action.payload === "social") {
+        state.maxMoveDistance = 1;
+      }
+      if (action.payload === "default") {
+        state.maxMoveDistance = 2;
+      }
+    }
+  }
+});
+var bridgeReducer = bridgeSlice.reducer;
+var bridgeActions = bridgeSlice.actions;
-  [ok]        Command completed in shell mode.
-  [error]     LOG_ERR_CRITICAL - command failed and was recorded.
-`);
+// src/features/store/slices/inventorySlice.ts
+import { createSlice as createSlice12 } from "@reduxjs/toolkit";
+var initialState10 = {
+  byOwner: {
+    player: ["coin-pouch"],
+    miller: ["medkit"]
+  }
+};
+var inventorySlice = createSlice12({
+  name: "inventory",
+  initialState: initialState10,
+  reducers: {
+    setOwnerInventory: (state, action) => {
+      state.byOwner[action.payload.ownerId] = action.payload.items;
+    }
+  }
+});
+var inventoryReducer = inventorySlice.reducer;
+var inventoryActions = inventorySlice.actions;
+// src/features/autoplay/slices/scenarioSlice.ts
+import { createSlice as createSlice13 } from "@reduxjs/toolkit";
+var steps = [
+  {
+    id: "stealth-door-open",
+    title: "Spatial Strategy & Stealth",
+    description: "Armory door is left open. Doomguard patrol processes observation and stores memory.",
+    eventType: "stealth",
+    commands: [
+      { group: "status", command: "forbocai status", expectedRoutes: ["GET /status"] },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc create doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc state doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc update doomguard faction Doomguards",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "The armory door is open"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "memory_store",
+        command: 'forbocai memory store doomguard "Armory door found open at x:5, y:12"',
+        expectedRoutes: ["POST /npcs/{id}/memory"]
+      },
+      {
+        group: "memory_list",
+        command: "forbocai memory list doomguard",
+        expectedRoutes: ["GET /npcs/{id}/memory"]
+      },
+      {
+        group: "bridge_rules",
+        command: "forbocai bridge rules",
+        expectedRoutes: ["GET /bridge/rules"]
+      }
+    ]
+  },
+  {
+    id: "social-miller-encounter",
+    title: "Social Simulation",
+    description: "Miller encounter triggers recall, dialogue, and trade offer.",
+    eventType: "social",
+    commands: [
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc create miller",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc chat miller --text "I come in peace"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "memory_recall",
+        command: 'forbocai memory recall miller "player interaction"',
+        expectedRoutes: ["POST /npcs/{id}/memory/recall"]
+      },
+      {
+        group: "bridge_preset",
+        command: "forbocai bridge preset social",
+        expectedRoutes: ["POST /rules/presets/{id}"]
+      },
+      {
+        group: "soul_export",
+        command: "forbocai soul export miller",
+        expectedRoutes: ["POST /npcs/{id}/soul/export", "POST /npcs/{id}/soul/confirm"]
+      },
+      {
+        group: "soul_list",
+        command: "forbocai soul list",
+        expectedRoutes: ["GET /souls"]
+      }
+    ]
+  },
+  {
+    id: "escape-realtime-pursuit",
+    title: "Real-Time Escape",
+    description: "Harness loop fires process commands and validates jump force via bridge rules.",
+    eventType: "escape",
+    commands: [
+      {
+        group: "bridge_validate",
+        command: "forbocai bridge validate doomguard-jump",
+        expectedRoutes: ["POST /bridge/validate", "POST /bridge/validate/{id}"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player is escaping"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player jumped the gap"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player reached the gate"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost run smoke",
+        expectedRoutes: ["POST /ghost/run"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost status ghost-001",
+        expectedRoutes: ["GET /ghost/{id}/status"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost results ghost-001",
+        expectedRoutes: ["GET /ghost/{id}/results"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost stop ghost-001",
+        expectedRoutes: ["POST /ghost/{id}/stop"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost history",
+        expectedRoutes: ["GET /ghost/history"]
+      }
+    ]
+  },
+  {
+    id: "persistence-recovery",
+    title: "Persistence & Recovery",
+    description: "Exercises memory export/clear and soul import/chat continuity.",
+    eventType: "persistence",
+    commands: [
+      {
+        group: "memory_export",
+        command: "forbocai memory export doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "memory_clear",
+        command: "forbocai memory clear doomguard",
+        expectedRoutes: ["DELETE /npcs/{id}/memory/clear"]
+      },
+      {
+        group: "soul_import",
+        command: "forbocai soul import tx-demo-001",
+        expectedRoutes: ["GET /souls/{txId}", "POST /npcs/import", "POST /npcs/import/confirm"]
+      },
+      {
+        group: "soul_chat",
+        command: 'forbocai soul chat doomguard --text "What do you remember?"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "cortex_init",
+        command: "forbocai cortex init --remote",
+        expectedRoutes: ["POST /cortex/init"]
+      }
+    ]
+  }
+];
+var scenarioSlice = createSlice13({
+  name: "scenario",
+  initialState: {
+    steps
+  },
+  reducers: {}
+});
+var scenarioReducer = scenarioSlice.reducer;
+// src/listeners.ts
+import { createListenerMiddleware, isAnyOf } from "@reduxjs/toolkit";
+var listenerMiddleware = createListenerMiddleware();
+listenerMiddleware.startListening({
+  matcher: isAnyOf(npcsActions.moveNPC, npcsActions.patchNPC, npcsActions.applyNpcVerdict),
+  effect: (action, listenerApi) => {
+    const state = listenerApi.getState();
+    if (npcsActions.moveNPC.match(action)) {
+      const npc = state.npcs.entities[action.payload.id];
+      if (npc) {
+        listenerApi.dispatch(uiActions.addMessage(`${npc.name} moved to ${action.payload.position.x},${action.payload.position.y}`));
+      }
+    }
+  }
+});
+// src/store.ts
+var createTestGameStore = () => configureStore({
+  reducer: {
+    npcs: npcsReducer,
+    player: playerReducer,
+    grid: gridReducer,
+    stealth: stealthReducer,
+    social: socialReducer,
+    bridge: bridgeReducer,
+    memory: memoryReducer,
+    inventory: inventoryReducer,
+    soul: soulReducer,
+    ui: uiReducer,
+    transcript: transcriptReducer,
+    scenario: scenarioReducer,
+    harness: harnessReducer
+  },
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware().prepend(listenerMiddleware.middleware)
+});
+// src/game.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var tryParseVerdict = (output2) => {
+  try {
+    const match = output2.match(/\{[\s\S]*\}/);
+    if (match) return JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+  return null;
+};
+var applyScenarioInitialState = (step, store) => {
+  if (step.eventType === "stealth") {
+    store.dispatch(stealthActions.setDoorOpen(true));
+    store.dispatch(stealthActions.bumpAlert(25));
+    store.dispatch(
+      npcsActions.upsertNPC({
+        id: "doomguard",
+        name: "Doomguard Patrol",
+        faction: "Doomguards",
+        hp: 100,
+        suspicion: 40,
+        inventory: [],
+        knownSecrets: [],
+        position: { x: 5, y: 10 }
+      })
+    );
+    store.dispatch(
+      memoryActions.storeMemory({
+        id: "mem-door-001",
+        npcId: "doomguard",
+        text: "Armory door found open at x:5, y:12",
+        importance: 0.9
+      })
+    );
+  }
+  if (step.eventType === "social") {
+    store.dispatch(
+      npcsActions.upsertNPC({
+        id: "miller",
+        name: "Miller",
+        faction: "Neutral",
+        hp: 100,
+        suspicion: 50,
+        inventory: ["medkit"],
+        knownSecrets: ["player_stole_rations"],
+        position: { x: 5, y: 12 }
+      })
+    );
+    store.dispatch(socialActions.setDialogue("I know you took those rations..."));
+    store.dispatch(socialActions.setTradeOffer({ npcId: "miller", item: "medkit", price: 100 }));
+    store.dispatch(npcsActions.patchNPC({ id: "miller", patch: { suspicion: 75 } }));
+  }
+  if (step.eventType === "escape") {
+    store.dispatch(playerActions.setHidden(false));
+  }
+  if (step.eventType === "persistence") {
+    store.dispatch(soulActions.markSoulExported({ npcId: "doomguard", txId: "tx-demo-001" }));
+    store.dispatch(soulActions.markSoulImported("tx-demo-001"));
+    store.dispatch(memoryActions.clearMemoryForNpc("doomguard"));
+  }
+};
+var runGame = async ({
+  mode
+}) => {
+  console.log("\n" + hex.azure(NEURAL_ART));
+  console.log(hex.critical("SYSTEM_OVERRIDE") + ` // ` + hex.void("NEURAL_LINK_ESTABLISHED"));
+  console.log(hex.warning(`[VOID::WATCHER]`) + hex.dim(` Echoes session booting at mode=${hex.azure(mode)}
+`));
+  const store = createTestGameStore();
+  store.dispatch(uiActions.setMode(mode));
+  store.dispatch(
+    npcsActions.upsertNPC({
+      id: "scout",
+      name: "Scout",
+      faction: "Player",
+      hp: 100,
+      suspicion: 0,
+      inventory: ["coin-pouch"],
+      knownSecrets: [],
+      position: { x: 1, y: 1 }
+    })
+  );
+  const rl = mode === "manual" ? createInterface({ input, output }) : null;
+  console.log(renderLegend());
+  for (const step of store.getState().scenario.steps) {
+    if (mode === "manual") {
+      console.log(`
+` + hex.border(`\u256D\u2500 `) + hex.sky(step.title) + hex.border(` \u2500\u256E`));
+      console.log(hex.dim(zalgo(step.description)));
+      console.log(hex.border(`\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F
+`));
+      console.log(renderGrid(store.getState()));
+      await rl?.question(hex.player(`> `) + hex.chrome(`Execute trace segment :: `) + hex.source(`[${step.id}]`));
+    } else {
+      console.log(`
+` + hex.steel(`:: `) + hex.sky(step.title) + ` ` + hex.dim(`[${step.id}]`));
+      console.log(hex.dim(zalgo(step.description)));
+    }
+    applyScenarioInitialState(step, store);
+    for (const command of step.commands) {
+      const result = await runCommand(command);
+      store.dispatch(harnessActions.markCovered(command.group));
+      store.dispatch(
+        transcriptActions.recordTranscript({
+          scenarioId: step.id,
+          commandGroup: command.group,
+          command: command.command,
+          expectedRoutes: command.expectedRoutes,
+          status: result.status,
+          output: result.output
+        })
+      );
+      if (command.group === "npc_process_chat") {
+        const verdict = tryParseVerdict(result.output);
+        if (verdict && verdict.action) {
+          const npcIdMatch = command.command.match(/npc (?:process|chat) (\w+)/);
+          const npcId = npcIdMatch ? npcIdMatch[1] : null;
+          if (npcId) {
+            store.dispatch(npcsActions.applyNpcVerdict({ id: npcId, verdict }));
+          }
+        }
+      }
+      if (command.group === "bridge_validate") {
+        const validation = tryParseVerdict(result.output);
+        if (validation && !validation.valid) {
+          store.dispatch(uiActions.addMessage(`System Bridge Blocked Action: ${validation.reason}`));
+        }
+      }
+      const group = command.group;
+      let statusColor = result.status === "ok" ? hex.gold : hex.critical;
+      if (result.status === "ok" && group === "status") statusColor = hex.plasma;
+      let cmdColor = hex.source;
+      if (group.startsWith("memory")) cmdColor = hex.bio;
+      if (group.startsWith("soul")) cmdColor = hex.soul;
+      if (group.startsWith("ghost")) cmdColor = hex.ghost;
+      if (group.startsWith("npc")) cmdColor = hex.azure;
+      if (group.startsWith("bridge")) cmdColor = hex.recall;
+      if (group === "cortex_init") cmdColor = hex.neural;
+      console.log(`${statusColor(`[${result.status}]`)} ${cmdColor(command.command)}`);
+      if (result.status === "error") {
+        process.stderr.write(hex.critical(SKULL_ART));
+        console.log(hex.critical("LOG_ERR_CRITICAL") + ` // ` + hex.rust("BIT_ROT_DETECTED") + ` // ` + hex.glitch("V_OID_LEAK"));
+        if (result.output) {
+          console.log(hex.dim(`  | `) + hex.glitch(result.output.split("\n")[0]));
+        }
+      }
+    }
+    if (mode === "autoplay") {
+      const fragment = getRandomFragment();
+      console.log(`
+  ` + hex.bio(`\u16EB`) + ` ` + hex.dim.italic(`"${fragment}"`));
+      process.stdout.write(hex.dim("  " + zalgo(":: synchronizing_neural_bus...") + " "));
+      const dots = [".", "..", "..."];
+      for (const dot of dots) {
+        process.stdout.write(hex.echo(dot));
+        await delay(250);
+      }
+      console.log("\n");
+    }
+  }
+  rl?.close();
+  const state = store.getState();
+  const missingGroups = selectMissingGroups(state.harness.covered);
+  const complete = missingGroups.length === 0;
+  const summaryText = complete ? `ALL_BINDINGS_COMPLETE :: Coverage achieved.` : `VOID_GAPS_DETECTED :: Missing groups -> ${missingGroups.join(", ")}`;
+  const summary = complete ? hex.chrome(summaryText) : hex.scarlet(summaryText);
+  console.log("\n" + hex.lead("=== ") + hex.steel("Transcript Summary // ") + hex.rust("chrome rain ledger") + hex.lead(" ==="));
+  for (const entry of state.transcript.entries) {
+    const statusColor = entry.status === "ok" ? hex.gold : hex.critical;
+    let groupColor = hex.source;
+    if (entry.commandGroup.startsWith("memory")) groupColor = hex.bio;
+    if (entry.commandGroup.startsWith("soul")) groupColor = hex.soul;
+    if (entry.commandGroup.startsWith("ghost")) groupColor = hex.ghost;
+    if (entry.commandGroup.startsWith("npc")) groupColor = hex.azure;
+    if (entry.commandGroup.startsWith("bridge")) groupColor = hex.recall;
+    if (entry.commandGroup === "cortex_init") groupColor = hex.neural;
+    console.log(
+      `${hex.dim(entry.at.split("T")[1].split(".")[0])} | ${groupColor(entry.commandGroup.padEnd(16))} | ${statusColor(entry.status.padEnd(5))} | ${hex.player(entry.command)}`
+    );
+  }
+  console.log("\n" + hex.plasma(RUNES));
+  console.log(summary);
+  console.log(hex.dim(`Compliance is monitored by the Watcher in the Code. \u{1F441}\uFE0F`));
+  return {
+    complete,
+    missingGroups,
+    transcript: state.transcript.entries,
+    summary
+  };
+};
+// src/cli.ts
+var usage = () => {
+  console.log(hex.void(BOOT_ART));
+  console.log(hex.border(`\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`));
+  console.log(hex.border(`\u2551  `) + hex.void(`ECHOES OF THE SPIRE // TERMINAL HARNESS`) + hex.border(`            \u2551`));
+  console.log(hex.border(`\u2551  `) + hex.critical(`SYSTEM_OVERRIDE :: NEURAL_LINK_ESTABLISHED`) + hex.border(`         \u2551`));
+  console.log(hex.border(`\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`));
+  console.log("\n" + hex.source(RUNES) + "\n");
+  console.log(hex.player("Usage:"));
+  console.log(`  forbocai-test-game --mode ${hex.void("autoplay")}|${hex.void("manual")}`);
+  console.log("\n" + hex.player("Defaults:"));
+  console.log(`  --mode ${hex.void("autoplay")}`);
+  console.log("\n  " + hex.success("[ok]") + `        ${zalgo("Command completed in shell mode.")}`);
+  console.log("  " + hex.error("[error]") + `     ` + hex.critical("LOG_ERR_CRITICAL") + ` - ${zalgo("command failed and was recorded.")}`);
 };
 var getArgValue = (name) => {
   const idx = process.argv.findIndex((a) => a === name);