@v5x/cli 0.0.20 → 0.0.21

package/dist/index.js

@@ -1,2144 +1,20 @@
 #!/usr/bin/env bun
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
-    constructor(exitCode, code, message) {
-      super(message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-      this.code = code;
-      this.exitCode = exitCode;
-      this.nestedError = undefined;
-    }
-  }
-
-  class InvalidArgumentError extends CommanderError {
-    constructor(message) {
-      super(1, "commander.invalidArgument", message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-    }
-  }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-});
-
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Argument {
-    constructor(name, description) {
-      this.description = description || "";
-      this.variadic = false;
-      this.parseArg = undefined;
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.argChoices = undefined;
-      switch (name[0]) {
-        case "<":
-          this.required = true;
-          this._name = name.slice(1, -1);
-          break;
-        case "[":
-          this.required = false;
-          this._name = name.slice(1, -1);
-          break;
-        default:
-          this.required = true;
-          this._name = name;
-          break;
-      }
-      if (this._name.endsWith("...")) {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
-    }
-    name() {
-      return this._name;
-    }
-    _collectValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      previous.push(value);
-      return previous;
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._collectValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    argRequired() {
-      this.required = true;
-      return this;
-    }
-    argOptional() {
-      this.required = false;
-      return this;
-    }
-  }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-  }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
-});
-
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
-
-  class Help {
-    constructor() {
-      this.helpWidth = undefined;
-      this.minWidthToWrap = 40;
-      this.sortSubcommands = false;
-      this.sortOptions = false;
-      this.showGlobalOptions = false;
-    }
-    prepareContext(contextOptions) {
-      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
-    }
-    visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      const helpCommand = cmd._getHelpCommand();
-      if (helpCommand && !helpCommand._hidden) {
-        visibleCommands.push(helpCommand);
-      }
-      if (this.sortSubcommands) {
-        visibleCommands.sort((a, b) => {
-          return a.name().localeCompare(b.name());
-        });
-      }
-      return visibleCommands;
-    }
-    compareOptions(a, b) {
-      const getSortKey = (option) => {
-        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-      };
-      return getSortKey(a).localeCompare(getSortKey(b));
-    }
-    visibleOptions(cmd) {
-      const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      const helpOption = cmd._getHelpOption();
-      if (helpOption && !helpOption.hidden) {
-        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
-        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
-        if (!removeShort && !removeLong) {
-          visibleOptions.push(helpOption);
-        } else if (helpOption.long && !removeLong) {
-          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
-        } else if (helpOption.short && !removeShort) {
-          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
-        }
-      }
-      if (this.sortOptions) {
-        visibleOptions.sort(this.compareOptions);
-      }
-      return visibleOptions;
-    }
-    visibleGlobalOptions(cmd) {
-      if (!this.showGlobalOptions)
-        return [];
-      const globalOptions = [];
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-        globalOptions.push(...visibleOptions);
-      }
-      if (this.sortOptions) {
-        globalOptions.sort(this.compareOptions);
-      }
-      return globalOptions;
-    }
-    visibleArguments(cmd) {
-      if (cmd._argsDescription) {
-        cmd.registeredArguments.forEach((argument) => {
-          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
-        });
-      }
-      if (cmd.registeredArguments.find((argument) => argument.description)) {
-        return cmd.registeredArguments;
-      }
-      return [];
-    }
-    subcommandTerm(cmd) {
-      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
-    }
-    optionTerm(option) {
-      return option.flags;
-    }
-    argumentTerm(argument) {
-      return argument.name();
-    }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
-      }, 0);
-    }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
-      }, 0);
-    }
-    commandUsage(cmd) {
-      let cmdName = cmd._name;
-      if (cmd._aliases[0]) {
-        cmdName = cmdName + "|" + cmd._aliases[0];
-      }
-      let ancestorCmdNames = "";
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
-      }
-      return ancestorCmdNames + cmdName + " " + cmd.usage();
-    }
-    commandDescription(cmd) {
-      return cmd.description();
-    }
-    subcommandDescription(cmd) {
-      return cmd.summary() || cmd.description();
-    }
-    optionDescription(option) {
-      const extraInfo = [];
-      if (option.argChoices) {
-        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (option.defaultValue !== undefined) {
-        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
-        if (showDefault) {
-          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-        }
-      }
-      if (option.presetArg !== undefined && option.optional) {
-        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
-      }
-      if (option.envVar !== undefined) {
-        extraInfo.push(`env: ${option.envVar}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (option.description) {
-          return `${option.description} ${extraDescription}`;
-        }
-        return extraDescription;
-      }
-      return option.description;
-    }
-    argumentDescription(argument) {
-      const extraInfo = [];
-      if (argument.argChoices) {
-        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (argument.defaultValue !== undefined) {
-        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (argument.description) {
-          return `${argument.description} ${extraDescription}`;
-        }
-        return extraDescription;
-      }
-      return argument.description;
-    }
-    formatItemList(heading, items, helper) {
-      if (items.length === 0)
-        return [];
-      return [helper.styleTitle(heading), ...items, ""];
-    }
-    groupItems(unsortedItems, visibleItems, getGroup) {
-      const result = new Map;
-      unsortedItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group))
-          result.set(group, []);
-      });
-      visibleItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group)) {
-          result.set(group, []);
-        }
-        result.get(group).push(item);
-      });
-      return result;
-    }
-    formatHelp(cmd, helper) {
-      const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth ?? 80;
-      function callFormatItem(term, description) {
-        return helper.formatItem(term, termWidth, description, helper);
-      }
-      let output = [
-        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
-        ""
-      ];
-      const commandDescription = helper.commandDescription(cmd);
-      if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
-          ""
-        ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
-      });
-      output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
-      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), (option) => option.helpGroupHeading ?? "Options:");
-      optionGroups.forEach((options, group) => {
-        const optionList = options.map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        output = output.concat(this.formatItemList(group, optionList, helper));
-      });
-      if (helper.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
-      }
-      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
-      commandGroups.forEach((commands, group) => {
-        const commandList = commands.map((sub) => {
-          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub)));
-        });
-        output = output.concat(this.formatItemList(group, commandList, helper));
-      });
-      return output.join(`
-`);
-    }
-    displayWidth(str) {
-      return stripColor(str).length;
-    }
-    styleTitle(str) {
-      return str;
-    }
-    styleUsage(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word === "[command]")
-          return this.styleSubcommandText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleCommandText(word);
-      }).join(" ");
-    }
-    styleCommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleOptionDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleSubcommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleArgumentDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleDescriptionText(str) {
-      return str;
-    }
-    styleOptionTerm(str) {
-      return this.styleOptionText(str);
-    }
-    styleSubcommandTerm(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleSubcommandText(word);
-      }).join(" ");
-    }
-    styleArgumentTerm(str) {
-      return this.styleArgumentText(str);
-    }
-    styleOptionText(str) {
-      return str;
-    }
-    styleArgumentText(str) {
-      return str;
-    }
-    styleSubcommandText(str) {
-      return str;
-    }
-    styleCommandText(str) {
-      return str;
-    }
-    padWidth(cmd, helper) {
-      return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
-    }
-    preformatted(str) {
-      return /\n[^\S\r\n]/.test(str);
-    }
-    formatItem(term, termWidth, description, helper) {
-      const itemIndent = 2;
-      const itemIndentStr = " ".repeat(itemIndent);
-      if (!description)
-        return itemIndentStr + term;
-      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
-      const spacerWidth = 2;
-      const helpWidth = this.helpWidth ?? 80;
-      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
-      let formattedDescription;
-      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
-        formattedDescription = description;
-      } else {
-        const wrappedDescription = helper.boxWrap(description, remainingWidth);
-        formattedDescription = wrappedDescription.replace(/\n/g, `
-` + " ".repeat(termWidth + spacerWidth));
-      }
-      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
-${itemIndentStr}`);
-    }
-    boxWrap(str, width) {
-      if (width < this.minWidthToWrap)
-        return str;
-      const rawLines = str.split(/\r\n|\n/);
-      const chunkPattern = /[\s]*[^\s]+/g;
-      const wrappedLines = [];
-      rawLines.forEach((line) => {
-        const chunks = line.match(chunkPattern);
-        if (chunks === null) {
-          wrappedLines.push("");
-          return;
-        }
-        let sumChunks = [chunks.shift()];
-        let sumWidth = this.displayWidth(sumChunks[0]);
-        chunks.forEach((chunk) => {
-          const visibleWidth = this.displayWidth(chunk);
-          if (sumWidth + visibleWidth <= width) {
-            sumChunks.push(chunk);
-            sumWidth += visibleWidth;
-            return;
-          }
-          wrappedLines.push(sumChunks.join(""));
-          const nextChunk = chunk.trimStart();
-          sumChunks = [nextChunk];
-          sumWidth = this.displayWidth(nextChunk);
-        });
-        wrappedLines.push(sumChunks.join(""));
-      });
-      return wrappedLines.join(`
-`);
-    }
-  }
-  function stripColor(str) {
-    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
-    return str.replace(sgrPattern, "");
-  }
-  exports.Help = Help;
-  exports.stripColor = stripColor;
-});
-
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/lib/option.js
-var require_option = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Option {
-    constructor(flags, description) {
-      this.flags = flags;
-      this.description = description || "";
-      this.required = flags.includes("<");
-      this.optional = flags.includes("[");
-      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
-      this.mandatory = false;
-      const optionFlags = splitOptionFlags(flags);
-      this.short = optionFlags.shortFlag;
-      this.long = optionFlags.longFlag;
-      this.negate = false;
-      if (this.long) {
-        this.negate = this.long.startsWith("--no-");
-      }
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.presetArg = undefined;
-      this.envVar = undefined;
-      this.parseArg = undefined;
-      this.hidden = false;
-      this.argChoices = undefined;
-      this.conflictsWith = [];
-      this.implied = undefined;
-      this.helpGroupHeading = undefined;
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    preset(arg) {
-      this.presetArg = arg;
-      return this;
-    }
-    conflicts(names) {
-      this.conflictsWith = this.conflictsWith.concat(names);
-      return this;
-    }
-    implies(impliedOptionValues) {
-      let newImplied = impliedOptionValues;
-      if (typeof impliedOptionValues === "string") {
-        newImplied = { [impliedOptionValues]: true };
-      }
-      this.implied = Object.assign(this.implied || {}, newImplied);
-      return this;
-    }
-    env(name) {
-      this.envVar = name;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    makeOptionMandatory(mandatory = true) {
-      this.mandatory = !!mandatory;
-      return this;
-    }
-    hideHelp(hide = true) {
-      this.hidden = !!hide;
-      return this;
-    }
-    _collectValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      previous.push(value);
-      return previous;
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._collectValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    name() {
-      if (this.long) {
-        return this.long.replace(/^--/, "");
-      }
-      return this.short.replace(/^-/, "");
-    }
-    attributeName() {
-      if (this.negate) {
-        return camelcase(this.name().replace(/^no-/, ""));
-      }
-      return camelcase(this.name());
-    }
-    helpGroup(heading) {
-      this.helpGroupHeading = heading;
-      return this;
-    }
-    is(arg) {
-      return this.short === arg || this.long === arg;
-    }
-    isBoolean() {
-      return !this.required && !this.optional && !this.negate;
-    }
-  }
-
-  class DualOptions {
-    constructor(options) {
-      this.positiveOptions = new Map;
-      this.negativeOptions = new Map;
-      this.dualOptions = new Set;
-      options.forEach((option) => {
-        if (option.negate) {
-          this.negativeOptions.set(option.attributeName(), option);
-        } else {
-          this.positiveOptions.set(option.attributeName(), option);
-        }
-      });
-      this.negativeOptions.forEach((value, key) => {
-        if (this.positiveOptions.has(key)) {
-          this.dualOptions.add(key);
-        }
-      });
-    }
-    valueFromOption(value, option) {
-      const optionKey = option.attributeName();
-      if (!this.dualOptions.has(optionKey))
-        return true;
-      const preset = this.negativeOptions.get(optionKey).presetArg;
-      const negativeValue = preset !== undefined ? preset : false;
-      return option.negate === (negativeValue === value);
-    }
-  }
-  function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
-    });
-  }
-  function splitOptionFlags(flags) {
-    let shortFlag;
-    let longFlag;
-    const shortFlagExp = /^-[^-]$/;
-    const longFlagExp = /^--[^-]/;
-    const flagParts = flags.split(/[ |,]+/).concat("guard");
-    if (shortFlagExp.test(flagParts[0]))
-      shortFlag = flagParts.shift();
-    if (longFlagExp.test(flagParts[0]))
-      longFlag = flagParts.shift();
-    if (!shortFlag && shortFlagExp.test(flagParts[0]))
-      shortFlag = flagParts.shift();
-    if (!shortFlag && longFlagExp.test(flagParts[0])) {
-      shortFlag = longFlag;
-      longFlag = flagParts.shift();
-    }
-    if (flagParts[0].startsWith("-")) {
-      const unsupportedFlag = flagParts[0];
-      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
-      if (/^-[^-][^-]/.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- a short flag is a single dash and a single character
-  - either use a single dash and a single character (for a short flag)
-  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
-      if (shortFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many short flags`);
-      if (longFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many long flags`);
-      throw new Error(`${baseError}
-- unrecognised flag format`);
-    }
-    if (shortFlag === undefined && longFlag === undefined)
-      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
-    return { shortFlag, longFlag };
-  }
-  exports.Option = Option;
-  exports.DualOptions = DualOptions;
-});
-
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar = __commonJS((exports) => {
-  var maxDistance = 3;
-  function editDistance(a, b) {
-    if (Math.abs(a.length - b.length) > maxDistance)
-      return Math.max(a.length, b.length);
-    const d = [];
-    for (let i = 0;i <= a.length; i++) {
-      d[i] = [i];
-    }
-    for (let j = 0;j <= b.length; j++) {
-      d[0][j] = j;
-    }
-    for (let j = 1;j <= b.length; j++) {
-      for (let i = 1;i <= a.length; i++) {
-        let cost = 1;
-        if (a[i - 1] === b[j - 1]) {
-          cost = 0;
-        } else {
-          cost = 1;
-        }
-        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-          d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
-        }
-      }
-    }
-    return d[a.length][b.length];
-  }
-  function suggestSimilar(word, candidates) {
-    if (!candidates || candidates.length === 0)
-      return "";
-    candidates = Array.from(new Set(candidates));
-    const searchingOptions = word.startsWith("--");
-    if (searchingOptions) {
-      word = word.slice(2);
-      candidates = candidates.map((candidate) => candidate.slice(2));
-    }
-    let similar = [];
-    let bestDistance = maxDistance;
-    const minSimilarity = 0.4;
-    candidates.forEach((candidate) => {
-      if (candidate.length <= 1)
-        return;
-      const distance = editDistance(word, candidate);
-      const length = Math.max(word.length, candidate.length);
-      const similarity = (length - distance) / length;
-      if (similarity > minSimilarity) {
-        if (distance < bestDistance) {
-          bestDistance = distance;
-          similar = [candidate];
-        } else if (distance === bestDistance) {
-          similar.push(candidate);
-        }
-      }
-    });
-    similar.sort((a, b) => a.localeCompare(b));
-    if (searchingOptions) {
-      similar = similar.map((candidate) => `--${candidate}`);
-    }
-    if (similar.length > 1) {
-      return `
-(Did you mean one of ${similar.join(", ")}?)`;
-    }
-    if (similar.length === 1) {
-      return `
-(Did you mean ${similar[0]}?)`;
-    }
-    return "";
-  }
-  exports.suggestSimilar = suggestSimilar;
-});
-
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/lib/command.js
-var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("events").EventEmitter;
-  var childProcess = __require("child_process");
-  var path = __require("path");
-  var fs = __require("fs");
-  var process2 = __require("process");
-  var { Argument, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help, stripColor } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
-
-  class Command extends EventEmitter {
-    constructor(name) {
-      super();
-      this.commands = [];
-      this.options = [];
-      this.parent = null;
-      this._allowUnknownOption = false;
-      this._allowExcessArguments = false;
-      this.registeredArguments = [];
-      this._args = this.registeredArguments;
-      this.args = [];
-      this.rawArgs = [];
-      this.processedArgs = [];
-      this._scriptPath = null;
-      this._name = name || "";
-      this._optionValues = {};
-      this._optionValueSources = {};
-      this._storeOptionsAsProperties = false;
-      this._actionHandler = null;
-      this._executableHandler = false;
-      this._executableFile = null;
-      this._executableDir = null;
-      this._defaultCommandName = null;
-      this._exitCallback = null;
-      this._aliases = [];
-      this._combineFlagAndOptionalValue = true;
-      this._description = "";
-      this._summary = "";
-      this._argsDescription = undefined;
-      this._enablePositionalOptions = false;
-      this._passThroughOptions = false;
-      this._lifeCycleHooks = {};
-      this._showHelpAfterError = false;
-      this._showSuggestionAfterError = true;
-      this._savedState = null;
-      this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
-        outputError: (str, write) => write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
-        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
-        stripColor: (str) => stripColor(str)
-      };
-      this._hidden = false;
-      this._helpOption = undefined;
-      this._addImplicitHelpCommand = undefined;
-      this._helpCommand = undefined;
-      this._helpConfiguration = {};
-      this._helpGroupHeading = undefined;
-      this._defaultCommandGroup = undefined;
-      this._defaultOptionGroup = undefined;
-    }
-    copyInheritedSettings(sourceCommand) {
-      this._outputConfiguration = sourceCommand._outputConfiguration;
-      this._helpOption = sourceCommand._helpOption;
-      this._helpCommand = sourceCommand._helpCommand;
-      this._helpConfiguration = sourceCommand._helpConfiguration;
-      this._exitCallback = sourceCommand._exitCallback;
-      this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
-      this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
-      this._allowExcessArguments = sourceCommand._allowExcessArguments;
-      this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
-      this._showHelpAfterError = sourceCommand._showHelpAfterError;
-      this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
-      return this;
-    }
-    _getCommandAndAncestors() {
-      const result = [];
-      for (let command = this;command; command = command.parent) {
-        result.push(command);
-      }
-      return result;
-    }
-    command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
-      let desc = actionOptsOrExecDesc;
-      let opts = execOpts;
-      if (typeof desc === "object" && desc !== null) {
-        opts = desc;
-        desc = null;
-      }
-      opts = opts || {};
-      const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
-      const cmd = this.createCommand(name);
-      if (desc) {
-        cmd.description(desc);
-        cmd._executableHandler = true;
-      }
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      cmd._hidden = !!(opts.noHelp || opts.hidden);
-      cmd._executableFile = opts.executableFile || null;
-      if (args)
-        cmd.arguments(args);
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd.copyInheritedSettings(this);
-      if (desc)
-        return this;
-      return cmd;
-    }
-    createCommand(name) {
-      return new Command(name);
-    }
-    createHelp() {
-      return Object.assign(new Help, this.configureHelp());
-    }
-    configureHelp(configuration) {
-      if (configuration === undefined)
-        return this._helpConfiguration;
-      this._helpConfiguration = configuration;
-      return this;
-    }
-    configureOutput(configuration) {
-      if (configuration === undefined)
-        return this._outputConfiguration;
-      this._outputConfiguration = {
-        ...this._outputConfiguration,
-        ...configuration
-      };
-      return this;
-    }
-    showHelpAfterError(displayHelp = true) {
-      if (typeof displayHelp !== "string")
-        displayHelp = !!displayHelp;
-      this._showHelpAfterError = displayHelp;
-      return this;
-    }
-    showSuggestionAfterError(displaySuggestion = true) {
-      this._showSuggestionAfterError = !!displaySuggestion;
-      return this;
-    }
-    addCommand(cmd, opts) {
-      if (!cmd._name) {
-        throw new Error(`Command passed to .addCommand() must have a name
-- specify the name in Command constructor or using .name()`);
-      }
-      opts = opts || {};
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      if (opts.noHelp || opts.hidden)
-        cmd._hidden = true;
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd._checkForBrokenPassThrough();
-      return this;
-    }
-    createArgument(name, description) {
-      return new Argument(name, description);
-    }
-    argument(name, description, parseArg, defaultValue) {
-      const argument = this.createArgument(name, description);
-      if (typeof parseArg === "function") {
-        argument.default(defaultValue).argParser(parseArg);
-      } else {
-        argument.default(parseArg);
-      }
-      this.addArgument(argument);
-      return this;
-    }
-    arguments(names) {
-      names.trim().split(/ +/).forEach((detail) => {
-        this.argument(detail);
-      });
-      return this;
-    }
-    addArgument(argument) {
-      const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument?.variadic) {
-        throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
-      }
-      if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
-        throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
-      }
-      this.registeredArguments.push(argument);
-      return this;
-    }
-    helpCommand(enableOrNameAndArgs, description) {
-      if (typeof enableOrNameAndArgs === "boolean") {
-        this._addImplicitHelpCommand = enableOrNameAndArgs;
-        if (enableOrNameAndArgs && this._defaultCommandGroup) {
-          this._initCommandGroup(this._getHelpCommand());
-        }
-        return this;
-      }
-      const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
-      const helpDescription = description ?? "display help for command";
-      const helpCommand = this.createCommand(helpName);
-      helpCommand.helpOption(false);
-      if (helpArgs)
-        helpCommand.arguments(helpArgs);
-      if (helpDescription)
-        helpCommand.description(helpDescription);
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      if (enableOrNameAndArgs || description)
-        this._initCommandGroup(helpCommand);
-      return this;
-    }
-    addHelpCommand(helpCommand, deprecatedDescription) {
-      if (typeof helpCommand !== "object") {
-        this.helpCommand(helpCommand, deprecatedDescription);
-        return this;
-      }
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      this._initCommandGroup(helpCommand);
-      return this;
-    }
-    _getHelpCommand() {
-      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
-      if (hasImplicitHelpCommand) {
-        if (this._helpCommand === undefined) {
-          this.helpCommand(undefined, undefined);
-        }
-        return this._helpCommand;
-      }
-      return null;
-    }
-    hook(event, listener) {
-      const allowedValues = ["preSubcommand", "preAction", "postAction"];
-      if (!allowedValues.includes(event)) {
-        throw new Error(`Unexpected value for event passed to hook : '${event}'.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      if (this._lifeCycleHooks[event]) {
-        this._lifeCycleHooks[event].push(listener);
-      } else {
-        this._lifeCycleHooks[event] = [listener];
-      }
-      return this;
-    }
-    exitOverride(fn) {
-      if (fn) {
-        this._exitCallback = fn;
-      } else {
-        this._exitCallback = (err) => {
-          if (err.code !== "commander.executeSubCommandAsync") {
-            throw err;
-          } else {}
-        };
-      }
-      return this;
-    }
-    _exit(exitCode, code, message) {
-      if (this._exitCallback) {
-        this._exitCallback(new CommanderError(exitCode, code, message));
-      }
-      process2.exit(exitCode);
-    }
-    action(fn) {
-      const listener = (args) => {
-        const expectedArgsCount = this.registeredArguments.length;
-        const actionArgs = args.slice(0, expectedArgsCount);
-        if (this._storeOptionsAsProperties) {
-          actionArgs[expectedArgsCount] = this;
-        } else {
-          actionArgs[expectedArgsCount] = this.opts();
-        }
-        actionArgs.push(this);
-        return fn.apply(this, actionArgs);
-      };
-      this._actionHandler = listener;
-      return this;
-    }
-    createOption(flags, description) {
-      return new Option(flags, description);
-    }
-    _callParseArg(target, value, previous, invalidArgumentMessage) {
-      try {
-        return target.parseArg(value, previous);
-      } catch (err) {
-        if (err.code === "commander.invalidArgument") {
-          const message = `${invalidArgumentMessage} ${err.message}`;
-          this.error(message, { exitCode: err.exitCode, code: err.code });
-        }
-        throw err;
-      }
-    }
-    _registerOption(option) {
-      const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
-      if (matchingOption) {
-        const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
-        throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
--  already used by option '${matchingOption.flags}'`);
-      }
-      this._initOptionGroup(option);
-      this.options.push(option);
-    }
-    _registerCommand(command) {
-      const knownBy = (cmd) => {
-        return [cmd.name()].concat(cmd.aliases());
-      };
-      const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
-      if (alreadyUsed) {
-        const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
-        const newCmd = knownBy(command).join("|");
-        throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
-      }
-      this._initCommandGroup(command);
-      this.commands.push(command);
-    }
-    addOption(option) {
-      this._registerOption(option);
-      const oname = option.name();
-      const name = option.attributeName();
-      if (option.negate) {
-        const positiveLongFlag = option.long.replace(/^--no-/, "--");
-        if (!this._findOption(positiveLongFlag)) {
-          this.setOptionValueWithSource(name, option.defaultValue === undefined ? true : option.defaultValue, "default");
-        }
-      } else if (option.defaultValue !== undefined) {
-        this.setOptionValueWithSource(name, option.defaultValue, "default");
-      }
-      const handleOptionValue = (val, invalidValueMessage, valueSource) => {
-        if (val == null && option.presetArg !== undefined) {
-          val = option.presetArg;
-        }
-        const oldValue = this.getOptionValue(name);
-        if (val !== null && option.parseArg) {
-          val = this._callParseArg(option, val, oldValue, invalidValueMessage);
-        } else if (val !== null && option.variadic) {
-          val = option._collectValue(val, oldValue);
-        }
-        if (val == null) {
-          if (option.negate) {
-            val = false;
-          } else if (option.isBoolean() || option.optional) {
-            val = true;
-          } else {
-            val = "";
-          }
-        }
-        this.setOptionValueWithSource(name, val, valueSource);
-      };
-      this.on("option:" + oname, (val) => {
-        const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
-        handleOptionValue(val, invalidValueMessage, "cli");
-      });
-      if (option.envVar) {
-        this.on("optionEnv:" + oname, (val) => {
-          const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
-          handleOptionValue(val, invalidValueMessage, "env");
-        });
-      }
-      return this;
-    }
-    _optionEx(config, flags, description, fn, defaultValue) {
-      if (typeof flags === "object" && flags instanceof Option) {
-        throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
-      }
-      const option = this.createOption(flags, description);
-      option.makeOptionMandatory(!!config.mandatory);
-      if (typeof fn === "function") {
-        option.default(defaultValue).argParser(fn);
-      } else if (fn instanceof RegExp) {
-        const regex = fn;
-        fn = (val, def) => {
-          const m = regex.exec(val);
-          return m ? m[0] : def;
-        };
-        option.default(defaultValue).argParser(fn);
-      } else {
-        option.default(fn);
-      }
-      return this.addOption(option);
-    }
-    option(flags, description, parseArg, defaultValue) {
-      return this._optionEx({}, flags, description, parseArg, defaultValue);
-    }
-    requiredOption(flags, description, parseArg, defaultValue) {
-      return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
-    }
-    combineFlagAndOptionalValue(combine = true) {
-      this._combineFlagAndOptionalValue = !!combine;
-      return this;
-    }
-    allowUnknownOption(allowUnknown = true) {
-      this._allowUnknownOption = !!allowUnknown;
-      return this;
-    }
-    allowExcessArguments(allowExcess = true) {
-      this._allowExcessArguments = !!allowExcess;
-      return this;
-    }
-    enablePositionalOptions(positional = true) {
-      this._enablePositionalOptions = !!positional;
-      return this;
-    }
-    passThroughOptions(passThrough = true) {
-      this._passThroughOptions = !!passThrough;
-      this._checkForBrokenPassThrough();
-      return this;
-    }
-    _checkForBrokenPassThrough() {
-      if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
-        throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
-      }
-    }
-    storeOptionsAsProperties(storeAsProperties = true) {
-      if (this.options.length) {
-        throw new Error("call .storeOptionsAsProperties() before adding options");
-      }
-      if (Object.keys(this._optionValues).length) {
-        throw new Error("call .storeOptionsAsProperties() before setting option values");
-      }
-      this._storeOptionsAsProperties = !!storeAsProperties;
-      return this;
-    }
-    getOptionValue(key) {
-      if (this._storeOptionsAsProperties) {
-        return this[key];
-      }
-      return this._optionValues[key];
-    }
-    setOptionValue(key, value) {
-      return this.setOptionValueWithSource(key, value, undefined);
-    }
-    setOptionValueWithSource(key, value, source) {
-      if (this._storeOptionsAsProperties) {
-        this[key] = value;
-      } else {
-        this._optionValues[key] = value;
-      }
-      this._optionValueSources[key] = source;
-      return this;
-    }
-    getOptionValueSource(key) {
-      return this._optionValueSources[key];
-    }
-    getOptionValueSourceWithGlobals(key) {
-      let source;
-      this._getCommandAndAncestors().forEach((cmd) => {
-        if (cmd.getOptionValueSource(key) !== undefined) {
-          source = cmd.getOptionValueSource(key);
-        }
-      });
-      return source;
-    }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
-        throw new Error("first parameter to parse must be array or undefined");
-      }
-      parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
-        if (process2.versions?.electron) {
-          parseOptions.from = "electron";
-        }
-        const execArgv = process2.execArgv ?? [];
-        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-          parseOptions.from = "eval";
-        }
-      }
-      if (argv === undefined) {
-        argv = process2.argv;
-      }
-      this.rawArgs = argv.slice();
-      let userArgs;
-      switch (parseOptions.from) {
-        case undefined:
-        case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
-          break;
-        case "electron":
-          if (process2.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
-          } else {
-            userArgs = argv.slice(1);
-          }
-          break;
-        case "user":
-          userArgs = argv.slice(0);
-          break;
-        case "eval":
-          userArgs = argv.slice(1);
-          break;
-        default:
-          throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
-      }
-      if (!this._name && this._scriptPath)
-        this.nameFromFilename(this._scriptPath);
-      this._name = this._name || "program";
-      return userArgs;
-    }
-    parse(argv, parseOptions) {
-      this._prepareForParse();
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      this._parseCommand([], userArgs);
-      return this;
-    }
-    async parseAsync(argv, parseOptions) {
-      this._prepareForParse();
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      await this._parseCommand([], userArgs);
-      return this;
-    }
-    _prepareForParse() {
-      if (this._savedState === null) {
-        this.saveStateBeforeParse();
-      } else {
-        this.restoreStateBeforeParse();
-      }
-    }
-    saveStateBeforeParse() {
-      this._savedState = {
-        _name: this._name,
-        _optionValues: { ...this._optionValues },
-        _optionValueSources: { ...this._optionValueSources }
-      };
-    }
-    restoreStateBeforeParse() {
-      if (this._storeOptionsAsProperties)
-        throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
-- either make a new Command for each call to parse, or stop storing options as properties`);
-      this._name = this._savedState._name;
-      this._scriptPath = null;
-      this.rawArgs = [];
-      this._optionValues = { ...this._savedState._optionValues };
-      this._optionValueSources = { ...this._savedState._optionValueSources };
-      this.args = [];
-      this.processedArgs = [];
-    }
-    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-      if (fs.existsSync(executableFile))
-        return;
-      const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-      const executableMissing = `'${executableFile}' does not exist
- - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-      throw new Error(executableMissing);
-    }
-    _executeSubCommand(subcommand, args) {
-      args = args.slice();
-      let launchWithNode = false;
-      const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
-      function findFile(baseDir, baseName) {
-        const localBin = path.resolve(baseDir, baseName);
-        if (fs.existsSync(localBin))
-          return localBin;
-        if (sourceExt.includes(path.extname(baseName)))
-          return;
-        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
-        if (foundExt)
-          return `${localBin}${foundExt}`;
-        return;
-      }
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
-      let executableDir = this._executableDir || "";
-      if (this._scriptPath) {
-        let resolvedScriptPath;
-        try {
-          resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch {
-          resolvedScriptPath = this._scriptPath;
-        }
-        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
-      }
-      if (executableDir) {
-        let localFile = findFile(executableDir, executableFile);
-        if (!localFile && !subcommand._executableFile && this._scriptPath) {
-          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
-          if (legacyName !== this._name) {
-            localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
-          }
-        }
-        executableFile = localFile || executableFile;
-      }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
-      let proc;
-      if (process2.platform !== "win32") {
-        if (launchWithNode) {
-          args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
-        } else {
-          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
-        }
-      } else {
-        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
-        args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
-      }
-      if (!proc.killed) {
-        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-        signals.forEach((signal) => {
-          process2.on(signal, () => {
-            if (proc.killed === false && proc.exitCode === null) {
-              proc.kill(signal);
-            }
-          });
-        });
-      }
-      const exitCallback = this._exitCallback;
-      proc.on("close", (code) => {
-        code = code ?? 1;
-        if (!exitCallback) {
-          process2.exit(code);
-        } else {
-          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
-        }
-      });
-      proc.on("error", (err) => {
-        if (err.code === "ENOENT") {
-          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
-        } else if (err.code === "EACCES") {
-          throw new Error(`'${executableFile}' not executable`);
-        }
-        if (!exitCallback) {
-          process2.exit(1);
-        } else {
-          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
-          wrappedError.nestedError = err;
-          exitCallback(wrappedError);
-        }
-      });
-      this.runningCommand = proc;
-    }
-    _dispatchSubcommand(commandName, operands, unknown) {
-      const subCommand = this._findCommand(commandName);
-      if (!subCommand)
-        this.help({ error: true });
-      subCommand._prepareForParse();
-      let promiseChain;
-      promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
-      promiseChain = this._chainOrCall(promiseChain, () => {
-        if (subCommand._executableHandler) {
-          this._executeSubCommand(subCommand, operands.concat(unknown));
-        } else {
-          return subCommand._parseCommand(operands, unknown);
-        }
-      });
-      return promiseChain;
-    }
-    _dispatchHelpCommand(subcommandName) {
-      if (!subcommandName) {
-        this.help();
-      }
-      const subCommand = this._findCommand(subcommandName);
-      if (subCommand && !subCommand._executableHandler) {
-        subCommand.help();
-      }
-      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
-    }
-    _checkNumberOfArguments() {
-      this.registeredArguments.forEach((arg, i) => {
-        if (arg.required && this.args[i] == null) {
-          this.missingArgument(arg.name());
-        }
-      });
-      if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
-        return;
-      }
-      if (this.args.length > this.registeredArguments.length) {
-        this._excessArguments(this.args);
-      }
-    }
-    _processArguments() {
-      const myParseArg = (argument, value, previous) => {
-        let parsedValue = value;
-        if (value !== null && argument.parseArg) {
-          const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
-          parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
-        }
-        return parsedValue;
-      };
-      this._checkNumberOfArguments();
-      const processedArgs = [];
-      this.registeredArguments.forEach((declaredArg, index) => {
-        let value = declaredArg.defaultValue;
-        if (declaredArg.variadic) {
-          if (index < this.args.length) {
-            value = this.args.slice(index);
-            if (declaredArg.parseArg) {
-              value = value.reduce((processed, v) => {
-                return myParseArg(declaredArg, v, processed);
-              }, declaredArg.defaultValue);
-            }
-          } else if (value === undefined) {
-            value = [];
-          }
-        } else if (index < this.args.length) {
-          value = this.args[index];
-          if (declaredArg.parseArg) {
-            value = myParseArg(declaredArg, value, declaredArg.defaultValue);
-          }
-        }
-        processedArgs[index] = value;
-      });
-      this.processedArgs = processedArgs;
-    }
-    _chainOrCall(promise, fn) {
-      if (promise?.then && typeof promise.then === "function") {
-        return promise.then(() => fn());
-      }
-      return fn();
-    }
-    _chainOrCallHooks(promise, event) {
-      let result = promise;
-      const hooks = [];
-      this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
-        hookedCommand._lifeCycleHooks[event].forEach((callback) => {
-          hooks.push({ hookedCommand, callback });
-        });
-      });
-      if (event === "postAction") {
-        hooks.reverse();
-      }
-      hooks.forEach((hookDetail) => {
-        result = this._chainOrCall(result, () => {
-          return hookDetail.callback(hookDetail.hookedCommand, this);
-        });
-      });
-      return result;
-    }
-    _chainOrCallSubCommandHook(promise, subCommand, event) {
-      let result = promise;
-      if (this._lifeCycleHooks[event] !== undefined) {
-        this._lifeCycleHooks[event].forEach((hook) => {
-          result = this._chainOrCall(result, () => {
-            return hook(this, subCommand);
-          });
-        });
-      }
-      return result;
-    }
-    _parseCommand(operands, unknown) {
-      const parsed = this.parseOptions(unknown);
-      this._parseOptionsEnv();
-      this._parseOptionsImplied();
-      operands = operands.concat(parsed.operands);
-      unknown = parsed.unknown;
-      this.args = operands.concat(unknown);
-      if (operands && this._findCommand(operands[0])) {
-        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
-      }
-      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
-        return this._dispatchHelpCommand(operands[1]);
-      }
-      if (this._defaultCommandName) {
-        this._outputHelpIfRequested(unknown);
-        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
-      }
-      if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
-        this.help({ error: true });
-      }
-      this._outputHelpIfRequested(parsed.unknown);
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      const checkForUnknownOptions = () => {
-        if (parsed.unknown.length > 0) {
-          this.unknownOption(parsed.unknown[0]);
-        }
-      };
-      const commandEvent = `command:${this.name()}`;
-      if (this._actionHandler) {
-        checkForUnknownOptions();
-        this._processArguments();
-        let promiseChain;
-        promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
-        promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
-        if (this.parent) {
-          promiseChain = this._chainOrCall(promiseChain, () => {
-            this.parent.emit(commandEvent, operands, unknown);
-          });
-        }
-        promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
-        return promiseChain;
-      }
-      if (this.parent?.listenerCount(commandEvent)) {
-        checkForUnknownOptions();
-        this._processArguments();
-        this.parent.emit(commandEvent, operands, unknown);
-      } else if (operands.length) {
-        if (this._findCommand("*")) {
-          return this._dispatchSubcommand("*", operands, unknown);
-        }
-        if (this.listenerCount("command:*")) {
-          this.emit("command:*", operands, unknown);
-        } else if (this.commands.length) {
-          this.unknownCommand();
-        } else {
-          checkForUnknownOptions();
-          this._processArguments();
-        }
-      } else if (this.commands.length) {
-        checkForUnknownOptions();
-        this.help({ error: true });
-      } else {
-        checkForUnknownOptions();
-        this._processArguments();
-      }
-    }
-    _findCommand(name) {
-      if (!name)
-        return;
-      return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
-    }
-    _findOption(arg) {
-      return this.options.find((option) => option.is(arg));
-    }
-    _checkForMissingMandatoryOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd.options.forEach((anOption) => {
-          if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === undefined) {
-            cmd.missingMandatoryOptionValue(anOption);
-          }
-        });
-      });
-    }
-    _checkForConflictingLocalOptions() {
-      const definedNonDefaultOptions = this.options.filter((option) => {
-        const optionKey = option.attributeName();
-        if (this.getOptionValue(optionKey) === undefined) {
-          return false;
-        }
-        return this.getOptionValueSource(optionKey) !== "default";
-      });
-      const optionsWithConflicting = definedNonDefaultOptions.filter((option) => option.conflictsWith.length > 0);
-      optionsWithConflicting.forEach((option) => {
-        const conflictingAndDefined = definedNonDefaultOptions.find((defined) => option.conflictsWith.includes(defined.attributeName()));
-        if (conflictingAndDefined) {
-          this._conflictingOption(option, conflictingAndDefined);
-        }
-      });
-    }
-    _checkForConflictingOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd._checkForConflictingLocalOptions();
-      });
-    }
-    parseOptions(args) {
-      const operands = [];
-      const unknown = [];
-      let dest = operands;
-      function maybeOption(arg) {
-        return arg.length > 1 && arg[0] === "-";
-      }
-      const negativeNumberArg = (arg) => {
-        if (!/^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg))
-          return false;
-        return !this._getCommandAndAncestors().some((cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)));
-      };
-      let activeVariadicOption = null;
-      let activeGroup = null;
-      let i = 0;
-      while (i < args.length || activeGroup) {
-        const arg = activeGroup ?? args[i++];
-        activeGroup = null;
-        if (arg === "--") {
-          if (dest === unknown)
-            dest.push(arg);
-          dest.push(...args.slice(i));
-          break;
-        }
-        if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
-          this.emit(`option:${activeVariadicOption.name()}`, arg);
-          continue;
-        }
-        activeVariadicOption = null;
-        if (maybeOption(arg)) {
-          const option = this._findOption(arg);
-          if (option) {
-            if (option.required) {
-              const value = args[i++];
-              if (value === undefined)
-                this.optionMissingArgument(option);
-              this.emit(`option:${option.name()}`, value);
-            } else if (option.optional) {
-              let value = null;
-              if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
-                value = args[i++];
-              }
-              this.emit(`option:${option.name()}`, value);
-            } else {
-              this.emit(`option:${option.name()}`);
-            }
-            activeVariadicOption = option.variadic ? option : null;
-            continue;
-          }
-        }
-        if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
-          const option = this._findOption(`-${arg[1]}`);
-          if (option) {
-            if (option.required || option.optional && this._combineFlagAndOptionalValue) {
-              this.emit(`option:${option.name()}`, arg.slice(2));
-            } else {
-              this.emit(`option:${option.name()}`);
-              activeGroup = `-${arg.slice(2)}`;
-            }
-            continue;
-          }
-        }
-        if (/^--[^=]+=/.test(arg)) {
-          const index = arg.indexOf("=");
-          const option = this._findOption(arg.slice(0, index));
-          if (option && (option.required || option.optional)) {
-            this.emit(`option:${option.name()}`, arg.slice(index + 1));
-            continue;
-          }
-        }
-        if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
-          dest = unknown;
-        }
-        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
-          if (this._findCommand(arg)) {
-            operands.push(arg);
-            unknown.push(...args.slice(i));
-            break;
-          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg, ...args.slice(i));
-            break;
-          } else if (this._defaultCommandName) {
-            unknown.push(arg, ...args.slice(i));
-            break;
-          }
-        }
-        if (this._passThroughOptions) {
-          dest.push(arg, ...args.slice(i));
-          break;
-        }
-        dest.push(arg);
-      }
-      return { operands, unknown };
-    }
-    opts() {
-      if (this._storeOptionsAsProperties) {
-        const result = {};
-        const len = this.options.length;
-        for (let i = 0;i < len; i++) {
-          const key = this.options[i].attributeName();
-          result[key] = key === this._versionOptionName ? this._version : this[key];
-        }
-        return result;
-      }
-      return this._optionValues;
-    }
-    optsWithGlobals() {
-      return this._getCommandAndAncestors().reduce((combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), {});
-    }
-    error(message, errorOptions) {
-      this._outputConfiguration.outputError(`${message}
-`, this._outputConfiguration.writeErr);
-      if (typeof this._showHelpAfterError === "string") {
-        this._outputConfiguration.writeErr(`${this._showHelpAfterError}
-`);
-      } else if (this._showHelpAfterError) {
-        this._outputConfiguration.writeErr(`
-`);
-        this.outputHelp({ error: true });
-      }
-      const config = errorOptions || {};
-      const exitCode = config.exitCode || 1;
-      const code = config.code || "commander.error";
-      this._exit(exitCode, code, message);
-    }
-    _parseOptionsEnv() {
-      this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process2.env) {
-          const optionKey = option.attributeName();
-          if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
-            if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
-            } else {
-              this.emit(`optionEnv:${option.name()}`);
-            }
-          }
-        }
-      });
-    }
-    _parseOptionsImplied() {
-      const dualHelper = new DualOptions(this.options);
-      const hasCustomOptionValue = (optionKey) => {
-        return this.getOptionValue(optionKey) !== undefined && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
-      };
-      this.options.filter((option) => option.implied !== undefined && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
-        Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
-          this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
-        });
-      });
-    }
-    missingArgument(name) {
-      const message = `error: missing required argument '${name}'`;
-      this.error(message, { code: "commander.missingArgument" });
-    }
-    optionMissingArgument(option) {
-      const message = `error: option '${option.flags}' argument missing`;
-      this.error(message, { code: "commander.optionMissingArgument" });
-    }
-    missingMandatoryOptionValue(option) {
-      const message = `error: required option '${option.flags}' not specified`;
-      this.error(message, { code: "commander.missingMandatoryOptionValue" });
-    }
-    _conflictingOption(option, conflictingOption) {
-      const findBestOptionFromValue = (option2) => {
-        const optionKey = option2.attributeName();
-        const optionValue = this.getOptionValue(optionKey);
-        const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
-        const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
-        if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
-          return negativeOption;
-        }
-        return positiveOption || option2;
-      };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
-        const optionKey = bestOption.attributeName();
-        const source = this.getOptionValueSource(optionKey);
-        if (source === "env") {
-          return `environment variable '${bestOption.envVar}'`;
-        }
-        return `option '${bestOption.flags}'`;
-      };
-      const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
-      this.error(message, { code: "commander.conflictingOption" });
-    }
-    unknownOption(flag) {
-      if (this._allowUnknownOption)
-        return;
-      let suggestion = "";
-      if (flag.startsWith("--") && this._showSuggestionAfterError) {
-        let candidateFlags = [];
-        let command = this;
-        do {
-          const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
-          candidateFlags = candidateFlags.concat(moreFlags);
-          command = command.parent;
-        } while (command && !command._enablePositionalOptions);
-        suggestion = suggestSimilar(flag, candidateFlags);
-      }
-      const message = `error: unknown option '${flag}'${suggestion}`;
-      this.error(message, { code: "commander.unknownOption" });
-    }
-    _excessArguments(receivedArgs) {
-      if (this._allowExcessArguments)
-        return;
-      const expected = this.registeredArguments.length;
-      const s = expected === 1 ? "" : "s";
-      const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
-      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
-      this.error(message, { code: "commander.excessArguments" });
-    }
-    unknownCommand() {
-      const unknownName = this.args[0];
-      let suggestion = "";
-      if (this._showSuggestionAfterError) {
-        const candidateNames = [];
-        this.createHelp().visibleCommands(this).forEach((command) => {
-          candidateNames.push(command.name());
-          if (command.alias())
-            candidateNames.push(command.alias());
-        });
-        suggestion = suggestSimilar(unknownName, candidateNames);
-      }
-      const message = `error: unknown command '${unknownName}'${suggestion}`;
-      this.error(message, { code: "commander.unknownCommand" });
-    }
-    version(str, flags, description) {
-      if (str === undefined)
-        return this._version;
-      this._version = str;
-      flags = flags || "-V, --version";
-      description = description || "output the version number";
-      const versionOption = this.createOption(flags, description);
-      this._versionOptionName = versionOption.attributeName();
-      this._registerOption(versionOption);
-      this.on("option:" + versionOption.name(), () => {
-        this._outputConfiguration.writeOut(`${str}
-`);
-        this._exit(0, "commander.version", str);
-      });
-      return this;
-    }
-    description(str, argsDescription) {
-      if (str === undefined && argsDescription === undefined)
-        return this._description;
-      this._description = str;
-      if (argsDescription) {
-        this._argsDescription = argsDescription;
-      }
-      return this;
-    }
-    summary(str) {
-      if (str === undefined)
-        return this._summary;
-      this._summary = str;
-      return this;
-    }
-    alias(alias) {
-      if (alias === undefined)
-        return this._aliases[0];
-      let command = this;
-      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-        command = this.commands[this.commands.length - 1];
-      }
-      if (alias === command._name)
-        throw new Error("Command alias can't be the same as its name");
-      const matchingCommand = this.parent?._findCommand(alias);
-      if (matchingCommand) {
-        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
-        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
-      }
-      command._aliases.push(alias);
-      return this;
-    }
-    aliases(aliases) {
-      if (aliases === undefined)
-        return this._aliases;
-      aliases.forEach((alias) => this.alias(alias));
-      return this;
-    }
-    usage(str) {
-      if (str === undefined) {
-        if (this._usage)
-          return this._usage;
-        const args = this.registeredArguments.map((arg) => {
-          return humanReadableArgName(arg);
-        });
-        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
-      }
-      this._usage = str;
-      return this;
-    }
-    name(str) {
-      if (str === undefined)
-        return this._name;
-      this._name = str;
-      return this;
-    }
-    helpGroup(heading) {
-      if (heading === undefined)
-        return this._helpGroupHeading ?? "";
-      this._helpGroupHeading = heading;
-      return this;
-    }
-    commandsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultCommandGroup ?? "";
-      this._defaultCommandGroup = heading;
-      return this;
-    }
-    optionsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultOptionGroup ?? "";
-      this._defaultOptionGroup = heading;
-      return this;
-    }
-    _initOptionGroup(option) {
-      if (this._defaultOptionGroup && !option.helpGroupHeading)
-        option.helpGroup(this._defaultOptionGroup);
-    }
-    _initCommandGroup(cmd) {
-      if (this._defaultCommandGroup && !cmd.helpGroup())
-        cmd.helpGroup(this._defaultCommandGroup);
-    }
-    nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
-      return this;
-    }
-    executableDir(path2) {
-      if (path2 === undefined)
-        return this._executableDir;
-      this._executableDir = path2;
-      return this;
-    }
-    helpInformation(contextOptions) {
-      const helper = this.createHelp();
-      const context = this._getOutputContext(contextOptions);
-      helper.prepareContext({
-        error: context.error,
-        helpWidth: context.helpWidth,
-        outputHasColors: context.hasColors
-      });
-      const text = helper.formatHelp(this, helper);
-      if (context.hasColors)
-        return text;
-      return this._outputConfiguration.stripColor(text);
-    }
-    _getOutputContext(contextOptions) {
-      contextOptions = contextOptions || {};
-      const error = !!contextOptions.error;
-      let baseWrite;
-      let hasColors;
-      let helpWidth;
-      if (error) {
-        baseWrite = (str) => this._outputConfiguration.writeErr(str);
-        hasColors = this._outputConfiguration.getErrHasColors();
-        helpWidth = this._outputConfiguration.getErrHelpWidth();
-      } else {
-        baseWrite = (str) => this._outputConfiguration.writeOut(str);
-        hasColors = this._outputConfiguration.getOutHasColors();
-        helpWidth = this._outputConfiguration.getOutHelpWidth();
-      }
-      const write = (str) => {
-        if (!hasColors)
-          str = this._outputConfiguration.stripColor(str);
-        return baseWrite(str);
-      };
-      return { error, write, hasColors, helpWidth };
-    }
-    outputHelp(contextOptions) {
-      let deprecatedCallback;
-      if (typeof contextOptions === "function") {
-        deprecatedCallback = contextOptions;
-        contextOptions = undefined;
-      }
-      const outputContext = this._getOutputContext(contextOptions);
-      const eventContext = {
-        error: outputContext.error,
-        write: outputContext.write,
-        command: this
-      };
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
-      this.emit("beforeHelp", eventContext);
-      let helpInformation = this.helpInformation({ error: outputContext.error });
-      if (deprecatedCallback) {
-        helpInformation = deprecatedCallback(helpInformation);
-        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
-          throw new Error("outputHelp callback must return a string or a Buffer");
-        }
-      }
-      outputContext.write(helpInformation);
-      if (this._getHelpOption()?.long) {
-        this.emit(this._getHelpOption().long);
-      }
-      this.emit("afterHelp", eventContext);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
-    }
-    helpOption(flags, description) {
-      if (typeof flags === "boolean") {
-        if (flags) {
-          if (this._helpOption === null)
-            this._helpOption = undefined;
-          if (this._defaultOptionGroup) {
-            this._initOptionGroup(this._getHelpOption());
-          }
-        } else {
-          this._helpOption = null;
-        }
-        return this;
-      }
-      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
-      if (flags || description)
-        this._initOptionGroup(this._helpOption);
-      return this;
-    }
-    _getHelpOption() {
-      if (this._helpOption === undefined) {
-        this.helpOption(undefined, undefined);
-      }
-      return this._helpOption;
-    }
-    addHelpOption(option) {
-      this._helpOption = option;
-      this._initOptionGroup(option);
-      return this;
-    }
-    help(contextOptions) {
-      this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
-      }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
-    }
-    addHelpText(position, text) {
-      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-      if (!allowedValues.includes(position)) {
-        throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      const helpEvent = `${position}Help`;
-      this.on(helpEvent, (context) => {
-        let helpStr;
-        if (typeof text === "function") {
-          helpStr = text({ error: context.error, command: context.command });
-        } else {
-          helpStr = text;
-        }
-        if (helpStr) {
-          context.write(`${helpStr}
-`);
-        }
-      });
-      return this;
-    }
-    _outputHelpIfRequested(args) {
-      const helpOption = this._getHelpOption();
-      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
-      if (helpRequested) {
-        this.outputHelp();
-        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
-      }
-    }
-  }
-  function incrementNodeInspectorPort(args) {
-    return args.map((arg) => {
-      if (!arg.startsWith("--inspect")) {
-        return arg;
-      }
-      let debugOption;
-      let debugHost = "127.0.0.1";
-      let debugPort = "9229";
-      let match;
-      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-        debugOption = match[1];
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-        debugOption = match[1];
-        if (/^\d+$/.test(match[3])) {
-          debugPort = match[3];
-        } else {
-          debugHost = match[3];
-        }
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-        debugOption = match[1];
-        debugHost = match[3];
-        debugPort = match[4];
-      }
-      if (debugOption && debugPort !== "0") {
-        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-      }
-      return arg;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
     });
-  }
-  function useColor() {
-    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
-      return false;
-    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
-      return true;
-    return;
-  }
-  exports.Command = Command;
-  exports.useColor = useColor;
-});
-
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // ../../node_modules/.bun/unzipit@1.4.3/node_modules/unzipit/dist/unzipit.module.js
 var exports_unzipit_module = {};
@@ -2277,16 +153,16 @@ function inflate(data, buf) {
       HDIST = bitsE(data, pos + 5, 5) + 1;
       HCLEN = bitsE(data, pos + 10, 4) + 4;
       pos += 14;
-      for (var i = 0;i < 38; i += 2) {
-        U.itree[i] = 0;
-        U.itree[i + 1] = 0;
+      for (var i2 = 0;i2 < 38; i2 += 2) {
+        U.itree[i2] = 0;
+        U.itree[i2 + 1] = 0;
       }
       var tl = 1;
-      for (var i = 0;i < HCLEN; i++) {
-        var l = bitsE(data, pos + i * 3, 3);
-        U.itree[(U.ordr[i] << 1) + 1] = l;
-        if (l > tl)
-          tl = l;
+      for (var i2 = 0;i2 < HCLEN; i2++) {
+        var l2 = bitsE(data, pos + i2 * 3, 3);
+        U.itree[(U.ordr[i2] << 1) + 1] = l2;
+        if (l2 > tl)
+          tl = l2;
       }
       pos += 3 * HCLEN;
       makeCodes(U.itree, tl);
@@ -2347,61 +223,61 @@ function _check(buf, len) {
 }
 function _decodeTiny(lmap, LL, len, data, pos, tree) {
   var bitsE = _bitsE, get17 = _get17;
-  var i = 0;
-  while (i < len) {
+  var i2 = 0;
+  while (i2 < len) {
     var code = lmap[get17(data, pos) & LL];
     pos += code & 15;
     var lit = code >>> 4;
     if (lit <= 15) {
-      tree[i] = lit;
-      i++;
+      tree[i2] = lit;
+      i2++;
     } else {
-      var ll = 0, n = 0;
+      var ll = 0, n2 = 0;
       if (lit == 16) {
-        n = 3 + bitsE(data, pos, 2);
+        n2 = 3 + bitsE(data, pos, 2);
         pos += 2;
-        ll = tree[i - 1];
+        ll = tree[i2 - 1];
       } else if (lit == 17) {
-        n = 3 + bitsE(data, pos, 3);
+        n2 = 3 + bitsE(data, pos, 3);
         pos += 3;
       } else if (lit == 18) {
-        n = 11 + bitsE(data, pos, 7);
+        n2 = 11 + bitsE(data, pos, 7);
         pos += 7;
       }
-      var ni = i + n;
-      while (i < ni) {
-        tree[i] = ll;
-        i++;
+      var ni = i2 + n2;
+      while (i2 < ni) {
+        tree[i2] = ll;
+        i2++;
       }
     }
   }
   return pos;
 }
 function _copyOut(src, off, len, tree) {
-  var mx = 0, i = 0, tl = tree.length >>> 1;
-  while (i < len) {
-    var v = src[i + off];
-    tree[i << 1] = 0;
-    tree[(i << 1) + 1] = v;
+  var mx = 0, i2 = 0, tl = tree.length >>> 1;
+  while (i2 < len) {
+    var v = src[i2 + off];
+    tree[i2 << 1] = 0;
+    tree[(i2 << 1) + 1] = v;
     if (v > mx)
       mx = v;
-    i++;
+    i2++;
   }
-  while (i < tl) {
-    tree[i << 1] = 0;
-    tree[(i << 1) + 1] = 0;
-    i++;
+  while (i2 < tl) {
+    tree[i2 << 1] = 0;
+    tree[(i2 << 1) + 1] = 0;
+    i2++;
   }
   return mx;
 }
 function makeCodes(tree, MAX_BITS) {
   var max_code = tree.length;
-  var code, bits, n, i, len;
+  var code, bits, n2, i2, len;
   var bl_count = U.bl_count;
-  for (var i = 0;i <= MAX_BITS; i++)
-    bl_count[i] = 0;
-  for (i = 1;i < max_code; i += 2)
-    bl_count[tree[i]]++;
+  for (var i2 = 0;i2 <= MAX_BITS; i2++)
+    bl_count[i2] = 0;
+  for (i2 = 1;i2 < max_code; i2 += 2)
+    bl_count[tree[i2]]++;
   var next_code = U.next_code;
   code = 0;
   bl_count[0] = 0;
@@ -2409,10 +285,10 @@ function makeCodes(tree, MAX_BITS) {
     code = code + bl_count[bits - 1] << 1;
     next_code[bits] = code;
   }
-  for (n = 0;n < max_code; n += 2) {
-    len = tree[n + 1];
+  for (n2 = 0;n2 < max_code; n2 += 2) {
+    len = tree[n2 + 1];
     if (len != 0) {
-      tree[n] = next_code[len];
+      tree[n2] = next_code[len];
       next_code[len]++;
     }
   }
@@ -2420,11 +296,11 @@ function makeCodes(tree, MAX_BITS) {
 function codes2map(tree, MAX_BITS, map) {
   var max_code = tree.length;
   var r15 = U.rev15;
-  for (var i = 0;i < max_code; i += 2)
-    if (tree[i + 1] != 0) {
-      var lit = i >> 1;
-      var cl = tree[i + 1], val = lit << 4 | cl;
-      var rest = MAX_BITS - cl, i0 = tree[i] << rest, i1 = i0 + (1 << rest);
+  for (var i2 = 0;i2 < max_code; i2 += 2)
+    if (tree[i2 + 1] != 0) {
+      var lit = i2 >> 1;
+      var cl = tree[i2 + 1], val = lit << 4 | cl;
+      var rest = MAX_BITS - cl, i0 = tree[i2] << rest, i1 = i0 + (1 << rest);
       while (i0 != i1) {
         var p0 = r15[i0] >>> 15 - MAX_BITS;
         map[p0] = val;
@@ -2434,9 +310,9 @@ function codes2map(tree, MAX_BITS, map) {
 }
 function revCodes(tree, MAX_BITS) {
   var r15 = U.rev15, imb = 15 - MAX_BITS;
-  for (var i = 0;i < tree.length; i += 2) {
-    var i0 = tree[i] << MAX_BITS - tree[i + 1];
-    tree[i] = r15[i0] >>> imb;
+  for (var i2 = 0;i2 < tree.length; i2 += 2) {
+    var i0 = tree[i2] << MAX_BITS - tree[i2 + 1];
+    tree[i2] = r15[i0] >>> imb;
   }
 }
 function _bitsE(dt, pos, length) {
@@ -2639,11 +515,11 @@ async function findEndOfCentralDirector(reader, totalLength) {
   const size = Math.min(EOCDR_WITHOUT_COMMENT_SIZE + MAX_COMMENT_SIZE, totalLength);
   const readStart = totalLength - size;
   const data = await readAs(reader, readStart, size);
-  for (let i = size - EOCDR_WITHOUT_COMMENT_SIZE;i >= 0; --i) {
-    if (getUint32LE(data, i) !== EOCDR_SIGNATURE) {
+  for (let i2 = size - EOCDR_WITHOUT_COMMENT_SIZE;i2 >= 0; --i2) {
+    if (getUint32LE(data, i2) !== EOCDR_SIGNATURE) {
       continue;
     }
-    const eocdr = new Uint8Array(data.buffer, data.byteOffset + i, data.byteLength - i);
+    const eocdr = new Uint8Array(data.buffer, data.byteOffset + i2, data.byteLength - i2);
     const diskNumber = getUint16LE(eocdr, 4);
     if (diskNumber !== 0) {
       throw new Error(`multi-volume zip files are not supported. This is volume: ${diskNumber}`);
@@ -2659,7 +535,7 @@ async function findEndOfCentralDirector(reader, totalLength) {
     const commentBytes = new Uint8Array(eocdr.buffer, eocdr.byteOffset + 22, commentLength);
     const comment = decodeBuffer(commentBytes);
     if (entryCount === 65535 || centralDirectoryOffset === 4294967295) {
-      return await readZip64CentralDirectory(reader, readStart + i, comment, commentBytes);
+      return await readZip64CentralDirectory(reader, readStart + i2, comment, commentBytes);
     } else {
       return await readEntries(reader, centralDirectoryOffset, centralDirectorySize, entryCount, comment, commentBytes);
     }
@@ -2719,11 +595,11 @@ async function readEntries(reader, centralDirectoryOffset, centralDirectorySize,
     const fileCommentStart = rawEntry.fileNameLength + rawEntry.extraFieldLength;
     const extraFieldBuffer = data.slice(rawEntry.fileNameLength, fileCommentStart);
     rawEntry.extraFields = [];
-    let i = 0;
-    while (i < extraFieldBuffer.length - 3) {
-      const headerId = getUint16LE(extraFieldBuffer, i + 0);
-      const dataSize = getUint16LE(extraFieldBuffer, i + 2);
-      const dataStart = i + 4;
+    let i2 = 0;
+    while (i2 < extraFieldBuffer.length - 3) {
+      const headerId = getUint16LE(extraFieldBuffer, i2 + 0);
+      const dataSize = getUint16LE(extraFieldBuffer, i2 + 2);
+      const dataStart = i2 + 4;
       const dataEnd = dataStart + dataSize;
       if (dataEnd > extraFieldBuffer.length) {
         throw new Error("extra field length exceeds extra field buffer size");
@@ -2732,7 +608,7 @@ async function readEntries(reader, centralDirectoryOffset, centralDirectorySize,
         id: headerId,
         data: extraFieldBuffer.slice(dataStart, dataEnd)
       });
-      i = dataEnd;
+      i2 = dataEnd;
     }
     rawEntry.commentBytes = data.slice(fileCommentStart, fileCommentStart + rawEntry.fileCommentLength);
     rawEntry.comment = decodeBuffer(rawEntry.commentBytes);
@@ -2922,21 +798,21 @@ var init_unzipit_module = __esm(() => {
   }();
   (function() {
     var len = 1 << 15;
-    for (var i = 0;i < len; i++) {
-      var x = i;
+    for (var i2 = 0;i2 < len; i2++) {
+      var x = i2;
       x = (x & 2863311530) >>> 1 | (x & 1431655765) << 1;
       x = (x & 3435973836) >>> 2 | (x & 858993459) << 2;
       x = (x & 4042322160) >>> 4 | (x & 252645135) << 4;
       x = (x & 4278255360) >>> 8 | (x & 16711935) << 8;
-      U.rev15[i] = (x >>> 16 | x << 16) >>> 17;
+      U.rev15[i2] = (x >>> 16 | x << 16) >>> 17;
     }
-    function pushV(tgt, n, sv) {
-      while (n-- != 0)
+    function pushV(tgt, n2, sv) {
+      while (n2-- != 0)
         tgt.push(0, sv);
     }
-    for (var i = 0;i < 32; i++) {
-      U.ldef[i] = U.of0[i] << 3 | U.exb[i];
-      U.ddef[i] = U.df0[i] << 4 | U.dxb[i];
+    for (var i2 = 0;i2 < 32; i2++) {
+      U.ldef[i2] = U.of0[i2] << 3 | U.exb[i2];
+      U.ddef[i2] = U.df0[i2] << 4 | U.dxb[i2];
     }
     pushV(U.fltree, 144, 8);
     pushV(U.fltree, 255 - 143, 9);
@@ -2957,25 +833,25 @@ var init_unzipit_module = __esm(() => {
   crc = {
     table: function() {
       var tab = new Uint32Array(256);
-      for (var n = 0;n < 256; n++) {
-        var c = n;
+      for (var n2 = 0;n2 < 256; n2++) {
+        var c = n2;
         for (var k = 0;k < 8; k++) {
           if (c & 1)
             c = 3988292384 ^ c >>> 1;
           else
             c = c >>> 1;
         }
-        tab[n] = c;
+        tab[n2] = c;
       }
       return tab;
     }(),
     update: function(c, buf, off, len) {
-      for (var i = 0;i < len; i++)
-        c = crc.table[(c ^ buf[off + i]) & 255] ^ c >>> 8;
+      for (var i2 = 0;i2 < len; i2++)
+        c = crc.table[(c ^ buf[off + i2]) & 255] ^ c >>> 8;
       return c;
     },
-    crc: function(b, o, l) {
-      return crc.update(4294967295, b, o, l) ^ 4294967295;
+    crc: function(b, o2, l2) {
+      return crc.update(4294967295, b, o2, l2) ^ 4294967295;
     }
   };
   config = {
@@ -3056,26 +932,259 @@ var init_unzipit_module = __esm(() => {
   utf8Decoder = new TextDecoder;
 });
 
-// ../../node_modules/.bun/commander@14.0.3/node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
+// ../../node_modules/.bun/mri@1.2.0/node_modules/mri/lib/index.mjs
+function toArr(any) {
+  return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  var x, old = out[key], nxt = ~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+  out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function lib_default(args, opts) {
+  args = args || [];
+  opts = opts || {};
+  var k, arr, arg, name, val, out = { _: [] };
+  var i = 0, j = 0, idx = 0, len = args.length;
+  const alibi = opts.alias !== undefined;
+  const strict = opts.unknown !== undefined;
+  const defaults = opts.default !== undefined;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0;i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length;i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length;j-- > 0; )
+      opts.boolean.push(arr[j]);
+  }
+  for (i = opts.string.length;i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length;j-- > 0; )
+      opts.string.push(arr[j]);
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== undefined) {
+        opts[name].push(k);
+        for (i = 0;i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0;i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0;j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45)
+        break;
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.substring(j + 3);
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1;idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61)
+          break;
+      }
+      name = arg.substring(j, idx);
+      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
+      arr = j === 2 ? [name] : name;
+      for (idx = 0;idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name))
+          return opts.unknown("-".repeat(j) + name);
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === undefined) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}
+
+// ../../node_modules/.bun/sade@1.8.1/node_modules/sade/lib/index.mjs
+var t = "__all__";
+var i = "__default__";
+var s = `
+`;
+function r(e) {
+  if (!e.length)
+    return "";
+  let t2 = function(e2) {
+    let t3 = 0, i2 = 0, s2 = 0, r2 = e2.length;
+    if (r2)
+      for (;r2--; )
+        i2 = e2[r2].length, i2 > t3 && (s2 = r2, t3 = i2);
+    return e2[s2].length;
+  }(e.map((e2) => e2[0])) + 4;
+  return e.map((e2) => e2[0] + " ".repeat(t2 - e2[0].length) + e2[1] + (e2[2] == null ? "" : `  (default ${e2[2]})`));
+}
+function n(e) {
+  return e;
+}
+function l(e, t2, i2) {
+  if (!t2 || !t2.length)
+    return "";
+  let r2 = 0, n2 = "";
+  for (n2 += `
+  ` + e;r2 < t2.length; r2++)
+    n2 += `
+    ` + i2(t2[r2]);
+  return n2 + s;
+}
+function a(e, t2, i2 = 1) {
+  let s2 = l("ERROR", [t2], n);
+  s2 += `
+  Run \`$ ${e} --help\` for more info.
+`, console.error(s2), process.exit(i2);
+}
+
+class o {
+  constructor(e, s2) {
+    let [r2, ...n2] = e.split(/\s+/);
+    s2 = s2 || n2.length > 0, this.bin = r2, this.ver = "0.0.0", this.default = "", this.tree = {}, this.command(t), this.command([i].concat(s2 ? n2 : "<command>").join(" ")), this.single = s2, this.curr = "";
+  }
+  command(e, t2, i2 = {}) {
+    if (this.single)
+      throw new Error('Disable "single" mode to add commands');
+    let s2 = [], r2 = [], n2 = /(\[|<)/;
+    if (e.split(/\s+/).forEach((e2) => {
+      (n2.test(e2.charAt(0)) ? r2 : s2).push(e2);
+    }), s2 = s2.join(" "), s2 in this.tree)
+      throw new Error("Command already exists: " + s2);
+    return s2.includes("__") || r2.unshift(s2), r2 = r2.join(" "), this.curr = s2, i2.default && (this.default = s2), this.tree[s2] = { usage: r2, alibi: [], options: [], alias: {}, default: {}, examples: [] }, i2.alias && this.alias(i2.alias), t2 && this.describe(t2), this;
+  }
+  describe(e) {
+    return this.tree[this.curr || i].describe = Array.isArray(e) ? e : function(e2) {
+      return (e2 || "").replace(/([.?!])\s*(?=[A-Z])/g, "$1|").split("|");
+    }(e), this;
+  }
+  alias(...e) {
+    if (this.single)
+      throw new Error('Cannot call `alias()` in "single" mode');
+    if (!this.curr)
+      throw new Error("Cannot call `alias()` before defining a command");
+    return (this.tree[this.curr].alibi = this.tree[this.curr].alibi.concat(...e)).forEach((e2) => this.tree[e2] = this.curr), this;
+  }
+  option(e, i2, s2) {
+    let r2 = this.tree[this.curr || t], [n2, l2] = function(e2) {
+      return (e2 || "").split(/^-{1,2}|,|\s+-{1,2}|\s+/).filter(Boolean);
+    }(e);
+    if (l2 && l2.length > 1 && ([n2, l2] = [l2, n2]), e = "--" + n2, l2 && l2.length > 0) {
+      e = `-${l2}, ${e}`;
+      let t2 = r2.alias[l2];
+      r2.alias[l2] = (t2 || []).concat(n2);
+    }
+    let a2 = [e, i2 || ""];
+    return s2 !== undefined ? (a2.push(s2), r2.default[n2] = s2) : l2 || (r2.default[n2] = undefined), r2.options.push(a2), this;
+  }
+  action(e) {
+    return this.tree[this.curr || i].handler = e, this;
+  }
+  example(e) {
+    return this.tree[this.curr || i].examples.push(e), this;
+  }
+  version(e) {
+    return this.ver = e, this;
+  }
+  parse(s2, r2 = {}) {
+    s2 = s2.slice();
+    let n2, l2, o2, h, u = 2, f = lib_default(s2.slice(u), { alias: { h: "help", v: "version" } }), c = this.single, p = this.bin, d = "";
+    if (c)
+      h = this.tree[i];
+    else {
+      let e, t2 = 1, i2 = f._.length + 1;
+      for (;t2 < i2; t2++)
+        if (n2 = f._.slice(0, t2).join(" "), e = this.tree[n2], typeof e == "string")
+          l2 = (d = e).split(" "), s2.splice(s2.indexOf(f._[0]), t2, ...l2), t2 += l2.length - t2;
+        else if (e)
+          d = n2;
+        else if (d)
+          break;
+      if (h = this.tree[d], o2 = h === undefined, o2) {
+        if (this.default)
+          d = this.default, h = this.tree[d], s2.unshift(d), u++;
+        else if (n2)
+          return a(p, "Invalid command: " + n2);
+      }
+    }
+    if (f.help)
+      return this.help(!c && !o2 && d);
+    if (f.version)
+      return this._version();
+    if (!c && h === undefined)
+      return a(p, "No command specified.");
+    let g = this.tree[t];
+    r2.alias = Object.assign(g.alias, h.alias, r2.alias), r2.default = Object.assign(g.default, h.default, r2.default), n2 = d.split(" "), l2 = s2.indexOf(n2[0], 2), ~l2 && s2.splice(l2, n2.length);
+    let m = lib_default(s2.slice(u), r2);
+    if (!m || typeof m == "string")
+      return a(p, m || "Parsed unknown option flag(s)!");
+    let b = h.usage.split(/\s+/), _ = b.filter((e) => e.charAt(0) === "<"), v = m._.splice(0, _.length);
+    if (v.length < _.length)
+      return d && (p += " " + d), a(p, "Insufficient arguments!");
+    b.filter((e) => e.charAt(0) === "[").forEach((e) => {
+      v.push(m._.shift());
+    }), v.push(m);
+    let $ = h.handler;
+    return r2.lazy ? { args: v, name: d, handler: $ } : $.apply(null, v);
+  }
+  help(e) {
+    console.log(function(e2, a2, o2, h) {
+      let u = "", f = a2[o2], c = "$ " + e2, p = a2[t], d = (e3) => `${c} ${e3}`.replace(/\s+/g, " "), g = [["-h, --help", "Displays this message"]];
+      if (o2 === i && g.unshift(["-v, --version", "Displays current version"]), f.options = (f.options || []).concat(p.options, g), f.options.length > 0 && (f.usage += " [options]"), u += l("Description", f.describe, n), u += l("Usage", [f.usage], d), h || o2 !== i)
+        h || o2 === i || (u += l("Aliases", f.alibi, d));
+      else {
+        let e3, t2 = /^__/, i2 = "", o3 = [];
+        for (e3 in a2)
+          typeof a2[e3] == "string" || t2.test(e3) || o3.push([e3, (a2[e3].describe || [""])[0]]) < 3 && (i2 += `
+    ${c} ${e3} --help`);
+        u += l("Available Commands", r(o3), n), u += "\n  For more info, run any command with the `--help` flag" + i2 + s;
+      }
+      return u += l("Options", r(f.options), n), u += l("Examples", f.examples.map(d), n), u;
+    }(this.bin, this.tree, e || i, this.single));
+  }
+  _version() {
+    console.log(`${this.bin}, ${this.ver}`);
+  }
+}
+var lib_default2 = (e, t2) => new o(e, t2);
 // package.json
 var package_default = {
   name: "@v5x/cli",
-  description: "modern v5 development",
-  version: "0.0.20",
+  description: "modern v5 tools",
+  version: "0.0.21",
   module: "dist/index.js",
   type: "module",
   bin: {
@@ -3102,8 +1211,8 @@ var package_default = {
     "bun-serialport": "^0.1.1",
     chalk: "^5.6.2",
     "cmd-table": "^1.6.0",
-    commander: "^14.0.3",
-    fflate: "^0.8.3"
+    fflate: "^0.8.3",
+    sade: "^1.8.1"
   }
 };
 
@@ -3698,7 +1807,7 @@ class PacketView extends DataView {
   }
   nextString(length) {
     let result = "";
-    for (let i = 0;i < length; i++) {
+    for (let i2 = 0;i2 < length; i2++) {
       result += String.fromCharCode(this.nextUint8());
     }
     return result;
@@ -3706,7 +1815,7 @@ class PacketView extends DataView {
   nextNTBS(length) {
     let result = "";
     const lastPosition = this.position;
-    for (let i = 0;i < length; i++) {
+    for (let i2 = 0;i2 < length; i2++) {
       if (this.byteLength <= this.position)
         break;
       const g = this.nextUint8();
@@ -3719,7 +1828,7 @@ class PacketView extends DataView {
   }
   nextVarNTBS(length) {
     let result = "";
-    for (let i = 0;i < length; i++) {
+    for (let i2 = 0;i2 < length; i2++) {
       if (this.byteLength <= this.position)
         break;
       const g = this.nextUint8();
@@ -4002,37 +2111,37 @@ class CrcGenerator {
   crc16(buf, initValue) {
     const numberOfBytes = buf.byteLength;
     let accumulator = initValue;
-    let i;
+    let i2;
     let j;
     for (j = 0;j < numberOfBytes; j++) {
-      i = (accumulator >>> 8 ^ buf[j]) & 255;
-      accumulator = (accumulator << 8 ^ CRC16TABLE[i]) >>> 0;
+      i2 = (accumulator >>> 8 ^ buf[j]) & 255;
+      accumulator = (accumulator << 8 ^ CRC16TABLE[i2]) >>> 0;
     }
     return (accumulator & 65535) >>> 0;
   }
   crc32GenTable() {
-    let i;
+    let i2;
     let j;
     let crcAccumulator;
-    for (i = 0;i < 256; i++) {
-      crcAccumulator = i << 24;
+    for (i2 = 0;i2 < 256; i2++) {
+      crcAccumulator = i2 << 24;
       for (j = 0;j < 8; j++) {
         if ((crcAccumulator & 2147483648) !== 0)
           crcAccumulator = crcAccumulator << 1 ^ CrcGenerator.POLYNOMIAL_CRC32;
         else
           crcAccumulator = crcAccumulator << 1;
       }
-      this.crc32Table[i] = crcAccumulator;
+      this.crc32Table[i2] = crcAccumulator;
     }
   }
   crc32(buf, initValue) {
     const numberOfBytes = buf.byteLength;
     let crcAccumulator = initValue;
-    let i;
+    let i2;
     let j;
     for (j = 0;j < numberOfBytes; j++) {
-      i = (crcAccumulator >>> 24 ^ buf[j]) & 255;
-      crcAccumulator = (crcAccumulator << 8 ^ this.crc32Table[i]) >>> 0;
+      i2 = (crcAccumulator >>> 24 ^ buf[j]) & 255;
+      crcAccumulator = (crcAccumulator << 8 ^ this.crc32Table[i2]) >>> 0;
     }
     return (crcAccumulator & 4294967295) >>> 0;
   }
@@ -4117,13 +2226,13 @@ class PacketEncoder {
     return this.crcgen.crc16(message, 0) === lastTwoBytes;
   }
   getPayloadSize(data) {
-    let t = 0;
-    let a = data[3];
-    if ((128 & a) !== 0) {
-      t = 127 & a;
-      a = data[4];
+    let t2 = 0;
+    let a2 = data[3];
+    if ((128 & a2) !== 0) {
+      t2 = 127 & a2;
+      a2 = data[4];
     }
-    return (t << 8) + a;
+    return (t2 << 8) + a2;
   }
 }
 PacketEncoder.HEADERS_LENGTH = 4;
@@ -4215,9 +2324,9 @@ GetRadioModeH2DPacket.COMMAND_ID = 88;
 GetRadioModeH2DPacket.COMMAND_EXTENDED_ID = 65;
 
 class FileControlH2DPacket extends DeviceBoundPacket {
-  constructor(a, b) {
+  constructor(a2, b) {
     const payload = new Uint8Array(2);
-    payload.set([a, b], 0);
+    payload.set([a2, b], 0);
     super(payload);
   }
 }
@@ -4604,11 +2713,11 @@ class HostBoundPacket extends Packet {
     super(data);
     this.ack = AckType.CDC2_NACK;
     this.payloadSize = Packet.ENCODER.getPayloadSize(this.data);
-    const n = this.payloadSize > 128 ? 5 : 4;
-    this.ack = this.data[this.ackIndex = n + 1];
+    const n2 = this.payloadSize > 128 ? 5 : 4;
+    this.ack = this.data[this.ackIndex = n2 + 1];
   }
-  static isValidPacket(data, n) {
-    const ack = data[n + 1];
+  static isValidPacket(data, n2) {
+    const ack = data[n2 + 1];
     return ack === AckType.CDC2_ACK || ack === 167;
   }
 }
@@ -4651,7 +2760,7 @@ class MatchStatusReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    const n = this.ackIndex;
+    const n2 = this.ackIndex;
     this.rssi = dataView.nextInt8();
     this.systemStatusBits = dataView.nextUint16();
     this.radioStatusBits = dataView.nextUint16();
@@ -4667,9 +2776,9 @@ class MatchStatusReplyD2HPacket extends HostBoundPacket {
     this.radioChannel = dataView.nextUint8();
     this.radioSlot = dataView.nextUint8();
     this.robotName = dataView.nextNTBS(10);
-    this.controllerFlags = dataView.getUint8(n + 28);
-    this.rxSignalQuality = dataView.getUint8(n + 29);
-    let rawStr = new TextDecoder("UTF-8").decode(data.slice(n + 18, n + this.payloadSize + 28));
+    this.controllerFlags = dataView.getUint8(n2 + 28);
+    this.rxSignalQuality = dataView.getUint8(n2 + 29);
+    let rawStr = new TextDecoder("UTF-8").decode(data.slice(n2 + 18, n2 + this.payloadSize + 28));
     const endIdx = rawStr.indexOf("\x00");
     if (endIdx > -1) {
       rawStr = rawStr.substr(0, endIdx);
@@ -4711,13 +2820,13 @@ class ReadFileReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    const n = this.ackIndex;
-    this.addr = dataView.getUint32(n, true);
+    const n2 = this.ackIndex;
+    this.addr = dataView.getUint32(n2, true);
     this.length = this.payloadSize - 7;
-    this.buf = data.slice(n + 4, n + 4 + this.length);
+    this.buf = data.slice(n2 + 4, n2 + 4 + this.length);
   }
-  static isValidPacket(data, n) {
-    return data[4] === 4 ? data[n + 1] === AckType.CDC2_ACK : true;
+  static isValidPacket(data, n2) {
+    return data[4] === 4 ? data[n2 + 1] === AckType.CDC2_ACK : true;
   }
 }
 ReadFileReplyD2HPacket.COMMAND_ID = 86;
@@ -4856,7 +2965,7 @@ class GetDeviceStatusReplyD2HPacket extends HostBoundPacket {
     const dataView = PacketView.fromPacket(this);
     this.count = dataView.nextUint8();
     this.devices = [];
-    for (let i = 0;i < this.count; i++) {
+    for (let i2 = 0;i2 < this.count; i2++) {
       this.devices.push({
         port: dataView.nextUint8(),
         type: dataView.nextUint8(),
@@ -4918,7 +3027,7 @@ class GetFdtStatusReplyD2HPacket extends HostBoundPacket {
     const dataView = PacketView.fromPacket(this);
     this.count = dataView.nextUint8();
     this.status = [];
-    for (let i = 0;i < this.count; i++) {
+    for (let i2 = 0;i2 < this.count; i2++) {
       this.status.push({
         index: dataView.nextUint8(),
         type: dataView.nextUint8(),
@@ -4948,13 +3057,13 @@ class ReadLogPageReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    const n = this.ackIndex;
+    const n2 = this.ackIndex;
     const size = dataView.nextUint8();
     this.offset = dataView.nextUint32();
     this.count = dataView.nextUint16();
     this.entries = [];
-    let j = n + 8;
-    for (let i = 0;i < this.count; i++) {
+    let j = n2 + 8;
+    for (let i2 = 0;i2 < this.count; i2++) {
       this.entries.push({
         code: dataView.getUint8(j),
         type: dataView.getUint8(j + 1),
@@ -4973,12 +3082,12 @@ class GetRadioStatusReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    const n = this.ackIndex;
+    const n2 = this.ackIndex;
     this.device = dataView.nextUint8();
     this.quality = dataView.nextUint16();
     this.strength = dataView.nextInt16();
-    this.channel = this.data[n + 6];
-    this.timeslot = this.data[n + 7];
+    this.channel = this.data[n2 + 6];
+    this.timeslot = this.data[n2 + 7];
   }
 }
 GetRadioStatusReplyD2HPacket.COMMAND_ID = 86;
@@ -5035,15 +3144,15 @@ class GetSlot1to4InfoReplyD2HPacket extends HostBoundPacket {
     const dataView = PacketView.fromPacket(this);
     this.slotFlags = dataView.nextUint8();
     this.slots = [];
-    for (let i = 0;i < 4; i++) {
-      const hasData = (this.slotFlags & Math.pow(2, start - 1 + i)) !== 0;
+    for (let i2 = 0;i2 < 4; i2++) {
+      const hasData = (this.slotFlags & Math.pow(2, start - 1 + i2)) !== 0;
       if (!hasData)
         continue;
       const iconNum = dataView.nextUint16();
       const nameLen = dataView.nextUint8();
       const name = dataView.nextString(nameLen);
       this.slots.push({
-        slot: start + i,
+        slot: start + i2,
         icon: iconNum,
         name
       });
@@ -5211,14 +3320,14 @@ class VexSerialConnection extends VexEventTarget {
           if (!thePacketEncoder.validateHeader(cache))
             throw new Error("Invalid header");
           const payloadExpectedSize = thePacketEncoder.getPayloadSize(cache);
-          const n = payloadExpectedSize > 128 ? 5 : 4;
-          const totalSize = n + payloadExpectedSize;
+          const n2 = payloadExpectedSize > 128 ? 5 : 4;
+          const totalSize = n2 + payloadExpectedSize;
           cache = yield this.readData(cache, totalSize);
           sliceIdx = totalSize;
           const cmdId = cache[2];
           const hasExtId = cmdId === 88 || cmdId === 86;
-          const cmdExId = hasExtId ? cache[n] : undefined;
-          const ack = cache[n + 1];
+          const cmdExId = hasExtId ? cache[n2] : undefined;
+          const ack = cache[n2 + 1];
           if (hasExtId) {
             if (!thePacketEncoder.validateMessageCdc(cache))
               throw new Error("Invalid message CDC");
@@ -5244,7 +3353,7 @@ class VexSerialConnection extends VexEventTarget {
           if (wantedCmdId === undefined && wantedCmdExId === undefined || PackageType === undefined) {
             callbackInfo.callback(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
           } else {
-            if (!hasExtId || PackageType.isValidPacket(data, n)) {
+            if (!hasExtId || PackageType.isValidPacket(data, n2)) {
               callbackInfo.callback(new PackageType(data));
             } else {
               console.warn("ack", ack);
@@ -5477,10 +3586,10 @@ function logData(data, limitedSize) {
   if (data === undefined)
     return;
   limitedSize || (limitedSize = data.length);
-  let a = "";
-  for (let n = 0;n < data.length && n < limitedSize; n++)
-    a += ("00" + data[n].toString(16)).substr(-2, 2) + " ";
-  limitedSize < data.length && (a += " ... ");
+  let a2 = "";
+  for (let n2 = 0;n2 < data.length && n2 < limitedSize; n2++)
+    a2 += ("00" + data[n2].toString(16)).substr(-2, 2) + " ";
+  limitedSize < data.length && (a2 += " ... ");
 }
 function binaryArrayJoin(left, right) {
   const leftSize = left != null ? left.byteLength : 0;
@@ -5690,8 +3799,8 @@ class V5Brain {
       if (!(result instanceof GetDirectoryFileCountReplyD2HPacket))
         return;
       const files = [];
-      for (let i = 0;i < result.count; i++) {
-        const result2 = yield conn.writeDataAsync(new GetDirectoryEntryH2DPacket(i));
+      for (let i2 = 0;i2 < result.count; i2++) {
+        const result2 = yield conn.writeDataAsync(new GetDirectoryEntryH2DPacket(i2));
         if (!(result2 instanceof GetDirectoryEntryReplyD2HPacket))
           return;
         if (result2.file != null) {
@@ -5724,30 +3833,30 @@ class V5Brain {
         var _a2;
         return (_a2 = (file === null || file === undefined ? undefined : file.filename.search(/.ini$/)) > 0) !== null && _a2 !== undefined ? _a2 : false;
       });
-      for (let i = 0;i < iniFiles.length; i++) {
-        const ini = iniFiles[i];
+      for (let i2 = 0;i2 < iniFiles.length; i2++) {
+        const ini = iniFiles[i2];
         if (ini.size === 0)
           continue;
         const programName = (_b = (_a = /(.+?)(\.[^.]*$|$)/.exec(ini.filename)) === null || _a === undefined ? undefined : _a[1]) !== null && _b !== undefined ? _b : "";
         const bin = files.filter((e) => e != null && e.filename === programName + ".bin")[0];
         if (bin == null || bin.timestamp === 0 || bin.size === 0)
           continue;
-        const n = new Date;
-        n.setTime(1000 * bin.timestamp);
-        const program2 = {
+        const n2 = new Date;
+        n2.setTime(1000 * bin.timestamp);
+        const program = {
           name: programName,
           binfile: bin.filename,
           size: ini.size + bin.size,
           slot: -1,
-          time: n,
+          time: n2,
           requestedSlot: -1
         };
-        const result2 = yield conn === null || conn === undefined ? undefined : conn.writeDataAsync(new GetProgramSlotInfoH2DPacket(FileVendor.USER, program2.binfile));
+        const result2 = yield conn === null || conn === undefined ? undefined : conn.writeDataAsync(new GetProgramSlotInfoH2DPacket(FileVendor.USER, program.binfile));
         if (result2 instanceof GetProgramSlotInfoReplyD2HPacket) {
-          program2.slot = result2.slot;
-          program2.requestedSlot = result2.requestedSlot;
+          program.slot = result2.slot;
+          program.requestedSlot = result2.requestedSlot;
         }
-        programList.push(program2);
+        programList.push(program);
       }
       return programList;
     });
@@ -5848,8 +3957,8 @@ class V5Brain {
           autoRun: true,
           linkedFile: undefined
         };
-        const result2 = yield conn.uploadFileToDevice(bootWriteRequest, (c, t) => {
-          pcb("UPLOAD BOOT", c, t);
+        const result2 = yield conn.uploadFileToDevice(bootWriteRequest, (c, t2) => {
+          pcb("UPLOAD BOOT", c, t2);
         });
         if (!result2)
           return false;
@@ -5891,8 +4000,8 @@ class V5Brain {
           autoRun: true,
           linkedFile: undefined
         };
-        const result6 = yield conn.uploadFileToDevice(assertWriteRequest, (c, t) => {
-          pcb("UPLOAD ASSERT", c, t);
+        const result6 = yield conn.uploadFileToDevice(assertWriteRequest, (c, t2) => {
+          pcb("UPLOAD ASSERT", c, t2);
         });
         if (!result6)
           return false;
@@ -6007,11 +4116,11 @@ class V5Brain {
       }, FileDownloadTarget.FILE_TARGET_CBUF, progressCallback);
       if (buf == null)
         return;
-      buf = buf.filter((_byte, i) => i % (messageWidth * messageChannels) < width * messageChannels).filter((_byte, i) => (i + 1) % messageChannels !== 0);
-      for (let i = 0;i < buf.length; i += channels) {
-        const px = buf.slice(i, i + channels).reverse();
+      buf = buf.filter((_byte, i2) => i2 % (messageWidth * messageChannels) < width * messageChannels).filter((_byte, i2) => (i2 + 1) % messageChannels !== 0);
+      for (let i2 = 0;i2 < buf.length; i2 += channels) {
+        const px = buf.slice(i2, i2 + channels).reverse();
         for (let j = 0;j < px.length; j++) {
-          buf[i + j] = px[j];
+          buf[i2 + j] = px[j];
         }
       }
       return buf;
@@ -6165,9 +4274,9 @@ class V5SerialDevice extends VexSerialDevice {
   }
   get devices() {
     const rtn = [];
-    for (let i = 1;i <= this.state.devices.length; i++) {
-      if (this.state.devices[i] != null)
-        rtn.push(new V5SmartDevice(this.state, i));
+    for (let i2 = 1;i2 <= this.state.devices.length; i2++) {
+      if (this.state.devices[i2] != null)
+        rtn.push(new V5SmartDevice(this.state, i2));
     }
     return rtn;
   }
@@ -6359,8 +4468,8 @@ class V5SerialDevice extends VexSerialDevice {
       if (dsPacket == null)
         return false;
       let missingPorts = this.state.devices.map((d) => d === null || d === undefined ? undefined : d.port).filter((p) => p !== undefined);
-      for (let i = 0;i < dsPacket.devices.length; i++) {
-        const device = dsPacket.devices[i];
+      for (let i2 = 0;i2 < dsPacket.devices.length; i2++) {
+        const device = dsPacket.devices[i2];
         this.state.devices[device.port] = device;
         missingPorts = missingPorts.filter((p) => p !== device.port);
       }
@@ -6677,8 +4786,8 @@ function openPort(path, options) {
   writeFlag(termiosView, off.c_oflag, 0);
   writeFlag(termiosView, off.c_lflag, 0);
   const ccOffset = off.c_cc;
-  for (let i = 0;i < NCCS; i++)
-    termiosBytes[ccOffset + i] = 0;
+  for (let i2 = 0;i2 < NCCS; i2++)
+    termiosBytes[ccOffset + i2] = 0;
   termiosBytes[ccOffset + VMIN] = 1;
   termiosBytes[ccOffset + VTIME] = 0;
   const baudCode = encodeBaudRate(baudRate);
@@ -6729,14 +4838,14 @@ function writePort(fd, data) {
   return offset;
 }
 function readPort(fd, buffer) {
-  const n = Number(libc.symbols.read(fd, ptr(buffer), BigInt(buffer.length)));
-  if (n < 0) {
+  const n2 = Number(libc.symbols.read(fd, ptr(buffer), BigInt(buffer.length)));
+  if (n2 < 0) {
     const code = getErrno();
     if (code === 11 || code === 35)
       return 0;
     throw errnoError("read");
   }
-  return n;
+  return n2;
 }
 function updateBaudRate(fd, baudRate) {
   const termiosBuf = new ArrayBuffer(TERMIOS_SIZE);
@@ -6927,9 +5036,9 @@ class SerialPort extends EventEmitter {
       if (!this.#isOpen || this.#isClosing)
         return;
       try {
-        const n = readPort(this.#fd, this.#readBuf);
-        if (n > 0) {
-          const data = this.#readBuf.slice(0, n);
+        const n2 = readPort(this.#fd, this.#readBuf);
+        if (n2 > 0) {
+          const data = this.#readBuf.slice(0, n2);
           this.emit("data", data);
         }
       } catch (err) {
@@ -7005,7 +5114,7 @@ async function listLinux() {
 }
 async function findUsbParent(devicePath) {
   let current = devicePath;
-  for (let i = 0;i < 10; i++) {
+  for (let i2 = 0;i2 < 10; i2++) {
     current = join(current, "..");
     if (await exists(join(current, "idVendor")))
       return current;
@@ -7133,10 +5242,10 @@ class WebSerialAdapter extends EventTarget {
         const info = { path: `/dev/${name}` };
         if (subsystem.includes("usb")) {
           let current = realDevicePath;
-          for (let i = 0;i < 5; i++) {
+          for (let i2 = 0;i2 < 5; i2++) {
             try {
-              const vendorId = await Bun.file(join2(current, "idVendor")).text().then((t) => t.trim());
-              const productId = await Bun.file(join2(current, "idProduct")).text().then((t) => t.trim());
+              const vendorId = await Bun.file(join2(current, "idVendor")).text().then((t2) => t2.trim());
+              const productId = await Bun.file(join2(current, "idProduct")).text().then((t2) => t2.trim());
               info.vendorId = vendorId;
               info.productId = productId;
               break;
@@ -7189,33 +5298,35 @@ async function connectV5Device() {
 }
 
 // src/commands/kv.ts
-var kvCommand = createCommand("kv").description("access a brain's system key/value configuration");
-kvCommand.command("get").argument("<key>").description("get the value of a system variable on a brain").action(async (key) => {
-  const device = await connectV5Device();
-  const value = await device.brain.getValue(key);
-  console.log(value);
-  await device.dispose();
-});
-kvCommand.command("set").argument("<key>").argument("<value>").description("set a system variable on a brain").action(async (key, value) => {
-  const device = await connectV5Device();
-  const ok = await device.brain.setValue(key, value);
-  if (ok)
-    console.log(`set ${key} to ${value}`);
-  else
-    console.error(`failed to set ${key} to ${value}`);
-  await device.dispose();
-});
-var kv_default = kvCommand;
+function registerKvCommand(program) {
+  program.command("kv", "access a brain's system key/value configuration").action(() => {});
+  program.command("kv get <key>", "get the value of a system variable on a brain").action(async (key) => {
+    const device = await connectV5Device();
+    const value = await device.brain.getValue(key);
+    console.log(value);
+    await device.dispose();
+  });
+  program.command("kv set <key> <value>", "set a system variable on a brain").action(async (key, value) => {
+    const device = await connectV5Device();
+    const ok = await device.brain.setValue(key, value);
+    if (ok)
+      console.log(`set ${key} to ${value}`);
+    else
+      console.error(`failed to set ${key} to ${value}`);
+    await device.dispose();
+  });
+}
 
 // src/commands/cat.ts
-var catCommand = createCommand("cat").description("read a file from flash").argument("<file>").action(async (file) => {
-  const device = await connectV5Device();
-  const decoder = new TextDecoder;
-  const content = await device.brain.readFile(file);
-  console.log(decoder.decode(content));
-  await device.dispose();
-});
-var cat_default = catCommand;
+function registerCatCommand(program) {
+  program.command("cat <file>", "read a file from flash").action(async (file) => {
+    const device = await connectV5Device();
+    const decoder = new TextDecoder;
+    const content = await device.brain.readFile(file);
+    console.log(decoder.decode(content));
+    await device.dispose();
+  });
+}
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -7747,12 +5858,12 @@ async function detectProgramType(path) {
 
 // src/utils/process.ts
 async function runProcess(command, cwd) {
-  const [program2, ...args] = command;
-  if (program2 === undefined)
+  const [program, ...args] = command;
+  if (program === undefined)
     throw new Error("cannot run an empty command");
-  const executable = Bun.which(program2);
+  const executable = Bun.which(program);
   if (executable === null) {
-    throw new Error(`${program2} is not installed or is not available on PATH`);
+    throw new Error(`${program} is not installed or is not available on PATH`);
   }
   const process3 = Bun.spawn({
     cmd: [executable, ...args],
@@ -7922,12 +6033,14 @@ function createProgramConfig(options) {
 }
 
 // src/commands/build.ts
-var buildCommand = createCommand("build").description("build a program for the V5 brain").alias("b").argument("[path]", "path to the program", process.cwd()).action(async (path) => {
-  const project = await inspectProject(path);
-  console.log(source_default.yellow(`building ${project.type} program...`));
-  await buildProject(project);
-});
-var build_default = buildCommand;
+function registerBuildCommand(program) {
+  program.command("build [path]", "build a program for the V5 brain", { alias: "b" }).action(async (path) => {
+    path ??= process.cwd();
+    const project = await inspectProject(path);
+    console.log(source_default.yellow(`building ${project.type} program...`));
+    await buildProject(project);
+  });
+}
 
 // ../../node_modules/.bun/cmd-table@1.6.0/node_modules/cmd-table/dist/chunk-G76XL7PC.mjs
 var Column = class {
@@ -8033,9 +6146,9 @@ var LayoutManager = class {
         if (table.columns.length && colIndex + cell.colSpan > table.columns.length) {
           throw new Error(`Row ${rowIndex} exceeds defined column count (${table.columns.length}).`);
         }
-        for (let r = 0;r < cell.rowSpan; r++) {
+        for (let r2 = 0;r2 < cell.rowSpan; r2++) {
           for (let c = 0;c < cell.colSpan; c++) {
-            if (isOccupied(colIndex + c, rowIndex + r)) {
+            if (isOccupied(colIndex + c, rowIndex + r2)) {
               throw new Error(`Cell span conflict at row ${rowIndex}, col ${colIndex}.`);
             }
           }
@@ -8048,17 +6161,17 @@ var LayoutManager = class {
           realRowSpan: cell.rowSpan
         };
         grid[rowIndex][colIndex] = gridCell;
-        for (let r = 0;r < cell.rowSpan; r++) {
+        for (let r2 = 0;r2 < cell.rowSpan; r2++) {
           for (let c = 0;c < cell.colSpan; c++) {
-            markOccupied(colIndex + c, rowIndex + r);
-            if (r === 0 && c === 0)
+            markOccupied(colIndex + c, rowIndex + r2);
+            if (r2 === 0 && c === 0)
               continue;
-            if (!grid[rowIndex + r])
-              grid[rowIndex + r] = [];
-            grid[rowIndex + r][colIndex + c] = {
+            if (!grid[rowIndex + r2])
+              grid[rowIndex + r2] = [];
+            grid[rowIndex + r2][colIndex + c] = {
               cell: gridCell.cell,
               x: colIndex + c,
-              y: rowIndex + r,
+              y: rowIndex + r2,
               realColSpan: gridCell.realColSpan,
               realRowSpan: gridCell.realRowSpan,
               hidden: true
@@ -8070,27 +6183,27 @@ var LayoutManager = class {
       });
     });
     const columnCount = table.columns.length || maxColumns;
-    for (let r = 0;r < grid.length; r++) {
-      if (!grid[r])
-        grid[r] = [];
+    for (let r2 = 0;r2 < grid.length; r2++) {
+      if (!grid[r2])
+        grid[r2] = [];
       for (let c = 0;c < columnCount; c++) {
-        if (grid[r][c])
+        if (grid[r2][c])
           continue;
-        if (isOccupied(c, r)) {
-          grid[r][c] = {
+        if (isOccupied(c, r2)) {
+          grid[r2][c] = {
             cell: new Cell(""),
             x: c,
-            y: r,
+            y: r2,
             realColSpan: 1,
             realRowSpan: 1,
             hidden: true
           };
           continue;
         }
-        grid[r][c] = {
+        grid[r2][c] = {
           cell: new Cell(""),
           x: c,
-          y: r,
+          y: r2,
           realColSpan: 1,
           realRowSpan: 1
         };
@@ -8122,12 +6235,12 @@ function stringWidth(str) {
   const stripped = stripAnsi(str);
   let width = 0;
   let inEmojiZwjSequence = false;
-  for (let i = 0;i < stripped.length; i++) {
-    const code = stripped.codePointAt(i);
+  for (let i2 = 0;i2 < stripped.length; i2++) {
+    const code = stripped.codePointAt(i2);
     if (!code)
       continue;
     if (code > 65535) {
-      i++;
+      i2++;
     }
     if (code <= 31 || 127 <= code && code <= 159) {
       continue;
@@ -8493,9 +6606,9 @@ var Table = class _Table {
       if (op === "count")
         footer[name] = values.length;
       else if (op === "avg")
-        footer[name] = values.length ? Number((values.reduce((a, b) => a + b, 0) / values.length).toFixed(2)) : 0;
+        footer[name] = values.length ? Number((values.reduce((a2, b) => a2 + b, 0) / values.length).toFixed(2)) : 0;
       else
-        footer[name] = values.reduce((a, b) => a + b, 0);
+        footer[name] = values.reduce((a2, b) => a2 + b, 0);
     });
     this.footer = footer;
     return this;
@@ -8523,8 +6636,8 @@ var Table = class _Table {
   getPages(pageSize) {
     const pages = [];
     const totalPages = Math.ceil(this.rows.length / pageSize);
-    for (let i = 1;i <= totalPages; i++) {
-      pages.push(this.paginate(i, pageSize));
+    for (let i2 = 1;i2 <= totalPages; i2++) {
+      pages.push(this.paginate(i2, pageSize));
     }
     return pages;
   }
@@ -8558,8 +6671,8 @@ var Table = class _Table {
     const colIndex = this.columns.findIndex((c) => c.name === columnName || c.key === columnName);
     if (colIndex === -1)
       return this;
-    this.rows.sort((a, b) => {
-      const cellA = a.cells[colIndex];
+    this.rows.sort((a2, b) => {
+      const cellA = a2.cells[colIndex];
       const cellB = b.cells[colIndex];
       const valA = cellA ? cellA.content : "";
       const valB = cellB ? cellB.content : "";
@@ -8633,7 +6746,7 @@ var Table = class _Table {
     if (primaryKey) {
       oldData.forEach((oldObj, oldIdx) => {
         const pkValue = oldObj[primaryKey];
-        const newIdx = newData.findIndex((n) => n[primaryKey] === pkValue);
+        const newIdx = newData.findIndex((n2) => n2[primaryKey] === pkValue);
         if (newIdx !== -1) {
           compareAndAdd(oldObj, newData[newIdx]);
           processedOldIndices.add(oldIdx);
@@ -8654,9 +6767,9 @@ var Table = class _Table {
       });
     } else {
       const maxLength = Math.max(oldData.length, newData.length);
-      for (let i = 0;i < maxLength; i++) {
-        const oldObj = oldData[i];
-        const newObj = newData[i];
+      for (let i2 = 0;i2 < maxLength; i2++) {
+        const oldObj = oldData[i2];
+        const newObj = newData[i2];
         if (oldObj && newObj) {
           compareAndAdd(oldObj, newObj);
         } else if (oldObj && !newObj) {
@@ -8690,13 +6803,13 @@ var Table = class _Table {
     nodes.forEach((node) => processNode(node, 0));
   }
   mergeAdjacent(columns) {
-    const colIndices = columns ? columns.map((name) => this.columns.findIndex((c) => c.name === name || c.key === name)).filter((i) => i >= 0) : this.columns.map((_, i) => i);
+    const colIndices = columns ? columns.map((name) => this.columns.findIndex((c) => c.name === name || c.key === name)).filter((i2) => i2 >= 0) : this.columns.map((_, i2) => i2);
     if (colIndices.length === 0)
       return;
     colIndices.forEach((colIndex) => {
       let lastCell = this.rows[0]?.cells[colIndex];
-      for (let i = 1;i < this.rows.length; i++) {
-        const currentCell = this.rows[i].cells[colIndex];
+      for (let i2 = 1;i2 < this.rows.length; i2++) {
+        const currentCell = this.rows[i2].cells[colIndex];
         if (lastCell && currentCell && lastCell.content === currentCell.content) {
           lastCell.rowSpan = (lastCell.rowSpan || 1) + 1;
           currentCell.merged = true;
@@ -8709,7 +6822,7 @@ var Table = class _Table {
   transpose() {
     const newColumns = [
       { name: "Field", key: "field" },
-      ...this.rows.map((_, i) => ({ name: `Row ${i + 1}`, key: `_row_${i}` }))
+      ...this.rows.map((_, i2) => ({ name: `Row ${i2 + 1}`, key: `_row_${i2}` }))
     ];
     const transposed = new _Table({
       theme: this.theme,
@@ -8836,7 +6949,7 @@ var StringRenderer = class {
     const total = this.calculateTableWidth(widths, this.getVisibleColumns(next), next.theme);
     if (total <= terminalWidth)
       return this.buildVisibleTable(next);
-    const sorted = next.columns.map((column, index) => ({ index, priority: column.priority })).sort((a, b) => b.priority - a.priority);
+    const sorted = next.columns.map((column, index) => ({ index, priority: column.priority })).sort((a2, b) => b.priority - a2.priority);
     for (const col of sorted) {
       next.columns[col.index].hidden = true;
       if (this.getVisibleColumns(next).length === 0)
@@ -8991,11 +7104,11 @@ var StringRenderer = class {
           return;
         let remaining = desired - current;
         let candidates = [];
-        for (let i = 0;i < span; i++) {
-          const column = columns[start + i];
+        for (let i2 = 0;i2 < span; i2++) {
+          const column = columns[start + i2];
           if (!column || column.width !== undefined)
             continue;
-          candidates.push(start + i);
+          candidates.push(start + i2);
         }
         if (candidates.length === 0)
           return;
@@ -9033,19 +7146,19 @@ var StringRenderer = class {
     let padLeft = 1;
     let padRight = 1;
     let internalPadding = 0;
-    for (let i = 0;i < span; i++) {
-      const column = columns[start + i];
+    for (let i2 = 0;i2 < span; i2++) {
+      const column = columns[start + i2];
       const left = column?.paddingLeft ?? 1;
       const right = column?.paddingRight ?? 1;
-      if (i === 0)
+      if (i2 === 0)
         padLeft = left;
       else
         internalPadding += left;
-      if (i === span - 1)
+      if (i2 === span - 1)
         padRight = right;
       else
         internalPadding += right;
-      contentWidth += widths[start + i] || 0;
+      contentWidth += widths[start + i2] || 0;
     }
     return {
       contentWidth: contentWidth + internalPadding + joinWidth * Math.max(0, span - 1),
@@ -9057,8 +7170,8 @@ var StringRenderer = class {
     const visibleCols = widths.length;
     const joinWidth = this.strWidth(theme.bodyJoin);
     const cellLines = [];
-    for (let i = 0;i < visibleCols; i++) {
-      const gridCell = row[i];
+    for (let i2 = 0;i2 < visibleCols; i2++) {
+      const gridCell = row[i2];
       if (!gridCell || gridCell.hidden)
         continue;
       const col = gridCell.x;
@@ -9082,7 +7195,7 @@ var StringRenderer = class {
         contentWidth: metrics.contentWidth,
         color: gridCell.cell.color
       });
-      i += gridCell.realColSpan - 1;
+      i2 += gridCell.realColSpan - 1;
     }
     const rowHeight = Math.max(1, ...cellLines.map((entry) => entry.lines.length));
     const lines = [];
@@ -9200,8 +7313,8 @@ var StringRenderer = class {
   }
   sumWidths(widths, start, span, joinWidth) {
     let sum = 0;
-    for (let i = 0;i < span; i++)
-      sum += widths[start + i] || 0;
+    for (let i2 = 0;i2 < span; i2++)
+      sum += widths[start + i2] || 0;
     return sum + Math.max(0, span - 1) * joinWidth;
   }
   strWidth(value) {
@@ -9292,24 +7405,25 @@ function formatVersion(version) {
   const patch = version & 255;
   return `${major}.${minor}.${patch}`;
 }
-var devicesCommand = createCommand("devices").description("list devices connected to brain").alias("lsdev").action(async () => {
-  const device = await connectV5Device();
-  const smartDevices = device.devices;
-  const table = new Table({ compact: true });
-  table.addColumn("port");
-  table.addColumn("type");
-  table.addColumn("version");
-  smartDevices.forEach((d) => {
-    table.addRow([
-      d.port.toString(),
-      SMART_DEVICE_LABELS[d.type],
-      formatVersion(d.version)
-    ]);
+function registerDevicesCommand(program) {
+  program.command("devices", "list devices connected to brain", { alias: "lsdev" }).action(async () => {
+    const device = await connectV5Device();
+    const smartDevices = device.devices;
+    const table = new Table({ compact: true });
+    table.addColumn("port");
+    table.addColumn("type");
+    table.addColumn("version");
+    smartDevices.forEach((d) => {
+      table.addRow([
+        d.port.toString(),
+        SMART_DEVICE_LABELS[d.type],
+        formatVersion(d.version)
+      ]);
+    });
+    console.log(table.render());
+    await device.dispose();
   });
-  console.log(table.render());
-  await device.dispose();
-});
-var devices_default = devicesCommand;
+}
 
 // src/commands/dir.ts
 var VENDORS = [
@@ -9370,38 +7484,39 @@ function formatSize(bytes) {
   }
   return `${size.toFixed(size < 10 && unit > 0 ? 1 : 0)} ${units[unit]}`;
 }
-var dirCommand = createCommand("dir").description("list files on flash").alias("ls").action(async () => {
-  const device = await connectV5Device();
-  const files = [];
-  for (const vendor of VENDORS) {
-    const vendorFiles = await device.brain.listFiles(vendor) ?? [];
-    files.push(...vendorFiles.map((file) => ({
-      ...file,
-      vendor
-    })));
-  }
-  const table = new Table({
-    compact: true
-  });
-  table.addColumn("name");
-  table.addColumn("size");
-  table.addColumn("load address");
-  table.addColumn("timestamp");
-  table.addColumn("crc32");
-  files.forEach(({ vendor, filename, size, loadAddress, timestamp, crc32 }) => {
-    const date = new Date(timestamp * 1000);
-    table.addRow([
-      vendorPrefix(vendor) + filename,
-      formatSize(size),
-      `0x${loadAddress.toString(16)}`,
-      formatDate(date),
-      `0x${crc32.toString(16)}`
-    ]);
+function registerDirCommand(program) {
+  program.command("dir", "list files on flash", { alias: "ls" }).action(async () => {
+    const device = await connectV5Device();
+    const files = [];
+    for (const vendor of VENDORS) {
+      const vendorFiles = await device.brain.listFiles(vendor) ?? [];
+      files.push(...vendorFiles.map((file) => ({
+        ...file,
+        vendor
+      })));
+    }
+    const table = new Table({
+      compact: true
+    });
+    table.addColumn("name");
+    table.addColumn("size");
+    table.addColumn("load address");
+    table.addColumn("timestamp");
+    table.addColumn("crc32");
+    files.forEach(({ vendor, filename, size, loadAddress, timestamp, crc32 }) => {
+      const date = new Date(timestamp * 1000);
+      table.addRow([
+        vendorPrefix(vendor) + filename,
+        formatSize(size),
+        `0x${loadAddress.toString(16)}`,
+        formatDate(date),
+        `0x${crc32.toString(16)}`
+      ]);
+    });
+    console.log(table.render());
+    await device.dispose();
   });
-  console.log(table.render());
-  await device.dispose();
-});
-var dir_default = dirCommand;
+}
 
 // src/utils/upload.ts
 async function uploadProgram(options) {
@@ -9443,34 +7558,42 @@ async function uploadProgram(options) {
 }
 
 // src/commands/upload.ts
-var uploadCommand = createCommand("upload").description("build and upload a program to the V5 brain").alias("u").argument("[path]", "path to the program", process.cwd()).option("-s, --slot <slot>", "program slot", "1").option("-n, --name <name>", "program name shown on the brain").option("-d, --description <description>", "program description").option("-i, --icon <icon>", "program icon file", "default.bmp").option("-f, --file <path>", "upload an existing .bin artifact").option("--no-build", "skip building the project").option("--run", "start the program after uploading").action(async (path, options) => {
-  await uploadProgram({
-    path,
-    slot: Number(options.slot),
-    name: options.name,
-    description: options.description,
-    icon: options.icon,
-    artifact: options.file,
-    build: options.build,
-    run: options.run ?? false
+function registerUploadCommand(program) {
+  program.command("upload [path]", "build and upload a program to the V5 brain", {
+    alias: "u"
+  }).option("-s, --slot", "program slot", "1").option("-n, --name", "program name shown on the brain").option("-d, --description", "program description").option("-i, --icon", "program icon file", "default.bmp").option("-f, --file", "upload an existing .bin artifact").option("--no-build", "skip building the project").option("--run", "start the program after uploading").action(async (path, options) => {
+    path ??= process.cwd();
+    await uploadProgram({
+      path,
+      slot: Number(options.slot),
+      name: options.name,
+      description: options.description,
+      icon: options.icon,
+      artifact: options.file,
+      build: options.build ?? true,
+      run: options.run ?? false
+    });
   });
-});
-var upload_default = uploadCommand;
+}
 
 // src/commands/run.ts
-var runCommand = createCommand("run").description("build, upload, and run a program on a V5 brain").alias("r").argument("[path]", "path to the program", process.cwd()).option("-s, --slot <slot>", "program slot", "1").option("-n, --name <name>", "program name shown on the brain").option("-d, --description <description>", "program description").option("-i, --icon <icon>", "program icon file", "default.bmp").option("-f, --file <path>", "upload an existing .bin artifact").option("--no-build", "skip building the project").action(async (path, options) => {
-  await uploadProgram({
-    path,
-    slot: Number(options.slot),
-    name: options.name,
-    description: options.description,
-    icon: options.icon,
-    artifact: options.file,
-    build: options.build,
-    run: true
+function registerRunCommand(program) {
+  program.command("run [path]", "build, upload, and run a program on a V5 brain", {
+    alias: "r"
+  }).option("-s, --slot", "program slot", "1").option("-n, --name", "program name shown on the brain").option("-d, --description", "program description").option("-i, --icon", "program icon file", "default.bmp").option("-f, --file", "upload an existing .bin artifact").option("--no-build", "skip building the project").action(async (path, options) => {
+    path ??= process.cwd();
+    await uploadProgram({
+      path,
+      slot: Number(options.slot),
+      name: options.name,
+      description: options.description,
+      icon: options.icon,
+      artifact: options.file,
+      build: options.build ?? true,
+      run: true
+    });
   });
-});
-var run_default = runCommand;
+}
 
 // src/commands/new.ts
 import { join as join6 } from "path";
@@ -9496,16 +7619,16 @@ var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9
 var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
 var freb = function(eb, start) {
   var b = new u16(31);
-  for (var i = 0;i < 31; ++i) {
-    b[i] = start += 1 << eb[i - 1];
+  for (var i2 = 0;i2 < 31; ++i2) {
+    b[i2] = start += 1 << eb[i2 - 1];
   }
-  var r = new i32(b[30]);
-  for (var i = 1;i < 30; ++i) {
-    for (var j = b[i];j < b[i + 1]; ++j) {
-      r[j] = j - b[i] << 5 | i;
+  var r2 = new i32(b[30]);
+  for (var i2 = 1;i2 < 30; ++i2) {
+    for (var j = b[i2];j < b[i2 + 1]; ++j) {
+      r2[j] = j - b[i2] << 5 | i2;
     }
   }
-  return { b, r };
+  return { b, r: r2 };
 };
 var _a = freb(fleb, 2);
 var fl = _a.b;
@@ -9515,94 +7638,94 @@ var _b = freb(fdeb, 0);
 var fd = _b.b;
 var revfd = _b.r;
 var rev = new u16(32768);
-for (i = 0;i < 32768; ++i) {
-  x = (i & 43690) >> 1 | (i & 21845) << 1;
+for (i2 = 0;i2 < 32768; ++i2) {
+  x = (i2 & 43690) >> 1 | (i2 & 21845) << 1;
   x = (x & 52428) >> 2 | (x & 13107) << 2;
   x = (x & 61680) >> 4 | (x & 3855) << 4;
-  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+  rev[i2] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
 }
 var x;
-var i;
-var hMap = function(cd, mb, r) {
-  var s = cd.length;
-  var i2 = 0;
-  var l = new u16(mb);
-  for (;i2 < s; ++i2) {
-    if (cd[i2])
-      ++l[cd[i2] - 1];
+var i2;
+var hMap = function(cd, mb, r2) {
+  var s2 = cd.length;
+  var i3 = 0;
+  var l2 = new u16(mb);
+  for (;i3 < s2; ++i3) {
+    if (cd[i3])
+      ++l2[cd[i3] - 1];
   }
   var le = new u16(mb);
-  for (i2 = 1;i2 < mb; ++i2) {
-    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  for (i3 = 1;i3 < mb; ++i3) {
+    le[i3] = le[i3 - 1] + l2[i3 - 1] << 1;
   }
   var co;
-  if (r) {
+  if (r2) {
     co = new u16(1 << mb);
     var rvb = 15 - mb;
-    for (i2 = 0;i2 < s; ++i2) {
-      if (cd[i2]) {
-        var sv = i2 << 4 | cd[i2];
-        var r_1 = mb - cd[i2];
-        var v = le[cd[i2] - 1]++ << r_1;
+    for (i3 = 0;i3 < s2; ++i3) {
+      if (cd[i3]) {
+        var sv = i3 << 4 | cd[i3];
+        var r_1 = mb - cd[i3];
+        var v = le[cd[i3] - 1]++ << r_1;
         for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
           co[rev[v] >> rvb] = sv;
         }
       }
     }
   } else {
-    co = new u16(s);
-    for (i2 = 0;i2 < s; ++i2) {
-      if (cd[i2]) {
-        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+    co = new u16(s2);
+    for (i3 = 0;i3 < s2; ++i3) {
+      if (cd[i3]) {
+        co[i3] = rev[le[cd[i3] - 1]++] >> 15 - cd[i3];
       }
     }
   }
   return co;
 };
 var flt = new u8(288);
-for (i = 0;i < 144; ++i)
-  flt[i] = 8;
-var i;
-for (i = 144;i < 256; ++i)
-  flt[i] = 9;
-var i;
-for (i = 256;i < 280; ++i)
-  flt[i] = 7;
-var i;
-for (i = 280;i < 288; ++i)
-  flt[i] = 8;
-var i;
+for (i2 = 0;i2 < 144; ++i2)
+  flt[i2] = 8;
+var i2;
+for (i2 = 144;i2 < 256; ++i2)
+  flt[i2] = 9;
+var i2;
+for (i2 = 256;i2 < 280; ++i2)
+  flt[i2] = 7;
+var i2;
+for (i2 = 280;i2 < 288; ++i2)
+  flt[i2] = 8;
+var i2;
 var fdt = new u8(32);
-for (i = 0;i < 32; ++i)
-  fdt[i] = 5;
-var i;
+for (i2 = 0;i2 < 32; ++i2)
+  fdt[i2] = 5;
+var i2;
 var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
 var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
-var max = function(a) {
-  var m = a[0];
-  for (var i2 = 1;i2 < a.length; ++i2) {
-    if (a[i2] > m)
-      m = a[i2];
+var max = function(a2) {
+  var m = a2[0];
+  for (var i3 = 1;i3 < a2.length; ++i3) {
+    if (a2[i3] > m)
+      m = a2[i3];
   }
   return m;
 };
 var bits = function(d, p, m) {
-  var o = p / 8 | 0;
-  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+  var o2 = p / 8 | 0;
+  return (d[o2] | d[o2 + 1] << 8) >> (p & 7) & m;
 };
 var bits16 = function(d, p) {
-  var o = p / 8 | 0;
-  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+  var o2 = p / 8 | 0;
+  return (d[o2] | d[o2 + 1] << 8 | d[o2 + 2] << 16) >> (p & 7);
 };
 var shft = function(p) {
   return (p + 7) / 8 | 0;
 };
-var slc = function(v, s, e) {
-  if (s == null || s < 0)
-    s = 0;
+var slc = function(v, s2, e) {
+  if (s2 == null || s2 < 0)
+    s2 = 0;
   if (e == null || e > v.length)
     e = v.length;
-  return new u8(v.subarray(s, e));
+  return new u8(v.subarray(s2, e));
 };
 var ec = [
   "unexpected EOF",
@@ -9638,10 +7761,10 @@ var inflt = function(dat, st, buf, dict) {
   var noSt = st.i;
   if (noBuf)
     buf = new u8(sl * 3);
-  var cbuf = function(l2) {
+  var cbuf = function(l3) {
     var bl = buf.length;
-    if (l2 > bl) {
-      var nbuf = new u8(Math.max(bl * 2, l2));
+    if (l3 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l3));
       nbuf.set(buf);
       buf = nbuf;
     }
@@ -9654,16 +7777,16 @@ var inflt = function(dat, st, buf, dict) {
       var type = bits(dat, pos + 1, 3);
       pos += 3;
       if (!type) {
-        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
-        if (t > sl) {
+        var s2 = shft(pos) + 4, l2 = dat[s2 - 4] | dat[s2 - 3] << 8, t2 = s2 + l2;
+        if (t2 > sl) {
           if (noSt)
             err(0);
           break;
         }
         if (resize)
-          cbuf(bt + l);
-        buf.set(dat.subarray(s, t), bt);
-        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+          cbuf(bt + l2);
+        buf.set(dat.subarray(s2, t2), bt);
+        st.b = bt += l2, st.p = pos = t2 * 8, st.f = final;
         continue;
       } else if (type == 1)
         lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
@@ -9673,28 +7796,28 @@ var inflt = function(dat, st, buf, dict) {
         pos += 14;
         var ldt = new u8(tl);
         var clt = new u8(19);
-        for (var i2 = 0;i2 < hcLen; ++i2) {
-          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        for (var i3 = 0;i3 < hcLen; ++i3) {
+          clt[clim[i3]] = bits(dat, pos + i3 * 3, 7);
         }
         pos += hcLen * 3;
         var clb = max(clt), clbmsk = (1 << clb) - 1;
         var clm = hMap(clt, clb, 1);
-        for (var i2 = 0;i2 < tl; ) {
-          var r = clm[bits(dat, pos, clbmsk)];
-          pos += r & 15;
-          var s = r >> 4;
-          if (s < 16) {
-            ldt[i2++] = s;
+        for (var i3 = 0;i3 < tl; ) {
+          var r2 = clm[bits(dat, pos, clbmsk)];
+          pos += r2 & 15;
+          var s2 = r2 >> 4;
+          if (s2 < 16) {
+            ldt[i3++] = s2;
           } else {
-            var c = 0, n = 0;
-            if (s == 16)
-              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
-            else if (s == 17)
-              n = 3 + bits(dat, pos, 7), pos += 3;
-            else if (s == 18)
-              n = 11 + bits(dat, pos, 127), pos += 7;
-            while (n--)
-              ldt[i2++] = c;
+            var c = 0, n2 = 0;
+            if (s2 == 16)
+              n2 = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i3 - 1];
+            else if (s2 == 17)
+              n2 = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s2 == 18)
+              n2 = 11 + bits(dat, pos, 127), pos += 7;
+            while (n2--)
+              ldt[i3++] = c;
           }
         }
         var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
@@ -9732,8 +7855,8 @@ var inflt = function(dat, st, buf, dict) {
       } else {
         var add = sym - 254;
         if (sym > 264) {
-          var i2 = sym - 257, b = fleb[i2];
-          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          var i3 = sym - 257, b = fleb[i3];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i3];
           pos += b;
         }
         var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
@@ -9790,34 +7913,34 @@ try {
   tds = 1;
 } catch (e) {}
 var dutf8 = function(d) {
-  for (var r = "", i2 = 0;; ) {
-    var c = d[i2++];
+  for (var r2 = "", i3 = 0;; ) {
+    var c = d[i3++];
     var eb = (c > 127) + (c > 223) + (c > 239);
-    if (i2 + eb > d.length)
-      return { s: r, r: slc(d, i2 - 1) };
+    if (i3 + eb > d.length)
+      return { s: r2, r: slc(d, i3 - 1) };
     if (!eb)
-      r += String.fromCharCode(c);
+      r2 += String.fromCharCode(c);
     else if (eb == 3) {
-      c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+      c = ((c & 15) << 18 | (d[i3++] & 63) << 12 | (d[i3++] & 63) << 6 | d[i3++] & 63) - 65536, r2 += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
     } else if (eb & 1)
-      r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+      r2 += String.fromCharCode((c & 31) << 6 | d[i3++] & 63);
     else
-      r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+      r2 += String.fromCharCode((c & 15) << 12 | (d[i3++] & 63) << 6 | d[i3++] & 63);
   }
 };
 function strFromU8(dat, latin1) {
   if (latin1) {
-    var r = "";
-    for (var i2 = 0;i2 < dat.length; i2 += 16384)
-      r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
-    return r;
+    var r2 = "";
+    for (var i3 = 0;i3 < dat.length; i3 += 16384)
+      r2 += String.fromCharCode.apply(null, dat.subarray(i3, i3 + 16384));
+    return r2;
   } else if (td) {
     return td.decode(dat);
   } else {
-    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
-    if (r.length)
+    var _a2 = dutf8(dat), s2 = _a2.s, r2 = _a2.r;
+    if (r2.length)
       err(8);
-    return s;
+    return s2;
   }
 }
 var slzh = function(d, b) {
@@ -9828,8 +7951,8 @@ var zh = function(d, b, z) {
   var _a2 = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
   return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
 };
-var z64hs = function(d, b, l, z, sc, su, off) {
-  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+var z64hs = function(d, b, l2, z, sc, su, off) {
+  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l2;
   var nf = nsc + nsu + noff;
   if (z && nf) {
     for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
@@ -9857,20 +7980,20 @@ function unzipSync(data, opts) {
   var c = b2(data, e + 8);
   if (!c)
     return {};
-  var o = b4(data, e + 16);
+  var o2 = b4(data, e + 16);
   var z = b4(data, e - 20) == 117853008;
   if (z) {
     var ze = b4(data, e - 12);
     z = b4(data, ze) == 101075792;
     if (z) {
       c = b4(data, ze + 32);
-      o = b4(data, ze + 48);
+      o2 = b4(data, ze + 48);
     }
   }
   var fltr = opts && opts.filter;
-  for (var i2 = 0;i2 < c; ++i2) {
-    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
-    o = no;
+  for (var i3 = 0;i3 < c; ++i3) {
+    var _a2 = zh(data, o2, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o2 = no;
     if (!fltr || fltr({
       name: fn,
       size: sc,
@@ -10042,32 +8165,42 @@ async function createProject(inputPath, toolchain, name = basename2(resolve2(inp
 }
 
 // src/commands/new.ts
-var newCommand = createCommand("new").description("create a new V5 program").alias("n").argument("<name>", "project name").addOption(new Option("-t, --type <type>", "project toolchain").choices(["pros", "vexide"]).makeOptionMandatory()).action(async (name, options) => {
-  const path = await createProject(join6(process.cwd(), name), options.type, name);
-  console.log(`created ${options.type} project at ${path}`);
-});
-var new_default = newCommand;
+function registerNewCommand(program) {
+  program.command("new <name>", "create a new V5 program", { alias: "n" }).option("-t, --type", "project toolchain").action(async (name, options) => {
+    if (options.type !== "pros" && options.type !== "vexide") {
+      throw new Error("--type must be either pros or vexide");
+    }
+    const path = await createProject(join6(process.cwd(), name), options.type, name);
+    console.log(`created ${options.type} project at ${path}`);
+  });
+}
 
 // src/commands/init.ts
 import { basename as basename3, resolve as resolve3 } from "path";
-var initCommand = createCommand("init").description("create a new V5 program in an empty directory").argument("[path]", "project directory", process.cwd()).addOption(new Option("-t, --type <type>", "project toolchain").choices(["pros", "vexide"]).makeOptionMandatory()).action(async (inputPath, options) => {
-  const path = resolve3(inputPath);
-  await createProject(path, options.type, basename3(path));
-  console.log(`created ${options.type} project at ${path}`);
-});
-var init_default = initCommand;
+function registerInitCommand(program) {
+  program.command("init [path]", "create a new V5 program in an empty directory").option("-t, --type", "project toolchain").action(async (inputPath, options) => {
+    inputPath ??= process.cwd();
+    if (options.type !== "pros" && options.type !== "vexide") {
+      throw new Error("--type must be either pros or vexide");
+    }
+    const path = resolve3(inputPath);
+    await createProject(path, options.type, basename3(path));
+    console.log(`created ${options.type} project at ${path}`);
+  });
+}
 
 // src/commands/rm.ts
-var rmCommand = createCommand("rm").description("erase a file from flash").argument("<file>").action(async (file) => {
-  const device = await connectV5Device();
-  const ok = await device.brain.removeFile(file);
-  if (ok)
-    console.log(`erased ${file}`);
-  else
-    console.log(`failed to erase ${file}`);
-  await device.dispose();
-});
-var rm_default = rmCommand;
+function registerRmCommand(program) {
+  program.command("rm <file>", "erase a file from flash").action(async (file) => {
+    const device = await connectV5Device();
+    const ok = await device.brain.removeFile(file);
+    if (ok)
+      console.log(`erased ${file}`);
+    else
+      console.log(`failed to erase ${file}`);
+    await device.dispose();
+  });
+}
 
 // src/commands/screenshot.ts
 function printKittyRGB(bytes) {
@@ -10080,45 +8213,62 @@ function printKittyRGB(bytes) {
   process.stdout.write(`\x1B_G` + `a=T,` + `f=24,` + `s=${WIDTH},` + `v=${HEIGHT},` + `c=40;` + base64 + `\x1B\\
 `);
 }
-var screenshotCommand = createCommand("screenshot").description("take a screen capture of the brain").alias("sc").action(async () => {
-  const device = await connectV5Device();
-  const data = await device.brain.captureScreen();
-  if (data)
-    printKittyRGB(data);
-  await device.dispose();
-});
-var screenshot_default = screenshotCommand;
+function registerScreenshotCommand(program) {
+  program.command("screenshot", "take a screen capture of the brain", {
+    alias: "sc"
+  }).action(async () => {
+    const device = await connectV5Device();
+    const data = await device.brain.captureScreen();
+    if (data)
+      printKittyRGB(data);
+    await device.dispose();
+  });
+}
 
 // src/commands/install.ts
-var installCommand = createCommand("install").description("install a V5 development toolchain").argument("<toolchain>", "toolchain to install", (value) => {
-  if (value !== "pros" && value !== "vexide") {
-    throw new Error("toolchain must be either pros or vexide");
-  }
-  return value;
-}).action(async (toolchain) => {
-  if (toolchain === "vexide") {
-    await runProcess(["cargo", "install", "cargo-v5"], process.cwd());
-    return;
-  }
-  const python = Bun.which("python3") ?? Bun.which("python");
-  if (python === null)
-    throw new Error("Python is required to install PROS");
-  await runProcess([python, "-m", "pip", "install", "--user", "pros-cli"], process.cwd());
-});
-var install_default = installCommand;
+function registerInstallCommand(program) {
+  program.command("install <toolchain>", "install a V5 development toolchain").action(async (toolchain) => {
+    if (toolchain !== "pros" && toolchain !== "vexide") {
+      throw new Error("toolchain must be either pros or vexide");
+    }
+    if (toolchain === "vexide") {
+      await runProcess(["cargo", "install", "cargo-v5"], process.cwd());
+      return;
+    }
+    const python = Bun.which("python3") ?? Bun.which("python");
+    if (python === null)
+      throw new Error("Python is required to install PROS");
+    await runProcess([python, "-m", "pip", "install", "--user", "pros-cli"], process.cwd());
+  });
+}
 
 // src/commands/clean.ts
-var cleanCommand = createCommand("clean").description("clean build outputs").alias("cl").argument("[path]", "path to the program", process.cwd()).action(async (path) => {
-  const project = await inspectProject(path);
-  console.log(source_default.yellow(`cleaning ${project.type} program...`));
-  await cleanProject(project);
-});
-var clean_default = cleanCommand;
+function registerCleanCommand(program) {
+  program.command("clean [path]", "clean build outputs", { alias: "cl" }).action(async (path) => {
+    path ??= process.cwd();
+    const project = await inspectProject(path);
+    console.log(source_default.yellow(`cleaning ${project.type} program...`));
+    await cleanProject(project);
+  });
+}
 
 // src/index.ts
-program.name("v5x").version(package_default.version).description(package_default.description).addCommand(build_default).addCommand(clean_default).addCommand(upload_default).addCommand(run_default).addCommand(new_default).addCommand(init_default).addCommand(dir_default).addCommand(cat_default).addCommand(rm_default).addCommand(devices_default).addCommand(screenshot_default).addCommand(install_default).addCommand(kv_default);
+var program = lib_default2("v5x").version(package_default.version).describe(package_default.description);
+registerBuildCommand(program);
+registerCleanCommand(program);
+registerUploadCommand(program);
+registerRunCommand(program);
+registerNewCommand(program);
+registerInitCommand(program);
+registerDirCommand(program);
+registerCatCommand(program);
+registerRmCommand(program);
+registerDevicesCommand(program);
+registerScreenshotCommand(program);
+registerInstallCommand(program);
+registerKvCommand(program);
 try {
-  await program.parseAsync();
+  await program.parse(process.argv);
 } catch (error) {
   console.error(error instanceof Error ? error.message : String(error));
   process.exitCode = 1;