@couch-kit/cli 0.3.8 → 0.3.9

package/dist/index.js

@@ -1,37 +1,24 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  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: () => mod[key],
-        enumerable: true
-      });
-  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: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// ../../node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/error.js
+var CommanderError, InvalidArgumentError;
+var init_error = __esm(() => {
+  CommanderError = class CommanderError extends Error {
     constructor(exitCode, code, message) {
       super(message);
       Error.captureStackTrace(this, this.constructor);
@@ -40,592 +27,753 @@ var require_error = __commonJS((exports) => {
       this.exitCode = exitCode;
       this.nestedError = undefined;
     }
-  }
-
-  class InvalidArgumentError extends CommanderError {
+  };
+  InvalidArgumentError = 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/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.length > 3 && this._name.slice(-3) === "...") {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/argument.js
+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;
+  }
+  name() {
+    return this._name;
+  }
+  _collectValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
     }
-    _concatValue(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(", ")}.`);
       }
-      return previous.concat(value);
-    }
-    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._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    argRequired() {
-      this.required = true;
-      return this;
-    }
-    argOptional() {
-      this.required = false;
-      return this;
-    }
+      if (this.variadic) {
+        return this._collectValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
   }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+  argRequired() {
+    this.required = true;
+    return this;
   }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
+  argOptional() {
+    this.required = false;
+    return this;
+  }
+}
+function humanReadableArgName(arg) {
+  const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
+  return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+}
+var init_argument = __esm(() => {
+  init_error();
 });
 
-// ../../node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/help.js
+import { stripVTControlCharacters } from "node:util";
 
-  class Help {
-    constructor() {
-      this.helpWidth = undefined;
-      this.sortSubcommands = false;
-      this.sortOptions = false;
-      this.showGlobalOptions = false;
-    }
-    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;
+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());
+      });
     }
-    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;
+    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);
     }
-    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;
+    if (this.sortOptions) {
+      globalOptions.sort(this.compareOptions);
     }
-    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 [];
+    return globalOptions;
+  }
+  visibleArguments(cmd) {
+    if (cmd._argsDescription) {
+      cmd.registeredArguments.forEach((argument) => {
+        argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+      });
     }
-    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 : "");
+    if (cmd.registeredArguments.find((argument) => argument.description)) {
+      return cmd.registeredArguments;
     }
-    optionTerm(option) {
-      return option.flags;
+    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];
     }
-    argumentTerm(argument) {
-      return argument.name();
+    let ancestorCmdNames = "";
+    for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+      ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
     }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, helper.subcommandTerm(command).length);
-      }, 0);
+    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(", ")}`);
     }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
-      }, 0);
+    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)}`);
+      }
     }
-    longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
-      }, 0);
+    if (option.presetArg !== undefined && option.optional) {
+      extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
     }
-    longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, helper.argumentTerm(argument).length);
-      }, 0);
+    if (option.envVar !== undefined) {
+      extraInfo.push(`env: ${option.envVar}`);
     }
-    commandUsage(cmd) {
-      let cmdName = cmd._name;
-      if (cmd._aliases[0]) {
-        cmdName = cmdName + "|" + cmd._aliases[0];
+    if (extraInfo.length > 0) {
+      const extraDescription = `(${extraInfo.join(", ")})`;
+      if (option.description) {
+        return `${option.description} ${extraDescription}`;
       }
-      let ancestorCmdNames = "";
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
-      }
-      return ancestorCmdNames + cmdName + " " + cmd.usage();
+      return extraDescription;
     }
-    commandDescription(cmd) {
-      return cmd.description();
+    return option.description;
+  }
+  argumentDescription(argument) {
+    const extraInfo = [];
+    if (argument.argChoices) {
+      extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
     }
-    subcommandDescription(cmd) {
-      return cmd.summary() || cmd.description();
+    if (argument.defaultValue !== undefined) {
+      extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
     }
-    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 (extraInfo.length > 0) {
+      const extraDescription = `(${extraInfo.join(", ")})`;
+      if (argument.description) {
+        return `${argument.description} ${extraDescription}`;
       }
-      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) {
-        return `${option.description} (${extraInfo.join(", ")})`;
-      }
-      return option.description;
+      return extraDescription;
     }
-    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)}`);
+    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, []);
       }
-      if (extraInfo.length > 0) {
-        const extraDescripton = `(${extraInfo.join(", ")})`;
-        if (argument.description) {
-          return `${argument.description} ${extraDescripton}`;
-        }
-        return extraDescripton;
-      }
-      return argument.description;
-    }
-    formatHelp(cmd, helper) {
-      const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth || 80;
-      const itemIndentWidth = 2;
-      const itemSeparatorWidth = 2;
-      function formatItem(term, description) {
-        if (description) {
-          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-        }
-        return term;
-      }
-      function formatList(textArray) {
-        return textArray.join(`
-`).replace(/^/gm, " ".repeat(itemIndentWidth));
-      }
-      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
-      const commandDescription = helper.commandDescription(cmd);
-      if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.wrap(commandDescription, helpWidth, 0),
-          ""
-        ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+      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)));
       });
-      if (argumentList.length > 0) {
-        output = output.concat(["Arguments:", formatList(argumentList), ""]);
-      }
-      const optionList = helper.visibleOptions(cmd).map((option) => {
-        return formatItem(helper.optionTerm(option), 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)));
       });
-      if (optionList.length > 0) {
-        output = output.concat(["Options:", formatList(optionList), ""]);
-      }
-      if (this.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
-        });
-        if (globalOptionList.length > 0) {
-          output = output.concat([
-            "Global Options:",
-            formatList(globalOptionList),
-            ""
-          ]);
-        }
-      }
-      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
+      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)));
       });
-      if (commandList.length > 0) {
-        output = output.concat(["Commands:", formatList(commandList), ""]);
-      }
-      return output.join(`
+      output = output.concat(this.formatItemList(group, commandList, helper));
+    });
+    return output.join(`
 `);
+  }
+  displayWidth(str) {
+    return stripVTControlCharacters(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));
     }
-    padWidth(cmd, helper) {
-      return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
-    }
-    wrap(str, width, indent, minColumnWidth = 40) {
-      const indents = " \\f\\t\\v   -   　\uFEFF";
-      const manualIndent = new RegExp(`[\\n][${indents}]+`);
-      if (str.match(manualIndent))
-        return str;
-      const columnWidth = width - indent;
-      if (columnWidth < minColumnWidth)
-        return str;
-      const leadingStr = str.slice(0, indent);
-      const columnText = str.slice(indent).replace(`\r
-`, `
-`);
-      const indentString = " ".repeat(indent);
-      const zeroWidthSpace = "​";
-      const breaks = `\\s${zeroWidthSpace}`;
-      const regex = new RegExp(`
-|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
-      const lines = columnText.match(regex) || [];
-      return leadingStr + lines.map((line, i) => {
-        if (line === `
-`)
-          return "";
-        return (i > 0 ? indentString : "") + line.trimEnd();
-      }).join(`
+    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(`
 `);
-    }
   }
-  exports.Help = Help;
+}
+var init_help = __esm(() => {
+  init_argument();
 });
 
-// ../../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;
-    }
-    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;
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/option.js
+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 };
     }
-    hideHelp(hide = true) {
-      this.hidden = !!hide;
-      return this;
+    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];
     }
-    _concatValue(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(", ")}.`);
       }
-      return previous.concat(value);
-    }
-    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._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    name() {
-      if (this.long) {
-        return this.long.replace(/^--/, "");
+      if (this.variadic) {
+        return this._collectValue(arg, previous);
       }
-      return this.short.replace(/^-/, "");
+      return arg;
+    };
+    return this;
+  }
+  name() {
+    if (this.long) {
+      return this.long.replace(/^--/, "");
     }
-    attributeName() {
+    return this.short.replace(/^-/, "");
+  }
+  attributeName() {
+    if (this.negate) {
       return camelcase(this.name().replace(/^no-/, ""));
     }
-    is(arg) {
-      return this.short === arg || this.long === arg;
-    }
-    isBoolean() {
-      return !this.required && !this.optional && !this.negate;
-    }
+    return camelcase(this.name());
   }
-
-  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);
-    }
+  helpGroup(heading) {
+    this.helpGroupHeading = heading;
+    return this;
   }
-  function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
+  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);
+      }
     });
   }
-  function splitOptionFlags(flags) {
-    let shortFlag;
-    let longFlag;
-    const flagParts = flags.split(/[ |,]+/);
-    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
-      shortFlag = flagParts.shift();
+  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 && /^-[^-]$/.test(longFlag)) {
-      shortFlag = longFlag;
-      longFlag = undefined;
-    }
-    return { shortFlag, longFlag };
+  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`);
   }
-  exports.Option = Option;
-  exports.DualOptions = DualOptions;
+  if (shortFlag === undefined && longFlag === undefined)
+    throw new Error(`option creation failed due to no flags found in '${flags}'.`);
+  return { shortFlag, longFlag };
+}
+var init_option = __esm(() => {
+  init_error();
 });
 
-// ../../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);
-        }
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/suggestSimilar.js
+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;
+      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);
-        }
+  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 `
+  });
+  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 `
+  }
+  if (similar.length === 1) {
+    return `
 (Did you mean ${similar[0]}?)`;
-    }
-    return "";
   }
-  exports.suggestSimilar = suggestSimilar;
-});
-
-// ../../node_modules/commander/lib/command.js
-var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("node:events").EventEmitter;
-  var childProcess = __require("node:child_process");
-  var path = __require("node:path");
-  var fs = __require("node:fs");
-  var process2 = __require("node:process");
-  var { Argument, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
+  return "";
+}
+var maxDistance = 3;
 
-  class Command extends EventEmitter {
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/command.js
+import { EventEmitter } from "node:events";
+import childProcess from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import process2 from "node:process";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+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;
+  });
+}
+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;
+}
+var Command;
+var init_command = __esm(() => {
+  init_argument();
+  init_error();
+  init_help();
+  init_option();
+  Command = class Command extends EventEmitter {
     constructor(name) {
       super();
       this.commands = [];
       this.options = [];
       this.parent = null;
       this._allowUnknownOption = false;
-      this._allowExcessArguments = true;
+      this._allowExcessArguments = false;
       this.registeredArguments = [];
       this._args = this.registeredArguments;
       this.args = [];
@@ -652,18 +800,25 @@ var require_command = __commonJS((exports) => {
       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,
-        outputError: (str, write) => write(str)
+        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
+        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
+        stripColor: (str) => stripVTControlCharacters2(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;
@@ -728,7 +883,10 @@ var require_command = __commonJS((exports) => {
     configureOutput(configuration) {
       if (configuration === undefined)
         return this._outputConfiguration;
-      Object.assign(this._outputConfiguration, configuration);
+      this._outputConfiguration = {
+        ...this._outputConfiguration,
+        ...configuration
+      };
       return this;
     }
     showHelpAfterError(displayHelp = true) {
@@ -759,12 +917,12 @@ var require_command = __commonJS((exports) => {
     createArgument(name, description) {
       return new Argument(name, description);
     }
-    argument(name, description, fn, defaultValue) {
+    argument(name, description, parseArg, defaultValue) {
       const argument = this.createArgument(name, description);
-      if (typeof fn === "function") {
-        argument.default(defaultValue).argParser(fn);
+      if (typeof parseArg === "function") {
+        argument.default(defaultValue).argParser(parseArg);
       } else {
-        argument.default(fn);
+        argument.default(parseArg);
       }
       this.addArgument(argument);
       return this;
@@ -777,7 +935,7 @@ var require_command = __commonJS((exports) => {
     }
     addArgument(argument) {
       const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument && previousArgument.variadic) {
+      if (previousArgument?.variadic) {
         throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
       }
       if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
@@ -789,10 +947,13 @@ var require_command = __commonJS((exports) => {
     helpCommand(enableOrNameAndArgs, description) {
       if (typeof enableOrNameAndArgs === "boolean") {
         this._addImplicitHelpCommand = enableOrNameAndArgs;
+        if (enableOrNameAndArgs && this._defaultCommandGroup) {
+          this._initCommandGroup(this._getHelpCommand());
+        }
         return this;
       }
-      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+      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);
@@ -802,6 +963,8 @@ var require_command = __commonJS((exports) => {
         helpCommand.description(helpDescription);
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
+      if (enableOrNameAndArgs || description)
+        this._initCommandGroup(helpCommand);
       return this;
     }
     addHelpCommand(helpCommand, deprecatedDescription) {
@@ -811,6 +974,7 @@ var require_command = __commonJS((exports) => {
       }
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
+      this._initCommandGroup(helpCommand);
       return this;
     }
     _getHelpCommand() {
@@ -843,7 +1007,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -890,6 +1054,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         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) {
@@ -902,18 +1067,14 @@ Expecting one of '${allowedValues.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) {
+      if (option.defaultValue !== undefined) {
         this.setOptionValueWithSource(name, option.defaultValue, "default");
       }
       const handleOptionValue = (val, invalidValueMessage, valueSource) => {
@@ -924,7 +1085,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (val !== null && option.parseArg) {
           val = this._callParseArg(option, val, oldValue, invalidValueMessage);
         } else if (val !== null && option.variadic) {
-          val = option._concatValue(val, oldValue);
+          val = option._collectValue(val, oldValue);
         }
         if (val == null) {
           if (option.negate) {
@@ -1089,18 +1250,61 @@ Expecting one of '${allowedValues.join("', '")}'`);
       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.options.filter((option) => option.negate && option.defaultValue === undefined && this.getOptionValue(option.attributeName()) === undefined).forEach((option) => {
+          const positiveLongFlag = option.long.replace(/^--no-/, "--");
+          if (!this._findOption(positiveLongFlag)) {
+            this.setOptionValueWithSource(option.attributeName(), true, "default");
+          }
+        });
+        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);
@@ -1121,7 +1325,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let resolvedScriptPath;
         try {
           resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch (err) {
+        } catch {
           resolvedScriptPath = this._scriptPath;
         }
         executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
@@ -1136,7 +1340,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         executableFile = localFile || executableFile;
       }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
+      const launchWithNode = sourceExt.includes(path.extname(executableFile));
       let proc;
       if (process2.platform !== "win32") {
         if (launchWithNode) {
@@ -1147,6 +1351,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           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" });
@@ -1172,12 +1377,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       proc.on("error", (err) => {
         if (err.code === "ENOENT") {
-          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 '${subcommand._name}' 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);
+          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         } else if (err.code === "EACCES") {
           throw new Error(`'${executableFile}' not executable`);
         }
@@ -1195,6 +1395,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       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, () => {
@@ -1264,7 +1465,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.processedArgs = processedArgs;
     }
     _chainOrCall(promise, fn) {
-      if (promise && promise.then && typeof promise.then === "function") {
+      if (promise?.then && typeof promise.then === "function") {
         return promise.then(() => fn());
       }
       return fn();
@@ -1341,7 +1542,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
         return promiseChain;
       }
-      if (this.parent && this.parent.listenerCount(commandEvent)) {
+      if (this.parent?.listenerCount(commandEvent)) {
         checkForUnknownOptions();
         this._processArguments();
         this.parent.emit(commandEvent, operands, unknown);
@@ -1403,24 +1604,31 @@ Expecting one of '${allowedValues.join("', '")}'`);
         cmd._checkForConflictingLocalOptions();
       });
     }
-    parseOptions(argv) {
+    parseOptions(args) {
       const operands = [];
       const unknown = [];
       let dest = operands;
-      const args = argv.slice();
       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;
-      while (args.length) {
-        const arg = args.shift();
+      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);
+          dest.push(...args.slice(i));
           break;
         }
-        if (activeVariadicOption && !maybeOption(arg)) {
+        if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
           this.emit(`option:${activeVariadicOption.name()}`, arg);
           continue;
         }
@@ -1429,14 +1637,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
           const option = this._findOption(arg);
           if (option) {
             if (option.required) {
-              const value = args.shift();
+              const value = args[i++];
               if (value === undefined)
                 this.optionMissingArgument(option);
               this.emit(`option:${option.name()}`, value);
             } else if (option.optional) {
               let value = null;
-              if (args.length > 0 && !maybeOption(args[0])) {
-                value = args.shift();
+              if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
+                value = args[i++];
               }
               this.emit(`option:${option.name()}`, value);
             } else {
@@ -1453,7 +1661,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
               this.emit(`option:${option.name()}`, arg.slice(2));
             } else {
               this.emit(`option:${option.name()}`);
-              args.unshift(`-${arg.slice(2)}`);
+              activeGroup = `-${arg.slice(2)}`;
             }
             continue;
           }
@@ -1466,31 +1674,24 @@ Expecting one of '${allowedValues.join("', '")}'`);
             continue;
           }
         }
-        if (maybeOption(arg)) {
+        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);
-            if (args.length > 0)
-              unknown.push(...args);
+            unknown.push(...args.slice(i));
             break;
           } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg);
-            if (args.length > 0)
-              operands.push(...args);
+            operands.push(arg, ...args.slice(i));
             break;
           } else if (this._defaultCommandName) {
-            unknown.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
+            unknown.push(arg, ...args.slice(i));
             break;
           }
         }
         if (this._passThroughOptions) {
-          dest.push(arg);
-          if (args.length > 0)
-            dest.push(...args);
+          dest.push(arg, ...args.slice(i));
           break;
         }
         dest.push(arg);
@@ -1610,8 +1811,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return;
       const expected = this.registeredArguments.length;
       const s = expected === 1 ? "" : "s";
+      const received = receivedArgs.length;
       const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
-      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
+      const details = receivedArgs.join(", ");
+      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${received}: ${details}.`;
       this.error(message, { code: "commander.excessArguments" });
     }
     unknownCommand() {
@@ -1701,6 +1904,32 @@ Expecting one of '${allowedValues.join("', '")}'`);
       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;
@@ -1713,23 +1942,38 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     helpInformation(contextOptions) {
       const helper = this.createHelp();
-      if (helper.helpWidth === undefined) {
-        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-      }
-      return helper.formatHelp(this, helper);
+      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);
     }
-    _getHelpContext(contextOptions) {
+    _getOutputContext(contextOptions) {
       contextOptions = contextOptions || {};
-      const context = { error: !!contextOptions.error };
-      let write;
-      if (context.error) {
-        write = (arg) => this._outputConfiguration.writeErr(arg);
+      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 {
-        write = (arg) => this._outputConfiguration.writeOut(arg);
-      }
-      context.write = contextOptions.write || write;
-      context.command = this;
-      return context;
+        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;
@@ -1737,35 +1981,44 @@ Expecting one of '${allowedValues.join("', '")}'`);
         deprecatedCallback = contextOptions;
         contextOptions = undefined;
       }
-      const context = this._getHelpContext(contextOptions);
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
-      this.emit("beforeHelp", context);
-      let helpInformation = this.helpInformation(context);
+      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");
         }
       }
-      context.write(helpInformation);
+      outputContext.write(helpInformation);
       if (this._getHelpOption()?.long) {
         this.emit(this._getHelpOption().long);
       }
-      this.emit("afterHelp", context);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
+      this.emit("afterHelp", eventContext);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
     }
     helpOption(flags, description) {
       if (typeof flags === "boolean") {
         if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
+          if (this._helpOption === null)
+            this._helpOption = undefined;
+          if (this._defaultOptionGroup) {
+            this._initOptionGroup(this._getHelpOption());
+          }
         } else {
           this._helpOption = null;
         }
         return this;
       }
-      flags = flags ?? "-h, --help";
-      description = description ?? "display help for command";
-      this._helpOption = this.createOption(flags, description);
+      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
+      if (flags || description)
+        this._initOptionGroup(this._helpOption);
       return this;
     }
     _getHelpOption() {
@@ -1776,11 +2029,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     addHelpOption(option) {
       this._helpOption = option;
+      this._initOptionGroup(option);
       return this;
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = process2.exitCode || 0;
+      let exitCode = Number(process2.exitCode ?? 0);
       if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
         exitCode = 1;
       }
@@ -1815,76 +2069,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
         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;
-    });
-  }
-  exports.Command = Command;
-});
-
-// ../../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;
+  };
 });
 
-// ../../node_modules/commander/esm.mjs
-var import__, program, createCommand, createArgument, createOption, CommanderError, InvalidArgumentError, InvalidOptionArgumentError, Command, Argument, Option, Help;
-var init_esm = __esm(() => {
-  import__ = __toESM(require_commander(), 1);
-  ({
-    program,
-    createCommand,
-    createArgument,
-    createOption,
-    CommanderError,
-    InvalidArgumentError,
-    InvalidOptionArgumentError,
-    Command,
-    Argument,
-    Option,
-    Help
-  } = import__.default);
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/index.js
+var program;
+var init_commander = __esm(() => {
+  init_argument();
+  init_command();
+  init_error();
+  init_help();
+  init_option();
+  program = new Command;
 });
 
 // ../core/src/types.ts
@@ -1974,16 +2170,16 @@ var exports_bundle = {};
 __export(exports_bundle, {
   bundleCommand: () => bundleCommand
 });
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import { execSync } from "node:child_process";
 function collectFiles(dir, prefix = "") {
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const entries = fs2.readdirSync(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      files.push(...collectFiles(path.join(dir, entry.name), relativePath));
+      files.push(...collectFiles(path2.join(dir, entry.name), relativePath));
     } else {
       files.push(relativePath);
     }
@@ -1991,32 +2187,32 @@ function collectFiles(dir, prefix = "") {
   return files;
 }
 function detectPackageManager(dir) {
-  for (let current = dir, parent = "";parent !== current; current = path.dirname(current)) {
+  for (let current = dir, parent = "";parent !== current; current = path2.dirname(current)) {
     parent = current;
-    if (fs.existsSync(path.join(current, "bun.lockb")) || fs.existsSync(path.join(current, "bun.lock")))
+    if (fs2.existsSync(path2.join(current, "bun.lockb")) || fs2.existsSync(path2.join(current, "bun.lock")))
       return "bun";
-    if (fs.existsSync(path.join(current, "pnpm-lock.yaml")))
+    if (fs2.existsSync(path2.join(current, "pnpm-lock.yaml")))
       return "pnpm";
-    if (fs.existsSync(path.join(current, "yarn.lock")))
+    if (fs2.existsSync(path2.join(current, "yarn.lock")))
       return "yarn";
-    if (fs.existsSync(path.join(current, "package-lock.json")))
+    if (fs2.existsSync(path2.join(current, "package-lock.json")))
       return "npm";
   }
   return "npm";
 }
 var bundleCommand;
 var init_bundle = __esm(() => {
-  init_esm();
+  init_commander();
   init_src();
   bundleCommand = new Command("bundle").description("Bundles the web controller into the Android assets directory").option("-s, --source <path>", "Source directory of web controller", "./web-controller").option("-o, --output <path>", "Android assets directory", "./android/app/src/main/assets/www").option("--no-build", "Skip build step (just copy)").option("-m, --manifest <path>", "Also write manifest to this path for import in app source").action(async (options) => {
     console.log("Bundling controller...");
     try {
-      const sourceDir = path.resolve(process.cwd(), options.source);
-      const distDir = path.join(sourceDir, "dist");
-      const targetDir = path.resolve(process.cwd(), options.output);
+      const sourceDir = path2.resolve(process.cwd(), options.source);
+      const distDir = path2.join(sourceDir, "dist");
+      const targetDir = path2.resolve(process.cwd(), options.output);
       if (options.build) {
         console.log("  Running build command...");
-        if (fs.existsSync(path.join(sourceDir, "package.json"))) {
+        if (fs2.existsSync(path2.join(sourceDir, "package.json"))) {
           const pm = detectPackageManager(sourceDir);
           console.log(`  Using ${pm} to build...`);
           execSync(`${pm} run build`, { cwd: sourceDir, stdio: "inherit" });
@@ -2024,24 +2220,24 @@ var init_bundle = __esm(() => {
           console.warn("  No package.json found, skipping build");
         }
       }
-      if (!fs.existsSync(distDir)) {
+      if (!fs2.existsSync(distDir)) {
         throw new Error(`Build output not found at ${distDir}`);
       }
       console.log("  Cleaning target directory...");
-      fs.rmSync(targetDir, { recursive: true, force: true });
-      fs.mkdirSync(targetDir, { recursive: true });
+      fs2.rmSync(targetDir, { recursive: true, force: true });
+      fs2.mkdirSync(targetDir, { recursive: true });
       console.log("  Copying assets...");
-      fs.cpSync(distDir, targetDir, { recursive: true });
+      fs2.cpSync(distDir, targetDir, { recursive: true });
       const files = collectFiles(targetDir).sort();
       const manifest = JSON.stringify({ files }, null, 2);
-      const manifestPath = path.join(targetDir, "www-manifest.json");
-      fs.writeFileSync(manifestPath, manifest + `
+      const manifestPath = path2.join(targetDir, "www-manifest.json");
+      fs2.writeFileSync(manifestPath, manifest + `
 `);
       console.log(`  Generated manifest with ${files.length} files`);
       if (options.manifest) {
-        const secondaryPath = path.resolve(process.cwd(), options.manifest);
-        fs.mkdirSync(path.dirname(secondaryPath), { recursive: true });
-        fs.writeFileSync(secondaryPath, manifest + `
+        const secondaryPath = path2.resolve(process.cwd(), options.manifest);
+        fs2.mkdirSync(path2.dirname(secondaryPath), { recursive: true });
+        fs2.writeFileSync(secondaryPath, manifest + `
 `);
         console.log(`  Manifest also written to ${options.manifest}`);
       }
@@ -2060,7 +2256,7 @@ __export(exports_simulate, {
 });
 var simulateCommand;
 var init_simulate = __esm(() => {
-  init_esm();
+  init_commander();
   init_src();
   simulateCommand = new Command("simulate").description("Spawns headless bots to simulate players").option("-n, --count <number>", "Number of bots", "4").option("-u, --url <url>", "WebSocket URL of host", `ws://localhost:${DEFAULT_HTTP_PORT + DEFAULT_WS_PORT_OFFSET}${DEFAULT_WS_PATH}`).option("-i, --interval <ms>", "Action interval in ms", "1000").action(async (options) => {
     const count = parseInt(options.count);
@@ -2123,8 +2319,8 @@ var exports_init = {};
 __export(exports_init, {
   initCommand: () => initCommand
 });
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 function detectPackageManager2() {
   if (typeof Bun !== "undefined")
     return "bun";
@@ -2139,16 +2335,16 @@ function detectPackageManager2() {
 }
 var initCommand;
 var init_init = __esm(() => {
-  init_esm();
+  init_commander();
   init_src();
   initCommand = new Command("init").description("Scaffolds a new web controller project").argument("[name]", "Project name", "web-controller").action(async (name) => {
     console.log(`Creating ${name}...`);
     try {
-      const targetDir = path2.resolve(process.cwd(), name);
-      if (fs2.existsSync(targetDir)) {
+      const targetDir = path3.resolve(process.cwd(), name);
+      if (fs3.existsSync(targetDir)) {
         throw new Error(`Directory ${name} already exists`);
       }
-      fs2.mkdirSync(targetDir, { recursive: true });
+      fs3.mkdirSync(targetDir, { recursive: true });
       const packageJson = {
         name,
         private: true,
@@ -2172,9 +2368,9 @@ var init_init = __esm(() => {
           vite: "^6.0.0"
         }
       };
-      fs2.writeFileSync(path2.join(targetDir, "package.json"), JSON.stringify(packageJson, null, 2) + `
+      fs3.writeFileSync(path3.join(targetDir, "package.json"), JSON.stringify(packageJson, null, 2) + `
 `);
-      fs2.writeFileSync(path2.join(targetDir, "tsconfig.json"), JSON.stringify({
+      fs3.writeFileSync(path3.join(targetDir, "tsconfig.json"), JSON.stringify({
         compilerOptions: {
           target: "ES2020",
           useDefineForClassFields: true,
@@ -2198,7 +2394,7 @@ var init_init = __esm(() => {
         references: [{ path: "./tsconfig.node.json" }]
       }, null, 2) + `
 `);
-      fs2.writeFileSync(path2.join(targetDir, "tsconfig.node.json"), JSON.stringify({
+      fs3.writeFileSync(path3.join(targetDir, "tsconfig.node.json"), JSON.stringify({
         compilerOptions: {
           composite: true,
           skipLibCheck: true,
@@ -2209,7 +2405,7 @@ var init_init = __esm(() => {
         include: ["vite.config.ts"]
       }, null, 2) + `
 `);
-      fs2.writeFileSync(path2.join(targetDir, "vite.config.ts"), `
+      fs3.writeFileSync(path3.join(targetDir, "vite.config.ts"), `
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 
@@ -2219,8 +2415,8 @@ export default defineConfig({
   base: './', // Important for relative paths in Android WebView
 })
 `);
-      fs2.mkdirSync(path2.join(targetDir, "src"), { recursive: true });
-      fs2.writeFileSync(path2.join(targetDir, "index.html"), `
+      fs3.mkdirSync(path3.join(targetDir, "src"), { recursive: true });
+      fs3.writeFileSync(path3.join(targetDir, "index.html"), `
 <!doctype html>
 <html lang="en">
   <head>
@@ -2234,7 +2430,7 @@ export default defineConfig({
   </body>
 </html>
 `);
-      fs2.writeFileSync(path2.join(targetDir, "src/main.tsx"), `
+      fs3.writeFileSync(path3.join(targetDir, "src/main.tsx"), `
 import React from 'react'
 import ReactDOM from 'react-dom/client'
 import App from './App'
@@ -2246,7 +2442,7 @@ ReactDOM.createRoot(document.getElementById('root')!).render(
   </React.StrictMode>,
 )
 `);
-      fs2.writeFileSync(path2.join(targetDir, "src/App.tsx"), `
+      fs3.writeFileSync(path3.join(targetDir, "src/App.tsx"), `
 import { useGameClient } from '@couch-kit/client';
 import { gameReducer, initialState } from './reducer';
 
@@ -2271,7 +2467,7 @@ function App() {
 
 export default App
 `);
-      fs2.writeFileSync(path2.join(targetDir, "src/index.css"), `
+      fs3.writeFileSync(path3.join(targetDir, "src/index.css"), `
 body { margin: 0; background: #111; color: #fff; }
 `);
       const reducerContent = `import type { IAction, IGameState, GameReducer } from "@couch-kit/core";
@@ -2306,14 +2502,14 @@ export const initialState: GameState = {
   round: 1,
 };
 `;
-      fs2.writeFileSync(path2.join(targetDir, "src/reducer.ts"), reducerContent);
+      fs3.writeFileSync(path3.join(targetDir, "src/reducer.ts"), reducerContent);
       const gitignoreContent = `node_modules/
 dist/
 lib/
 .DS_Store
 *.local
 `;
-      fs2.writeFileSync(path2.join(targetDir, ".gitignore"), gitignoreContent);
+      fs3.writeFileSync(path3.join(targetDir, ".gitignore"), gitignoreContent);
       const pm = detectPackageManager2();
       console.log(`Done! Created new project in ${name}`);
       console.log(`
@@ -2337,7 +2533,7 @@ __export(exports_replay, {
 import { resolve } from "node:path";
 var replay2;
 var init_replay = __esm(() => {
-  init_esm();
+  init_commander();
   init_src();
   replay2 = new Command("replay").description("Replay a recorded game session against a reducer").argument("<recording>", "Path to recording JSON file").argument("<reducer>", "Path to reducer module (must export default or named 'reducer')").option("--snapshots", "Output intermediate state snapshots", false).option("--json", "Output as formatted JSON", false).action(async (recordingPath, reducerPath, options) => {
     try {
@@ -2413,7 +2609,7 @@ function getLanIp() {
 }
 var dev;
 var init_dev = __esm(() => {
-  init_esm();
+  init_commander();
   init_src();
   dev = new Command("dev").description("Start development server with LAN access for mobile testing").option("-p, --port <port>", "Port number", "5173").option("--host", "Expose to LAN", true).option("--open", "Open browser automatically", false).action(async (options) => {
     try {
@@ -2457,9 +2653,9 @@ var init_dev = __esm(() => {
 });
 
 // src/index.ts
-init_esm();
-import { createRequire as createRequire2 } from "node:module";
-var require2 = createRequire2(import.meta.url);
+init_commander();
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var program2 = new Command;
 program2.name("couch-kit").description("CLI for Couch Kit").version(version);