@ccpluginizer/ccpluginizer 0.6.0 → 0.6.1

package/dist/index.js

@@ -16,1401 +16,1786 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/shared/chunk-vt64gs69.js
-import { parseArgs as U } from "util";
-function q(B) {
-  let J = {}, G = {};
-  if (!B)
-    return { options: J, aliasToName: G };
-  let z = new Map;
-  for (let j of Object.keys(B))
-    z.set(j, j);
-  for (let [j, H] of Object.entries(B)) {
-    if (j.startsWith("no-")) {
-      let L = j.slice(3);
-      throw new W("DEFINITION", `Flag "--${j}" must not use "no-" prefix; define "${L}" and negate with "--no-${L}"`);
-    }
-    let K = H.type === "boolean" ? "boolean" : "string", Q = { type: K };
-    if (H.multiple)
-      Q.multiple = true;
-    if (H.short) {
-      if (H.short.startsWith("no-"))
-        throw new W("DEFINITION", `Short alias "-${H.short}" on "--${j}" must not use "no-" prefix (reserved for negation)`);
-      let L = z.get(H.short);
-      if (L)
-        throw new W("DEFINITION", `Alias collision: "-${H.short}" is used by both "--${L}" and "--${j}"`);
-      z.set(H.short, j), G[H.short] = j, Q.short = H.short;
-    }
-    if (H.aliases)
-      for (let L of H.aliases) {
-        if (L.startsWith("no-"))
-          throw new W("DEFINITION", `Alias "--${L}" on "--${j}" must not use "no-" prefix (reserved for negation)`);
-        let X = z.get(L);
-        if (X)
-          throw new W("DEFINITION", `Alias collision: "${L.length === 1 ? "-" : "--"}${L}" is used by both "--${X}" and "--${j}"`);
-        z.set(L, j), G[L] = j;
-        let $ = { type: K };
-        if (H.multiple)
-          $.multiple = true;
-        J[L] = $;
+// ../../node_modules/.bun/@crustjs+utils@0.0.3+328ed37f40d3034a/node_modules/@crustjs/utils/dist/index.js
+function C(N) {
+  let O = Number(N);
+  return Number.isNaN(O) ? undefined : O;
+}
+function G(N) {
+  return N === "true" || N === "1";
+}
+var init_dist = () => {};
+
+// ../../node_modules/.bun/@crustjs+core@0.0.19+328ed37f40d3034a/node_modules/@crustjs/core/dist/shared/chunk-q8y07jw2.js
+import { parseArgs as L } from "util";
+import { homedir as k } from "os";
+import { resolve as T } from "path";
+function R(H) {
+  try {
+    return new URL(H);
+  } catch {
+    let z = /^[a-z][a-z0-9+.-]*:/i.test(H) ? "" : " (missing protocol — e.g. https://example.com)";
+    throw new Y("PARSE", `Invalid URL "${H}"${z}`);
+  }
+}
+function J(H) {
+  if (H === "")
+    throw new Y("PARSE", "Path cannot be empty");
+  let K = H.replace(/^~(?=\/|$)/, k());
+  return T(process.cwd(), K);
+}
+function O(H) {
+  try {
+    return JSON.parse(H);
+  } catch (K) {
+    let z = K instanceof Error ? K.message : String(K);
+    throw new Y("PARSE", `Invalid JSON: ${z}. Tip: wrap JSON in single quotes on the command line, e.g. --flag '{"k":1}'`);
+  }
+}
+function w(H) {
+  let K = {}, z = {};
+  if (!H)
+    return { options: K, aliasToName: z };
+  let $ = new Map;
+  for (let Q of Object.keys(H))
+    $.set(Q, Q);
+  for (let [Q, Z] of Object.entries(H)) {
+    if (Q.startsWith("no-")) {
+      let X = Q.slice(3);
+      throw new Y("DEFINITION", `Flag "--${Q}" must not use "no-" prefix; define "${X}" and negate with "--no-${X}"`);
+    }
+    if (!E.has(Z.type))
+      throw new Y("DEFINITION", `Flag "--${Q}" must declare a parser type ("string", "number", "boolean", "url", "path", or "json")`);
+    let B = Z.type === "boolean" ? "boolean" : "string", W = { type: B };
+    if (Z.multiple)
+      W.multiple = true;
+    if (Z.short) {
+      if (Z.short.startsWith("no-"))
+        throw new Y("DEFINITION", `Short alias "-${Z.short}" on "--${Q}" must not use "no-" prefix (reserved for negation)`);
+      let X = $.get(Z.short);
+      if (X)
+        throw new Y("DEFINITION", `Alias collision: "-${Z.short}" is used by both "--${X}" and "--${Q}"`);
+      $.set(Z.short, Q), z[Z.short] = Q, W.short = Z.short;
+    }
+    if (Z.aliases)
+      for (let X of Z.aliases) {
+        if (X.startsWith("no-"))
+          throw new Y("DEFINITION", `Alias "--${X}" on "--${Q}" must not use "no-" prefix (reserved for negation)`);
+        let G2 = $.get(X);
+        if (G2)
+          throw new Y("DEFINITION", `Alias collision: "${X.length === 1 ? "-" : "--"}${X}" is used by both "--${G2}" and "--${Q}"`);
+        $.set(X, Q), z[X] = Q;
+        let M = { type: B };
+        if (Z.multiple)
+          M.multiple = true;
+        K[X] = M;
       }
-    J[j] = Q;
-  }
-  return { options: J, aliasToName: G };
-}
-function _(B, J, G) {
-  if (J === "number") {
-    let z = Number(B);
-    if (Number.isNaN(z))
-      throw new W("PARSE", `Expected number for ${G}, got "${B}"`);
-    return z;
-  }
-  if (J === "boolean")
-    return B === "true" || B === "1";
-  return B;
-}
-function I(B, J, G) {
-  let z = `--${B}`;
-  if (J.multiple && Array.isArray(G))
-    return J.type === "boolean" ? G.filter((j) => typeof j === "boolean") : G.map((j) => _(j, J.type, z));
-  if (J.type === "boolean") {
-    if (typeof G === "boolean")
-      return G;
-    throw new W("PARSE", `Expected boolean value for flag "${z}", got ${typeof G}`);
-  }
-  if (typeof G === "string")
-    return _(G, J.type, z);
-  if (G === true)
-    return J.default ?? undefined;
-  return G;
-}
-function M(B, J, G) {
-  let z = {};
-  for (let j in B) {
-    let H = J[j] ?? j;
-    if (!(H in G))
-      continue;
-    let K = B[j], Q = z[H];
-    if (Q !== undefined && Array.isArray(Q) && Array.isArray(K))
-      Q.push(...K);
+    K[Q] = W;
+  }
+  return { options: K, aliasToName: z };
+}
+function F(H, K, z) {
+  if (K === "number") {
+    let $ = C(H);
+    if ($ === undefined)
+      throw new Y("PARSE", `Expected number for ${z}, got "${H}"`);
+    return $;
+  }
+  if (K === "boolean")
+    return G(H);
+  if (K === "url")
+    return R(H);
+  if (K === "path")
+    return J(H);
+  if (K === "json")
+    return O(H);
+  return H;
+}
+function I(H, K, z) {
+  if (!K.includes(H))
+    throw new Y("PARSE", `Invalid value "${H}" for ${z}. Expected one of: ${K.join(", ")}`);
+}
+function _(H, K, z, $) {
+  try {
+    return H(K);
+  } catch (Q) {
+    let Z = $ === undefined ? z : `${z} element [${$}]`, B = Q instanceof Error ? Q.message : String(Q);
+    throw new Y("PARSE", `Failed to parse ${Z}: ${B}`).withCause(Q);
+  }
+}
+function P(H, K) {
+  let { default: z, choices: $, parse: Q } = H;
+  if (z === undefined)
+    return;
+  if ($)
+    if (Array.isArray(z))
+      for (let Z of z)
+        I(String(Z), $, K);
     else
-      z[H] = K;
+      I(String(z), $, K);
+  if (Q) {
+    if (Array.isArray(z))
+      return z.map((Z, B) => _(Q, String(Z), K, B));
+    return _(Q, String(z), K);
+  }
+  if (H.type === "path") {
+    if (Array.isArray(z))
+      return z.map((Z) => J(String(Z)));
+    return J(String(z));
   }
   return z;
 }
-function h(B, J, G) {
-  if (!B)
+function N(H, K) {
+  if (H)
+    for (let [z, $] of Object.entries(H)) {
+      let Q = $.parse;
+      if (Q && Q.constructor.name === "AsyncFunction")
+        throw new Y("CONFIG", `Async parse not supported for flag --${z}. Use a sync parser; do async work in run().`);
+    }
+  if (K)
+    for (let z of K) {
+      let $ = z.parse;
+      if ($ && $.constructor.name === "AsyncFunction")
+        throw new Y("CONFIG", `Async parse not supported for argument <${z.name}>. Use a sync parser; do async work in run().`);
+    }
+}
+function h(H, K, z) {
+  let $ = `--${H}`, Q = K.choices, Z = K.parse;
+  if (K.multiple && Array.isArray(z)) {
+    if (K.type === "boolean")
+      return z.filter((B) => typeof B === "boolean");
+    return z.map((B, W) => {
+      if (Q)
+        I(B, Q, $);
+      if (Z)
+        return _(Z, B, $, W);
+      return F(B, K.type, $);
+    });
+  }
+  if (K.type === "boolean") {
+    if (typeof z === "boolean")
+      return z;
+    throw new Y("PARSE", `Expected boolean value for flag "${$}", got ${typeof z}`);
+  }
+  if (typeof z === "string") {
+    if (Q)
+      I(z, Q, $);
+    if (Z)
+      return _(Z, z, $);
+    return F(z, K.type, $);
+  }
+  throw new Y("PARSE", `Internal: unexpected value shape for flag "${$}" (got ${typeof z})`);
+}
+function C2(H, K, z) {
+  let $ = {};
+  for (let Q in H) {
+    let Z = K[Q] ?? Q;
+    if (!(Z in z))
+      continue;
+    let B = H[Q], W = $[Z];
+    if (W !== undefined && Array.isArray(W) && Array.isArray(B))
+      W.push(...B);
+    else
+      $[Z] = B;
+  }
+  return $;
+}
+function V(H, K, z) {
+  if (!H)
     return {};
-  let z = M(J, G, B), j = {};
-  for (let [H, K] of Object.entries(B)) {
-    let Q = z[H];
-    if (Q !== undefined) {
-      j[H] = I(H, K, Q);
+  let $ = C2(K, z, H), Q = {};
+  for (let [Z, B] of Object.entries(H)) {
+    let W = $[Z];
+    if (W !== undefined) {
+      Q[Z] = h(Z, B, W);
       continue;
     }
-    j[H] = K.default ?? undefined;
+    Q[Z] = P(B, `--${Z}`);
   }
-  return j;
+  return Q;
 }
-function O(B, J) {
-  if (!B)
+function D(H, K) {
+  if (!H)
     return;
-  for (let [G, z] of Object.entries(B))
-    if (z.required === true && z.default === undefined) {
-      if (J[G] === undefined)
-        throw new W("VALIDATION", `Missing required flag "--${G}"`);
+  for (let [z, $] of Object.entries(H))
+    if ($.required === true && $.default === undefined) {
+      if (K[z] === undefined)
+        throw new Y("VALIDATION", `Missing required flag "--${z}"`);
     }
 }
-function P(B, J) {
-  if (!B)
+function b(H, K) {
+  if (!H)
     return {};
-  let G = {}, z = 0;
-  for (let j of B) {
-    let { name: H } = j;
-    if (j.variadic) {
-      let K = J.slice(z);
-      G[H] = j.type === "string" ? K : K.map((Q) => _(Q, j.type, `<${H}>`)), z = J.length;
-    } else if (z < J.length)
-      G[H] = _(J[z], j.type, `<${H}>`), z++;
+  let z = {}, $ = 0;
+  for (let Q of H) {
+    let { name: Z } = Q, B = `<${Z}>`, W = Q.choices, X = Q.parse, G2 = (M, U) => {
+      if (W)
+        I(M, W, B);
+      if (X)
+        return _(X, M, B, U);
+      return Q.type === undefined ? M : F(M, Q.type, B);
+    };
+    if (Q.variadic) {
+      let M = K.slice($);
+      z[Z] = M.map((U, q) => G2(U, q)), $ = K.length;
+    } else if ($ < K.length)
+      z[Z] = G2(K[$]), $++;
     else
-      G[H] = j.default ?? undefined;
+      z[Z] = P(Q, B);
   }
-  return G;
+  return z;
 }
-function S(B, J, G) {
-  if (!J)
+function v(H, K, z) {
+  if (!K)
     return;
-  for (let z of B) {
-    if (z === "--")
+  for (let $ of H) {
+    if ($ === "--")
       return;
-    if (!z.startsWith("--no-"))
+    if (!$.startsWith("--no-"))
       continue;
-    let j = z.indexOf("="), H = j === -1 ? z.slice(5) : z.slice(5, j);
-    if (!H)
+    let Q = $.indexOf("="), Z = Q === -1 ? $.slice(5) : $.slice(5, Q);
+    if (!Z)
       continue;
-    let K = G[H];
-    if (!K)
+    let B = z[Z];
+    if (!B)
       continue;
-    if (K === H)
+    if (B === Z)
       continue;
-    if (J[K]?.type !== "boolean")
+    if (K[B]?.type !== "boolean")
       continue;
-    throw new W("PARSE", `Cannot negate alias "--no-${H}"; use "--no-${K}" instead`);
+    throw new Y("PARSE", `Cannot negate alias "--no-${Z}"; use "--no-${B}" instead`);
   }
 }
-function b(B, J) {
-  let { args: G, effectiveFlags: z } = B, { options: j, aliasToName: H } = q(z);
-  S(J, z, H);
-  let K;
+function S(H, K) {
+  let { args: z, effectiveFlags: $ } = H;
+  N($, z);
+  let { options: Q, aliasToName: Z } = w($);
+  v(K, $, Z);
+  let B;
   try {
-    K = U({ args: J, options: j, strict: true, allowPositionals: true, allowNegative: true, tokens: true });
-  } catch (Y) {
-    if (Y instanceof Error) {
-      let Z = Y.message.match(/Unknown option '(.+?)'/);
-      if (Z)
-        throw new W("PARSE", `Unknown flag "${Z[1]}"`).withCause(Y);
-    }
-    throw new W("PARSE", "Failed to parse command arguments").withCause(Y);
-  }
-  let Q = [], L = [];
-  if (K.tokens) {
-    let Y = false;
-    for (let Z of K.tokens) {
-      if (Z.kind === "option-terminator") {
-        Y = true;
+    B = L({ args: K, options: Q, strict: true, allowPositionals: true, allowNegative: true, tokens: true });
+  } catch (U) {
+    if (U instanceof Error) {
+      let q = U.message.match(/Unknown option '(.+?)'/);
+      if (q)
+        throw new Y("PARSE", `Unknown flag "${q[1]}"`).withCause(U);
+    }
+    throw new Y("PARSE", "Failed to parse command arguments").withCause(U);
+  }
+  let W = [], X = [];
+  if (B.tokens) {
+    let U = false;
+    for (let q of B.tokens) {
+      if (q.kind === "option-terminator") {
+        U = true;
         continue;
       }
-      if (Z.kind === "positional")
-        (Y ? Q : L).push(Z.value ?? "");
+      if (q.kind === "positional")
+        (U ? W : X).push(q.value ?? "");
     }
   } else
-    L.push(...K.positionals);
-  let X = h(z, K.values, H);
-  return { args: P(G, L), flags: X, rawArgs: Q };
-}
-function E(B, J) {
-  let { args: G, effectiveFlags: z } = B, j = J.args, H = J.flags;
-  if (G)
-    for (let K of G) {
-      let { name: Q } = K, L = `argument "<${Q}>"`, X = j[Q];
-      if (K.required === true && K.default === undefined) {
-        if (K.variadic) {
-          if (!Array.isArray(X) || X.length === 0)
-            throw new W("VALIDATION", `Missing required ${L}`);
-        } else if (X === undefined)
-          throw new W("VALIDATION", `Missing required ${L}`);
+    X.push(...B.positionals);
+  let G2 = V($, B.values, Z);
+  return { args: b(z, X), flags: G2, rawArgs: W };
+}
+function A(H, K) {
+  let { args: z, effectiveFlags: $ } = H, Q = K.args, Z = K.flags;
+  if (z)
+    for (let B of z) {
+      let { name: W } = B, X = `argument "<${W}>"`, G2 = Q[W];
+      if (B.required === true && B.default === undefined) {
+        if (B.variadic) {
+          if (!Array.isArray(G2) || G2.length === 0)
+            throw new Y("VALIDATION", `Missing required ${X}`);
+        } else if (G2 === undefined)
+          throw new Y("VALIDATION", `Missing required ${X}`);
       }
     }
-  O(z, H);
-}
-var W;
-var init_chunk_vt64gs69 = __esm(() => {
-  W = class W extends Error {
-    code;
-    details;
-    cause;
-    constructor(B, J, ...G) {
-      super(J);
-      this.name = "CrustError", this.code = B, this.details = G[0];
-    }
-    is(B) {
-      return this.code === B;
-    }
-    withCause(B) {
-      return this.cause = B, this;
+  D($, Z);
+}
+function p(H, K, z) {
+  if (typeof H !== "string" || H.length === 0)
+    throw new Y("DEFINITION", `Subcommand "${z}" has an invalid alias: must be a non-empty string`);
+  if (/\s/.test(H))
+    throw new Y("DEFINITION", `Subcommand "${z}" alias "${H}" must not contain whitespace`);
+  if (H.startsWith("-"))
+    throw new Y("DEFINITION", `Subcommand "${z}" alias "${H}" must not start with "-" (reserved for flags)`);
+  if (H === K)
+    throw new Y("DEFINITION", `Subcommand "${z}" alias "${H}" must not equal its own canonical name`);
+}
+function g(H, K, z) {
+  let { canonicalName: $, aliases: Q } = H;
+  if (Q) {
+    let Z = new Set;
+    for (let B of Q) {
+      if (p(B, $, z), Z.has(B))
+        throw new Y("DEFINITION", `Subcommand "${z}" lists alias "${B}" more than once`);
+      Z.add(B);
+    }
+  }
+  for (let [Z, B] of Object.entries(K)) {
+    let W = B.meta.aliases;
+    if (W?.includes($))
+      throw new Y("DEFINITION", `Subcommand "${z}" canonical name "${$}" collides with alias of sibling "${Z}"`);
+    if (!Q)
+      continue;
+    for (let X of Q) {
+      if (X === Z)
+        throw new Y("DEFINITION", `Subcommand "${z}" alias "${X}" collides with sibling canonical name "${Z}"`);
+      if (W?.includes(X))
+        throw new Y("DEFINITION", `Subcommand "${z}" alias "${X}" collides with alias of sibling "${Z}"`);
     }
-  };
-});
-
-// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/shared/chunk-5apf3vnv.js
-var exports_chunk_5apf3vnv = {};
-__export(exports_chunk_5apf3vnv, {
-  validateCommandTree: () => _2
-});
-function M2(B) {
-  switch (B.type) {
+  }
+}
+function j(H) {
+  let K = H.choices;
+  if (K !== undefined && K.length > 0)
+    return K[0];
+  switch (H.type) {
     case "number":
       return "1";
     case "boolean":
       return "true";
+    case "url":
+      return "https://example.com";
+    case "json":
+      return "null";
     default:
       return "sample";
   }
 }
-function X(B) {
-  let z = [], K = B.effectiveFlags;
-  for (let [j, G] of Object.entries(K)) {
-    if (G.required !== true || G.default !== undefined)
+function m(H) {
+  let K = [], z = H.effectiveFlags;
+  for (let [Q, Z] of Object.entries(z)) {
+    if (Z.required !== true || Z.default !== undefined)
       continue;
-    if (z.push(`--${j}`), G.type !== "boolean")
-      z.push(M2(G));
+    if (K.push(`--${Q}`), Z.type !== "boolean")
+      K.push(j(Z));
   }
-  let J = B.args;
-  if (J)
-    for (let j of J) {
-      if (j.required !== true || j.default !== undefined)
+  let $ = H.args;
+  if ($)
+    for (let Q of $) {
+      if (Q.required !== true || Q.default !== undefined)
         continue;
-      z.push(M2(j));
+      K.push(j(Q));
     }
-  return z;
+  return K;
 }
-function _2(B) {
-  let z = [{ command: B, path: [B.meta.name] }], K = new Set;
-  while (z.length > 0) {
-    let J = z.pop();
-    if (!J)
+function Hz(H) {
+  let K = [{ command: H, path: [H.meta.name] }], z = new Set;
+  while (K.length > 0) {
+    let $ = K.pop();
+    if (!$)
       break;
-    let { command: j, path: G } = J;
-    if (K.has(j))
+    let { command: Q, path: Z } = $;
+    if (z.has(Q))
       continue;
-    K.add(j);
+    z.add(Q);
     try {
-      let H = b(j, X(j));
-      E(j, H);
-    } catch (H) {
-      let L = H instanceof Error ? H.message : "Unknown validation error";
-      throw new W("DEFINITION", `Command "${G.join(" ")}" failed runtime validation: ${L}`).withCause(H);
+      let W = S(Q, m(Q));
+      A(Q, W);
+    } catch (W) {
+      let X = W instanceof Error ? W.message : "Unknown validation error";
+      throw new Y("DEFINITION", `Command "${Z.join(" ")}" failed runtime validation: ${X}`).withCause(W);
+    }
+    let B = {};
+    for (let [W, X] of Object.entries(Q.subCommands))
+      g({ canonicalName: W, aliases: X.meta.aliases }, B, [...Z, W].join(" ")), B[W] = X;
+    for (let [W, X] of Object.entries(Q.subCommands))
+      K.push({ command: X, path: [...Z, W] });
+  }
+}
+var Y, E;
+var init_chunk_q8y07jw2 = __esm(() => {
+  init_dist();
+  Y = class Y extends Error {
+    code;
+    details;
+    cause;
+    constructor(H, K, ...z) {
+      super(K);
+      this.name = "CrustError", this.code = H, this.details = z[0];
     }
-    for (let [H, L] of Object.entries(j.subCommands))
-      z.push({ command: L, path: [...G, H] });
-  }
-}
-var init_chunk_5apf3vnv = __esm(() => {
-  init_chunk_vt64gs69();
+    is(H) {
+      return this.code === H;
+    }
+    withCause(H) {
+      return this.cause = H, this;
+    }
+  };
+  E = new Set(["string", "number", "boolean", "url", "path", "json"]);
 });
 
-// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/index.js
-init_chunk_vt64gs69();
-function T(j) {
-  return { meta: { name: j }, localFlags: {}, effectiveFlags: {}, args: undefined, subCommands: {}, plugins: [], preRun: undefined, run: undefined, postRun: undefined };
-}
-function z(j, q2) {
-  let J = {};
-  for (let [Q, $] of Object.entries(j))
-    if ($.inherit === true)
-      J[Q] = $;
-  for (let [Q, $] of Object.entries(q2))
-    J[Q] = $;
-  return J;
-}
-function D(j, q2) {
-  let J = [j.meta.name], Q = j, $ = q2;
-  while ($.length > 0) {
-    let K = Q.subCommands;
-    if (!K || Object.keys(K).length === 0)
+// ../../node_modules/.bun/@crustjs+core@0.0.19+328ed37f40d3034a/node_modules/@crustjs/core/dist/shared/chunk-1670njz2.js
+var exports_chunk_1670njz2 = {};
+__export(exports_chunk_1670njz2, {
+  validateIncomingAliases: () => g,
+  validateCommandTree: () => Hz,
+  validateAliasString: () => p
+});
+var init_chunk_1670njz2 = __esm(() => {
+  init_chunk_q8y07jw2();
+});
+
+// ../../node_modules/.bun/@crustjs+core@0.0.19+328ed37f40d3034a/node_modules/@crustjs/core/dist/index.js
+init_chunk_q8y07jw2();
+function P2(j2) {
+  return { meta: { name: j2 }, localFlags: {}, effectiveFlags: {}, args: undefined, subCommands: {}, plugins: [], preRun: undefined, run: undefined, postRun: undefined };
+}
+function X(j2, J2) {
+  let q = {};
+  for (let [Q, Z] of Object.entries(j2))
+    if (Z.inherit === true)
+      q[Q] = Z;
+  for (let [Q, Z] of Object.entries(J2))
+    q[Q] = Z;
+  return q;
+}
+function E2(j2, J2) {
+  for (let [q, Q] of Object.entries(j2)) {
+    let Z = Q.meta.aliases;
+    if (!Z)
+      continue;
+    if (Z.includes(J2))
+      return { canonicalName: q, node: Q };
+  }
+  return null;
+}
+function D2(j2, J2) {
+  let q = [j2.meta.name], Q = j2, Z = J2;
+  while (Z.length > 0) {
+    let $ = Q.subCommands;
+    if (!$ || Object.keys($).length === 0)
       break;
-    let Z = $[0];
-    if (!Z || Z.startsWith("-"))
+    let G2 = Z[0];
+    if (!G2 || G2.startsWith("-"))
       break;
-    if (Z in K && K[Z]) {
-      Q = K[Z], J.push(Z), $ = $.slice(1);
+    if (G2 in $ && $[G2]) {
+      Q = $[G2], q.push(G2), Z = Z.slice(1);
+      continue;
+    }
+    let H = E2($, G2);
+    if (H) {
+      Q = H.node, q.push(H.canonicalName), Z = Z.slice(1);
       continue;
     }
     if (Q.run)
       break;
-    let H = Object.keys(K);
-    throw new W("COMMAND_NOT_FOUND", `Unknown command "${Z}".`, { input: Z, available: H, commandPath: [...J], parentCommand: Q });
+    throw new Y("COMMAND_NOT_FOUND", `Unknown command "${G2}".`, { input: G2, available: Object.keys($), commandPath: [...q], parentCommand: Q });
   }
-  return { command: Q, argv: $, commandPath: J };
+  return { command: Q, argv: Z, commandPath: q };
 }
-function N(j) {
-  for (let [q2, J] of Object.entries(j)) {
-    if (q2.startsWith("no-")) {
-      let Q = q2.slice(3);
-      throw new W("DEFINITION", `Flag "--${q2}" must not use "no-" prefix; define "${Q}" and negate with "--no-${Q}"`);
+function f2(j2) {
+  for (let [J2, q] of Object.entries(j2)) {
+    if (J2.startsWith("no-")) {
+      let Q = J2.slice(3);
+      throw new Y("DEFINITION", `Flag "--${J2}" must not use "no-" prefix; define "${Q}" and negate with "--no-${Q}"`);
     }
-    if (J.short?.startsWith("no-"))
-      throw new W("DEFINITION", `Short alias "-${J.short}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
-    if (J.aliases) {
-      for (let Q of J.aliases)
+    if (q.short?.startsWith("no-"))
+      throw new Y("DEFINITION", `Short alias "-${q.short}" on "--${J2}" must not use "no-" prefix (reserved for negation)`);
+    if (q.aliases) {
+      for (let Q of q.aliases)
         if (Q.startsWith("no-"))
-          throw new W("DEFINITION", `Alias "--${Q}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
-    }
-  }
-}
-var w = "CRUST_INTERNAL_VALIDATE_ONLY";
-var P2 = 130;
-var v = "__CRUST_VALIDATE_RESULT__";
-function x() {
-  let j = new Map;
-  return { get(q2) {
-    return j.get(q2);
-  }, has(q2) {
-    return j.has(q2);
-  }, set(q2, J) {
-    j.set(q2, J);
-  }, delete(q2) {
-    return j.delete(q2);
+          throw new Y("DEFINITION", `Alias "--${Q}" on "--${J2}" must not use "no-" prefix (reserved for negation)`);
+    }
+  }
+}
+var N2 = "CRUST_INTERNAL_VALIDATE_ONLY";
+var b2 = "CRUST_INTERNAL_VALIDATE_FORCE_EXIT";
+var x = 130;
+var C3 = "__CRUST_VALIDATE_RESULT__";
+function k2() {
+  let j2 = new Map;
+  return { get(J2) {
+    return j2.get(J2);
+  }, has(J2) {
+    return j2.has(J2);
+  }, set(J2, q) {
+    j2.set(J2, q);
+  }, delete(J2) {
+    return j2.delete(J2);
   } };
 }
-function B(j) {
-  if (!(j instanceof Error))
+function L2(j2) {
+  if (!(j2 instanceof Error))
     return false;
-  return j.name === "CancelledError";
-}
-function b2(j, q2) {
-  j.effectiveFlags = z(q2, j.localFlags);
-  for (let J of Object.values(j.subCommands))
-    b2(J, j.effectiveFlags);
-}
-function y(j) {
-  return { addFlag(q2, J, Q) {
-    if (J in q2.effectiveFlags)
-      j?.push(`Plugin flag "--${J}" on "${q2.meta.name}" overrides existing flag`);
-    q2.effectiveFlags[J] = Q;
-  }, addSubCommand(q2, J, Q) {
-    if (!J.trim())
-      throw new W("DEFINITION", "addSubCommand: name must be a non-empty string");
-    if (q2.subCommands[J]) {
-      j?.push(`Plugin subcommand "${J}" on "${q2.meta.name}" skipped (already exists)`);
+  return j2.name === "CancelledError";
+}
+function h2(j2, J2) {
+  j2.effectiveFlags = X(J2, j2.localFlags);
+  for (let q of Object.values(j2.subCommands))
+    h2(q, j2.effectiveFlags);
+}
+function y(j2) {
+  return { addFlag(J2, q, Q) {
+    if (q in J2.effectiveFlags)
+      j2?.push(`Plugin flag "--${q}" on "${J2.meta.name}" overrides existing flag`);
+    J2.effectiveFlags[q] = Q;
+  }, addSubCommand(J2, q, Q) {
+    if (!q.trim())
+      throw new Y("DEFINITION", "addSubCommand: name must be a non-empty string");
+    if (J2.subCommands[q]) {
+      j2?.push(`Plugin subcommand "${q}" on "${J2.meta.name}" skipped (already exists)`);
+      return;
+    }
+    try {
+      g({ canonicalName: q, aliases: Q.meta.aliases }, J2.subCommands, q);
+    } catch (Z) {
+      let $ = Z instanceof Error ? Z.message : String(Z);
+      j2?.push(`Plugin subcommand "${q}" on "${J2.meta.name}" skipped: ${$}`);
       return;
     }
-    b2(Q, q2.effectiveFlags), q2.subCommands[J] = Q;
+    h2(Q, J2.effectiveFlags), J2.subCommands[q] = Q;
   } };
 }
-async function A2(j, q2, J) {
-  for (let Q of j) {
+async function F2(j2, J2, q) {
+  for (let Q of j2) {
     if (!Q.setup)
       continue;
-    await Q.setup(q2, J);
+    await Q.setup(J2, q);
   }
 }
-async function F(j, q2, J) {
-  let Q = j.map((Z) => Z.middleware).filter((Z) => Boolean(Z)), $ = -1, K = async (Z) => {
-    if (Z <= $)
-      throw new W("DEFINITION", "Plugin middleware called next() multiple times");
-    if ($ = Z, Z === Q.length) {
-      await J();
+async function A2(j2, J2, q) {
+  let Q = j2.map((G2) => G2.middleware).filter((G2) => Boolean(G2)), Z = -1, $ = async (G2) => {
+    if (G2 <= Z)
+      throw new Y("DEFINITION", "Plugin middleware called next() multiple times");
+    if (Z = G2, G2 === Q.length) {
+      await q();
       return;
     }
-    let H = Q[Z];
+    let H = Q[G2];
     if (!H)
-      throw new W("DEFINITION", "Plugin middleware stack is invalid");
-    await H(q2, () => K(Z + 1));
+      throw new Y("DEFINITION", "Plugin middleware stack is invalid");
+    await H(J2, () => $(G2 + 1));
   };
-  await K(0);
-}
-function I2(j) {
-  let q2 = [...j.plugins];
-  for (let J of Object.values(j.subCommands))
-    q2.push(...I2(J));
-  return q2;
-}
-function k(j) {
-  let q2 = {};
-  for (let [J, Q] of Object.entries(j))
-    q2[J] = { ...Q, aliases: Q.aliases ? [...Q.aliases] : undefined };
-  return q2;
-}
-function h2(j) {
-  let q2 = {};
-  for (let [J, Q] of Object.entries(j.subCommands))
-    q2[J] = h2(Q);
-  return { meta: { ...j.meta }, localFlags: k(j.localFlags), effectiveFlags: k(j.effectiveFlags), args: j.args ? j.args.map((J) => ({ ...J })) : undefined, subCommands: q2, plugins: [...j.plugins], preRun: j.preRun, run: j.run, postRun: j.postRun };
-}
-function _3(j) {
-  if (Object.freeze(j), Object.freeze(j.localFlags), Object.freeze(j.effectiveFlags), Object.freeze(j.meta), Object.freeze(j.plugins), j.args)
-    Object.freeze(j.args);
-  for (let q2 of Object.values(j.subCommands))
-    _3(q2);
-  Object.freeze(j.subCommands);
+  await $(0);
+}
+function S2(j2) {
+  let J2 = [...j2.plugins];
+  for (let q of Object.values(j2.subCommands))
+    J2.push(...S2(q));
+  return J2;
+}
+function w2(j2) {
+  let J2 = {};
+  for (let [q, Q] of Object.entries(j2))
+    J2[q] = { ...Q, aliases: Q.aliases ? [...Q.aliases] : undefined };
+  return J2;
+}
+function v2(j2) {
+  let J2 = {};
+  for (let [q, Q] of Object.entries(j2.subCommands))
+    J2[q] = v2(Q);
+  return { meta: { ...j2.meta }, localFlags: w2(j2.localFlags), effectiveFlags: w2(j2.effectiveFlags), args: j2.args ? j2.args.map((q) => ({ ...q })) : undefined, subCommands: J2, plugins: [...j2.plugins], preRun: j2.preRun, run: j2.run, postRun: j2.postRun };
+}
+function _2(j2) {
+  if (Object.freeze(j2), Object.freeze(j2.localFlags), Object.freeze(j2.effectiveFlags), Object.freeze(j2.meta), Object.freeze(j2.plugins), j2.args)
+    Object.freeze(j2.args);
+  for (let J2 of Object.values(j2.subCommands))
+    _2(J2);
+  Object.freeze(j2.subCommands);
 }
 
-class R {
+class M {
   _node;
   _inheritedFlags;
-  constructor(j) {
-    if (!j.trim())
-      throw new W("DEFINITION", "meta.name must be a non-empty string");
-    this._node = T(j), this._inheritedFlags = {};
-  }
-  static _createChild(j, q2) {
-    let J = new R(j);
-    return J._inheritedFlags = q2, J;
-  }
-  _clone(j) {
-    let q2 = Object.create(Object.getPrototypeOf(this)), J = { ...this._node, localFlags: { ...this._node.localFlags }, effectiveFlags: { ...this._node.effectiveFlags }, subCommands: { ...this._node.subCommands }, plugins: [...this._node.plugins], meta: { ...this._node.meta }, args: this._node.args ? [...this._node.args] : undefined, ...j };
-    return q2._node = J, q2._inheritedFlags = this._inheritedFlags, q2;
-  }
-  meta(j) {
-    return this._clone({ meta: { ...this._node.meta, ...j } });
-  }
-  flags(j) {
-    N(j);
-    let q2 = {};
-    for (let [J, Q] of Object.entries(j))
-      q2[J] = { ...Q };
-    return this._clone({ localFlags: q2, effectiveFlags: z(this._inheritedFlags, q2) });
-  }
-  args(j) {
-    let q2 = j.map((J) => ({ ...J }));
-    return this._clone({ args: q2 });
-  }
-  run(j) {
-    return this._clone({ run: j });
-  }
-  preRun(j) {
-    return this._clone({ preRun: j });
-  }
-  postRun(j) {
-    return this._clone({ postRun: j });
-  }
-  use(j) {
-    return this._clone({ plugins: [...this._node.plugins, j] });
-  }
-  sub(j) {
-    if (!j.trim())
-      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
-    let q2 = z(this._inheritedFlags, this._node.localFlags);
-    return R._createChild(j, q2);
-  }
-  command(j, q2) {
-    if (typeof j === "string") {
-      let K = j;
-      if (!q2)
-        throw new W("DEFINITION", "command(name, cb) requires a callback");
-      if (!K.trim())
-        throw new W("DEFINITION", "Subcommand name must be a non-empty string");
-      if (this._node.subCommands[K])
-        throw new W("DEFINITION", `Subcommand "${K}" is already registered`);
-      let Z = z(this._inheritedFlags, this._node.localFlags), H = R._createChild(K, Z), X2 = q2(H), W2 = { ...X2._node, effectiveFlags: z(X2._inheritedFlags, X2._node.localFlags) };
-      return this._clone({ subCommands: { ...this._node.subCommands, [K]: W2 } });
-    }
-    let J = j, Q = J._node.meta.name;
+  constructor(j2) {
+    if (!j2.trim())
+      throw new Y("DEFINITION", "meta.name must be a non-empty string");
+    this._node = P2(j2), this._inheritedFlags = {};
+  }
+  static _createChild(j2, J2) {
+    let q = new M(j2);
+    return q._inheritedFlags = J2, q;
+  }
+  _clone(j2) {
+    let J2 = Object.create(Object.getPrototypeOf(this)), q = { ...this._node, localFlags: { ...this._node.localFlags }, effectiveFlags: { ...this._node.effectiveFlags }, subCommands: { ...this._node.subCommands }, plugins: [...this._node.plugins], meta: { ...this._node.meta }, args: this._node.args ? [...this._node.args] : undefined, ...j2 };
+    return J2._node = q, J2._inheritedFlags = this._inheritedFlags, J2;
+  }
+  meta(j2) {
+    return this._clone({ meta: { ...this._node.meta, ...j2 } });
+  }
+  flags(j2) {
+    f2(j2);
+    let J2 = {};
+    for (let [q, Q] of Object.entries(j2))
+      J2[q] = { ...Q };
+    return this._clone({ localFlags: J2, effectiveFlags: X(this._inheritedFlags, J2) });
+  }
+  args(j2) {
+    let J2 = j2.map((q) => ({ ...q }));
+    return this._clone({ args: J2 });
+  }
+  run(j2) {
+    return this._clone({ run: j2 });
+  }
+  preRun(j2) {
+    return this._clone({ preRun: j2 });
+  }
+  postRun(j2) {
+    return this._clone({ postRun: j2 });
+  }
+  use(j2) {
+    return this._clone({ plugins: [...this._node.plugins, j2] });
+  }
+  sub(j2) {
+    if (!j2.trim())
+      throw new Y("DEFINITION", "Subcommand name must be a non-empty string");
+    let J2 = X(this._inheritedFlags, this._node.localFlags);
+    return M._createChild(j2, J2);
+  }
+  command(j2, J2) {
+    if (typeof j2 === "string") {
+      let $ = j2;
+      if (!J2)
+        throw new Y("DEFINITION", "command(name, cb) requires a callback");
+      if (!$.trim())
+        throw new Y("DEFINITION", "Subcommand name must be a non-empty string");
+      if (this._node.subCommands[$])
+        throw new Y("DEFINITION", `Subcommand "${$}" is already registered`);
+      let G2 = X(this._inheritedFlags, this._node.localFlags), H = M._createChild($, G2), z = J2(H);
+      g({ canonicalName: $, aliases: z._node.meta.aliases }, this._node.subCommands, $);
+      let W = { ...z._node, effectiveFlags: X(z._inheritedFlags, z._node.localFlags) };
+      return this._clone({ subCommands: { ...this._node.subCommands, [$]: W } });
+    }
+    let q = j2, Q = q._node.meta.name;
     if (!Q.trim())
-      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+      throw new Y("DEFINITION", "Subcommand name must be a non-empty string");
     if (this._node.subCommands[Q])
-      throw new W("DEFINITION", `Subcommand "${Q}" is already registered`);
-    let $ = { ...J._node, effectiveFlags: z(J._inheritedFlags, J._node.localFlags) };
-    return this._clone({ subCommands: { ...this._node.subCommands, [Q]: $ } });
+      throw new Y("DEFINITION", `Subcommand "${Q}" is already registered`);
+    g({ canonicalName: Q, aliases: q._node.meta.aliases }, this._node.subCommands, Q);
+    let Z = { ...q._node, effectiveFlags: X(q._inheritedFlags, q._node.localFlags) };
+    return this._clone({ subCommands: { ...this._node.subCommands, [Q]: Z } });
   }
-  async prepareCommandTree(j) {
-    let q2 = j?.argv ?? [], J = h2(this._node), Q = I2(J), $ = [], K = x(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y($);
+  async prepareCommandTree(j2) {
+    let J2 = j2?.argv ?? [], q = v2(this._node), Q = S2(q), Z = [], $ = k2(), G2 = { argv: [...J2], rootCommand: q, state: $ }, H = y(Z);
     try {
-      await A2(Q, Z, H);
-    } catch (W2) {
-      if (B(W2))
-        throw W2;
-      if (W2 instanceof W)
-        throw W2;
-      if (W2 instanceof Error)
-        throw W2;
-      throw new W("DEFINITION", String(W2));
-    }
-    _3(J);
-    let { validateCommandTree: X2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
-    return X2(J), { root: J, warnings: $ };
-  }
-  async execute(j) {
-    let q2 = j?.argv ?? process.argv.slice(2), J = this._node, Q = I2(J), $ = [], K = x(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y($);
+      await F2(Q, G2, H);
+    } catch (W) {
+      if (L2(W))
+        throw W;
+      if (W instanceof Y)
+        throw W;
+      if (W instanceof Error)
+        throw W;
+      throw new Y("DEFINITION", String(W));
+    }
+    _2(q);
+    let { validateCommandTree: z } = await Promise.resolve().then(() => (init_chunk_1670njz2(), exports_chunk_1670njz2));
+    return z(q), { root: q, warnings: Z };
+  }
+  async execute(j2) {
+    let J2 = j2?.argv ?? process.argv.slice(2), q = this._node, Q = S2(q), Z = [], $ = k2(), G2 = { argv: [...J2], rootCommand: q, state: $ }, H = y(Z);
     try {
-      await A2(Q, Z, H);
-    } catch (W2) {
-      if (B(W2)) {
-        process.exitCode = P2;
+      await F2(Q, G2, H);
+    } catch (W) {
+      if (L2(W)) {
+        process.exitCode = x;
         return;
       }
-      if (W2 instanceof W) {
-        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+      if (W instanceof Y) {
+        console.error(`Error: ${W.message}`), process.exitCode = 1;
         return;
       }
-      let U2 = W2 instanceof Error ? W2.message : String(W2);
-      console.error(`Error: ${U2}`), process.exitCode = 1;
+      let U = W instanceof Error ? W.message : String(W);
+      console.error(`Error: ${U}`), process.exitCode = 1;
       return;
     }
-    if (_3(J), process.env[w] === "1") {
-      let W2 = (async () => {
+    if (_2(q), process.env[N2] === "1") {
+      let W = (async () => {
         try {
-          let { validateCommandTree: U2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
-          U2(J);
-          for (let Y of $)
-            console.warn(`Warning: ${Y}`);
+          let { validateCommandTree: U } = await Promise.resolve().then(() => (init_chunk_1670njz2(), exports_chunk_1670njz2));
+          U(q);
+          for (let Y2 of Z)
+            console.warn(`Warning: ${Y2}`);
           return { ok: true };
-        } catch (U2) {
-          let Y = U2 instanceof Error ? U2.message : String(U2);
-          return console.error(Y), process.exitCode = 1, { ok: false, error: U2 };
+        } catch (U) {
+          let Y2 = U instanceof Error ? U.message : String(U);
+          return console.error(Y2), process.exitCode = 1, { ok: false, error: U };
         }
       })();
-      return globalThis[v] = W2, await W2, process.exit(process.exitCode ?? 0);
+      if (globalThis[C3] = W, await W, process.env[b2] === "1")
+        return process.exit(process.exitCode ?? 0);
+      return;
     }
-    for (let W2 of $)
-      console.warn(`Warning: ${W2}`);
-    let X2 = { argv: [...q2], rootCommand: J, state: K, route: null, input: null };
+    for (let W of Z)
+      console.warn(`Warning: ${W}`);
+    let z = { argv: [...J2], rootCommand: q, state: $, route: null, input: null };
     try {
-      let W2, U2;
+      let W, U;
       try {
-        let Y = D(J, [...q2]);
-        X2.route = Y, W2 = Y.command, U2 = b(W2, Y.argv), X2.input = U2;
-      } catch (Y) {
-        await F(Q, X2, async () => {
-          throw Y;
+        let Y2 = D2(q, [...J2]);
+        z.route = Y2, W = Y2.command, U = S(W, Y2.argv), z.input = U;
+      } catch (Y2) {
+        await A2(Q, z, async () => {
+          throw Y2;
         });
         return;
       }
-      await F(Q, X2, async () => {
-        if (E(W2, U2), !W2.run)
+      await A2(Q, z, async () => {
+        if (A(W, U), !W.run)
           return;
-        let Y = { args: U2.args, flags: U2.flags, rawArgs: U2.rawArgs, command: W2 }, V;
+        let Y2 = { args: U.args, flags: U.flags, rawArgs: U.rawArgs, command: W }, R2;
         try {
-          if (W2.preRun)
-            await W2.preRun(Y);
-          await W2.run(Y);
-        } catch (M3) {
-          V = M3;
+          if (W.preRun)
+            await W.preRun(Y2);
+          await W.run(Y2);
+        } catch (V2) {
+          R2 = V2;
         }
-        if (W2.postRun)
+        if (W.postRun)
           try {
-            await W2.postRun(Y);
-          } catch (M3) {
-            if (!V)
-              V = M3;
+            await W.postRun(Y2);
+          } catch (V2) {
+            if (!R2)
+              R2 = V2;
             else
-              console.error(`Error in postRun: ${M3 instanceof Error ? M3.message : String(M3)}`);
+              console.error(`Error in postRun: ${V2 instanceof Error ? V2.message : String(V2)}`);
           }
-        if (V)
-          throw V;
+        if (R2)
+          throw R2;
       });
-    } catch (W2) {
-      if (B(W2)) {
-        process.exitCode = P2;
+    } catch (W) {
+      if (L2(W)) {
+        process.exitCode = x;
         return;
       }
-      if (W2 instanceof W) {
-        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+      if (W instanceof Y) {
+        console.error(`Error: ${W.message}`), process.exitCode = 1;
         return;
       }
-      if (W2 instanceof Error) {
-        let U2 = new W("EXECUTION", W2.message).withCause(W2);
-        console.error(`Error: ${U2.message}`), process.exitCode = 1;
+      if (W instanceof Error) {
+        let U = new Y("EXECUTION", W.message).withCause(W);
+        console.error(`Error: ${U.message}`), process.exitCode = 1;
         return;
       }
-      console.error(`Error: ${String(W2)}`), process.exitCode = 1;
+      console.error(`Error: ${String(W)}`), process.exitCode = 1;
     }
   }
 }
 
-// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/index.js
-init_chunk_vt64gs69();
-function T2(j) {
-  return { meta: { name: j }, localFlags: {}, effectiveFlags: {}, args: undefined, subCommands: {}, plugins: [], preRun: undefined, run: undefined, postRun: undefined };
-}
-function z2(j, q2) {
-  let J = {};
-  for (let [Q, $] of Object.entries(j))
-    if ($.inherit === true)
-      J[Q] = $;
-  for (let [Q, $] of Object.entries(q2))
-    J[Q] = $;
-  return J;
-}
-function D2(j, q2) {
-  let J = [j.meta.name], Q = j, $ = q2;
-  while ($.length > 0) {
-    let K = Q.subCommands;
-    if (!K || Object.keys(K).length === 0)
+// ../../node_modules/.bun/@crustjs+core@0.0.19+328ed37f40d3034a/node_modules/@crustjs/core/dist/index.js
+init_chunk_q8y07jw2();
+function P3(j2) {
+  return { meta: { name: j2 }, localFlags: {}, effectiveFlags: {}, args: undefined, subCommands: {}, plugins: [], preRun: undefined, run: undefined, postRun: undefined };
+}
+function X2(j2, J2) {
+  let q = {};
+  for (let [Q, Z] of Object.entries(j2))
+    if (Z.inherit === true)
+      q[Q] = Z;
+  for (let [Q, Z] of Object.entries(J2))
+    q[Q] = Z;
+  return q;
+}
+function E3(j2, J2) {
+  for (let [q, Q] of Object.entries(j2)) {
+    let Z = Q.meta.aliases;
+    if (!Z)
+      continue;
+    if (Z.includes(J2))
+      return { canonicalName: q, node: Q };
+  }
+  return null;
+}
+function D3(j2, J2) {
+  let q = [j2.meta.name], Q = j2, Z = J2;
+  while (Z.length > 0) {
+    let $ = Q.subCommands;
+    if (!$ || Object.keys($).length === 0)
       break;
-    let Z = $[0];
-    if (!Z || Z.startsWith("-"))
+    let G2 = Z[0];
+    if (!G2 || G2.startsWith("-"))
       break;
-    if (Z in K && K[Z]) {
-      Q = K[Z], J.push(Z), $ = $.slice(1);
+    if (G2 in $ && $[G2]) {
+      Q = $[G2], q.push(G2), Z = Z.slice(1);
+      continue;
+    }
+    let H = E3($, G2);
+    if (H) {
+      Q = H.node, q.push(H.canonicalName), Z = Z.slice(1);
       continue;
     }
     if (Q.run)
       break;
-    let H = Object.keys(K);
-    throw new W("COMMAND_NOT_FOUND", `Unknown command "${Z}".`, { input: Z, available: H, commandPath: [...J], parentCommand: Q });
+    throw new Y("COMMAND_NOT_FOUND", `Unknown command "${G2}".`, { input: G2, available: Object.keys($), commandPath: [...q], parentCommand: Q });
   }
-  return { command: Q, argv: $, commandPath: J };
+  return { command: Q, argv: Z, commandPath: q };
 }
-function N2(j) {
-  for (let [q2, J] of Object.entries(j)) {
-    if (q2.startsWith("no-")) {
-      let Q = q2.slice(3);
-      throw new W("DEFINITION", `Flag "--${q2}" must not use "no-" prefix; define "${Q}" and negate with "--no-${Q}"`);
+function f3(j2) {
+  for (let [J2, q] of Object.entries(j2)) {
+    if (J2.startsWith("no-")) {
+      let Q = J2.slice(3);
+      throw new Y("DEFINITION", `Flag "--${J2}" must not use "no-" prefix; define "${Q}" and negate with "--no-${Q}"`);
     }
-    if (J.short?.startsWith("no-"))
-      throw new W("DEFINITION", `Short alias "-${J.short}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
-    if (J.aliases) {
-      for (let Q of J.aliases)
+    if (q.short?.startsWith("no-"))
+      throw new Y("DEFINITION", `Short alias "-${q.short}" on "--${J2}" must not use "no-" prefix (reserved for negation)`);
+    if (q.aliases) {
+      for (let Q of q.aliases)
         if (Q.startsWith("no-"))
-          throw new W("DEFINITION", `Alias "--${Q}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
-    }
-  }
-}
-var w2 = "CRUST_INTERNAL_VALIDATE_ONLY";
-var P3 = 130;
-var v2 = "__CRUST_VALIDATE_RESULT__";
-function x2() {
-  let j = new Map;
-  return { get(q2) {
-    return j.get(q2);
-  }, has(q2) {
-    return j.has(q2);
-  }, set(q2, J) {
-    j.set(q2, J);
-  }, delete(q2) {
-    return j.delete(q2);
+          throw new Y("DEFINITION", `Alias "--${Q}" on "--${J2}" must not use "no-" prefix (reserved for negation)`);
+    }
+  }
+}
+var N3 = "CRUST_INTERNAL_VALIDATE_ONLY";
+var b3 = "CRUST_INTERNAL_VALIDATE_FORCE_EXIT";
+var x2 = 130;
+var C4 = "__CRUST_VALIDATE_RESULT__";
+function k3() {
+  let j2 = new Map;
+  return { get(J2) {
+    return j2.get(J2);
+  }, has(J2) {
+    return j2.has(J2);
+  }, set(J2, q) {
+    j2.set(J2, q);
+  }, delete(J2) {
+    return j2.delete(J2);
   } };
 }
-function B2(j) {
-  if (!(j instanceof Error))
+function L3(j2) {
+  if (!(j2 instanceof Error))
     return false;
-  return j.name === "CancelledError";
-}
-function b3(j, q2) {
-  j.effectiveFlags = z2(q2, j.localFlags);
-  for (let J of Object.values(j.subCommands))
-    b3(J, j.effectiveFlags);
-}
-function y2(j) {
-  return { addFlag(q2, J, Q) {
-    if (J in q2.effectiveFlags)
-      j?.push(`Plugin flag "--${J}" on "${q2.meta.name}" overrides existing flag`);
-    q2.effectiveFlags[J] = Q;
-  }, addSubCommand(q2, J, Q) {
-    if (!J.trim())
-      throw new W("DEFINITION", "addSubCommand: name must be a non-empty string");
-    if (q2.subCommands[J]) {
-      j?.push(`Plugin subcommand "${J}" on "${q2.meta.name}" skipped (already exists)`);
+  return j2.name === "CancelledError";
+}
+function h3(j2, J2) {
+  j2.effectiveFlags = X2(J2, j2.localFlags);
+  for (let q of Object.values(j2.subCommands))
+    h3(q, j2.effectiveFlags);
+}
+function y2(j2) {
+  return { addFlag(J2, q, Q) {
+    if (q in J2.effectiveFlags)
+      j2?.push(`Plugin flag "--${q}" on "${J2.meta.name}" overrides existing flag`);
+    J2.effectiveFlags[q] = Q;
+  }, addSubCommand(J2, q, Q) {
+    if (!q.trim())
+      throw new Y("DEFINITION", "addSubCommand: name must be a non-empty string");
+    if (J2.subCommands[q]) {
+      j2?.push(`Plugin subcommand "${q}" on "${J2.meta.name}" skipped (already exists)`);
+      return;
+    }
+    try {
+      g({ canonicalName: q, aliases: Q.meta.aliases }, J2.subCommands, q);
+    } catch (Z) {
+      let $ = Z instanceof Error ? Z.message : String(Z);
+      j2?.push(`Plugin subcommand "${q}" on "${J2.meta.name}" skipped: ${$}`);
       return;
     }
-    b3(Q, q2.effectiveFlags), q2.subCommands[J] = Q;
+    h3(Q, J2.effectiveFlags), J2.subCommands[q] = Q;
   } };
 }
-async function A3(j, q2, J) {
-  for (let Q of j) {
+async function F3(j2, J2, q) {
+  for (let Q of j2) {
     if (!Q.setup)
       continue;
-    await Q.setup(q2, J);
+    await Q.setup(J2, q);
   }
 }
-async function F2(j, q2, J) {
-  let Q = j.map((Z) => Z.middleware).filter((Z) => Boolean(Z)), $ = -1, K = async (Z) => {
-    if (Z <= $)
-      throw new W("DEFINITION", "Plugin middleware called next() multiple times");
-    if ($ = Z, Z === Q.length) {
-      await J();
+async function A3(j2, J2, q) {
+  let Q = j2.map((G2) => G2.middleware).filter((G2) => Boolean(G2)), Z = -1, $ = async (G2) => {
+    if (G2 <= Z)
+      throw new Y("DEFINITION", "Plugin middleware called next() multiple times");
+    if (Z = G2, G2 === Q.length) {
+      await q();
       return;
     }
-    let H = Q[Z];
+    let H = Q[G2];
     if (!H)
-      throw new W("DEFINITION", "Plugin middleware stack is invalid");
-    await H(q2, () => K(Z + 1));
+      throw new Y("DEFINITION", "Plugin middleware stack is invalid");
+    await H(J2, () => $(G2 + 1));
   };
-  await K(0);
-}
-function I3(j) {
-  let q2 = [...j.plugins];
-  for (let J of Object.values(j.subCommands))
-    q2.push(...I3(J));
-  return q2;
-}
-function k2(j) {
-  let q2 = {};
-  for (let [J, Q] of Object.entries(j))
-    q2[J] = { ...Q, aliases: Q.aliases ? [...Q.aliases] : undefined };
-  return q2;
-}
-function h3(j) {
-  let q2 = {};
-  for (let [J, Q] of Object.entries(j.subCommands))
-    q2[J] = h3(Q);
-  return { meta: { ...j.meta }, localFlags: k2(j.localFlags), effectiveFlags: k2(j.effectiveFlags), args: j.args ? j.args.map((J) => ({ ...J })) : undefined, subCommands: q2, plugins: [...j.plugins], preRun: j.preRun, run: j.run, postRun: j.postRun };
-}
-function _4(j) {
-  if (Object.freeze(j), Object.freeze(j.localFlags), Object.freeze(j.effectiveFlags), Object.freeze(j.meta), Object.freeze(j.plugins), j.args)
-    Object.freeze(j.args);
-  for (let q2 of Object.values(j.subCommands))
-    _4(q2);
-  Object.freeze(j.subCommands);
+  await $(0);
+}
+function S3(j2) {
+  let J2 = [...j2.plugins];
+  for (let q of Object.values(j2.subCommands))
+    J2.push(...S3(q));
+  return J2;
+}
+function w3(j2) {
+  let J2 = {};
+  for (let [q, Q] of Object.entries(j2))
+    J2[q] = { ...Q, aliases: Q.aliases ? [...Q.aliases] : undefined };
+  return J2;
+}
+function v3(j2) {
+  let J2 = {};
+  for (let [q, Q] of Object.entries(j2.subCommands))
+    J2[q] = v3(Q);
+  return { meta: { ...j2.meta }, localFlags: w3(j2.localFlags), effectiveFlags: w3(j2.effectiveFlags), args: j2.args ? j2.args.map((q) => ({ ...q })) : undefined, subCommands: J2, plugins: [...j2.plugins], preRun: j2.preRun, run: j2.run, postRun: j2.postRun };
+}
+function _3(j2) {
+  if (Object.freeze(j2), Object.freeze(j2.localFlags), Object.freeze(j2.effectiveFlags), Object.freeze(j2.meta), Object.freeze(j2.plugins), j2.args)
+    Object.freeze(j2.args);
+  for (let J2 of Object.values(j2.subCommands))
+    _3(J2);
+  Object.freeze(j2.subCommands);
 }
 
-class R2 {
+class M2 {
   _node;
   _inheritedFlags;
-  constructor(j) {
-    if (!j.trim())
-      throw new W("DEFINITION", "meta.name must be a non-empty string");
-    this._node = T2(j), this._inheritedFlags = {};
-  }
-  static _createChild(j, q2) {
-    let J = new R2(j);
-    return J._inheritedFlags = q2, J;
-  }
-  _clone(j) {
-    let q2 = Object.create(Object.getPrototypeOf(this)), J = { ...this._node, localFlags: { ...this._node.localFlags }, effectiveFlags: { ...this._node.effectiveFlags }, subCommands: { ...this._node.subCommands }, plugins: [...this._node.plugins], meta: { ...this._node.meta }, args: this._node.args ? [...this._node.args] : undefined, ...j };
-    return q2._node = J, q2._inheritedFlags = this._inheritedFlags, q2;
-  }
-  meta(j) {
-    return this._clone({ meta: { ...this._node.meta, ...j } });
-  }
-  flags(j) {
-    N2(j);
-    let q2 = {};
-    for (let [J, Q] of Object.entries(j))
-      q2[J] = { ...Q };
-    return this._clone({ localFlags: q2, effectiveFlags: z2(this._inheritedFlags, q2) });
-  }
-  args(j) {
-    let q2 = j.map((J) => ({ ...J }));
-    return this._clone({ args: q2 });
-  }
-  run(j) {
-    return this._clone({ run: j });
-  }
-  preRun(j) {
-    return this._clone({ preRun: j });
-  }
-  postRun(j) {
-    return this._clone({ postRun: j });
-  }
-  use(j) {
-    return this._clone({ plugins: [...this._node.plugins, j] });
-  }
-  sub(j) {
-    if (!j.trim())
-      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
-    let q2 = z2(this._inheritedFlags, this._node.localFlags);
-    return R2._createChild(j, q2);
-  }
-  command(j, q2) {
-    if (typeof j === "string") {
-      let K = j;
-      if (!q2)
-        throw new W("DEFINITION", "command(name, cb) requires a callback");
-      if (!K.trim())
-        throw new W("DEFINITION", "Subcommand name must be a non-empty string");
-      if (this._node.subCommands[K])
-        throw new W("DEFINITION", `Subcommand "${K}" is already registered`);
-      let Z = z2(this._inheritedFlags, this._node.localFlags), H = R2._createChild(K, Z), X2 = q2(H), W2 = { ...X2._node, effectiveFlags: z2(X2._inheritedFlags, X2._node.localFlags) };
-      return this._clone({ subCommands: { ...this._node.subCommands, [K]: W2 } });
-    }
-    let J = j, Q = J._node.meta.name;
+  constructor(j2) {
+    if (!j2.trim())
+      throw new Y("DEFINITION", "meta.name must be a non-empty string");
+    this._node = P3(j2), this._inheritedFlags = {};
+  }
+  static _createChild(j2, J2) {
+    let q = new M2(j2);
+    return q._inheritedFlags = J2, q;
+  }
+  _clone(j2) {
+    let J2 = Object.create(Object.getPrototypeOf(this)), q = { ...this._node, localFlags: { ...this._node.localFlags }, effectiveFlags: { ...this._node.effectiveFlags }, subCommands: { ...this._node.subCommands }, plugins: [...this._node.plugins], meta: { ...this._node.meta }, args: this._node.args ? [...this._node.args] : undefined, ...j2 };
+    return J2._node = q, J2._inheritedFlags = this._inheritedFlags, J2;
+  }
+  meta(j2) {
+    return this._clone({ meta: { ...this._node.meta, ...j2 } });
+  }
+  flags(j2) {
+    f3(j2);
+    let J2 = {};
+    for (let [q, Q] of Object.entries(j2))
+      J2[q] = { ...Q };
+    return this._clone({ localFlags: J2, effectiveFlags: X2(this._inheritedFlags, J2) });
+  }
+  args(j2) {
+    let J2 = j2.map((q) => ({ ...q }));
+    return this._clone({ args: J2 });
+  }
+  run(j2) {
+    return this._clone({ run: j2 });
+  }
+  preRun(j2) {
+    return this._clone({ preRun: j2 });
+  }
+  postRun(j2) {
+    return this._clone({ postRun: j2 });
+  }
+  use(j2) {
+    return this._clone({ plugins: [...this._node.plugins, j2] });
+  }
+  sub(j2) {
+    if (!j2.trim())
+      throw new Y("DEFINITION", "Subcommand name must be a non-empty string");
+    let J2 = X2(this._inheritedFlags, this._node.localFlags);
+    return M2._createChild(j2, J2);
+  }
+  command(j2, J2) {
+    if (typeof j2 === "string") {
+      let $ = j2;
+      if (!J2)
+        throw new Y("DEFINITION", "command(name, cb) requires a callback");
+      if (!$.trim())
+        throw new Y("DEFINITION", "Subcommand name must be a non-empty string");
+      if (this._node.subCommands[$])
+        throw new Y("DEFINITION", `Subcommand "${$}" is already registered`);
+      let G2 = X2(this._inheritedFlags, this._node.localFlags), H = M2._createChild($, G2), z = J2(H);
+      g({ canonicalName: $, aliases: z._node.meta.aliases }, this._node.subCommands, $);
+      let W = { ...z._node, effectiveFlags: X2(z._inheritedFlags, z._node.localFlags) };
+      return this._clone({ subCommands: { ...this._node.subCommands, [$]: W } });
+    }
+    let q = j2, Q = q._node.meta.name;
     if (!Q.trim())
-      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+      throw new Y("DEFINITION", "Subcommand name must be a non-empty string");
     if (this._node.subCommands[Q])
-      throw new W("DEFINITION", `Subcommand "${Q}" is already registered`);
-    let $ = { ...J._node, effectiveFlags: z2(J._inheritedFlags, J._node.localFlags) };
-    return this._clone({ subCommands: { ...this._node.subCommands, [Q]: $ } });
+      throw new Y("DEFINITION", `Subcommand "${Q}" is already registered`);
+    g({ canonicalName: Q, aliases: q._node.meta.aliases }, this._node.subCommands, Q);
+    let Z = { ...q._node, effectiveFlags: X2(q._inheritedFlags, q._node.localFlags) };
+    return this._clone({ subCommands: { ...this._node.subCommands, [Q]: Z } });
   }
-  async prepareCommandTree(j) {
-    let q2 = j?.argv ?? [], J = h3(this._node), Q = I3(J), $ = [], K = x2(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y2($);
+  async prepareCommandTree(j2) {
+    let J2 = j2?.argv ?? [], q = v3(this._node), Q = S3(q), Z = [], $ = k3(), G2 = { argv: [...J2], rootCommand: q, state: $ }, H = y2(Z);
     try {
-      await A3(Q, Z, H);
-    } catch (W2) {
-      if (B2(W2))
-        throw W2;
-      if (W2 instanceof W)
-        throw W2;
-      if (W2 instanceof Error)
-        throw W2;
-      throw new W("DEFINITION", String(W2));
-    }
-    _4(J);
-    let { validateCommandTree: X2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
-    return X2(J), { root: J, warnings: $ };
-  }
-  async execute(j) {
-    let q2 = j?.argv ?? process.argv.slice(2), J = this._node, Q = I3(J), $ = [], K = x2(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y2($);
+      await F3(Q, G2, H);
+    } catch (W) {
+      if (L3(W))
+        throw W;
+      if (W instanceof Y)
+        throw W;
+      if (W instanceof Error)
+        throw W;
+      throw new Y("DEFINITION", String(W));
+    }
+    _3(q);
+    let { validateCommandTree: z } = await Promise.resolve().then(() => (init_chunk_1670njz2(), exports_chunk_1670njz2));
+    return z(q), { root: q, warnings: Z };
+  }
+  async execute(j2) {
+    let J2 = j2?.argv ?? process.argv.slice(2), q = this._node, Q = S3(q), Z = [], $ = k3(), G2 = { argv: [...J2], rootCommand: q, state: $ }, H = y2(Z);
     try {
-      await A3(Q, Z, H);
-    } catch (W2) {
-      if (B2(W2)) {
-        process.exitCode = P3;
+      await F3(Q, G2, H);
+    } catch (W) {
+      if (L3(W)) {
+        process.exitCode = x2;
         return;
       }
-      if (W2 instanceof W) {
-        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+      if (W instanceof Y) {
+        console.error(`Error: ${W.message}`), process.exitCode = 1;
         return;
       }
-      let U2 = W2 instanceof Error ? W2.message : String(W2);
-      console.error(`Error: ${U2}`), process.exitCode = 1;
+      let U = W instanceof Error ? W.message : String(W);
+      console.error(`Error: ${U}`), process.exitCode = 1;
       return;
     }
-    if (_4(J), process.env[w2] === "1") {
-      let W2 = (async () => {
+    if (_3(q), process.env[N3] === "1") {
+      let W = (async () => {
         try {
-          let { validateCommandTree: U2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
-          U2(J);
-          for (let Y of $)
-            console.warn(`Warning: ${Y}`);
+          let { validateCommandTree: U } = await Promise.resolve().then(() => (init_chunk_1670njz2(), exports_chunk_1670njz2));
+          U(q);
+          for (let Y2 of Z)
+            console.warn(`Warning: ${Y2}`);
           return { ok: true };
-        } catch (U2) {
-          let Y = U2 instanceof Error ? U2.message : String(U2);
-          return console.error(Y), process.exitCode = 1, { ok: false, error: U2 };
+        } catch (U) {
+          let Y2 = U instanceof Error ? U.message : String(U);
+          return console.error(Y2), process.exitCode = 1, { ok: false, error: U };
         }
       })();
-      return globalThis[v2] = W2, await W2, process.exit(process.exitCode ?? 0);
+      if (globalThis[C4] = W, await W, process.env[b3] === "1")
+        return process.exit(process.exitCode ?? 0);
+      return;
     }
-    for (let W2 of $)
-      console.warn(`Warning: ${W2}`);
-    let X2 = { argv: [...q2], rootCommand: J, state: K, route: null, input: null };
+    for (let W of Z)
+      console.warn(`Warning: ${W}`);
+    let z = { argv: [...J2], rootCommand: q, state: $, route: null, input: null };
     try {
-      let W2, U2;
+      let W, U;
       try {
-        let Y = D2(J, [...q2]);
-        X2.route = Y, W2 = Y.command, U2 = b(W2, Y.argv), X2.input = U2;
-      } catch (Y) {
-        await F2(Q, X2, async () => {
-          throw Y;
+        let Y2 = D3(q, [...J2]);
+        z.route = Y2, W = Y2.command, U = S(W, Y2.argv), z.input = U;
+      } catch (Y2) {
+        await A3(Q, z, async () => {
+          throw Y2;
         });
         return;
       }
-      await F2(Q, X2, async () => {
-        if (E(W2, U2), !W2.run)
+      await A3(Q, z, async () => {
+        if (A(W, U), !W.run)
           return;
-        let Y = { args: U2.args, flags: U2.flags, rawArgs: U2.rawArgs, command: W2 }, V;
+        let Y2 = { args: U.args, flags: U.flags, rawArgs: U.rawArgs, command: W }, R2;
         try {
-          if (W2.preRun)
-            await W2.preRun(Y);
-          await W2.run(Y);
-        } catch (M3) {
-          V = M3;
+          if (W.preRun)
+            await W.preRun(Y2);
+          await W.run(Y2);
+        } catch (V2) {
+          R2 = V2;
         }
-        if (W2.postRun)
+        if (W.postRun)
           try {
-            await W2.postRun(Y);
-          } catch (M3) {
-            if (!V)
-              V = M3;
+            await W.postRun(Y2);
+          } catch (V2) {
+            if (!R2)
+              R2 = V2;
             else
-              console.error(`Error in postRun: ${M3 instanceof Error ? M3.message : String(M3)}`);
+              console.error(`Error in postRun: ${V2 instanceof Error ? V2.message : String(V2)}`);
           }
-        if (V)
-          throw V;
+        if (R2)
+          throw R2;
       });
-    } catch (W2) {
-      if (B2(W2)) {
-        process.exitCode = P3;
+    } catch (W) {
+      if (L3(W)) {
+        process.exitCode = x2;
         return;
       }
-      if (W2 instanceof W) {
-        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+      if (W instanceof Y) {
+        console.error(`Error: ${W.message}`), process.exitCode = 1;
         return;
       }
-      if (W2 instanceof Error) {
-        let U2 = new W("EXECUTION", W2.message).withCause(W2);
-        console.error(`Error: ${U2.message}`), process.exitCode = 1;
+      if (W instanceof Error) {
+        let U = new Y("EXECUTION", W.message).withCause(W);
+        console.error(`Error: ${U.message}`), process.exitCode = 1;
         return;
       }
-      console.error(`Error: ${String(W2)}`), process.exitCode = 1;
+      console.error(`Error: ${String(W)}`), process.exitCode = 1;
     }
   }
 }
 
-// ../../node_modules/.bun/@crustjs+style@0.1.0+7524df1edfed9f02/node_modules/@crustjs/style/dist/index.js
-var rF = Object.defineProperty;
-var sF = (F3) => F3;
-function aF(F3, Y) {
-  this[F3] = sF.bind(null, Y);
-}
-var oF = (F3, Y) => {
-  for (var B3 in Y)
-    rF(F3, B3, { get: Y[B3], enumerable: true, configurable: true, set: aF.bind(Y, B3) });
+// ../../node_modules/.bun/@crustjs+style@0.2.0+7524df1edfed9f02/node_modules/@crustjs/style/dist/index.js
+var YZ = Object.defineProperty;
+var jZ = (V2) => V2;
+function UZ(V2, $) {
+  this[V2] = jZ.bind(null, $);
+}
+var HZ = (V2, $) => {
+  for (var Z in $)
+    YZ(V2, Z, { get: $[Z], enumerable: true, configurable: true, set: UZ.bind($, Z) });
 };
-var E2 = {};
-oF(E2, { yellow: () => o, white: () => FF, underline: () => c, strikethrough: () => d, reset: () => p, red: () => s, magenta: () => t, italic: () => h4, inverse: () => n, hidden: () => l, green: () => a, gray: () => BF, dim: () => m, cyan: () => e, brightYellow: () => ZF, brightWhite: () => JF, brightRed: () => YF, brightMagenta: () => zF, brightGreen: () => VF, brightCyan: () => QF, brightBlue: () => $F, bold: () => u, blue: () => i, black: () => r, bgYellow: () => GF, bgWhite: () => OF, bgRed: () => KF, bgMagenta: () => HF, bgGreen: () => jF, bgCyan: () => _F, bgBrightYellow: () => AF, bgBrightWhite: () => TF, bgBrightRed: () => qF, bgBrightMagenta: () => MF, bgBrightGreen: () => RF, bgBrightCyan: () => IF, bgBrightBlue: () => LF, bgBrightBlack: () => DF, bgBlue: () => UF, bgBlack: () => XF });
-function J(F3, Y) {
-  return { open: `\x1B[${F3}m`, close: `\x1B[${Y}m` };
-}
-var p = J(0, 0);
-var u = J(1, 22);
-var m = J(2, 22);
-var h4 = J(3, 23);
-var c = J(4, 24);
-var n = J(7, 27);
-var l = J(8, 28);
-var d = J(9, 29);
-var r = J(30, 39);
-var s = J(31, 39);
-var a = J(32, 39);
-var o = J(33, 39);
-var i = J(34, 39);
-var t = J(35, 39);
-var e = J(36, 39);
-var FF = J(37, 39);
-var BF = J(90, 39);
-var YF = J(91, 39);
-var VF = J(92, 39);
-var ZF = J(93, 39);
-var $F = J(94, 39);
-var zF = J(95, 39);
-var QF = J(96, 39);
-var JF = J(97, 39);
-var XF = J(40, 49);
-var KF = J(41, 49);
-var jF = J(42, 49);
-var GF = J(43, 49);
-var UF = J(44, 49);
-var HF = J(45, 49);
-var _F = J(46, 49);
-var OF = J(47, 49);
-var DF = J(100, 49);
-var qF = J(101, 49);
-var RF = J(102, 49);
-var AF = J(103, 49);
-var LF = J(104, 49);
-var MF = J(105, 49);
-var IF = J(106, 49);
-var TF = J(107, 49);
-function iF(F3) {
-  return F3 >= 19968 && F3 <= 40959 || F3 >= 13312 && F3 <= 19903 || F3 >= 131072 && F3 <= 173791 || F3 >= 63744 && F3 <= 64255 || F3 >= 65281 && F3 <= 65376 || F3 >= 65504 && F3 <= 65510 || F3 >= 11904 && F3 <= 12031 || F3 >= 12032 && F3 <= 12255 || F3 >= 12288 && F3 <= 12351 || F3 >= 12352 && F3 <= 12447 || F3 >= 12448 && F3 <= 12543 || F3 >= 12544 && F3 <= 12591 || F3 >= 12592 && F3 <= 12687 || F3 >= 12800 && F3 <= 13055 || F3 >= 13056 && F3 <= 13311 || F3 >= 44032 && F3 <= 55215 || F3 >= 65072 && F3 <= 65103;
-}
-function O2(F3) {
-  let Y = Bun.stripANSI(F3), B3 = 0;
-  for (let V of Y) {
-    let Z = V.codePointAt(0);
-    if (Z === undefined)
+var f4 = {};
+HZ(f4, { yellow: () => XV, white: () => UV, underline: () => e, strikethrough: () => $V, reset: () => qZ, red: () => QV, magenta: () => YV, italic: () => t, inverse: () => VV, hidden: () => ZV, green: () => JV, gray: () => HV, dim: () => i, cyan: () => jV, brightYellow: () => GV, brightWhite: () => DV, brightRed: () => qV, brightMagenta: () => AV, brightGreen: () => BV, brightCyan: () => LV, brightBlue: () => _V, bold: () => r, blue: () => KV, black: () => zV, bgYellow: () => OV, bgWhite: () => FV, bgRed: () => MV, bgMagenta: () => TV, bgGreen: () => RV, bgCyan: () => EV, bgBrightYellow: () => fV, bgBrightWhite: () => yV, bgBrightRed: () => kV, bgBrightMagenta: () => CV, bgBrightGreen: () => SV, bgBrightCyan: () => PV, bgBrightBlue: () => wV, bgBrightBlack: () => IV, bgBlue: () => WV, bgBlack: () => NV });
+function U(V2, $) {
+  return { open: `\x1B[${V2}m`, close: `\x1B[${$}m` };
+}
+var qZ = U(0, 0);
+var r = U(1, 22);
+var i = U(2, 22);
+var t = U(3, 23);
+var e = U(4, 24);
+var VV = U(7, 27);
+var ZV = U(8, 28);
+var $V = U(9, 29);
+var zV = U(30, 39);
+var QV = U(31, 39);
+var JV = U(32, 39);
+var XV = U(33, 39);
+var KV = U(34, 39);
+var YV = U(35, 39);
+var jV = U(36, 39);
+var UV = U(37, 39);
+var HV = U(90, 39);
+var qV = U(91, 39);
+var BV = U(92, 39);
+var GV = U(93, 39);
+var _V = U(94, 39);
+var AV = U(95, 39);
+var LV = U(96, 39);
+var DV = U(97, 39);
+var NV = U(40, 49);
+var MV = U(41, 49);
+var RV = U(42, 49);
+var OV = U(43, 49);
+var WV = U(44, 49);
+var TV = U(45, 49);
+var EV = U(46, 49);
+var FV = U(47, 49);
+var IV = U(100, 49);
+var kV = U(101, 49);
+var SV = U(102, 49);
+var fV = U(103, 49);
+var wV = U(104, 49);
+var CV = U(105, 49);
+var PV = U(106, 49);
+var yV = U(107, 49);
+function BZ(V2) {
+  return V2 >= 19968 && V2 <= 40959 || V2 >= 13312 && V2 <= 19903 || V2 >= 131072 && V2 <= 173791 || V2 >= 63744 && V2 <= 64255 || V2 >= 65281 && V2 <= 65376 || V2 >= 65504 && V2 <= 65510 || V2 >= 11904 && V2 <= 12031 || V2 >= 12032 && V2 <= 12255 || V2 >= 12288 && V2 <= 12351 || V2 >= 12352 && V2 <= 12447 || V2 >= 12448 && V2 <= 12543 || V2 >= 12544 && V2 <= 12591 || V2 >= 12592 && V2 <= 12687 || V2 >= 12800 && V2 <= 13055 || V2 >= 13056 && V2 <= 13311 || V2 >= 44032 && V2 <= 55215 || V2 >= 65072 && V2 <= 65103;
+}
+function M3(V2) {
+  let $ = Bun.stripANSI(V2), Z = 0;
+  for (let z of $) {
+    let Q = z.codePointAt(0);
+    if (Q === undefined)
       continue;
-    B3 += iF(Z) ? 2 : 1;
+    Z += BZ(Q) ? 2 : 1;
   }
-  return B3;
+  return Z;
 }
-function M3(F3, Y) {
-  if (F3 === "always")
-    return true;
-  if (F3 === "never")
-    return false;
-  let V = Y !== undefined && "isTTY" in Y ? Y.isTTY ?? false : process.stdout?.isTTY ?? false, z3 = Y !== undefined && "noColor" in Y ? Y.noColor : process.env.NO_COLOR;
-  if (z3 !== undefined && z3 !== "")
-    return false;
-  return V;
+function v4(V2) {
+  return V2 !== undefined && "isTTY" in V2 ? V2.isTTY ?? false : process.stdout?.isTTY ?? false;
 }
-function NF(F3, Y) {
-  if (F3 === "always")
-    return true;
-  if (F3 === "never")
-    return false;
-  return Y !== undefined && "isTTY" in Y ? Y.isTTY ?? false : process.stdout?.isTTY ?? false;
+function RZ(V2) {
+  return V2 !== undefined && "noColor" in V2 ? V2.noColor : process.env.NO_COLOR;
+}
+function OZ(V2) {
+  return V2 !== undefined && "colorTerm" in V2 ? V2.colorTerm : process.env.COLORTERM;
 }
-function kF(F3, Y) {
-  if (F3 === "always")
+function WZ(V2) {
+  return V2 !== undefined && "term" in V2 ? V2.term : process.env.TERM;
+}
+function TZ(V2) {
+  let $ = V2.toLowerCase();
+  return $.includes("24bit") || $.includes("truecolor") || $.endsWith("-direct");
+}
+function EZ(V2, $) {
+  if (V2 !== undefined) {
+    let Z = V2.toLowerCase();
+    if (Z === "truecolor" || Z === "24bit")
+      return true;
+  }
+  return $ !== undefined && TZ($);
+}
+function x3(V2, $) {
+  if (V2 === "never")
+    return "none";
+  if (V2 === "always")
+    return "truecolor";
+  if (!v4($))
+    return "none";
+  let z = RZ($);
+  if (z !== undefined && z !== "")
+    return "none";
+  let Q = OZ($), J2 = WZ($);
+  if (EZ(Q, J2))
+    return "truecolor";
+  if (J2 !== undefined) {
+    let X3 = J2.toLowerCase();
+    if (X3 === "dumb")
+      return "none";
+    if (X3.includes("256color"))
+      return "256";
+  }
+  return "16";
+}
+function xV(V2, $) {
+  if (V2 === "always")
     return true;
-  if (F3 === "never")
+  if (V2 === "never")
     return false;
-  return Y !== undefined && "isTTY" in Y ? Y.isTTY ?? false : process.stdout?.isTTY ?? false;
+  return v4($);
 }
-function S2(F3, Y) {
-  if (F3 === "always")
+function gV(V2, $) {
+  if (V2 === "always")
     return true;
-  if (F3 === "never")
-    return false;
-  if (!M3(F3, Y))
+  if (V2 === "never")
     return false;
-  let Z = (Y !== undefined && "colorTerm" in Y ? Y.colorTerm : process.env.COLORTERM)?.toLowerCase();
-  if (Z === "truecolor" || Z === "24bit")
-    return true;
-  let $ = Y !== undefined && "term" in Y ? Y.term : process.env.TERM;
-  if ($ !== undefined) {
-    let K = $.toLowerCase();
-    if (K.includes("24bit") || K.includes("truecolor") || K.endsWith("-direct"))
-      return true;
-  }
-  return false;
+  return v4($);
+}
+function L4(V2, $) {
+  if (V2 == null)
+    return "";
+  if (typeof V2 !== "string")
+    V2 = String(V2);
+  if (V2 === "")
+    return "";
+  let { open: Z, close: z } = $;
+  if (V2.includes(z))
+    V2 = V2.replaceAll(z, z + Z);
+  return Z + V2 + z;
+}
+var m2 = "\x1B[39m";
+var b4 = "\x1B[49m";
+var g2 = "\x1B[38;";
+var mV = "\x1B[48;";
+function bV(V2) {
+  if (typeof V2 === "string" || V2 !== null && typeof V2 === "object")
+    try {
+      return JSON.stringify(V2);
+    } catch {
+      return String(V2);
+    }
+  return String(V2);
+}
+function uV(V2) {
+  let $ = Bun.color(V2, "[rgb]");
+  if ($ === null)
+    throw TypeError(`Invalid color input: ${bV(V2)}`);
+  return $;
+}
+function hV(V2, $, Z) {
+  let z = Math.max(V2, $, Z), Q = Math.round(z / 127.5);
+  if (Q === 0)
+    return 30;
+  let J2 = 30 + ((Math.round(Z / 255) << 2 | Math.round($ / 255) << 1 | Math.round(V2 / 255)) & 7);
+  if (Q === 2)
+    J2 += 60;
+  return J2;
+}
+function O2(V2, $) {
+  if ($ === "16") {
+    let [Q, J2, X3] = uV(V2);
+    return `\x1B[${hV(Q, J2, X3)}m`;
+  }
+  let Z = $ === "truecolor" ? "ansi-16m" : "ansi-256", z = Bun.color(V2, Z);
+  if (z === null)
+    throw TypeError(`Invalid color input: ${bV(V2)}`);
+  return z;
 }
-function D3(F3, Y) {
-  if (F3 === "")
+function u(V2, $) {
+  if ($ === "16") {
+    let [z, Q, J2] = uV(V2);
+    return `\x1B[${hV(z, Q, J2) + 10}m`;
+  }
+  let Z = O2(V2, $);
+  return Z.startsWith(g2) ? mV + Z.slice(g2.length) : Z.replace(g2, mV);
+}
+function h4(V2, $) {
+  if ($ === "none")
+    return O2(V2, "truecolor"), { open: "", close: "" };
+  return { open: O2(V2, $), close: m2 };
+}
+function p2(V2, $) {
+  if ($ === "none")
+    return O2(V2, "truecolor"), { open: "", close: "" };
+  return { open: u(V2, $), close: b4 };
+}
+function I2(V2, $, Z = "truecolor") {
+  let z = $;
+  if (Z === "none")
+    return O2(z, "truecolor"), V2 === "" ? "" : V2;
+  let Q = O2(z, Z);
+  if (V2 === "")
     return "";
-  let { open: B3, close: V } = Y;
-  if (F3.includes(V))
-    F3 = F3.replaceAll(V, V + B3);
-  return B3 + F3 + V;
-}
-function f(F3, Y) {
-  if (!Number.isInteger(F3) || F3 < 0 || F3 > 255)
-    throw RangeError(`Invalid ${Y} value: ${String(F3)}. Must be an integer between 0 and 255.`);
-}
-function gF(F3, Y, B3) {
-  f(F3, "red"), f(Y, "green"), f(B3, "blue");
-}
-var zB = /^#([0-9a-f]{3})$/i;
-var QB = /^#([0-9a-f]{6})$/i;
-function y3(F3) {
-  let Y = zB.exec(F3);
-  if (Y) {
-    let V = Y[1], Z = V.charAt(0), z3 = V.charAt(1), $ = V.charAt(2);
-    return [Number.parseInt(Z + Z, 16), Number.parseInt(z3 + z3, 16), Number.parseInt($ + $, 16)];
-  }
-  let B3 = QB.exec(F3);
-  if (B3) {
-    let V = B3[1];
-    return [Number.parseInt(V.slice(0, 2), 16), Number.parseInt(V.slice(2, 4), 16), Number.parseInt(V.slice(4, 6), 16)];
-  }
-  throw TypeError(`Invalid hex color: "${F3}". Expected format: "#RGB" or "#RRGGBB".`);
-}
-function w3(F3, Y, B3) {
-  return gF(F3, Y, B3), { open: `\x1B[38;2;${F3};${Y};${B3}m`, close: "\x1B[39m" };
-}
-function C(F3, Y, B3) {
-  return gF(F3, Y, B3), { open: `\x1B[48;2;${F3};${Y};${B3}m`, close: "\x1B[49m" };
-}
-function WF(F3) {
-  let [Y, B3, V] = y3(F3);
-  return w3(Y, B3, V);
-}
-function SF(F3) {
-  let [Y, B3, V] = y3(F3);
-  return C(Y, B3, V);
-}
-function fF(F3, Y, B3, V) {
-  return D3(F3, w3(Y, B3, V));
-}
-function yF(F3, Y, B3, V) {
-  return D3(F3, C(Y, B3, V));
-}
-function wF(F3, Y) {
-  return D3(F3, WF(Y));
-}
-function CF(F3, Y) {
-  return D3(F3, SF(Y));
-}
-var xF = "\x1B]";
-var bF = "\x1B\\";
-var JB = `${xF}8;;${bF}`;
-var XB = /^[\x20-\x7e]*$/;
-var KB = /^[\x21-\x7e]*$/;
-function jB(F3, Y) {
-  if (!XB.test(F3))
-    throw TypeError(`Invalid ${Y}: must contain only printable ASCII characters.`);
-}
-function GB(F3, Y) {
-  if (!KB.test(F3))
-    throw TypeError(`Invalid ${Y}: must contain only printable ASCII characters without spaces.`);
-}
-function UB(F3) {
-  let Y = F3?.id;
-  if (Y === undefined || Y === "")
+  return L4(V2, { open: Q, close: m2 });
+}
+function k4(V2, $, Z = "truecolor") {
+  let z = $;
+  if (Z === "none")
+    return O2(z, "truecolor"), V2 === "" ? "" : V2;
+  let Q = u(z, Z);
+  if (V2 === "")
     return "";
-  if (jB(Y, "hyperlink id"), Y.includes(":") || Y.includes(";"))
+  return L4(V2, { open: Q, close: b4 });
+}
+function c(V2, $) {
+  if (!Number.isInteger(V2) || V2 < 0 || V2 > 255)
+    throw RangeError(`Invalid ${$} value: ${String(V2)}. Must be an integer between 0 and 255.`);
+}
+function pV(V2, $, Z) {
+  c(V2, "red"), c($, "green"), c(Z, "blue");
+}
+var SZ = /^#([0-9a-f]{3})$/i;
+var fZ = /^#([0-9a-f]{6})$/i;
+function d(V2) {
+  let $ = SZ.exec(V2);
+  if ($) {
+    let z = $[1], Q = z.charAt(0), J2 = z.charAt(1), X3 = z.charAt(2);
+    return [Number.parseInt(Q + Q, 16), Number.parseInt(J2 + J2, 16), Number.parseInt(X3 + X3, 16)];
+  }
+  let Z = fZ.exec(V2);
+  if (Z) {
+    let z = Z[1];
+    return [Number.parseInt(z.slice(0, 2), 16), Number.parseInt(z.slice(2, 4), 16), Number.parseInt(z.slice(4, 6), 16)];
+  }
+  throw TypeError(`Invalid hex color: "${V2}". Expected format: "#RGB" or "#RRGGBB".`);
+}
+function l(V2, $, Z) {
+  return pV(V2, $, Z), { open: `\x1B[38;2;${V2};${$};${Z}m`, close: "\x1B[39m" };
+}
+function s(V2, $, Z) {
+  return pV(V2, $, Z), { open: `\x1B[48;2;${V2};${$};${Z}m`, close: "\x1B[49m" };
+}
+function cV(V2) {
+  let [$, Z, z] = d(V2);
+  return l($, Z, z);
+}
+function dV(V2) {
+  let [$, Z, z] = d(V2);
+  return s($, Z, z);
+}
+function lV(V2, $, Z, z) {
+  return L4(V2, l($, Z, z));
+}
+function sV(V2, $, Z, z) {
+  return L4(V2, s($, Z, z));
+}
+function nV(V2, $) {
+  return L4(V2, cV($));
+}
+function aV(V2, $) {
+  return L4(V2, dV($));
+}
+var oV = "\x1B]";
+var rV = "\x1B\\";
+var wZ = `${oV}8;;${rV}`;
+var CZ = /^[\x20-\x7e]*$/;
+var PZ = /^[\x21-\x7e]*$/;
+function yZ(V2, $) {
+  if (!CZ.test(V2))
+    throw TypeError(`Invalid ${$}: ${JSON.stringify(V2)} must contain only printable ASCII characters.`);
+}
+function vZ(V2, $) {
+  if (!PZ.test(V2))
+    throw TypeError(`Invalid ${$}: ${JSON.stringify(V2)} must contain only printable ASCII characters without spaces.`);
+}
+function xZ(V2) {
+  let $ = V2?.id;
+  if ($ === undefined || $ === "")
+    return "";
+  if (yZ($, "hyperlink id"), $.includes(":") || $.includes(";"))
     throw TypeError('Invalid hyperlink id: ":" and ";" are reserved by the OSC 8 format.');
-  return `id=${Y}`;
-}
-function PF(F3, Y) {
-  GB(F3, "hyperlink URL");
-  let B3 = UB(Y);
-  return { open: `${xF}8;${B3};${F3}${bF}`, close: JB };
-}
-function vF(F3, Y, B3) {
-  return D3(F3, PF(Y, B3));
-}
-function HB() {
-  let { reset: F3, ...Y } = E2;
-  return Y;
-}
-var x3 = Object.freeze(HB());
-var I4 = Object.freeze(Object.keys(x3));
-function pF(F3) {
-  return x3[F3];
-}
-var uF = Object.freeze(["bold", "dim", "italic", "underline", "inverse", "hidden", "strikethrough"]);
-var _B = new Set(uF);
-function mF(F3) {
-  return _B.has(F3);
-}
-var OB = new Set(uF.map((F3) => x3[F3]));
-function hF(F3) {
-  return OB.has(F3);
-}
-function DB(F3, Y, B3, V) {
-  if (F3 === "")
-    return F3;
-  let Z = F3;
-  for (let z3 = Y.length - 1;z3 >= 0; z3--) {
-    let $ = Y[z3];
-    if ($ === undefined)
+  return `id=${$}`;
+}
+function S4(V2, $) {
+  vZ(V2, "hyperlink URL");
+  let Z = xZ($);
+  return { open: `${oV}8;${Z};${V2}${rV}`, close: wZ };
+}
+function iV(V2, $, Z) {
+  return L4(V2, S4($, Z));
+}
+function gZ() {
+  let { reset: V2, ...$ } = f4;
+  return $;
+}
+var n = Object.freeze(gZ());
+var E4 = Object.freeze(Object.keys(n));
+function a(V2) {
+  return n[V2];
+}
+var tV = Object.freeze(["bold", "dim", "italic", "underline", "inverse", "hidden", "strikethrough"]);
+var mZ = new Set(tV);
+function eV(V2) {
+  return mZ.has(V2);
+}
+var bZ = new Set(tV.map((V2) => n[V2]));
+function VZ(V2) {
+  return bZ.has(V2);
+}
+function uZ(V2) {
+  return V2.kind === "named" ? eV(V2.name) : V2.isModifier;
+}
+function zZ(V2) {
+  return V2.kind === "named" ? a(V2.name) : V2.pair;
+}
+function ZZ(V2, $, Z, z) {
+  if (V2 == null)
+    return "";
+  if (typeof V2 !== "string")
+    V2 = String(V2);
+  if (V2 === "")
+    return V2;
+  let Q = V2;
+  for (let J2 = $.length - 1;J2 >= 0; J2--) {
+    let X3 = $[J2];
+    if (X3 === undefined)
       continue;
-    if (mF($) ? !B3 : !V)
+    if (uZ(X3) ? !Z : !z)
       continue;
-    Z = D3(Z, pF($));
+    Q = L4(Q, zZ(X3));
   }
-  return Z;
+  return Q;
 }
-function qB(F3, Y) {
-  let B3 = new Map;
-  function V(z3) {
-    return z3.join("|");
-  }
-  function Z(z3) {
-    let $ = V(z3), K = B3.get($);
-    if (K)
-      return K;
-    let j = (U2) => DB(U2, z3, F3, Y);
-    B3.set($, j);
-    for (let U2 of I4)
-      Object.defineProperty(j, U2, { configurable: false, enumerable: true, get() {
-        return Z([...z3, U2]);
+function hZ(V2, $, Z) {
+  let z = new Map;
+  function Q(X3) {
+    return X3.map((H) => H.kind === "named" ? H.name : `~${H.pair.open}`).join("|");
+  }
+  function J2(X3) {
+    let H = Q(X3), q = z.get(H);
+    if (q)
+      return q;
+    let G2 = (K, ...B) => {
+      if (Array.isArray(K) && "raw" in K && Array.isArray(K.raw)) {
+        let N4 = K, D4 = "";
+        for (let A4 = 0;A4 < N4.length; A4++)
+          if (D4 += N4[A4] ?? "", A4 < B.length)
+            D4 += String(B[A4]);
+        return ZZ(D4, X3, V2, $);
+      }
+      return ZZ(K, X3, V2, $);
+    };
+    z.set(H, G2);
+    for (let K of E4)
+      Object.defineProperty(G2, K, { configurable: false, enumerable: true, get() {
+        return J2([...X3, { kind: "named", name: K }]);
       } });
-    return Object.freeze(j);
-  }
-  return Z;
-}
-function RB(F3) {
-  let Y = {};
-  for (let B3 of I4)
-    Y[B3] = F3([B3]);
-  return Y;
-}
-function A4(F3) {
-  let Y = F3?.mode ?? "auto", B3 = NF(Y, F3?.overrides), V = M3(Y, F3?.overrides), Z = kF(Y, F3?.overrides), z3 = B3 || V, $ = S2(Y, F3?.overrides), K = qB(B3, V), j = RB(K), U2 = { enabled: z3, colorsEnabled: V, trueColorEnabled: $, apply: (X2, G) => {
-    return (hF(G) ? B3 : V) ? D3(X2, G) : X2;
-  }, link: Z ? (X2, G, _5) => vF(X2, G, _5) : (X2, G) => X2, rgb: $ ? (X2, G, _5, H) => fF(X2, G, _5, H) : (X2, G, _5, H) => X2, bgRgb: $ ? (X2, G, _5, H) => yF(X2, G, _5, H) : (X2, G, _5, H) => X2, hex: $ ? (X2, G) => wF(X2, G) : (X2, G) => X2, bgHex: $ ? (X2, G) => CF(X2, G) : (X2, G) => X2, ...j };
-  return Object.freeze(U2);
-}
-var L;
-var cF = new Map;
-function MB() {
-  if (L === "always")
-    return A4({ mode: "always" });
-  if (L === "never")
-    return A4({ mode: "auto", overrides: { isTTY: true, noColor: "1" } });
-  return A4({ mode: "auto" });
-}
-function b4() {
-  let F3 = `${L ?? "auto"}|${process.stdout?.isTTY ?? false}|${process.env.NO_COLOR ?? ""}`, Y = cF.get(F3);
-  if (Y)
-    return Y;
-  let B3 = MB();
-  return cF.set(F3, B3), B3;
-}
-var IB = ["apply", "link", "rgb", "bgRgb", "hex", "bgHex"];
-var TB = ["enabled", "colorsEnabled", "trueColorEnabled"];
-function EB() {
-  let F3 = {};
-  for (let Y of TB)
-    Object.defineProperty(F3, Y, { configurable: false, enumerable: true, get() {
-      return b4()[Y];
+    Object.defineProperty(G2, "fg", { configurable: false, enumerable: true, value: (K) => J2([...X3, { kind: "pair", pair: h4(K, Z), isModifier: false }]), writable: false }), Object.defineProperty(G2, "bg", { configurable: false, enumerable: true, value: (K) => J2([...X3, { kind: "pair", pair: p2(K, Z), isModifier: false }]), writable: false });
+    let _4 = "", Y2 = "";
+    for (let K of X3) {
+      let B = zZ(K);
+      _4 += B.open, Y2 = B.close + Y2;
+    }
+    return Object.defineProperty(G2, "open", { value: _4, writable: false, configurable: false, enumerable: true }), Object.defineProperty(G2, "close", { value: Y2, writable: false, configurable: false, enumerable: true }), Object.freeze(G2);
+  }
+  return J2;
+}
+function pZ(V2) {
+  let $ = {};
+  for (let Z of E4)
+    $[Z] = V2([{ kind: "named", name: Z }]);
+  return $;
+}
+function T2(V2) {
+  let $ = V2?.mode ?? "auto", Z = xV($, V2?.overrides), z = x3($, V2?.overrides), Q = z !== "none", J2 = z === "truecolor", X3 = gV($, V2?.overrides), H = Z || Q, q = hZ(Z, Q, z), G2 = pZ(q), _4 = { enabled: H, colorsEnabled: Q, trueColorEnabled: J2, colorDepth: z, apply: (Y2, K) => {
+    return (VZ(K) ? Z : Q) ? L4(Y2, K) : Y2;
+  }, link: X3 ? (Y2, K, B) => iV(Y2, K, B) : (Y2, K, B) => {
+    return S4(K, B), Y2;
+  }, fg: (Y2, K) => {
+    if (K === undefined)
+      return q([{ kind: "pair", pair: h4(Y2, z), isModifier: false }]);
+    return I2(Y2, K, z);
+  }, bg: (Y2, K) => {
+    if (K === undefined)
+      return q([{ kind: "pair", pair: p2(Y2, z), isModifier: false }]);
+    return k4(Y2, K, z);
+  }, rgb: J2 ? (Y2, K, B, N4) => lV(Y2, K, B, N4) : (Y2, K, B, N4) => Y2, bgRgb: J2 ? (Y2, K, B, N4) => sV(Y2, K, B, N4) : (Y2, K, B, N4) => Y2, hex: J2 ? (Y2, K) => nV(Y2, K) : (Y2, K) => Y2, bgHex: J2 ? (Y2, K) => aV(Y2, K) : (Y2, K) => Y2, ...G2 };
+  return Object.freeze(_4);
+}
+var F4;
+var $Z = new Map;
+function lZ() {
+  if (F4 === "always")
+    return T2({ mode: "always" });
+  if (F4 === "never")
+    return T2({ mode: "auto", overrides: { isTTY: true, noColor: "1" } });
+  return T2({ mode: "auto" });
+}
+function W() {
+  let V2 = [F4 ?? "auto", process.stdout?.isTTY ?? false, process.env.NO_COLOR ?? "", process.env.COLORTERM ?? "", process.env.TERM ?? ""].join("|"), $ = $Z.get(V2);
+  if ($)
+    return $;
+  let Z = lZ();
+  return $Z.set(V2, Z), Z;
+}
+var sZ = ["apply", "link", "fg", "bg", "rgb", "bgRgb", "hex", "bgHex"];
+var nZ = ["enabled", "colorsEnabled", "trueColorEnabled", "colorDepth"];
+function j2(V2) {
+  let $ = (...z) => W()[V2](...z);
+  for (let z of E4)
+    Object.defineProperty($, z, { configurable: false, enumerable: true, get() {
+      return W()[V2][z];
     } });
-  for (let Y of IB)
-    Object.defineProperty(F3, Y, { configurable: false, enumerable: true, value: (...B3) => {
-      return b4()[Y](...B3);
-    }, writable: false });
-  for (let Y of I4)
-    Object.defineProperty(F3, Y, { configurable: false, enumerable: true, get() {
-      return b4()[Y];
+  Object.defineProperty($, "fg", { configurable: false, enumerable: true, value: (z) => W()[V2].fg(z), writable: false }), Object.defineProperty($, "bg", { configurable: false, enumerable: true, value: (z) => W()[V2].bg(z), writable: false });
+  let Z = a(V2);
+  return Object.defineProperty($, "open", { value: Z.open, writable: false, configurable: false, enumerable: true }), Object.defineProperty($, "close", { value: Z.close, writable: false, configurable: false, enumerable: true }), Object.freeze($);
+}
+function aZ() {
+  let V2 = {};
+  for (let $ of nZ)
+    Object.defineProperty(V2, $, { configurable: false, enumerable: true, get() {
+      return W()[$];
     } });
-  return Object.freeze(F3);
-}
-var Q = EB();
-var kB = (F3) => Q.red(F3);
-var gB = (F3) => Q.green(F3);
-var yB = (F3) => Q.cyan(F3);
-var ZY = (F3) => Q.bold(F3);
-var $Y = (F3) => Q.dim(F3);
-function P4(F3) {
-  return Object.freeze({ heading1: (B3) => F3.bold(F3.underline(B3)), heading2: (B3) => F3.bold(B3), heading3: (B3) => F3.bold(F3.yellow(B3)), heading4: (B3) => F3.yellow(B3), heading5: (B3) => F3.dim(F3.yellow(B3)), heading6: (B3) => F3.dim(B3), text: (B3) => B3, emphasis: (B3) => F3.italic(B3), strong: (B3) => F3.bold(B3), strongEmphasis: (B3) => F3.bold(F3.italic(B3)), strikethrough: (B3) => F3.strikethrough(B3), inlineCode: (B3) => F3.cyan(B3), linkText: (B3) => F3.blue(F3.underline(B3)), linkUrl: (B3) => F3.dim(F3.underline(B3)), autolink: (B3) => F3.blue(F3.underline(B3)), blockquoteMarker: (B3) => F3.dim(F3.green(B3)), blockquoteText: (B3) => F3.italic(B3), listMarker: (B3) => F3.dim(B3), orderedListMarker: (B3) => F3.dim(B3), taskChecked: (B3) => F3.green(B3), taskUnchecked: (B3) => F3.dim(B3), codeFence: (B3) => F3.dim(B3), codeInfo: (B3) => F3.dim(F3.italic(B3)), codeText: (B3) => F3.cyan(B3), thematicBreak: (B3) => F3.dim(B3), tableHeader: (B3) => F3.bold(B3), tableCell: (B3) => B3, tableBorder: (B3) => F3.dim(B3), imageAltText: (B3) => F3.italic(F3.magenta(B3)), imageUrl: (B3) => F3.dim(F3.underline(B3)) });
-}
-function nF(F3) {
-  let Y = A4(F3?.style), B3 = P4(Y), V = F3?.overrides;
-  if (!V)
-    return B3;
-  let Z = { heading1: V.heading1 ?? B3.heading1, heading2: V.heading2 ?? B3.heading2, heading3: V.heading3 ?? B3.heading3, heading4: V.heading4 ?? B3.heading4, heading5: V.heading5 ?? B3.heading5, heading6: V.heading6 ?? B3.heading6, text: V.text ?? B3.text, emphasis: V.emphasis ?? B3.emphasis, strong: V.strong ?? B3.strong, strongEmphasis: V.strongEmphasis ?? B3.strongEmphasis, strikethrough: V.strikethrough ?? B3.strikethrough, inlineCode: V.inlineCode ?? B3.inlineCode, linkText: V.linkText ?? B3.linkText, linkUrl: V.linkUrl ?? B3.linkUrl, autolink: V.autolink ?? B3.autolink, blockquoteMarker: V.blockquoteMarker ?? B3.blockquoteMarker, blockquoteText: V.blockquoteText ?? B3.blockquoteText, listMarker: V.listMarker ?? B3.listMarker, orderedListMarker: V.orderedListMarker ?? B3.orderedListMarker, taskChecked: V.taskChecked ?? B3.taskChecked, taskUnchecked: V.taskUnchecked ?? B3.taskUnchecked, codeFence: V.codeFence ?? B3.codeFence, codeInfo: V.codeInfo ?? B3.codeInfo, codeText: V.codeText ?? B3.codeText, thematicBreak: V.thematicBreak ?? B3.thematicBreak, tableHeader: V.tableHeader ?? B3.tableHeader, tableCell: V.tableCell ?? B3.tableCell, tableBorder: V.tableBorder ?? B3.tableBorder, imageAltText: V.imageAltText ?? B3.imageAltText, imageUrl: V.imageUrl ?? B3.imageUrl };
-  return Object.freeze(Z);
-}
-var MY = nF();
+  for (let $ of sZ)
+    Object.defineProperty(V2, $, { configurable: false, enumerable: true, value: (...Z) => {
+      return W()[$](...Z);
+    }, writable: false });
+  for (let $ of E4)
+    Object.defineProperty(V2, $, { configurable: false, enumerable: true, value: j2($), writable: false });
+  return Object.freeze(V2);
+}
+var R2 = aZ();
+var oZ = j2("black");
+var rZ = j2("red");
+var iZ = j2("green");
+var tZ = j2("yellow");
+var eZ = j2("blue");
+var V$ = j2("magenta");
+var Z$ = j2("cyan");
+var $$ = j2("white");
+var z$ = j2("gray");
+var Q$ = j2("brightRed");
+var J$ = j2("brightGreen");
+var X$ = j2("brightYellow");
+var K$ = j2("brightBlue");
+var Y$ = j2("brightMagenta");
+var j$ = j2("brightCyan");
+var U$ = j2("brightWhite");
+var H$ = j2("bgBlack");
+var q$ = j2("bgRed");
+var B$ = j2("bgGreen");
+var G$ = j2("bgYellow");
+var _$ = j2("bgBlue");
+var A$ = j2("bgMagenta");
+var L$ = j2("bgCyan");
+var D$ = j2("bgWhite");
+var N$ = j2("bgBrightBlack");
+var M$ = j2("bgBrightRed");
+var R$ = j2("bgBrightGreen");
+var O$ = j2("bgBrightYellow");
+var W$ = j2("bgBrightBlue");
+var T$ = j2("bgBrightMagenta");
+var E$ = j2("bgBrightCyan");
+var F$ = j2("bgBrightWhite");
+var I$ = j2("bold");
+var k$ = j2("dim");
+var S$ = j2("italic");
+var f$ = j2("underline");
+var w$ = j2("inverse");
+var C$ = j2("hidden");
+var P$ = j2("strikethrough");
+function QZ(V2) {
+  return Object.freeze({ heading1: (Z) => V2.bold(V2.underline(Z)), heading2: (Z) => V2.bold(Z), heading3: (Z) => V2.bold(V2.yellow(Z)), heading4: (Z) => V2.yellow(Z), heading5: (Z) => V2.dim(V2.yellow(Z)), heading6: (Z) => V2.dim(Z), text: (Z) => Z, emphasis: (Z) => V2.italic(Z), strong: (Z) => V2.bold(Z), strongEmphasis: (Z) => V2.bold(V2.italic(Z)), strikethrough: (Z) => V2.strikethrough(Z), inlineCode: (Z) => V2.cyan(Z), linkText: (Z) => V2.blue(V2.underline(Z)), linkUrl: (Z) => V2.dim(V2.underline(Z)), autolink: (Z) => V2.blue(V2.underline(Z)), blockquoteMarker: (Z) => V2.dim(V2.green(Z)), blockquoteText: (Z) => V2.italic(Z), listMarker: (Z) => V2.dim(Z), orderedListMarker: (Z) => V2.dim(Z), taskChecked: (Z) => V2.green(Z), taskUnchecked: (Z) => V2.dim(Z), codeFence: (Z) => V2.dim(Z), codeInfo: (Z) => V2.dim(V2.italic(Z)), codeText: (Z) => V2.cyan(Z), thematicBreak: (Z) => V2.dim(Z), tableHeader: (Z) => V2.bold(Z), tableCell: (Z) => Z, tableBorder: (Z) => V2.dim(Z), imageAltText: (Z) => V2.italic(V2.magenta(Z)), imageUrl: (Z) => V2.dim(V2.underline(Z)) });
+}
+function JZ(V2) {
+  let $ = T2(V2?.style), Z = QZ($), z = V2?.overrides;
+  if (!z)
+    return Z;
+  let Q = { heading1: z.heading1 ?? Z.heading1, heading2: z.heading2 ?? Z.heading2, heading3: z.heading3 ?? Z.heading3, heading4: z.heading4 ?? Z.heading4, heading5: z.heading5 ?? Z.heading5, heading6: z.heading6 ?? Z.heading6, text: z.text ?? Z.text, emphasis: z.emphasis ?? Z.emphasis, strong: z.strong ?? Z.strong, strongEmphasis: z.strongEmphasis ?? Z.strongEmphasis, strikethrough: z.strikethrough ?? Z.strikethrough, inlineCode: z.inlineCode ?? Z.inlineCode, linkText: z.linkText ?? Z.linkText, linkUrl: z.linkUrl ?? Z.linkUrl, autolink: z.autolink ?? Z.autolink, blockquoteMarker: z.blockquoteMarker ?? Z.blockquoteMarker, blockquoteText: z.blockquoteText ?? Z.blockquoteText, listMarker: z.listMarker ?? Z.listMarker, orderedListMarker: z.orderedListMarker ?? Z.orderedListMarker, taskChecked: z.taskChecked ?? Z.taskChecked, taskUnchecked: z.taskUnchecked ?? Z.taskUnchecked, codeFence: z.codeFence ?? Z.codeFence, codeInfo: z.codeInfo ?? Z.codeInfo, codeText: z.codeText ?? Z.codeText, thematicBreak: z.thematicBreak ?? Z.thematicBreak, tableHeader: z.tableHeader ?? Z.tableHeader, tableCell: z.tableCell ?? Z.tableCell, tableBorder: z.tableBorder ?? Z.tableBorder, imageAltText: z.imageAltText ?? Z.imageAltText, imageUrl: z.imageUrl ?? Z.imageUrl };
+  return Object.freeze(Q);
+}
+var n$ = JZ();
 
-// ../../node_modules/.bun/@crustjs+prompts@0.0.13+7524df1edfed9f02/node_modules/@crustjs/prompts/dist/index.js
-import * as QJ from "readline";
+// ../../node_modules/.bun/@crustjs+prompts@0.1.0+7524df1edfed9f02/node_modules/@crustjs/prompts/dist/index.js
+import * as ZJ from "readline";
 
-// ../../node_modules/.bun/@crustjs+progress@0.0.3+7524df1edfed9f02/node_modules/@crustjs/progress/dist/index.js
-var Q2 = "\x1B[";
-var N3 = `${Q2}?25l`;
-var J2 = `${Q2}?25h`;
-var V = `${Q2}2K`;
+// ../../node_modules/.bun/@crustjs+progress@0.0.4+7524df1edfed9f02/node_modules/@crustjs/progress/dist/index.js
+var Q = "\x1B[";
+var N4 = `${Q}?25l`;
+var J2 = `${Q}?25h`;
+var V2 = `${Q}2K`;
 
-// ../../node_modules/.bun/@crustjs+prompts@0.0.13+7524df1edfed9f02/node_modules/@crustjs/prompts/dist/index.js
-var b5 = { prefix: yB, message: ZY, placeholder: $Y, cursor: yB, selected: yB, unselected: $Y, error: kB, success: gB, hint: $Y, filterMatch: yB };
-var h5;
+// ../../node_modules/.bun/@crustjs+prompts@0.1.0+7524df1edfed9f02/node_modules/@crustjs/prompts/dist/index.js
+var b5 = { prefix: Z$, message: I$, placeholder: k$, cursor: Z$, selected: Z$, unselected: k$, error: rZ, success: iZ, hint: k$, filterMatch: Z$ };
+var u2;
 function w4(J3) {
-  if (!h5 && !J3)
+  if (!u2 && !J3)
     return b5;
-  return { ...b5, ...h5, ...J3 };
+  return { ...b5, ...u2, ...J3 };
 }
-var i2 = Symbol("submit");
-function M4(J3) {
-  return { [i2]: J3 };
+var a2 = Symbol("submit");
+function H(J3) {
+  return { [a2]: J3 };
 }
-var o2 = false;
-var u2 = "\x1B[";
-var zJ = `${u2}?25l`;
-var NJ = `${u2}?25h`;
-var qJ = `${u2}2K`;
-function e2(J3) {
-  return J3 > 0 ? `${u2}${J3}A` : "";
+var i2 = false;
+var c2 = "\x1B[";
+var HJ = `${c2}?25l`;
+var MJ = `${c2}?25h`;
+var qJ = `${c2}2K`;
+function JJ(J3) {
+  return J3 > 0 ? `${c2}${J3}A` : "";
 }
-function JJ(J3, Q3) {
+function QJ(J3, Q2) {
   let Z = J3.split(`
 `), W2 = 0;
-  for (let G of Z) {
-    let $ = O2(G);
-    W2 += $ === 0 ? 1 : Math.ceil($ / Q3);
+  for (let G2 of Z) {
+    let $ = M3(G2);
+    W2 += $ === 0 ? 1 : Math.ceil($ / Q2);
   }
   return W2;
 }
 
-class a2 extends Error {
+class s2 extends Error {
   constructor(J3) {
     super(J3 ?? "Prompts require an interactive terminal (TTY).");
     this.name = "NonInteractiveError";
   }
 }
 
-class s2 extends Error {
+class t2 extends Error {
   constructor(J3) {
     super(J3 ?? "Prompt was cancelled.");
     this.name = "CancelledError";
   }
 }
-function _5() {
+function _4() {
   return !!process.stdin.isTTY;
 }
-function ZJ() {
-  if (!_5())
-    throw new a2;
+function $J() {
+  if (!_4())
+    throw new s2;
 }
-function HJ(J3) {
-  return typeof J3 === "object" && J3 !== null && i2 in J3;
+function DJ(J3) {
+  return typeof J3 === "object" && J3 !== null && a2 in J3;
 }
 function D4(J3) {
-  let { render: Q3, handleKey: Z, initialState: W2, theme: G, renderSubmitted: $ } = J3;
-  return new Promise((K, Y) => {
-    if (o2) {
-      Y(Error("Cannot run multiple prompts concurrently. Await each prompt before starting the next."));
+  let { render: Q2, handleKey: Z, initialState: W2, theme: G2, renderSubmitted: $ } = J3;
+  return new Promise((K, j3) => {
+    if (i2) {
+      j3(Error("Cannot run multiple prompts concurrently. Await each prompt before starting the next."));
       return;
     }
     try {
-      ZJ();
-    } catch (U2) {
-      Y(U2);
+      $J();
+    } catch (A4) {
+      j3(A4);
       return;
     }
-    o2 = true;
-    let j = W2, X2 = 0, F3 = false, B3 = process.stdin, z3 = process.stderr;
-    function N4() {
-      if (F3)
+    i2 = true;
+    let Y2 = W2, X3 = 0, F5 = false, B = process.stdin, z = process.stderr;
+    function N5() {
+      if (F5)
         return;
-      if (F3 = true, o2 = false, B3.removeListener("keypress", x4), B3.isTTY && B3.isRaw)
-        B3.setRawMode(false);
-      B3.pause(), z3.write(NJ);
-    }
-    function H(U2) {
-      let T3 = z3.columns || 80;
-      if (X2 > 0) {
-        z3.write(`${e2(X2 - 1)}\r`);
-        for (let p2 = 0;p2 < X2; p2++)
-          if (z3.write(qJ), p2 < X2 - 1)
-            z3.write(`${u2}1B`);
-        if (X2 > 1)
-          z3.write(e2(X2 - 1));
-        z3.write("\r");
+      if (F5 = true, i2 = false, B.removeListener("keypress", p3), B.isTTY && B.isRaw)
+        B.setRawMode(false);
+      B.pause(), z.write(MJ);
+    }
+    function q(A4) {
+      let T3 = z.columns || 80;
+      if (X3 > 0) {
+        z.write(`${JJ(X3 - 1)}\r`);
+        for (let d2 = 0;d2 < X3; d2++)
+          if (z.write(qJ), d2 < X3 - 1)
+            z.write(`${c2}1B`);
+        if (X3 > 1)
+          z.write(JJ(X3 - 1));
+        z.write("\r");
       }
-      z3.write(U2), X2 = JJ(U2, T3);
+      z.write(A4), X3 = QJ(A4, T3);
     }
-    let P5 = Promise.resolve(), R3 = null;
-    function I5() {
-      if (R3 !== null)
+    let P4 = Promise.resolve(), O4 = null;
+    function k5() {
+      if (O4 !== null)
         return;
-      R3 = setTimeout(() => {
-        if (R3 = null, !F3)
-          H(Q3(j, G));
+      O4 = setTimeout(() => {
+        if (O4 = null, !F5)
+          q(Q2(Y2, G2));
       }, 0);
     }
-    function y4() {
-      if (R3 !== null)
-        clearTimeout(R3), R3 = null;
+    function x4() {
+      if (O4 !== null)
+        clearTimeout(O4), O4 = null;
     }
-    function x4(U2, T3) {
+    function p3(A4, T3) {
       if (T3?.ctrl && T3.name === "c") {
-        y4(), z3.write(`
-`), N4(), Y(new s2);
+        x4(), z.write(`
+`), N5(), j3(new t2);
         return;
       }
-      let p2 = { char: U2 ?? "", name: T3?.name ?? "", ctrl: T3?.ctrl ?? false, meta: T3?.meta ?? false, shift: T3?.shift ?? false };
-      P5 = P5.then(async () => {
-        if (F3)
+      let d2 = { char: A4 ?? "", name: T3?.name ?? "", ctrl: T3?.ctrl ?? false, meta: T3?.meta ?? false, shift: T3?.shift ?? false };
+      P4 = P4.then(async () => {
+        if (F5)
           return;
         try {
-          let d2 = await Z(p2, j);
-          if (HJ(d2)) {
-            y4();
-            let t2 = d2[i2];
+          let h5 = await Z(d2, Y2);
+          if (DJ(h5)) {
+            x4();
+            let e2 = h5[a2];
             if ($)
-              H($(j, t2, G));
-            z3.write(`
-`), N4(), K(t2);
+              q($(Y2, e2, G2));
+            z.write(`
+`), N5(), K(e2);
           } else
-            j = d2, I5();
-        } catch (d2) {
-          y4(), N4(), Y(d2);
+            Y2 = h5, k5();
+        } catch (h5) {
+          x4(), N5(), j3(h5);
         }
       });
     }
     try {
-      QJ.emitKeypressEvents(B3), B3.setRawMode(true), B3.resume(), z3.write(zJ);
-      let U2 = Q3(j, G);
-      z3.write(U2);
-      let T3 = z3.columns || 80;
-      X2 = JJ(U2, T3), B3.on("keypress", x4);
-    } catch (U2) {
-      N4(), Y(U2);
+      ZJ.emitKeypressEvents(B), B.setRawMode(true), B.resume(), z.write(HJ);
+      let A4 = Q2(Y2, G2);
+      z.write(A4);
+      let T3 = z.columns || 80;
+      X3 = QJ(A4, T3), B.on("keypress", p3);
+    } catch (A4) {
+      N5(), j3(A4);
     }
   });
 }
-var V2 = "┃";
-var E3 = "✓";
-function c2(J3, Q3) {
-  if (Q3)
-    return `${J3} ${Q3}`;
+var V3 = "┃";
+var E5 = "✓";
+function m3(J3, Q2) {
+  if (Q2)
+    return `${J3} ${Q2}`;
   return J3;
 }
-function A5(J3, Q3, Z) {
+function U2(J3, Q2, Z) {
   let W2 = [J3];
-  if (Q3)
-    W2.push(Q3);
+  if (Q2)
+    W2.push(Q2);
   if (Z)
     W2.push(Z);
   return W2.join(" ");
 }
-function L2(J3, Q3, Z, W2) {
-  let G = c2(J3, Q3), $ = W2 ?? "";
-  if (Q3)
-    return `${G}${$}
+function R3(J3, Q2, Z, W2) {
+  let G2 = m3(J3, Q2), $ = W2 ?? "";
+  if (Q2)
+    return `${G2}${$}
   ${Z}`;
-  return `${G}${$} ${Z}`;
+  return `${G2}${$} ${Z}`;
 }
-function MJ(J3, Q3) {
+function UJ(J3, Q2) {
   if (J3.name === "return")
-    return M4(Q3.value);
+    return H(Q2.value);
   if (J3.name === "left" || J3.name === "right")
-    return { value: !Q3.value };
+    return { value: !Q2.value };
   if (J3.name === "h")
     return { value: true };
   if (J3.name === "l")
     return { value: false };
   if (J3.name === "tab")
-    return { value: !Q3.value };
+    return { value: !Q2.value };
   if (J3.char === "y" || J3.char === "Y")
     return { value: true };
   if (J3.char === "n" || J3.char === "N")
     return { value: false };
-  return Q3;
+  return Q2;
 }
-var DJ = " · ";
-function AJ(J3, Q3, Z, W2, G) {
-  let $ = Q3.prefix(V2), K = Q3.message(Z ?? "Are you sure?"), Y = J3.value ? `${Q3.selected("●")} ${Q3.selected(W2)}` : `${Q3.unselected("○")} ${Q3.unselected(W2)}`, j = J3.value ? `${Q3.unselected("○")} ${Q3.unselected(G)}` : `${Q3.selected("●")} ${Q3.selected(G)}`, X2 = `${Y}${DJ}${j}`;
-  return L2($, K, X2);
+var AJ = " · ";
+function wJ(J3, Q2, Z, W2, G2) {
+  let $ = Q2.prefix(V3), K = Q2.message(Z ?? "Are you sure?"), j3 = J3.value ? `${Q2.selected("●")} ${Q2.selected(W2)}` : `${Q2.unselected("○")} ${Q2.unselected(W2)}`, Y2 = J3.value ? `${Q2.unselected("○")} ${Q2.unselected(G2)}` : `${Q2.selected("●")} ${Q2.selected(G2)}`, X3 = `${j3}${AJ}${Y2}`;
+  return R3($, K, X3);
 }
-function UJ(J3, Q3, Z, W2, G, $) {
-  let K = Z.success(E3), Y = Z.message(W2 ?? "Are you sure?"), j = Q3 ? G : $;
-  return A5(K, Y, Z.success(j));
+function _J(J3, Q2, Z, W2, G2, $) {
+  let K = Z.success(E5), j3 = Z.message(W2 ?? "Are you sure?"), Y2 = Q2 ? G2 : $;
+  return U2(K, j3, Z.success(Y2));
 }
-async function wJ(J3) {
+async function VJ(J3) {
   if (J3.initial !== undefined)
     return J3.initial;
-  if (!_5() && J3.default !== undefined)
+  if (!_4() && J3.default !== undefined)
     return J3.default;
-  let Q3 = w4(J3.theme), Z = J3.active ?? "Yes", W2 = J3.inactive ?? "No", $ = { value: J3.default ?? true };
-  return D4({ initialState: $, theme: Q3, render: (K, Y) => AJ(K, Y, J3.message, Z, W2), handleKey: MJ, renderSubmitted: (K, Y, j) => UJ(K, Y, j, J3.message, Z, W2) });
+  let Q2 = w4(J3.theme), Z = J3.active ?? "Yes", W2 = J3.inactive ?? "No", $ = { value: J3.default ?? true };
+  return D4({ initialState: $, theme: Q2, render: (K, j3) => wJ(K, j3, J3.message, Z, W2), handleKey: UJ, renderSubmitted: (K, j3, Y2) => _J(K, j3, Y2, J3.message, Z, W2) });
 }
 
 // src/commands/scan.ts
@@ -1513,9 +1898,17 @@ async function resolveSource(input) {
   return resolveGithub(parsed.repo);
 }
 
-// ../../node_modules/.bun/valibot@1.3.1+7524df1edfed9f02/node_modules/valibot/dist/index.mjs
+// ../../node_modules/.bun/valibot@1.4.1+7524df1edfed9f02/node_modules/valibot/dist/index.mjs
 var store$4;
+var DEFAULT_CONFIG = {
+  lang: undefined,
+  message: undefined,
+  abortEarly: undefined,
+  abortPipeEarly: undefined
+};
 function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4)
+    return DEFAULT_CONFIG;
   return {
     lang: config$1?.lang ?? store$4?.lang,
     message: config$1?.message,
@@ -1574,17 +1967,23 @@ function _addIssue(context, label, dataset, config$1, other) {
   else
     dataset.issues = [issue];
 }
+var _standardCache = /* @__PURE__ */ new WeakMap;
 function _getStandardProps(context) {
-  return {
-    version: 1,
-    vendor: "valibot",
-    validate(value$1) {
-      return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
-    }
-  };
+  let cached = _standardCache.get(context);
+  if (!cached) {
+    cached = {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+    _standardCache.set(context, cached);
+  }
+  return cached;
 }
 function _isValidObjectKey(object$1, key) {
-  return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+  return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
 }
 function _joinExpects(values$1, separator) {
   const list = [...new Set(values$1)];
@@ -1659,64 +2058,6 @@ function transform(operation) {
     }
   };
 }
-var _LruCache = class {
-  constructor(config$1) {
-    this.refCount = 0;
-    this.maxSize = config$1?.maxSize ?? 1000;
-    this.maxAge = config$1?.maxAge ?? Infinity;
-    this.hasMaxAge = isFinite(this.maxAge);
-  }
-  #stringify(input) {
-    const type = typeof input;
-    if (type === "string")
-      return `"${input}"`;
-    if (type === "number" || type === "boolean")
-      return `${input}`;
-    if (type === "bigint")
-      return `${input}n`;
-    if (type === "object" || type === "function") {
-      if (input) {
-        this.refIds ??= /* @__PURE__ */ new WeakMap;
-        let id = this.refIds.get(input);
-        if (!id) {
-          id = ++this.refCount;
-          this.refIds.set(input, id);
-        }
-        return `#${id}`;
-      }
-      return "null";
-    }
-    return type;
-  }
-  key(input, config$1 = {}) {
-    return `${this.#stringify(input)}|${this.#stringify(config$1.lang)}|${this.#stringify(config$1.message)}|${this.#stringify(config$1.abortEarly)}|${this.#stringify(config$1.abortPipeEarly)}`;
-  }
-  get(key) {
-    if (!this.store)
-      return;
-    const entry = this.store.get(key);
-    if (!entry)
-      return;
-    if (this.hasMaxAge && Date.now() - entry[1] > this.maxAge) {
-      this.store.delete(key);
-      return;
-    }
-    this.store.delete(key);
-    this.store.set(key, entry);
-    return entry[0];
-  }
-  set(key, value$1) {
-    this.store ??= /* @__PURE__ */ new Map;
-    this.store.delete(key);
-    const timestamp = this.hasMaxAge ? Date.now() : 0;
-    this.store.set(key, [value$1, timestamp]);
-    if (this.store.size > this.maxSize)
-      this.store.delete(this.store.keys().next().value);
-  }
-  clear() {
-    this.store?.clear();
-  }
-};
 function getFallback(schema, dataset, config$1) {
   return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
 }
@@ -2141,7 +2482,8 @@ function _subIssues(datasets) {
   if (datasets)
     for (const dataset of datasets)
       if (issues)
-        issues.push(...dataset.issues);
+        for (const issue of dataset.issues)
+          issues.push(issue);
       else
         issues = dataset.issues;
   return issues;
@@ -2300,10 +2642,10 @@ function makeDirLister(onSkip) {
   };
 }
 function dirContainsFile(list, dir, name) {
-  return list(dir).some((e3) => e3.isFile && e3.name === name);
+  return list(dir).some((e2) => e2.isFile && e2.name === name);
 }
 function dirContainsDir(list, dir, name) {
-  return list(dir).some((e3) => e3.isDirectory && e3.name === name);
+  return list(dir).some((e2) => e2.isDirectory && e2.name === name);
 }
 function walkTree(root, options) {
   const list = options.list ?? makeDirLister();
@@ -2320,7 +2662,7 @@ function walkTree(root, options) {
   };
   const walkInto = (dir) => {
     options.onDir?.(dir);
-    const entries = list(dir).filter((e3) => !options.skipDirs.has(e3.name));
+    const entries = list(dir).filter((e2) => !options.skipDirs.has(e2.name));
     for (const entry of entries) {
       if (entry.isFile) {
         options.onFile?.(join3(dir, entry.name));
@@ -2363,14 +2705,14 @@ function readJsonFile(file) {
   let raw;
   try {
     raw = readFileSync(file, "utf8");
-  } catch (e3) {
-    throw new Error(`Cannot read ${file}: ${e3 instanceof Error ? e3.message : String(e3)}`, { cause: e3 });
+  } catch (e2) {
+    throw new Error(`Cannot read ${file}: ${e2 instanceof Error ? e2.message : String(e2)}`, { cause: e2 });
   }
   try {
     return JSON.parse(raw);
-  } catch (e3) {
-    throw new Error(`Invalid JSON in ${file}: ${e3 instanceof Error ? e3.message : String(e3)}`, {
-      cause: e3
+  } catch (e2) {
+    throw new Error(`Invalid JSON in ${file}: ${e2 instanceof Error ? e2.message : String(e2)}`, {
+      cause: e2
     });
   }
 }
@@ -2477,8 +2819,8 @@ function detectMarkerFile(repoRoot) {
   let parsed;
   try {
     parsed = readJsonFile(markerPath);
-  } catch (e3) {
-    throw new MarkerFileError(e3 instanceof Error ? e3.message : String(e3), []);
+  } catch (e2) {
+    throw new MarkerFileError(e2 instanceof Error ? e2.message : String(e2), []);
   }
   const result = safeParse(MarkerFileSchema, parsed);
   if (!result.success) {
@@ -2521,7 +2863,7 @@ function scanRoot(repoRoot, prefix, list) {
       continue;
     }
     const folderPath = join5(baseDir, folder);
-    const entries = list(folderPath).map((e3) => e3.name);
+    const entries = list(folderPath).map((e2) => e2.name);
     if (emit === "directory") {
       findings.push({
         kind,
@@ -2530,11 +2872,11 @@ function scanRoot(repoRoot, prefix, list) {
         source: "convention"
       });
     } else {
-      const files = entries.filter((e3) => e3.endsWith(emit.enumerateFiles));
+      const files = entries.filter((e2) => e2.endsWith(emit.enumerateFiles));
       if (files.length > 0) {
         findings.push({
           kind,
-          paths: files.map((f2) => `${pathPrefix}${folder}/${f2}`),
+          paths: files.map((f5) => `${pathPrefix}${folder}/${f5}`),
           confidence: "high",
           source: "convention"
         });
@@ -2545,7 +2887,7 @@ function scanRoot(repoRoot, prefix, list) {
     const parts = file.split("/");
     const fileName = parts[parts.length - 1] ?? file;
     const fileDir = parts.length > 1 ? join5(baseDir, ...parts.slice(0, -1)) : baseDir;
-    if (list(fileDir).some((e3) => e3.isFile && e3.name === fileName)) {
+    if (list(fileDir).some((e2) => e2.isFile && e2.name === fileName)) {
       findings.push({
         kind,
         paths: [`${pathPrefix}${file}`],
@@ -2620,12 +2962,12 @@ function detectNonStandardManifest(repoRoot) {
     if (!result.success) {
       continue;
     }
-    const m2 = result.output;
-    const hasComponent = m2.skills !== undefined || m2.agents !== undefined || m2.commands !== undefined || m2.hooks !== undefined || m2.mcpServers !== undefined;
+    const m4 = result.output;
+    const hasComponent = m4.skills !== undefined || m4.agents !== undefined || m4.commands !== undefined || m4.hooks !== undefined || m4.mcpServers !== undefined;
     if (!hasComponent) {
       continue;
     }
-    return { filename: entry, manifest: m2 };
+    return { filename: entry, manifest: m4 };
   }
   return null;
 }
@@ -2735,8 +3077,8 @@ function collectPlainContinuation(lines, start) {
 function dedentCommonIndent(lines) {
   let minIndent = Infinity;
   for (const line of lines) {
-    const t2 = line.trim();
-    if (t2 === "" || t2.startsWith("#")) {
+    const t3 = line.trim();
+    if (t3 === "" || t3.startsWith("#")) {
       continue;
     }
     minIndent = Math.min(minIndent, leadingSpaces(line));
@@ -2803,8 +3145,8 @@ function collectBlockScalar(lines, start, baseIndent, indicator) {
 function collectNested(lines, start, baseIndent) {
   let peek = start;
   while (peek < lines.length) {
-    const t2 = (lines[peek] ?? "").trim();
-    if (t2 !== "" && !t2.startsWith("#")) {
+    const t3 = (lines[peek] ?? "").trim();
+    if (t3 !== "" && !t3.startsWith("#")) {
       break;
     }
     peek++;
@@ -2836,11 +3178,11 @@ function collectNested(lines, start, baseIndent) {
       if (leadingSpaces(line) > childIndent) {
         continue;
       }
-      const t2 = line.trim();
-      if (t2 === "-") {
+      const t3 = line.trim();
+      if (t3 === "-") {
         arr.push(null);
-      } else if (t2.startsWith("- ")) {
-        arr.push(coerceYamlValue(t2.slice(2).trim()));
+      } else if (t3.startsWith("- ")) {
+        arr.push(coerceYamlValue(t3.slice(2).trim()));
       }
     }
     return { value: arr, next: i4 };
@@ -2849,8 +3191,8 @@ function collectNested(lines, start, baseIndent) {
   let i3 = start;
   for (;i3 < lines.length; i3++) {
     const line = lines[i3] ?? "";
-    const t2 = line.trim();
-    if (t2 === "" || t2.startsWith("#")) {
+    const t3 = line.trim();
+    if (t3 === "" || t3.startsWith("#")) {
       continue;
     }
     if (leadingSpaces(line) <= baseIndent) {
@@ -2859,13 +3201,13 @@ function collectNested(lines, start, baseIndent) {
     if (leadingSpaces(line) > childIndent) {
       continue;
     }
-    const ci = mappingColonIndex(t2);
+    const ci = mappingColonIndex(t3);
     if (ci === -1) {
       continue;
     }
-    const k3 = t2.slice(0, ci).trim();
-    const val = t2.slice(ci + 1).trim();
-    map[k3] = val === "" || isBlockScalarIndicator(val) ? null : coerceYamlValue(val);
+    const k5 = t3.slice(0, ci).trim();
+    const val = t3.slice(ci + 1).trim();
+    map[k5] = val === "" || isBlockScalarIndicator(val) ? null : coerceYamlValue(val);
   }
   return { value: map, next: i3 };
 }
@@ -3010,8 +3352,8 @@ function detectContentSniff(repoRoot, caches = {}) {
 // src/detector/caches.ts
 function makeScanCaches() {
   const skippedPaths = [];
-  const onSkip = (p2) => {
-    skippedPaths.push(p2);
+  const onSkip = (p3) => {
+    skippedPaths.push(p3);
   };
   return {
     list: makeDirLister(onSkip),
@@ -3070,8 +3412,8 @@ function stripCommonPrefix(keys) {
     return [...keys];
   }
   let prefix = keys[0] ?? "";
-  for (const k3 of keys.slice(1)) {
-    while (prefix !== "" && !k3.startsWith(prefix)) {
+  for (const k5 of keys.slice(1)) {
+    while (prefix !== "" && !k5.startsWith(prefix)) {
       prefix = prefix.slice(0, -1);
     }
     if (prefix === "") {
@@ -3083,7 +3425,7 @@ function stripCommonPrefix(keys) {
     return [...keys];
   }
   const cut = lastHyphen + 1;
-  const stripped = keys.map((k3) => k3.slice(cut));
+  const stripped = keys.map((k5) => k5.slice(cut));
   if (stripped.some((s3) => s3 === "")) {
     return [...keys];
   }
@@ -3114,7 +3456,7 @@ function uniqueSlugs(slugs) {
 import { join as join8 } from "node:path";
 function enumerateSkills(containerDir, list = makeDirLister(), readFm = readFrontmatter) {
   const out = [];
-  const children = list(containerDir).filter((e3) => e3.isDirectory).map((e3) => e3.name).sort();
+  const children = list(containerDir).filter((e2) => e2.isDirectory).map((e2) => e2.name).sort();
   for (const dir of children) {
     const skillPath = join8(containerDir, dir);
     if (!dirContainsFile(list, skillPath, "SKILL.md")) {
@@ -3138,7 +3480,7 @@ function toMeta(dir, fm) {
   };
 }
 function countSkillMdDirs(containerDir, list = makeDirLister(), skipDirs) {
-  return list(containerDir).filter((e3) => e3.isDirectory && !(skipDirs?.has(e3.name) ?? false) && dirContainsFile(list, join8(containerDir, e3.name), "SKILL.md")).length;
+  return list(containerDir).filter((e2) => e2.isDirectory && !(skipDirs?.has(e2.name) ?? false) && dirContainsFile(list, join8(containerDir, e2.name), "SKILL.md")).length;
 }
 
 // src/detector/sourceLayout.ts
@@ -3255,7 +3597,7 @@ function shallowerThenCodeUnit(a3, b6) {
 }
 function resolveAgentsContainer(repoRoot, dirs, list, readFm) {
   const score = (absDir) => {
-    const files = list(absDir).filter((e3) => e3.isFile && e3.name.endsWith(".md") && e3.name !== "SKILL.md").map((e3) => e3.name).filter((f2) => isAgentFile(join9(absDir, f2), readFm)).sort();
+    const files = list(absDir).filter((e2) => e2.isFile && e2.name.endsWith(".md") && e2.name !== "SKILL.md").map((e2) => e2.name).filter((f5) => isAgentFile(join9(absDir, f5), readFm)).sort();
     return {
       absDir,
       relPath: toRel(repoRoot, absDir),
@@ -3349,7 +3691,7 @@ function extractServers(parsed) {
   if (entries.length === 0) {
     return null;
   }
-  if (!hasWrapper && !entries.every((e3) => e3 !== null && typeof e3 === "object")) {
+  if (!hasWrapper && !entries.every((e2) => e2 !== null && typeof e2 === "object")) {
     return null;
   }
   return servers;
@@ -3362,10 +3704,10 @@ function classifyServers(servers) {
   if (types.includes("repo-local")) {
     return "repo-local";
   }
-  if (types.every((t2) => t2 === "remote")) {
+  if (types.every((t3) => t3 === "remote")) {
     return "remote";
   }
-  if (types.every((t2) => t2 === "remote" || t2 === "package")) {
+  if (types.every((t3) => t3 === "remote" || t3 === "package")) {
     return "package";
   }
   return "unknown";
@@ -3479,17 +3821,17 @@ function dropTrailingLanguage(name) {
   return parts.join("-");
 }
 function groupByKey(skills, keyOf) {
-  const m2 = new Map;
+  const m4 = new Map;
   for (const s3 of skills) {
-    const k3 = keyOf(s3);
-    const list = m2.get(k3) ?? [];
+    const k5 = keyOf(s3);
+    const list = m4.get(k5) ?? [];
     list.push(s3);
-    m2.set(k3, list);
+    m4.set(k5, list);
   }
-  return m2;
+  return m4;
 }
 function passesGateBounds(groups, total) {
-  return groups.length >= MIN_K && groups.length <= MAX_K && !groups.some((g) => g.skills.length > MAX_FRACTION * total);
+  return groups.length >= MIN_K && groups.length <= MAX_K && !groups.some((g3) => g3.skills.length > MAX_FRACTION * total);
 }
 function normalizeAndGate(rawByKey, total) {
   let groups = [...rawByKey].map(([key, skills]) => ({ key, skills }));
@@ -3501,7 +3843,7 @@ function normalizeAndGate(rawByKey, total) {
   if (!passesGateBounds(groups, total)) {
     return null;
   }
-  return finalizeGroups(groups.map((g) => ({ slug: slugify(g.key), skills: g.skills })));
+  return finalizeGroups(groups.map((g3) => ({ slug: slugify(g3.key), skills: g3.skills })));
 }
 function collapseToFit(groups, maxK) {
   if (groups.length <= maxK) {
@@ -3514,17 +3856,17 @@ function collapseToFit(groups, maxK) {
   return mergeSmallestIntoMisc(collapsed, maxK);
 }
 function collapseByLeadingSegment(groups) {
-  const m2 = new Map;
-  for (const g of groups) {
-    const lead = g.key.split("-")[0] ?? g.key;
-    const list = m2.get(lead) ?? [];
-    list.push(...g.skills);
-    m2.set(lead, list);
+  const m4 = new Map;
+  for (const g3 of groups) {
+    const lead = g3.key.split("-")[0] ?? g3.key;
+    const list = m4.get(lead) ?? [];
+    list.push(...g3.skills);
+    m4.set(lead, list);
   }
-  return [...m2].map(([key, skills]) => ({ key, skills }));
+  return [...m4].map(([key, skills]) => ({ key, skills }));
 }
 function appendToMisc(keep, extra) {
-  const existingMisc = keep.find((g) => g.key === MISC);
+  const existingMisc = keep.find((g3) => g3.key === MISC);
   if (existingMisc !== undefined) {
     existingMisc.skills.push(...extra);
     return [...keep];
@@ -3536,28 +3878,28 @@ function mergeSmallestIntoMisc(groups, maxK) {
   const removeCount = groups.length - maxK + 1;
   const toMerge = sorted.slice(0, removeCount);
   const keep = sorted.slice(removeCount);
-  return appendToMisc(keep, toMerge.flatMap((g) => g.skills));
+  return appendToMisc(keep, toMerge.flatMap((g3) => g3.skills));
 }
 function coalesceTiny(groups, minSize) {
-  const tiny = groups.filter((g) => g.skills.length < minSize);
+  const tiny = groups.filter((g3) => g3.skills.length < minSize);
   if (tiny.length === 0) {
     return [...groups];
   }
-  const big = groups.filter((g) => g.skills.length >= minSize);
-  return appendToMisc(big, tiny.flatMap((g) => g.skills));
+  const big = groups.filter((g3) => g3.skills.length >= minSize);
+  return appendToMisc(big, tiny.flatMap((g3) => g3.skills));
 }
 function finalizeGroups(groups) {
-  const slugs = uniqueSlugs(groups.map((g) => g.slug));
-  return groups.map((g, i3) => ({
-    slug: slugs[i3] ?? g.slug,
-    skills: [...g.skills].sort((a3, b6) => byCodeUnit(a3.dir, b6.dir))
+  const slugs = uniqueSlugs(groups.map((g3) => g3.slug));
+  return groups.map((g3, i3) => ({
+    slug: slugs[i3] ?? g3.slug,
+    skills: [...g3.skills].sort((a3, b6) => byCodeUnit(a3.dir, b6.dir))
   })).sort((a3, b6) => byCodeUnit(a3.slug, b6.slug));
 }
 function acceptRawGroups(groups, total) {
   if (!passesGateBounds(groups, total)) {
     return null;
   }
-  const covered = groups.flatMap((g) => g.skills.map((s3) => s3.dir));
+  const covered = groups.flatMap((g3) => g3.skills.map((s3) => s3.dir));
   if (new Set(covered).size !== covered.length) {
     return null;
   }
@@ -3570,7 +3912,7 @@ function mapRawGroups(skills, raw) {
   const byDir = new Map(skills.map((s3) => [s3.dir, s3]));
   const out = [];
   for (const item of raw) {
-    const gs = item.members.map((m2) => byDir.get(m2)).filter((s3) => s3 !== undefined);
+    const gs = item.members.map((m4) => byDir.get(m4)).filter((s3) => s3 !== undefined);
     if (gs.length > 0) {
       out.push({ slug: slugify(item.slug), skills: gs });
     }
@@ -3578,7 +3920,7 @@ function mapRawGroups(skills, raw) {
   return out;
 }
 function validRawItems(raw) {
-  return raw.filter((g) => safeParse(RawGroupSchema, g).success);
+  return raw.filter((g3) => safeParse(RawGroupSchema, g3).success);
 }
 function gateRaw(skills, raw) {
   return acceptRawGroups(mapRawGroups(skills, raw), skills.length);
@@ -3593,19 +3935,19 @@ function matchMarkerGroups(skills, markerGroups) {
   const fuzzyMatched = [];
   for (const mg of markerGroups) {
     const gs = [];
-    for (const p2 of mg.skills) {
-      const norm = normalizePath2(p2);
+    for (const p3 of mg.skills) {
+      const norm = normalizePath2(p3);
       const exact = byPath.get(norm);
       const s3 = exact ?? byDir.get(basename2(norm));
       if (s3 === undefined) {
-        unmatched.push(p2);
+        unmatched.push(p3);
         continue;
       }
       if (exact === undefined) {
-        fuzzyMatched.push(p2);
+        fuzzyMatched.push(p3);
       }
       if (assigned.has(s3.dir)) {
-        duplicates.push(p2);
+        duplicates.push(p3);
         continue;
       }
       gs.push(s3);
@@ -3620,8 +3962,8 @@ function matchMarkerGroups(skills, markerGroups) {
 function preview(items) {
   return items.slice(0, 3).join(", ") + (items.length > 3 ? ", …" : "");
 }
-function normalizePath2(p2) {
-  return p2.endsWith("/") ? p2 : `${p2}/`;
+function normalizePath2(p3) {
+  return p3.endsWith("/") ? p3 : `${p3}/`;
 }
 var deterministicFns = {
   metadata: partitionByMetadata,
@@ -3883,8 +4225,8 @@ function synthesizeEntryFromDetection(input, caches) {
   if (manifestResult !== null) {
     addManifestFindings(findings, manifestResult.manifest, manifestKindsWithFindings);
   }
-  let mergedFindings = findings.filter((f2) => {
-    if (f2.source === "convention" && manifestKindsWithFindings.has(f2.kind)) {
+  let mergedFindings = findings.filter((f5) => {
+    if (f5.source === "convention" && manifestKindsWithFindings.has(f5.kind)) {
       return false;
     }
     return true;
@@ -3961,7 +4303,7 @@ function buildEntryFromFindings(findings, repoRoot, sourceRepo) {
   const byKind = groupByKind(findings);
   const componentEntries = {};
   for (const [kind, kindFindings] of byKind) {
-    const allPaths = kindFindings.flatMap((f2) => f2.paths);
+    const allPaths = kindFindings.flatMap((f5) => f5.paths);
     const { kept } = normalizePathsAgainstRepo(repoRoot, allPaths);
     if (kept.length > 0) {
       componentEntries[kind] = kept;
@@ -3975,8 +4317,8 @@ function buildEntryFromFindings(findings, repoRoot, sourceRepo) {
   };
 }
 function hasKind(findings, kind) {
-  for (const f2 of findings) {
-    if (f2.kind === kind) {
+  for (const f5 of findings) {
+    if (f5.kind === kind) {
       return true;
     }
   }
@@ -3984,10 +4326,10 @@ function hasKind(findings, kind) {
 }
 function groupByKind(findings) {
   const map = new Map;
-  for (const f2 of findings) {
-    const list = map.get(f2.kind) ?? [];
-    list.push(f2);
-    map.set(f2.kind, list);
+  for (const f5 of findings) {
+    const list = map.get(f5.kind) ?? [];
+    list.push(f5);
+    map.set(f5.kind, list);
   }
   return map;
 }
@@ -4032,7 +4374,7 @@ function buildSplitEntries(groups, layout, skillsContainer, sourceRepo, options)
     entries.push(core.entry);
   }
   const reservedSlugs = core.entry !== null ? ["core"] : [];
-  const slugs = uniqueSlugs([...reservedSlugs, ...groups.map((g) => g.slug)]).slice(reservedSlugs.length);
+  const slugs = uniqueSlugs([...reservedSlugs, ...groups.map((g3) => g3.slug)]).slice(reservedSlugs.length);
   const markerGroups = [];
   groups.forEach((group, i3) => {
     const slug = slugs[i3] ?? group.slug;
@@ -4064,7 +4406,7 @@ function buildUmbrellaEntry(base, groups, layout, skillsContainer, sourceRepo) {
     };
   }
   const artifact = (kind) => layout.artifacts.find((a3) => a3.kind === kind)?.relPath;
-  const skills = groups.flatMap((g) => g.skills).map((s3) => repoRelPath(skillsContainer.relPath, s3.path)).sort(byCodeUnit);
+  const skills = groups.flatMap((g3) => g3.skills).map((s3) => repoRelPath(skillsContainer.relPath, s3.path)).sort(byCodeUnit);
   const agents = layout.agentsContainer;
   const hooks = artifact("hooks");
   const commands = artifact("commands");
@@ -4076,7 +4418,7 @@ function buildUmbrellaEntry(base, groups, layout, skillsContainer, sourceRepo) {
     source: makeGitSubdirSource(sourceRepo, "."),
     strict: false,
     ...skills.length > 0 ? { skills } : {},
-    ...agents !== null ? { agents: agents.files.map((f2) => repoRelPath(agents.relPath, f2)) } : {},
+    ...agents !== null ? { agents: agents.files.map((f5) => repoRelPath(agents.relPath, f5)) } : {},
     ...layout.mcp !== null ? { mcpServers: layout.mcp.servers } : {},
     ...hooks !== undefined ? { hooks: `./${hooks}` } : {},
     ...commands !== undefined ? { commands: [`./${commands}/`] } : {},
@@ -4085,8 +4427,8 @@ function buildUmbrellaEntry(base, groups, layout, skillsContainer, sourceRepo) {
     ...monitors !== undefined ? { monitors: `./${monitors}` } : {}
   };
 }
-function repoRelPath(containerRel, p2) {
-  const inner = p2.startsWith("./") ? p2.slice(2) : p2;
+function repoRelPath(containerRel, p3) {
+  const inner = p3.startsWith("./") ? p3.slice(2) : p3;
   return containerRel === "." ? `./${inner}` : `./${containerRel}/${inner}`;
 }
 function buildCoreEntry(name, layout, skillsContainer, sourceRepo) {
@@ -4105,7 +4447,7 @@ function buildCoreEntry(name, layout, skillsContainer, sourceRepo) {
       name,
       source: makeGitSubdirSource(sourceRepo, rootPath),
       strict: false,
-      ...carriesAgents ? { agents: agents.files.map((f2) => `./${f2}`) } : {},
+      ...carriesAgents ? { agents: agents.files.map((f5) => `./${f5}`) } : {},
       ...mcp !== null ? { mcpServers: mcp.servers } : {}
     },
     agentsDropped: agents !== null && !carriesAgents
@@ -4158,12 +4500,12 @@ function collectEntries(path, options = {}) {
     });
   };
   if (statSync3(path).isDirectory()) {
-    const files = readdirSync3(path).filter((f2) => f2.endsWith(".json")).sort();
+    const files = readdirSync3(path).filter((f5) => f5.endsWith(".json")).sort();
     if (files.length === 0 && options.allowEmptyDir !== true) {
       throw new Error(`No entry JSON files (*.json) found in directory: ${path}`);
     }
-    for (const f2 of files) {
-      add(readJsonFile(join10(path, f2)), f2);
+    for (const f5 of files) {
+      add(readJsonFile(join10(path, f5)), f5);
     }
   } else {
     add(readJsonFile(path), basename3(path));
@@ -4231,7 +4573,7 @@ function parseClusterResponse(text, validDirs) {
       if (!r2.success) {
         continue;
       }
-      const members = r2.output.members.filter((m2) => validDirs.has(m2));
+      const members = r2.output.members.filter((m4) => validDirs.has(m4));
       if (members.length > 0) {
         groups.push({ slug: r2.output.slug, members });
       }
@@ -4288,8 +4630,8 @@ function spawnGroupRun(command, args, options) {
         detached: !win,
         windowsVerbatimArguments: win
       });
-    } catch (e3) {
-      resolve2({ error: e3 instanceof Error ? e3 : new Error(String(e3)), signal: null, status: null, stdout: null });
+    } catch (e2) {
+      resolve2({ error: e2 instanceof Error ? e2 : new Error(String(e2)), signal: null, status: null, stdout: null });
       return;
     }
     let stdout = "";
@@ -4342,8 +4684,8 @@ function spawnGroupRun(command, args, options) {
         return;
       }
       settled = true;
-      for (const t2 of timers) {
-        clearTimeout(t2);
+      for (const t3 of timers) {
+        clearTimeout(t3);
       }
       if (!win || timedOut || overflowed || viaExitGrace || result.error !== undefined) {
         killTree("SIGKILL");
@@ -4353,9 +4695,9 @@ function spawnGroupRun(command, args, options) {
       resolve2(result);
     };
     const schedule = (fn, ms) => {
-      const t2 = setTimeout(fn, ms);
-      t2.unref();
-      timers.push(t2);
+      const t3 = setTimeout(fn, ms);
+      t3.unref();
+      timers.push(t3);
     };
     schedule(() => {
       timedOut = true;
@@ -4531,7 +4873,7 @@ function writeCacheFile(file, groups) {
 }
 
 // src/commands/scan.ts
-var scanCommand = new R2("scan").meta({ description: "Scan a non-plugin repo and emit a marketplace entry (auto-splits bloated plugins)" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo, URL, or local path" }]).flags({
+var scanCommand = new M2("scan").meta({ description: "Scan a non-plugin repo and emit a marketplace entry (auto-splits bloated plugins)" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo, URL, or local path" }]).flags({
   output: { type: "string", short: "o", description: "Write the entry/entries JSON to a single file" },
   outDir: { type: "string", aliases: ["out-dir"], description: "Write one JSON file per entry into this directory" },
   split: { type: "boolean", default: true, description: "Auto-split bloated plugins (use --no-split to force one entry)" },
@@ -4568,9 +4910,9 @@ var scanCommand = new R2("scan").meta({ description: "Scan a non-plugin repo and
       try {
         lstatSync(outputFlags.outDir);
         throw new Error(`--out-dir "${outputFlags.outDir}" is a dangling symlink`);
-      } catch (e3) {
-        if (e3 instanceof Error && e3.message.includes("dangling symlink")) {
-          throw e3;
+      } catch (e2) {
+        if (e2 instanceof Error && e2.message.includes("dangling symlink")) {
+          throw e2;
         }
       }
     }
@@ -4717,13 +5059,13 @@ function printNoSplitNotice(requestedCluster, llmFailure) {
   const reason = llmFailure !== undefined ? `${llmFailureReason(llmFailure)}, and no clean deterministic partition` : "no clean deterministic partition";
   console.error(`ccpluginizer: --cluster=${requestedCluster} produced no split — ${reason}; emitting a single entry.`);
 }
-async function reviewSplit(result, ctx, confirmFn = (opts) => wJ(opts)) {
+async function reviewSplit(result, ctx, confirmFn = (opts) => VJ(opts)) {
   if (result.split === null || result.provenance.kind === "none" || result.provenance.kind === "skipped") {
     return result;
   }
   console.error(`ccpluginizer: proposed split — ${describeProvenance(result.provenance)}`);
-  for (const g of result.marker?.groups ?? []) {
-    console.error(`  ${g.slug}: ${String(g.skills.length)} skills`);
+  for (const g3 of result.marker?.groups ?? []) {
+    console.error(`  ${g3.slug}: ${String(g3.skills.length)} skills`);
   }
   const proceed = await confirmFn({
     message: `Emit this ${String(result.split.groupCount)}-way split?`,
@@ -4769,11 +5111,11 @@ function warnAboutStaleEntries(entries, outDir, sourceRepo) {
   if (sourceRepo.startsWith("local/")) {
     return;
   }
-  const current = new Set(entries.map((e3) => `${e3.name}.json`));
+  const current = new Set(entries.map((e2) => `${e2.name}.json`));
   const expectedUrl = sourceRepoUrl(sourceRepo);
-  const stale = readdirSync4(outDir).filter((f2) => f2.endsWith(".json") && !current.has(f2)).filter((f2) => {
+  const stale = readdirSync4(outDir).filter((f5) => f5.endsWith(".json") && !current.has(f5)).filter((f5) => {
     try {
-      return entryReferencesUrl(readJsonFile(join12(outDir, f2)), expectedUrl);
+      return entryReferencesUrl(readJsonFile(join12(outDir, f5)), expectedUrl);
     } catch {
       return false;
     }
@@ -4793,7 +5135,7 @@ function entryReferencesUrl(parsed, url) {
 }
 
 // src/commands/validate.ts
-var validateCommand = new R2("validate").meta({ description: "Validate marketplace entries against the schema (file, JSON array, or directory)" }).args([
+var validateCommand = new M2("validate").meta({ description: "Validate marketplace entries against the schema (file, JSON array, or directory)" }).args([
   { name: "entryFile", type: "string", required: true, description: "Path to an entry JSON file, a JSON array, or a directory of entries" }
 ]).run(({ args }) => {
   const { items, sources } = collectEntries(args.entryFile);
@@ -4809,5 +5151,5 @@ var validateCommand = new R2("validate").meta({ description: "Validate marketpla
 });
 
 // src/index.ts
-var app = new R("ccpluginizer").meta({ description: "Pluginize non-plugin Claude Code repos" }).command(scanCommand).command(validateCommand);
+var app = new M("ccpluginizer").meta({ description: "Pluginize non-plugin Claude Code repos" }).command(scanCommand).command(validateCommand);
 await app.execute();