@kaynooo/cli-workspace 0.0.0-stage → 0.3.0

package/dist/cli.js

@@ -0,0 +1,2414 @@
+#!/usr/bin/env -S bun --no-env-file
+// @bun
+
+// src/cli.ts
+import process18 from "process";
+
+// ../kit/src/advisory.ts
+var SEVERITIES = ["low", "moderate", "high", "critical"];
+function severityRank(severity) {
+  return SEVERITIES.indexOf(severity);
+}
+function isIgnored(advisory, ignore) {
+  return ignore.includes(advisory.ghsa ?? "") || ignore.includes(String(advisory.id));
+}
+// ../kit/src/args.ts
+import process8 from "process";
+import { parseArgs } from "util";
+
+// ../kit/src/format.ts
+import process6 from "process";
+
+// ../kit/src/style.ts
+import process5 from "process";
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
+function x(s) {
+  let r = s.startsWith("#") ? s.slice(1).toLowerCase() : s.toLowerCase();
+  if (!/^[a-f0-9]+$/.test(r))
+    return [0, 0, 0];
+  let t = r.length, n = (c) => Number.parseInt(c, 16);
+  if (t === 3 || t === 4) {
+    let c = n(r[0] + r[0]), u = n(r[1] + r[1]), h = n(r[2] + r[2]), g = t === 4 ? n(r[3] + r[3]) : undefined;
+    return g !== undefined ? [c, u, h, g] : [c, u, h];
+  }
+  if (t !== 6 && t !== 8)
+    throw Error(`Invalid hex color length: ${t}`);
+  let a = n(r.slice(0, 2)), b = n(r.slice(2, 4)), o = n(r.slice(4, 6)), y = t === 8 ? n(r.slice(6, 8)) : undefined;
+  if ([a, b, o].some(Number.isNaN) || y !== undefined && Number.isNaN(y))
+    throw Error(`Invalid hex color value: ${s}`);
+  return y !== undefined ? [a, b, o, y] : [a, b, o];
+}
+function A(s) {
+  let [r, t, n, a] = s;
+  if (a)
+    return `#${(r << 24 | t << 16 | n << 8 | Math.round((a ?? 1) * 255)).toString(16).padStart(8, "0").toUpperCase()}`;
+  return `#${(r << 16 | t << 8 | n).toString(16).padStart(6, "0").toUpperCase()}`;
+}
+function R(s, r, t) {
+  s = (s % 360 + 360) % 360, t /= 100;
+  let n = r * Math.min(t, 1 - t) / 100, a = (b) => {
+    let o = (b + s / 30) % 12, y = t - n * Math.max(Math.min(o - 3, 9 - o, 1), -1);
+    return Math.round(255 * y);
+  };
+  return [a(0), a(8), a(4)];
+}
+function k(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = 0, y = 0, c = (a + b) / 2;
+  if (a !== b) {
+    let u = a - b;
+    if (y = c > 0 && c < 1 ? u / (1 - Math.abs(2 * c - 1)) : 0, a === r)
+      o = (t - n) / u + (t < n ? 6 : 0);
+    else if (a === t)
+      o = (n - r) / u + 2;
+    else
+      o = (r - t) / u + 4;
+    o /= 6;
+  }
+  return [Math.round(o * 360), Math.round(y * 100), Math.round(c * 100)];
+}
+function H(s, r, t) {
+  s = (s % 360 + 360) % 360, r /= 100, t /= 100;
+  let n = (a) => {
+    let b = (a + s / 60) % 6, o = t - t * r * Math.max(Math.min(b, 4 - b, 1), 0);
+    return Math.round(255 * o);
+  };
+  return [n(5), n(3), n(1)];
+}
+function f(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = a - b, y = 0, c = a === 0 ? 0 : o / a, u = a;
+  if (o !== 0) {
+    if (a === r)
+      y = (t - n) / o + (t < n ? 6 : 0);
+    else if (a === t)
+      y = (n - r) / o + 2;
+    else
+      y = (r - t) / o + 4;
+    y /= 6;
+  }
+  return [Math.round(y * 360), Math.round(c * 100), Math.round(u * 100)];
+}
+function O(s) {
+  let r = s[0] / 255, t = s[1] / 255, n = s[2] / 255, a = 1 - Math.max(r, t, n);
+  if (a === 1)
+    return [0, 0, 0, 100];
+  let b = (1 - r - a) / (1 - a), o = (1 - t - a) / (1 - a), y = (1 - n - a) / (1 - a);
+  return [Math.round(b * 100), Math.round(o * 100), Math.round(y * 100), Math.round(a * 100)];
+}
+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)];
+}
+function M(s, r, t) {
+  let n = (s + 0.3963377774 * r + 0.2158037573 * t) ** 3, a = (s - 0.1055613458 * r - 0.0638541728 * t) ** 3, b = (s - 0.0894841775 * r - 1.291485548 * t) ** 3, o = p(4.0767416621 * n - 3.3077115913 * a + 0.2309699292 * b), y = p(-1.2684380046 * n + 2.6097574011 * a - 0.3413193965 * b), c = p(-0.0041960863 * n - 0.7034186147 * a + 1.707614701 * b), u = (h) => Math.min(255, Math.max(0, Math.round(h * 255)));
+  return [u(o), u(y), u(c)];
+}
+function d(s) {
+  let [r, t, n] = T(s), a = Math.sqrt(t * t + n * n), b = (Math.atan2(n, t) * 180 / Math.PI + 360) % 360;
+  return [i(r, 4), i(a, 4), i(b, 2)];
+}
+function C(s, r, t) {
+  let n = t * Math.PI / 180;
+  return M(s, r * Math.cos(n), r * Math.sin(n));
+}
+function l(s) {
+  let r = s / 255;
+  return r <= 0.03928 ? r / 12.92 : ((r + 0.055) / 1.055) ** 2.4;
+}
+
+class e {
+  r;
+  g;
+  b;
+  a;
+  constructor(s, r, t, n = 1) {
+    this.r = s, this.g = r, this.b = t, this.a = n;
+  }
+  static from(s, r) {
+    if (s === "hex") {
+      let [t, n, a, b] = x(r);
+      return new e(t, n, a, b);
+    }
+    if (s === "rgb") {
+      if (Array.isArray(r)) {
+        let [o, y, c, u] = r;
+        return new e(o, y, c, u);
+      }
+      let { r: t, g: n, b: a, a: b } = r;
+      return new e(t, n, a, b);
+    }
+    if (s === "hsl") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, l: a, a: b } = r);
+      let [o, y, c] = R(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "hsv") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, v: a, a: b } = r);
+      let [o, y, c] = H(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "cmyk") {
+      let t, n, a, b, o;
+      if (Array.isArray(r))
+        [t, n, a, b, o] = r;
+      else
+        ({ c: t, m: n, y: a, k: b, a: o } = r);
+      let [y, c, u] = v(t, n, a, b);
+      return new e(y, c, u, o);
+    }
+    if (s === "oklch") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, c: n, h: a, a: b } = r);
+      let [o, y, c] = C(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "oklab") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, a: n, b: a, alpha: b } = r);
+      let [o, y, c] = M(t, n, a);
+      return new e(o, y, c, b);
+    }
+    throw Error("Invalid input");
+  }
+  to(s) {
+    switch (s) {
+      case "rgb":
+        return [this.r, this.g, this.b];
+      case "rgba":
+        return [this.r, this.g, this.b, this.a];
+      case "hex":
+        return A([this.r, this.g, this.b]);
+      case "hexa":
+        return A([this.r, this.g, this.b, this.a]);
+      case "hsl":
+        return k([this.r, this.g, this.b]);
+      case "hsla":
+        return [...k([this.r, this.g, this.b]), this.a];
+      case "hsv":
+        return f([this.r, this.g, this.b]);
+      case "hsva":
+        return [...f([this.r, this.g, this.b]), this.a];
+      case "cmyk":
+        return O([this.r, this.g, this.b]);
+      case "cmyka":
+        return [...O([this.r, this.g, this.b]), this.a];
+      case "oklch":
+        return d([this.r, this.g, this.b]);
+      case "oklcha":
+        return [...d([this.r, this.g, this.b]), this.a];
+      case "oklab":
+        return T([this.r, this.g, this.b]);
+      case "oklaba":
+        return [...T([this.r, this.g, this.b]), this.a];
+      default:
+        return [this.r, this.g, this.b];
+    }
+  }
+  getLuminance() {
+    let s = l(this.r), r = l(this.g), t = l(this.b);
+    return 0.2126 * s + 0.7152 * r + 0.0722 * t;
+  }
+  contrastRatio(s) {
+    let r = this.getLuminance(), t = s.getLuminance(), [n, a] = r >= t ? [r, t] : [t, r];
+    return (n + 0.05) / (a + 0.05);
+  }
+  bestContrastForeground() {
+    let s = new e(255, 255, 255, 1), r = new e(0, 0, 0, 1), t = this.contrastRatio(s), n = this.contrastRatio(r);
+    return t >= n ? s : r;
+  }
+}
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.2+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);
+  if (n.NO_COLOR !== undefined || n.NODE_DISABLE_COLORS !== undefined || n.TERM === "dumb")
+    return false;
+  return i?.isTTY === true;
+}
+function d2(i, n, a) {
+  if (!h(a.stream ?? globalThis.process?.stdout, a.env))
+    return n;
+  let l = "", s = "";
+  for (let g = 0, y = i.length;g < y; g++) {
+    let [c, p] = i[g];
+    l += `${f2}${c}m`, s = `${f2}${p}m${s}`;
+  }
+  return l + n + s;
+}
+function u(i, n = []) {
+  return new Proxy((l) => d2(n, l, i), { get(l, s) {
+    let g = C2[s];
+    if (Array.isArray(g))
+      return u(i, [...n, g]);
+    if (typeof g === "function")
+      return (...y) => u(i, [...n, g(...y)]);
+    throw Error(`Unknown style: ${String(s)}`);
+  } });
+}
+function le(i = {}) {
+  return u(i);
+}
+var t = le();
+
+// ../kit/src/theme.ts
+import { existsSync as existsSync3, readFileSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
+import process4 from "process";
+
+// ../kit/src/config.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import process2 from "process";
+function findUp(names, from = process2.cwd(), stop = () => false) {
+  const wanted = typeof names === "string" ? [names] : names;
+  for (let dir = resolve(from);; dir = dirname(dir)) {
+    const found = wanted.map((name) => join(dir, name)).find((path) => existsSync(path));
+    if (found !== undefined)
+      return found;
+    if (stop(dir) || dirname(dir) === dir)
+      return;
+  }
+}
+
+// ../kit/src/user-config.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import process3 from "process";
+function configBase(where = {}) {
+  const xdg = where.xdg ?? (where.home === undefined ? process3.env.XDG_CONFIG_HOME : undefined);
+  return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
+}
+function userConfigPath(bin, where = {}) {
+  return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
+}
+function userConfigReadPath(bin, legacy = [], where = {}) {
+  const current = userConfigPath(bin, where);
+  if (existsSync2(current))
+    return current;
+  const base = configBase(where);
+  return legacy.map((parts) => join2(base, ...parts)).find((path) => existsSync2(path)) ?? current;
+}
+
+// ../kit/src/theme.ts
+var DEFAULT = {
+  colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
+  glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501" },
+  accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
+  bins: {}
+};
+var BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
+var MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
+var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#" };
+var PRESETS = {
+  default: {},
+  "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"] },
+  mono: { colors: MONO, accents: ["bold"] },
+  ascii: { glyphs: ASCII }
+};
+var STYLES = new Set(["bold", "dim", "italic", "underline", "inverse", "strikethrough", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray", "grey", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright"]);
+var HEX = /^#[0-9a-f]{6}$/i;
+var CONTROL = /\p{Cc}/u;
+var MAX_FILE_BYTES = 64 * 1024;
+var SPACES = /\s+/;
+function isColorSpec(spec) {
+  if (typeof spec === "number")
+    return Number.isInteger(spec) && spec >= 0 && spec <= 255;
+  return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
+}
+function tinted(colors, spec) {
+  if (typeof spec === "number")
+    return colors.ansi256(spec);
+  return spec.trim().split(SPACES).reduce((chain, token) => HEX.test(token) ? chain.hex(token) : chain[token] ?? chain, colors);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readThemeFile(path, warn) {
+  try {
+    const stat = statSync(path, { throwIfNoEntry: false });
+    if (stat === undefined)
+      return;
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+      warn(`${path} is not a regular file under ${MAX_FILE_BYTES / 1024} KiB, theme ignored`);
+      return;
+    }
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (isRecord(parsed))
+      return parsed;
+    warn(`${path} is not a JSON object, theme ignored`);
+  } catch (error) {
+    warn(`${path} does not parse (${error instanceof Error ? error.message : String(error)}), theme ignored`);
+  }
+  return;
+}
+function applyPreset(theme, name, warn, where) {
+  if (name === undefined)
+    return;
+  if (typeof name !== "string" || !Object.hasOwn(PRESETS, name)) {
+    warn(`${where}: no preset ${String(name)}, one of ${Object.keys(PRESETS).join(", ")}`);
+    return;
+  }
+  const preset = PRESETS[name];
+  Object.assign(theme.colors, preset.colors);
+  Object.assign(theme.glyphs, preset.glyphs);
+  if (preset.accents !== undefined)
+    theme.accents = [...preset.accents];
+  return name;
+}
+function applyFile(theme, file, where, warn) {
+  if (isRecord(file.colors)) {
+    for (const [key, value] of Object.entries(file.colors)) {
+      if (!Object.hasOwn(DEFAULT.colors, key))
+        warn(`${where}: no colour ${key}, one of ${Object.keys(DEFAULT.colors).join(", ")}`);
+      else if (!isColorSpec(value))
+        warn(`${where}: colour ${key} is not an ANSI name, \`#rrggbb\` or a number up to 255`);
+      else
+        theme.colors[key] = value;
+    }
+  }
+  if (isRecord(file.glyphs)) {
+    for (const [key, value] of Object.entries(file.glyphs)) {
+      if (!Object.hasOwn(DEFAULT.glyphs, key))
+        warn(`${where}: no glyph ${key}, one of ${Object.keys(DEFAULT.glyphs).join(", ")}`);
+      else if (typeof value !== "string" || CONTROL.test(value) || Bun.stringWidth(value) !== 1)
+        warn(`${where}: glyph ${key} must be one visible character wide, with no control character`);
+      else
+        theme.glyphs[key] = value;
+    }
+  }
+  if (Array.isArray(file.accents) && file.accents.length > 0 && file.accents.every(isColorSpec))
+    theme.accents = [...file.accents];
+  else if (file.accents !== undefined)
+    warn(`${where}: accents must be a non-empty list of colours`);
+  if (isRecord(file.bins)) {
+    for (const [bin, value] of Object.entries(file.bins)) {
+      if (isColorSpec(value))
+        theme.bins[bin] = value;
+      else
+        warn(`${where}: bin ${bin} has no valid colour`);
+    }
+  }
+}
+function endsWalk(home) {
+  return (dir) => dir === resolve2(home) || existsSync3(join3(dir, ".git"));
+}
+var warned = new Set;
+function warnOnce(message) {
+  if (warned.has(message))
+    return;
+  warned.add(message);
+  console.error(`warning: theme ${message}`);
+}
+function isPath(chosen) {
+  return chosen.includes("/") || chosen.endsWith(".json");
+}
+function loadTheme({ env = process4.env, from = process4.cwd(), home = homedir2(), warn = warnOnce } = {}) {
+  const theme = { colors: { ...DEFAULT.colors }, glyphs: { ...DEFAULT.glyphs }, accents: [...DEFAULT.accents], bins: Object.create(null) };
+  const sources = [];
+  const chosen = env.KIT_THEME ?? "";
+  const wanted = chosen === "" ? [userConfigPath("theme", { home, xdg: env.XDG_CONFIG_HOME }), findUp(join3(".kaynooo", "theme.json"), from, endsWalk(home))] : [];
+  if (isPath(chosen))
+    wanted.push(resolve2(from, chosen));
+  const files = [];
+  for (const path of wanted) {
+    const file = path === undefined ? undefined : readThemeFile(path, warn);
+    if (path !== undefined && file !== undefined)
+      files.push({ path, file });
+  }
+  let preset = "default";
+  if (chosen !== "" && !isPath(chosen)) {
+    preset = applyPreset(theme, chosen, warn, "KIT_THEME") ?? preset;
+  } else {
+    const named = files.findLast(({ file }) => file.preset !== undefined);
+    if (named !== undefined)
+      preset = applyPreset(theme, named.file.preset, warn, named.path) ?? preset;
+  }
+  for (const { path, file } of files) {
+    applyFile(theme, file, path, warn);
+    sources.push(path);
+  }
+  return { theme, sources, preset };
+}
+var current;
+var currentKey = "";
+function activeTheme() {
+  const key = `${process4.cwd()}\x00${process4.env.KIT_THEME ?? ""}\x00${process4.env.XDG_CONFIG_HOME ?? ""}`;
+  if (current === undefined || key !== currentKey) {
+    current = loadTheme();
+    currentKey = key;
+  }
+  return current;
+}
+
+// ../kit/src/style.ts
+var MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:" };
+function takesControlCodes(stream, env = process5.env) {
+  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
+}
+function paint(stream, env = process5.env) {
+  return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
+}
+function marked(mark, text, stream, detail, env = process5.env) {
+  const colors = paint(stream, env);
+  let head = MARK_WORDS[mark];
+  if (takesControlCodes(stream, env)) {
+    const { theme } = activeTheme();
+    head = tinted(colors.bold, theme.colors[mark])(theme.glyphs[mark]);
+  }
+  return `${head} ${text}${detail === undefined ? "" : ` ${colors.dim(detail)}`}`;
+}
+function ok(text, detail) {
+  console.log(marked("ok", text, process5.stdout, detail));
+}
+function note(text, detail) {
+  console.log(marked("note", text, process5.stdout, detail));
+}
+function problem(text, detail) {
+  console.error(marked("problem", text, process5.stderr, detail));
+}
+function role(name, stream, env = process5.env) {
+  const colors = paint(stream, env);
+  return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name]) : colors;
+}
+var STATUS_WORDS = {
+  passed: ["passed", "success", "succeeded", "ok"],
+  failed: ["failed", "failure", "error", "errored"],
+  running: ["running", "in_progress", "started"],
+  queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
+  skipped: ["skipped", "cancelled", "canceled", "manual"]
+};
+var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
+// ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-hrsswv1w.js
+function $e(t, e = false, i = 1) {
+  let n = typeof e === "object" ? e : { units: e ? "si" : "iec", dp: i }, { units: s = "iec", dp: u = 1 } = n, r = s === "si" ? 1000 : 1024;
+  if (Math.abs(t) < r)
+    return `${t} B`;
+  let c = s === "iec" ? ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"] : ["kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"], o = -1, l = 10 ** u;
+  do
+    t /= r, ++o;
+  while (Math.round(Math.abs(t) * l) / l >= r && o < c.length - 1);
+  return `${t.toFixed(u)} ${c[o]}`;
+}
+
+// ../kit/src/format.ts
+var UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
+function formatSeconds(total) {
+  let rest = Math.max(0, Math.round(total));
+  const amounts = UNITS.map(([unit, size]) => {
+    const amount = Math.floor(rest / size);
+    rest -= amount * size;
+    return `${amount}${unit}`;
+  });
+  const first = amounts.findIndex((amount) => !amount.startsWith("0"));
+  if (first === -1)
+    return "0s";
+  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);
+}
+function formatAge(date, now = Date.now()) {
+  const at = typeof date === "number" ? date : Date.parse(date);
+  if (Number.isNaN(at))
+    return "-";
+  const seconds = (now - at) / 1000;
+  return seconds < 60 ? "just now" : `${upTo(formatSeconds(seconds), " ")} ago`;
+}
+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);
+}
+function table(rows, { cellWidth, header = false, align = [], fit, stream = process6.stdout } = {}) {
+  const cells = cellWidth === undefined ? rows : rows.map((row) => row.map((cell) => truncate(cell.replaceAll(LINE_BREAKS, " "), cellWidth)));
+  const widths = [];
+  for (const row of cells) {
+    for (const [index, cell] of row.entries())
+      widths[index] = Math.max(widths[index] ?? 0, textWidth(cell));
+  }
+  const shown = fit === undefined ? cells : narrow(cells, widths, fit);
+  const colors = paint(stream);
+  const lines = shown.map((row) => row.map((cell, index) => {
+    const width = widths[index] ?? 0;
+    const gap = " ".repeat(Math.max(0, width - textWidth(cell)));
+    if (align[index] === "right")
+      return `${gap}${cell}`;
+    return index === row.length - 1 ? cell : `${cell}${gap}`;
+  }).join("  ").trimEnd());
+  const rule = header && takesControlCodes(stream) && lines.length > 1 ? [colors.dim("\u2500".repeat(Math.max(...lines.map(textWidth))))] : [];
+  return lines.flatMap((line, index) => header && index === 0 ? [colors.bold(line), ...rule] : [line]).join(`
+`);
+}
+function narrow(rows, widths, limit) {
+  const used = () => widths.reduce((sum, width) => sum + width, 0) + 2 * Math.max(0, widths.length - 1);
+  const cuttable = (index) => rows.every((row) => !(row[index] ?? "").includes(ESCAPE));
+  const floor = 8;
+  while (used() > limit) {
+    let widest = -1;
+    for (const [index, width] of widths.entries()) {
+      if (cuttable(index) && width > floor && width > (widths[widest] ?? 0))
+        widest = index;
+    }
+    if (widest === -1)
+      break;
+    widths[widest] = Math.max(floor, (widths[widest] ?? 0) - (used() - limit));
+  }
+  return rows.map((row) => row.map((cell, index) => textWidth(cell) > (widths[index] ?? 0) ? truncate(cell, widths[index] ?? 0) : cell));
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, undefined, 2));
+}
+
+// ../kit/src/help.ts
+import process7 from "process";
+var OPTIONAL = /\[[^\]]+\]/g;
+var USAGE_PREFIX = /^usage:\s*/i;
+var FULL_STOP = /\.$/;
+function usageLine(usage, colors = paint(process7.stdout)) {
+  return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
+}
+function helpText(usage, options, colors = paint(process7.stdout), { examples = [], replaces, exits = [] } = {}) {
+  return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
+`);
+}
+function exitRows(exits, colors = paint(process7.stdout)) {
+  if (exits.length === 0)
+    return [];
+  const width = Math.max(...exits.map(([code]) => String(code).length));
+  return ["", colors.bold("Exits:"), ...exits.map(([code, meaning]) => `  ${colors.cyan(String(code).padEnd(width))}  ${meaning}`)];
+}
+function replacesRows(replaces, colors = paint(process7.stdout)) {
+  return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
+}
+function wantsHelpJson(env = process7.env) {
+  return env.KIT_HELP === "json";
+}
+function description(usage, { examples = [], replaces, exits } = {}, options) {
+  const lines = usage.replace(USAGE_PREFIX, "").split(`
+`);
+  const first = lines[0];
+  const colon = first.indexOf(": ");
+  const prose = lines[lines.indexOf("") + 1] ?? "";
+  const fallback = lines.includes("") ? `${prose.charAt(0).toLowerCase()}${prose.slice(1)}`.replace(FULL_STOP, "") : "";
+  return {
+    synopsis: colon === -1 ? first : first.slice(0, colon),
+    summary: colon === -1 ? fallback : first.slice(colon + 2),
+    ...replaces === undefined ? {} : { replaces },
+    examples: examples.map((example) => typeof example === "string" ? { line: example } : { line: example[0], note: example[1] }),
+    ...exits === undefined ? {} : { exits: exits.map(([code, meaning]) => ({ code, meaning })) },
+    ...options === undefined ? {} : { options: Object.entries(options).map(([name, { short, description }]) => ({ name, ...short === undefined ? {} : { short }, ...description === undefined ? {} : { description } })) }
+  };
+}
+function exampleRows(examples, colors = paint(process7.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(process7.stdout)) {
+  const rows = Object.entries(options).map(([name, option]) => {
+    const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
+    const named = option.choices === undefined ? "<value>" : `<${option.choices.join("|")}>`;
+    const placeholder = option.optional === undefined ? named : `[${named}]`;
+    const value = option.type === "string" ? ` ${colors.dim(placeholder)}` : "";
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? placeholder.length + 1 : 0), description: option.description ?? "" };
+  });
+  const width = Math.max(0, ...rows.map((row) => row.width));
+  return rows.map((row) => row.description === "" ? `  ${row.flag}` : `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
+}
+
+// ../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()) {
+    const current = [i + 1];
+    for (const [j, right] of [...b].entries())
+      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+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;
+}
+// ../kit/src/input.ts
+var DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
+var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+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, 1h or 7d, not ${value}`);
+  return ms;
+}
+
+// ../kit/src/args.ts
+var DASHES = /^-+/;
+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, hint) {
+    super(message, 2, hint);
+  }
+}
+function badUsage(message) {
+  throw new UsageError(message);
+}
+
+class HelpShown extends Exit {
+  constructor() {
+    super("help shown", 0);
+  }
+}
+
+class Completing {
+  options;
+  positionals;
+  candidates;
+  constructor(options, positionals = [], candidates = {}) {
+    this.options = options;
+    this.positionals = positionals;
+    this.candidates = candidates;
+  }
+}
+var completion = { active: false };
+var 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" }
+};
+function applyOutput(color, plain, env = process8.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 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" } };
+  const listing = listed(all, settings.allowNegative === true);
+  if (completion.active)
+    throw new Completing(listing, settings.positionals, settings.candidates);
+  const { own, rest } = settings.trailing === true ? splitTrailing(args, all, settings.positionals?.length ?? 0) : splitRest(args, settings.rest === true);
+  let parsed;
+  try {
+    parsed = parseArgs({ args: joinDashValues(withBare(withAliases(own, all), all), all), options: all, allowPositionals: true, allowNegative: settings.allowNegative === true, strict: true });
+  } catch (error) {
+    const message = parseError(error);
+    throw new UsageError(message, nearestOption(message, all, settings.allowNegative === true));
+  }
+  const values = parsed.values;
+  applyOutput("color" in output ? values.color : undefined, "plain" in output ? values.plain : undefined);
+  if (values.help === true) {
+    console.log(wantsHelpJson() ? JSON.stringify(description(usage, settings, listing)) : helpText(usage, listing, undefined, settings));
+    throw new HelpShown;
+  }
+  checkChoices(parsed.values, all);
+  checkConflicts(parsed.values, all);
+  if (settings.positionals !== undefined)
+    checkPositionals(parsed.positionals, settings.positionals);
+  return { ...parsed, values: parsed.values, positionals: parsed.positionals, rest };
+}
+function splitRest(args, passes) {
+  const separator = passes ? args.indexOf("--") : -1;
+  return { own: separator === -1 ? args : args.slice(0, separator), rest: separator === -1 ? undefined : args.slice(separator + 1) };
+}
+function splitTrailing(args, options, count) {
+  const takesValue = (word) => !word.includes("=") && Object.entries(options).some(([name, { short, type }]) => type === "string" && (word === `--${name}` || word === `-${short}`));
+  let seen = 0;
+  if (count === 0)
+    return { own: args, rest: undefined };
+  for (let at = 0;at < args.length; at++) {
+    const word = args[at];
+    if (word === "--")
+      break;
+    if (word.startsWith("-")) {
+      if (takesValue(word))
+        at++;
+      continue;
+    }
+    seen++;
+    if (seen === count)
+      return { own: args.slice(0, at + 1), rest: args.slice(at + 1) };
+  }
+  return { own: args, rest: undefined };
+}
+function listed(options, allowNegative) {
+  if (!allowNegative)
+    return options;
+  return Object.fromEntries(Object.entries(options).flatMap(([name, option]) => {
+    if (option.type !== "boolean" || option.negative === undefined)
+      return [[name, option]];
+    return [...option.description === undefined ? [] : [[name, option]], [`no-${name}`, { type: "boolean", description: option.negative }]];
+  }));
+}
+function withAliases(args, options) {
+  const named = new Map(Object.entries(options).flatMap(([name, { aliases = [] }]) => aliases.map((alias) => [`--${alias}`, `--${name}`])));
+  if (named.size === 0)
+    return args;
+  const separator = args.indexOf("--");
+  const own = separator === -1 ? args : args.slice(0, separator);
+  return [...own.map((arg) => {
+    const at = arg.indexOf("=");
+    const current = named.get(at === -1 ? arg : arg.slice(0, at));
+    return current === undefined ? arg : `${current}${at === -1 ? "" : arg.slice(at)}`;
+  }), ...separator === -1 ? [] : args.slice(separator)];
+}
+function withBare(args, options) {
+  const bare = new Map(Object.entries(options).flatMap(([name, { short, optional }]) => optional === undefined ? [] : [[`--${name}`, optional], ...short === undefined ? [] : [[`-${short}`, optional]]]));
+  if (bare.size === 0)
+    return args;
+  const separator = args.indexOf("--");
+  const own = separator === -1 ? args : args.slice(0, separator);
+  return [...own.flatMap((arg, index) => {
+    const optional = bare.get(arg);
+    const next = own[index + 1];
+    const value = next !== undefined && (optional?.accepts === undefined ? !next.startsWith("-") : optional.accepts.test(next));
+    return optional === undefined || value ? [arg] : [arg, optional.bare];
+  }), ...separator === -1 ? [] : args.slice(separator)];
+}
+function checkConflicts(values, options) {
+  const given = (name) => values[name] !== undefined && values[name] !== false;
+  for (const [name, { conflicts = [] }] of Object.entries(options)) {
+    const other = given(name) ? conflicts.find(given) : undefined;
+    if (other !== undefined)
+      badUsage(`--${name} cannot be used with --${other}`);
+  }
+}
+function checkChoices(values, options) {
+  for (const [name, option] of Object.entries(options)) {
+    if (option.choices === undefined)
+      continue;
+    const given = values[name];
+    for (const value of Array.isArray(given) ? given : [given]) {
+      if (typeof value === "string")
+        oneOf(value, name, option.choices);
+    }
+  }
+}
+function oneOf(value, name, choices) {
+  if (!choices.includes(value))
+    badUsage(`${name.startsWith("<") ? name : `--${name}`} takes one of ${choices.join(", ")}, not ${value}`);
+  return value;
+}
+function checkPositionals(given, names) {
+  const variadic = names.at(-1)?.replace("]", "").endsWith("...") === true;
+  const required = names.filter((name) => !name.startsWith("[")).length;
+  if (given.length < required)
+    badUsage(`missing ${names[given.length]}`);
+  if (!variadic && given.length > names.length)
+    badUsage(`unexpected argument ${given[names.length]}`);
+}
+function joinDashValues(args, options) {
+  const longOf = new Map(Object.entries(options).flatMap(([name, option]) => option.short === undefined ? [[`--${name}`, name]] : [[`--${name}`, name], [`-${option.short}`, name]]));
+  const isOption = (arg) => arg === "--" || longOf.has(arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg);
+  const joined = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--")
+      return [...joined, ...args.slice(i)];
+    const name = longOf.get(arg);
+    const next = args[i + 1];
+    if (name !== undefined && options[name]?.type === "string" && next !== undefined && next.startsWith("-") && next !== "-" && !isOption(next)) {
+      joined.push(`--${name}=${next}`);
+      i++;
+    } else {
+      joined.push(arg);
+    }
+  }
+  return joined;
+}
+function parseError(error) {
+  const message = upTo(error instanceof Error ? error.message : String(error), ". ");
+  return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
+}
+var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
+function nearestOption(message, options, allowNegative) {
+  const typed = UNKNOWN_OPTION.exec(message)?.[1];
+  if (typed === undefined)
+    return;
+  const word = typed.replace(DASHES, "");
+  if (word.length < 2 && !typed.startsWith("--"))
+    return;
+  const known = Object.entries(options).flatMap(([name, option]) => [
+    ...option.short === undefined ? [] : [`-${option.short}`],
+    `--${name}`,
+    ...allowNegative && option.type === "boolean" ? [`--no-${name}`] : []
+  ]);
+  const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
+  return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
+}
+// ../kit/src/process.ts
+import { constants } from "os";
+import process9 from "process";
+var KILL_GRACE_MS = 2000;
+function exitCodeOf(code, signal) {
+  if (code !== null)
+    return code;
+  if (typeof signal === "number")
+    return 128 + signal;
+  return signal === null ? 129 : 128 + constants.signals[signal];
+}
+async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
+  const chunks = [];
+  const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
+  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
+  const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
+  const timers = [];
+  const killGroup = (killing) => {
+    if (state.done)
+      return;
+    try {
+      if (grouped)
+        process9.kill(-proc.pid, killing);
+      else
+        proc.kill(killing);
+    } catch {}
+  };
+  const stop = () => {
+    killGroup("SIGTERM");
+    timers.push(setTimeout(killGroup, KILL_GRACE_MS, "SIGKILL"));
+  };
+  const onAbort = () => stop();
+  if (timeoutMs !== undefined) {
+    timers.push(setTimeout(() => {
+      state.timedOut = true;
+      stop();
+    }, timeoutMs));
+  }
+  if (signal?.aborted === true)
+    onAbort();
+  else
+    signal?.addEventListener("abort", onAbort, { once: true });
+  onStart?.({ kill: (killing) => killGroup(killing) });
+  const drain = async (stream, name) => {
+    for await (const data of stream) {
+      if (state.failure !== undefined)
+        continue;
+      try {
+        onChunk?.({ stream: name, data });
+      } catch (error) {
+        state.failure = error;
+        stop();
+        continue;
+      }
+      if (state.kept + data.length > maxBytes) {
+        state.truncated = true;
+        continue;
+      }
+      state.kept += data.length;
+      chunks.push({ stream: name, data });
+    }
+  };
+  try {
+    await Promise.all([drain(proc.stdout, "stdout"), drain(proc.stderr, "stderr")]);
+    await proc.exited;
+  } finally {
+    state.done = true;
+    for (const timer of timers)
+      clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+  if (state.failure !== undefined)
+    throw state.failure;
+  const joined = () => Buffer.concat(chunks.map(({ data }) => data));
+  let output;
+  let text;
+  return {
+    code: exitCodeOf(proc.exitCode, proc.signalCode),
+    chunks,
+    timedOut: state.timedOut,
+    truncated: state.truncated,
+    get output() {
+      return output ??= joined();
+    },
+    get text() {
+      return text ??= (output ??= joined()).toString();
+    }
+  };
+}
+
+// ../kit/src/progress.ts
+var ESC = String.fromCharCode(27);
+var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
+var RESET_STYLE = `${ESC}[0m`;
+var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
+
+// ../kit/src/tool.ts
+import process10 from "process";
+function cwdGone() {
+  try {
+    process10.cwd();
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+class SpawnError extends Error {
+  missing;
+  constructor(message, missing) {
+    super(message);
+    this.missing = missing;
+  }
+}
+function spawnFailure(command, error) {
+  const gone = cwdGone();
+  const missing = !gone && error?.code === "ENOENT";
+  return new SpawnError(`${command}: ${error instanceof Error ? error.message : String(error)}${gone ? " (the working directory was removed)" : ""}`, missing);
+}
+async function runTool(label, argv, { timeoutMs, cwd, onStart } = {}) {
+  let ran;
+  try {
+    ran = await runCommand(argv, { env: process10.env, ...timeoutMs === undefined ? {} : { timeoutMs }, ...cwd === undefined ? {} : { cwd }, ...onStart === undefined ? {} : { onStart } });
+  } catch (error) {
+    throw spawnFailure(label, error);
+  }
+  if (ran.timedOut)
+    throw new Error(`${label}: no answer in ${formatDuration(timeoutMs ?? 0)}`);
+  const decoders = { stdout: new TextDecoder, stderr: new TextDecoder };
+  const streams = { stdout: "", stderr: "" };
+  for (const { stream, data } of ran.chunks)
+    streams[stream] += decoders[stream].decode(data, { stream: true });
+  streams.stdout += decoders.stdout.decode();
+  streams.stderr += decoders.stderr.decode();
+  return { code: ran.code, ...streams };
+}
+// ../kit/src/cli.ts
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import process12 from "process";
+
+// ../kit/src/usage.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, isAbsolute, join as join4 } from "path";
+import process11 from "process";
+
+// ../kit/src/logs.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+var CLI_FOLDER = "kaynooo-cli";
+
+// ../kit/src/usage.ts
+var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
+var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
+var LONGEST_NAME = 40;
+var usageError;
+function noteUsageError(message) {
+  usageError = message;
+}
+function stateHome(env = process11.env) {
+  const dir = env.XDG_STATE_HOME;
+  return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
+}
+function usagePath(env = process11.env) {
+  return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
+}
+function usageRecorded(env = process11.env) {
+  const off = env.KAYNOOO_CLI_NO_USAGE;
+  return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
+}
+function flagNames(argv) {
+  const end = argv.indexOf("--");
+  const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
+  return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
+}
+function usageEntry(bin, command, argv, code, now = new Date) {
+  const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
+  usageError = undefined;
+  return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
+}
+function recordUsage(entry, env = process11.env) {
+  if (!usageRecorded(env))
+    return;
+  try {
+    const path = usagePath(env);
+    mkdirSync(dirname2(path), { recursive: true, mode: 448 });
+    appendFileSync(path, `${JSON.stringify(entry)}
+`, { mode: 384 });
+  } catch {}
+}
+
+// ../kit/src/cli.ts
+var LEVEL_OPTIONS = {
+  ...OUTPUT_OPTIONS,
+  help: { type: "boolean", short: "h", description: "show this help" }
+};
+var TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
+async function commandRows(all, colors) {
+  const commands = shown(all);
+  const width = Math.max(0, ...Object.keys(commands).map((name) => name.length));
+  const groups = new Map([["Commands:", []]]);
+  const summaries = await Promise.all(Object.values(commands).map(async ({ summary }) => resolveSummary(summary)));
+  for (const [index, [name, { group }]] of Object.entries(commands).entries()) {
+    const heading = group === undefined ? "Commands:" : `${group}:`;
+    const rows = groups.get(heading) ?? [];
+    rows.push(`  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summaries[index])}`);
+    groups.set(heading, rows);
+  }
+  return [...groups].filter(([, rows]) => rows.length > 0).flatMap(([heading, rows], index) => [...index === 0 ? [] : [""], colors.bold(heading), ...rows]);
+}
+function shown(commands) {
+  return Object.fromEntries(Object.entries(commands).filter(([, { hidden }]) => hidden !== true));
+}
+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);
+}
+async function resolveSummary(summary) {
+  return typeof summary === "string" ? summary : summary();
+}
+function scopeOf(commands, extra, aliases) {
+  return { commands: typeof commands === "function" ? {} : commands, lazy: [...typeof commands === "function" ? [commands] : [], ...extra === undefined ? [] : [extra]], aliases };
+}
+async function expand(scope, words) {
+  if (scope.lazy.length === 0)
+    return scope;
+  const commands = { ...scope.commands };
+  for (const added of await Promise.all(scope.lazy.map(async (lazy) => lazy(words)))) {
+    for (const [name, command] of Object.entries(added))
+      commands[name] ??= command;
+  }
+  return { ...scope, commands, lazy: [] };
+}
+async function help2({ path, header, summary: lazySummary, commands, defaultCommand, examples, replaces }, stream) {
+  const colors = paint(stream);
+  const prefix = path.join(" ");
+  const summary = await resolveSummary(lazySummary);
+  if (wantsHelpJson())
+    return JSON.stringify(description(`${prefix} <command> [options]: ${summary}`, { examples, replaces }));
+  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, summary),
+    "",
+    usageLine(`${prefix} ${defaultCommand === undefined ? colors.cyan("<command>") : `[${colors.cyan("<command>")}]`} [options]`, colors),
+    ...replacesRows(replaces, colors),
+    "",
+    ...await 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(process12.stderr);
+  const styled = takesControlCodes(process12.stderr);
+  const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
+  const under = (label, text, tint) => text === undefined ? "" : `
+  ${styled ? tint(label) : `${label}:`} ${text}`;
+  console.error(`${head} ${message}${under("cause", cause, colors.dim)}${under("hint", hint, colors.yellow)}`);
+}
+function printJsonError(message, hint, cause) {
+  console.error(JSON.stringify({ error: message, ...hint === undefined ? {} : { hint }, ...cause === undefined ? {} : { cause } }));
+}
+function wantsJson(argv) {
+  const end = argv.indexOf("--");
+  return (end === -1 ? argv : argv.slice(0, end)).includes("--json");
+}
+function reportThrown(prefix, error, redact = (text) => text, json = false) {
+  if (error instanceof HelpShown)
+    return 0;
+  const help = error instanceof UsageError ? `run ${prefix} --help for its options` : undefined;
+  const named = error instanceof Error && !(error instanceof Exit) && error.name !== "Error" ? `${error.name}: ${error.message}` : undefined;
+  const cause = error instanceof Error && error.cause instanceof Error ? redact(error.cause.message) : undefined;
+  if (error instanceof Exit && error.code === 2)
+    noteUsageError(error.message);
+  const report = json ? printJsonError : (message, hint, causeText) => printError(prefix, message, hint, causeText);
+  report(redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
+  return error instanceof Exit ? error.code : 1;
+}
+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;
+  const fallback = level.defaultCommand === undefined ? undefined : level.commands[level.defaultCommand];
+  if (name === undefined && level.runBare && fallback !== undefined && "run" in fallback) {
+    try {
+      return await fallback.run([]);
+    } catch (error) {
+      return reportThrown(`${prefix} ${level.defaultCommand}`, error, redact, false);
+    }
+  }
+  if (name === undefined && level.path.length > 1) {
+    console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]), process12.stderr));
+    return 2;
+  }
+  if (name === undefined || name === "help" || name === "--help" || name === "-h") {
+    console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]), process12.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;
+  let ran = name;
+  if (command === undefined && level.lazy.length > 0) {
+    level = await expand(level, [...level.path.slice(1), ...argv]);
+    command = level.commands[level.aliases?.[name] ?? name];
+  }
+  if (command === undefined && level.defaultCommand !== undefined) {
+    command = level.commands[level.defaultCommand];
+    rest = argv;
+    ran = level.defaultCommand;
+  }
+  if (command === undefined) {
+    const meant = closest(name, Object.keys(shown(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, text) => `${colors.bold(`${prefix} ${name}`)}  ${text}`, summary, ...scopeOf(command.commands, command.extraCommands, command.aliases), defaultCommand: undefined, runBare: false, examples: command.examples, replaces: undefined }, rest, { version, redact });
+  }
+  try {
+    return await command.run(rest);
+  } catch (error) {
+    return reportThrown(`${prefix} ${ran}`, error, redact, wantsJson(rest));
+  }
+}
+var COMPLETE = "__complete";
+var FILES = "__files__";
+async function completingOf(run) {
+  completion.active = true;
+  try {
+    await run([]);
+  } catch (error) {
+    if (error instanceof Completing)
+      return error;
+  } finally {
+    completion.active = false;
+  }
+  return new Completing({});
+}
+async function optionsOf(run) {
+  return (await completingOf(run)).options;
+}
+function candidateLine(candidate) {
+  return typeof candidate === "string" ? candidate : candidate.join("\t");
+}
+function positionalBeingTyped(before, { options, positionals }) {
+  const takesValue = (word) => !word.includes("=") && Object.entries(options).some(([name, { short, type }]) => type === "string" && (word === `--${name}` || word === `-${short}`));
+  let index = 0;
+  let at = 0;
+  while (at < before.length) {
+    const word = before[at];
+    if (word === "--") {
+      index += before.length - at - 1;
+      break;
+    }
+    if (!word.startsWith("-"))
+      index++;
+    else if (takesValue(word))
+      at++;
+    at++;
+  }
+  const last = positionals.at(-1);
+  if (index < positionals.length)
+    return positionals[index];
+  return last?.replace("]", "").endsWith("...") === true ? last : undefined;
+}
+async function leafCandidates(run, words) {
+  const completing = await completingOf(run);
+  if ((words.at(-1) ?? "").startsWith("-"))
+    return Object.entries(completing.options).map(([name, option]) => option.description === undefined ? `--${name}` : `--${name}	${option.description}`);
+  const flag = words.at(-2);
+  const option = flag?.startsWith("-") === true ? Object.entries(completing.options).find(([name, { short }]) => flag === `--${name}` || flag === `-${short}`)?.[1] : undefined;
+  if (option?.type === "string") {
+    const values = option.choices === undefined ? await option.candidates?.() : option.choices;
+    return values === undefined ? [FILES] : values.map(candidateLine);
+  }
+  const name = positionalBeingTyped(words.slice(0, -1), completing);
+  const values = name === undefined ? undefined : await completing.candidates[name]?.();
+  return values === undefined ? [FILES] : values.map(candidateLine);
+}
+async function candidates(scope, defaultCommand, words, before = []) {
+  const [word = "", ...rest] = words;
+  const listing = rest.length === 0 && !word.startsWith("-");
+  let { commands, aliases } = scope;
+  let command = commands[aliases?.[word] ?? word];
+  if (listing || command === undefined) {
+    ({ commands, aliases } = await expand(scope, [...before, ...words]));
+    command = commands[aliases?.[word] ?? word];
+  }
+  if (listing) {
+    const own = await Promise.all(Object.entries(shown(commands)).map(async ([name, { summary }]) => `${name}	${await resolveSummary(summary)}`));
+    const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
+    const values = fallback !== undefined && "run" in fallback ? await leafCandidates(fallback.run, [word]) : [];
+    const valueOf = (line) => line.slice(0, line.includes("\t") ? line.indexOf("\t") : undefined);
+    return [...own, ...values.filter((line) => line !== FILES && !(valueOf(line) in commands))];
+  }
+  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(scopeOf(command.commands, command.extraCommands, command.aliases), undefined, rest, [...before, word]) : leafCandidates(command.run, rest);
+}
+async function printCandidates(found) {
+  for (const line of await found)
+    console.log(line);
+  return 0;
+}
+function packageVersion(entry = Bun.main) {
+  for (let dir = dirname3(realpathSync(entry));; dir = dirname3(dir)) {
+    try {
+      const { version } = JSON.parse(readFileSync2(join5(dir, "package.json"), "utf8"));
+      if (typeof version === "string")
+        return version;
+    } catch {}
+    if (dirname3(dir) === dir)
+      return "0.0.0";
+  }
+}
+async function runCli(cli, argv = process12.argv.slice(2)) {
+  const version = cli.version ?? packageVersion();
+  if (argv[0] === COMPLETE)
+    return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
+  const code = await dispatch({ path: [cli.name], header: (colors, about) => `${colors.bold(cli.name)} ${colors.dim(version)}  ${about}`, summary: cli.about, ...scopeOf(cli.commands, cli.extraCommands, cli.aliases), defaultCommand: cli.defaultCommand, runBare: cli.runBare === true, examples: cli.examples, replaces: cli.replaces }, argv, { version, redact: cli.redact });
+  if (cli.usage !== false) {
+    try {
+      recordUsage(usageEntry(cli.name, commandPath(scopeOf(cli.commands, cli.extraCommands, cli.aliases), argv), argv, code));
+    } catch {}
+  }
+  return code;
+}
+function commandPath(scope, argv) {
+  const path = [];
+  let level = scope;
+  for (const word of argv.filter((each) => !each.startsWith("-"))) {
+    const name = level.aliases !== undefined && Object.hasOwn(level.aliases, word) ? level.aliases[word] ?? word : word;
+    const command = Object.hasOwn(level.commands, name) ? level.commands[name] : undefined;
+    if (command === undefined)
+      break;
+    path.push(word);
+    if (!("commands" in command))
+      break;
+    level = scopeOf(command.commands, command.extraCommands, command.aliases);
+  }
+  return path.length === 0 ? undefined : path.join(" ");
+}
+async function runMain({ name, version, run, redact, usage }, argv = process12.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 ?? packageVersion());
+    return 0;
+  }
+  let code;
+  try {
+    code = await run(argv);
+  } catch (error) {
+    code = reportThrown(name, error, redact, wantsJson(argv));
+  }
+  if (usage !== false) {
+    try {
+      recordUsage(usageEntry(name, undefined, argv, code));
+    } catch {}
+  }
+  return code;
+}
+// ../kit/src/secrets.ts
+var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
+// ../kit/src/sessions.ts
+var {Glob } = globalThis.Bun;
+var SESSION_FILES = new Glob("*.json");
+var ACCOUNT_DIRS = new Glob("*/sessions");
+// ../kit/src/size.ts
+var SIZE = /^(\d+(?:\.\d+)?)\s*([kmgt]?)i?b?$/i;
+var POWERS = { "": 0, k: 1, m: 2, g: 3, t: 4 };
+function parseSize(text, bareUnit = 1) {
+  const match = SIZE.exec(text.trim());
+  if (match === null)
+    return;
+  const suffix = match[2].toLowerCase();
+  return Math.round(Number(match[1]) * (suffix === "" ? bareUnit : 1024 ** POWERS[suffix]));
+}
+// src/audit.ts
+import { existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
+import { readdir } from "fs/promises";
+import { join as join7, relative, resolve as resolve3 } from "path";
+import process14 from "process";
+
+// src/report.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
+var UPPER_BOUND = /<\s*(\d[\w.+-]*)/;
+var DEPENDENCY_KINDS = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+var GHSA = /GHSA-[\w-]+$/;
+function parseAudit(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function fixedAt(range) {
+  const bounds = range.split("||").map((part) => UPPER_BOUND.exec(part)?.[1]);
+  if (bounds.length === 0 || bounds.includes(undefined))
+    return;
+  return bounds.reduce((highest, bound) => Bun.semver.order(bound, highest) > 0 ? bound : highest);
+}
+function fixFor(advisories) {
+  const fixes = advisories.map((advisory) => fixedAt(advisory.vulnerable_versions));
+  if (fixes.length === 0 || fixes.includes(undefined))
+    return;
+  return fixes.reduce((highest, fix) => Bun.semver.order(fix, highest) > 0 ? fix : highest);
+}
+function findingsOf(audit, reaching, direct, level, ignore = []) {
+  const found = [];
+  for (const [name, all] of Object.entries(audit)) {
+    const kept = all.filter((advisory) => severityRank(advisory.severity) >= severityRank(level) && !isIgnored({ id: advisory.id, ghsa: GHSA.exec(advisory.url)?.[0] }, ignore));
+    if (kept.length === 0)
+      continue;
+    const advisories = kept.map((advisory) => ({ id: advisory.id, ghsa: GHSA.exec(advisory.url)?.[0], url: advisory.url, title: advisory.title, severity: advisory.severity, fixed: fixedAt(advisory.vulnerable_versions) }));
+    found.push({
+      package: name,
+      severity: advisories.reduce((worst, advisory) => severityRank(advisory.severity) > severityRank(worst) ? advisory.severity : worst, advisories[0].severity),
+      advisories,
+      scope: reaching.has(name) ? "prod" : "dev",
+      direct: direct.has(name),
+      fix: fixFor(kept)
+    });
+  }
+  return found.toSorted((a, b) => severityRank(b.severity) - severityRank(a.severity) || Number(b.scope === "prod") - Number(a.scope === "prod") || a.package.localeCompare(b.package));
+}
+function readManifest(path) {
+  try {
+    return existsSync4(path) ? JSON.parse(readFileSync3(path, "utf8")) : {};
+  } catch {
+    return {};
+  }
+}
+function namesIn(manifest) {
+  return DEPENDENCY_KINDS.flatMap((kind) => {
+    const section = manifest[kind];
+    return typeof section === "object" && section !== null ? Object.keys(section) : [];
+  });
+}
+function directDependencies(root, workspaces) {
+  const names = new Set(namesIn(readManifest(join6(root, "package.json"))));
+  for (const workspace of workspaces) {
+    for (const name of namesIn(readManifest(join6(root, workspace, "package.json"))))
+      names.add(name);
+  }
+  return names;
+}
+function workspacePatterns(field) {
+  if (Array.isArray(field))
+    return field;
+  const packages = typeof field === "object" && field !== null ? field.packages : undefined;
+  return Array.isArray(packages) ? packages : [];
+}
+function workspaceFolders(root, children) {
+  const patterns = workspacePatterns(readManifest(join6(root, "package.json")).workspaces);
+  return patterns.filter((pattern) => typeof pattern === "string").flatMap((pattern) => pattern.endsWith("/*") ? children(pattern.slice(0, -2)).map((name) => join6(pattern.slice(0, -2), name)) : [pattern]);
+}
+
+// src/audit.ts
+var USAGE = `audit [options] [root]: the known vulnerabilities of the Bun repositories under root (the current folder by default), one table per repository
+
+Each package with an advisory is one row: its worst severity, how many advisories, whether a production dependency needs it (prod) or only a development one (dev), whether the repository asks for it itself (direct) or a dependency does (the row then says via), and the version that fixes every advisory at once, "-" when an advisory names none. The worst and the production ones come first.
+It runs \`bun audit --json\` in each repository holding a bun.lock, which reaches the registry; the walk goes three levels deep, stops at a bun.lock and skips node_modules and hidden folders.
+
+Reach for it to sweep many repositories at once; \`pkg audit\` vets the one repository in a folder (package age, install scripts, licences) as well as its advisories, and shares --level, --prod and --ignore.`;
+var EXITS = [[0, "no repository has an advisory at the level asked"], [1, "one has"], [2, "a repository's audit failed, no bun.lock sits under root, a usage error or a root that is no folder"]];
+var OPTIONS = {
+  level: { type: "string", choices: SEVERITIES, default: "moderate", description: "only the advisories at least this severe: low, moderate, high or critical" },
+  prod: { type: "boolean", description: "only the packages a production dependency needs" },
+  ignore: { type: "string", multiple: true, description: "an advisory skipped by GHSA or numeric id, repeatable" },
+  json: jsonOption("[{repo, path, findings: [{package, severity, scope, direct, fix, advisories: [{id, ghsa, url, title, severity, fixed}]}], error}]")
+};
+var MAX_DEPTH = 3;
+var CONCURRENCY = 4;
+var AUDIT_MS = 60000;
+function holdsLock(dir) {
+  return existsSync5(join7(dir, "bun.lock")) || existsSync5(join7(dir, "bun.lockb"));
+}
+async function findRepos(root) {
+  if (holdsLock(root))
+    return [root];
+  const found = [];
+  async function walk(dir, depth) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+      if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith("."))
+        continue;
+      const path = join7(dir, entry.name);
+      if (holdsLock(path))
+        found.push(path);
+      else if (depth < MAX_DEPTH)
+        await walk(path, depth + 1);
+    }
+  }
+  await walk(root, 1);
+  return found;
+}
+async function pool(items, limit, task) {
+  const results = Array.from({ length: items.length });
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await task(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return results;
+}
+function children(root) {
+  return (folder) => {
+    try {
+      return readdirSync(join7(root, folder), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    } catch {
+      return [];
+    }
+  };
+}
+async function audited(path, shown, level, ignore) {
+  const [all, production] = await Promise.all([
+    runCommand(["bun", "audit", "--json"], { cwd: path, timeoutMs: AUDIT_MS }),
+    runCommand(["bun", "audit", "--json", "--prod"], { cwd: path, timeoutMs: AUDIT_MS })
+  ]);
+  const audit = parseAudit(stdoutOf(all));
+  const reached = parseAudit(stdoutOf(production));
+  if (audit === undefined || reached === undefined)
+    return { repo: shown, path, findings: [], error: failure(audit === undefined ? all : production) };
+  const reaching = new Set(Object.keys(reached));
+  const direct = directDependencies(path, workspaceFolders(path, children(path)));
+  return { repo: shown, path, findings: findingsOf(audit, reaching, direct, level, ignore), error: undefined };
+}
+function stdoutOf(ran) {
+  return Buffer.concat(ran.chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString();
+}
+function failure(ran) {
+  return ran.timedOut ? `timed out after ${AUDIT_MS / 1000}s` : ran.text.trim().split(`
+`).at(-1) ?? `exit ${ran.code}`;
+}
+function tint(severity) {
+  const colors = paint(process14.stdout);
+  if (severity === "critical" || severity === "high")
+    return colors.red;
+  return severity === "moderate" ? colors.yellow : colors.dim;
+}
+function rows(findings) {
+  return findings.map((found) => [
+    found.package,
+    tint(found.severity)(found.severity),
+    String(found.advisories.length),
+    found.scope,
+    found.direct ? "direct" : "via",
+    found.fix ?? "-"
+  ]);
+}
+async function audit(args) {
+  const { values, positionals } = parse(args, USAGE, OPTIONS, { positionals: ["[root]"], exits: EXITS, replaces: "a bun audit run in each repository and a read of every advisory to find what is worth fixing", examples: ["audit", "audit ~/Workspace --level high --prod"] });
+  const root = resolve3(positionals[0] ?? ".");
+  if (!existsSync5(root) || !statSync2(root).isDirectory())
+    fail(`no folder ${root}`);
+  const level = oneOf(values.level, "level", SEVERITIES);
+  const paths = await findRepos(root);
+  if (paths.length === 0)
+    fail(`no bun.lock under ${root}`);
+  const audits = await pool(paths, CONCURRENCY, async (path) => audited(path, relative(root, path) || ".", level, values.ignore ?? []));
+  const kept = audits.map((each) => ({ ...each, findings: values.prod === true ? each.findings.filter((found) => found.scope === "prod") : each.findings }));
+  if (values.json === true)
+    printJson(kept);
+  else
+    show(kept, audits.length);
+  if (kept.some((each) => each.error !== undefined))
+    return 2;
+  return kept.some((each) => each.findings.length > 0) ? 1 : 0;
+}
+function show(audits, total) {
+  const label = role("label", process14.stdout);
+  const path = role("path", process14.stdout);
+  const flagged = audits.filter((each) => each.error !== undefined || each.findings.length > 0);
+  if (flagged.length === 0) {
+    console.log(label(`no advisory in ${total} ${total === 1 ? "repository" : "repositories"}`));
+    return;
+  }
+  for (const each of flagged) {
+    console.log(`${path(each.repo)} ${label(each.error === undefined ? `${each.findings.length} ${each.findings.length === 1 ? "package" : "packages"}` : `audit failed: ${each.error}`)}`);
+    if (each.findings.length > 0)
+      console.log(table([["package", "severity", "advisories", "scope", "origin", "fix"], ...rows(each.findings)], { header: true, align: ["left", "left", "right", "left", "left", "left"] }));
+  }
+}
+
+// src/repos.ts
+import { existsSync as existsSync7, statSync as statSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join9, relative as relative2, resolve as resolve4 } from "path";
+import process16 from "process";
+
+// src/repos-scan.ts
+import { existsSync as existsSync6 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { basename, join as join8 } from "path";
+import process15 from "process";
+var MAX_DEPTH2 = 3;
+var CONCURRENCY2 = 8;
+var GIT_MS = 1e4;
+var FETCH_MS = 30000;
+var AHEAD_BEHIND = /\+(\d+) -(\d+)/;
+var PACKAGE_TAG = /^(.+)-v\d/;
+var REASONS = ["dirty", "unpushed", "unreleased", "behind"];
+function reasonsOf(repo) {
+  const reasons = [];
+  if (repo.dirty > 0)
+    reasons.push("dirty");
+  if ((repo.ahead ?? 0) > 0)
+    reasons.push("unpushed");
+  if ((repo.behind ?? 0) > 0)
+    reasons.push("behind");
+  if ((repo.unreleased ?? 0) > 0)
+    reasons.push("unreleased");
+  return reasons;
+}
+async function findRepos2(root, skip) {
+  if (existsSync6(join8(root, ".git")))
+    return [root];
+  const found = [];
+  async function walk(dir, depth) {
+    let entries;
+    try {
+      entries = await readdir2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+      if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".") || skip.has(entry.name))
+        continue;
+      const path = join8(dir, entry.name);
+      if (existsSync6(join8(path, ".git")))
+        found.push(path);
+      else if (depth < MAX_DEPTH2)
+        await walk(path, depth + 1);
+    }
+  }
+  await walk(root, 1);
+  return found;
+}
+async function read(path, args, timeoutMs = GIT_MS) {
+  try {
+    const ran = await runCommand(["git", "--no-optional-locks", ...args], { cwd: path, env: { ...process15.env, GIT_TERMINAL_PROMPT: "0" }, timeoutMs });
+    return ran.code === 0 && !ran.timedOut ? ran.text.trim() : undefined;
+  } catch {
+    return;
+  }
+}
+async function commitsSince(path, tag, folder) {
+  const count = await read(path, ["rev-list", "--count", `${tag}..HEAD`, ...folder === undefined ? [] : ["--", folder]]);
+  return Number(count ?? 0);
+}
+async function packageReleases(path) {
+  const names = new Set;
+  for (const tag of (await read(path, ["tag", "--list"]) ?? "").split(`
+`)) {
+    const name = PACKAGE_TAG.exec(tag)?.[1];
+    if (name !== undefined)
+      names.add(name);
+  }
+  const releases = [];
+  for (const name of [...names].toSorted()) {
+    const folder = [join8("packages", name), name].find((candidate) => existsSync6(join8(path, candidate)));
+    const tag = folder === undefined ? undefined : await read(path, ["describe", "--tags", "--abbrev=0", "--match", `${name}-v*`]);
+    if (folder !== undefined && tag !== undefined && tag !== "")
+      releases.push({ name, tag, unreleased: await commitsSince(path, tag, folder) });
+  }
+  return releases;
+}
+async function inspect(path, fetch) {
+  const fetched = fetch ? await read(path, ["fetch", "--quiet"], FETCH_MS) : "";
+  const [status, worktrees, packages] = await Promise.all([
+    read(path, ["status", "--porcelain=v2", "--branch"]),
+    read(path, ["worktree", "list", "--porcelain"]),
+    packageReleases(path)
+  ]);
+  const state = { name: basename(path), path, branch: "?", upstream: null, dirty: 0, ahead: null, behind: null, worktrees: 0, tag: null, unreleased: null, packages, fetchFailed: fetched === undefined, unreadable: status === undefined };
+  for (const line of (status ?? "").split(`
+`)) {
+    if (line.startsWith("# branch.head "))
+      state.branch = line.slice("# branch.head ".length);
+    else if (line.startsWith("# branch.upstream "))
+      state.upstream = line.slice("# branch.upstream ".length);
+    else if (line.startsWith("# branch.ab "))
+      [state.ahead, state.behind] = AHEAD_BEHIND.exec(line)?.slice(1).map(Number);
+    else if (line !== "" && !line.startsWith("#"))
+      state.dirty++;
+  }
+  state.worktrees = Math.max(0, (worktrees ?? "").split(`
+`).filter((line) => line.startsWith("worktree ")).length - 1);
+  if (packages.length > 0) {
+    state.unreleased = packages.reduce((sum, release) => sum + release.unreleased, 0);
+  } else {
+    const tag = await read(path, ["describe", "--tags", "--abbrev=0"]);
+    if (tag !== undefined && tag !== "") {
+      state.tag = tag;
+      state.unreleased = await commitsSince(path, tag);
+    }
+  }
+  return state;
+}
+function pullBlocker(repo) {
+  if (repo.unreadable)
+    return "unreadable";
+  if (repo.fetchFailed)
+    return "fetch failed";
+  if (repo.branch === "(detached)")
+    return "detached HEAD";
+  if (repo.upstream === null)
+    return "no upstream";
+  if (repo.dirty > 0)
+    return `${repo.dirty} dirty ${repo.dirty === 1 ? "file" : "files"}`;
+  return (repo.ahead ?? 0) > 0 ? `diverged, ${repo.ahead} ahead` : undefined;
+}
+function firstLine(text) {
+  const end = text.indexOf(`
+`);
+  return end === -1 ? text : text.slice(0, end);
+}
+async function fastForward(path) {
+  try {
+    const ran = await runCommand(["git", "--no-optional-locks", "merge", "--ff-only", "--quiet", "@{upstream}"], { cwd: path, env: { ...process15.env, GIT_TERMINAL_PROMPT: "0" }, timeoutMs: GIT_MS });
+    if (ran.timedOut)
+      return "timed out";
+    return ran.code === 0 ? undefined : firstLine(ran.text.trim()) || `exit ${ran.code}`;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+async function pool2(items, limit, task) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await task(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return results;
+}
+
+// src/repos.ts
+var USAGE2 = `repos [options] [root]: the git repositories under root (~/Workspace by default) that need attention, with their branch, dirty files, ahead/behind their upstream, linked worktrees and commits since their latest tag
+
+A repository with nothing to report is left out unless --all. A monorepo tagging its packages <folder>-v<version> counts the unreleased commits per package folder. The walk goes ${MAX_DEPTH2} levels deep, stops at a .git and skips node_modules, hidden folders and the names in "skip" of ~/.config/kaynooo-cli/repos.json.
+
+Ahead and behind are those of the last fetch unless --fetch refreshes the upstreams first, which reaches the remote.
+--pull fetches, then fast-forwards the repositories listed that are clean, on a branch and only behind their upstream, and touches nothing else: a dirty, ahead, diverged or detached one is reported as skipped. A repository pulled is listed again as it now stands.
+--path prints only the paths of the repositories listed, one per line, for xargs -d '\\n'.`;
+var EXITS2 = [[0, "it listed the repositories, including when none needs attention"], [1, "a fast-forward --pull attempted failed"], [2, "a usage error, an unreadable config or a root that is no folder"]];
+var OPTIONS2 = {
+  all: { type: "boolean", short: "a", description: "list the repositories with nothing to report too" },
+  only: { type: "string", choices: REASONS, description: "only the repositories with this reason: dirty, unpushed, unreleased or behind" },
+  fetch: { type: "boolean", description: "refresh the upstreams first (reaches the remote)" },
+  pull: { type: "boolean", description: "fetch, then fast-forward the clean repositories listed that are only behind their upstream (reaches the remote)" },
+  path: { type: "boolean", conflicts: ["json"], description: "print only the paths of the repositories listed, one per line" },
+  json: jsonOption("[{name, path, branch, upstream, dirty, ahead, behind, worktrees, tag, unreleased, packages, reasons, fetchFailed, unreadable}]")
+};
+async function skipped() {
+  const file = userConfigReadPath("repos");
+  if (!existsSync7(file))
+    return new Set;
+  try {
+    const config = await Bun.file(file).json();
+    return new Set(Array.isArray(config.skip) ? config.skip.filter((name) => typeof name === "string") : []);
+  } catch (error) {
+    fail(`${file} does not parse: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function releasedCell(repo) {
+  if (repo.packages.length > 0)
+    return repo.packages.filter((release) => release.unreleased > 0).map((release) => `${release.name} ${release.unreleased}`).join(", ") || "-";
+  return repo.tag === null || repo.unreleased === 0 ? "-" : `${repo.unreleased} since ${repo.tag}`;
+}
+function syncCell(repo, stream = process16.stdout) {
+  const colors = paint(stream);
+  const ahead = repo.ahead ?? 0;
+  const behind = repo.behind ?? 0;
+  if (repo.upstream === null)
+    return colors.dim("no upstream");
+  const parts = [ahead > 0 ? colors.green(`+${ahead}`) : "", behind > 0 ? colors.red(`-${behind}`) : ""].filter(Boolean);
+  const diverged = takesControlCodes(stream) && ahead > 0 && behind > 0;
+  return parts.length === 0 ? colors.dim("-") : `${parts.join(" ")}${diverged ? colors.yellow(" diverged") : ""}`;
+}
+function branchCell(repo) {
+  const colors = paint(process16.stdout);
+  if (repo.unreadable)
+    return colors.red("? (unreadable)");
+  return repo.branch === "(detached)" ? colors.yellow(repo.branch) : repo.branch;
+}
+function row(repo, shown) {
+  const colors = paint(process16.stdout);
+  const tint = role("path", process16.stdout);
+  const unreleased = releasedCell(repo);
+  return [
+    tint(shown),
+    branchCell(repo),
+    repo.dirty === 0 ? colors.dim("-") : colors.yellow(String(repo.dirty)),
+    syncCell(repo),
+    repo.worktrees === 0 ? colors.dim("-") : String(repo.worktrees),
+    unreleased === "-" ? colors.dim("-") : colors.cyan(unreleased)
+  ];
+}
+async function repos(args) {
+  const { values, positionals } = parse(args, USAGE2, OPTIONS2, { positionals: ["[root]"], exits: EXITS2, replaces: "a cd, git status, git log and git tag loop over each repository of the workspace", examples: ["repos", "repos ~/Workspace --only unreleased --fetch", ["repos --only behind --pull", "fast-forward what is behind and clean"], ["repos --only dirty --path", "the paths, for xargs"]] });
+  const root = resolve4(positionals[0] ?? join9(homedir4(), "Workspace"));
+  if (!existsSync7(root) || !statSync3(root).isDirectory())
+    fail(`no folder ${root}`);
+  const only = values.only === undefined ? undefined : oneOf(values.only, "only", REASONS);
+  const paths = await findRepos2(root, await skipped());
+  const states = await pool2(paths, CONCURRENCY2, async (path) => inspect(path, values.fetch === true || values.pull === true));
+  const keeps = (repo) => {
+    const reasons = reasonsOf(repo);
+    return only === undefined ? values.all === true || reasons.length > 0 || repo.unreadable : reasons.includes(only);
+  };
+  let failedPulls = 0;
+  if (values.pull === true) {
+    const log = values.json === true || values.path === true ? console.error : console.log;
+    for (const [index, repo] of states.entries()) {
+      if (!keeps(repo) || (repo.behind ?? 0) === 0)
+        continue;
+      const blocker = pullBlocker(repo);
+      const refused = blocker === undefined ? await fastForward(repo.path) : undefined;
+      if (blocker !== undefined) {
+        log(marked("note", `${repo.name} skipped`, process16.stdout, blocker));
+      } else if (refused !== undefined) {
+        failedPulls++;
+        log(marked("problem", `${repo.name} not pulled`, process16.stdout, refused));
+      } else {
+        log(marked("ok", `${repo.name} pulled`, process16.stdout, `${repo.behind} ${repo.behind === 1 ? "commit" : "commits"}`));
+        states[index] = await inspect(repo.path, false);
+      }
+    }
+  }
+  const kept = states.filter(keeps);
+  if (values.path === true) {
+    for (const repo of kept)
+      console.log(repo.path);
+    return failedPulls > 0 ? 1 : 0;
+  }
+  if (values.json === true) {
+    printJson(kept.map((repo) => ({ ...repo, reasons: reasonsOf(repo) })));
+    return failedPulls > 0 ? 1 : 0;
+  }
+  const label = role("label", process16.stdout);
+  if (kept.length === 0) {
+    console.log(label(`nothing needs attention in ${states.length} repositories`));
+    return failedPulls > 0 ? 1 : 0;
+  }
+  console.log(table([["repo", "branch", "dirty", "ahead/behind", "worktrees", "unreleased"], ...kept.map((repo) => row(repo, relative2(root, repo.path) || repo.name))], { header: true, align: ["left", "left", "right", "left", "right", "left"] }));
+  const failed = kept.filter((repo) => repo.fetchFailed).map((repo) => repo.name);
+  if (failed.length > 0)
+    console.log(label(`fetch failed for ${failed.join(", ")}`));
+  if (values.fetch !== true)
+    console.log(label("ahead/behind as of the last fetch, --fetch refreshes them"));
+  return failedPulls > 0 ? 1 : 0;
+}
+
+// src/sweep.ts
+import { existsSync as existsSync10, statSync as statSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join13, relative as relative3, resolve as resolve5 } from "path";
+
+// ../kit/src/prompt.ts
+import process17 from "process";
+var KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|[\s\S]/giu;
+var CONTROL2 = /^[\x00-\x1F\x7F]/;
+var KEYS = { "\x1B[A": "up", "\x1BOA": "up", "\x1B[B": "down", "\x1BOB": "down", "\r": "enter", "\n": "enter", "\x03": "cancel", "\x1B": "cancel", "\x7F": "erase", "\b": "erase" };
+function readKeys(input) {
+  return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => KEYS[sequence] ?? (CONTROL2.test(sequence) ? [] : [{ text: sequence }]));
+}
+async function confirm(question, { default: fallback, ...settings } = {}) {
+  let answered = fallback;
+  const choices = { true: "Y/n", false: "y/N", undefined: "y/n" }[String(fallback)];
+  const accepted = await ask(question, settings, (colors, state) => [state === "asking" ? asking(colors, question, "", choices) : answer(colors, question, state, answered ? "yes" : "no")], (key) => {
+    if (key === "cancel")
+      return "cancel";
+    if (key === "enter")
+      return answered === undefined ? undefined : "enter";
+    const letter = typeof key === "object" ? key.text.toLowerCase() : "";
+    if (letter !== "y" && letter !== "n")
+      return;
+    answered = letter === "y";
+    return "enter";
+  });
+  return accepted ? answered : undefined;
+}
+function asking(colors, question, typed, keys) {
+  return `${colors.cyan("?")} ${question} ${typed === "" ? colors.dim(`(${keys})`) : typed}`;
+}
+function answer(colors, question, state, picked) {
+  return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
+}
+async function ask(question, { hint, terminal = process17 }, render, press) {
+  const { stdin, stderr } = terminal;
+  if (stdin.isTTY !== true || stderr.isTTY !== true)
+    fail(`cannot ask "${question}" off a terminal`, 2, hint);
+  const colors = paint(stderr);
+  let drawn = 0;
+  let outcome;
+  const draw = (state) => {
+    const frame = render(colors, state, { columns: stderr.columns || 80, rows: stderr.rows || 24 });
+    stderr.write(`${drawn > 1 ? `\x1B[${drawn - 1}A` : ""}\r\x1B[0J${frame.join(`
+`)}`);
+    drawn = frame.length;
+  };
+  try {
+    stdin.setRawMode(true);
+    stdin.resume();
+    stderr.write("\x1B[?25l");
+    draw("asking");
+    return await new Promise((resolve) => {
+      function onData(data) {
+        for (const key of readKeys(data.toString())) {
+          const pressed = press(key);
+          if (pressed !== undefined) {
+            settle(pressed);
+            return;
+          }
+        }
+        draw("asking");
+      }
+      function onEnd() {
+        settle("cancel");
+      }
+      function settle(settled) {
+        outcome = settled;
+        stdin.off("data", onData);
+        stdin.off("end", onEnd);
+        resolve(settled === "enter");
+      }
+      stdin.on("data", onData);
+      stdin.on("end", onEnd);
+    });
+  } finally {
+    draw(outcome ?? "cancel");
+    stderr.write(`
+\x1B[?25h`);
+    stdin.setRawMode(false);
+    stdin.pause();
+  }
+}
+
+// src/apply.ts
+import { existsSync as existsSync9 } from "fs";
+import { lstat as lstat3, rm } from "fs/promises";
+import { basename as basename3, join as join12 } from "path";
+
+// src/sweep-scan.ts
+import { existsSync as existsSync8 } from "fs";
+import { lstat as lstat2, readdir as readdir4, realpath } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { basename as basename2, dirname as dirname4, join as join11 } from "path";
+
+// src/size.ts
+import { lstat, readdir as readdir3 } from "fs/promises";
+import { join as join10 } from "path";
+async function pooled(items, limit, work) {
+  const results = Array.from({ length: items.length });
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await work(items[index]);
+    }
+  }));
+  return results;
+}
+var FS_LIMIT = 32;
+var waiting = [];
+var running = 0;
+async function gated(call) {
+  if (running >= FS_LIMIT)
+    await new Promise((resolve) => waiting.push(resolve));
+  running++;
+  try {
+    return await call();
+  } finally {
+    running--;
+    waiting.shift()?.();
+  }
+}
+async function sizeOf(folder) {
+  const seen = new Set;
+  let total = 0;
+  const visit = async (dir) => {
+    let entries;
+    try {
+      entries = await gated(async () => readdir3(dir, { withFileTypes: true }));
+    } catch {
+      return;
+    }
+    await Promise.all(entries.map(async (entry) => {
+      const path = join10(dir, entry.name);
+      if (entry.isDirectory())
+        return visit(path);
+      try {
+        const stat = await gated(async () => lstat(path));
+        if (stat.nlink > 1) {
+          const key = `${stat.dev}:${stat.ino}`;
+          if (seen.has(key))
+            return;
+          seen.add(key);
+        }
+        total += stat.size;
+      } catch {}
+    }));
+  };
+  await visit(folder);
+  return total;
+}
+
+// src/sweep-scan.ts
+var FOLDER_NAMES = new Set(["node_modules", ".nuxt", ".next", ".output", "dist", "build", ".turbo", ".svelte-kit", "target"]);
+var MAX_DEPTH3 = 3;
+var PROJECT_CACHE_NAMES = new Set([".turbo", ".nuxt", ".next", ".svelte-kit"]);
+var GLOBAL_CACHES = [".bun/install/cache", ".npm/_cacache", ".cache/pip", ".cache/uv", ".cache/ms-playwright", ".cache/puppeteer", ".cache/go-build", ".cache/typescript", ".cargo/registry"];
+function isCachePath(path, home = homedir5()) {
+  return GLOBAL_CACHES.some((cache) => join11(home, cache) === path) || basename2(path) === ".cache" && basename2(dirname4(path)) === "node_modules";
+}
+async function listing(dir) {
+  try {
+    return await readdir4(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function addGlobalCaches(found, home) {
+  for (const cache of GLOBAL_CACHES) {
+    const path = join11(home, cache);
+    try {
+      const stat = await lstat2(path);
+      if (stat.isSymbolicLink())
+        found.skipped.push({ path, reason: "symlink" });
+      else if (stat.isDirectory())
+        found.candidates.push({ path, kind: "cache", global: true });
+    } catch {}
+  }
+}
+async function findCandidates(root, home = homedir5(), withGlobal = true) {
+  const found = { candidates: [], skipped: [] };
+  const visit = async (dir, depth) => {
+    const entries = await listing(dir);
+    for (const entry of entries) {
+      const path = join11(dir, entry.name);
+      if (entry.name === ".git")
+        continue;
+      if (entry.name === ".worktrees" || entry.name === "worktrees" && basename2(dir) === ".claude") {
+        if (!entry.isDirectory()) {
+          found.skipped.push({ path, reason: "symlink" });
+          continue;
+        }
+        for (const worktree of await listing(path)) {
+          if (worktree.isDirectory())
+            found.candidates.push({ path: join11(path, worktree.name), kind: "worktree" });
+          else if (worktree.isSymbolicLink())
+            found.skipped.push({ path: join11(path, worktree.name), reason: "symlink" });
+        }
+        continue;
+      }
+      if (FOLDER_NAMES.has(entry.name) && (entry.name !== "target" || existsSync8(join11(dir, "Cargo.toml")))) {
+        if (entry.isSymbolicLink()) {
+          found.skipped.push({ path, reason: "symlink" });
+        } else if (entry.isDirectory()) {
+          found.candidates.push({ path, kind: PROJECT_CACHE_NAMES.has(entry.name) ? "cache" : "folder" });
+          if (entry.name === "node_modules") {
+            const cache = (await listing(path)).find((inner) => inner.name === ".cache");
+            if (cache?.isSymbolicLink())
+              found.skipped.push({ path: join11(path, ".cache"), reason: "symlink" });
+            else if (cache?.isDirectory())
+              found.candidates.push({ path: join11(path, ".cache"), kind: "cache", inside: path });
+          }
+        }
+        continue;
+      }
+      if (entry.isDirectory() && depth < MAX_DEPTH3)
+        await visit(path, depth + 1);
+    }
+  };
+  await visit(root, 0);
+  if (withGlobal)
+    await addGlobalCaches(found, home);
+  return found;
+}
+async function realOf(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return;
+  }
+}
+var HEADS_PREFIX = /^refs\/heads\//;
+var TRAILING_SLASH = /\/$/;
+async function gitIn(cwd, args) {
+  try {
+    const { code, stdout, stderr } = await runTool(`git ${args.join(" ")}`, ["git", "-C", cwd, ...args], { timeoutMs: 30000 });
+    return { code, stdout: stdout.trim(), stderr };
+  } catch (error) {
+    return { code: -1, stdout: "", stderr: String(error) };
+  }
+}
+function memo(make) {
+  const cache = new Map;
+  return async (key) => {
+    let value = cache.get(key);
+    if (value === undefined) {
+      value = make(key);
+      cache.set(key, value);
+    }
+    return value;
+  };
+}
+var NOT_A_REPO = /not a git repository/i;
+var toplevelOf = memo(async (dir) => {
+  const { code, stdout, stderr } = await gitIn(dir, ["rev-parse", "--show-toplevel"]);
+  if (code === 0 && stdout !== "")
+    return { top: stdout };
+  return NOT_A_REPO.test(stderr) ? "none" : "failed";
+});
+var lastCommitOf = memo(async (top) => {
+  const { code, stdout } = await gitIn(top, ["log", "-1", "--format=%ct"]);
+  return code === 0 && stdout !== "" ? Number(stdout) * 1000 : undefined;
+});
+var worktreesOf = memo(async (repo) => {
+  const { code, stdout } = await gitIn(repo, ["worktree", "list", "--porcelain"]);
+  const branches = new Map;
+  if (code !== 0)
+    return branches;
+  for (const block of stdout.split(`
+
+`)) {
+    const lines = block.split(`
+`);
+    const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
+    const branch = lines.find((line) => line.startsWith("branch "))?.slice("branch ".length);
+    if (path !== undefined)
+      branches.set(await realOf(path) ?? path, branch);
+  }
+  return branches;
+});
+async function judgeFolder(path, kind, inside) {
+  const parent = dirname4(path);
+  const name = basename2(path);
+  const located = await toplevelOf(parent);
+  if (located === "failed")
+    return { skip: "git failed" };
+  if (existsSync8(join11(path, ".git")))
+    return { skip: "holds a git repository" };
+  if (located === "none")
+    return name === "node_modules" || inside !== undefined ? { entry: { path, kind, committedAt: undefined, action: "remove", inside } } : { skip: "not in a git repository" };
+  const tracked = await gitIn(parent, ["ls-files", "--", name]);
+  if (tracked.code !== 0 || tracked.stdout !== "")
+    return { skip: "tracked by git" };
+  if (name !== "node_modules" && inside === undefined && (await gitIn(parent, ["check-ignore", "-q", "--", name])).code !== 0)
+    return { skip: "not ignored by git" };
+  return { entry: { path, kind, committedAt: await lastCommitOf(located.top), action: "remove", inside } };
+}
+async function judgeWorktree(path) {
+  const located = await toplevelOf(dirname4(path));
+  if (located === "failed")
+    return { skip: "git failed" };
+  if (located === "none")
+    return { skip: "not in a git repository" };
+  const { top } = located;
+  const real = await realOf(path);
+  const branches = await worktreesOf(top);
+  if (real === undefined || !branches.has(real))
+    return { skip: "not a worktree of this repo" };
+  const committedAt = await lastCommitOf(top);
+  const keep = (reason) => ({ entry: { path, kind: "worktree", committedAt, action: "keep", reason, repo: top } });
+  const branch = branches.get(real);
+  if (branch === undefined)
+    return keep("detached HEAD");
+  const status = await gitIn(path, ["status", "--porcelain", "-z", "--ignored=matching"]);
+  if (status.code !== 0)
+    return keep("status failed");
+  const changes = status.stdout.split("\x00").filter((line) => line !== "");
+  if (changes.some((line) => !line.startsWith("!! ")))
+    return keep("uncommitted changes");
+  if (changes.some((line) => !line.endsWith("/") || !FOLDER_NAMES.has(basename2(line.slice(3).replace(TRAILING_SLASH, "")))))
+    return keep("ignored files (.env, local data) that removing would delete");
+  const unique = await gitIn(path, ["log", "--format=%h", branch, "--not", "--remotes", `--exclude=${branch.replace(HEADS_PREFIX, "")}`, "--branches"]);
+  if (unique.code !== 0)
+    return keep("log failed");
+  if (unique.stdout !== "")
+    return keep(`${unique.stdout.split(`
+`).length} commits on no other branch or remote`);
+  return { entry: { path, kind: "worktree", committedAt, action: "remove", repo: top } };
+}
+async function judge(candidate) {
+  if (candidate.global === true)
+    return { entry: { path: candidate.path, kind: candidate.kind, committedAt: undefined, action: "remove" } };
+  return candidate.kind === "worktree" ? judgeWorktree(candidate.path) : judgeFolder(candidate.path, candidate.kind, candidate.inside);
+}
+async function inspect2({ candidates, skipped }) {
+  const entries = [];
+  const rejected = [...skipped];
+  await pooled(candidates, 8, async (candidate) => {
+    const verdict = await judge(candidate);
+    if ("skip" in verdict)
+      rejected.push({ path: candidate.path, reason: verdict.skip });
+    else
+      entries.push({ ...verdict.entry, bytes: await sizeOf(candidate.path) });
+  });
+  const listed = new Set(entries.filter((entry) => entry.action === "remove").map((entry) => entry.path));
+  return { entries: entries.filter((entry) => entry.inside === undefined || !listed.has(entry.inside)), skipped: rejected };
+}
+
+// src/apply.ts
+async function removeFolder(entry) {
+  try {
+    const stat = await lstat3(entry.path);
+    if (stat.isSymbolicLink() || !stat.isDirectory() || !(FOLDER_NAMES.has(basename3(entry.path)) || entry.kind === "cache" && isCachePath(entry.path)))
+      return { path: entry.path, removed: false, error: "no longer a plain folder" };
+    if (existsSync9(join12(entry.path, ".git")))
+      return { path: entry.path, removed: false, error: "holds a git repository" };
+    await rm(entry.path, { recursive: true, force: true });
+    return { path: entry.path, removed: true };
+  } catch (error) {
+    return { path: entry.path, removed: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function removeWorktree(entry) {
+  if (entry.repo === undefined)
+    return { path: entry.path, removed: false, error: "no repository known" };
+  try {
+    const ran = await runTool("git worktree remove", ["git", "-C", entry.repo, "worktree", "remove", entry.path]);
+    return ran.code === 0 ? { path: entry.path, removed: true } : { path: entry.path, removed: false, error: ran.stderr.trim() };
+  } catch (error) {
+    return { path: entry.path, removed: false, error: String(error) };
+  }
+}
+async function applyAll(entries, done) {
+  const outcomes = [];
+  for (const entry of entries) {
+    if (entry.action !== "remove")
+      continue;
+    const outcome = await (entry.kind === "worktree" ? removeWorktree(entry) : removeFolder(entry));
+    outcomes.push(outcome);
+    done(outcome);
+  }
+  return outcomes;
+}
+
+// src/sweep.ts
+var LARGE = 100 * 1024 ** 2;
+var BIG = 1024 ** 3;
+var USAGE3 = `sweep [options] [root]: lists the regenerable folders (node_modules, .output, dist, build, target beside a Cargo.toml), the caches (.nuxt, .next, .turbo, .svelte-kit and node_modules/.cache per project; ~/.bun/install/cache, ~/.npm/_cacache, ~/.cache/{pip,uv,ms-playwright,puppeteer,go-build,typescript} and ~/.cargo/registry, exact paths only, listed only when no root is given or with --only caches) and the .worktrees/* and .claude/worktrees/* entries under root (~/Workspace by default, ${MAX_DEPTH3} levels down), largest first with the age of the repo's last commit; --only worktrees, folders or caches keeps one kind
+
+Dry unless --apply, which deletes after a confirm showing the total (read from the terminal; off one, pass --yes). A folder is deleted for good, not trashed. Never touched: a symlink, a folder git tracks files in, a build folder git does not ignore. A worktree is removed with git worktree remove, never forced, and only when it is clean and every commit of its branch is on another branch or a remote; the others stay listed as kept and count for nothing in the total. With --docker the Docker usage comes after the list, left to dclean.
+
+Exits 0 when it listed, or removed every entry it was allowed to, 1 when a removal failed or the confirm was declined, 2 on a usage error, a missing root, or --apply off a terminal without --yes.`;
+var ONLY_KINDS = { worktrees: "worktree", folders: "folder", caches: "cache" };
+var OPTIONS3 = {
+  apply: { type: "boolean", description: "delete what is listed as removable, after the confirm" },
+  yes: { type: "boolean", short: "y", description: "with --apply, skip the confirm" },
+  older: { type: "string", description: "only the entries whose repo last committed longer ago than this (30d, 12h)" },
+  min: { type: "string", description: "only the entries of at least this size (500K, 10M, 1G)" },
+  only: { type: "string", description: "worktrees, folders or caches: leave the other kinds out (.nuxt, .next, .turbo and .svelte-kit are caches; the global caches are listed with no root or with caches)" },
+  docker: { type: "boolean", description: "add the docker system df output, which alone takes about ten seconds" },
+  json: jsonOption("{root, entries: [{path, kind (folder, worktree or cache), bytes, committedAt, action (remove or keep), reason}], skipped: [{path, reason}], reclaimable, docker, removed?}")
+};
+async function dockerUsage() {
+  if (Bun.which("docker") === null)
+    return;
+  try {
+    const { code, stdout } = await runTool("docker system df", ["docker", "system", "df"], { timeoutMs: 1e4 });
+    return code === 0 ? stdout.trimEnd() : undefined;
+  } catch {
+    return;
+  }
+}
+async function sweep(args) {
+  const { values, positionals } = parse(args, USAGE3, OPTIONS3, { positionals: ["[root]"], replaces: "find ~/Workspace -name node_modules, du -sh and rm -rf by hand", examples: ["sweep", "sweep ~/Workspace --older 30d --min 100M --apply", "sweep --only worktrees --apply"] });
+  if (positionals.length > 1)
+    badUsage("give one root");
+  const root = resolve5(positionals[0] ?? join13(homedir6(), "Workspace"));
+  if (!existsSync10(root) || !statSync4(root).isDirectory())
+    fail(`${root} is not a folder`);
+  if (values.only !== undefined && !Object.hasOwn(ONLY_KINDS, values.only))
+    badUsage(`--only takes worktrees, folders or caches, not ${values.only}`);
+  const olderMs = values.older === undefined ? undefined : duration(values.older, "older", 0);
+  const minBytes = values.min === undefined ? 0 : parseSize(values.min);
+  if (minBytes === undefined)
+    badUsage(`--min takes a size such as 500K, 10M or 1G, not ${values.min}`);
+  const now = Date.now();
+  const found = await findCandidates(root, homedir6(), positionals.length === 0 || values.only === "caches");
+  const wanted = values.only === undefined ? found.candidates : found.candidates.filter((candidate) => candidate.kind === ONLY_KINDS[values.only]);
+  const { entries: all, skipped } = await inspect2({ candidates: wanted, skipped: found.skipped });
+  const entries = all.filter((entry) => entry.bytes >= minBytes && (olderMs === undefined || entry.committedAt !== undefined && now - entry.committedAt >= olderMs)).sort((a, b) => b.bytes - a.bytes || a.path.localeCompare(b.path));
+  const removable = entries.filter((entry) => entry.action === "remove");
+  const reclaimable = removable.reduce((sum, entry) => sum + entry.bytes, 0);
+  const docker = values.docker === true ? await dockerUsage() : undefined;
+  const json = values.json === true;
+  if (values.apply === true && removable.length > 0 && values.yes !== true) {
+    if (!json)
+      print(root, entries, skipped.length, reclaimable, now);
+    const agreed = await confirm(`Delete ${removable.length} ${removable.length === 1 ? "entry" : "entries"} (${$e(reclaimable)})?`, { default: false, hint: "pass --yes to skip the confirm" });
+    if (agreed !== true) {
+      if (json)
+        fail("nothing deleted: the confirm was declined", 1, "pass --yes to skip the confirm");
+      note("nothing deleted");
+      return 1;
+    }
+  }
+  const outcomes = values.apply === true ? await applyAll(removable, (outcome) => report(root, outcome, json)) : undefined;
+  const failed = outcomes?.filter((outcome) => !outcome.removed).length ?? 0;
+  if (json) {
+    printJson({ root, entries: entries.map((entry) => ({ path: entry.path, kind: entry.kind, bytes: entry.bytes, committedAt: entry.committedAt === undefined ? null : new Date(entry.committedAt).toISOString(), action: entry.action, reason: entry.reason ?? null })), skipped, reclaimable, docker: docker ?? null, ...outcomes === undefined ? {} : { removed: outcomes } });
+    return failed === 0 ? 0 : 1;
+  }
+  if (outcomes === undefined) {
+    print(root, entries, skipped.length, reclaimable, now);
+    if (removable.length > 0)
+      console.log("dry run, pass --apply to delete");
+  } else {
+    const bytes = new Map(removable.map((entry) => [entry.path, entry.bytes]));
+    note(`freed ${$e(outcomes.reduce((sum, outcome) => sum + (outcome.removed ? bytes.get(outcome.path) ?? 0 : 0), 0))}`);
+  }
+  if (docker !== undefined)
+    console.log(`
+docker (left to dclean):
+${docker}`);
+  return failed === 0 ? 0 : 1;
+}
+function report(root, outcome, json) {
+  if (json)
+    return;
+  if (outcome.removed)
+    ok(`removed ${relative3(root, outcome.path)}`);
+  else
+    problem(`kept ${relative3(root, outcome.path)}`, outcome.error);
+}
+function print(root, entries, skipped, reclaimable, now) {
+  if (entries.length === 0) {
+    console.log("nothing to sweep");
+    return;
+  }
+  const colors = paint(process.stdout);
+  const path = role("path", process.stdout);
+  const sized = (bytes) => {
+    if (bytes >= BIG)
+      return colors.red($e(bytes));
+    return bytes >= LARGE ? colors.yellow($e(bytes)) : $e(bytes);
+  };
+  console.log(table([["size", "age", "what", "path", "note"], ...entries.map((entry) => [sized(entry.bytes), entry.committedAt === undefined ? colors.dim("-") : colors.dim(formatAge(entry.committedAt, now)), entry.kind, path(relative3(root, entry.path)), entry.action === "keep" ? colors.dim(`kept: ${entry.reason}`) : ""])], { header: true, align: ["right", "right", "left", "left", "left"] }));
+  console.log(`
+${$e(reclaimable)} reclaimable${skipped === 0 ? "" : `, ${skipped} skipped (symlinks, tracked or not ignored by git)`}`);
+}
+
+// src/cli.ts
+process18.exitCode = await runCli({
+  name: "ws",
+  about: "the repositories under a root: the ones needing attention, the folders worth reclaiming and their known vulnerabilities",
+  replaces: "a cd, git status and du loop over each repository of the workspace, and a bun audit run in each",
+  examples: ["ws repos", ["ws sweep --older 30d", "what a month of idle repos weighs"], "ws audit"],
+  commands: {
+    repos: { summary: "the git repositories that need attention: dirty, ahead or behind, worktrees, unreleased commits", run: repos },
+    sweep: { summary: "the regenerable folders, caches and clean worktrees, largest first, deleted only on --apply", run: sweep },
+    audit: { summary: "the known vulnerabilities of the Bun repositories, one table per repository", run: audit }
+  }
+});