@kaynooo/pkg-tools 0.2.1 → 0.3.0

package/dist/cli.js

@@ -1,18 +1,30 @@
 #!/usr/bin/env bun
 // @bun
-
-// src/cli.ts
-import process7 from "process";
-
-// ../kit/src/args.ts
-import process3 from "process";
-import { parseArgs } from "util";
-
-// ../kit/src/format.ts
-import process2 from "process";
-
-// ../kit/src/style.ts
-import process from "process";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 
 // ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
 function x(s) {
@@ -94,9 +106,6 @@ function O(s) {
 function v(s, r, t, n) {
   return s /= 100, r /= 100, t /= 100, n /= 100, [Math.round(255 * (1 - s) * (1 - n)), Math.round(255 * (1 - r) * (1 - n)), Math.round(255 * (1 - t) * (1 - n))];
 }
-var m = (s) => s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
-var p = (s) => s <= 0.0031308 ? 12.92 * s : 1.055 * s ** 0.4166666666666667 - 0.055;
-var i = (s, r) => Math.round(s * 10 ** r) / 10 ** r;
 function T(s) {
   let r = m(s[0] / 255), t = m(s[1] / 255), n = m(s[2] / 255), a = Math.cbrt(0.4122214708 * r + 0.5363325363 * t + 0.0514459929 * n), b = Math.cbrt(0.2119034982 * r + 0.6806995451 * t + 0.1073969566 * n), o = Math.cbrt(0.0883024619 * r + 0.2817188376 * t + 0.6299787005 * n);
   return [i(0.2104542553 * a + 0.793617785 * b - 0.0040720468 * o, 4), i(1.9779984951 * a - 2.428592205 * b + 0.4505937099 * o, 4), i(0.0259040371 * a + 0.7827717662 * b - 0.808675766 * o, 4)];
@@ -233,16 +242,10 @@ class e {
     return t >= n ? s : r;
   }
 }
+var m = (s) => s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4, p = (s) => s <= 0.0031308 ? 12.92 * s : 1.055 * s ** 0.4166666666666667 - 0.055, i = (s, r) => Math.round(s * 10 ** r) / 10 ** r;
+var init_chunk_mtetydvc = () => {};
 
 // ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-y1msbssb.js
-var r = 39;
-var o = 49;
-var f2 = "\x1B[";
-var C2 = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, r], red: [31, r], green: [32, r], yellow: [33, r], blue: [34, r], magenta: [35, r], cyan: [36, r], white: [37, r], gray: [90, r], grey: [90, r], blackBright: [90, r], redBright: [91, r], greenBright: [92, r], yellowBright: [93, r], blueBright: [94, r], magentaBright: [95, r], cyanBright: [96, r], whiteBright: [97, r], bgBlack: [40, o], bgRed: [41, o], bgGreen: [42, o], bgYellow: [43, o], bgBlue: [44, o], bgMagenta: [45, o], bgCyan: [46, o], bgWhite: [47, o], bgBlackBright: [100, o], bgRedBright: [101, o], bgGreenBright: [102, o], bgYellowBright: [103, o], bgBlueBright: [104, o], bgMagentaBright: [105, o], bgCyanBright: [106, o], bgWhiteBright: [107, o], rgb: (i, n, a, l = "fg") => [`${l === "fg" ? 38 : 48};2;${i};${n};${a}`, l === "fg" ? r : o], hex: (i, n = "fg") => {
-  let [a, l, s] = e.from("hex", i).to("rgb");
-  return [`${n === "fg" ? 38 : 48};2;${a};${l};${s}`, n === "fg" ? r : o];
-}, ansi256: (i, n = "fg") => [`${n === "fg" ? 38 : 48};5;${i}`, n === "fg" ? r : o] };
-var b = new Set(["", "1", "2", "3", "true"]);
 function h(i, n = globalThis.process?.env ?? {}) {
   if (n.FORCE_COLOR !== undefined)
     return b.has(n.FORCE_COLOR);
@@ -273,26 +276,69 @@ function u(i, n = []) {
 function le(i = {}) {
   return u(i);
 }
-var t = le();
+var r = 39, o = 49, f2 = "\x1B[", C2, b, t;
+var init_chunk_y1msbssb = __esm(() => {
+  init_chunk_mtetydvc();
+  C2 = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, r], red: [31, r], green: [32, r], yellow: [33, r], blue: [34, r], magenta: [35, r], cyan: [36, r], white: [37, r], gray: [90, r], grey: [90, r], blackBright: [90, r], redBright: [91, r], greenBright: [92, r], yellowBright: [93, r], blueBright: [94, r], magentaBright: [95, r], cyanBright: [96, r], whiteBright: [97, r], bgBlack: [40, o], bgRed: [41, o], bgGreen: [42, o], bgYellow: [43, o], bgBlue: [44, o], bgMagenta: [45, o], bgCyan: [46, o], bgWhite: [47, o], bgBlackBright: [100, o], bgRedBright: [101, o], bgGreenBright: [102, o], bgYellowBright: [103, o], bgBlueBright: [104, o], bgMagentaBright: [105, o], bgCyanBright: [106, o], bgWhiteBright: [107, o], rgb: (i, n, a, l = "fg") => [`${l === "fg" ? 38 : 48};2;${i};${n};${a}`, l === "fg" ? r : o], hex: (i, n = "fg") => {
+    let [a, l, s] = e.from("hex", i).to("rgb");
+    return [`${n === "fg" ? 38 : 48};2;${a};${l};${s}`, n === "fg" ? r : o];
+  }, ansi256: (i, n = "fg") => [`${n === "fg" ? 38 : 48};5;${i}`, n === "fg" ? r : o] };
+  b = new Set(["", "1", "2", "3", "true"]);
+  t = le();
+});
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/tools/colors.js
+var init_colors = __esm(() => {
+  init_chunk_y1msbssb();
+});
 
 // ../kit/src/style.ts
+import process from "process";
 function takesControlCodes(stream, env = process.env) {
   return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
 }
 function paint(stream, env = process.env) {
   return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
 }
-var STATUSES = {
-  passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
-  failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
-  running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
-  queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
-  skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
-};
-var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+function marked(mark, text, stream, detail, env = process.env) {
+  const colors = paint(stream, env);
+  const { symbol, word, paint: tint } = MARKS[mark];
+  const head = takesControlCodes(stream, env) ? tint(colors)(symbol) : word;
+  return `${head} ${text}${detail === undefined ? "" : ` ${colors.dim(detail)}`}`;
+}
+function ok(text, detail) {
+  console.log(marked("ok", text, process.stdout, detail));
+}
+function note(text, detail) {
+  console.log(marked("note", text, process.stdout, detail));
+}
+function warn(text, detail) {
+  console.error(marked("warn", text, process.stderr, detail));
+}
+function problem(text, detail) {
+  console.error(marked("problem", text, process.stderr, detail));
+}
+var MARKS, STATUSES, STATUS_OF;
+var init_style = __esm(() => {
+  init_colors();
+  MARKS = {
+    ok: { symbol: "\u2713", word: "ok:", paint: (colors) => colors.green },
+    warn: { symbol: "!", word: "warning:", paint: (colors) => colors.yellow },
+    problem: { symbol: "\u2717", word: "error:", paint: (colors) => colors.red },
+    note: { symbol: "\xB7", word: "note:", paint: (colors) => colors.dim }
+  };
+  STATUSES = {
+    passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
+    failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
+    running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
+    queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
+    skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
+  };
+  STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+});
 
 // ../kit/src/format.ts
-var UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
+import process2 from "process";
 function formatSeconds(total) {
   let rest = Math.max(0, Math.round(total));
   const amounts = UNITS.map(([unit, size]) => {
@@ -306,6 +352,9 @@ function formatSeconds(total) {
   const next = amounts[first + 1];
   return next === undefined || next.startsWith("0") ? amounts[first] ?? "0s" : `${amounts[first]} ${next}`;
 }
+function formatDuration(ms) {
+  return ms < 60000 ? `${(Math.max(0, ms) / 1000).toFixed(1)}s` : formatSeconds(ms / 1000);
+}
 function upTo(text, separator) {
   const end = text.indexOf(separator);
   return end === -1 ? text : text.slice(0, end);
@@ -320,8 +369,6 @@ function formatAge(date, now = Date.now()) {
 function truncate(text, width) {
   return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
 }
-var LINE_BREAKS = /\s*\n\s*/g;
-var ESCAPE = String.fromCharCode(27);
 function textWidth(text) {
   return Bun.stringWidth(text);
 }
@@ -363,56 +410,45 @@ function narrow(rows, widths, limit) {
 function printJson(value) {
   console.log(JSON.stringify(value, undefined, 2));
 }
+var UNITS, LINE_BREAKS, ESCAPE;
+var init_format = __esm(() => {
+  init_style();
+  UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
+  LINE_BREAKS = /\s*\n\s*/g;
+  ESCAPE = String.fromCharCode(27);
+});
 
 // ../kit/src/args.ts
+import process3 from "process";
+import { parseArgs } from "util";
 function jsonOption(holds) {
   return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
 }
-
-class Exit extends Error {
-  code;
-  hint;
-  constructor(message, code, hint) {
-    super(message);
-    this.code = code;
-    this.hint = hint;
-  }
-}
 function fail(message, code = 2, hint) {
   throw new Exit(message, code, hint);
 }
-
-class UsageError extends Exit {
-  constructor(message) {
-    super(message, 2);
-  }
-}
 function badUsage(message) {
   throw new UsageError(message);
 }
 
-class HelpShown extends Exit {
-  constructor() {
-    super("help shown", 0);
-  }
-}
-
 class Completing {
   options;
   constructor(options) {
     this.options = options;
   }
 }
-var completion = { active: false };
-var OPTIONAL = /\[[^\]]+\]/g;
-var USAGE_PREFIX = /^usage:\s*/i;
 function usageLine(usage, colors = paint(process3.stdout)) {
   return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
 }
-function helpText(usage, options, colors = paint(process3.stdout)) {
-  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors)].join(`
+function helpText(usage, options, colors = paint(process3.stdout), examples = []) {
+  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exampleRows(examples, colors)].join(`
 `);
 }
+function exampleRows(examples, colors = paint(process3.stdout)) {
+  if (examples.length === 0)
+    return [];
+  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
+}
 function optionRows(options, colors = paint(process3.stdout)) {
   const rows = Object.entries(options).map(([name, option]) => {
     const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
@@ -422,8 +458,23 @@ function optionRows(options, colors = paint(process3.stdout)) {
   const width = Math.max(0, ...rows.map((row) => row.width));
   return rows.map((row) => `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
 }
+function applyOutput(color, plain, env = process3.env) {
+  const when = plain === true ? "never" : color ?? "auto";
+  if (when === "auto")
+    return;
+  if (when !== "always" && when !== "never")
+    badUsage(`--color takes auto, always or never, not ${when}`);
+  if (when === "always") {
+    env.FORCE_COLOR = "1";
+    delete env.NO_COLOR;
+  } else {
+    env.NO_COLOR = "1";
+    delete env.FORCE_COLOR;
+  }
+}
 function parse(args, usage, options, settings = {}) {
-  const all = { ...options, help: { type: "boolean", short: "h", description: "show this help" } };
+  const output = Object.fromEntries(Object.entries(OUTPUT_OPTIONS).filter(([name]) => !(name in options)));
+  const all = { ...options, ...output, help: { type: "boolean", short: "h", description: "show this help" } };
   if (completion.active)
     throw new Completing(all);
   const separator = settings.rest === true ? args.indexOf("--") : -1;
@@ -435,8 +486,10 @@ function parse(args, usage, options, settings = {}) {
   } catch (error) {
     badUsage(parseError(error));
   }
-  if (parsed.values.help === true) {
-    console.log(helpText(usage, all));
+  const values = parsed.values;
+  applyOutput("color" in output ? values.color : undefined, "plain" in output ? values.plain : undefined);
+  if (values.help === true) {
+    console.log(helpText(usage, all, undefined, settings.examples));
     throw new HelpShown;
   }
   if (settings.positionals !== undefined)
@@ -463,11 +516,56 @@ function wholeNumber(value, name, fallback, min = 1) {
     badUsage(`--${name} takes a whole number from ${min}, not ${value}`);
   return number;
 }
-// ../kit/src/cli.ts
-import process4 from "process";
+function duration(value, name, fallback, unit = "s") {
+  if (value === undefined)
+    return fallback;
+  const match = DURATION.exec(value.trim());
+  const ms = match === null ? 0 : Number(match[1]) * UNIT_MS[match[2] ?? unit];
+  if (ms < 1)
+    badUsage(`--${name} takes a duration such as 30s, 5m or 1h, not ${value}`);
+  return ms;
+}
+var Exit, UsageError, HelpShown, completion, OPTIONAL, USAGE_PREFIX, OUTPUT_OPTIONS, DURATION, UNIT_MS;
+var init_args = __esm(() => {
+  init_format();
+  init_style();
+  Exit = class Exit extends Error {
+    code;
+    hint;
+    constructor(message, code, hint) {
+      super(message);
+      this.code = code;
+      this.hint = hint;
+    }
+  };
+  UsageError = class UsageError extends Exit {
+    constructor(message) {
+      super(message, 2);
+    }
+  };
+  HelpShown = class HelpShown extends Exit {
+    constructor() {
+      super("help shown", 0);
+    }
+  };
+  completion = { active: false };
+  OPTIONAL = /\[[^\]]+\]/g;
+  USAGE_PREFIX = /^usage:\s*/i;
+  OUTPUT_OPTIONS = {
+    color: { type: "string", description: "auto (on a terminal alone), always or never" },
+    plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
+  };
+  DURATION = /^(\d+(?:\.\d+)?)(ms|[smh])?$/;
+  UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000 };
+});
+
+// ../kit/src/chart.ts
+var init_chart = __esm(() => {
+  init_format();
+  init_style();
+});
 
 // ../kit/src/text.ts
-var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
 function distance(a, b) {
   let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
   for (const [i, left] of [...a].entries()) {
@@ -478,8 +576,68 @@ function distance(a, b) {
   }
   return previous[b.length] ?? 0;
 }
+var ANSI;
+var init_text = __esm(() => {
+  ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+});
 
 // ../kit/src/cli.ts
+import process4 from "process";
+function commandRows(commands, colors) {
+  const width = Math.max(...Object.keys(commands).map((name) => name.length));
+  const groups = new Map([["Commands:", []]]);
+  for (const [name, { summary, group }] of Object.entries(commands)) {
+    const heading = group === undefined ? "Commands:" : `${group}:`;
+    const rows = groups.get(heading) ?? [];
+    rows.push(`  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summary)}`);
+    groups.set(heading, rows);
+  }
+  return [...groups].filter(([, rows]) => rows.length > 0).flatMap(([heading, rows], index) => [...index === 0 ? [] : [""], colors.bold(heading), ...rows]);
+}
+function takeOutputFlags(argv) {
+  let index = 0;
+  for (;index < argv.length; index++) {
+    const word = argv[index];
+    if (word === "--plain")
+      applyOutput(undefined, true);
+    else if (word.startsWith("--color="))
+      applyOutput(word.slice("--color=".length), undefined);
+    else if (word === "--color" && argv[index + 1] !== undefined)
+      applyOutput(argv[++index], undefined);
+    else
+      break;
+  }
+  return argv.slice(index);
+}
+function closest(name, names) {
+  const started = names.find((known) => known.startsWith(name));
+  if (started !== undefined)
+    return started;
+  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
+  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
+}
+async function help({ path, header, commands, defaultCommand, examples }, stream) {
+  const colors = paint(stream);
+  const prefix = path.join(" ");
+  const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
+  const options = fallback !== undefined && "run" in fallback ? await optionsOf(fallback.run) : undefined;
+  const own = Object.entries(options ?? {}).filter(([name]) => !(name in TOP_OPTIONS));
+  return [
+    header(colors),
+    "",
+    usageLine(`${prefix} ${defaultCommand === undefined ? colors.cyan("<command>") : `[${colors.cyan("<command>")}]`} [options]`, colors),
+    "",
+    ...commandRows(commands, colors),
+    ...own.length === 0 ? [] : ["", `${colors.bold(`Options of ${defaultCommand}:`)} ${colors.dim("the command run when none is named")}`, ...optionRows(Object.fromEntries(own), colors)],
+    "",
+    colors.bold("Options:"),
+    ...optionRows(path.length === 1 ? TOP_OPTIONS : LEVEL_OPTIONS, colors),
+    ...exampleRows(examples ?? [], colors),
+    "",
+    `${colors.dim("Run")} ${prefix} ${colors.cyan("<command>")} --help ${colors.dim("for its options.")}`
+  ].join(`
+`);
+}
 function printError(prefix, message, hint, cause) {
   const colors = paint(process4.stderr);
   const styled = takesControlCodes(process4.stderr);
@@ -497,8 +655,48 @@ function reportThrown(prefix, error, redact = (text) => text) {
   printError(prefix, redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
   return error instanceof Exit ? error.code : 1;
 }
-var COMPLETE = "__complete";
-var FILES = "__files__";
+async function dispatch(level, typed, { version, redact }) {
+  const prefix = level.path.join(" ");
+  let argv;
+  try {
+    argv = takeOutputFlags(typed);
+  } catch (error) {
+    return reportThrown(prefix, error);
+  }
+  const [name, ...args] = argv;
+  if (name === undefined && level.path.length > 1) {
+    console.error(await help(level, process4.stderr));
+    return 2;
+  }
+  if (name === undefined || name === "help" || name === "--help" || name === "-h") {
+    console.log(await help(level, process4.stdout));
+    return 0;
+  }
+  if (level.path.length === 1 && (name === "--version" || name === "-v")) {
+    console.log(version);
+    return 0;
+  }
+  let command = level.commands[level.aliases?.[name] ?? name];
+  let rest = args;
+  if (command === undefined && level.defaultCommand !== undefined) {
+    command = level.commands[level.defaultCommand];
+    rest = argv;
+  }
+  if (command === undefined) {
+    const meant = closest(name, Object.keys(level.commands));
+    printError(prefix, `no command ${name}`, meant === undefined ? `run ${prefix} --help for its commands` : `did you mean ${meant}?`);
+    return 2;
+  }
+  if ("commands" in command) {
+    const { summary } = command;
+    return dispatch({ path: [...level.path, name], header: (colors) => `${colors.bold(`${prefix} ${name}`)}  ${summary}`, commands: command.commands, aliases: command.aliases, defaultCommand: undefined, examples: command.examples }, rest, { version, redact });
+  }
+  try {
+    return await command.run(rest);
+  } catch (error) {
+    return reportThrown(`${prefix} ${name}`, error, redact);
+  }
+}
 async function optionsOf(run) {
   completion.active = true;
   try {
@@ -516,534 +714,622 @@ async function leafCandidates(run, words) {
     return [FILES];
   return Object.entries(await optionsOf(run)).map(([name, option]) => `--${name}	${option.description}`);
 }
+async function candidates(commands, aliases, defaultCommand, words) {
+  const [word = "", ...rest] = words;
+  const command = commands[aliases?.[word] ?? word];
+  if (rest.length === 0 && !word.startsWith("-"))
+    return Object.entries(commands).map(([name, { summary }]) => `${name}	${summary}`);
+  if (command === undefined) {
+    const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
+    return fallback !== undefined && "run" in fallback ? leafCandidates(fallback.run, words) : [];
+  }
+  return "commands" in command ? candidates(command.commands, command.aliases, undefined, rest) : leafCandidates(command.run, rest);
+}
 async function printCandidates(found) {
   for (const line of await found)
     console.log(line);
   return 0;
 }
-async function runMain({ name, version, run, redact }, argv = process4.argv.slice(2)) {
+async function runCli(cli, argv = process4.argv.slice(2)) {
   if (argv[0] === COMPLETE)
-    return printCandidates(leafCandidates(run, argv.slice(1)));
-  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
-    console.log(version);
-    return 0;
-  }
-  try {
-    return await run(argv);
-  } catch (error) {
-    return reportThrown(name, error, redact);
+    return printCandidates(candidates(cli.commands, cli.aliases, cli.defaultCommand, argv.slice(1)));
+  return dispatch({ path: [cli.name], header: (colors) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${cli.about}`, commands: cli.commands, aliases: cli.aliases, defaultCommand: cli.defaultCommand, examples: cli.examples }, argv, { version: cli.version, redact: cli.redact });
+}
+var LEVEL_OPTIONS, TOP_OPTIONS, COMPLETE = "__complete", FILES = "__files__";
+var init_cli = __esm(() => {
+  init_args();
+  init_style();
+  init_text();
+  LEVEL_OPTIONS = {
+    ...OUTPUT_OPTIONS,
+    help: { type: "boolean", short: "h", description: "show this help" }
+  };
+  TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
+});
+
+// ../kit/src/config.ts
+var init_config = __esm(() => {
+  init_args();
+});
+
+// ../kit/src/process.ts
+import { constants } from "os";
+import process5 from "process";
+async function collect(stream, name, chunks) {
+  for await (const data of stream)
+    chunks.push({ stream: name, data });
+}
+function exitCodeOf(code, signal) {
+  if (code !== null)
+    return code;
+  if (typeof signal === "number")
+    return 128 + signal;
+  return signal === null ? 129 : 128 + constants.signals[signal];
+}
+function holdSignals(cleanup) {
+  let received;
+  let child;
+  const held = {
+    get signal() {
+      return received;
+    },
+    forward: (to) => {
+      child = to;
+    },
+    release: () => {
+      for (const signal of SIGNALS)
+        process5.off(signal, onSignal);
+    }
+  };
+  function onSignal(signal) {
+    received = signal;
+    if (child !== undefined) {
+      child.kill(signal);
+      return;
+    }
+    if (cleanup === undefined)
+      return;
+    held.release();
+    cleanup(signal);
+    process5.kill(process5.pid, signal);
   }
-}
-// package.json
-var version = "0.2.1";
+  for (const signal of SIGNALS)
+    process5.on(signal, onSignal);
+  return held;
+}
+async function runCommand(argv, { cwd, env, stdin = "ignore" } = {}) {
+  const chunks = [];
+  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe" });
+  await Promise.all([collect(proc.stdout, "stdout", chunks), collect(proc.stderr, "stderr", chunks)]);
+  await proc.exited;
+  const output = Buffer.concat(chunks.map(({ data }) => data));
+  return { code: exitCodeOf(proc.exitCode, proc.signalCode), chunks, output, text: output.toString() };
+}
+var SIGNALS;
+var init_process = __esm(() => {
+  SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+});
+
+// ../kit/src/index.ts
+var init_src = __esm(() => {
+  init_args();
+  init_chart();
+  init_cli();
+  init_config();
+  init_format();
+  init_process();
+  init_style();
+  init_text();
+});
 
 // src/popular.json
-var popular_default = [
-  "semver",
-  "minimatch",
-  "debug",
-  "ansi-styles",
-  "brace-expansion",
-  "strip-ansi",
-  "ansi-regex",
-  "ms",
-  "supports-color",
-  "chalk",
-  "commander",
-  "lru-cache",
-  "string-width",
-  "wrap-ansi",
-  "tslib",
-  "picomatch",
-  "emoji-regex",
-  "glob",
-  "type-fest",
-  "color-name",
-  "eslint-visitor-keys",
-  "color-convert",
-  "ajv",
-  "minipass",
-  "source-map",
-  "balanced-match",
-  "readable-stream",
-  "which",
-  "glob-parent",
-  "escape-string-regexp",
-  "has-flag",
-  "find-up",
-  "locate-path",
-  "json-schema-traverse",
-  "p-limit",
-  "yallist",
-  "safe-buffer",
-  "uuid",
-  "p-locate",
-  "undici-types",
-  "ignore",
-  "iconv-lite",
-  "signal-exit",
-  "esbuild",
-  "is-fullwidth-code-point",
-  "js-yaml",
-  "entities",
-  "globals",
-  "postcss",
-  "isexe",
-  "isarray",
-  "path-key",
-  "string_decoder",
-  "argparse",
-  "ws",
-  "mime-db",
-  "resolve",
-  "agent-base",
-  "@esbuild/linux-x64",
-  "yargs-parser",
-  "mime-types",
-  "acorn",
-  "estraverse",
-  "cross-spawn",
-  "react-is",
-  "picocolors",
-  "fs-extra",
-  "hasown",
-  "nanoid",
-  "yargs",
-  "resolve-from",
-  "shebang-command",
-  "pretty-format",
-  "json5",
-  "https-proxy-agent",
-  "path-to-regexp",
-  "path-exists",
-  "punycode",
-  "js-tokens",
-  "cliui",
-  "shebang-regex",
-  "@babel/types",
-  "chokidar",
-  "strip-json-comments",
-  "inherits",
-  "webidl-conversions",
-  "get-stream",
-  "eslint-scope",
-  "cookie",
-  "@babel/parser",
-  "qs",
-  "is-number",
-  "whatwg-url",
-  "@types/estree",
-  "tr46",
-  "convert-source-map",
-  "is-glob",
-  "braces",
-  "fast-deep-equal",
-  "form-data",
-  "lodash",
-  "@babel/helper-validator-identifier",
-  "electron-to-chromium",
-  "fill-range",
-  "function-bind",
-  "readdirp",
-  "escalade",
-  "graceful-fs",
-  "negotiator",
-  "is-stream",
-  "camelcase",
-  "@babel/runtime",
-  "yocto-queue",
-  "to-regex-range",
-  "node-fetch",
-  "micromatch",
-  "node-releases",
-  "get-intrinsic",
-  "universalify",
-  "path-scurry",
-  "jsesc",
-  "browserslist",
-  "es-errors",
-  "statuses",
-  "@radix-ui/react-primitive",
-  "magic-string",
-  "rimraf",
-  "is-extglob",
-  "@jridgewell/trace-mapping",
-  "@jridgewell/resolve-uri",
-  "http-errors",
-  "onetime",
-  "has-symbols",
-  "es-define-property",
-  "gopd",
-  "util-deprecate",
-  "object-assign",
-  "jiti",
-  "yaml",
-  "dotenv",
-  "@babel/generator",
-  "@babel/template",
-  "imurmurhash",
-  "postcss-selector-parser",
-  "fast-glob",
-  "update-browserslist-db",
-  "@types/node",
-  "@babel/compat-data",
-  "eventemitter3",
-  "callsites",
-  "http-proxy-agent",
-  "detect-libc",
-  "espree",
-  "execa",
-  "@babel/core",
-  "@babel/helpers",
-  "concat-map",
-  "source-map-js",
-  "tinyglobby",
-  "call-bind-apply-helpers",
-  "flat-cache",
-  "fdir",
-  "pify",
-  "@jest/types",
-  "normalize-path",
-  "is-core-module",
-  "eslint",
-  "minimist",
-  "estree-walker",
-  "file-entry-cache",
-  "object-inspect",
-  "buffer",
-  "uri-js",
-  "import-fresh",
-  "@babel/helper-module-transforms",
-  "optionator",
-  "flatted",
-  "math-intrinsics",
-  "safer-buffer",
-  "y18n",
-  "@babel/helper-module-imports",
-  "mkdirp",
-  "dunder-proto",
-  "path-parse",
-  "fastq",
-  "levn",
-  "@babel/helper-compilation-targets",
-  "@babel/helper-string-parser",
-  "keyv",
-  "get-proto",
-  "csstype",
-  "npm-run-path",
-  "fast-json-stable-stringify",
-  "reusify",
-  "@babel/helper-plugin-utils",
-  "kind-of",
-  "mime",
-  "caniuse-lite",
-  "lines-and-columns",
-  "fast-levenshtein",
-  "supports-preserve-symlinks-flag",
-  "make-dir",
-  "slash",
-  "prelude-ls",
-  "typescript",
-  "strip-bom",
-  "parent-module",
-  "esutils",
-  "ci-info",
-  "@smithy/util-utf8",
-  "type-check",
-  "mimic-fn",
-  "@babel/helper-validator-option",
-  "@types/json-schema",
-  "@rolldown/pluginutils",
-  "side-channel-list",
-  "json-buffer",
-  "raw-body",
-  "has-tostringtag",
-  "wrappy",
-  "diff",
-  "jackspeak",
-  "baseline-browser-mapping",
-  "deep-is",
-  "foreground-child",
-  "@eslint/js",
-  "anymatch",
-  "natural-compare",
-  "esquery",
-  "@eslint-community/regexpp",
-  "es-set-tostringtag",
-  "acorn-jsx",
-  "parse5",
-  "finalhandler",
-  "parse-json",
-  "depd",
-  "axios",
-  "run-parallel",
-  "source-map-support",
-  "esrecurse",
-  "call-bound",
-  "content-disposition",
-  "human-signals",
-  "ts-api-utils",
-  "ansi-escapes",
-  "jest-util",
-  "send",
-  "@opentelemetry/core",
-  "type-is",
-  "encodeurl",
-  "once",
-  "cosmiconfig",
-  "lodash.merge",
-  "json-stable-stringify-without-jsonify",
-  "open",
-  "prettier",
-  "@eslint/eslintrc",
-  "is-arrayish",
-  "@jridgewell/sourcemap-codec",
-  "gensync",
-  "word-wrap",
-  "express",
-  "arg",
-  "jsonfile",
-  "schema-utils",
-  "@smithy/is-array-buffer",
-  "@typescript-eslint/types",
-  "chownr",
-  "delayed-stream",
-  "@smithy/util-buffer-from",
-  "asynckit",
-  "tapable",
-  "enhanced-resolve",
-  "aria-query",
-  "indent-string",
-  "bytes",
-  "binary-extensions",
-  "ini",
-  "@radix-ui/react-context",
-  "doctrine",
-  "queue-microtask",
-  "accepts",
-  "merge2",
-  "get-caller-file",
-  "@humanwhocodes/retry",
-  "@jridgewell/gen-mapping",
-  "@typescript-eslint/typescript-estree",
-  "jest-worker",
-  "proxy-from-env",
-  "clsx",
-  "side-channel-map",
-  "@typescript-eslint/visitor-keys",
-  "fresh",
-  "restore-cursor",
-  "on-finished",
-  "is-plain-obj",
-  "ipaddr.js",
-  "pathe",
-  "@jest/schemas",
-  "base64-js",
-  "@smithy/types",
-  "require-directory",
-  "tough-cookie",
-  "is-binary-path",
-  "body-parser",
-  "postcss-value-parser",
-  "media-typer",
-  "setprototypeof",
-  "side-channel-weakmap",
-  "@typescript-eslint/tsconfig-utils",
-  "@isaacs/cliui",
-  "@rollup/rollup-linux-x64-gnu",
-  "is-wsl",
-  "retry",
-  "@aws-sdk/types",
-  "@types/react-dom",
-  "combined-stream",
-  "es-object-atoms",
-  "@eslint/core",
-  "whatwg-mimetype",
-  "domutils",
-  "@rollup/rollup-linux-x64-musl",
-  "core-util-is",
-  "@typescript-eslint/scope-manager",
-  "esprima",
-  "loose-envify",
-  "cookie-signature",
-  "follow-redirects",
-  "cli-cursor",
-  "strip-final-newline",
-  "@typescript-eslint/project-service",
-  "eastasianwidth",
-  "json-parse-even-better-errors",
-  "sprintf-js",
-  "path-type",
-  "content-type",
-  "es-module-lexer",
-  "@nodelib/fs.scandir",
-  "write-file-atomic",
-  "@eslint/plugin-kit",
-  "ieee754",
-  "prop-types",
-  "require-from-string",
-  "dom-serializer",
-  "call-bind",
-  "@eslint/config-array",
-  "has-property-descriptors",
-  "@nodelib/fs.stat",
-  "merge-descriptors",
-  "slice-ansi",
-  "rxjs",
-  "p-map",
-  "toidentifier",
-  "globby",
-  "domhandler",
-  "async",
-  "@babel/helper-globals",
-  "pirates",
-  "@opentelemetry/semantic-conventions",
-  "@typescript-eslint/utils",
-  "date-fns",
-  "is-docker",
-  "tar",
-  "which-typed-array",
-  "ajv-formats",
-  "@opentelemetry/api-logs",
-  "@opentelemetry/resources",
-  "side-channel",
-  "cjs-module-lexer",
-  "range-parser",
-  "@humanfs/node",
-  "define-data-property",
-  "node-addon-api",
-  "pako",
-  "lilconfig",
-  "fast-uri",
-  "ip-address",
-  "fs.realpath",
-  "@img/sharp-libvips-linuxmusl-x64",
-  "cssesc",
-  "@opentelemetry/instrumentation",
-  "domelementtype",
-  "hosted-git-info",
-  "@eslint/object-schema",
-  "etag",
-  "@eslint/config-helpers",
-  "package-json-from-dist",
-  "@humanfs/core",
-  "htmlparser2",
-  "jest-message-util",
-  "for-each",
-  "pkg-dir",
-  "unpipe",
-  "buffer-from",
-  "es-abstract",
-  "is-unicode-supported",
-  "@types/yargs",
-  "is-callable",
-  "fast-xml-parser",
-  "istanbul-lib-instrument",
-  "escape-html",
-  "is-regex",
-  "dom-accessibility-api",
-  "css-tree",
-  "error-ex",
-  "ee-first",
-  "@types/unist",
-  "log-symbols",
-  "path-is-absolute",
-  "end-of-stream",
-  "@vitest/utils",
-  "object.assign",
-  "object-keys",
-  "tinyexec",
-  "scheduler",
-  "p-try",
-  "process-nextick-args",
-  "vary",
-  "@babel/traverse",
-  "@pkgjs/parseargs",
-  "@types/babel__generator",
-  "kleur",
-  "zod",
-  "merge-stream",
-  "available-typed-arrays",
-  "mute-stream",
-  "is-typed-array",
-  "safe-regex-test",
-  "tsconfig-paths",
-  "minizlib",
-  "tar-stream",
-  "@floating-ui/core",
-  "jose",
-  "deepmerge",
-  "get-tsconfig",
-  "set-function-length",
-  "@vitest/spy",
-  "css-select",
-  "@types/babel__core",
-  "forwarded",
-  "react",
-  "@typescript-eslint/parser",
-  "ajv-keywords",
-  "define-properties",
-  "is-generator-function",
-  "regexp.prototype.flags",
-  "acorn-walk",
-  "pump",
-  "data-uri-to-buffer",
-  "object-hash",
-  "jsdom",
-  "nopt",
-  "@babel/plugin-syntax-jsx",
-  "@floating-ui/dom",
-  "tiny-invariant",
-  "strip-indent",
-  "d3-array",
-  "chai",
-  "@babel/code-frame",
-  "@typescript-eslint/eslint-plugin",
-  "proxy-addr",
-  "parseurl",
-  "@floating-ui/utils",
-  "ora",
-  "html-encoding-sniffer",
-  "pnpm",
-  "whatwg-encoding",
-  "events",
-  "@typescript-eslint/type-utils",
-  "env-paths",
-  "internal-slot",
-  "string.prototype.trimend",
-  "extend",
-  "resolve-pkg-maps",
-  "istanbul-lib-coverage",
-  "react-dom",
-  "is-number-object",
-  "@radix-ui/primitive",
-  "is-plain-object",
-  "string.prototype.trimstart",
-  "@babel/plugin-syntax-typescript",
-  "jest-diff",
-  "define-lazy-prop",
-  "globalthis",
-  "which-boxed-primitive",
-  "@vitest/expect",
-  "sax",
-  "@floating-ui/react-dom",
-  "@vitest/pretty-format",
-  "internmap",
-  "@radix-ui/react-compose-refs",
-  "is-symbol",
-  "@eslint-community/eslint-utils",
-  "bl",
-  "serve-static",
-  "get-symbol-description",
-  "is-shared-array-buffer",
-  "functions-have-names",
-  "array-buffer-byte-length",
-  "socks-proxy-agent"
-];
+var popular_default;
+var init_popular = __esm(() => {
+  popular_default = [
+    "semver",
+    "minimatch",
+    "debug",
+    "ansi-styles",
+    "brace-expansion",
+    "strip-ansi",
+    "ansi-regex",
+    "ms",
+    "supports-color",
+    "chalk",
+    "commander",
+    "lru-cache",
+    "string-width",
+    "wrap-ansi",
+    "tslib",
+    "picomatch",
+    "emoji-regex",
+    "glob",
+    "type-fest",
+    "color-name",
+    "eslint-visitor-keys",
+    "color-convert",
+    "ajv",
+    "minipass",
+    "source-map",
+    "balanced-match",
+    "readable-stream",
+    "which",
+    "glob-parent",
+    "escape-string-regexp",
+    "has-flag",
+    "find-up",
+    "locate-path",
+    "json-schema-traverse",
+    "p-limit",
+    "yallist",
+    "safe-buffer",
+    "uuid",
+    "p-locate",
+    "undici-types",
+    "ignore",
+    "iconv-lite",
+    "signal-exit",
+    "esbuild",
+    "is-fullwidth-code-point",
+    "js-yaml",
+    "entities",
+    "globals",
+    "postcss",
+    "isexe",
+    "isarray",
+    "path-key",
+    "string_decoder",
+    "argparse",
+    "ws",
+    "mime-db",
+    "resolve",
+    "agent-base",
+    "@esbuild/linux-x64",
+    "yargs-parser",
+    "mime-types",
+    "acorn",
+    "estraverse",
+    "cross-spawn",
+    "react-is",
+    "picocolors",
+    "fs-extra",
+    "hasown",
+    "nanoid",
+    "yargs",
+    "resolve-from",
+    "shebang-command",
+    "pretty-format",
+    "json5",
+    "https-proxy-agent",
+    "path-to-regexp",
+    "path-exists",
+    "punycode",
+    "js-tokens",
+    "cliui",
+    "shebang-regex",
+    "@babel/types",
+    "chokidar",
+    "strip-json-comments",
+    "inherits",
+    "webidl-conversions",
+    "get-stream",
+    "eslint-scope",
+    "cookie",
+    "@babel/parser",
+    "qs",
+    "is-number",
+    "whatwg-url",
+    "@types/estree",
+    "tr46",
+    "convert-source-map",
+    "is-glob",
+    "braces",
+    "fast-deep-equal",
+    "form-data",
+    "lodash",
+    "@babel/helper-validator-identifier",
+    "electron-to-chromium",
+    "fill-range",
+    "function-bind",
+    "readdirp",
+    "escalade",
+    "graceful-fs",
+    "negotiator",
+    "is-stream",
+    "camelcase",
+    "@babel/runtime",
+    "yocto-queue",
+    "to-regex-range",
+    "node-fetch",
+    "micromatch",
+    "node-releases",
+    "get-intrinsic",
+    "universalify",
+    "path-scurry",
+    "jsesc",
+    "browserslist",
+    "es-errors",
+    "statuses",
+    "@radix-ui/react-primitive",
+    "magic-string",
+    "rimraf",
+    "is-extglob",
+    "@jridgewell/trace-mapping",
+    "@jridgewell/resolve-uri",
+    "http-errors",
+    "onetime",
+    "has-symbols",
+    "es-define-property",
+    "gopd",
+    "util-deprecate",
+    "object-assign",
+    "jiti",
+    "yaml",
+    "dotenv",
+    "@babel/generator",
+    "@babel/template",
+    "imurmurhash",
+    "postcss-selector-parser",
+    "fast-glob",
+    "update-browserslist-db",
+    "@types/node",
+    "@babel/compat-data",
+    "eventemitter3",
+    "callsites",
+    "http-proxy-agent",
+    "detect-libc",
+    "espree",
+    "execa",
+    "@babel/core",
+    "@babel/helpers",
+    "concat-map",
+    "source-map-js",
+    "tinyglobby",
+    "call-bind-apply-helpers",
+    "flat-cache",
+    "fdir",
+    "pify",
+    "@jest/types",
+    "normalize-path",
+    "is-core-module",
+    "eslint",
+    "minimist",
+    "estree-walker",
+    "file-entry-cache",
+    "object-inspect",
+    "buffer",
+    "uri-js",
+    "import-fresh",
+    "@babel/helper-module-transforms",
+    "optionator",
+    "flatted",
+    "math-intrinsics",
+    "safer-buffer",
+    "y18n",
+    "@babel/helper-module-imports",
+    "mkdirp",
+    "dunder-proto",
+    "path-parse",
+    "fastq",
+    "levn",
+    "@babel/helper-compilation-targets",
+    "@babel/helper-string-parser",
+    "keyv",
+    "get-proto",
+    "csstype",
+    "npm-run-path",
+    "fast-json-stable-stringify",
+    "reusify",
+    "@babel/helper-plugin-utils",
+    "kind-of",
+    "mime",
+    "caniuse-lite",
+    "lines-and-columns",
+    "fast-levenshtein",
+    "supports-preserve-symlinks-flag",
+    "make-dir",
+    "slash",
+    "prelude-ls",
+    "typescript",
+    "strip-bom",
+    "parent-module",
+    "esutils",
+    "ci-info",
+    "@smithy/util-utf8",
+    "type-check",
+    "mimic-fn",
+    "@babel/helper-validator-option",
+    "@types/json-schema",
+    "@rolldown/pluginutils",
+    "side-channel-list",
+    "json-buffer",
+    "raw-body",
+    "has-tostringtag",
+    "wrappy",
+    "diff",
+    "jackspeak",
+    "baseline-browser-mapping",
+    "deep-is",
+    "foreground-child",
+    "@eslint/js",
+    "anymatch",
+    "natural-compare",
+    "esquery",
+    "@eslint-community/regexpp",
+    "es-set-tostringtag",
+    "acorn-jsx",
+    "parse5",
+    "finalhandler",
+    "parse-json",
+    "depd",
+    "axios",
+    "run-parallel",
+    "source-map-support",
+    "esrecurse",
+    "call-bound",
+    "content-disposition",
+    "human-signals",
+    "ts-api-utils",
+    "ansi-escapes",
+    "jest-util",
+    "send",
+    "@opentelemetry/core",
+    "type-is",
+    "encodeurl",
+    "once",
+    "cosmiconfig",
+    "lodash.merge",
+    "json-stable-stringify-without-jsonify",
+    "open",
+    "prettier",
+    "@eslint/eslintrc",
+    "is-arrayish",
+    "@jridgewell/sourcemap-codec",
+    "gensync",
+    "word-wrap",
+    "express",
+    "arg",
+    "jsonfile",
+    "schema-utils",
+    "@smithy/is-array-buffer",
+    "@typescript-eslint/types",
+    "chownr",
+    "delayed-stream",
+    "@smithy/util-buffer-from",
+    "asynckit",
+    "tapable",
+    "enhanced-resolve",
+    "aria-query",
+    "indent-string",
+    "bytes",
+    "binary-extensions",
+    "ini",
+    "@radix-ui/react-context",
+    "doctrine",
+    "queue-microtask",
+    "accepts",
+    "merge2",
+    "get-caller-file",
+    "@humanwhocodes/retry",
+    "@jridgewell/gen-mapping",
+    "@typescript-eslint/typescript-estree",
+    "jest-worker",
+    "proxy-from-env",
+    "clsx",
+    "side-channel-map",
+    "@typescript-eslint/visitor-keys",
+    "fresh",
+    "restore-cursor",
+    "on-finished",
+    "is-plain-obj",
+    "ipaddr.js",
+    "pathe",
+    "@jest/schemas",
+    "base64-js",
+    "@smithy/types",
+    "require-directory",
+    "tough-cookie",
+    "is-binary-path",
+    "body-parser",
+    "postcss-value-parser",
+    "media-typer",
+    "setprototypeof",
+    "side-channel-weakmap",
+    "@typescript-eslint/tsconfig-utils",
+    "@isaacs/cliui",
+    "@rollup/rollup-linux-x64-gnu",
+    "is-wsl",
+    "retry",
+    "@aws-sdk/types",
+    "@types/react-dom",
+    "combined-stream",
+    "es-object-atoms",
+    "@eslint/core",
+    "whatwg-mimetype",
+    "domutils",
+    "@rollup/rollup-linux-x64-musl",
+    "core-util-is",
+    "@typescript-eslint/scope-manager",
+    "esprima",
+    "loose-envify",
+    "cookie-signature",
+    "follow-redirects",
+    "cli-cursor",
+    "strip-final-newline",
+    "@typescript-eslint/project-service",
+    "eastasianwidth",
+    "json-parse-even-better-errors",
+    "sprintf-js",
+    "path-type",
+    "content-type",
+    "es-module-lexer",
+    "@nodelib/fs.scandir",
+    "write-file-atomic",
+    "@eslint/plugin-kit",
+    "ieee754",
+    "prop-types",
+    "require-from-string",
+    "dom-serializer",
+    "call-bind",
+    "@eslint/config-array",
+    "has-property-descriptors",
+    "@nodelib/fs.stat",
+    "merge-descriptors",
+    "slice-ansi",
+    "rxjs",
+    "p-map",
+    "toidentifier",
+    "globby",
+    "domhandler",
+    "async",
+    "@babel/helper-globals",
+    "pirates",
+    "@opentelemetry/semantic-conventions",
+    "@typescript-eslint/utils",
+    "date-fns",
+    "is-docker",
+    "tar",
+    "which-typed-array",
+    "ajv-formats",
+    "@opentelemetry/api-logs",
+    "@opentelemetry/resources",
+    "side-channel",
+    "cjs-module-lexer",
+    "range-parser",
+    "@humanfs/node",
+    "define-data-property",
+    "node-addon-api",
+    "pako",
+    "lilconfig",
+    "fast-uri",
+    "ip-address",
+    "fs.realpath",
+    "@img/sharp-libvips-linuxmusl-x64",
+    "cssesc",
+    "@opentelemetry/instrumentation",
+    "domelementtype",
+    "hosted-git-info",
+    "@eslint/object-schema",
+    "etag",
+    "@eslint/config-helpers",
+    "package-json-from-dist",
+    "@humanfs/core",
+    "htmlparser2",
+    "jest-message-util",
+    "for-each",
+    "pkg-dir",
+    "unpipe",
+    "buffer-from",
+    "es-abstract",
+    "is-unicode-supported",
+    "@types/yargs",
+    "is-callable",
+    "fast-xml-parser",
+    "istanbul-lib-instrument",
+    "escape-html",
+    "is-regex",
+    "dom-accessibility-api",
+    "css-tree",
+    "error-ex",
+    "ee-first",
+    "@types/unist",
+    "log-symbols",
+    "path-is-absolute",
+    "end-of-stream",
+    "@vitest/utils",
+    "object.assign",
+    "object-keys",
+    "tinyexec",
+    "scheduler",
+    "p-try",
+    "process-nextick-args",
+    "vary",
+    "@babel/traverse",
+    "@pkgjs/parseargs",
+    "@types/babel__generator",
+    "kleur",
+    "zod",
+    "merge-stream",
+    "available-typed-arrays",
+    "mute-stream",
+    "is-typed-array",
+    "safe-regex-test",
+    "tsconfig-paths",
+    "minizlib",
+    "tar-stream",
+    "@floating-ui/core",
+    "jose",
+    "deepmerge",
+    "get-tsconfig",
+    "set-function-length",
+    "@vitest/spy",
+    "css-select",
+    "@types/babel__core",
+    "forwarded",
+    "react",
+    "@typescript-eslint/parser",
+    "ajv-keywords",
+    "define-properties",
+    "is-generator-function",
+    "regexp.prototype.flags",
+    "acorn-walk",
+    "pump",
+    "data-uri-to-buffer",
+    "object-hash",
+    "jsdom",
+    "nopt",
+    "@babel/plugin-syntax-jsx",
+    "@floating-ui/dom",
+    "tiny-invariant",
+    "strip-indent",
+    "d3-array",
+    "chai",
+    "@babel/code-frame",
+    "@typescript-eslint/eslint-plugin",
+    "proxy-addr",
+    "parseurl",
+    "@floating-ui/utils",
+    "ora",
+    "html-encoding-sniffer",
+    "pnpm",
+    "whatwg-encoding",
+    "events",
+    "@typescript-eslint/type-utils",
+    "env-paths",
+    "internal-slot",
+    "string.prototype.trimend",
+    "extend",
+    "resolve-pkg-maps",
+    "istanbul-lib-coverage",
+    "react-dom",
+    "is-number-object",
+    "@radix-ui/primitive",
+    "is-plain-object",
+    "string.prototype.trimstart",
+    "@babel/plugin-syntax-typescript",
+    "jest-diff",
+    "define-lazy-prop",
+    "globalthis",
+    "which-boxed-primitive",
+    "@vitest/expect",
+    "sax",
+    "@floating-ui/react-dom",
+    "@vitest/pretty-format",
+    "internmap",
+    "@radix-ui/react-compose-refs",
+    "is-symbol",
+    "@eslint-community/eslint-utils",
+    "bl",
+    "serve-static",
+    "get-symbol-description",
+    "is-shared-array-buffer",
+    "functions-have-names",
+    "array-buffer-byte-length",
+    "socks-proxy-agent"
+  ];
+});
 
 // src/nearmiss.ts
-var SEPARATORS = /[-_.]/g;
-var MIN_LENGTH = 5;
 function baseName(name) {
   return name.slice(name.indexOf("/") + 1);
 }
@@ -1073,13 +1359,14 @@ function nearMisses(name, popular = popular_default) {
   }
   return found.sort((a, b) => a.edits - b.edits).slice(0, 3).map((match) => match.text);
 }
+var SEPARATORS, MIN_LENGTH = 5;
+var init_nearmiss = __esm(() => {
+  init_src();
+  init_popular();
+  SEPARATORS = /[-_.]/g;
+});
 
 // src/analyze.ts
-var DEFAULT_MIN_AGE_DAYS = 14;
-var DAY = 86400000;
-var INSTALL_SCRIPTS = ["preinstall", "install", "postinstall"];
-var GIT_PREFIX = /^git\+/;
-var VERSION_SEPARATOR = /(?<=.)@/;
 function parseSpec(text) {
   const at = text.search(VERSION_SEPARATOR);
   return at === -1 ? { name: text } : { name: text.slice(0, at), request: text.slice(at + 1) };
@@ -1157,16 +1444,15 @@ function analyze(input) {
     report.warnings.push(`${version} is deprecated: ${report.deprecated}`);
   return report;
 }
-
-// src/config.ts
-import { homedir } from "os";
-import { dirname, join } from "path";
-import process6 from "process";
+var DEFAULT_MIN_AGE_DAYS = 14, DAY = 86400000, INSTALL_SCRIPTS, GIT_PREFIX, VERSION_SEPARATOR;
+var init_analyze = __esm(() => {
+  init_nearmiss();
+  INSTALL_SCRIPTS = ["preinstall", "install", "postinstall"];
+  GIT_PREFIX = /^git\+/;
+  VERSION_SEPARATOR = /(?<=.)@/;
+});
 
 // src/registry.ts
-var PUBLIC_REGISTRY = "https://registry.npmjs.org";
-var DOWNLOADS_API = "https://api.npmjs.org/downloads/point/last-week";
-var TRAILING_SLASHES = /\/+$/;
 function isPublic(registry) {
   return registry.url.replace(TRAILING_SLASHES, "") === PUBLIC_REGISTRY;
 }
@@ -1192,14 +1478,16 @@ async function fetchDownloads(name, fetcher = fetch) {
   const body = await response.json();
   return body.downloads;
 }
+var PUBLIC_REGISTRY = "https://registry.npmjs.org", DOWNLOADS_API = "https://api.npmjs.org/downloads/point/last-week", TRAILING_SLASHES;
+var init_registry = __esm(() => {
+  init_src();
+  TRAILING_SLASHES = /\/+$/;
+});
 
 // src/config.ts
-var ENV_REFERENCE = /\$\{(\w+)\}|\$(\w+)/g;
-var COMMENT = /^\s*[#;]/;
-var SCOPE_REGISTRY = /^(@[^:]+):registry$/;
-var AUTH_TOKEN = /^(\/\/.+?):_authToken$/;
-var PROTOCOL = /^\w+:/;
-var QUOTES = /^(["'])(.*)\1$/;
+import { homedir } from "os";
+import { dirname, join } from "path";
+import process7 from "process";
 function expand(value, env) {
   let missing = false;
   const expanded = value.replace(ENV_REFERENCE, (_, braced, bare) => {
@@ -1275,7 +1563,7 @@ async function readIfThere(path) {
   const file = Bun.file(path);
   return await file.exists() ? file.text() : undefined;
 }
-async function loadConfigs(cwd = process6.cwd(), env = process6.env, home = homedir()) {
+async function loadConfigs(cwd = process7.cwd(), env = process7.env, home = homedir()) {
   const directories = [];
   for (let dir = cwd;!directories.includes(dir); dir = dirname(dir))
     directories.push(dir);
@@ -1292,16 +1580,22 @@ async function loadConfigs(cwd = process6.cwd(), env = process6.env, home = home
   }
   return configs;
 }
+var ENV_REFERENCE, COMMENT, SCOPE_REGISTRY, AUTH_TOKEN, PROTOCOL, QUOTES;
+var init_config2 = __esm(() => {
+  init_registry();
+  ENV_REFERENCE = /\$\{(\w+)\}|\$(\w+)/g;
+  COMMENT = /^\s*[#;]/;
+  SCOPE_REGISTRY = /^(@[^:]+):registry$/;
+  AUTH_TOKEN = /^(\/\/.+?):_authToken$/;
+  PROTOCOL = /^\w+:/;
+  QUOTES = /^(["'])(.*)\1$/;
+});
 
 // src/commands/check.ts
-var usage = `pkg <name>[@version]...
-
-Checks npm packages before they are added: whether the name exists, the latest and the newest version at least two weeks old, weekly downloads, licence, repository, install scripts and a near miss of a popular name.
-Exits 1 when a package is missing or the version asked for is under the minimum age.`;
-var options = {
-  json: jsonOption(),
-  "min-age": { type: "string", description: `days a version must be old (${DEFAULT_MIN_AGE_DAYS})` }
-};
+var exports_check = {};
+__export(exports_check, {
+  check: () => check
+});
 async function checkPackage(text, context) {
   const spec = parseSpec(text);
   const registry = registryFor(spec.name, context.configs);
@@ -1350,6 +1644,379 @@ ${usage}`);
 `));
   return reports.some((report) => report.blocked) ? 1 : 0;
 }
+var usage = `pkg [check] <name>[@version]...
+
+Checks npm packages before they are added: whether the name exists, the latest and the newest version at least two weeks old, weekly downloads, licence, repository, install scripts and a near miss of a popular name.
+Exits 1 when a package is missing or the version asked for is under the minimum age.`, options;
+var init_check = __esm(() => {
+  init_src();
+  init_analyze();
+  init_config2();
+  init_registry();
+  options = {
+    json: jsonOption(),
+    "min-age": { type: "string", description: `days a version must be old (${DEFAULT_MIN_AGE_DAYS})` }
+  };
+});
+
+// ../kit/src/progress.ts
+import process8 from "process";
+function liveRegion(render, stream = process8.stderr, env = process8.env) {
+  if (!takesControlCodes(stream, env))
+    return { redraw: () => {
+      return;
+    }, print: (text) => void stream.write(`${text}
+`), stop: () => {
+      return;
+    } };
+  const write = stream.write.bind(stream);
+  let frame = 0;
+  let drawn = 0;
+  const clear = () => {
+    if (drawn > 0)
+      write(`${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}`);
+    drawn = 0;
+  };
+  const draw = () => {
+    const width = (stream.columns === undefined || stream.columns === 0 ? 80 : stream.columns) - 1;
+    const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
+    const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
+    if (lines.length === 0) {
+      clear();
+      return;
+    }
+    write(`${drawn > 0 ? `${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}` : CLEAR_LINE}${lines.join(`
+`)}`);
+    drawn = lines.length;
+  };
+  const timer = setInterval(draw, FRAME_MS);
+  const restore = interceptOutput(clear);
+  const onExit = () => clear();
+  const signals = holdSignals(stop);
+  function stop() {
+    clearInterval(timer);
+    clear();
+    restore();
+    process8.off("exit", onExit);
+    signals.release();
+  }
+  timer.unref();
+  process8.on("exit", onExit);
+  return {
+    redraw: draw,
+    print: (text) => {
+      clear();
+      write(`${text}
+`);
+      draw();
+    },
+    stop
+  };
+}
+function cutToWidth(line, width) {
+  if (Bun.stringWidth(line) <= width)
+    return line;
+  let room = width;
+  let kept = "";
+  let index = 0;
+  let linked = false;
+  while (index < line.length) {
+    ESCAPE_CODE.lastIndex = index;
+    const escape = ESCAPE_CODE.exec(line);
+    if (escape !== null) {
+      kept += escape[0];
+      linked ||= escape[0].startsWith(`${ESC}]`);
+      index = ESCAPE_CODE.lastIndex;
+      continue;
+    }
+    const char = String.fromCodePoint(line.codePointAt(index));
+    const columns = Bun.stringWidth(char);
+    if (columns > room)
+      break;
+    kept += char;
+    room -= columns;
+    index += char.length;
+  }
+  return `${kept}${RESET_STYLE}${linked ? CLOSE_LINK : ""}`;
+}
+function interceptOutput(clear) {
+  const targets = [...CONSOLE_METHODS.map((name) => [console, name]), [process8.stdout, "write"], [process8.stderr, "write"]];
+  const wrapped = targets.map(([target, name]) => {
+    const original = Reflect.get(target, name);
+    const wrapper = (...args) => {
+      clear();
+      return original.apply(target, args);
+    };
+    Reflect.set(target, name, wrapper);
+    return { target, name, original, wrapper };
+  });
+  return () => {
+    for (const { target, name, original, wrapper } of wrapped) {
+      if (Reflect.get(target, name) === wrapper)
+        Reflect.set(target, name, original);
+    }
+  };
+}
+var FRAMES, FRAME_MS = 80, CLEAR_LINE = "\r\x1B[2K", LINE_UP = "\x1B[1A\x1B[2K", ESC, ESCAPE_CODE, RESET_STYLE, CLOSE_LINK, CONSOLE_METHODS;
+var init_progress = __esm(() => {
+  init_format();
+  init_process();
+  init_style();
+  FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  ESC = String.fromCharCode(27);
+  ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
+  RESET_STYLE = `${ESC}[0m`;
+  CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
+  CONSOLE_METHODS = ["log", "info", "warn", "error", "debug", "dir", "dirxml", "table", "trace", "group", "groupCollapsed", "count", "timeEnd", "timeLog", "assert"];
+});
+
+// ../kit/src/shell.ts
+var SEPARATORS2, PLAIN_BREAKERS, DOUBLE_QUOTED_ESCAPES, WRAPPERS;
+var init_shell = __esm(() => {
+  SEPARATORS2 = new Set([`
+`, ";", "|"]);
+  PLAIN_BREAKERS = new Set(["<", ">", "(", ")", "&", "|"]);
+  DOUBLE_QUOTED_ESCAPES = new Set(["$", "`", '"', "\\"]);
+  WRAPPERS = new Set(["command", "env", "sudo", "exec", "nohup", "time"]);
+});
+
+// src/pin.ts
+function actions(byAction) {
+  return new Map(Object.entries(byAction).flatMap(([action, names]) => names.map((name) => [name, action])));
+}
+var LOCKFILES, ACTIONS, OPTION_FLAGS, DIR_FLAGS, VALUE_FLAGS;
+var init_pin = __esm(() => {
+  init_shell();
+  LOCKFILES = [
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["package-lock.json", "npm"]
+  ];
+  ACTIONS = {
+    bun: actions({ install: ["install", "i"], add: ["add", "a"], remove: ["remove", "rm"], update: ["update"] }),
+    pnpm: actions({ install: ["install", "i"], add: ["add"], remove: ["remove", "rm"], update: ["update", "up"] }),
+    yarn: new Map([...actions({ install: ["", "install"], add: ["add"], remove: ["remove"], update: ["upgrade"] }), ["upgrade-interactive", null], ["import", null]]),
+    npm: actions({
+      install: ["install", "i", "in", "ins", "inst", "insta", "instal", "isnt", "isnta", "isntal", "isntall"],
+      add: ["add"],
+      frozen: ["ci", "clean-install", "ic", "install-clean", "isntall-clean"],
+      remove: ["uninstall", "unlink", "remove", "rm", "r", "un"],
+      update: ["update", "u", "up", "upgrade", "udpate"]
+    })
+  };
+  OPTION_FLAGS = new Map([
+    ["-D", "dev"],
+    ["--save-dev", "dev"],
+    ["--dev", "dev"],
+    ["-E", "exact"],
+    ["--save-exact", "exact"],
+    ["--exact", "exact"]
+  ]);
+  DIR_FLAGS = new Set(["--cwd", "-C", "--dir", "--prefix"]);
+  VALUE_FLAGS = new Set([...DIR_FLAGS, "--filter", "-F"]);
+});
+
+// src/consumers.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname as dirname2, join as join2, relative } from "path";
+function packageFiles(dir, depth, found) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name === "package.json")
+      found.push(join2(dir, entry.name));
+    else if (entry.isDirectory() && depth < MAX_DEPTH && !entry.name.startsWith(".") && !SKIPPED.has(entry.name))
+      packageFiles(join2(dir, entry.name), depth + 1, found);
+  }
+  return found;
+}
+function managerFor(dir, root) {
+  for (let at = dir;; at = dirname2(at)) {
+    const lockfile = LOCKFILES.find(([file]) => existsSync(join2(at, file)));
+    if (lockfile !== undefined)
+      return lockfile[1];
+    if (at === root || at === dirname2(at))
+      return "bun";
+  }
+}
+function findConsumers(name, root) {
+  const consumers = [];
+  for (const path of packageFiles(root, 0, []).sort()) {
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+      continue;
+    }
+    const kind = KINDS.find((each) => typeof manifest[each]?.[name] === "string");
+    const spec = kind === undefined ? undefined : manifest[kind]?.[name];
+    if (kind !== undefined && spec !== undefined)
+      consumers.push({ dir: relative(root, dirname2(path)) || ".", path, kind, spec, manager: managerFor(dirname2(path), root) });
+  }
+  return consumers;
+}
+function isLocal(consumer) {
+  return LOCAL_SPEC.test(consumer.spec);
+}
+function addCommand(consumer, name, version) {
+  return ["bun", "add", ...KIND_FLAGS[consumer.kind], "--exact", "--no-cache", `${name}@${version}`];
+}
+var KINDS, SKIPPED, MAX_DEPTH = 5, LOCAL_SPEC, KIND_FLAGS;
+var init_consumers = __esm(() => {
+  init_pin();
+  KINDS = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+  SKIPPED = new Set(["node_modules", "dist", "build", "vendor", "target", "coverage"]);
+  LOCAL_SPEC = /^(?:workspace|link|file|portal):/;
+  KIND_FLAGS = { dependencies: [], devDependencies: ["--dev"], optionalDependencies: ["--optional"], peerDependencies: ["--peer"] };
+});
+
+// src/commands/bump.ts
+var exports_bump = {};
+__export(exports_bump, {
+  ROOT_OPTION: () => ROOT_OPTION,
+  bump: () => bump
+});
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+async function servedVersion(name, version, settings) {
+  const registry = registryFor(name, settings.configs);
+  const host = new URL(registry.url).host;
+  const started = Date.now();
+  const region = liveRegion((spinner) => [`${spinner} waiting for ${host} to serve ${name}@${version} ${formatDuration(Date.now() - started)}`]);
+  try {
+    for (;; ) {
+      const packument = await fetchPackument(name, registry, settings.fetcher);
+      const latest = packument?.["dist-tags"]?.latest;
+      if (version === undefined && latest !== undefined)
+        return latest;
+      if (version === undefined)
+        fail(`${host} has no ${name}`, 1);
+      if (packument?.versions?.[version] !== undefined)
+        return version;
+      if (Date.now() - started >= settings.timeout)
+        fail(`${host} does not serve ${name}@${version} after ${formatDuration(settings.timeout)}`, 1);
+      region.redraw();
+      await Bun.sleep(settings.poll ?? POLL);
+    }
+  } finally {
+    region.stop();
+  }
+}
+async function bumpConsumers(name, version, settings) {
+  const found = findConsumers(name, settings.root);
+  const consumers = found.filter((each) => !isLocal(each));
+  const local = found.length - consumers.length;
+  const run = settings.run ?? (async (argv, cwd) => runCommand(argv, { cwd }));
+  let isClean = true;
+  if (found.length === 0)
+    note(`nothing under ${settings.root} depends on ${name}`);
+  if (local > 0)
+    note(`${local} workspace:, link: or file: dependenc${local === 1 ? "y" : "ies"}`, "left as they are");
+  for (const consumer of consumers) {
+    const argv = addCommand(consumer, name, version);
+    const where = join3(settings.root, consumer.dir);
+    if (consumer.spec === version) {
+      note(consumer.dir, `already on ${version}`);
+    } else if (consumer.manager !== "bun") {
+      warn(consumer.dir, `${consumer.spec}, its lockfile pins ${consumer.manager}: put ${version} in by hand`);
+    } else if (settings.isDryRun === true) {
+      note(consumer.dir, `would run ${argv.join(" ")}`);
+    } else {
+      const ran = await run(argv, where);
+      if (ran.code === 0) {
+        ok(consumer.dir, `${consumer.spec} -> ${version}`);
+      } else {
+        isClean = false;
+        problem(consumer.dir, `${argv.join(" ")} exited ${ran.code}: ${ran.text.trim().split(`
+`).at(-1) ?? ""}`);
+      }
+    }
+  }
+  return isClean;
+}
+async function bump(args) {
+  const { values, positionals: [name, asked] } = parse(args, usage2, options2, { positionals: ["<name>", "[version]"] });
+  const settings = {
+    root: values.root ?? join3(homedir2(), "Workspace"),
+    configs: await loadConfigs(),
+    timeout: duration(values.timeout, "timeout", 10 * 60000),
+    isDryRun: values["dry-run"] === true
+  };
+  const version = await servedVersion(name, asked, settings);
+  return await bumpConsumers(name, version, settings) ? 0 : 1;
+}
+var usage2 = `pkg bump <name> [version]
+
+Waits until the registry serves the version (the latest when none is given), then runs \`bun add --exact --no-cache\` in each folder under --root whose package.json depends on the package, the kind of dependency kept, a line per folder.
+A workspace:, link: or file: dependency, a folder already on the version and one whose lockfile pins another manager are left as they are, each said so.
+Exits 1 when an install fails or the version never shows, 2 on a usage error.`, ROOT_OPTION, options2, POLL = 5000;
+var init_bump = __esm(() => {
+  init_src();
+  init_progress();
+  init_config2();
+  init_consumers();
+  init_registry();
+  ROOT_OPTION = { type: "string", description: "the folder holding the repositories (~/Workspace)" };
+  options2 = {
+    root: ROOT_OPTION,
+    timeout: { type: "string", short: "t", description: "how long to wait for the registry (10m): 30s, 5m, 1h" },
+    "dry-run": { type: "boolean", description: "print what would run, changing nothing" }
+  };
+});
+
+// src/commands/consumers.ts
+var exports_consumers = {};
+__export(exports_consumers, {
+  consumers: () => consumers
+});
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+function consumers(args) {
+  const { values, positionals: [name] } = parse(args, usage3, options3, { positionals: ["<name>"] });
+  const root = values.root ?? join4(homedir3(), "Workspace");
+  const found = findConsumers(name, root);
+  if (values.json === true)
+    printJson(found);
+  else if (found.length === 0)
+    console.log(`nothing under ${root} depends on ${name}`);
+  else
+    console.log(table([["FOLDER", "KIND", "VERSION", "MANAGER"], ...found.map((each) => [each.dir, each.kind, each.spec, each.manager])], { header: true }));
+  return 0;
+}
+var usage3 = `pkg consumers <name>
+
+Lists the folders under --root whose package.json depends on the package: the folder, the kind of dependency, the version it asks for and the manager its lockfile pins.`, options3;
+var init_consumers2 = __esm(() => {
+  init_src();
+  init_consumers();
+  init_bump();
+  options3 = {
+    root: ROOT_OPTION,
+    json: jsonOption("[{dir, path, kind, spec, manager}]")
+  };
+});
 
 // src/cli.ts
-process7.exitCode = await runMain({ name: "pkg", version, run: check });
+init_src();
+import process9 from "process";
+// package.json
+var version = "0.3.0";
+
+// src/cli.ts
+process9.exitCode = await runCli({
+  name: "pkg",
+  version,
+  about: "checks npm packages before they are added, and moves a lib's consumers onto a new release",
+  defaultCommand: "check",
+  commands: {
+    check: { summary: "check packages before they are added (`pkg <name>` alone runs it)", run: async (args) => (await Promise.resolve().then(() => (init_check(), exports_check))).check(args) },
+    bump: { summary: "wait for a release on the registry, then bun add it in every consumer", run: async (args) => (await Promise.resolve().then(() => (init_bump(), exports_bump))).bump(args) },
+    consumers: { summary: "list the folders depending on a package, with the version each asks for", run: async (args) => (await Promise.resolve().then(() => (init_consumers2(), exports_consumers))).consumers(args) }
+  }
+});