@kaynooo/cli-out 0.0.0-stage → 0.6.0

package/dist/cli.js

@@ -0,0 +1,1523 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import process11 from "process";
+
+// ../kit/src/args.ts
+import { fstatSync } from "fs";
+import process3 from "process";
+import { parseArgs } from "util";
+
+// ../kit/src/format.ts
+import process2 from "process";
+
+// ../kit/src/style.ts
+import process from "process";
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+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.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-y1msbssb.js
+var r = 39;
+var o = 49;
+var f2 = "\x1B[";
+var C2 = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, r], red: [31, r], green: [32, r], yellow: [33, r], blue: [34, r], magenta: [35, r], cyan: [36, r], white: [37, r], gray: [90, r], grey: [90, r], blackBright: [90, r], redBright: [91, r], greenBright: [92, r], yellowBright: [93, r], blueBright: [94, r], magentaBright: [95, r], cyanBright: [96, r], whiteBright: [97, r], bgBlack: [40, o], bgRed: [41, o], bgGreen: [42, o], bgYellow: [43, o], bgBlue: [44, o], bgMagenta: [45, o], bgCyan: [46, o], bgWhite: [47, o], bgBlackBright: [100, o], bgRedBright: [101, o], bgGreenBright: [102, o], bgYellowBright: [103, o], bgBlueBright: [104, o], bgMagentaBright: [105, o], bgCyanBright: [106, o], bgWhiteBright: [107, o], rgb: (i, n, a, l = "fg") => [`${l === "fg" ? 38 : 48};2;${i};${n};${a}`, l === "fg" ? r : o], hex: (i, n = "fg") => {
+  let [a, l, s] = e.from("hex", i).to("rgb");
+  return [`${n === "fg" ? 38 : 48};2;${a};${l};${s}`, n === "fg" ? r : o];
+}, ansi256: (i, n = "fg") => [`${n === "fg" ? 38 : 48};5;${i}`, n === "fg" ? r : o] };
+var b = new Set(["", "1", "2", "3", "true"]);
+function h(i, n = globalThis.process?.env ?? {}) {
+  if (n.FORCE_COLOR !== undefined)
+    return b.has(n.FORCE_COLOR);
+  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/style.ts
+function takesControlCodes(stream, env = process.env) {
+  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
+}
+function paint(stream, env = process.env) {
+  return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
+}
+var STATUSES = {
+  passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
+  failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
+  running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
+  queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
+  skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
+};
+var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+
+// ../kit/src/format.ts
+function upTo(text, separator) {
+  const end = text.indexOf(separator);
+  return end === -1 ? text : text.slice(0, end);
+}
+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 } = {}) {
+  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(process2.stdout);
+  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());
+  return lines.map((line, index) => header && index === 0 ? colors.bold(line) : 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/text.ts
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+function stripAnsi(text) {
+  return text.replace(ANSI, "");
+}
+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/args.ts
+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;
+  constructor(options) {
+    this.options = options;
+  }
+}
+var completion = { active: false };
+var OPTIONAL = /\[[^\]]+\]/g;
+var USAGE_PREFIX = /^usage:\s*/i;
+var FULL_STOP = /\.$/;
+var DASHES = /^-+/;
+function usageLine(usage, colors = paint(process3.stdout)) {
+  return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
+}
+function helpText(usage, options, colors = paint(process3.stdout), { examples = [], replaces } = {}) {
+  return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exampleRows(examples, colors)].join(`
+`);
+}
+function replacesRows(replaces, colors = paint(process3.stdout)) {
+  return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
+}
+function wantsHelpJson(env = process3.env) {
+  return env.KIT_HELP === "json";
+}
+function description(usage, { examples = [], replaces } = {}) {
+  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] })
+  };
+}
+function exampleRows(examples, colors = paint(process3.stdout)) {
+  if (examples.length === 0)
+    return [];
+  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
+}
+function optionRows(options, colors = paint(process3.stdout)) {
+  const rows = Object.entries(options).map(([name, option]) => {
+    const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
+    const value = option.type === "string" ? ` ${colors.dim("<value>")}` : "";
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? " <value>".length : 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)}`);
+}
+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 = process3.env) {
+  const when = plain === true ? "never" : color ?? "auto";
+  if (when === "auto")
+    return;
+  if (when !== "always" && when !== "never")
+    badUsage(`--color takes auto, always or never, not ${when}`);
+  if (when === "always") {
+    env.FORCE_COLOR = "1";
+    delete env.NO_COLOR;
+  } else {
+    env.NO_COLOR = "1";
+    delete env.FORCE_COLOR;
+  }
+}
+function parse(args, usage, options, settings = {}) {
+  const output = Object.fromEntries(Object.entries(OUTPUT_OPTIONS).filter(([name]) => !(name in options)));
+  const all = { ...options, ...output, help: { type: "boolean", short: "h", description: "show this help" } };
+  if (completion.active)
+    throw new Completing(all);
+  const separator = settings.rest === true ? args.indexOf("--") : -1;
+  const own = separator === -1 ? args : args.slice(0, separator);
+  const rest = separator === -1 ? undefined : args.slice(separator + 1);
+  let parsed;
+  try {
+    parsed = parseArgs({ args: joinDashValues(own, 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)) : helpText(usage, all, undefined, settings));
+    throw new HelpShown;
+  }
+  if (settings.positionals !== undefined)
+    checkPositionals(parsed.positionals, settings.positionals);
+  return { ...parsed, positionals: parsed.positionals, rest };
+}
+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)}?`;
+}
+var WHOLE = /^\d+$/;
+function wholeNumber(value, name, fallback, min = 1) {
+  if (value === undefined)
+    return fallback;
+  const number = Number(value);
+  if (!WHOLE.test(value) || !Number.isSafeInteger(number) || number < min)
+    badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
+  return number;
+}
+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;
+}
+function isStdinPiped() {
+  const stat = fstatSync(0);
+  return stat.isFIFO() || stat.isFile();
+}
+// ../kit/src/process.ts
+import { constants } from "os";
+import process4 from "process";
+var KILL_GRACE_MS = 2000;
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function exitCodeOf(code, signal) {
+  if (code !== null)
+    return code;
+  if (typeof signal === "number")
+    return 128 + signal;
+  return signal === null ? 129 : 128 + constants.signals[signal];
+}
+function holdSignals(cleanup) {
+  let received;
+  let child;
+  const held = {
+    get signal() {
+      return received;
+    },
+    forward: (to) => {
+      child = to;
+    },
+    release: () => {
+      for (const signal of SIGNALS)
+        process4.off(signal, onSignal);
+    }
+  };
+  function onSignal(signal) {
+    received = signal;
+    if (child !== undefined) {
+      child.kill(signal);
+      return;
+    }
+    if (cleanup === undefined)
+      return;
+    held.release();
+    cleanup(signal);
+    process4.kill(process4.pid, signal);
+  }
+  for (const signal of SIGNALS)
+    process4.on(signal, onSignal);
+  return held;
+}
+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)
+        process4.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/cli.ts
+import process5 from "process";
+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" } };
+function printError(prefix, message, hint, cause) {
+  const colors = paint(process5.stderr);
+  const styled = takesControlCodes(process5.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;
+  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;
+}
+var COMPLETE = "__complete";
+var FILES = "__files__";
+async function optionsOf(run) {
+  completion.active = true;
+  try {
+    await run([]);
+  } catch (error) {
+    if (error instanceof Completing)
+      return error.options;
+  } finally {
+    completion.active = false;
+  }
+  return {};
+}
+async function leafCandidates(run, words) {
+  if (!(words.at(-1) ?? "").startsWith("-"))
+    return [FILES];
+  return Object.entries(await optionsOf(run)).map(([name, option]) => option.description === undefined ? `--${name}` : `--${name}	${option.description}`);
+}
+async function printCandidates(found) {
+  for (const line of await found)
+    console.log(line);
+  return 0;
+}
+async function runMain({ name, version, run, redact }, argv = process5.argv.slice(2)) {
+  if (argv[0] === COMPLETE)
+    return printCandidates(leafCandidates(run, argv.slice(1)));
+  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
+    console.log(version);
+    return 0;
+  }
+  try {
+    return await run(argv);
+  } catch (error) {
+    return reportThrown(name, error, redact, wantsJson(argv));
+  }
+}
+// ../kit/src/logs.ts
+import { lstatSync, openSync } from "fs";
+import { mkdir, mkdtemp, readdir, rm, stat } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+import process6 from "process";
+var DAY_MS = 24 * 60 * 60 * 1000;
+var CLI_FOLDER = "kaynooo-cli";
+function isPrivateDirectory(path) {
+  try {
+    const info = lstatSync(path, { throwIfNoEntry: false });
+    return info !== undefined && info.isDirectory() && info.uid === (process6.getuid?.() ?? info.uid) && (info.mode & 63) === 0;
+  } catch {
+    return false;
+  }
+}
+async function privateLogDirectory(name, env = process6.env) {
+  const runtime = env.XDG_RUNTIME_DIR;
+  const base = runtime === undefined || runtime === "" ? join(homedir(), ".cache", CLI_FOLDER) : join(runtime, CLI_FOLDER);
+  const path = join(base, name);
+  try {
+    await mkdir(path, { recursive: true, mode: 448 });
+    if (isPrivateDirectory(path))
+      return path;
+  } catch {}
+  return mkdtemp(join(tmpdir(), `${name.replaceAll("/", "-")}-`));
+}
+async function sweepLogs(dir, maxAgeMs = DAY_MS, now = Date.now()) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const path = join(dir, name);
+    try {
+      const info = await stat(path);
+      if (info.isDirectory())
+        await sweepLogs(path, maxAgeMs, now);
+      if (now - info.mtimeMs > maxAgeMs)
+        await rm(path, { force: true, recursive: info.isDirectory() });
+    } catch {
+      continue;
+    }
+  }
+}
+function createLog(path) {
+  return openSync(path, "wx", 384);
+}
+// ../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");
+// package.json
+var version = "0.6.0";
+
+// src/shape.ts
+var HEX_LITERAL = /\b0x[0-9a-f]+\b/gi;
+var PATH = /(?:\.{1,2}\/|\/)?[\w.@~-]+(?:\/[\w.@~-]+)+/g;
+var FILE = /\b[\w@~-]+(?:\.[\w-]+)*\.[a-z]\w{0,5}\b/gi;
+var HASH = /\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b/gi;
+var DURATION2 = /\b\d+(?:\.\d+)?\s?(?:ms|\u00B5s|ns|[smh])\b/g;
+var PERCENT = /\b\d+(?:\.\d+)?%/g;
+var NUMBER = /\d+(?:\.\d+)?/g;
+var MAX_SHAPED = 2000;
+var IMPORTANT = /error|fail|warn|panic|exception|fatal|\u2717|\u2718|^\s+at\s+\S|^\s*File ".*", line \d+|^\s*\d+: .+ at /i;
+function isImportant(line) {
+  return IMPORTANT.test(stripAnsi(line.slice(0, MAX_SHAPED)));
+}
+function shape(line) {
+  return stripAnsi(line.slice(0, MAX_SHAPED)).replaceAll(HEX_LITERAL, "<hex>").replaceAll(PATH, "<path>").replaceAll(FILE, "<file>").replaceAll(HASH, "<hex>").replaceAll(DURATION2, "<time>").replaceAll(PERCENT, "<pct>").replaceAll(NUMBER, "<n>").trimEnd();
+}
+
+// src/fold.ts
+var FOLD_LINES = 150;
+var HEAD = 40;
+var TAIL = 60;
+var MAX_BLOCK = 20;
+var MIN_REFERENCED = 20;
+var TOP_REPEATED = 3;
+var LINE_BREAK = /\r\n|\r|\n/;
+var LINE_END = /(?:\r\n|\r|\n)$/;
+function lineCount(text) {
+  if (text === "")
+    return 0;
+  const count = text.split(LINE_BREAK).length;
+  return LINE_END.test(text) ? count - 1 : count;
+}
+function shouldFold(text, threshold) {
+  return lineCount(text) > threshold;
+}
+function finalState(line) {
+  const segments = line.split("\r").filter((segment) => segment !== "");
+  return segments.at(-1) ?? "";
+}
+function splitLines(text) {
+  const lines = text.replaceAll(`\r
+`, `
+`).split(`
+`).map((line) => line.includes("\r") ? finalState(line) : line);
+  return text.endsWith(`
+`) ? lines.slice(0, -1) : lines;
+}
+function repeats(keys, at, size) {
+  if (keys[at] !== keys[at + size])
+    return false;
+  for (let offset = 1;offset < size; offset++) {
+    if (keys[at + offset] !== keys[at + size + offset])
+      return false;
+  }
+  return true;
+}
+function toUnits(lines, keys) {
+  const units = [];
+  for (let at = 0;at < lines.length; ) {
+    let size = 1;
+    let reps = 1;
+    for (let candidate = 1;candidate <= MAX_BLOCK && at + candidate * 2 <= lines.length; candidate++) {
+      let count = 1;
+      while (at + (count + 1) * candidate <= lines.length && repeats(keys, at + (count - 1) * candidate, candidate))
+        count++;
+      if (count > 1 && candidate * count > size * reps) {
+        size = candidate;
+        reps = count;
+      }
+    }
+    const slice = lines.slice(at, at + size);
+    units.push({
+      start: at,
+      size,
+      reps,
+      lines: slice,
+      last: lines[at + size * reps - 1] ?? "",
+      key: keys.slice(at, at + size).join(`
+`),
+      important: slice.some((line) => isImportant(line))
+    });
+    at += size * reps;
+  }
+  return units;
+}
+function clip(line, width = 100) {
+  const trimmed = line.trim();
+  return trimmed.length > width ? `${trimmed.slice(0, width)}...` : trimmed;
+}
+function toEntries(units) {
+  const entries = [];
+  const firstSeen = new Map;
+  const counts = new Map;
+  let references = false;
+  for (const unit of units) {
+    const seen = counts.get(unit.key);
+    counts.set(unit.key, { count: (seen?.count ?? 0) + unit.reps, sample: seen?.sample ?? clip(unit.lines[0] ?? "") });
+    const earlier = firstSeen.get(unit.key);
+    const covers = unit.size * unit.reps;
+    if (earlier !== undefined && (unit.size > 1 || unit.key.length >= MIN_REFERENCED)) {
+      references = true;
+      const where = unit.size > 1 ? `block same as line ${earlier}` : `same as line ${earlier}`;
+      const times = unit.reps > 1 ? `, repeated ${unit.reps} times` : "";
+      const prefix = unit.important ? `${clip(unit.lines[0] ?? "")} ` : "";
+      entries.push({ text: `${prefix}(${where}${times})`, important: unit.important, covers });
+      continue;
+    }
+    firstSeen.set(unit.key, unit.start + 1);
+    if (unit.reps === 1) {
+      entries.push(...unit.lines.map((text) => ({ text, important: unit.important, covers: 1 })));
+      continue;
+    }
+    if (unit.size === 1) {
+      const first = unit.lines[0] ?? "";
+      const ending = unit.last === first ? "" : `, last: ${clip(unit.last)}`;
+      entries.push({ text: `${first} (x${unit.reps}${ending})`, important: unit.important, covers });
+      continue;
+    }
+    entries.push(...unit.lines.map((text) => ({ text, important: unit.important, covers: unit.reps })));
+    entries.push({ text: `(block repeated ${unit.reps} times)`, important: unit.important, covers: 0 });
+  }
+  const repeated = [...counts.values()].filter(({ count }) => count >= 2).sort((a, b) => b.count - a.count).slice(0, TOP_REPEATED).map(({ count, sample }) => `${count}x ${sample}`);
+  return { entries, references, repeated };
+}
+function fold(text, { threshold, logPath }) {
+  const lines = splitLines(text);
+  const { entries, references, repeated } = toEntries(toUnits(lines, lines.map((line) => shape(line))));
+  const head = Math.min(HEAD, Math.floor(threshold / 3));
+  const tail = Math.min(TAIL, Math.floor(threshold / 2));
+  const out = [];
+  let dropped = 0;
+  if (entries.length <= threshold) {
+    out.push(...entries.map(({ text }) => text));
+  } else {
+    const middleEnd = entries.length - tail;
+    let gap = 0;
+    const closeGap = () => {
+      if (gap > 0)
+        out.push(`[out: ${gap} lines left out]`);
+      dropped += gap;
+      gap = 0;
+    };
+    for (const [index, entry] of entries.entries()) {
+      if (index < head || index >= middleEnd) {
+        closeGap();
+        out.push(entry.text);
+        continue;
+      }
+      if (entry.important) {
+        closeGap();
+        out.push(entry.text);
+        continue;
+      }
+      gap += entry.covers;
+    }
+    closeGap();
+  }
+  const note = references ? ' (line numbers in "same as line N" refer to it)' : "";
+  const header = [`[out: ${lines.length} lines, ${dropped} left out, full log: ${logPath}${note}]`];
+  if (repeated.length > 0)
+    header.push(`[out: most repeated: ${repeated.join(", ")}]`);
+  return `${[...header, ...out].join(`
+`)}
+`;
+}
+
+// src/run.ts
+import { closeSync, rmSync, writeSync } from "fs";
+import process10 from "process";
+
+// src/logs.ts
+import { join as join2 } from "path";
+import process8 from "process";
+var MAX_AGE_MS = 24 * 60 * 60 * 1000;
+async function logDir() {
+  return privateLogDirectory("out");
+}
+async function cleanLogs(dir, now = Date.now()) {
+  await sweepLogs(dir, MAX_AGE_MS, now);
+}
+function newLog(dir) {
+  const path = join2(dir, `${new Date().toISOString().replaceAll(/[:.]/g, "-")}-${process8.pid}.log`);
+  return { path, fd: createLog(path) };
+}
+
+// ../kit/src/shell.ts
+var SEPARATORS = new Set([`
+`, ";", "|"]);
+var PLAIN_BREAKERS = new Set(["<", ">", "(", ")", "&", "|"]);
+var GLOB_CHARS = new Set(["*", "?", "["]);
+var COMMENT_PREFIXES = new Set([";", "&", "|", "(", ")"]);
+var WHITESPACE = /\s/;
+var LEADING_HEX = /^[\da-f]*/i;
+var DOUBLE_QUOTED_ESCAPES = new Set(["$", "`", '"', "\\"]);
+var ANSI_QUOTE = "$'";
+var ANSI_ESCAPES = { n: `
+`, t: "\t", r: "\r", a: "\x07", b: "\b", f: "\f", v: "\v", e: "\x1B", E: "\x1B", "\\": "\\", "'": "'", '"': '"', "?": "?" };
+var ANSI_DIGITS = { x: 2, u: 4, U: 8 };
+var OCTAL = /^[0-7]{1,3}/;
+var KEYWORDS = new Set(["then", "do", "else", "if", "elif", "while", "until", "!", "{", "}"]);
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ash", "ksh"]);
+var COMMAND_STRING_PROGRAMS = new Set([...SHELLS, "su", "runuser"]);
+var SHELL_VALUE_OPTIONS = new Set(["-o", "-O", "--rcfile", "--init-file"]);
+var PRINTERS = new Set(["echo", "printf"]);
+var FIND_EXEC = new Set(["-exec", "-execdir", "-ok", "-okdir"]);
+function wrapper(short = "", long = [], operands = 0) {
+  return { short, long, operands };
+}
+var WRAPPERS = new Map([
+  ["command", wrapper()],
+  ["builtin", wrapper()],
+  ["nohup", wrapper()],
+  ["setsid", wrapper()],
+  ["busybox", wrapper()],
+  ["exec", wrapper("a")],
+  ["time", wrapper("fo", ["--format", "--output"])],
+  ["env", wrapper("uCS", ["--unset", "--chdir", "--split-string", "--argv0"])],
+  ["sudo", wrapper("ughpCTrtUDR", ["--user", "--group", "--host", "--prompt", "--close-from", "--command-timeout", "--role", "--type", "--other-user", "--chdir", "--chroot"])],
+  ["doas", wrapper("uC")],
+  ["timeout", wrapper("sk", ["--signal", "--kill-after"], 1)],
+  ["nice", wrapper("n", ["--adjustment"])],
+  ["ionice", wrapper("cnpPu", ["--class", "--classdata", "--pid", "--pgid", "--uid"])],
+  ["stdbuf", wrapper("ioe", ["--input", "--output", "--error"])],
+  ["chroot", wrapper("", ["--userspec", "--groups"], 1)],
+  ["xargs", wrapper("IndsEaPL", ["--max-args", "--max-procs", "--max-chars", "--delimiter", "--arg-file", "--eof", "--max-lines", "--process-slot-var"])]
+]);
+function closerOf(quote) {
+  return quote === ANSI_QUOTE ? "'" : quote;
+}
+function ansiEscape(text, at) {
+  const letter = text[at + 1] ?? "";
+  const simple = ANSI_ESCAPES[letter];
+  if (simple !== undefined)
+    return [simple, at + 1];
+  const hex = LEADING_HEX.exec(text.slice(at + 2, at + 2 + (ANSI_DIGITS[letter] ?? 0)))?.[0] ?? "";
+  if (hex !== "")
+    return [String.fromCodePoint(Number.parseInt(hex, 16)), at + 1 + hex.length];
+  const octal = OCTAL.exec(text.slice(at + 1))?.[0];
+  if (octal !== undefined)
+    return [String.fromCodePoint(Number.parseInt(octal, 8)), at + octal.length];
+  return [`\\${letter}`, at + 1];
+}
+function words(text) {
+  const found = [];
+  let current = "";
+  let isStarted = false;
+  let isProse = false;
+  let hasGlob = false;
+  let hasBrace = false;
+  let quote = null;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i] ?? "";
+    const isContinuation = char === "\\" && quote !== "'" && text[i + 1] === `
+`;
+    if (isContinuation)
+      i++;
+    if (quote === null && (isContinuation || WHITESPACE.test(char))) {
+      if (isStarted)
+        found.push({ text: current, isProse, hasGlob, hasBrace });
+      current = "";
+      isStarted = false;
+      isProse = false;
+      hasGlob = false;
+      hasBrace = false;
+      continue;
+    }
+    if (isContinuation)
+      continue;
+    isStarted = true;
+    if (char === "\\" && quote === ANSI_QUOTE) {
+      const [decoded, last] = ansiEscape(text, i);
+      current += decoded;
+      i = last;
+    } else if (char === "\\" && quote === '"' && !DOUBLE_QUOTED_ESCAPES.has(text[i + 1] ?? "")) {
+      current += char;
+    } else if (char === "\\" && quote !== "'") {
+      current += text[++i] ?? "";
+    } else if (quote !== null && char === closerOf(quote)) {
+      quote = null;
+    } else if (quote === null && char === "$" && text[i + 1] === "'") {
+      quote = ANSI_QUOTE;
+      i++;
+    } else if (quote === null && (char === '"' || char === "'")) {
+      quote = char;
+    } else {
+      current += char;
+      hasGlob ||= quote === null && GLOB_CHARS.has(char);
+      hasBrace ||= quote === null && char === "{";
+    }
+    isProse ||= quote !== null && WHITESPACE.test(char);
+  }
+  if (isStarted)
+    found.push({ text: current, isProse, hasGlob, hasBrace });
+  return found;
+}
+function tokenize(text) {
+  return words(text).map((word) => word.text);
+}
+
+// src/stages.ts
+var DIGITS = /^\d+$/;
+var SIGNED = /^[+-]?\d+$/;
+var SHORT_COUNT = /^-(\d+)$/;
+var GREP_FLAGS = new Set(["i", "v", "E", "F", "w", "x", "n", "H", "h", "s", "a", "I", "P", "G"]);
+var GREP_VALUES = new Set(["e", "m", "A", "B", "C"]);
+var LONG_VALUE = /^--(lines|regexp|max-count|after-context|before-context|context)=(.*)$/;
+var LONG_NAMES = { lines: "n", regexp: "e", "max-count": "m", "after-context": "A", "before-context": "B", context: "C" };
+var LONG_FLAGS = { "--ignore-case": "i", "--invert-match": "v", "--extended-regexp": "E", "--fixed-strings": "F", "--word-regexp": "w", "--line-regexp": "x", "--line-number": "n" };
+var REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+var BASIC_SWAPPED = new Set(["(", ")", "|", "+", "?", "{", "}"]);
+var DEFAULT_LINES = 10;
+function options(args, flags, valued) {
+  const read = { flags: new Set, values: new Map, operands: [] };
+  const add = (name, value) => read.values.set(name, [...read.values.get(name) ?? [], value]);
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    const long = LONG_VALUE.exec(arg);
+    const count = SHORT_COUNT.exec(arg);
+    if (long !== null) {
+      add(LONG_NAMES[long[1] ?? ""] ?? "", long[2] ?? "");
+    } else if (LONG_FLAGS[arg] !== undefined) {
+      read.flags.add(LONG_FLAGS[arg]);
+    } else if (count !== null) {
+      add("count", count[1] ?? "");
+    } else if (arg.startsWith("-") && arg.length > 1 && !arg.startsWith("--")) {
+      for (const [at, letter] of [...arg.slice(1)].entries()) {
+        if (valued.has(letter)) {
+          const glued = arg.slice(at + 2);
+          add(letter, glued === "" ? args[++i] ?? "" : glued);
+          break;
+        }
+        if (!flags.has(letter))
+          return;
+        read.flags.add(letter);
+      }
+    } else if (arg.startsWith("--")) {
+      return;
+    } else {
+      read.operands.push(arg);
+    }
+  }
+  return read;
+}
+function cut(lines, bin, args) {
+  const read = options(args, new Set(["q", "v"]), new Set(["n"]));
+  const value = read?.values.get("n")?.at(-1) ?? read?.values.get("count")?.at(-1) ?? String(DEFAULT_LINES);
+  if (read === undefined || read.operands.length > 0 || !SIGNED.test(value))
+    return;
+  const n = Math.abs(Number(value));
+  if (bin === "tail")
+    return value.startsWith("+") ? lines.slice(Math.max(0, n - 1)) : lines.slice(Math.max(0, lines.length - n));
+  return value.startsWith("-") ? lines.slice(0, Math.max(0, lines.length - n)) : lines.slice(0, n);
+}
+function patternSource(pattern, read) {
+  if (read.flags.has("F"))
+    return pattern.replaceAll(REGEX_SPECIAL, "\\$&");
+  if (read.flags.has("E") || read.flags.has("P"))
+    return pattern;
+  let source = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const char = pattern[i] ?? "";
+    const next = pattern[i + 1] ?? "";
+    if (char === "\\" && BASIC_SWAPPED.has(next)) {
+      source += next;
+      i++;
+    } else if (char === "\\") {
+      source += `${char}${next}`;
+      i++;
+    } else {
+      source += BASIC_SWAPPED.has(char) ? `\\${char}` : char;
+    }
+  }
+  return source;
+}
+function anchoredSource(source, flags) {
+  if (flags.has("x"))
+    return `^(?:${source})$`;
+  return flags.has("w") ? `\\b(?:${source})\\b` : source;
+}
+function search(lines, args) {
+  const read = options(args, GREP_FLAGS, GREP_VALUES);
+  if (read === undefined)
+    return;
+  const patterns = read.values.get("e") ?? read.operands.splice(0, 1);
+  const numbers = ["A", "B", "C", "m", "count"].map((name) => read.values.get(name)?.at(-1));
+  if (patterns.length === 0 || read.operands.length > 0 || numbers.some((each) => each !== undefined && !DIGITS.test(each)))
+    return;
+  const [after, before, context, max, count] = numbers.map((each) => each === undefined ? undefined : Number(each));
+  let regex;
+  try {
+    const source = patterns.map((pattern) => `(?:${patternSource(pattern, read)})`).join("|");
+    regex = new RegExp(anchoredSource(source, read.flags), read.flags.has("i") ? "i" : "");
+  } catch {
+    return;
+  }
+  const matched = [];
+  for (const [index, line] of lines.entries()) {
+    if (regex.test(line) !== read.flags.has("v"))
+      matched.push(index);
+    if (max !== undefined && matched.length >= max)
+      break;
+  }
+  const ahead = before ?? context ?? count ?? 0;
+  const behind = after ?? context ?? count ?? 0;
+  const kept = [];
+  let last = -1;
+  for (const index of matched) {
+    const from = Math.max(last + 1, index - ahead);
+    if (last >= 0 && from > last + 1 && ahead + behind > 0)
+      kept.push("--");
+    for (let at = from;at <= Math.min(lines.length - 1, index + behind); at++)
+      kept.push(lines[at] ?? "");
+    last = Math.max(last, Math.min(lines.length - 1, index + behind));
+  }
+  return kept;
+}
+function filtered(text, stages) {
+  const ended = text.endsWith(`
+`);
+  let lines = (ended ? text.slice(0, -1) : text).split(`
+`);
+  for (const stage of stages) {
+    const [bin = "", ...args] = tokenize(stage);
+    if (bin === "grep")
+      lines = search(lines, args);
+    else
+      lines = bin === "tail" || bin === "head" ? cut(lines, bin, args) : undefined;
+    if (lines === undefined)
+      return;
+  }
+  return lines.length === 0 ? "" : `${lines.join(`
+`)}${ended ? `
+` : ""}`;
+}
+
+// src/stats.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, dirname, join as join3 } from "path";
+import process9 from "process";
+var BYTES_PER_TOKEN = 4;
+var KEY_WORD = /^[a-z][a-z:_-]*$/;
+var KEY_WORDS = 3;
+var BLANKS = /\s+/;
+var ASSIGNMENT = /^\w+=/;
+var CHAIN = /&&|\|\||;/;
+var SHELLS2 = new Set(["sh", "bash", "zsh"]);
+var TOP = 10;
+function statsPath(env = process9.env) {
+  return join3(env.XDG_STATE_HOME ?? join3(homedir2(), ".local", "state"), CLI_FOLDER, "out", "stats.jsonl");
+}
+function commandKey(command) {
+  const [program = "", ...rest] = command.slice(Math.max(0, command.findIndex((word) => !ASSIGNMENT.test(word))));
+  if (SHELLS2.has(basename(program)) && rest[0] === "-c" && rest[1] !== undefined) {
+    const chain = rest[1].split(CHAIN).map((segment) => segment.trim()).filter((segment) => segment !== "" && segment !== "cd" && !segment.startsWith("cd "));
+    return commandKey((chain.at(-1) ?? "").split(BLANKS));
+  }
+  const words = [basename(program)];
+  for (const word of rest) {
+    if (words.length === KEY_WORDS || !KEY_WORD.test(word))
+      break;
+    words.push(word);
+  }
+  return words.join(" ");
+}
+function record(entry, path = statsPath()) {
+  try {
+    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    appendFileSync(path, `${JSON.stringify(entry)}
+`, { mode: 384 });
+  } catch {}
+}
+async function readEntries(path = statsPath(), since = 0) {
+  const file = Bun.file(path);
+  if (!await file.exists())
+    return [];
+  return (await file.text()).split(`
+`).flatMap((line) => {
+    try {
+      const entry = JSON.parse(line);
+      return Date.parse(entry.at) >= since ? [entry] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+function tokens(bytes) {
+  return Math.round(bytes / BYTES_PER_TOKEN);
+}
+function formatNumber(value) {
+  return value.toLocaleString("en-US");
+}
+function summarize(entries) {
+  const commands = Map.groupBy(entries, (entry) => entry.command).entries().map(([command, runs]) => ({
+    command,
+    runs: runs.length,
+    folded: runs.filter((run) => run.folded).length,
+    tokensSaved: tokens(runs.reduce((sum, run) => sum + run.baseline - run.shown, 0))
+  }));
+  const sum = (field) => entries.reduce((total, entry) => total + entry[field], 0);
+  return { runs: entries.length, folded: entries.filter((entry) => entry.folded).length, bytes: sum("bytes"), shown: sum("shown"), tokensSaved: tokens(sum("baseline") - sum("shown")), commands: [...commands].sort((a, b) => b.tokensSaved - a.tokensSaved) };
+}
+function renderSummary(summary, period) {
+  if (summary.runs === 0)
+    return `no run of out recorded ${period}`;
+  const top = summary.commands.slice(0, TOP).filter((each) => each.tokensSaved !== 0);
+  return [
+    `${formatNumber(summary.runs)} runs ${period}, ${formatNumber(summary.folded)} folded: ${formatNumber(summary.bytes)} bytes printed, ${formatNumber(summary.shown)} shown, about ${formatNumber(summary.tokensSaved)} tokens saved (bytes / ${BYTES_PER_TOKEN})`,
+    ...top.length === 0 ? [] : ["", table([["command", "runs", "folded", "tokens saved"], ...top.map((each) => [each.command, formatNumber(each.runs), formatNumber(each.folded), formatNumber(each.tokensSaved)])])]
+  ].join(`
+`);
+}
+
+// src/run.ts
+var HEAD_BYTES = 2 * 1024 * 1024;
+var TAIL_BYTES = 2 * 1024 * 1024;
+var FALLBACK_LINES = 100;
+
+class Recorder {
+  dir;
+  head = [];
+  tail = [];
+  headBytes = 0;
+  tailBytes = 0;
+  dropped = 0;
+  log;
+  constructor(dir) {
+    this.dir = dir;
+  }
+  add(chunk) {
+    if (this.headBytes < HEAD_BYTES) {
+      this.head.push(chunk);
+      this.headBytes += chunk.data.length;
+      return;
+    }
+    writeSync(this.startLog().fd, chunk.data);
+    this.tail.push(chunk);
+    this.tailBytes += chunk.data.length;
+    while (this.tail.length > 1 && this.tailBytes - (this.tail[0]?.data.length ?? 0) >= TAIL_BYTES) {
+      const gone = this.tail.shift();
+      this.tailBytes -= gone?.data.length ?? 0;
+      this.dropped += gone?.data.length ?? 0;
+    }
+  }
+  startLog() {
+    if (this.log !== undefined)
+      return this.log;
+    this.log = newLog(this.dir);
+    for (const chunk of [...this.head, ...this.tail])
+      writeSync(this.log.fd, chunk.data);
+    return this.log;
+  }
+  get overflowing() {
+    return this.dropped > 0;
+  }
+  get bytes() {
+    return this.headBytes + this.tailBytes + this.dropped;
+  }
+  get chunks() {
+    return [...this.head, ...this.tail];
+  }
+  save() {
+    return this.startLog().path;
+  }
+  discard() {
+    if (this.log === undefined)
+      return;
+    closeSync(this.log.fd);
+    rmSync(this.log.path, { force: true });
+    this.log = undefined;
+  }
+  get text() {
+    const decode = (chunks) => Buffer.concat(chunks.map(({ data }) => data)).toString();
+    if (this.dropped === 0)
+      return decode(this.chunks);
+    return `${decode(this.head)}
+[out: ${this.dropped} bytes left out of memory, all of it is in the log]
+${decode(this.tail)}`;
+  }
+}
+function replay(chunks) {
+  for (const { stream, data } of chunks)
+    process10[stream].write(data);
+}
+function count(recorder, shown, recorded) {
+  const baseline = recorded.was.length === 0 || recorder.overflowing ? undefined : filtered(recorder.text, recorded.was);
+  record({ at: new Date().toISOString(), dir: process10.cwd(), command: recorded.command, bytes: recorder.bytes, baseline: baseline === undefined ? recorder.bytes : Buffer.byteLength(baseline), shown, folded: shown !== recorder.bytes });
+}
+async function run(command, threshold, was = []) {
+  const dir = await logDir();
+  await cleanLogs(dir);
+  const recorder = new Recorder(dir);
+  const held = holdSignals();
+  let started = false;
+  let code;
+  try {
+    const ran = await runCommand(command, {
+      stdin: "inherit",
+      maxBytes: 0,
+      onStart: (child) => {
+        started = true;
+        held.forward(child);
+      },
+      onChunk: (chunk) => {
+        recorder.add(chunk);
+      }
+    });
+    code = ran.code;
+  } catch (error) {
+    if (!started) {
+      console.error(`out: cannot run ${command[0]}: ${error instanceof Error ? error.message : String(error)}`);
+      return 127;
+    }
+    console.error(`out: ${error instanceof Error ? error.message : String(error)}`);
+    code = 1;
+  } finally {
+    held.release();
+  }
+  count(recorder, present(recorder, threshold), { command: commandKey(command), was });
+  return code;
+}
+async function readPiped(threshold, was = []) {
+  const dir = await logDir();
+  await cleanLogs(dir);
+  const recorder = new Recorder(dir);
+  for await (const data of Bun.stdin.stream())
+    recorder.add({ stream: "stdout", data });
+  count(recorder, present(recorder, threshold), { command: "(piped)", was });
+  return 0;
+}
+function present(recorder, threshold) {
+  const text = recorder.text;
+  if (!recorder.overflowing && !shouldFold(text, threshold)) {
+    replay(recorder.chunks);
+    return recorder.bytes;
+  }
+  let printed;
+  try {
+    printed = fold(text, { threshold, logPath: recorder.save() });
+  } catch (error) {
+    console.error(`out: could not fold the output: ${error instanceof Error ? error.message : String(error)}`);
+    printed = text.split(`
+`).slice(-FALLBACK_LINES).join(`
+`);
+  }
+  if (!recorder.overflowing && Buffer.byteLength(printed) >= recorder.bytes) {
+    recorder.discard();
+    replay(recorder.chunks);
+    return recorder.bytes;
+  }
+  process10.stdout.write(printed);
+  return Buffer.byteLength(printed);
+}
+
+// src/cli.ts
+var USAGE = `out [-n <lines>] -- <command> [args...]: runs the command and shortens its output when it is long, exiting with its code
+<command> | out [-n <lines>]: shortens the output piped in
+out --stats [--since 7d] [--json]: the runs recorded and about how many tokens they saved
+
+Each run is recorded in ~/.local/state/kaynooo-cli/out/stats.jsonl with the words naming the command, never its arguments; tokens are counted as bytes / 4.
+Exits 0 when the command does, with its own code otherwise, 127 when it cannot be started, 2 on a usage error. Piped into, it exits 0.`;
+var OPTIONS = {
+  lines: { type: "string", short: "n", description: "longest output left untouched (default 150)" },
+  was: { type: "string", multiple: true, description: "a tail, head or grep stage out stands in for, so the stats count against what it would have printed (repeatable, in pipeline order)" },
+  stats: { type: "boolean", description: "print the runs recorded and the tokens saved" },
+  since: { type: "string", description: "with --stats, only the runs this recent (7d, 12h)" },
+  json: jsonOption("with --stats, {runs, folded, bytes, shown, tokensSaved, commands}")
+};
+async function stats(since, json) {
+  const window = since === undefined ? undefined : duration(since, "since", 0, "h");
+  const summary = summarize(await readEntries(statsPath(), window === undefined ? 0 : Date.now() - window));
+  if (json)
+    printJson(summary);
+  else
+    console.log(renderSummary(summary, since === undefined ? "recorded" : `in the last ${since}`));
+  return 0;
+}
+async function main(argv) {
+  const bare = argv[0] !== undefined && !argv[0].startsWith("-");
+  const parsed = parse(bare ? [] : argv, USAGE, OPTIONS, { rest: true, replaces: "piping a noisy command through tail or head", examples: ["out -- bun install", ["out -n 300 -- bun run build", "up to 300 lines left untouched"], ["bun run build 2>&1 | out", "what is piped in"], ["out --stats --since 7d", "the tokens saved this week"]] });
+  const { values } = parsed;
+  if (values.stats === true) {
+    if ((parsed.rest ?? []).length > 0 || parsed.positionals.length > 0)
+      badUsage("--stats runs no command");
+    return stats(values.since, values.json === true);
+  }
+  if (values.since !== undefined || values.json === true)
+    badUsage("--since and --json go with --stats");
+  const command = bare ? argv : parsed.rest ?? [];
+  const lines = wholeNumber(values.lines, "lines", FOLD_LINES);
+  const was = values.was ?? [];
+  if (command.length === 0 && parsed.positionals.length === 0 && isStdinPiped())
+    return readPiped(lines, was);
+  if (command.length === 0 || parsed.positionals.length > 0)
+    fail(`give the command after --
+
+${USAGE}`);
+  return run(command, lines, was);
+}
+process11.exitCode = await runMain({ name: "out", version, run: main });