@zgeoff/checks 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,2285 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { resolve as resolve2 } from "path";
+
+// src/missing-program-error.ts
+class MissingProgramError extends Error {
+  program;
+  constructor(check, program) {
+    super(`${check}: ${program} is not on the PATH, and the ${check} check needs it. Install ${program}, then run zgeoff-check again.`);
+    this.name = "MissingProgramError";
+    this.program = program;
+  }
+}
+
+// src/run-program.ts
+function runProgram(check, context, argv) {
+  const [program] = argv;
+  if (Bun.which(program, { PATH: context.env["PATH"] ?? "" }) === null) {
+    throw new MissingProgramError(check, program);
+  }
+  const result = Bun.spawnSync([...argv], {
+    cwd: context.cwd,
+    env: { ...context.env },
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString()
+  };
+}
+
+// src/checks/parse-shellcheck-output.ts
+function parseShellcheckOutput(result) {
+  const problemLine = /^(?<path>.+?):(?<line>\d+):\d+: (?<level>\w+): (?<message>.*)$/u;
+  if (result.exitCode > 1) {
+    throw new Error(`shell: shellcheck failed: ${result.stderr.trim()}`);
+  }
+  const findings = result.stdout.split(`
+`).flatMap((line) => {
+    const groups = problemLine.exec(line)?.groups;
+    if (groups === undefined) {
+      return [];
+    }
+    return [
+      {
+        path: groups["path"] ?? "",
+        line: Number(groups["line"]),
+        message: `shellcheck ${groups["level"]}: ${groups["message"]}`
+      }
+    ];
+  });
+  if (result.exitCode === 1 && findings.length === 0) {
+    throw new Error(`shell: shellcheck failed: ${result.stderr.trim()}`);
+  }
+  return findings;
+}
+
+// src/checks/parse-shfmt-output.ts
+function parseShfmtOutput(result) {
+  const parseErrorLine = /^(?<path>.+?):(?<line>\d+):\d+: (?<message>.*)$/u;
+  const stderrLines = result.stderr.split(`
+`).filter((line) => line.trim() !== "");
+  const failures = stderrLines.filter((line) => !parseErrorLine.test(line));
+  if (result.exitCode > 1 || failures.length > 0) {
+    throw new Error(`shell: shfmt failed: ${result.stderr.trim()}`);
+  }
+  const errors = stderrLines.flatMap((line) => {
+    const groups = parseErrorLine.exec(line)?.groups;
+    if (groups === undefined) {
+      return [];
+    }
+    return [
+      {
+        path: groups["path"] ?? "",
+        line: Number(groups["line"]),
+        message: `shfmt cannot parse the file: ${groups["message"]}`
+      }
+    ];
+  });
+  const diffs = collectDiffFindings(result.stdout);
+  if (result.exitCode !== 0 && errors.length === 0 && diffs.length === 0) {
+    throw new Error(`shell: shfmt failed: ${result.stderr.trim()}`);
+  }
+  return [...errors, ...diffs];
+}
+function collectDiffFindings(diff) {
+  const diffTargetLine = /^\+\+\+ (?<path>.+)$/u;
+  const hunkHeader = /^@@ -(?<start>\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/u;
+  const findings = [];
+  let path = "";
+  let line = 0;
+  let reported = true;
+  for (const text of diff.split(`
+`)) {
+    const target = diffTargetLine.exec(text)?.groups;
+    if (target !== undefined) {
+      path = target["path"] ?? "";
+      continue;
+    }
+    const hunk = hunkHeader.exec(text)?.groups;
+    if (hunk !== undefined) {
+      line = Number(hunk["start"]);
+      reported = false;
+      continue;
+    }
+    if (reported || text.startsWith("---")) {
+      continue;
+    }
+    if (text.startsWith("-") || text.startsWith("+")) {
+      findings.push({
+        path,
+        line,
+        message: `shfmt would reformat this hunk; run shfmt -w ${path} to fix it`
+      });
+      reported = true;
+    } else if (text.startsWith(" ")) {
+      line += 1;
+    }
+  }
+  return findings;
+}
+
+// src/checks/shell-check.ts
+var shellCheck = {
+  name: "shell",
+  glob: "**/*.sh",
+  check: checkShellFiles
+};
+var BATCH_SIZE = 200;
+function checkShellFiles(context) {
+  const plain = {
+    ...context,
+    env: Object.fromEntries(Object.entries(context.env).filter(([name]) => name !== "FORCE_COLOR"))
+  };
+  const findings = [];
+  for (let start = 0;start < plain.files.length; start += BATCH_SIZE) {
+    const batch = plain.files.slice(start, start + BATCH_SIZE);
+    findings.push(...runShellcheck(plain, batch), ...runShfmt(plain, batch));
+  }
+  return findings;
+}
+function runShellcheck(context, files) {
+  const result = runProgram("shell", context, [
+    "shellcheck",
+    "--format=gcc",
+    "--external-sources",
+    "--source-path=SCRIPTDIR",
+    `--source-path=${context.cwd}`,
+    "--",
+    ...files
+  ]);
+  return parseShellcheckOutput(result);
+}
+function runShfmt(context, files) {
+  const result = runProgram("shell", context, ["shfmt", "-d", "--", ...files]);
+  return parseShfmtOutput(result);
+}
+
+// src/all-checks.ts
+var allChecks = [shellCheck];
+
+// src/load-config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+
+// ../std/src/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/config-error.ts
+class ConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+}
+
+// src/load-config.ts
+var CONFIG_FILE = "zgeoff-check.json";
+function loadConfig(cwd, checkNames) {
+  let text;
+  try {
+    text = readFileSync(join(cwd, CONFIG_FILE), "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { off: new Map };
+    }
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new ConfigError(`${CONFIG_FILE}: ${error instanceof Error ? error.message : "not JSON"}`);
+  }
+  return parseConfig(value, checkNames);
+}
+function parseConfig(value, checkNames) {
+  if (!isRecord(value)) {
+    throw new ConfigError(`${CONFIG_FILE}: the file must hold an object`);
+  }
+  const unknownKeys = Object.keys(value).filter((key) => key !== "off");
+  if (unknownKeys.length > 0) {
+    throw new ConfigError(`${CONFIG_FILE}: unknown key ${unknownKeys.join(", ")}`);
+  }
+  const entries = value["off"] ?? [];
+  if (!Array.isArray(entries)) {
+    throw new ConfigError(`${CONFIG_FILE}: off must be a list of { "check", "reason" } entries`);
+  }
+  const off = new Map;
+  for (const [index, entry] of entries.entries()) {
+    const at = `${CONFIG_FILE}: off[${index}]`;
+    if (!isRecord(entry)) {
+      throw new ConfigError(`${at} must be an object with a check and a reason`);
+    }
+    const check = entry["check"];
+    const reason = entry["reason"];
+    const extraKeys = Object.keys(entry).filter((key) => key !== "check" && key !== "reason");
+    if (extraKeys.length > 0) {
+      throw new ConfigError(`${at} has an unknown key ${extraKeys.join(", ")}`);
+    }
+    if (typeof check !== "string" || !checkNames.includes(check)) {
+      throw new ConfigError(`${at} names no known check; the checks are ${checkNames.join(", ")}`);
+    }
+    if (typeof reason !== "string" || reason.trim() === "") {
+      throw new ConfigError(`${at} turns off ${check} with no reason; give one in reason`);
+    }
+    if (off.has(check)) {
+      throw new ConfigError(`${at} turns off ${check} a second time`);
+    }
+    off.set(check, reason);
+  }
+  return { off };
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/utils-D-MmF6sM.js
+function kebabnize(str) {
+  return str.replace(/[A-Z]/g, (match, offset) => (offset > 0 ? "-" : "") + match.toLowerCase());
+}
+function formatChoices(choices) {
+  return choices.map((value) => JSON.stringify(value)).join(", ");
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/utils.js
+function isLazyCommand(cmd) {
+  return typeof cmd === "function" && "commandName" in cmd;
+}
+async function resolveLazyCommand(cmd, name, needRunResolving = false) {
+  let command;
+  if (isLazyCommand(cmd)) {
+    const baseCommand = {
+      name: cmd.commandName,
+      description: cmd.description,
+      args: cmd.args,
+      examples: cmd.examples,
+      internal: cmd.internal,
+      entry: cmd.entry,
+      toKebab: cmd.toKebab,
+      rendering: cmd.rendering,
+      subCommands: cmd.subCommands
+    };
+    if ("resource" in cmd && cmd.resource)
+      baseCommand.resource = cmd.resource;
+    command = Object.assign(create(), baseCommand);
+    if (needRunResolving) {
+      const loaded = await cmd();
+      if (typeof loaded === "function")
+        command.run = loaded;
+      else if (typeof loaded === "object") {
+        if (loaded.run == null)
+          throw new TypeError(`'run' is required in command: ${cmd.name || name}`);
+        command.run = loaded.run;
+        command.name = loaded.name ?? cmd.commandName;
+        command.description = loaded.description ?? cmd.description;
+        command.args = loaded.args ?? cmd.args;
+        command.examples = loaded.examples ?? cmd.examples;
+        command.internal = loaded.internal ?? cmd.internal;
+        command.entry = loaded.entry ?? cmd.entry;
+        command.toKebab = loaded.toKebab ?? cmd.toKebab;
+        command.rendering = loaded.rendering ?? cmd.rendering;
+        command.subCommands = loaded.subCommands || cmd.subCommands;
+        if ("resource" in loaded && loaded.resource)
+          command.resource = loaded.resource;
+      } else
+        throw new TypeError(`Cannot resolve command: ${cmd.name || name}`);
+    }
+  } else
+    command = Object.assign(create(), cmd);
+  if (command.name == null && name)
+    command.name = name;
+  return deepFreeze(command);
+}
+function create(obj = null) {
+  return Object.create(obj);
+}
+function log(...args) {
+  console.log(...args);
+}
+function getCommandSubCommands(cmd) {
+  const subCommands = isLazyCommand(cmd) ? cmd.subCommands : typeof cmd === "object" ? cmd.subCommands : undefined;
+  if (!subCommands)
+    return;
+  if (subCommands instanceof Map)
+    return subCommands.size > 0 ? subCommands : undefined;
+  if (typeof subCommands === "object") {
+    const entries = Object.entries(subCommands);
+    if (entries.length === 0)
+      return;
+    const map = /* @__PURE__ */ new Map;
+    for (const [name, cmd] of entries)
+      map.set(name, cmd);
+    return map;
+  }
+}
+function deepFreeze(obj, ignores = []) {
+  if (obj === null || typeof obj !== "object")
+    return obj;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (ignores.includes(key))
+      continue;
+    if (typeof value === "object" && value !== null)
+      deepFreeze(value, ignores);
+  }
+  return Object.freeze(obj);
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/context-CSecf6R5.js
+var ANONYMOUS_COMMAND_NAME = "(anonymous)";
+var NOOP = () => {};
+var CLI_OPTIONS_DEFAULT = {
+  name: undefined,
+  description: undefined,
+  version: undefined,
+  cwd: undefined,
+  usageSilent: false,
+  subCommands: undefined,
+  leftMargin: 2,
+  middleMargin: 10,
+  usageOptionType: false,
+  usageOptionValue: true,
+  strict: false,
+  renderHeader: undefined,
+  renderUsage: undefined,
+  renderValidationErrors: undefined,
+  plugins: undefined,
+  fallbackToEntry: false
+};
+async function createCommandContext({ args = {}, explicit = {}, values = {}, positionals = [], rest = [], argv = [], tokens = [], command = {}, extensions = {}, cliOptions = {}, callMode = "entry", commandPath = [], omitted = false, validationError }) {
+  const _args = Object.entries(args).reduce((acc, [key, value]) => {
+    acc[key] = Object.assign(create(), value);
+    return acc;
+  }, create());
+  const env = Object.assign(create(), CLI_OPTIONS_DEFAULT, cliOptions);
+  if (command.rendering) {
+    const { header, usage, validationErrors } = command.rendering;
+    if (header !== undefined)
+      env.renderHeader = header;
+    if (usage !== undefined)
+      env.renderUsage = usage;
+    if (validationErrors !== undefined)
+      env.renderValidationErrors = validationErrors;
+  }
+  const core = Object.assign(create(), {
+    name: getCommandName(command),
+    description: command.description,
+    omitted,
+    callMode,
+    commandPath,
+    env,
+    args: _args,
+    explicit,
+    values,
+    positionals,
+    rest,
+    _: argv,
+    tokens,
+    toKebab: command.toKebab,
+    log: cliOptions.usageSilent ? NOOP : log,
+    validationError
+  });
+  if (Object.keys(extensions).length > 0) {
+    const ext = create(null);
+    Object.defineProperty(core, "extensions", {
+      value: ext,
+      writable: false,
+      enumerable: true,
+      configurable: true
+    });
+    for (const [key, extension] of Object.entries(extensions)) {
+      ext[key] = await extension.factory(core, command);
+      if (extension.onFactory)
+        await extension.onFactory(core, command);
+    }
+  }
+  return deepFreeze(core, ["extensions", "entryCommand"]);
+}
+function getCommandName(cmd) {
+  if (isLazyCommand(cmd))
+    return cmd.commandName || cmd.name || "(anonymous)";
+  else if (typeof cmd === "object")
+    return cmd.name || "(anonymous)";
+  else
+    return ANONYMOUS_COMMAND_NAME;
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/resolver-CAlgxe_R-3pz9PVFu.js
+var HYPHEN_CHAR = "-";
+var HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
+var EQUAL_CHAR = "=";
+var EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
+var TERMINATOR = "--";
+var SHORT_OPTION_PREFIX = HYPHEN_CHAR;
+var LONG_OPTION_PREFIX = "--";
+function parseArgs(args, options = {}) {
+  const { allowCompatible = false } = options;
+  const tokens = [];
+  const remainings = [...args];
+  let index = -1;
+  let groupCount = 0;
+  let hasShortGroupValue = false;
+  let shortGroupValueInline = true;
+  while (remainings.length > 0) {
+    const arg = remainings.shift();
+    if (arg == undefined)
+      break;
+    if (groupCount > 0)
+      groupCount--;
+    else
+      index++;
+    if (arg === TERMINATOR) {
+      tokens.push({
+        kind: "option-terminator",
+        index
+      });
+      const mapped = remainings.map((arg) => {
+        return {
+          kind: "positional",
+          index: ++index,
+          value: arg
+        };
+      });
+      tokens.push(...mapped);
+      break;
+    }
+    if (isShortOption(arg)) {
+      const shortOption = arg.charAt(1);
+      let value;
+      let inlineValue;
+      if (groupCount) {
+        tokens.push({
+          kind: "option",
+          name: shortOption,
+          rawName: arg,
+          index,
+          value,
+          inlineValue
+        });
+        if (groupCount === 1 && hasShortGroupValue) {
+          value = remainings.shift();
+          inlineValue = shortGroupValueInline;
+          hasShortGroupValue = false;
+          tokens.push({
+            kind: "option",
+            index,
+            value,
+            inlineValue
+          });
+        }
+      } else
+        tokens.push({
+          kind: "option",
+          name: shortOption,
+          rawName: arg,
+          index,
+          value,
+          inlineValue
+        });
+      if (value != null)
+        ++index;
+      continue;
+    }
+    if (isShortOptionGroup(arg)) {
+      const expanded = [];
+      let separated = false;
+      let dashed = false;
+      let shortValue = "";
+      for (let i = 1;i < arg.length; i++) {
+        const shortableOption = arg.charAt(i);
+        if (separated)
+          shortValue += shortableOption;
+        else if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE && expanded.length > 0)
+          separated = true;
+        else if (!allowCompatible && shortableOption.codePointAt(0) === HYPHEN_CODE) {
+          separated = true;
+          dashed = true;
+          shortValue += shortableOption;
+        } else
+          expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
+      }
+      hasShortGroupValue = separated;
+      shortGroupValueInline = !dashed;
+      if (separated)
+        expanded.push(shortValue);
+      remainings.unshift(...expanded);
+      groupCount = expanded.length;
+      continue;
+    }
+    if (isLongOption(arg)) {
+      const longOption = arg.slice(2);
+      tokens.push({
+        kind: "option",
+        name: longOption,
+        rawName: arg,
+        index,
+        value: undefined,
+        inlineValue: undefined
+      });
+      continue;
+    }
+    if (isLongOptionAndValue(arg)) {
+      const equalIndex = arg.indexOf(EQUAL_CHAR);
+      const longOption = arg.slice(2, equalIndex);
+      const value = arg.slice(equalIndex + 1);
+      tokens.push({
+        kind: "option",
+        name: longOption,
+        rawName: `${LONG_OPTION_PREFIX}${longOption}`,
+        index,
+        value,
+        inlineValue: true
+      });
+      continue;
+    }
+    tokens.push({
+      kind: "positional",
+      index,
+      value: arg
+    });
+  }
+  return tokens;
+}
+function isShortOption(arg) {
+  return arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE;
+}
+function isShortOptionGroup(arg) {
+  if (arg.length <= 2)
+    return false;
+  if (arg.codePointAt(0) !== HYPHEN_CODE)
+    return false;
+  if (arg.codePointAt(1) === HYPHEN_CODE)
+    return false;
+  return true;
+}
+function isLongOption(arg) {
+  return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
+}
+function isLongOptionAndValue(arg) {
+  return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
+}
+function hasLongOptionPrefix(arg) {
+  return arg.startsWith(LONG_OPTION_PREFIX) && arg.length > 2;
+}
+var PURE_PARSE = Symbol.for("args-tokens.pureParse");
+var ArgsValidationErrorKeys = {
+  requiredOption: "err:arg:required-option",
+  requiredPositional: "err:arg:required-positional",
+  invalidType: "err:arg:invalid-type",
+  invalidChoice: "err:arg:invalid-choice",
+  customParse: "err:arg:custom-parse",
+  unknownOption: "err:arg:unknown-option",
+  unexpectedValue: "err:arg:unexpected-value",
+  missingValue: "err:arg:missing-value",
+  conflict: "err:arg:conflict",
+  invalidDefault: "err:arg:invalid-default"
+};
+var ARGS_VALIDATION_ERROR_BRAND = Symbol.for("args-tokens.ArgsValidationError");
+var ArgsValidationError = class extends Error {
+  code;
+  values;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "ArgsValidationError";
+    this.code = options.code;
+    this.values = options.values ?? {};
+    Object.defineProperty(this, ARGS_VALIDATION_ERROR_BRAND, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+};
+function isArgsValidationError(error) {
+  if (error instanceof ArgsValidationError)
+    return true;
+  if (typeof error !== "object" || error === null)
+    return false;
+  if (!Object.hasOwn(error, ARGS_VALIDATION_ERROR_BRAND) || error[ARGS_VALIDATION_ERROR_BRAND] !== true)
+    return false;
+  const values = error.values;
+  return typeof values === "object" && values !== null;
+}
+var SKIP_POSITIONAL_DEFAULT = -1;
+var ARG_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "boolean",
+  "number",
+  "enum",
+  "positional",
+  "custom"
+]);
+function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKIP_POSITIONAL_DEFAULT, toKebab = false } = {}) {
+  const skipPositionalIndex = typeof skipPositional === "number" ? Math.max(skipPositional, SKIP_POSITIONAL_DEFAULT) : SKIP_POSITIONAL_DEFAULT;
+  const rest = [];
+  const optionTokens = [];
+  const positionalTokens = [];
+  const argEntries = Object.entries(args);
+  let currentLongOption;
+  let currentShortOption;
+  const expandableShortOptions = [];
+  function getOptionName(rawArg, schema) {
+    return toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+  }
+  function checkLongTokenName(option, schema, token) {
+    if (token.rawName == undefined || !hasLongOptionPrefix(token.rawName))
+      return false;
+    return token.name === option || isNegatedToken(token, option, schema);
+  }
+  function toShortValue() {
+    if (expandableShortOptions.length === 0)
+      return;
+    else {
+      let value = "";
+      for (let i = 0;i < expandableShortOptions.length; i++)
+        value += expandableShortOptions[i].name ?? "";
+      expandableShortOptions.length = 0;
+      return value;
+    }
+  }
+  function applyLongOptionValue(value) {
+    if (currentLongOption) {
+      currentLongOption.value = value;
+      optionTokens.push({ ...currentLongOption });
+      currentLongOption = undefined;
+    }
+  }
+  function applyShortOptionValue(value) {
+    if (currentShortOption) {
+      currentShortOption.value = value ?? toShortValue();
+      optionTokens.push({ ...currentShortOption });
+      currentShortOption = undefined;
+    }
+  }
+  const schemas = Object.values(args);
+  const booleanLongOptionNames = /* @__PURE__ */ new Set;
+  for (let i = 0;i < argEntries.length; i++) {
+    const entry = argEntries[i];
+    const rawArg = entry[0];
+    const schema = entry[1];
+    if (typeof schema.parse !== "function") {
+      if (schema.type === "custom")
+        throw new TypeError(`argument '${getOptionName(rawArg, schema)}' should have a 'parse' function`);
+      if (schema.type === "enum" && !Array.isArray(schema.choices))
+        throw new TypeError(`argument '${getOptionName(rawArg, schema)}' should have a 'choices' array`);
+      if (!ARG_TYPES.has(schema.type))
+        throw new Error(`Unsupported argument type '${schema.type}' for option '${getOptionName(rawArg, schema)}'`);
+    }
+    if (schema.type !== "boolean")
+      continue;
+    const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+    booleanLongOptionNames.add(arg);
+    if (schema.negatable === true)
+      booleanLongOptionNames.add(`no-${arg}`);
+  }
+  let terminated = false;
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.kind === "positional") {
+      if (terminated) {
+        rest.push(token.value);
+        continue;
+      }
+      if (currentShortOption) {
+        if (schemas.find((schema) => schema.short === currentShortOption.name && schema.type === "boolean") || expandableShortOptions.length > 0) {
+          positionalTokens.push({ ...token });
+          applyShortOptionValue();
+        } else
+          applyShortOptionValue(token.value);
+      } else if (currentLongOption) {
+        if (booleanLongOptionNames.has(currentLongOption.name)) {
+          positionalTokens.push({ ...token });
+          applyLongOptionValue();
+        } else
+          applyLongOptionValue(token.value);
+      } else
+        positionalTokens.push({ ...token });
+    } else if (token.kind === "option") {
+      if (token.rawName) {
+        if (token.rawName.startsWith("--")) {
+          applyLongOptionValue();
+          applyShortOptionValue();
+          if (token.inlineValue)
+            optionTokens.push({ ...token });
+          else
+            currentLongOption = { ...token };
+        } else if (isShortOption(token.rawName)) {
+          if (currentShortOption) {
+            if (currentShortOption.index === token.index) {
+              if (shortGrouping) {
+                currentShortOption.value = token.value;
+                optionTokens.push({ ...currentShortOption });
+                currentShortOption = { ...token };
+              } else
+                expandableShortOptions.push({ ...token });
+            } else {
+              currentShortOption.value = toShortValue();
+              optionTokens.push({ ...currentShortOption });
+              currentShortOption = { ...token };
+            }
+            applyLongOptionValue();
+          } else {
+            currentShortOption = { ...token };
+            applyLongOptionValue();
+          }
+        }
+      } else {
+        if (currentShortOption && currentShortOption.index == token.index) {
+          const letters = toShortValue();
+          currentShortOption.value = letters === undefined ? token.value : `${letters}${token.inlineValue ? "=" : ""}${token.value ?? ""}`;
+          currentShortOption.inlineValue = token.inlineValue;
+          optionTokens.push({ ...currentShortOption });
+          currentShortOption = undefined;
+        }
+        applyLongOptionValue();
+      }
+    } else {
+      if (token.kind === "option-terminator")
+        terminated = true;
+      applyLongOptionValue();
+      applyShortOptionValue();
+    }
+  }
+  applyLongOptionValue();
+  applyShortOptionValue();
+  const values = Object.create(null);
+  const errors = [];
+  const explicit = Object.create(null);
+  const actualInputNames = /* @__PURE__ */ new Map;
+  let requiredPositionalsAfter;
+  const positionalItemCount = tokens.filter((token) => token.kind === "positional").length;
+  function getPositionalSkipIndex() {
+    return Math.min(skipPositionalIndex, positionalItemCount);
+  }
+  function getRequiredPositionalsAfter(rawArg) {
+    requiredPositionalsAfter ??= createRequiredPositionalsAfter(argEntries);
+    return requiredPositionalsAfter[rawArg] ?? 0;
+  }
+  let positionalsCount = 0;
+  for (let argIndex = 0;argIndex < argEntries.length; argIndex++) {
+    const entry = argEntries[argIndex];
+    const rawArg = entry[0];
+    const schema = entry[1];
+    const arg = getOptionName(rawArg, schema);
+    explicit[rawArg] = false;
+    if (schema.type === "positional") {
+      if (skipPositionalIndex > SKIP_POSITIONAL_DEFAULT)
+        while (positionalsCount <= getPositionalSkipIndex())
+          positionalsCount++;
+      if (schema.multiple) {
+        const availablePositionals = Math.max(positionalTokens.length - positionalsCount, 0);
+        const positionalsToConsume = availablePositionals > 0 ? Math.max(availablePositionals - getRequiredPositionalsAfter(rawArg), 0) : 0;
+        if (positionalsToConsume > 0) {
+          const endPositionals = positionalsCount + positionalsToConsume;
+          if (typeof schema.parse === "function") {
+            const parsed = [];
+            for (let i = positionalsCount;i < endPositionals; i++) {
+              const p = positionalTokens[i];
+              const [parsedValue, error] = parseSchemaValue(p.value, rawArg, arg, schema);
+              if (error)
+                errors.push(error);
+              else
+                parsed.push(parsedValue);
+            }
+            values[rawArg] = parsed;
+          } else {
+            const valuesArray = [];
+            for (let i = positionalsCount;i < endPositionals; i++)
+              valuesArray.push(positionalTokens[i].value);
+            values[rawArg] = valuesArray;
+          }
+          positionalsCount = endPositionals;
+          explicit[rawArg] = true;
+        } else if (schema.required)
+          errors.push(createRequireError(rawArg, arg, schema));
+        else if (hasDefault(schema))
+          values[rawArg] = getDefaultValue(schema);
+      } else {
+        const positional = positionalTokens[positionalsCount];
+        if (shouldRequireMissingSinglePositional(schema)) {
+          if (positional != null) {
+            resolveSinglePositionalValue(values, errors, rawArg, arg, schema, positional);
+            explicit[rawArg] = true;
+            positionalsCount++;
+          } else
+            errors.push(createRequireError(rawArg, arg, schema));
+          continue;
+        }
+        if (positional != null) {
+          const requiredPositionals = getRequiredPositionalsAfter(rawArg);
+          if (Math.max(positionalTokens.length - positionalsCount, 0) > requiredPositionals) {
+            resolveSinglePositionalValue(values, errors, rawArg, arg, schema, positional);
+            explicit[rawArg] = true;
+            positionalsCount++;
+            continue;
+          }
+        }
+        if (hasDefault(schema))
+          values[rawArg] = schema.default;
+      }
+      continue;
+    }
+    if (schema.required) {
+      if (!optionTokens.find((token) => {
+        return schema.short && token.name === schema.short && token.rawName != null && isShortOption(token.rawName) || checkLongTokenName(arg, schema, token);
+      })) {
+        errors.push(createRequireError(rawArg, arg, schema));
+        continue;
+      }
+    }
+    let resolved = false;
+    for (let i = 0;i < optionTokens.length; i++) {
+      const token = optionTokens[i];
+      if (checkLongTokenName(arg, schema, token) || schema.short === token.name && token.rawName != null && isShortOption(token.rawName)) {
+        explicit[rawArg] = true;
+        const rawName = token.rawName;
+        const actualInputName = isShortOption(rawName) ? `-${token.name}` : rawName;
+        actualInputNames.set(rawArg, actualInputName);
+        const missing = schema.type !== "boolean" && token.value === undefined;
+        if (!missing) {
+          const invalid = validateRequire(token, rawArg, arg, schema);
+          if (invalid) {
+            errors.push(invalid);
+            continue;
+          }
+        }
+        const [parsedValue, error] = missing ? [undefined, createMissingValueError(rawArg, arg, schema, findOptionLikeNextArgument(tokens, optionTokens, i, argEntries, toKebab))] : parse(token, rawArg, arg, schema);
+        if (error)
+          errors.push(error);
+        else {
+          resolved = true;
+          if (schema.multiple) {
+            values[rawArg] ||= [];
+            values[rawArg].push(parsedValue);
+          } else
+            values[rawArg] = parsedValue;
+        }
+      }
+    }
+    if (!resolved && schema.default != null) {
+      if (hasDefaultOutsideChoices(schema))
+        errors.push(createDefaultChoiceError(rawArg, arg, schema));
+      else
+        values[rawArg] = getDefaultValue(schema);
+    }
+  }
+  const conflictErrors = checkConflicts(args, explicit, toKebab, actualInputNames);
+  errors.push(...conflictErrors);
+  return {
+    values,
+    positionals: positionalTokens.map((token) => token.value),
+    rest,
+    error: errors.length > 0 ? new AggregateError(errors) : undefined,
+    explicit
+  };
+}
+function isNegatedToken(token, option, schema) {
+  return schema.type === "boolean" && schema.negatable === true && token.name === `no-${option}`;
+}
+function parse(token, rawArg, option, schema) {
+  if (schema.type === "enum" && schema.choices && !schema.choices.includes(token.value))
+    return [undefined, createChoiceError(rawArg, option, schema, token.value)];
+  if (typeof schema.parse === "function") {
+    if (schema.type === "boolean") {
+      const [boolValue, error] = resolveBooleanValue(token, rawArg, option, schema);
+      if (error)
+        return [undefined, error];
+      return parseSchemaValue(String(boolValue), rawArg, option, schema);
+    }
+    return parseSchemaValue(token.value, rawArg, option, schema);
+  }
+  switch (schema.type) {
+    case "string":
+      return typeof token.value === "string" ? [token.value, undefined] : [undefined, createTypeError(rawArg, option, schema, token.value)];
+    case "boolean":
+      return resolveBooleanValue(token, rawArg, option, schema);
+    case "number":
+      if (typeof token.value !== "string" || !isNumeric(token.value))
+        return [undefined, createTypeError(rawArg, option, schema, token.value)];
+      return [+token.value, undefined];
+    case "enum":
+      return [token.value, undefined];
+    case "custom":
+      throw new TypeError(`argument '${option}' should have a 'parse' function`);
+    default:
+      throw new Error(`Unsupported argument type '${schema.type}' for option '${option}'`);
+  }
+}
+function resolveBooleanValue(token, rawArg, option, schema) {
+  const negated = isNegatedToken(token, option, schema);
+  if (!token.inlineValue)
+    return [!negated, undefined];
+  if (negated)
+    return [undefined, createUnexpectedValueError(rawArg, option, schema, token)];
+  if (token.value !== "true" && token.value !== "false")
+    return [undefined, createTypeError(rawArg, option, schema, token.value)];
+  return [token.value === "true", undefined];
+}
+function parseSchemaValue(value, rawArg, option, schema) {
+  try {
+    return [schema.parse(value), undefined];
+  } catch (error) {
+    return [undefined, createCustomParseError(error, rawArg, option, schema, value)];
+  }
+}
+function createRequireError(rawArg, option, schema) {
+  return new ArgResolveError(schema.type === "positional" ? `Positional argument '${option}' is required` : `Optional argument ${createOptionDisplayName(option, schema)} is required`, option, "required", schema, {
+    code: schema.type === "positional" ? ArgsValidationErrorKeys.requiredPositional : ArgsValidationErrorKeys.requiredOption,
+    values: schema.type === "positional" ? {
+      displayName: createArgumentDisplayName(option, schema),
+      name: rawArg
+    } : {
+      displayName: createOptionDisplayName(option, schema),
+      name: rawArg
+    }
+  });
+}
+function resolveSinglePositionalValue(values, errors, rawArg, option, schema, positional) {
+  if (typeof schema.parse === "function") {
+    const [parsedValue, error] = parseSchemaValue(positional.value, rawArg, option, schema);
+    if (error)
+      errors.push(error);
+    else
+      values[rawArg] = parsedValue;
+  } else
+    values[rawArg] = positional.value;
+}
+function hasDefault(schema) {
+  return schema.default != null;
+}
+function getDefaultValue(schema) {
+  const value = schema.default;
+  return schema.multiple && !Array.isArray(value) ? [value] : value;
+}
+function hasDefaultOutsideChoices(schema) {
+  const defaultType = typeof schema.default;
+  if (schema.type !== "enum" || !Array.isArray(schema.choices) || defaultType !== "string" && defaultType !== "number" && defaultType !== "boolean" || schema.choices.includes(schema.default))
+    return false;
+  const { parse } = schema;
+  if (typeof parse !== "function")
+    return true;
+  try {
+    return hasPureParseBrand(parse);
+  } catch {
+    return false;
+  }
+}
+function shouldRequireMissingSinglePositional(schema) {
+  if (schema.required === true)
+    return true;
+  if (schema.required === false)
+    return false;
+  return !hasDefault(schema);
+}
+function getRequiredPositionalInputCount(schema) {
+  if (schema.type !== "positional")
+    return 0;
+  if (schema.multiple)
+    return schema.required === true ? 1 : 0;
+  return shouldRequireMissingSinglePositional(schema) ? 1 : 0;
+}
+function createRequiredPositionalsAfter(argEntries) {
+  const requiredPositionalsAfter = Object.create(null);
+  let minimumRequiredPositionals = 0;
+  for (let i = argEntries.length - 1;i >= 0; i--) {
+    const [rawArg, schema] = argEntries[i];
+    if (schema.type !== "positional")
+      continue;
+    requiredPositionalsAfter[rawArg] = minimumRequiredPositionals;
+    minimumRequiredPositionals += getRequiredPositionalInputCount(schema);
+  }
+  return requiredPositionalsAfter;
+}
+var ArgResolveError = class extends ArgsValidationError {
+  name;
+  schema;
+  type;
+  constructor(message, name, type, schema, options = {}) {
+    super(message, options);
+    this.name = name;
+    this.type = type;
+    this.schema = schema;
+  }
+};
+function validateRequire(token, rawArg, option, schema) {
+  if (schema.required && schema.type !== "boolean" && !token.value)
+    return createRequireError(rawArg, option, schema);
+}
+function isNumeric(str) {
+  return str.trim() !== "" && !isNaN(str);
+}
+function createTypeError(rawArg, option, schema, actual, expected = schema.type) {
+  return new ArgResolveError(`Optional argument ${createOptionDisplayName(option, schema)} should be '${expected}'`, option, "type", schema, {
+    code: ArgsValidationErrorKeys.invalidType,
+    values: {
+      displayName: createOptionDisplayName(option, schema),
+      name: rawArg,
+      expected,
+      ...actual != null ? { actual } : {}
+    }
+  });
+}
+function createMissingValueError(rawArg, option, schema, next) {
+  const displayName = createOptionDisplayName(option, schema);
+  const suggestion = next === undefined || !acceptsSuggestedValue(schema, next) ? undefined : `--${option}=${next}`;
+  const hint = suggestion === undefined ? "" : ` (to pass '${next}' as its value, write '${suggestion}')`;
+  const choices = schema.choices ?? [];
+  return new ArgResolveError(`Optional argument ${displayName} requires a value${hint}`, option, "type", schema, {
+    code: ArgsValidationErrorKeys.missingValue,
+    values: {
+      displayName,
+      name: rawArg,
+      expected: schema.type === "custom" ? schema.metavar ?? schema.type : schema.type,
+      ...schema.type === "enum" ? {
+        choices: formatChoices(choices),
+        choiceValues: [...choices]
+      } : {},
+      ...suggestion === undefined ? {} : {
+        next,
+        suggestion
+      }
+    }
+  });
+}
+function findOptionLikeNextArgument(tokens, optionTokens, position, argEntries, toKebab) {
+  const token = optionTokens[position];
+  for (let i = position + 1;i < optionTokens.length; i++)
+    if (optionTokens[i].index === token.index)
+      return;
+  const nextArg = tokens.filter((t) => t.index === token.index + 1);
+  if (nextArg.length === 0 || nextArg.some((t) => t.kind !== "option" || t.rawName == null))
+    return;
+  let text;
+  let known;
+  if (nextArg.length === 1 && nextArg[0].rawName.startsWith("--")) {
+    const [option] = nextArg;
+    text = option.inlineValue ? `${option.rawName}=${option.value}` : option.rawName;
+    known = createKnownOptionNames(argEntries, toKebab).long.has(option.name);
+  } else if (nextArg.every((t) => isShortOption(t.rawName) && t.value === undefined)) {
+    text = `-${nextArg.map((t) => t.name).join("")}`;
+    const { short } = createKnownOptionNames(argEntries, toKebab);
+    known = optionTokens.every((t) => t.index !== token.index + 1 || short.has(t.name));
+  } else
+    return;
+  return known ? undefined : text;
+}
+function createKnownOptionNames(argEntries, toKebab) {
+  const long = /* @__PURE__ */ new Set;
+  const short = /* @__PURE__ */ new Set;
+  for (const [rawArg, schema] of argEntries) {
+    if (schema.type === "positional")
+      continue;
+    const name = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+    long.add(name);
+    if (schema.type === "boolean" && schema.negatable === true)
+      long.add(`no-${name}`);
+    if (schema.short)
+      short.add(schema.short);
+  }
+  return {
+    long,
+    short
+  };
+}
+function acceptsSuggestedValue(schema, value) {
+  if (schema.type === "number" && !isNumeric(value))
+    return false;
+  if (schema.type === "enum" && schema.choices && !schema.choices.includes(value))
+    return false;
+  const { parse } = schema;
+  if (typeof parse !== "function")
+    return true;
+  try {
+    if (!hasPureParseBrand(parse))
+      return schema.type === "number" || schema.type === "enum" && schema.choices !== undefined;
+    parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasPureParseBrand(parse) {
+  return Object.hasOwn(parse, PURE_PARSE) && parse[PURE_PARSE] === true;
+}
+function createUnexpectedValueError(rawArg, option, schema, token) {
+  const rawName = token.rawName;
+  const displayName = `'${rawName}'`;
+  return new ArgResolveError(`Optional argument ${displayName} does not take a value`, option, "type", schema, {
+    code: ArgsValidationErrorKeys.unexpectedValue,
+    values: {
+      displayName,
+      name: rawArg,
+      rawName,
+      ...token.value != null ? { actual: token.value } : {}
+    }
+  });
+}
+function createChoiceError(rawArg, option, schema, actual) {
+  const choices = schema.choices ?? [];
+  return new ArgResolveError(`Optional argument ${createOptionDisplayName(option, schema)} should be chosen from '${schema.type}' [${formatChoices(choices)}] values`, option, "type", schema, {
+    code: ArgsValidationErrorKeys.invalidChoice,
+    values: {
+      displayName: createOptionDisplayName(option, schema),
+      name: rawArg,
+      expected: schema.type,
+      choices: formatChoices(choices),
+      choiceValues: [...choices],
+      ...actual != null ? { actual } : {}
+    }
+  });
+}
+function createDefaultChoiceError(rawArg, option, schema) {
+  const choices = schema.choices ?? [];
+  const displayName = createOptionDisplayName(option, schema);
+  return new ArgResolveError(`Optional argument ${displayName} has the default ${typeof schema.default === "string" ? JSON.stringify(schema.default) : String(schema.default)}, which is not one of '${schema.type}' [${formatChoices(choices)}] values`, option, "type", schema, {
+    code: ArgsValidationErrorKeys.invalidDefault,
+    values: {
+      displayName,
+      name: rawArg,
+      expected: schema.type,
+      choices: formatChoices(choices),
+      choiceValues: [...choices],
+      actual: schema.default
+    }
+  });
+}
+function createCustomParseError(error, rawArg, option, schema, value) {
+  const reused = reuseValidationError(error, rawArg, option, schema, value);
+  if (reused)
+    return reused;
+  const reason = getErrorReason(error);
+  return new ArgsValidationError(reason, {
+    code: ArgsValidationErrorKeys.customParse,
+    values: {
+      displayName: createArgumentDisplayName(option, schema),
+      name: rawArg,
+      reason
+    },
+    cause: error
+  });
+}
+function reuseValidationError(error, rawArg, option, schema, value) {
+  try {
+    if (isArgsValidationError(error)) {
+      augmentValidationError(error, rawArg, option, schema, value);
+      return error;
+    }
+  } catch {}
+}
+function augmentValidationError(error, rawArg, option, schema, value) {
+  const values = error.values;
+  values.name ??= rawArg;
+  values.displayName ??= createArgumentDisplayName(option, schema);
+  if ((error.code === ArgsValidationErrorKeys.invalidType || error.code === ArgsValidationErrorKeys.invalidChoice) && values.actual == null)
+    values.actual = value;
+}
+function getErrorReason(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createArgumentDisplayName(option, schema) {
+  return schema.type === "positional" ? `'${option}'` : createOptionDisplayName(option, schema);
+}
+function createOptionDisplayName(option, schema) {
+  return `'--${option}'${schema.short ? ` or '-${schema.short}'` : ""}`;
+}
+function createConflictError(rawArg, option, schema, actualName, conflictingArg, conflictingActualName) {
+  const displayName = `'${actualName}'`;
+  const conflictDisplayName = `'${conflictingActualName}'`;
+  return new ArgResolveError(`${schema.type === "positional" ? "Positional" : "Optional"} argument ${displayName} conflicts with ${conflictDisplayName}`, option, "conflict", schema, {
+    code: ArgsValidationErrorKeys.conflict,
+    values: {
+      displayName,
+      name: rawArg,
+      conflictDisplayName,
+      conflictName: conflictingArg
+    }
+  });
+}
+function checkConflicts(args, explicit, toKebab, actualInputNames) {
+  for (const rawArg in args) {
+    const schema = args[rawArg];
+    if (!explicit[rawArg])
+      continue;
+    if (!schema.conflicts)
+      continue;
+    const conflicts = Array.isArray(schema.conflicts) ? schema.conflicts : [schema.conflicts];
+    for (let i = 0;i < conflicts.length; i++) {
+      const conflictingArg = conflicts[i];
+      if (!explicit[conflictingArg])
+        continue;
+      const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+      const conflictingArgKebab = toKebab || args[conflictingArg]?.toKebab ? kebabnize(conflictingArg) : conflictingArg;
+      return [createConflictError(rawArg, arg, schema, schema.type === "positional" ? arg : actualInputNames.get(rawArg) || `--${arg}`, conflictingArg, args[conflictingArg]?.type === "positional" ? conflictingArgKebab : actualInputNames.get(conflictingArg) || `--${conflictingArgKebab}`)];
+    }
+  }
+  return [];
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/error-pbHb3QAL.js
+var CommandNotFoundErrorKeys = { notFound: "err:cmd:not-found" };
+var CommandResolutionErrorKeys = {
+  ambiguous: "err:cmd:ambiguous",
+  inconsistentOptions: "err:cmd:inconsistent-options",
+  lazySchemaMismatch: "err:cmd:lazy-schema-mismatch"
+};
+var COMMAND_NOT_FOUND_ERROR_BRAND = Symbol.for("gunshi.CommandNotFoundError");
+var COMMAND_RESOLUTION_ERROR_BRAND = Symbol.for("gunshi.CommandResolutionError");
+var CommandNotFoundError = class extends Error {
+  code;
+  values;
+  commandName;
+  candidates;
+  commandPath;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "CommandNotFoundError";
+    this.code = options.code;
+    this.values = options.values || {};
+    this.commandName = options.commandName;
+    this.candidates = options.candidates || [];
+    this.commandPath = options.commandPath || [];
+    Object.defineProperty(this, COMMAND_NOT_FOUND_ERROR_BRAND, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+};
+var CommandResolutionError = class extends Error {
+  code;
+  values;
+  commandPath;
+  candidatePaths;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "CommandResolutionError";
+    this.code = options.code;
+    this.values = options.values || {};
+    this.commandPath = options.commandPath || [];
+    this.candidatePaths = options.candidatePaths || [];
+    Object.defineProperty(this, COMMAND_RESOLUTION_ERROR_BRAND, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+};
+function isCommandNotFoundError(error) {
+  if (error instanceof CommandNotFoundError)
+    return true;
+  if (!isRecord2(error) || !hasCommandNotFoundErrorShape(error))
+    return false;
+  if (Object.hasOwn(error, COMMAND_NOT_FOUND_ERROR_BRAND) && error[COMMAND_NOT_FOUND_ERROR_BRAND] === true)
+    return true;
+  return error instanceof Error && error.name === "CommandNotFoundError";
+}
+function isCommandResolutionError(error) {
+  if (error instanceof CommandResolutionError)
+    return true;
+  if (!isRecord2(error) || !hasCommandResolutionErrorShape(error))
+    return false;
+  return Object.hasOwn(error, COMMAND_RESOLUTION_ERROR_BRAND) && error[COMMAND_RESOLUTION_ERROR_BRAND] === true;
+}
+function isArgsValidationError2(error) {
+  if (error instanceof ArgsValidationError)
+    return true;
+  if (!isRecord2(error) || !hasArgsValidationErrorShape(error))
+    return false;
+  if (isArgsValidationError(error))
+    return true;
+  return error instanceof Error && error.name === "ArgsValidationError";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasOptionalStringCode(error) {
+  return "code" in error && (error.code === undefined || typeof error.code === "string");
+}
+function hasCommandNotFoundErrorShape(error) {
+  return hasOptionalStringCode(error) && isRecord2(error.values) && typeof error.commandName === "string" && isStringArray(error.candidates) && isStringArray(error.commandPath);
+}
+function hasCommandResolutionErrorShape(error) {
+  return hasOptionalStringCode(error) && isRecord2(error.values) && isStringArray(error.commandPath) && Array.isArray(error.candidatePaths) && error.candidatePaths.every((path) => isStringArray(path));
+}
+function hasArgsValidationErrorShape(error) {
+  return hasOptionalStringCode(error) && isRecord2(error.values);
+}
+function hasPriorityValidationError(error) {
+  return error?.errors.some((error) => isCommandNotFoundError(error) || isCommandResolutionError(error) || isArgsValidationError2(error) && error.code === ArgsValidationErrorKeys.unknownOption) ?? false;
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/core-EDPnjwxe.js
+var EMPTY_RENDERER = () => Promise.resolve("");
+function createDecorators() {
+  const headerDecorators = [];
+  const usageDecorators = [];
+  const validationDecorators = [];
+  const commandDecorators = [];
+  function buildRenderer(decorators, defaultRenderer) {
+    if (decorators.length === 0)
+      return defaultRenderer;
+    let renderer = defaultRenderer;
+    for (const decorator of decorators) {
+      const previousRenderer = renderer;
+      renderer = (ctx) => decorator(previousRenderer, ctx);
+    }
+    return renderer;
+  }
+  return Object.freeze({
+    addHeaderDecorator(decorator) {
+      headerDecorators.push(decorator);
+    },
+    addUsageDecorator(decorator) {
+      usageDecorators.push(decorator);
+    },
+    addValidationErrorsDecorator(decorator) {
+      validationDecorators.push(decorator);
+    },
+    addCommandDecorator(decorator) {
+      commandDecorators.push(decorator);
+    },
+    get commandDecorators() {
+      return [...commandDecorators];
+    },
+    getHeaderRenderer() {
+      return buildRenderer(headerDecorators, EMPTY_RENDERER);
+    },
+    getUsageRenderer() {
+      return buildRenderer(usageDecorators, EMPTY_RENDERER);
+    },
+    getValidationErrorsRenderer() {
+      if (validationDecorators.length === 0)
+        return EMPTY_RENDERER;
+      let renderer = EMPTY_RENDERER;
+      for (const decorator of validationDecorators) {
+        const previousRenderer = renderer;
+        renderer = (ctx, error) => decorator(previousRenderer, ctx, error);
+      }
+      return renderer;
+    }
+  });
+}
+function createPluginContext(decorators, initialSubCommands) {
+  const globalOptions = /* @__PURE__ */ new Map;
+  const subCommands = new Map(initialSubCommands || []);
+  return Object.freeze({
+    get globalOptions() {
+      return new Map(globalOptions);
+    },
+    addGlobalOption(name, schema) {
+      if (!name)
+        throw new Error("Option name must be a non-empty string");
+      if (globalOptions.has(name))
+        throw new Error(`Global option '${name}' is already registered`);
+      const taken = schema.short && findGlobalOptionByShort(globalOptions, schema.short);
+      if (taken) {
+        console.warn(`Short name '-${schema.short}' of the global option '${name}' is already used by '${taken}'. Global option '${name}' is registered without it.`);
+        globalOptions.set(name, {
+          ...schema,
+          short: undefined
+        });
+        return;
+      }
+      globalOptions.set(name, schema);
+    },
+    get subCommands() {
+      return new Map(subCommands);
+    },
+    addCommand(name, command) {
+      if (!name)
+        throw new Error("Command name must be a non-empty string");
+      if (subCommands.has(name))
+        throw new Error(`Command '${name}' is already registered`);
+      subCommands.set(name, command);
+    },
+    hasCommand(name) {
+      return subCommands.has(name);
+    },
+    decorateHeaderRenderer(decorator) {
+      decorators.addHeaderDecorator(decorator);
+    },
+    decorateUsageRenderer(decorator) {
+      decorators.addUsageDecorator(decorator);
+    },
+    decorateValidationErrorsRenderer(decorator) {
+      decorators.addValidationErrorsDecorator(decorator);
+    },
+    decorateCommand(decorator) {
+      decorators.addCommandDecorator(decorator);
+    }
+  });
+}
+function findGlobalOptionByShort(globalOptions, short) {
+  for (const [name, schema] of globalOptions)
+    if (schema.short === short)
+      return name;
+}
+function resolveDependencies(plugins) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set;
+  const visiting = /* @__PURE__ */ new Set;
+  const pluginMap = /* @__PURE__ */ new Map;
+  for (const plugin of plugins) {
+    if (typeof plugin.id !== "string" || plugin.id.length === 0)
+      throw new Error("Plugin id must be a non-empty string");
+    if (pluginMap.has(plugin.id))
+      console.warn(`Duplicate plugin id detected: \`${plugin.id}\``);
+    pluginMap.set(plugin.id, plugin);
+  }
+  function visit(plugin) {
+    if (typeof plugin.id !== "string" || plugin.id.length === 0)
+      throw new Error("Plugin id must be a non-empty string");
+    if (visited.has(plugin.id))
+      return;
+    if (visiting.has(plugin.id))
+      throw new Error(`Circular dependency detected: \`${[...visiting].join(` -> `) + " -> " + plugin.id}\``);
+    visiting.add(plugin.id);
+    const deps = plugin.dependencies || [];
+    for (const dep of deps) {
+      const depId = typeof dep === "string" ? dep : dep.id;
+      const isOptional = typeof dep === "string" ? false : dep.optional || false;
+      const depPlugin = pluginMap.get(depId);
+      if (!depPlugin && !isOptional)
+        throw new Error(`Missing required dependency: \`${depId}\` on \`${plugin.id}\``);
+      if (depPlugin)
+        visit(depPlugin);
+    }
+    visiting.delete(plugin.id);
+    visited.add(plugin.id);
+    sorted.push(plugin);
+  }
+  for (const plugin of plugins)
+    visit(plugin);
+  return sorted;
+}
+function resolveCommandArgs(globalOptions, args) {
+  return Object.assign(create(), resolveGlobalOptions(globalOptions, args), args);
+}
+function resolveGlobalOptions(globalOptions, args) {
+  if (!globalOptions)
+    return;
+  const shortNames = /* @__PURE__ */ new Set;
+  for (const schema of Object.values(args || {}))
+    if (schema.type !== "positional" && schema.short)
+      shortNames.add(schema.short);
+  const resolved = create();
+  for (const [name, schema] of globalOptions)
+    resolved[name] = schema.short && shortNames.has(schema.short) ? {
+      ...schema,
+      short: undefined
+    } : schema;
+  return resolved;
+}
+async function cliCore(argv, entry, options, plugins, usageOnly = false) {
+  const decorators = createDecorators();
+  if (usageOnly)
+    decorators.addCommandDecorator(usageOnlyDecorator());
+  const entryCommand = createEntryCommand(entry);
+  const initialSubCommands = createInitialSubCommands(options, entryCommand);
+  const pluginContext = createPluginContext(decorators, initialSubCommands);
+  const resolvedPlugins = await applyPlugins(pluginContext, [...plugins, ...options.plugins || []]);
+  const cliOptions = normalizeCliOptions(options, decorators, pluginContext, entryCommand);
+  if (initialSubCommands.size === 0 && cliOptions.subCommands.size > 0 && options.fallbackToEntry === undefined)
+    cliOptions.fallbackToEntry = true;
+  const tokens = parseArgs(argv);
+  const selection = resolveCommandSelection(tokens, entry, cliOptions, pluginContext.globalOptions);
+  const resolved = selection.context;
+  const { commandName: name, command, callMode, commandPath, depth, levelSubCommands } = resolved;
+  let targetCommand = command;
+  let targetCommandName = name;
+  let targetCallMode = callMode;
+  let targetCommandPath = commandPath;
+  let targetDepth = depth;
+  let targetOmitted = resolved.omitted;
+  let targetLevelSubCommands = levelSubCommands;
+  const additionalValidationErrors = selection.error ? [selection.error] : [];
+  if (!targetCommand) {
+    if (!resolved.parentCommand || !resolved.unresolvedCommandName)
+      throw new Error(`Command not found: ${name || ""}`);
+    targetCommand = resolved.parentCommand;
+    targetCommandName = resolved.parentCommandName;
+    targetCommandPath = resolved.parentCommandPath || [];
+    targetDepth = targetCommandPath.length;
+    targetCallMode = targetDepth > 0 ? "subCommand" : "entry";
+    targetOmitted = false;
+    targetLevelSubCommands = resolved.parentSubCommands;
+    additionalValidationErrors.push(createCommandNotFoundError(resolved));
+  }
+  const routingOptions = Object.assign(create(), cliOptions, { subCommands: new Map(cliOptions.subCommands) });
+  if (targetLevelSubCommands)
+    cliOptions.subCommands = targetLevelSubCommands;
+  const resolvedCommand = isLazyCommand(targetCommand) ? await resolveLazyCommand(targetCommand, targetCommandName, true) : targetCommand;
+  if (selection.error == null && isLazyCommand(targetCommand)) {
+    const loaded = resolveCommandTreeFromPositionals(getRoutingPositionals(tokens, pluginContext.globalOptions, resolvedCommand), entry, routingOptions);
+    if (!sameCommandPath(loaded.commandPath, targetCommandPath))
+      additionalValidationErrors.push(createLazySchemaMismatchError(targetCommandPath, loaded.commandPath));
+  }
+  const commandArgs = getCommandArgs(resolvedCommand);
+  const args = resolveCommandArgs(pluginContext.globalOptions, commandArgs);
+  cliOptions.globalOptions = resolveEffectiveGlobalOptions(pluginContext.globalOptions, commandArgs, args);
+  const skipPositional = resolveSkipPositional(tokens, pluginContext.globalOptions, resolvedCommand, targetDepth);
+  const diagnostic = selection.diagnostic === true;
+  const { explicit, values, positionals, rest, error } = diagnostic ? {
+    explicit: create(),
+    values: create(),
+    positionals: [],
+    rest: [],
+    error: undefined
+  } : resolveArgs(args, tokens, {
+    shortGrouping: true,
+    toKebab: resolvedCommand.toKebab,
+    skipPositional
+  });
+  const validationError = mergeValidationErrors(error, [...additionalValidationErrors, ...cliOptions.strict && !diagnostic ? createUnknownOptionErrors(findUnknownOptions(args, tokens, { toKebab: resolvedCommand.toKebab })) : []]);
+  return await executeCommand(resolvedCommand, await createCommandContext({
+    args,
+    explicit,
+    values,
+    positionals,
+    rest,
+    argv,
+    tokens,
+    omitted: targetOmitted,
+    callMode: targetCallMode,
+    commandPath: targetCommandPath,
+    command: resolvedCommand,
+    extensions: getPluginExtensions(resolvedPlugins),
+    validationError,
+    cliOptions
+  }), decorators.commandDecorators);
+}
+function usageOnlyDecorator() {
+  return () => async (ctx) => {
+    if (hasPriorityValidationError(ctx.validationError))
+      throw ctx.validationError;
+    const buf = [];
+    if (ctx.env.renderHeader != null) {
+      const header = await ctx.env.renderHeader(ctx);
+      if (header)
+        buf.push(header);
+    }
+    if (ctx.env.renderUsage == null)
+      return;
+    const usage = await ctx.env.renderUsage(ctx);
+    if (!usage)
+      return;
+    buf.push(usage);
+    return buf.join(`
+`);
+  };
+}
+async function applyPlugins(pluginContext, plugins) {
+  const sortedPlugins = resolveDependencies(plugins);
+  for (const plugin of sortedPlugins)
+    try {
+      await plugin(pluginContext);
+    } catch (error) {
+      throw new Error(`Failed to install the plugin \`${plugin.id}\``, { cause: error });
+    }
+  return sortedPlugins;
+}
+function resolveEffectiveGlobalOptions(globalOptions, commandArgs, args) {
+  const effective = /* @__PURE__ */ new Map;
+  for (const name of globalOptions.keys())
+    if (!Object.hasOwn(commandArgs, name))
+      effective.set(name, args[name]);
+  return effective;
+}
+function getCommandArgs(cmd) {
+  if (isLazyCommand(cmd))
+    return cmd.args || create();
+  else if (typeof cmd === "object")
+    return cmd.args || create();
+  else
+    return create();
+}
+var NEGATABLE_OPTION_PREFIX = "no-";
+function findUnknownOptions(args, tokens, options) {
+  const knownLongOptions = /* @__PURE__ */ new Set;
+  const knownShortOptions = /* @__PURE__ */ new Set;
+  const knownNegatableOptions = /* @__PURE__ */ new Set;
+  const knownLongOptionCandidates = /* @__PURE__ */ new Set;
+  const longOptionCandidates = [];
+  function addLongOptionCandidate(name) {
+    const candidate = `--${name}`;
+    if (knownLongOptionCandidates.has(candidate))
+      return;
+    knownLongOptionCandidates.add(candidate);
+    longOptionCandidates.push(candidate);
+  }
+  for (const [name, schema] of Object.entries(args)) {
+    if (schema.type === "positional")
+      continue;
+    const optionName = resolveOptionName(name, schema, options);
+    knownLongOptions.add(optionName);
+    if (!schema.hidden)
+      addLongOptionCandidate(optionName);
+    if (schema.short)
+      knownShortOptions.add(schema.short);
+    if (schema.type === "boolean" && schema.negatable) {
+      const negatableOptionName = `${NEGATABLE_OPTION_PREFIX}${optionName}`;
+      knownNegatableOptions.add(negatableOptionName);
+      if (!schema.hidden)
+        addLongOptionCandidate(negatableOptionName);
+    }
+  }
+  const unknownOptions = [];
+  for (const token of tokens) {
+    if (token.kind === "option-terminator")
+      break;
+    if (token.kind !== "option" || !token.name || !token.rawName)
+      continue;
+    const isLongOption = token.rawName.startsWith("--");
+    if (isLongOption) {
+      if (knownLongOptions.has(token.name) || knownNegatableOptions.has(token.name))
+        continue;
+    } else if (knownShortOptions.has(token.name))
+      continue;
+    unknownOptions.push({
+      rawName: token.rawName,
+      name: token.name,
+      candidates: isLongOption ? longOptionCandidates : []
+    });
+  }
+  return unknownOptions;
+}
+function resolveOptionName(name, schema, options) {
+  return options.toKebab || schema.toKebab ? kebabnize(name) : name;
+}
+function createUnknownOptionErrors(unknownOptions) {
+  return unknownOptions.map(({ rawName, name, candidates }) => {
+    return new ArgsValidationError(`Unknown option: ${rawName}`, {
+      code: ArgsValidationErrorKeys.unknownOption,
+      values: {
+        rawName,
+        name,
+        candidates
+      }
+    });
+  });
+}
+function mergeValidationErrors(error, additionalErrors) {
+  if (additionalErrors.length === 0)
+    return error;
+  return new AggregateError(error ? [...error.errors, ...additionalErrors] : additionalErrors, error?.message || additionalErrors[0]?.message);
+}
+var isObject = (val) => val !== null && typeof val === "object";
+function createEntryCommand(entryCmd) {
+  if (isLazyCommand(entryCmd))
+    return Object.assign((...args) => entryCmd(...args), entryCmd, { entry: true });
+  else if (typeof entryCmd === "object")
+    return Object.assign(create(), entryCmd, { entry: true });
+  else if (typeof entryCmd === "function")
+    return {
+      run: entryCmd,
+      name: entryCmd.name || "(anonymous)",
+      entry: true
+    };
+}
+function createInitialSubCommands(options, entryCommand) {
+  const hasSubCommands = options.subCommands ? options.subCommands instanceof Map ? options.subCommands.size > 0 : isObject(options.subCommands) && Object.keys(options.subCommands).length > 0 : false;
+  const subCommands = new Map(options.subCommands instanceof Map ? options.subCommands : []);
+  if (!(options.subCommands instanceof Map) && isObject(options.subCommands))
+    for (const [name, cmd] of Object.entries(options.subCommands))
+      subCommands.set(name, cmd);
+  if (hasSubCommands && entryCommand)
+    subCommands.set(resolveEntryName(entryCommand), entryCommand);
+  return subCommands;
+}
+function normalizeCliOptions(options, decorators, pluginContext, entryCommand) {
+  const subCommands = new Map(pluginContext.subCommands);
+  const resolvedOptions = Object.assign(create(), CLI_OPTIONS_DEFAULT, options, {
+    subCommands,
+    entryCommand
+  });
+  if (resolvedOptions.renderHeader === undefined)
+    resolvedOptions.renderHeader = decorators.getHeaderRenderer();
+  if (resolvedOptions.renderUsage === undefined)
+    resolvedOptions.renderUsage = decorators.getUsageRenderer();
+  if (resolvedOptions.renderValidationErrors === undefined)
+    resolvedOptions.renderValidationErrors = decorators.getValidationErrorsRenderer();
+  return resolvedOptions;
+}
+function getPositionalTokens(tokens) {
+  const positionals = [];
+  for (const token of tokens) {
+    if (token.kind === "option-terminator")
+      break;
+    if (token.kind === "positional" && token.value)
+      positionals.push(token.value);
+  }
+  return positionals;
+}
+function resolveCommandTree(tokens, entry, options) {
+  return resolveCommandTreeFromPositionals(getPositionalTokens(tokens), entry, options);
+}
+function resolveCommandTreeFromPositionals(positionals, entry, options) {
+  function resolveAsEntry() {
+    if (typeof entry === "function") {
+      if (isLazyCommand(entry))
+        return {
+          commandName: resolveEntryName(entry),
+          command: entry,
+          callMode: "entry",
+          commandPath: [],
+          depth: 0,
+          omitted: options.subCommands.size > 0 && !positionals[0],
+          levelSubCommands: options.subCommands.size > 0 ? options.subCommands : undefined
+        };
+      else
+        return {
+          command: {
+            run: entry,
+            entry: true
+          },
+          callMode: "entry",
+          commandPath: [],
+          depth: 0,
+          omitted: options.subCommands.size > 0 && !positionals[0],
+          levelSubCommands: options.subCommands.size > 0 ? options.subCommands : undefined
+        };
+    } else if (typeof entry === "object")
+      return {
+        commandName: resolveEntryName(entry),
+        command: entry,
+        callMode: "entry",
+        commandPath: [],
+        depth: 0,
+        omitted: options.subCommands.size > 0 && !positionals[0],
+        levelSubCommands: options.subCommands.size > 0 ? options.subCommands : undefined
+      };
+    else
+      return {
+        callMode: "unexpected",
+        commandPath: [],
+        depth: 0,
+        omitted: false,
+        levelSubCommands: undefined
+      };
+  }
+  if (positionals.length === 0 || options.subCommands.size === 0)
+    return resolveAsEntry();
+  let currentSubCommands = options.subCommands;
+  let resolvedCommand;
+  let resolvedName;
+  const commandPath = [];
+  let depth = 0;
+  for (let i = 0;i < positionals.length; i++) {
+    const token = positionals[i];
+    const cmd = currentSubCommands.get(token);
+    if (cmd == null) {
+      if (depth === 0) {
+        if (options.fallbackToEntry)
+          return resolveAsEntry();
+        const parent = resolveAsEntry();
+        return {
+          commandName: token,
+          callMode: "unexpected",
+          commandPath: [],
+          depth: 0,
+          omitted: false,
+          levelSubCommands: undefined,
+          unresolvedCommandName: token,
+          parentCommand: parent.command,
+          parentCommandName: parent.commandName,
+          parentCommandPath: [],
+          parentSubCommands: options.subCommands
+        };
+      }
+      return {
+        commandName: token,
+        callMode: "unexpected",
+        commandPath: [...commandPath],
+        depth,
+        omitted: false,
+        levelSubCommands: undefined,
+        unresolvedCommandName: token,
+        parentCommand: resolvedCommand,
+        parentCommandName: resolvedName,
+        parentCommandPath: [...commandPath],
+        parentSubCommands: currentSubCommands
+      };
+    }
+    let resolved = cmd;
+    if (typeof cmd === "function" && cmd.commandName == null)
+      resolved = Object.assign((...args) => cmd(...args), cmd, { commandName: token });
+    else if (typeof cmd === "object" && cmd.name == null)
+      resolved = Object.assign(create(), cmd, { name: token });
+    resolvedCommand = resolved;
+    resolvedName = token;
+    commandPath.push(token);
+    depth++;
+    const nestedSubCommands = getCommandSubCommands(cmd);
+    if (nestedSubCommands && nestedSubCommands.size > 0)
+      currentSubCommands = nestedSubCommands;
+    else
+      break;
+  }
+  if (!resolvedCommand)
+    return resolveAsEntry();
+  const resolvedSubCommands = getCommandSubCommands(resolvedCommand);
+  const omitted = resolvedSubCommands != null && resolvedSubCommands.size > 0;
+  let levelSubCommands;
+  if (omitted && resolvedSubCommands) {
+    levelSubCommands = new Map(resolvedSubCommands);
+    let entryCopy;
+    if (typeof resolvedCommand === "function")
+      entryCopy = Object.assign((...args) => resolvedCommand(...args), resolvedCommand, { entry: true });
+    else
+      entryCopy = Object.assign(create(), resolvedCommand, { entry: true });
+    levelSubCommands.set(resolvedName || resolveEntryName(entryCopy), entryCopy);
+  }
+  return {
+    commandName: resolvedName,
+    command: resolvedCommand,
+    callMode: depth > 0 ? "subCommand" : "entry",
+    commandPath,
+    depth,
+    omitted,
+    levelSubCommands
+  };
+}
+function resolveCommandSelection(tokens, entry, options, globalOptions) {
+  const rawPositionals = getPositionalTokens(tokens);
+  const legacy = resolveCommandTree(tokens, entry, options);
+  if (!tokens.some((token) => token.kind === "option"))
+    return { context: legacy };
+  const candidates = collectRoutingCandidates(rawPositionals, options.subCommands);
+  const evaluations = candidates.map((candidate) => evaluateRoutingCandidate(candidate));
+  const validExplicit = evaluations.filter((evaluation) => evaluation.result.command != null && evaluation.result.unresolvedCommandName == null && sameCommandPath(evaluation.result.commandPath, evaluation.path) && evaluation.path.length > 0);
+  if (legacy.command != null && legacy.unresolvedCommandName == null && legacy.commandPath.length > 0) {
+    const legacyMatch = validExplicit.find((evaluation) => sameCommandPath(evaluation.path, legacy.commandPath));
+    if (legacyMatch)
+      return { context: legacyMatch.result };
+  }
+  if (validExplicit.length === 1)
+    return { context: validExplicit[0].result };
+  if (validExplicit.length > 1)
+    return createCommandResolutionResult(options, entry, CommandResolutionErrorKeys.ambiguous, validExplicit.map((evaluation) => evaluation.path));
+  const entryEvaluation = evaluateRoutingCandidate({
+    path: [],
+    command: getEntryRoutingCommand(entry, options)
+  });
+  if (entryEvaluation.result.command != null && entryEvaluation.result.unresolvedCommandName == null && entryEvaluation.result.commandPath.length === 0)
+    return { context: entryEvaluation.result };
+  const failures = evaluations.filter((evaluation) => {
+    const { result } = evaluation;
+    if (!result.unresolvedCommandName)
+      return false;
+    const parentPath = result.parentCommandPath || [];
+    return isPathPrefix(evaluation.path, parentPath);
+  }).map((evaluation) => evaluation.result);
+  if (entryEvaluation.result.unresolvedCommandName)
+    failures.push(entryEvaluation.result);
+  const deepestFailures = selectDeepestFailures(failures);
+  if (deepestFailures.length === 1)
+    return { context: deepestFailures[0] };
+  if (deepestFailures.length > 1) {
+    const paths = deepestFailures.map((result) => result.parentCommandPath || []);
+    return createCommandResolutionResult(options, entry, CommandResolutionErrorKeys.ambiguous, paths);
+  }
+  return createCommandResolutionResult(options, entry, CommandResolutionErrorKeys.inconsistentOptions, candidates.map((candidate) => candidate.path));
+  function evaluateRoutingCandidate(candidate) {
+    const positionals = getRoutingPositionals(tokens, globalOptions, candidate.command);
+    return {
+      ...candidate,
+      positionals,
+      result: resolveCommandTreeFromPositionals(positionals, entry, options)
+    };
+  }
+}
+function collectRoutingCandidates(rawPositionals, root) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set;
+  function collect(commands, offset, parentPath) {
+    for (let index = offset;index < rawPositionals.length; index++) {
+      const name = rawPositionals[index];
+      const command = commands.get(name);
+      if (command == null)
+        continue;
+      const path = [...parentPath, name];
+      const key = JSON.stringify(path);
+      const normalized = normalizeCommandReference(command, name);
+      if (!seen.has(key)) {
+        seen.add(key);
+        candidates.push({
+          path,
+          command: normalized
+        });
+      }
+      const nested = getCommandSubCommands(normalized);
+      if (nested && nested.size > 0)
+        collect(nested, index + 1, path);
+    }
+  }
+  collect(root, 0, []);
+  return candidates;
+}
+function normalizeCommandReference(command, name) {
+  if (typeof command === "function" && command.commandName == null)
+    return Object.assign((...args) => command(...args), command, { commandName: name });
+  if (typeof command === "object" && command.name == null)
+    return Object.assign(create(), command, { name });
+  return command;
+}
+function getEntryRoutingCommand(entry, options) {
+  if (options.entryCommand)
+    return options.entryCommand;
+  if (typeof entry === "function" && !isLazyCommand(entry))
+    return {
+      run: entry,
+      entry: true
+    };
+  return entry;
+}
+function getRoutingPositionals(tokens, globalOptions, command) {
+  return readPositionals(tokens, globalOptions, command).filter((value) => value !== "");
+}
+function readPositionals(tokens, globalOptions, command) {
+  const effective = resolveCommandArgs(globalOptions, getCommandArgs(command));
+  const routingArgs = create();
+  for (const [name, schema] of Object.entries(effective)) {
+    if (schema.type === "positional")
+      continue;
+    routingArgs[name] = {
+      type: schema.type === "boolean" ? "boolean" : "string",
+      short: schema.short,
+      negatable: schema.negatable,
+      toKebab: schema.toKebab
+    };
+  }
+  return resolveArgs(routingArgs, tokens, {
+    shortGrouping: true,
+    toKebab: command.toKebab
+  }).positionals;
+}
+function resolveSkipPositional(tokens, globalOptions, command, depth) {
+  if (depth === 0)
+    return -1;
+  if (!tokens.some((token) => token.kind === "positional" && token.value === ""))
+    return depth - 1;
+  let names = 0;
+  for (const [index, value] of readPositionals(tokens, globalOptions, command).entries()) {
+    if (value === "")
+      continue;
+    names++;
+    if (names === depth)
+      return index;
+  }
+  return depth - 1;
+}
+function sameCommandPath(left, right) {
+  return left.length === right.length && left.every((name, index) => name === right[index]);
+}
+function isPathPrefix(prefix, path) {
+  return prefix.length <= path.length && prefix.every((name, index) => name === path[index]);
+}
+function selectDeepestFailures(failures) {
+  const unique = /* @__PURE__ */ new Map;
+  for (const failure of failures) {
+    const path = failure.parentCommandPath || [];
+    const key = JSON.stringify(path);
+    unique.set(key, failure);
+  }
+  const deepest = Math.max(-1, ...[...unique.values()].map((failure) => (failure.parentCommandPath || []).length));
+  return [...unique.values()].filter((failure) => (failure.parentCommandPath || []).length === deepest);
+}
+function createCommandResolutionResult(options, entry, code, candidatePaths) {
+  const normalizedPaths = candidatePaths.map((path) => [...path]);
+  const commandPath = commonCommandPath(normalizedPaths);
+  const parent = resolveCommandTreeFromPositionals(commandPath, entry, options);
+  const command = createDiagnosticCommand(parent.command, commandPath.at(-1));
+  const context = {
+    ...parent,
+    command,
+    commandPath,
+    depth: commandPath.length,
+    commandName: parent.commandName || commandPath.at(-1),
+    callMode: commandPath.length > 0 ? "subCommand" : "entry",
+    omitted: false
+  };
+  const formattedPaths = normalizedPaths.map((path) => path.join(" ")).join(", ");
+  const formattedPath = commandPath.join(" ");
+  const values = {
+    commandPath: formattedPath,
+    candidatePaths: formattedPaths,
+    candidates: formattedPaths
+  };
+  const message = createCommandResolutionMessage(code, formattedPath, formattedPaths);
+  return {
+    context,
+    error: new CommandResolutionError(message, {
+      code,
+      values,
+      commandPath,
+      candidatePaths: normalizedPaths
+    }),
+    diagnostic: true
+  };
+}
+function commonCommandPath(paths) {
+  if (paths.length === 0)
+    return [];
+  const common = [...paths[0]];
+  for (const path of paths.slice(1)) {
+    let length = 0;
+    while (length < common.length && length < path.length && common[length] === path[length])
+      length++;
+    common.length = length;
+  }
+  return common;
+}
+function createDiagnosticCommand(command, name) {
+  if (typeof command === "function")
+    return Object.assign(create(), command, {
+      name: command.commandName || name,
+      run: undefined
+    });
+  return Object.assign(create(), command || {}, {
+    name: command?.name || name,
+    run: undefined
+  });
+}
+function createCommandResolutionMessage(code, commandPath, candidatePaths) {
+  switch (code) {
+    case CommandResolutionErrorKeys.ambiguous:
+      return `Ambiguous command resolution. Move options after the command name: ${candidatePaths}`;
+    case CommandResolutionErrorKeys.lazySchemaMismatch:
+      return `Lazy command schema mismatch at ${commandPath}. Declare leading options in the lazy definition or move options after the command name.`;
+    default:
+      return "The options do not identify a consistent command. Move options after the command name.";
+  }
+}
+function createLazySchemaMismatchError(commandPath, loadedPath) {
+  const expected = [...commandPath];
+  const actual = [...loadedPath];
+  return new CommandResolutionError(`Lazy command schema mismatch at ${expected.join(" ")}. Declare leading options in the lazy definition or move options after the command name.`, {
+    code: CommandResolutionErrorKeys.lazySchemaMismatch,
+    values: {
+      commandPath: expected.join(" "),
+      loadedCommandPath: actual.join(" ")
+    },
+    commandPath: expected,
+    candidatePaths: [expected, actual]
+  });
+}
+function createCommandNotFoundError(resolved) {
+  const commandName = resolved.unresolvedCommandName || resolved.commandName || "";
+  return new CommandNotFoundError(`Command not found: ${commandName}`, {
+    code: CommandNotFoundErrorKeys.notFound,
+    values: { commandName },
+    commandName,
+    candidates: [...resolved.parentSubCommands?.keys() || []],
+    commandPath: resolved.parentCommandPath || []
+  });
+}
+function resolveEntryName(entry) {
+  return isLazyCommand(entry) ? entry.commandName || "(anonymous)" : entry.name || "(anonymous)";
+}
+function getPluginExtensions(plugins) {
+  const extensions = create();
+  for (const plugin of plugins)
+    if (plugin.extension) {
+      const key = plugin.id;
+      if (extensions[key])
+        console.warn(`Plugin "${key}" is already installed. Ignore it for command context extending.`);
+      else
+        extensions[key] = plugin.extension;
+    }
+  return extensions;
+}
+async function executeCommand(cmd, ctx, decorators) {
+  const commandRunner = cmd.run || NOOP;
+  const baseRunner = (ctx) => {
+    if (hasPriorityValidationError(ctx.validationError))
+      throw ctx.validationError;
+    return commandRunner(ctx);
+  };
+  const decoratedRunner = decorators.reduceRight((runner, decorator) => decorator(runner), baseRunner);
+  try {
+    if (ctx.env.onBeforeCommand)
+      await ctx.env.onBeforeCommand(ctx);
+    const result = await decoratedRunner(ctx);
+    if (ctx.env.onAfterCommand)
+      await ctx.env.onAfterCommand(ctx, result);
+    return typeof result === "string" ? result : undefined;
+  } catch (error) {
+    if (ctx.env.onErrorCommand)
+      try {
+        await ctx.env.onErrorCommand(ctx, error);
+      } catch (hookError) {
+        console.error("Error in onErrorCommand hook:", hookError);
+      }
+    throw error;
+  }
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/bone.js
+async function cli(args, entry, options = {}) {
+  return cliCore(args, entry, options, []);
+}
+
+// ../../node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/definition.js
+function define(definition) {
+  return definition;
+}
+
+// src/parse-cli-args.ts
+async function parseCLIArgs(argv) {
+  let parsed = null;
+  const command = define({
+    name: "zgeoff-check",
+    args: {
+      help: { type: "boolean", short: "h", default: false }
+    },
+    run: (ctx) => {
+      if (ctx.validationError !== undefined) {
+        throw ctx.validationError;
+      }
+      parsed = { help: ctx.values.help, files: [...ctx.positionals, ...ctx.rest] };
+    }
+  });
+  try {
+    await cli([...argv], command, { strict: true });
+  } catch (error) {
+    return formatParseError(error);
+  }
+  if (parsed === null) {
+    return "the command line could not be parsed";
+  }
+  const args = parsed;
+  if (args.help && args.files.length > 0) {
+    return "--help takes no files";
+  }
+  return args;
+}
+function formatParseError(error) {
+  if (error instanceof AggregateError) {
+    return error.errors.map((reason) => formatParseError(reason)).join(`
+`);
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/run-checks.ts
+import { statSync } from "fs";
+import { isAbsolute, relative, resolve } from "path";
+async function runChecks(options) {
+  const files = (options.files ?? runGitLsFiles(options)).map((file) => toRepoPath(options.cwd, file)).filter((file) => checkPathExists(options.cwd, file));
+  const findings = [];
+  for (const check of options.checks) {
+    if (options.config.off.has(check.name)) {
+      continue;
+    }
+    const glob = new Bun.Glob(check.glob);
+    const matched = files.filter((file) => glob.match(file));
+    if (matched.length === 0) {
+      continue;
+    }
+    const checkFindings = await check.check({ cwd: options.cwd, files: matched, env: options.env });
+    findings.push(...checkFindings.toSorted((a, b) => a.path.localeCompare(b.path) || a.line - b.line).map((finding) => ({
+      check: check.name,
+      path: finding.path,
+      line: finding.line,
+      message: finding.message
+    })));
+  }
+  return findings;
+}
+function runGitLsFiles(options) {
+  const result = Bun.spawnSync(["git", "ls-files", "-z"], {
+    cwd: options.cwd,
+    env: { ...options.env },
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`git ls-files failed: ${result.stderr.toString().trim()}`);
+  }
+  return result.stdout.toString().split("\x00").filter((file) => file !== "");
+}
+function checkPathExists(cwd, file) {
+  try {
+    statSync(resolve(cwd, file));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return false;
+    }
+    throw error;
+  }
+  return true;
+}
+function toRepoPath(cwd, file) {
+  const path = relative(cwd, resolve(cwd, file));
+  return isAbsolute(path) ? file : path;
+}
+
+// src/run-git-show-toplevel.ts
+function runGitShowToplevel(cwd, env) {
+  if (Bun.which("git", { PATH: env["PATH"] ?? "" }) === null) {
+    return cwd;
+  }
+  const result = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+    cwd,
+    env: { ...env },
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return result.exitCode === 0 ? result.stdout.toString().trim() : cwd;
+}
+
+// src/cli.ts
+var USAGE = `usage: zgeoff-check [--] [file ...]
+
+Runs every check over the files that git tracks, or over the files given.
+Each finding prints as path:line: <check>: <message>, with the path from the repo root.
+Exits 0 with no finding, 1 with any finding, and 2 when the run could not finish.
+Checks: ${allChecks.map((check) => check.name).join(", ")}`;
+var parsed = await parseCLIArgs(process.argv.slice(2));
+if (typeof parsed === "string") {
+  process.stderr.write(`zgeoff-check: ${parsed}
+${USAGE}
+`);
+  process.exit(2);
+}
+if (parsed.help) {
+  process.stdout.write(`${USAGE}
+`);
+  process.exit(0);
+}
+var files = parsed.files;
+try {
+  const root = runGitShowToplevel(process.cwd(), process.env);
+  const config = loadConfig(root, allChecks.map((check) => check.name));
+  const findings = await runChecks({
+    cwd: root,
+    checks: allChecks,
+    config,
+    env: process.env,
+    ...files.length === 0 ? {} : { files: files.map((file) => resolve2(file)) }
+  });
+  for (const finding of findings) {
+    process.stdout.write(`${finding.path}:${finding.line}: ${finding.check}: ${finding.message}
+`);
+  }
+  const exitCode = findings.length === 0 ? 0 : 1;
+  process.exit(exitCode);
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`zgeoff-check: ${message}
+`);
+  process.exit(2);
+}