@reliverse/dler 1.7.153 → 2.0.0

package/cli.js

@@ -0,0 +1,1316 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/launcher/src/mod.ts
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+// packages/helpers/src/impl/write.ts
+var textEncoder = new TextEncoder;
+var writeErrorLines = (lines) => {
+  const buffer = new Array(lines.length + 1);
+  for (let i = 0;i < lines.length; i++) {
+    buffer[i] = lines[i];
+  }
+  buffer[lines.length] = "";
+  const encoded = textEncoder.encode(buffer.join(`
+`));
+  Bun.write(Bun.stderr, encoded);
+};
+// packages/colors/src/mod.ts
+var RESET = "\x1B[0m";
+var OP_SYMBOL = Symbol("re.ops");
+var COLOR_LEVEL_OFF = 0;
+var COLOR_LEVEL_BASIC = 1;
+var COLOR_LEVEL_256 = 2;
+var COLOR_LEVEL_TRUECOLOR = 3;
+var MIN_BYTE = 0;
+var MAX_BYTE = 255;
+var WHITE_RGB = 255;
+var ANSI_256_GRAYSCALE_MIN = 8;
+var ANSI_256_GRAYSCALE_MAX = 248;
+var ANSI_256_BASE_OFFSET = 16;
+var ANSI_256_GRAYSCALE_BASE = 232;
+var ANSI_256_GRAYSCALE_RANGE = 247;
+var ANSI_256_GRAYSCALE_STEPS = 24;
+var ANSI_256_BRIGHT_THRESHOLD = 231;
+var ANSI_256_RGB_LEVELS = 5;
+var ANSI_256_RGB_RED_MULTIPLIER = 36;
+var ANSI_256_RGB_GREEN_MULTIPLIER = 6;
+var SGR_FG_BASE = 30;
+var SGR_BG_BASE = 40;
+var SGR_FG_BRIGHT_BASE = 90;
+var SGR_BG_BRIGHT_BASE = 100;
+var SGR_RESET = 0;
+var SGR_BOLD = 1;
+var SGR_DIM = 2;
+var SGR_ITALIC = 3;
+var SGR_UNDERLINE = 4;
+var SGR_INVERSE = 7;
+var SGR_HIDDEN = 8;
+var SGR_STRIKETHROUGH = 9;
+var HEX_RADIX = 16;
+var BRIGHT_SUFFIX_LENGTH = 6;
+var BG_PREFIX_LENGTH = 2;
+var BRIGHT_MIX_FACTOR = 0.25;
+var BRIGHT_SUFFIX = "Bright";
+var IS_BUN = typeof process !== "undefined" && process.versions?.bun !== undefined && typeof Bun !== "undefined" && typeof Bun.color === "function";
+var CURRENT_LEVEL = COLOR_LEVEL_TRUECOLOR;
+var clampByte = (n) => {
+  if (n <= MIN_BYTE || !Number.isFinite(n))
+    return MIN_BYTE;
+  if (n >= MAX_BYTE)
+    return MAX_BYTE;
+  return Math.round(n);
+};
+var BASIC8 = Object.freeze([
+  Object.freeze({ r: 0, g: 0, b: 0 }),
+  Object.freeze({ r: 205, g: 0, b: 0 }),
+  Object.freeze({ r: 0, g: 205, b: 0 }),
+  Object.freeze({ r: 205, g: 205, b: 0 }),
+  Object.freeze({ r: 0, g: 0, b: 238 }),
+  Object.freeze({ r: 205, g: 0, b: 205 }),
+  Object.freeze({ r: 0, g: 205, b: 205 }),
+  Object.freeze({ r: 229, g: 229, b: 229 })
+]);
+var sgrCache = new Map;
+var sgr = (codes) => {
+  if (codes.length === 1) {
+    const code = codes[0];
+    const cached2 = sgrCache.get(String(code));
+    if (cached2)
+      return cached2;
+    const seq2 = `\x1B[${code}m`;
+    sgrCache.set(String(code), seq2);
+    return seq2;
+  }
+  const key = codes.join(";");
+  const cached = sgrCache.get(key);
+  if (cached)
+    return cached;
+  const seq = `\x1B[${key}m`;
+  sgrCache.set(key, seq);
+  return seq;
+};
+var nearestBasicIndex = (rgb) => {
+  if (IS_BUN) {
+    const ansiStr = Bun.color(rgb, "ansi-16");
+    if (ansiStr) {
+      const match = ansiStr.match(/38;5;(\d+)/);
+      if (match?.[1]) {
+        return Number.parseInt(match[1], 10) & 7;
+      }
+    }
+  }
+  let best = 0;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (let i = 0;i < 8; i++) {
+    const c = BASIC8[i];
+    const dr = c.r - rgb.r;
+    const dg = c.g - rgb.g;
+    const db = c.b - rgb.b;
+    if (dr === 0 && dg === 0 && db === 0)
+      return i;
+    const d = dr * dr + dg * dg + db * db;
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best;
+};
+var rgbToAnsi256 = (rgb) => {
+  if (IS_BUN) {
+    const ansiStr = Bun.color(rgb, "ansi-256");
+    if (ansiStr) {
+      const match = ansiStr.match(/38;5;(\d+)/);
+      if (match?.[1]) {
+        return Number.parseInt(match[1], 10);
+      }
+    }
+  }
+  if (rgb.r === rgb.g && rgb.g === rgb.b) {
+    if (rgb.r < ANSI_256_GRAYSCALE_MIN)
+      return ANSI_256_BASE_OFFSET;
+    if (rgb.r > ANSI_256_GRAYSCALE_MAX)
+      return ANSI_256_BRIGHT_THRESHOLD;
+    const step = Math.round((rgb.r - ANSI_256_GRAYSCALE_MIN) / ANSI_256_GRAYSCALE_RANGE * ANSI_256_GRAYSCALE_STEPS);
+    return ANSI_256_GRAYSCALE_BASE + step;
+  }
+  const r = (rgb.r * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE | 0;
+  const g = (rgb.g * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE | 0;
+  const b = (rgb.b * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE | 0;
+  return ANSI_256_BASE_OFFSET + r * ANSI_256_RGB_RED_MULTIPLIER + g * ANSI_256_RGB_GREEN_MULTIPLIER + b;
+};
+var NAMED_COLORS = {
+  black: "#000000",
+  red: "#ff0000",
+  green: "#00ff00",
+  yellow: "#ffff00",
+  blue: "#0000ff",
+  magenta: "#ff00ff",
+  cyan: "#00ffff",
+  white: "#ffffff",
+  gray: "#808080",
+  orange: "#ffa500",
+  pink: "#ffc0cb",
+  purple: "#800080",
+  teal: "#008080",
+  lime: "#00ff00",
+  brown: "#a52a2a",
+  navy: "#000080",
+  maroon: "#800000",
+  olive: "#808000",
+  silver: "#c0c0c0"
+};
+var rgbCache = new Map;
+for (const name of ["black", "white", "red", "green", "blue"]) {
+  const hex = NAMED_COLORS[name];
+  if (hex) {
+    const clean = hex.slice(1);
+    const r = Number.parseInt(clean.slice(0, 2), HEX_RADIX);
+    const g = Number.parseInt(clean.slice(2, 4), HEX_RADIX);
+    const b = Number.parseInt(clean.slice(4, 6), HEX_RADIX);
+    rgbCache.set(name, Object.freeze({ r, g, b }));
+  }
+}
+var mixWithWhite = (rgb, factor) => {
+  const invFactor = 1 - factor;
+  return {
+    r: clampByte(rgb.r * invFactor + WHITE_RGB * factor),
+    g: clampByte(rgb.g * invFactor + WHITE_RGB * factor),
+    b: clampByte(rgb.b * invFactor + WHITE_RGB * factor)
+  };
+};
+var fromNamed = (name) => {
+  const cached = rgbCache.get(name);
+  if (cached)
+    return cached;
+  const hex = NAMED_COLORS[name];
+  if (!hex)
+    return { r: 0, g: 0, b: 0 };
+  if (IS_BUN) {
+    const rgb = Bun.color(hex, "{rgb}");
+    if (rgb) {
+      rgbCache.set(name, rgb);
+      return rgb;
+    }
+  }
+  const clean = hex[0] === "#" ? hex.slice(1) : hex;
+  const len = clean.length;
+  let r, g, b;
+  if (len === 3) {
+    const rv = Number.parseInt(clean[0], HEX_RADIX);
+    const gv = Number.parseInt(clean[1], HEX_RADIX);
+    const bv = Number.parseInt(clean[2], HEX_RADIX);
+    r = rv << 4 | rv;
+    g = gv << 4 | gv;
+    b = bv << 4 | bv;
+  } else if (len === 6) {
+    r = Number.parseInt(clean.slice(0, 2), HEX_RADIX);
+    g = Number.parseInt(clean.slice(2, 4), HEX_RADIX);
+    b = Number.parseInt(clean.slice(4, 6), HEX_RADIX);
+  } else {
+    return { r: 0, g: 0, b: 0 };
+  }
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
+    return { r: 0, g: 0, b: 0 };
+  }
+  const result = Object.freeze({ r, g, b });
+  rgbCache.set(name, result);
+  return result;
+};
+var toBaseName = (compound) => {
+  if (!compound)
+    return "black";
+  const base = compound.slice(0, -BRIGHT_SUFFIX_LENGTH);
+  if (!base)
+    return "black";
+  return base[0].toLowerCase() + base.slice(1);
+};
+var parseColorName = (name) => {
+  if (!name)
+    return { rgb: { r: 0, g: 0, b: 0 }, wantBright: false };
+  if (name.endsWith(BRIGHT_SUFFIX)) {
+    const base = toBaseName(name);
+    const rgb = fromNamed(base);
+    const rgbAdj = mixWithWhite(rgb, BRIGHT_MIX_FACTOR);
+    return { rgb: rgbAdj, wantBright: true };
+  }
+  return { rgb: fromNamed(name), wantBright: false };
+};
+var openForOp = (op) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF)
+    return "";
+  switch (op.kind) {
+    case "style":
+      return sgr(op.open);
+    case "fg-basic": {
+      const code = (op.bright ? SGR_FG_BRIGHT_BASE : SGR_FG_BASE) + op.idx;
+      return sgr([code]);
+    }
+    case "bg-basic": {
+      const code = (op.bright ? SGR_BG_BRIGHT_BASE : SGR_BG_BASE) + op.idx;
+      return sgr([code]);
+    }
+    case "fg-256": {
+      if (IS_BUN) {
+        const ansi = Bun.color(op.code, "ansi-256");
+        if (ansi)
+          return ansi;
+      }
+      return `\x1B[38;5;${op.code}m`;
+    }
+    case "bg-256": {
+      if (IS_BUN) {
+        const fgAnsi = Bun.color(op.code, "ansi-256");
+        if (fgAnsi)
+          return fgAnsi.replace("38;5;", "48;5;");
+      }
+      return `\x1B[48;5;${op.code}m`;
+    }
+    case "fg-true": {
+      if (IS_BUN) {
+        const ansi = Bun.color(op.rgb, "ansi-16m");
+        if (ansi)
+          return ansi;
+      }
+      const { r, g, b } = op.rgb;
+      return `\x1B[38;2;${r};${g};${b}m`;
+    }
+    case "bg-true": {
+      if (IS_BUN) {
+        const fgAnsi = Bun.color(op.rgb, "ansi-16m");
+        if (fgAnsi)
+          return fgAnsi.replace("38;2;", "48;2;");
+      }
+      const { r, g, b } = op.rgb;
+      return `\x1B[48;2;${r};${g};${b}m`;
+    }
+    default:
+      return "";
+  }
+};
+var opsToOpen = (ops) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF)
+    return "";
+  const len = ops.length;
+  if (len === 0)
+    return "";
+  if (len === 1)
+    return openForOp(ops[0]);
+  let result = "";
+  for (let i = 0;i < len; i++) {
+    result += openForOp(ops[i]);
+  }
+  return result;
+};
+var applyOpsToText = (ops, input) => {
+  const text = String(input);
+  const textLen = text.length;
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF || ops.length === 0 || textLen === 0) {
+    return text;
+  }
+  const open = opsToOpen(ops);
+  if (!open)
+    return text;
+  const nlIdx = text.indexOf(`
+`);
+  if (nlIdx === -1) {
+    return `${open}${text}${RESET}`;
+  }
+  let result = "";
+  let start = 0;
+  while (start < textLen) {
+    const end = text.indexOf(`
+`, start);
+    if (end === -1) {
+      const line2 = text.slice(start);
+      if (line2) {
+        if (line2.endsWith("\r")) {
+          result += `${open}${line2.slice(0, -1)}\r${RESET}`;
+        } else {
+          result += `${open}${line2}${RESET}`;
+        }
+      }
+      break;
+    }
+    if (start > 0)
+      result += `
+`;
+    const line = text.slice(start, end);
+    if (line) {
+      if (line.endsWith("\r")) {
+        result += `${open}${line.slice(0, -1)}\r${RESET}`;
+      } else {
+        result += `${open}${line}${RESET}`;
+      }
+    } else {
+      result += `${open}${RESET}`;
+    }
+    start = end + 1;
+  }
+  return result;
+};
+var mkFgOpsFromRgb = (rgb, wantBright = false) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
+    return [
+      { kind: "fg-basic", idx: nearestBasicIndex(rgb), bright: wantBright }
+    ];
+  }
+  if (CURRENT_LEVEL === COLOR_LEVEL_256) {
+    return [{ kind: "fg-256", code: rgbToAnsi256(rgb) }];
+  }
+  return [{ kind: "fg-true", rgb }];
+};
+var mkBgOpsFromRgb = (rgb, wantBright = false) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
+    return [
+      { kind: "bg-basic", idx: nearestBasicIndex(rgb), bright: wantBright }
+    ];
+  }
+  if (CURRENT_LEVEL === COLOR_LEVEL_256) {
+    return [{ kind: "bg-256", code: rgbToAnsi256(rgb) }];
+  }
+  return [{ kind: "bg-true", rgb }];
+};
+var STYLE_TABLE = {
+  reset: Object.freeze({ kind: "style", open: [SGR_RESET] }),
+  bold: Object.freeze({ kind: "style", open: [SGR_BOLD] }),
+  dim: Object.freeze({ kind: "style", open: [SGR_DIM] }),
+  italic: Object.freeze({ kind: "style", open: [SGR_ITALIC] }),
+  underline: Object.freeze({ kind: "style", open: [SGR_UNDERLINE] }),
+  inverse: Object.freeze({ kind: "style", open: [SGR_INVERSE] }),
+  hidden: Object.freeze({ kind: "style", open: [SGR_HIDDEN] }),
+  strikethrough: Object.freeze({ kind: "style", open: [SGR_STRIKETHROUGH] })
+};
+var STYLE_KEYS = Object.freeze(new Set([
+  "reset",
+  "bold",
+  "dim",
+  "italic",
+  "underline",
+  "inverse",
+  "hidden",
+  "strikethrough"
+]));
+var COLOR_KEYS = Object.freeze(new Set(Object.keys(NAMED_COLORS)));
+var BRIGHT_COLOR_KEYS = Object.freeze(new Set(Object.keys(NAMED_COLORS).map((name) => `${name}Bright`)));
+var BG_COLOR_KEYS = Object.freeze(new Set(Object.keys(NAMED_COLORS).map((name) => `bg${name[0].toUpperCase()}${name.slice(1)}`)));
+var BG_BRIGHT_COLOR_KEYS = Object.freeze(new Set(Object.keys(NAMED_COLORS).map((name) => `bg${name[0].toUpperCase()}${name.slice(1)}Bright`)));
+var isColorKey = (key) => COLOR_KEYS.has(key) || BRIGHT_COLOR_KEYS.has(key);
+var isBgKey = (key) => {
+  const len = key.length;
+  if (len <= BG_PREFIX_LENGTH || key[0] !== "b" || key[1] !== "g") {
+    return false;
+  }
+  return BG_COLOR_KEYS.has(key) || BG_BRIGHT_COLOR_KEYS.has(key);
+};
+var proxyCache = new WeakMap;
+var callableProxy = (ops) => {
+  const cached = proxyCache.get(ops);
+  if (cached)
+    return cached;
+  const base = (input) => applyOpsToText(ops, input);
+  Object.defineProperty(base, OP_SYMBOL, {
+    value: ops,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  const proxy = new Proxy(base, {
+    apply(_target, _thisArg, argArray) {
+      return applyOpsToText(ops, argArray[0]);
+    },
+    get(_target, prop) {
+      if (prop === OP_SYMBOL)
+        return ops;
+      const key = String(prop);
+      if (STYLE_KEYS.has(key)) {
+        const op = STYLE_TABLE[key];
+        const newOps = [...ops, op];
+        return callableProxy(newOps);
+      }
+      if (isBgKey(key)) {
+        const colorName = key[2].toLowerCase() + key.slice(3);
+        const { rgb, wantBright } = parseColorName(colorName);
+        const bgOps = mkBgOpsFromRgb(rgb, wantBright);
+        const newOps = [...ops, ...bgOps];
+        return callableProxy(newOps);
+      }
+      if (isColorKey(key)) {
+        const { rgb, wantBright } = parseColorName(key);
+        const fgOps = mkFgOpsFromRgb(rgb, wantBright);
+        const newOps = [...ops, ...fgOps];
+        return callableProxy(newOps);
+      }
+      return proxy;
+    }
+  });
+  proxyCache.set(ops, proxy);
+  return proxy;
+};
+var re = callableProxy([]);
+
+// packages/logger/src/mod.ts
+var textEncoder2 = new TextEncoder;
+var LOG_COLORS = {
+  log: re.white,
+  error: re.red,
+  warn: re.yellow,
+  info: re.blue,
+  success: re.green,
+  debug: re.gray
+};
+var LOG_SYMBOLS = {
+  log: "\u2502  ",
+  error: "\u2716  ",
+  warn: "\u26A0  ",
+  info: "\u25A0  ",
+  success: "\u2713  ",
+  debug: "\u2731  "
+};
+var writeLock = Promise.resolve();
+var formatMessage = (...args) => args.map(String).join(" ");
+var createPrefixedMessage = (level, message) => `${LOG_SYMBOLS[level]}${message}`;
+var writeAsync = async (text, isError = false) => {
+  const encoded = textEncoder2.encode(`${text}
+`);
+  await writeLock;
+  writeLock = Bun.write(isError ? Bun.stderr : Bun.stdout, encoded).then(() => {});
+  await writeLock;
+};
+var writeSync = (text, isError = false) => {
+  const encoded = textEncoder2.encode(`${text}
+`);
+  (isError ? process.stderr : process.stdout).write(encoded);
+};
+var writeColoredAsync = async (text, color, isError = false) => {
+  const coloredText = color(text);
+  await writeAsync(coloredText, isError);
+};
+var writeColoredSync = (text, color, isError = false) => {
+  const coloredText = color(text);
+  writeSync(coloredText, isError);
+};
+function createLogMethod(level, isAsync, isError = false) {
+  if (isAsync) {
+    return async (...args) => {
+      const message = formatMessage(...args);
+      const prefixedMessage = createPrefixedMessage(level, message);
+      await writeColoredAsync(prefixedMessage, LOG_COLORS[level], isError);
+    };
+  }
+  return (...args) => {
+    const message = formatMessage(...args);
+    const prefixedMessage = createPrefixedMessage(level, message);
+    writeColoredSync(prefixedMessage, LOG_COLORS[level], isError);
+  };
+}
+function createRawMethod(isAsync) {
+  if (isAsync) {
+    return async (...args) => {
+      const message = formatMessage(...args);
+      await writeAsync(message);
+    };
+  }
+  return (...args) => {
+    const message = formatMessage(...args);
+    writeSync(message);
+  };
+}
+var loggerAsync = {
+  log: createLogMethod("log", true),
+  error: createLogMethod("error", true, true),
+  warn: createLogMethod("warn", true),
+  info: createLogMethod("info", true),
+  success: createLogMethod("success", true),
+  debug: createLogMethod("debug", true),
+  raw: createRawMethod(true)
+};
+var logger = {
+  log: createLogMethod("log", false),
+  error: createLogMethod("error", false, true),
+  warn: createLogMethod("warn", false),
+  info: createLogMethod("info", false),
+  success: createLogMethod("success", false),
+  debug: createLogMethod("debug", false),
+  raw: createRawMethod(false)
+};
+
+// packages/mapper/src/mod.ts
+var pMapSkip = Symbol("skip");
+async function pMap(input, mapper, options = {}) {
+  const {
+    concurrency = Number.POSITIVE_INFINITY,
+    stopOnError = true,
+    signal
+  } = options;
+  if (!("Symbol" in globalThis) || input[Symbol.iterator] === undefined && input[Symbol.asyncIterator] === undefined) {
+    throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, ` + `got (${typeof input})`);
+  }
+  if (typeof mapper !== "function") {
+    throw new TypeError("Mapper function is required");
+  }
+  if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or ` + `\`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+  }
+  return new Promise((resolve, reject) => {
+    const iterator = input[Symbol.asyncIterator] !== undefined ? input[Symbol.asyncIterator]() : input[Symbol.iterator]();
+    const results = [];
+    const errors = [];
+    let activeCount = 0;
+    let currentIndex = 0;
+    let isIterableDone = false;
+    let isSettled = false;
+    let isPumping = false;
+    let iteratorClosed = false;
+    const safeCloseIterator = async () => {
+      if (iteratorClosed)
+        return;
+      const ret = iterator?.return;
+      if (typeof ret === "function") {
+        try {
+          iteratorClosed = true;
+          await ret.call(iterator);
+        } catch {}
+      } else {
+        iteratorClosed = true;
+      }
+    };
+    const onAbort = () => {
+      if (isSettled)
+        return;
+      isSettled = true;
+      safeCloseIterator();
+      cleanup();
+      reject(signal.reason);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    function cleanup() {
+      signal?.removeEventListener("abort", onAbort);
+    }
+    function settleWithAggregateIfNeeded() {
+      if (errors.length > 0 && !stopOnError) {
+        cleanup();
+        reject(new AggregateError(errors, "One or more promises rejected"));
+        return true;
+      }
+      return false;
+    }
+    function resolveResults() {
+      cleanup();
+      const out = [];
+      for (let i = 0;i < results.length; i++) {
+        const v = results[i];
+        if (v !== undefined && v !== pMapSkip) {
+          out.push(v);
+        }
+      }
+      resolve(out);
+    }
+    function checkCompletion() {
+      if (isSettled)
+        return;
+      if (!isIterableDone)
+        return;
+      if (activeCount > 0)
+        return;
+      isSettled = true;
+      if (settleWithAggregateIfNeeded()) {
+        return;
+      }
+      resolveResults();
+    }
+    async function startMapper(valueOrPromise, index) {
+      try {
+        const item = await valueOrPromise;
+        const result = await mapper(item, index);
+        if (!isSettled) {
+          results[index] = result;
+        }
+      } catch (error) {
+        if (isSettled)
+          return;
+        if (stopOnError) {
+          isSettled = true;
+          safeCloseIterator();
+          cleanup();
+          reject(error);
+          return;
+        }
+        errors.push(error);
+      } finally {
+        if (!isSettled) {
+          activeCount--;
+          checkCompletion();
+          pump();
+        }
+      }
+    }
+    async function pump() {
+      if (isSettled || isPumping)
+        return;
+      isPumping = true;
+      try {
+        while (!isSettled && !isIterableDone && activeCount < concurrency) {
+          let next;
+          try {
+            next = iterator.next();
+            next = await next;
+          } catch (error) {
+            if (!isSettled) {
+              isSettled = true;
+              safeCloseIterator();
+              cleanup();
+              reject(error);
+            }
+            return;
+          }
+          if (next.done) {
+            isIterableDone = true;
+            break;
+          }
+          const index = currentIndex++;
+          activeCount++;
+          startMapper(next.value, index);
+        }
+        checkCompletion();
+      } finally {
+        isPumping = false;
+      }
+    }
+    pump();
+  });
+}
+
+// packages/launcher/src/impl/discovery.ts
+var {Glob } = globalThis.Bun;
+
+// packages/launcher/src/impl/cache.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CACHE_VERSION = "1.0.0";
+var CACHE_DIR = ".reliverse/dler/cache/launcher";
+var CACHE_FILE = "metadata.json";
+var getCachePath = () => {
+  const homeDir = homedir();
+  const cacheDir = join(homeDir, CACHE_DIR);
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+  return join(cacheDir, CACHE_FILE);
+};
+var isCacheValid = async (entry) => {
+  try {
+    const file = Bun.file(entry.filePath);
+    const stats = await file.stat();
+    return entry.mtime === stats.mtime.getTime() && entry.size === stats.size;
+  } catch {
+    return false;
+  }
+};
+var loadMetadataCache = async () => {
+  const cachePath = getCachePath();
+  if (!existsSync(cachePath)) {
+    return null;
+  }
+  try {
+    const cacheFile = Bun.file(cachePath);
+    const cacheData = await cacheFile.json();
+    if (cacheData.version !== CACHE_VERSION) {
+      return null;
+    }
+    const results = await pMap(Object.entries(cacheData.entries), async ([cmdName, entry]) => ({
+      cmdName,
+      metadata: await isCacheValid(entry) ? entry.metadata : null
+    }), { concurrency: 20 });
+    const metadataMap = new Map;
+    for (const { cmdName, metadata } of results) {
+      if (metadata) {
+        metadataMap.set(cmdName, metadata);
+      }
+    }
+    return metadataMap.size > 0 ? metadataMap : null;
+  } catch {
+    return null;
+  }
+};
+var saveMetadataCache = async (metadata, fileStats, filePaths) => {
+  const cachePath = getCachePath();
+  const entries = {};
+  for (const [cmdName, cmdMetadata] of metadata) {
+    const stats = fileStats.get(cmdName);
+    const filePath = filePaths.get(cmdName);
+    if (stats && filePath) {
+      entries[cmdName] = {
+        metadata: cmdMetadata,
+        filePath,
+        mtime: stats.mtime,
+        size: stats.size
+      };
+    }
+  }
+  const cacheData = {
+    entries,
+    version: CACHE_VERSION
+  };
+  await Bun.write(cachePath, JSON.stringify(cacheData, null, 2));
+};
+
+// packages/launcher/src/impl/errors.ts
+class LauncherError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "LauncherError";
+  }
+}
+
+class CommandNotFoundError extends LauncherError {
+  constructor(cmdName, availableCmds) {
+    super(`Command "${cmdName}" not found. Available commands: ${availableCmds.join(", ")}`, "CMD_NOT_FOUND");
+    this.name = "CommandNotFoundError";
+  }
+}
+
+class ArgumentValidationError extends LauncherError {
+  argName;
+  reason;
+  constructor(argName, reason) {
+    super(`Invalid argument "${argName}": ${reason}`, "ARG_VALIDATION_ERROR");
+    this.argName = argName;
+    this.reason = reason;
+    this.name = "ArgumentValidationError";
+  }
+}
+
+class CommandLoadError extends LauncherError {
+  constructor(cmdName, cause) {
+    super(`Failed to load command "${cmdName}"`, "CMD_LOAD_ERROR");
+    this.name = "CommandLoadError";
+    this.cause = cause;
+  }
+}
+
+// packages/launcher/src/impl/discovery.ts
+var fileStatsCache = new Map;
+var moduleCache = new Map;
+var getFileStats = async (filePath) => {
+  const cached = fileStatsCache.get(filePath);
+  if (cached)
+    return cached;
+  const stats = await Bun.file(filePath).stat();
+  const result = { mtime: stats.mtime.getTime(), size: stats.size };
+  fileStatsCache.set(filePath, result);
+  return result;
+};
+var createLazyMetadataLoader = (filePath, cmdName) => {
+  let cachedMetadata = null;
+  let isLoading = false;
+  let loadPromise = null;
+  return async () => {
+    if (cachedMetadata)
+      return cachedMetadata;
+    if (isLoading && loadPromise) {
+      return loadPromise;
+    }
+    isLoading = true;
+    loadPromise = (async () => {
+      try {
+        const module = await import(filePath);
+        const definition = module.default;
+        if (!definition || !definition.cfg) {
+          throw new Error("Invalid command definition");
+        }
+        const cmdMetadata = {
+          name: definition.cfg.name,
+          description: definition.cfg.description,
+          aliases: definition.cfg.aliases,
+          version: definition.cfg.version,
+          examples: definition.cfg.examples
+        };
+        cachedMetadata = cmdMetadata;
+        return cmdMetadata;
+      } catch (error) {
+        throw new CommandLoadError(cmdName, error);
+      } finally {
+        isLoading = false;
+        loadPromise = null;
+      }
+    })();
+    return loadPromise;
+  };
+};
+var discoverCommands = async (cmdsDir, baseDir) => {
+  const registry = new Map;
+  const aliases = new Map;
+  const metadata = new Map;
+  const hierarchy = new Map;
+  const rootCommands = new Set;
+  const fileStats = new Map;
+  const filePaths = new Map;
+  const loadedMetadata = new Map;
+  const cachedMetadata = await loadMetadataCache();
+  const cachedMetadataMap = new Map;
+  if (cachedMetadata) {
+    for (const [cmdName, cmdMetadata] of cachedMetadata) {
+      cachedMetadataMap.set(cmdName, cmdMetadata);
+    }
+  }
+  const glob = new Glob("**/cmd.ts");
+  const cwd = baseDir ? `${baseDir}/${cmdsDir}` : `${process.cwd()}/${cmdsDir}`;
+  const files = await Array.fromAsync(glob.scan(cwd));
+  const fileData = await pMap(files, async (file) => {
+    const pathParts = file.split(/[/\\]/);
+    const cmdName = pathParts[pathParts.length - 2];
+    const filePath = `${cwd}/${file}`;
+    const stats = await getFileStats(filePath);
+    const depth = pathParts.length - 1;
+    const parent = depth > 1 ? pathParts[0] : undefined;
+    const fullPath = pathParts.slice(0, -1).join("/");
+    return {
+      cmdName,
+      filePath,
+      stats,
+      file,
+      depth,
+      parent,
+      fullPath
+    };
+  }, { concurrency: 10 });
+  for (const {
+    cmdName,
+    filePath,
+    stats,
+    depth,
+    parent,
+    fullPath
+  } of fileData) {
+    const loader = async () => {
+      if (moduleCache.has(filePath)) {
+        return moduleCache.get(filePath);
+      }
+      try {
+        const module = await import(filePath);
+        const definition = module.default;
+        if (!definition || typeof definition.handler !== "function") {
+          throw new Error("Invalid command definition");
+        }
+        moduleCache.set(filePath, definition);
+        return definition;
+      } catch (error) {
+        throw new CommandLoadError(cmdName, error);
+      }
+    };
+    fileStats.set(cmdName, stats);
+    filePaths.set(cmdName, filePath);
+    const cachedMeta = cachedMetadataMap.get(cmdName);
+    if (cachedMeta && await isCacheValid2(filePath, stats)) {
+      const lazyMetadataLoader = () => Promise.resolve(cachedMeta);
+      metadata.set(cmdName, lazyMetadataLoader);
+      loadedMetadata.set(cmdName, cachedMeta);
+      if (cachedMeta.aliases) {
+        for (const alias of cachedMeta.aliases) {
+          aliases.set(alias, cmdName);
+        }
+      }
+    } else {
+      const lazyMetadataLoader = createLazyMetadataLoader(filePath, cmdName);
+      metadata.set(cmdName, lazyMetadataLoader);
+    }
+    registry.set(cmdName, loader);
+    const cmdNode = {
+      name: cmdName,
+      path: fullPath,
+      depth,
+      parent,
+      children: new Map,
+      loader,
+      metadata: metadata.get(cmdName)
+    };
+    hierarchy.set(cmdName, cmdNode);
+    if (depth === 1) {
+      rootCommands.add(cmdName);
+    }
+  }
+  for (const [cmdName, node] of hierarchy) {
+    if (node.parent) {
+      const parentNode = hierarchy.get(node.parent);
+      if (parentNode) {
+        parentNode.children.set(cmdName, node);
+      }
+    }
+  }
+  saveMetadataCache(loadedMetadata, fileStats, filePaths).catch(() => {});
+  return { registry, aliases, metadata, hierarchy, rootCommands };
+};
+var isCacheValid2 = async (filePath, stats) => {
+  try {
+    const file = Bun.file(filePath);
+    const fileStats = await file.stat();
+    return fileStats.mtime.getTime() === stats.mtime && fileStats.size === stats.size;
+  } catch {
+    return false;
+  }
+};
+
+// packages/launcher/src/impl/help.ts
+var HELP_TEMPLATES = {
+  commandHeader: (name, description) => `
+${name} - ${description}`,
+  version: (version) => `Version: ${version}`,
+  usage: (name) => `
+Usage:
+  ${name} [options]`,
+  usageWithSubCommands: (name) => `
+Usage:
+  ${name} [subcommand] [options]`,
+  optionsHeader: `
+Options:`,
+  requiredNote: `
+* = required`,
+  examplesHeader: `
+Examples:`,
+  globalHeader: `
+Available commands:
+`,
+  helpFooter: `
+Use "command --help" for command-specific help
+`
+};
+var formatArgName = (name, def) => {
+  const aliases = def.aliases ? ` (-${def.aliases.join(", -")})` : "";
+  const required = def.required ? "*" : "";
+  return `--${name}${aliases}${required}`;
+};
+var formatArgType = (def) => {
+  if (def.type === "boolean")
+    return "";
+  return `<${def.type}>`;
+};
+var argHelpCache = new Map;
+var helpCache = new Map;
+var getArgHelp = (name, def) => {
+  const cacheKey = `${name}:${JSON.stringify(def)}`;
+  let cached = argHelpCache.get(cacheKey);
+  if (!cached) {
+    const argName = formatArgName(name, def);
+    const argType = formatArgType(def);
+    const desc = def.description ?? "";
+    const defaultVal = "default" in def && def.default !== undefined ? ` (default: ${def.default})` : "";
+    cached = `  ${argName} ${argType}
+      ${desc}${defaultVal}`;
+    argHelpCache.set(cacheKey, cached);
+  }
+  return cached;
+};
+var generateCommandHelp = async (definition) => {
+  const { cfg, args } = definition;
+  const cacheKey = `${cfg.name}:${JSON.stringify(cfg)}:${JSON.stringify(args)}`;
+  const cached = helpCache.get(cacheKey);
+  if (cached) {
+    return cached.commandHelp;
+  }
+  const lines = [
+    HELP_TEMPLATES.commandHeader(cfg.name, cfg.description || "No description available")
+  ];
+  if (cfg.version) {
+    lines.push(HELP_TEMPLATES.version(cfg.version));
+  }
+  lines.push(HELP_TEMPLATES.usage(cfg.name));
+  if (Object.keys(args).length > 0) {
+    lines.push(HELP_TEMPLATES.optionsHeader);
+    for (const [name, def] of Object.entries(args)) {
+      lines.push(getArgHelp(name, def));
+    }
+    lines.push(HELP_TEMPLATES.requiredNote);
+  }
+  if (cfg.examples && cfg.examples.length > 0) {
+    lines.push(HELP_TEMPLATES.examplesHeader);
+    for (const example of cfg.examples) {
+      lines.push(`  ${example}`);
+    }
+  }
+  const helpText = lines.join(`
+`);
+  helpCache.set(cacheKey, {
+    commandHelp: helpText,
+    globalHelp: "",
+    fileHash: "",
+    lastModified: Date.now()
+  });
+  return helpText;
+};
+var commandHelpCache = new Map;
+var formatCommandHelp = (name, metadata) => {
+  const cacheKey = `${name}:${JSON.stringify(metadata)}`;
+  let cached = commandHelpCache.get(cacheKey);
+  if (!cached) {
+    const aliases = metadata.aliases ? ` (${metadata.aliases.join(", ")})` : "";
+    const description = metadata.description || "No description available";
+    cached = `  ${name}${aliases}
+      ${description}`;
+    commandHelpCache.set(cacheKey, cached);
+  }
+  return cached;
+};
+var generateGlobalHelp = async (registry) => {
+  const cacheKey = `global:${Array.from(registry.metadata.keys()).sort().join(",")}`;
+  const cached = helpCache.get(cacheKey);
+  if (cached && cached.globalHelp) {
+    return cached.globalHelp;
+  }
+  const lines = [HELP_TEMPLATES.globalHeader];
+  const metadataResults = await pMap(Array.from(registry.metadata.entries()), async ([name, metadataLoader]) => {
+    const metadata = await metadataLoader();
+    return [name, metadata];
+  }, { concurrency: 5 });
+  metadataResults.sort(([a], [b]) => a.localeCompare(b));
+  for (const [name, metadata] of metadataResults) {
+    lines.push(formatCommandHelp(name, metadata));
+  }
+  lines.push(HELP_TEMPLATES.helpFooter);
+  const helpText = lines.join(`
+`);
+  helpCache.set(cacheKey, {
+    commandHelp: "",
+    globalHelp: helpText,
+    fileHash: "",
+    lastModified: Date.now()
+  });
+  return helpText;
+};
+
+// packages/launcher/src/impl/validator.ts
+var validateArgValue = (argName, value, definition) => {
+  const expectedType = definition.type === "boolean" ? "boolean" : definition.type === "number" ? "number" : "string";
+  if (typeof value !== expectedType) {
+    throw new ArgumentValidationError(argName, `Expected ${expectedType}, got ${typeof value}`);
+  }
+  if ("validate" in definition && definition.validate) {
+    const result = definition.validate(value);
+    if (result !== true) {
+      throw new ArgumentValidationError(argName, typeof result === "string" ? result : "Validation failed");
+    }
+  }
+  return true;
+};
+
+// packages/launcher/src/impl/parser.ts
+var camelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+var schemaMetadataCache = new Map;
+var createSchemaMetadata = (schema) => {
+  const aliasMap = new Map;
+  const camelCaseCache = new Map;
+  const defaults = {};
+  const requiredKeys = new Set;
+  const availableKeys = [];
+  for (const [key, def] of Object.entries(schema)) {
+    availableKeys.push(key);
+    const camelKey = camelCase(key);
+    if (camelKey !== key) {
+      camelCaseCache.set(key, camelKey);
+    }
+    if (def.aliases) {
+      for (const alias of def.aliases) {
+        aliasMap.set(alias, key);
+        const camelAlias = camelCase(alias);
+        if (camelAlias !== alias) {
+          camelCaseCache.set(alias, camelAlias);
+        }
+      }
+    }
+    if ("default" in def && def.default !== undefined) {
+      defaults[key] = def.default;
+    }
+    if (def.required) {
+      requiredKeys.add(key);
+    }
+  }
+  return {
+    aliasMap,
+    camelCaseCache,
+    defaults,
+    requiredKeys,
+    availableKeys
+  };
+};
+var hashSchema = (schema) => {
+  const keys = Object.keys(schema).sort();
+  return keys.join("|");
+};
+var getSchemaMetadata = (schema) => {
+  const schemaKey = hashSchema(schema);
+  let metadata = schemaMetadataCache.get(schemaKey);
+  if (!metadata) {
+    metadata = createSchemaMetadata(schema);
+    schemaMetadataCache.set(schemaKey, metadata);
+  }
+  return metadata;
+};
+var parseArgs = (argv, schema) => {
+  const [cmdName, ...rawArgs] = argv;
+  if (!cmdName) {
+    throw new ArgumentValidationError("command", "No command provided");
+  }
+  const { aliasMap, camelCaseCache, defaults, requiredKeys, availableKeys } = getSchemaMetadata(schema);
+  const parsedArgs = { ...defaults };
+  for (let i = 0;i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (!arg || !arg.startsWith("-"))
+      continue;
+    const isLongForm = arg.startsWith("--");
+    const flagName = arg.slice(isLongForm ? 2 : 1);
+    const actualKey = aliasMap.get(flagName) ?? camelCaseCache.get(flagName) ?? camelCase(flagName);
+    const definition = schema[actualKey];
+    if (!definition) {
+      throw new ArgumentValidationError(flagName, `Unknown argument. Available: ${availableKeys.join(", ")}`);
+    }
+    if (definition.type === "boolean") {
+      parsedArgs[actualKey] = true;
+      continue;
+    }
+    const nextArg = rawArgs[++i];
+    if (nextArg === undefined || nextArg.startsWith("-")) {
+      throw new ArgumentValidationError(flagName, `Expected value for argument "${flagName}"`);
+    }
+    let value = nextArg;
+    if (definition.type === "number") {
+      value = Number(nextArg);
+      if (Number.isNaN(value)) {
+        throw new ArgumentValidationError(flagName, `Expected number, got "${nextArg}"`);
+      }
+    }
+    validateArgValue(actualKey, value, definition);
+    parsedArgs[actualKey] = value;
+  }
+  for (const requiredKey of requiredKeys) {
+    if (!(requiredKey in parsedArgs)) {
+      throw new ArgumentValidationError(requiredKey, `Required argument "${requiredKey}" is missing`);
+    }
+  }
+  return { cmdName, parsedArgs };
+};
+
+// packages/launcher/src/impl/registry.ts
+var cachedRegistry = null;
+var getRegistry = () => cachedRegistry;
+var setRegistry = (registry) => {
+  cachedRegistry = registry;
+};
+var resolveCommand = (registry, cmdNameOrAlias) => {
+  const resolvedName = registry.aliases.get(cmdNameOrAlias) ?? cmdNameOrAlias;
+  return resolvedName;
+};
+
+// packages/launcher/src/mod.ts
+var getCallerDirectory = (importMetaUrl) => {
+  return dirname(fileURLToPath(importMetaUrl));
+};
+var runLauncher = async (importMetaUrl, options = {}) => {
+  const { cmdsDir = "./cmds", onError } = options;
+  try {
+    let registry = getRegistry();
+    if (!registry) {
+      const callerDir = getCallerDirectory(importMetaUrl);
+      registry = await discoverCommands(cmdsDir, callerDir);
+      setRegistry(registry);
+    }
+    const argv = process.argv.slice(2);
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+      logger.log(await generateGlobalHelp(registry));
+      process.exit(0);
+    }
+    const isSubCommand = argv.length > 1 && !argv[1].startsWith("-");
+    if (isSubCommand) {
+      const parentName = resolveCommand(registry, argv[0]);
+      const subCommandName = resolveCommand(registry, argv[1]);
+      const parentNode = registry.hierarchy.get(parentName);
+      const subCommandNode = registry.hierarchy.get(subCommandName);
+      if (!parentNode) {
+        throw new CommandNotFoundError(argv[0], Array.from(registry.registry.keys()));
+      }
+      if (!subCommandNode || subCommandNode.parent !== parentName) {
+        const availableSubCommands = Array.from(parentNode.children.keys());
+        throw new CommandNotFoundError(subCommandName, availableSubCommands);
+      }
+      const parentDefinition = await parentNode.loader();
+      const subCommandDefinition = await subCommandNode.loader();
+      if (argv.includes("--help") || argv.includes("-h")) {
+        logger.log(await generateCommandHelp(subCommandDefinition));
+        process.exit(0);
+      }
+      const subCommandIndex = argv.findIndex((arg, index) => index > 0 && !arg.startsWith("-"));
+      const parentArgs = [];
+      const subCommandArgsFiltered = [];
+      for (let i = 1;i < argv.length; i++) {
+        const arg = argv[i];
+        if (i === subCommandIndex) {
+          continue;
+        }
+        const isParentArg = Object.keys(parentDefinition.args).some((key) => {
+          const def = parentDefinition.args[key];
+          if (!def)
+            return false;
+          return arg === `--${key}` || arg === `-${key}` || def.aliases && def.aliases.some((alias) => arg === `-${alias}`);
+        });
+        if (isParentArg) {
+          parentArgs.push(arg);
+          if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+            parentArgs.push(argv[i + 1]);
+            i++;
+          }
+        } else {
+          subCommandArgsFiltered.push(arg);
+        }
+      }
+      let parentParsedArgs = {};
+      if (parentArgs.length > 0) {
+        const { parsedArgs } = parseArgs([parentName, ...parentArgs], parentDefinition.args);
+        parentParsedArgs = parsedArgs;
+      }
+      const { parsedArgs: subCommandParsedArgs } = parseArgs([subCommandName, ...subCommandArgsFiltered], subCommandDefinition.args);
+      await subCommandDefinition.handler(subCommandParsedArgs, parentParsedArgs);
+    } else {
+      const cmdNameOrAlias = argv[0];
+      const cmdName = resolveCommand(registry, cmdNameOrAlias);
+      const loader = registry.registry.get(cmdName);
+      if (!loader) {
+        throw new CommandNotFoundError(cmdNameOrAlias, Array.from(registry.registry.keys()));
+      }
+      const definition = await loader();
+      if (argv.includes("--help") || argv.includes("-h")) {
+        logger.log(await generateCommandHelp(definition));
+        process.exit(0);
+      }
+      const { parsedArgs } = parseArgs(argv, definition.args);
+      await definition.handler(parsedArgs);
+    }
+  } catch (error) {
+    if (error instanceof LauncherError) {
+      if (onError) {
+        onError(error);
+      } else {
+        const errorLines = [`
+\u274C Error: ${error.message}`];
+        if (error instanceof CommandLoadError && error.cause) {
+          errorLines.push(`Cause: ${error.cause}`);
+        }
+        errorLines.push("");
+        writeErrorLines(errorLines);
+      }
+      process.exit(1);
+    } else {
+      throw error;
+    }
+  }
+};
+
+// apps/dler/src/cli.ts
+await runLauncher(import.meta.url);
+
+//# debugId=E90D77EA3D02CDB664756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["..\\..\\..\\packages\\launcher\\src\\mod.ts", "..\\..\\..\\packages\\helpers\\src\\impl\\write.ts", "..\\..\\..\\packages\\colors\\src\\mod.ts", "..\\..\\..\\packages\\logger\\src\\mod.ts", "..\\..\\..\\packages\\mapper\\src\\mod.ts", "..\\..\\..\\packages\\launcher\\src\\impl\\discovery.ts", "..\\..\\..\\packages\\launcher\\src\\impl\\cache.ts", "..\\..\\..\\packages\\launcher\\src\\impl\\errors.ts", "..\\..\\..\\packages\\launcher\\src\\impl\\help.ts", "..\\..\\..\\packages\\launcher\\src\\impl\\validator.ts", "..\\..\\..\\packages\\launcher\\src\\impl\\parser.ts", "..\\..\\..\\packages\\launcher\\src\\impl\\registry.ts", "..\\src\\cli.ts"],
  "sourcesContent": [
    "// packages/launcher/src/impl/launcher/mod.ts\n\nimport { dirname } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { writeErrorLines } from \"@reliverse/dler-helpers\";\nimport { logger } from \"@reliverse/dler-logger\";\nimport { discoverCommands } from \"./impl/discovery\";\nimport {\n  CommandLoadError,\n  CommandNotFoundError,\n  LauncherError,\n} from \"./impl/errors\";\nimport { generateCommandHelp, generateGlobalHelp } from \"./impl/help\";\nimport { parseArgs } from \"./impl/parser\";\nimport { getRegistry, resolveCommand, setRegistry } from \"./impl/registry\";\n\nexport { defineCmd, defineCmdArgs, defineCmdCfg } from \"./impl/command\";\nexport {\n  ArgumentValidationError,\n  CommandLoadError,\n  CommandNotFoundError,\n  LauncherError,\n} from \"./impl/errors\";\nexport type {\n  CmdArgDefinition,\n  CmdArgsSchema,\n  CmdCfg,\n  CmdDefinition,\n  CmdHandler,\n  CmdLoader,\n  CmdRegistry,\n  DiscoveryResult,\n  ParsedArgs,\n} from \"./impl/types\";\n\nexport interface LauncherOptions {\n  cmdsDir?: string;\n  onError?: (error: LauncherError) => void;\n}\n\n// Get the directory of the file that called runLauncher\nconst getCallerDirectory = (importMetaUrl: string): string => {\n  // Use provided import.meta.url (most reliable caller detection)\n  return dirname(fileURLToPath(importMetaUrl));\n};\n\nexport const runLauncher = async (\n  importMetaUrl: string,\n  options: LauncherOptions = {},\n): Promise<void> => {\n  const { cmdsDir = \"./cmds\", onError } = options;\n\n  try {\n    let registry = getRegistry();\n    if (!registry) {\n      // Get the caller's directory using import.meta.url\n      const callerDir = getCallerDirectory(importMetaUrl);\n      registry = await discoverCommands(cmdsDir, callerDir);\n      setRegistry(registry);\n    }\n\n    const argv = process.argv.slice(2);\n\n    if (argv.length === 0 || argv[0] === \"--help\" || argv[0] === \"-h\") {\n      // Use cached global help for faster display\n      logger.log(await generateGlobalHelp(registry));\n      process.exit(0);\n    }\n\n    // Check if this is a sub-command invocation\n    const isSubCommand = argv.length > 1 && !argv[1]!.startsWith(\"-\");\n\n    if (isSubCommand) {\n      // Handle sub-command execution using folder-based discovery\n      const parentName = resolveCommand(registry, argv[0]!);\n      const subCommandName = resolveCommand(registry, argv[1]!);\n\n      // Check if both parent and sub-command exist in the hierarchy\n      const parentNode = registry.hierarchy.get(parentName);\n      const subCommandNode = registry.hierarchy.get(subCommandName);\n\n      if (!parentNode) {\n        throw new CommandNotFoundError(\n          argv[0]!,\n          Array.from(registry.registry.keys()),\n        );\n      }\n\n      if (!subCommandNode || subCommandNode.parent !== parentName) {\n        // Get available sub-commands for this parent\n        const availableSubCommands = Array.from(parentNode.children.keys());\n        throw new CommandNotFoundError(subCommandName, availableSubCommands);\n      }\n\n      // Load both parent and sub-command definitions\n      const parentDefinition = await parentNode.loader();\n      const subCommandDefinition = await subCommandNode.loader();\n\n      if (argv.includes(\"--help\") || argv.includes(\"-h\")) {\n        logger.log(await generateCommandHelp(subCommandDefinition));\n        process.exit(0);\n      }\n\n      // Separate parent and sub-command arguments\n      const subCommandIndex = argv.findIndex(\n        (arg, index) => index > 0 && !arg.startsWith(\"-\"),\n      );\n\n      // Filter parent args from the full argument list\n      const parentArgs: string[] = [];\n      const subCommandArgsFiltered: string[] = [];\n\n      for (let i = 1; i < argv.length; i++) {\n        const arg = argv[i]!;\n        if (i === subCommandIndex) {\n          // This is the sub-command name, skip it\n          continue;\n        }\n\n        // Check if this argument belongs to the parent command\n        const isParentArg = Object.keys(parentDefinition.args).some((key) => {\n          const def = parentDefinition.args[key];\n          if (!def) return false;\n          return (\n            arg === `--${key}` ||\n            arg === `-${key}` ||\n            (def.aliases && def.aliases.some((alias) => arg === `-${alias}`))\n          );\n        });\n\n        if (isParentArg) {\n          parentArgs.push(arg);\n          // If it's a flag with a value, add the next argument too\n          if (i + 1 < argv.length && !argv[i + 1]!.startsWith(\"-\")) {\n            parentArgs.push(argv[i + 1]!);\n            i++; // Skip the next argument as it's the value\n          }\n        } else {\n          subCommandArgsFiltered.push(arg);\n        }\n      }\n\n      // Parse parent args (only if there are any)\n      let parentParsedArgs = {};\n      if (parentArgs.length > 0) {\n        const { parsedArgs } = parseArgs(\n          [parentName, ...parentArgs],\n          parentDefinition.args,\n        );\n        parentParsedArgs = parsedArgs;\n      }\n\n      // Parse sub-command args\n      const { parsedArgs: subCommandParsedArgs } = parseArgs(\n        [subCommandName, ...subCommandArgsFiltered],\n        subCommandDefinition.args,\n      );\n\n      // Execute sub-command with parent args\n      await subCommandDefinition.handler(\n        subCommandParsedArgs as never,\n        parentParsedArgs as never,\n      );\n    } else {\n      // Handle single command execution\n      const cmdNameOrAlias = argv[0]!;\n      const cmdName = resolveCommand(registry, cmdNameOrAlias);\n\n      const loader = registry.registry.get(cmdName);\n      if (!loader) {\n        throw new CommandNotFoundError(\n          cmdNameOrAlias,\n          Array.from(registry.registry.keys()),\n        );\n      }\n\n      const definition = await loader();\n\n      if (argv.includes(\"--help\") || argv.includes(\"-h\")) {\n        logger.log(await generateCommandHelp(definition));\n        process.exit(0);\n      }\n\n      const { parsedArgs } = parseArgs(argv, definition.args);\n\n      await definition.handler(parsedArgs as never);\n    }\n  } catch (error) {\n    if (error instanceof LauncherError) {\n      if (onError) {\n        onError(error);\n      } else {\n        const errorLines = [`\\n❌ Error: ${error.message}`];\n        if (error instanceof CommandLoadError && error.cause) {\n          errorLines.push(`Cause: ${error.cause}`);\n        }\n        errorLines.push(\"\");\n        writeErrorLines(errorLines);\n      }\n      process.exit(1);\n    } else {\n      throw error;\n    }\n  }\n};\n",
    "// Optimized output functions that batch writes\nconst textEncoder = new TextEncoder();\n\nexport const writeLine = (text: string): void => {\n  const encoded = textEncoder.encode(`${text}\\n`);\n  Bun.write(Bun.stdout, encoded);\n};\n\nexport const writeError = (text: string): void => {\n  const encoded = textEncoder.encode(`${text}\\n`);\n  Bun.write(Bun.stderr, encoded);\n};\n\nexport const writeErrorLines = (lines: string[]): void => {\n  // Pre-allocate string buffer for better performance\n  const buffer = new Array(lines.length + 1);\n  for (let i = 0; i < lines.length; i++) {\n    buffer[i] = lines[i];\n  }\n  buffer[lines.length] = \"\";\n  const encoded = textEncoder.encode(buffer.join(\"\\n\"));\n  Bun.write(Bun.stderr, encoded);\n};\n\nexport const writeJsonFile = async (\n  path: string,\n  data: unknown,\n): Promise<void> => {\n  await Bun.write(path, JSON.stringify(data, null, 2) + \"\\n\");\n};\n\nexport const writeTextFile = async (\n  path: string,\n  content: string,\n): Promise<void> => {\n  await Bun.write(path, content);\n};\n",
    "type ColorLevel = 0 | 1 | 2 | 3;\n\ninterface Rgb {\n  r: number;\n  g: number;\n  b: number;\n}\n\ntype SgrOp =\n  | { kind: \"style\"; open: number[] }\n  | { kind: \"fg-basic\"; idx: number; bright: boolean }\n  | { kind: \"bg-basic\"; idx: number; bright: boolean }\n  | { kind: \"fg-256\"; code: number }\n  | { kind: \"bg-256\"; code: number }\n  | { kind: \"fg-true\"; rgb: Rgb }\n  | { kind: \"bg-true\"; rgb: Rgb };\n\ntype ApplyInput = string | number;\n\ntype FormatCallable = ((input: ApplyInput) => string) & {\n  readonly [OP_SYMBOL]: SgrOp[];\n};\n\nexport type BaseColorName =\n  | \"black\"\n  | \"red\"\n  | \"green\"\n  | \"yellow\"\n  | \"blue\"\n  | \"magenta\"\n  | \"cyan\"\n  | \"white\"\n  | \"gray\"\n  | \"orange\"\n  | \"pink\"\n  | \"purple\"\n  | \"teal\"\n  | \"lime\"\n  | \"brown\"\n  | \"navy\"\n  | \"maroon\"\n  | \"olive\"\n  | \"silver\";\n\nexport type ColorName = BaseColorName | BrightColorName | BgColorName;\n\nexport type BrightColorName =\n  | \"blackBright\"\n  | \"redBright\"\n  | \"greenBright\"\n  | \"yellowBright\"\n  | \"blueBright\"\n  | \"magentaBright\"\n  | \"cyanBright\"\n  | \"whiteBright\"\n  | \"orangeBright\"\n  | \"pinkBright\"\n  | \"purpleBright\"\n  | \"tealBright\"\n  | \"limeBright\"\n  | \"brownBright\"\n  | \"navyBright\"\n  | \"maroonBright\"\n  | \"oliveBright\"\n  | \"silverBright\";\n\nexport type BgColorName =\n  | `bg${Capitalize<BaseColorName>}`\n  | `bg${Capitalize<BrightColorName>}`;\n\nexport type ReStyleKey =\n  | \"reset\"\n  | \"bold\"\n  | \"dim\"\n  | \"italic\"\n  | \"underline\"\n  | \"inverse\"\n  | \"hidden\"\n  | \"strikethrough\";\n\nexport type Re = FormatCallable & {\n  readonly [K in ReStyleKey]: Re;\n} & {\n  readonly [K in ColorName]: Re;\n} & {\n  readonly [K in BgColorName]: Re;\n};\n\n// Constants\nconst RESET = \"\\x1B[0m\";\nconst OP_SYMBOL: unique symbol = Symbol(\"re.ops\");\n\nconst COLOR_LEVEL_OFF = 0;\nconst COLOR_LEVEL_BASIC = 1;\nconst COLOR_LEVEL_256 = 2;\nconst COLOR_LEVEL_TRUECOLOR = 3;\n\nconst MIN_BYTE = 0;\nconst MAX_BYTE = 255;\nconst WHITE_RGB = 255;\n\nconst ANSI_256_GRAYSCALE_MIN = 8;\nconst ANSI_256_GRAYSCALE_MAX = 248;\nconst ANSI_256_BASE_OFFSET = 16;\nconst ANSI_256_GRAYSCALE_BASE = 232;\nconst ANSI_256_GRAYSCALE_RANGE = 247;\nconst ANSI_256_GRAYSCALE_STEPS = 24;\nconst ANSI_256_BRIGHT_THRESHOLD = 231;\nconst ANSI_256_RGB_LEVELS = 5;\nconst ANSI_256_RGB_RED_MULTIPLIER = 36;\nconst ANSI_256_RGB_GREEN_MULTIPLIER = 6;\n\nconst SGR_FG_BASE = 30;\nconst SGR_BG_BASE = 40;\nconst SGR_FG_BRIGHT_BASE = 90;\nconst SGR_BG_BRIGHT_BASE = 100;\n\nconst SGR_RESET = 0;\nconst SGR_BOLD = 1;\nconst SGR_DIM = 2;\nconst SGR_ITALIC = 3;\nconst SGR_UNDERLINE = 4;\nconst SGR_INVERSE = 7;\nconst SGR_HIDDEN = 8;\nconst SGR_STRIKETHROUGH = 9;\n\nconst HEX_RADIX = 16;\nconst BRIGHT_SUFFIX_LENGTH = 6;\nconst BG_PREFIX_LENGTH = 2;\nconst BRIGHT_MIX_FACTOR = 0.25;\nconst BRIGHT_SUFFIX = \"Bright\";\n\n// Runtime detection (cached)\nconst IS_BUN =\n  typeof process !== \"undefined\" &&\n  process.versions?.bun !== undefined &&\n  typeof Bun !== \"undefined\" &&\n  typeof Bun.color === \"function\";\n\nlet CURRENT_LEVEL: ColorLevel = COLOR_LEVEL_TRUECOLOR;\n\nexport const setColorLevel = (level: ColorLevel): void => {\n  if (\n    level !== COLOR_LEVEL_OFF &&\n    level !== COLOR_LEVEL_BASIC &&\n    level !== COLOR_LEVEL_256 &&\n    level !== COLOR_LEVEL_TRUECOLOR\n  ) {\n    throw new Error(\"Invalid color level\");\n  }\n  CURRENT_LEVEL = level;\n};\n\n// byte clamping\nconst clampByte = (n: number): number => {\n  if (n <= MIN_BYTE || !Number.isFinite(n)) return MIN_BYTE;\n  if (n >= MAX_BYTE) return MAX_BYTE;\n  return Math.round(n);\n};\n\n// Base 8-color RGB anchors (frozen for optimization)\nconst BASIC8: readonly Rgb[] = Object.freeze([\n  Object.freeze({ r: 0, g: 0, b: 0 }),\n  Object.freeze({ r: 205, g: 0, b: 0 }),\n  Object.freeze({ r: 0, g: 205, b: 0 }),\n  Object.freeze({ r: 205, g: 205, b: 0 }),\n  Object.freeze({ r: 0, g: 0, b: 238 }),\n  Object.freeze({ r: 205, g: 0, b: 205 }),\n  Object.freeze({ r: 0, g: 205, b: 205 }),\n  Object.freeze({ r: 229, g: 229, b: 229 }),\n]) as readonly Rgb[];\n\n// SGR sequence cache for common codes\nconst sgrCache = new Map<string, string>();\n\nconst sgr = (codes: number[]): string => {\n  // Fast path for single codes\n  if (codes.length === 1) {\n    const code = codes[0];\n    const cached = sgrCache.get(String(code));\n    if (cached) return cached;\n    const seq = `\\x1B[${code}m`;\n    sgrCache.set(String(code), seq);\n    return seq;\n  }\n\n  // Multi-code path\n  const key = codes.join(\";\");\n  const cached = sgrCache.get(key);\n  if (cached) return cached;\n  const seq = `\\x1B[${key}m`;\n  sgrCache.set(key, seq);\n  return seq;\n};\n\n// nearest basic color with early exit\nconst nearestBasicIndex = (rgb: Rgb): number => {\n  if (IS_BUN) {\n    const ansiStr = Bun.color(rgb, \"ansi-16\");\n    if (ansiStr) {\n      const match = ansiStr.match(/38;5;(\\d+)/);\n      if (match?.[1]) {\n        return Number.parseInt(match[1], 10) & 7; // Faster modulo for power of 2\n      }\n    }\n  }\n\n  let best = 0;\n  let bestDist = Number.POSITIVE_INFINITY;\n\n  // Early exit on exact match\n  for (let i = 0; i < 8; i++) {\n    const c = BASIC8[i]!;\n    const dr = c.r - rgb.r;\n    const dg = c.g - rgb.g;\n    const db = c.b - rgb.b;\n\n    if (dr === 0 && dg === 0 && db === 0) return i; // Exact match\n\n    const d = dr * dr + dg * dg + db * db;\n    if (d < bestDist) {\n      bestDist = d;\n      best = i;\n    }\n  }\n  return best;\n};\n\n// RGB to ANSI 256\nconst rgbToAnsi256 = (rgb: Rgb): number => {\n  if (IS_BUN) {\n    const ansiStr = Bun.color(rgb, \"ansi-256\");\n    if (ansiStr) {\n      const match = ansiStr.match(/38;5;(\\d+)/);\n      if (match?.[1]) {\n        return Number.parseInt(match[1], 10);\n      }\n    }\n  }\n\n  // grayscale check\n  if (rgb.r === rgb.g && rgb.g === rgb.b) {\n    if (rgb.r < ANSI_256_GRAYSCALE_MIN) return ANSI_256_BASE_OFFSET;\n    if (rgb.r > ANSI_256_GRAYSCALE_MAX) return ANSI_256_BRIGHT_THRESHOLD;\n    const step = Math.round(\n      ((rgb.r - ANSI_256_GRAYSCALE_MIN) / ANSI_256_GRAYSCALE_RANGE) *\n        ANSI_256_GRAYSCALE_STEPS,\n    );\n    return ANSI_256_GRAYSCALE_BASE + step;\n  }\n\n  // RGB calculation with reduced operations\n  const r = ((rgb.r * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE) | 0;\n  const g = ((rgb.g * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE) | 0;\n  const b = ((rgb.b * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE) | 0;\n  return (\n    ANSI_256_BASE_OFFSET +\n    r * ANSI_256_RGB_RED_MULTIPLIER +\n    g * ANSI_256_RGB_GREEN_MULTIPLIER +\n    b\n  );\n};\n\n// Named colors\nconst NAMED_COLORS: Record<BaseColorName, string> = {\n  black: \"#000000\",\n  red: \"#ff0000\",\n  green: \"#00ff00\",\n  yellow: \"#ffff00\",\n  blue: \"#0000ff\",\n  magenta: \"#ff00ff\",\n  cyan: \"#00ffff\",\n  white: \"#ffffff\",\n  gray: \"#808080\",\n  orange: \"#ffa500\",\n  pink: \"#ffc0cb\",\n  purple: \"#800080\",\n  teal: \"#008080\",\n  lime: \"#00ff00\",\n  brown: \"#a52a2a\",\n  navy: \"#000080\",\n  maroon: \"#800000\",\n  olive: \"#808000\",\n  silver: \"#c0c0c0\",\n};\n\n// RGB cache with common colors pre-populated\nconst rgbCache = new Map<BaseColorName, Rgb>();\n\n// Pre-populate cache with common colors\nfor (const name of [\"black\", \"white\", \"red\", \"green\", \"blue\"] as const) {\n  const hex = NAMED_COLORS[name];\n  if (hex) {\n    const clean = hex.slice(1);\n    const r = Number.parseInt(clean.slice(0, 2), HEX_RADIX);\n    const g = Number.parseInt(clean.slice(2, 4), HEX_RADIX);\n    const b = Number.parseInt(clean.slice(4, 6), HEX_RADIX);\n    rgbCache.set(name, Object.freeze({ r, g, b }));\n  }\n}\n\n// white mixing\nconst mixWithWhite = (rgb: Rgb, factor: number): Rgb => {\n  const invFactor = 1 - factor;\n  return {\n    r: clampByte(rgb.r * invFactor + WHITE_RGB * factor),\n    g: clampByte(rgb.g * invFactor + WHITE_RGB * factor),\n    b: clampByte(rgb.b * invFactor + WHITE_RGB * factor),\n  };\n};\n\n// hex parsing with fewer string operations\nconst fromNamed = (name: BaseColorName): Rgb => {\n  const cached = rgbCache.get(name);\n  if (cached) return cached;\n\n  const hex = NAMED_COLORS[name];\n  if (!hex) return { r: 0, g: 0, b: 0 };\n\n  if (IS_BUN) {\n    const rgb = Bun.color(hex, \"{rgb}\");\n    if (rgb) {\n      rgbCache.set(name, rgb);\n      return rgb;\n    }\n  }\n\n  const clean = hex[0] === \"#\" ? hex.slice(1) : hex;\n  const len = clean.length;\n\n  let r: number, g: number, b: number;\n\n  if (len === 3) {\n    // short hex: use bit operations\n    const rv = Number.parseInt(clean[0]!, HEX_RADIX);\n    const gv = Number.parseInt(clean[1]!, HEX_RADIX);\n    const bv = Number.parseInt(clean[2]!, HEX_RADIX);\n    r = (rv << 4) | rv;\n    g = (gv << 4) | gv;\n    b = (bv << 4) | bv;\n  } else if (len === 6) {\n    r = Number.parseInt(clean.slice(0, 2), HEX_RADIX);\n    g = Number.parseInt(clean.slice(2, 4), HEX_RADIX);\n    b = Number.parseInt(clean.slice(4, 6), HEX_RADIX);\n  } else {\n    return { r: 0, g: 0, b: 0 };\n  }\n\n  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {\n    return { r: 0, g: 0, b: 0 };\n  }\n\n  const result = Object.freeze({ r, g, b });\n  rgbCache.set(name, result);\n  return result;\n};\n\n// base name extraction\nconst toBaseName = (compound: BrightColorName): BaseColorName => {\n  if (!compound) return \"black\";\n  const base = compound.slice(0, -BRIGHT_SUFFIX_LENGTH);\n  if (!base) return \"black\";\n  return (base[0]!.toLowerCase() + base.slice(1)) as BaseColorName;\n};\n\nconst parseColorName = (name: ColorName): { rgb: Rgb; wantBright: boolean } => {\n  if (!name) return { rgb: { r: 0, g: 0, b: 0 }, wantBright: false };\n\n  if (name.endsWith(BRIGHT_SUFFIX)) {\n    const base = toBaseName(name as BrightColorName);\n    const rgb = fromNamed(base);\n    const rgbAdj = mixWithWhite(rgb, BRIGHT_MIX_FACTOR);\n    return { rgb: rgbAdj, wantBright: true };\n  }\n  return { rgb: fromNamed(name as BaseColorName), wantBright: false };\n};\n\n// ANSI sequence generation with reduced string operations\nconst openForOp = (op: SgrOp): string => {\n  if (CURRENT_LEVEL === COLOR_LEVEL_OFF) return \"\";\n\n  switch (op.kind) {\n    case \"style\":\n      return sgr(op.open);\n\n    case \"fg-basic\": {\n      const code = (op.bright ? SGR_FG_BRIGHT_BASE : SGR_FG_BASE) + op.idx;\n      return sgr([code]);\n    }\n\n    case \"bg-basic\": {\n      const code = (op.bright ? SGR_BG_BRIGHT_BASE : SGR_BG_BASE) + op.idx;\n      return sgr([code]);\n    }\n\n    case \"fg-256\": {\n      if (IS_BUN) {\n        const ansi = Bun.color(op.code, \"ansi-256\");\n        if (ansi) return ansi;\n      }\n      return `\\x1B[38;5;${op.code}m`;\n    }\n\n    case \"bg-256\": {\n      if (IS_BUN) {\n        const fgAnsi = Bun.color(op.code, \"ansi-256\");\n        if (fgAnsi) return fgAnsi.replace(\"38;5;\", \"48;5;\");\n      }\n      return `\\x1B[48;5;${op.code}m`;\n    }\n\n    case \"fg-true\": {\n      if (IS_BUN) {\n        const ansi = Bun.color(op.rgb, \"ansi-16m\");\n        if (ansi) return ansi;\n      }\n      const { r, g, b } = op.rgb;\n      return `\\x1B[38;2;${r};${g};${b}m`;\n    }\n\n    case \"bg-true\": {\n      if (IS_BUN) {\n        const fgAnsi = Bun.color(op.rgb, \"ansi-16m\");\n        if (fgAnsi) return fgAnsi.replace(\"38;2;\", \"48;2;\");\n      }\n      const { r, g, b } = op.rgb;\n      return `\\x1B[48;2;${r};${g};${b}m`;\n    }\n\n    default:\n      return \"\";\n  }\n};\n\n// ops-to-open with pre-allocated array\nconst opsToOpen = (ops: SgrOp[]): string => {\n  if (CURRENT_LEVEL === COLOR_LEVEL_OFF) return \"\";\n\n  const len = ops.length;\n  if (len === 0) return \"\";\n  if (len === 1) return openForOp(ops[0]!);\n\n  // Direct string building for better performance\n  let result = \"\";\n  for (let i = 0; i < len; i++) {\n    result += openForOp(ops[i]!);\n  }\n  return result;\n};\n\n// multiline text processing\nconst applyOpsToText = (ops: SgrOp[], input: ApplyInput): string => {\n  const text = String(input);\n  const textLen = text.length;\n\n  if (CURRENT_LEVEL === COLOR_LEVEL_OFF || ops.length === 0 || textLen === 0) {\n    return text;\n  }\n\n  const open = opsToOpen(ops);\n  if (!open) return text;\n\n  // Fast path for single-line text (most common)\n  const nlIdx = text.indexOf(\"\\n\");\n  if (nlIdx === -1) {\n    return `${open}${text}${RESET}`;\n  }\n\n  // multiline with direct string building\n  let result = \"\";\n  let start = 0;\n\n  while (start < textLen) {\n    const end = text.indexOf(\"\\n\", start);\n\n    if (end === -1) {\n      // Last line\n      const line = text.slice(start);\n      if (line) {\n        if (line.endsWith(\"\\r\")) {\n          result += `${open}${line.slice(0, -1)}\\r${RESET}`;\n        } else {\n          result += `${open}${line}${RESET}`;\n        }\n      }\n      break;\n    }\n\n    // Line with newline\n    if (start > 0) result += \"\\n\";\n\n    const line = text.slice(start, end);\n    if (line) {\n      if (line.endsWith(\"\\r\")) {\n        result += `${open}${line.slice(0, -1)}\\r${RESET}`;\n      } else {\n        result += `${open}${line}${RESET}`;\n      }\n    } else {\n      result += `${open}${RESET}`;\n    }\n\n    start = end + 1;\n  }\n\n  return result;\n};\n\n// operation builders\nconst mkFgOpsFromRgb = (rgb: Rgb, wantBright = false): SgrOp[] => {\n  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {\n    return [\n      { kind: \"fg-basic\", idx: nearestBasicIndex(rgb), bright: wantBright },\n    ];\n  }\n  if (CURRENT_LEVEL === COLOR_LEVEL_256) {\n    return [{ kind: \"fg-256\", code: rgbToAnsi256(rgb) }];\n  }\n  return [{ kind: \"fg-true\", rgb }];\n};\n\nconst mkBgOpsFromRgb = (rgb: Rgb, wantBright = false): SgrOp[] => {\n  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {\n    return [\n      { kind: \"bg-basic\", idx: nearestBasicIndex(rgb), bright: wantBright },\n    ];\n  }\n  if (CURRENT_LEVEL === COLOR_LEVEL_256) {\n    return [{ kind: \"bg-256\", code: rgbToAnsi256(rgb) }];\n  }\n  return [{ kind: \"bg-true\", rgb }];\n};\n\n// Style table with frozen objects\nconst STYLE_TABLE: Record<ReStyleKey, SgrOp> = {\n  reset: Object.freeze({ kind: \"style\", open: [SGR_RESET] }),\n  bold: Object.freeze({ kind: \"style\", open: [SGR_BOLD] }),\n  dim: Object.freeze({ kind: \"style\", open: [SGR_DIM] }),\n  italic: Object.freeze({ kind: \"style\", open: [SGR_ITALIC] }),\n  underline: Object.freeze({ kind: \"style\", open: [SGR_UNDERLINE] }),\n  inverse: Object.freeze({ kind: \"style\", open: [SGR_INVERSE] }),\n  hidden: Object.freeze({ kind: \"style\", open: [SGR_HIDDEN] }),\n  strikethrough: Object.freeze({ kind: \"style\", open: [SGR_STRIKETHROUGH] }),\n} as const;\n\n// Pre-computed lookup sets (frozen)\nconst STYLE_KEYS = Object.freeze(\n  new Set([\n    \"reset\",\n    \"bold\",\n    \"dim\",\n    \"italic\",\n    \"underline\",\n    \"inverse\",\n    \"hidden\",\n    \"strikethrough\",\n  ]),\n);\n\nconst COLOR_KEYS = Object.freeze(new Set(Object.keys(NAMED_COLORS)));\nconst BRIGHT_COLOR_KEYS = Object.freeze(\n  new Set(Object.keys(NAMED_COLORS).map((name) => `${name}Bright`)),\n);\nconst BG_COLOR_KEYS = Object.freeze(\n  new Set(\n    Object.keys(NAMED_COLORS).map(\n      (name) => `bg${name[0]!.toUpperCase()}${name.slice(1)}`,\n    ),\n  ),\n);\nconst BG_BRIGHT_COLOR_KEYS = Object.freeze(\n  new Set(\n    Object.keys(NAMED_COLORS).map(\n      (name) => `bg${name[0]!.toUpperCase()}${name.slice(1)}Bright`,\n    ),\n  ),\n);\n\n// key checks with early returns\nconst isColorKey = (key: string): boolean =>\n  COLOR_KEYS.has(key) || BRIGHT_COLOR_KEYS.has(key);\n\nconst isBgKey = (key: string): boolean => {\n  const len = key.length;\n  if (len <= BG_PREFIX_LENGTH || key[0] !== \"b\" || key[1] !== \"g\") {\n    return false;\n  }\n  return BG_COLOR_KEYS.has(key) || BG_BRIGHT_COLOR_KEYS.has(key);\n};\n\n// Proxy cache for reusing common chains\nconst proxyCache = new WeakMap<SgrOp[], Re>();\n\n// proxy with reduced overhead\nconst callableProxy = (ops: SgrOp[]): Re => {\n  const cached = proxyCache.get(ops);\n  if (cached) return cached;\n\n  const base = ((input: ApplyInput) =>\n    applyOpsToText(ops, input)) as FormatCallable;\n\n  Object.defineProperty(base, OP_SYMBOL, {\n    value: ops,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n  });\n\n  const proxy = new Proxy(base as unknown as Re, {\n    apply(_target, _thisArg, argArray) {\n      return applyOpsToText(ops, argArray[0] as ApplyInput);\n    },\n\n    get(_target, prop) {\n      if (prop === OP_SYMBOL) return ops;\n\n      const key = String(prop);\n\n      // Style key fast path\n      if (STYLE_KEYS.has(key)) {\n        const op = STYLE_TABLE[key as ReStyleKey];\n        const newOps = [...ops, op];\n        return callableProxy(newOps);\n      }\n\n      // Background color fast path\n      if (isBgKey(key)) {\n        const colorName = (key[2]!.toLowerCase() + key.slice(3)) as ColorName;\n        const { rgb, wantBright } = parseColorName(colorName);\n        const bgOps = mkBgOpsFromRgb(rgb, wantBright);\n        const newOps = [...ops, ...bgOps];\n        return callableProxy(newOps);\n      }\n\n      // Foreground color fast path\n      if (isColorKey(key)) {\n        const { rgb, wantBright } = parseColorName(key as ColorName);\n        const fgOps = mkFgOpsFromRgb(rgb, wantBright);\n        const newOps = [...ops, ...fgOps];\n        return callableProxy(newOps);\n      }\n\n      // Unknown key → return self (no-op)\n      return proxy;\n    },\n  });\n\n  proxyCache.set(ops, proxy);\n  return proxy;\n};\n\n// Public root\nexport const re: Re = callableProxy([]);\n\n// chain with reduced allocations\nexport const chain = (...parts: FormatCallable[]): Re => {\n  if (parts.length === 0) return re;\n  if (parts.length === 1) return parts[0] as Re;\n\n  const collected: SgrOp[] = [];\n  for (let i = 0; i < parts.length; i++) {\n    const ops = (parts[i] as FormatCallable)[OP_SYMBOL] as SgrOp[] | undefined;\n    if (ops?.length) {\n      collected.push(...ops);\n    }\n  }\n\n  return callableProxy(collected);\n};\n\n// Bun color input type\ntype BunColorInput =\n  | { r: number; g: number; b: number; a?: number }\n  | [number, number, number]\n  | [number, number, number, number]\n  | string\n  | number\n  | { toString(): string };\n\n// color function with early returns\nexport const color = (input: BunColorInput, isBg = false): Re => {\n  if (!IS_BUN) {\n    if (\n      typeof input === \"object\" &&\n      \"r\" in input &&\n      \"g\" in input &&\n      \"b\" in input\n    ) {\n      const ops = isBg\n        ? mkBgOpsFromRgb(input, false)\n        : mkFgOpsFromRgb(input, false);\n      return callableProxy(ops);\n    }\n    return re;\n  }\n\n  const rgb = Bun.color(input, \"{rgb}\");\n  if (!rgb) return re;\n\n  const ops = isBg ? mkBgOpsFromRgb(rgb, false) : mkFgOpsFromRgb(rgb, false);\n  return callableProxy(ops);\n};\n",
    "/* \nWhen to Use Async vs Sync:\nUse SYNC (logger) when:\n✅ Sequential logging (like your tsc implementation)\n✅ CLI tools with ordered output\n✅ Small, frequent console writes\n✅ Error reporting that needs to maintain order\nUse ASYNC (loggerAsync) when:\n✅ Logging from multiple concurrent async operations\n✅ High-frequency logging where order doesn't matter\n✅ Large log outputs that could block\n✅ When you need to await logging completion\n*/\n\nimport { re } from \"@reliverse/dler-colors\";\n\nconst textEncoder = new TextEncoder();\n\nconst LOG_COLORS = {\n  log: re.white,\n  error: re.red,\n  warn: re.yellow,\n  info: re.blue,\n  success: re.green,\n  debug: re.gray,\n} as const;\n\nconst LOG_SYMBOLS = {\n  log: \"│  \",\n  error: \"✖  \",\n  warn: \"⚠  \",\n  info: \"■  \",\n  success: \"✓  \",\n  debug: \"✱  \",\n} as const;\n\ntype LogLevel = keyof typeof LOG_COLORS;\n\n// Write lock to prevent interleaving\nlet writeLock = Promise.resolve();\n\n// Generic message formatter\nconst formatMessage = (...args: unknown[]): string =>\n  args.map(String).join(\" \");\n\n// Generic prefixed message creator\nconst createPrefixedMessage = (level: LogLevel, message: string): string =>\n  `${LOG_SYMBOLS[level]}${message}`;\n\n// Generic async writer\nconst writeAsync = async (text: string, isError = false): Promise<void> => {\n  const encoded = textEncoder.encode(`${text}\\n`);\n  await writeLock;\n  writeLock = Bun.write(isError ? Bun.stderr : Bun.stdout, encoded).then(\n    () => {},\n  );\n  await writeLock;\n};\n\n// Generic sync writer\nconst writeSync = (text: string, isError = false): void => {\n  const encoded = textEncoder.encode(`${text}\\n`);\n  (isError ? process.stderr : process.stdout).write(encoded);\n};\n\n// Generic colored async writer\nconst writeColoredAsync = async (\n  text: string,\n  color: typeof re.white,\n  isError = false,\n): Promise<void> => {\n  const coloredText = color(text);\n  await writeAsync(coloredText, isError);\n};\n\n// Generic colored sync writer\nconst writeColoredSync = (\n  text: string,\n  color: typeof re.white,\n  isError = false,\n): void => {\n  const coloredText = color(text);\n  writeSync(coloredText, isError);\n};\n\n// Generic log method creator with overloads\nfunction createLogMethod(\n  level: LogLevel,\n  isAsync: true,\n  isError?: boolean,\n): (...args: unknown[]) => Promise<void>;\nfunction createLogMethod(\n  level: LogLevel,\n  isAsync: false,\n  isError?: boolean,\n): (...args: unknown[]) => void;\nfunction createLogMethod(\n  level: LogLevel,\n  isAsync: boolean,\n  isError = false,\n): ((...args: unknown[]) => void) | ((...args: unknown[]) => Promise<void>) {\n  if (isAsync) {\n    return async (...args: unknown[]): Promise<void> => {\n      const message = formatMessage(...args);\n      const prefixedMessage = createPrefixedMessage(level, message);\n      await writeColoredAsync(prefixedMessage, LOG_COLORS[level], isError);\n    };\n  }\n\n  return (...args: unknown[]): void => {\n    const message = formatMessage(...args);\n    const prefixedMessage = createPrefixedMessage(level, message);\n    writeColoredSync(prefixedMessage, LOG_COLORS[level], isError);\n  };\n}\n\n// Generic raw method creator with overloads\nfunction createRawMethod(isAsync: true): (...args: unknown[]) => Promise<void>;\nfunction createRawMethod(isAsync: false): (...args: unknown[]) => void;\nfunction createRawMethod(\n  isAsync: boolean,\n): ((...args: unknown[]) => void) | ((...args: unknown[]) => Promise<void>) {\n  if (isAsync) {\n    return async (...args: unknown[]): Promise<void> => {\n      const message = formatMessage(...args);\n      await writeAsync(message);\n    };\n  }\n\n  return (...args: unknown[]): void => {\n    const message = formatMessage(...args);\n    writeSync(message);\n  };\n}\n\n// Base interface for both sync and async\ninterface LoggerBase {\n  log: (...args: unknown[]) => void | Promise<void>;\n  error: (...args: unknown[]) => void | Promise<void>;\n  warn: (...args: unknown[]) => void | Promise<void>;\n  info: (...args: unknown[]) => void | Promise<void>;\n  success: (...args: unknown[]) => void | Promise<void>;\n  debug: (...args: unknown[]) => void | Promise<void>;\n  raw: (...args: unknown[]) => void | Promise<void>;\n}\n\ninterface LoggerAsync extends LoggerBase {\n  log: (...args: unknown[]) => Promise<void>;\n  error: (...args: unknown[]) => Promise<void>;\n  warn: (...args: unknown[]) => Promise<void>;\n  info: (...args: unknown[]) => Promise<void>;\n  success: (...args: unknown[]) => Promise<void>;\n  debug: (...args: unknown[]) => Promise<void>;\n  raw: (...args: unknown[]) => Promise<void>;\n}\n\ninterface Logger extends LoggerBase {\n  log: (...args: unknown[]) => void;\n  error: (...args: unknown[]) => void;\n  warn: (...args: unknown[]) => void;\n  info: (...args: unknown[]) => void;\n  success: (...args: unknown[]) => void;\n  debug: (...args: unknown[]) => void;\n  raw: (...args: unknown[]) => void;\n}\n\nexport const loggerAsync: LoggerAsync = {\n  log: createLogMethod(\"log\", true),\n  error: createLogMethod(\"error\", true, true),\n  warn: createLogMethod(\"warn\", true),\n  info: createLogMethod(\"info\", true),\n  success: createLogMethod(\"success\", true),\n  debug: createLogMethod(\"debug\", true),\n  raw: createRawMethod(true),\n};\n\nexport const logger: Logger = {\n  log: createLogMethod(\"log\", false),\n  error: createLogMethod(\"error\", false, true),\n  warn: createLogMethod(\"warn\", false),\n  info: createLogMethod(\"info\", false),\n  success: createLogMethod(\"success\", false),\n  debug: createLogMethod(\"debug\", false),\n  raw: createRawMethod(false),\n};\n",
    "type BaseOptions = {\n  /**\n   * Number of concurrently pending promises returned by `mapper`.\n   *\n   * Must be an integer from 1 and up or `Infinity`.\n   *\n   * @default Infinity\n   */\n  readonly concurrency?: number;\n};\n\nexport type Options = BaseOptions & {\n  /**\n   * When `true`, the first mapper rejection will be rejected back to the consumer.\n   *\n   * When `false`, instead of stopping when a promise rejects, it will wait for all\n   * the promises to settle and then reject with an `AggregateError` containing all\n   * the errors from the rejected promises.\n   *\n   * Caveat: When `true`, any already-started async mappers will continue to run\n   * until they resolve or reject. In the case of infinite concurrency with sync\n   * iterables, all mappers are invoked on startup and will continue after the first\n   * rejection. AbortControl can be used to stop pulling new items.\n   *\n   * @default true\n   */\n  readonly stopOnError?: boolean;\n\n  /**\n   * You can abort the promises using `AbortController`.\n   *\n   * Rejects with the `signal.reason` immediately, stops pulling new items, and\n   * attempts to close the underlying iterator via `.return()` if available.\n   */\n  readonly signal?: AbortSignal;\n};\n\nexport type IterableOptions = BaseOptions & {\n  /**\n   * Maximum number of promises returned by `mapper` that have resolved but not yet\n   * collected by the consumer of the async iterable. Calls to `mapper` will be\n   * limited so that there is never too much backpressure.\n   *\n   * Useful whenever you are consuming the iterable slower than what the mapper\n   * function can produce concurrently.\n   *\n   * Default: `options.concurrency`\n   */\n  readonly backpressure?: number;\n};\n\ntype MaybePromise<T> = T | Promise<T>;\n\n/**\n * Function which is called for every item in `input`. Expected to return a\n * `Promise` or value.\n *\n * @param element - Iterated element.\n * @param index - Index of the element in the source array.\n */\nexport type Mapper<Element = unknown, NewElement = unknown> = (\n  element: Element,\n  index: number,\n) => MaybePromise<NewElement | typeof pMapSkip>;\n\n/**\n * Return this value from a `mapper` function to skip including the value in the\n * returned array.\n */\nexport const pMapSkip = Symbol(\"skip\");\n\n/**\n * @param input - Synchronous or asynchronous iterable that is iterated over\n * concurrently, calling the `mapper` function for each element. Each iterated\n * item is `await`'d before the `mapper` is invoked so the iterable may return a\n * `Promise` that resolves to an item.\n * @param mapper - Function which is called for every item in `input`. Expected\n * to return a `Promise` or value.\n * @returns A `Promise` that is fulfilled when all promises in `input` and ones\n * returned from `mapper` are fulfilled, or rejects if any of the promises\n * reject. The fulfilled value is an `Array` of the fulfilled values returned\n * from `mapper` in `input` order, excluding `pMapSkip`.\n */\nexport default async function pMap<Element, NewElement>(\n  input:\n    | AsyncIterable<Element | Promise<Element>>\n    | Iterable<Element | Promise<Element>>,\n  mapper: Mapper<Element, NewElement>,\n  options: Options = {},\n): Promise<Array<Exclude<NewElement, typeof pMapSkip>>> {\n  const {\n    concurrency = Number.POSITIVE_INFINITY,\n    stopOnError = true,\n    signal,\n  } = options;\n\n  if (\n    !(\"Symbol\" in globalThis) ||\n    ((input as any)[Symbol.iterator] === undefined &&\n      (input as any)[Symbol.asyncIterator] === undefined)\n  ) {\n    throw new TypeError(\n      `Expected \\`input\\` to be either an \\`Iterable\\` or \\`AsyncIterable\\`, ` +\n        `got (${typeof input})`,\n    );\n  }\n\n  if (typeof mapper !== \"function\") {\n    throw new TypeError(\"Mapper function is required\");\n  }\n\n  if (\n    !(\n      (Number.isSafeInteger(concurrency) && concurrency >= 1) ||\n      concurrency === Number.POSITIVE_INFINITY\n    )\n  ) {\n    throw new TypeError(\n      `Expected \\`concurrency\\` to be an integer from 1 and up or ` +\n        `\\`Infinity\\`, got \\`${concurrency}\\` (${typeof concurrency})`,\n    );\n  }\n\n  return new Promise((resolve, reject) => {\n    const iterator =\n      (input as any)[Symbol.asyncIterator] !== undefined\n        ? (input as any)[Symbol.asyncIterator]()\n        : (input as any)[Symbol.iterator]();\n\n    const results: Array<NewElement | typeof pMapSkip> = [];\n    const errors: Error[] = [];\n\n    let activeCount = 0;\n    let currentIndex = 0;\n    let isIterableDone = false;\n    let isSettled = false;\n    let isPumping = false;\n    let iteratorClosed = false;\n\n    const safeCloseIterator = async () => {\n      if (iteratorClosed) return;\n      const ret = (iterator as any)?.return;\n      if (typeof ret === \"function\") {\n        try {\n          iteratorClosed = true;\n          await ret.call(iterator);\n        } catch {\n          // Swallow errors closing the iterator\n        }\n      } else {\n        iteratorClosed = true;\n      }\n    };\n\n    const onAbort = () => {\n      if (isSettled) return;\n      isSettled = true;\n      void safeCloseIterator();\n      cleanup();\n      reject(signal!.reason);\n    };\n\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n\n    function cleanup() {\n      signal?.removeEventListener(\"abort\", onAbort);\n    }\n\n    function settleWithAggregateIfNeeded() {\n      if (errors.length > 0 && !stopOnError) {\n        cleanup();\n        reject(new AggregateError(errors, \"One or more promises rejected\"));\n        return true;\n      }\n\n      return false;\n    }\n\n    function resolveResults() {\n      cleanup();\n      // Build filtered array in one pass, preserving order\n      const out: Array<Exclude<NewElement, typeof pMapSkip>> = [];\n      for (let i = 0; i < results.length; i++) {\n        const v = results[i];\n        if (v !== undefined && v !== pMapSkip) {\n          out.push(v as Exclude<NewElement, typeof pMapSkip>);\n        }\n      }\n      resolve(out);\n    }\n\n    function checkCompletion() {\n      if (isSettled) return;\n      if (!isIterableDone) return;\n      if (activeCount > 0) return;\n\n      isSettled = true;\n\n      if (settleWithAggregateIfNeeded()) {\n        return;\n      }\n\n      resolveResults();\n    }\n\n    async function startMapper(\n      valueOrPromise: Element | Promise<Element>,\n      index: number,\n    ) {\n      try {\n        const item = await valueOrPromise;\n        const result = await mapper(item, index);\n        if (!isSettled) {\n          results[index] = result;\n        }\n      } catch (error) {\n        if (isSettled) return;\n\n        if (stopOnError) {\n          isSettled = true;\n          void safeCloseIterator();\n          cleanup();\n          reject(error);\n          return;\n        }\n\n        errors.push(error as Error);\n      } finally {\n        if (!isSettled) {\n          activeCount--;\n          checkCompletion();\n          void pump();\n        }\n      }\n    }\n\n    async function pump() {\n      if (isSettled || isPumping) return;\n      isPumping = true;\n\n      try {\n        // Pull new items sequentially; never call iterator.next() concurrently.\n        while (!isSettled && !isIterableDone && activeCount < concurrency) {\n          let next:\n            | IteratorResult<Element | Promise<Element>>\n            | Promise<IteratorResult<Element | Promise<Element>>>;\n\n          try {\n            next = iterator.next();\n            // Ensure we await next in case it's a promise\n            next = await next;\n          } catch (error) {\n            if (!isSettled) {\n              isSettled = true;\n              void safeCloseIterator();\n              cleanup();\n              reject(error);\n            }\n            return;\n          }\n\n          if (next.done) {\n            isIterableDone = true;\n            break;\n          }\n\n          const index = currentIndex++;\n          activeCount++;\n          void startMapper(next.value, index);\n        }\n\n        checkCompletion();\n      } finally {\n        isPumping = false;\n      }\n    }\n\n    void pump();\n  });\n}\n\n/**\n * @param input - Synchronous or asynchronous iterable that is iterated over\n * concurrently, calling the `mapper` function for each element. Each iterated\n * item is `await`'d before the `mapper` is invoked so the iterable may return a\n * `Promise` that resolves to an item.\n * @param mapper - Function which is called for every item in `input`. Expected\n * to return a `Promise` or value.\n * @returns An async iterable that streams each return value from `mapper` in\n * order, excluding `pMapSkip`.\n */\nexport function pMapIterable<Element, NewElement>(\n  input:\n    | AsyncIterable<Element | Promise<Element>>\n    | Iterable<Element | Promise<Element>>,\n  mapper: Mapper<Element, NewElement>,\n  options: IterableOptions = {},\n): AsyncIterable<Exclude<NewElement, typeof pMapSkip>> {\n  const { concurrency = Number.POSITIVE_INFINITY, backpressure = concurrency } =\n    options;\n\n  if (\n    !(\"Symbol\" in globalThis) ||\n    ((input as any)[Symbol.iterator] === undefined &&\n      (input as any)[Symbol.asyncIterator] === undefined)\n  ) {\n    throw new TypeError(\n      `Expected \\`input\\` to be either an \\`Iterable\\` or \\`AsyncIterable\\`, ` +\n        `got (${typeof input})`,\n    );\n  }\n\n  if (typeof mapper !== \"function\") {\n    throw new TypeError(\"Mapper function is required\");\n  }\n\n  if (\n    !(\n      (Number.isSafeInteger(concurrency) && concurrency >= 1) ||\n      concurrency === Number.POSITIVE_INFINITY\n    )\n  ) {\n    throw new TypeError(\n      `Expected \\`concurrency\\` to be an integer from 1 and up or ` +\n        `\\`Infinity\\`, got \\`${concurrency}\\` (${typeof concurrency})`,\n    );\n  }\n\n  if (\n    !(\n      (Number.isSafeInteger(backpressure) && backpressure >= concurrency) ||\n      backpressure === Number.POSITIVE_INFINITY\n    )\n  ) {\n    throw new TypeError(\n      `Expected \\`backpressure\\` to be an integer from ` +\n        `\\`concurrency\\` (${concurrency}) and up or \\`Infinity\\`, got ` +\n        `\\`${backpressure}\\` (${typeof backpressure})`,\n    );\n  }\n\n  return {\n    async *[Symbol.asyncIterator]() {\n      const iterator =\n        (input as any)[Symbol.asyncIterator] !== undefined\n          ? (input as any)[Symbol.asyncIterator]()\n          : (input as any)[Symbol.iterator]();\n\n      type ResultItem = {\n        value?: NewElement | typeof pMapSkip;\n        error?: Error;\n        done: boolean;\n      };\n\n      const resultQueue: Array<Promise<ResultItem>> = [];\n      let runningCount = 0;\n      let currentIndex = 0;\n      let isDone = false;\n      let pulling = false;\n      let iteratorClosed = false;\n\n      const safeCloseIterator = async () => {\n        if (iteratorClosed) return;\n        const ret = (iterator as any)?.return;\n        if (typeof ret === \"function\") {\n          try {\n            iteratorClosed = true;\n            await ret.call(iterator);\n          } catch {\n            // Ignore errors closing the iterator\n          }\n        } else {\n          iteratorClosed = true;\n        }\n      };\n\n      const schedulePull = () => {\n        if (pulling || isDone) return;\n        pulling = true;\n\n        (async () => {\n          try {\n            while (\n              !isDone &&\n              runningCount < concurrency &&\n              resultQueue.length < backpressure\n            ) {\n              let next:\n                | IteratorResult<Element | Promise<Element>>\n                | Promise<IteratorResult<Element | Promise<Element>>>;\n\n              try {\n                next = iterator.next();\n                next = await next;\n              } catch (error) {\n                isDone = true;\n                resultQueue.push(\n                  Promise.resolve({\n                    error: error as Error,\n                    done: false,\n                  }),\n                );\n                break;\n              }\n\n              if (next.done) {\n                isDone = true;\n                // Push a terminal marker so the consumer can finish cleanly\n                resultQueue.push(Promise.resolve({ done: true }));\n                break;\n              }\n\n              const index = currentIndex++;\n              runningCount++;\n\n              const promise = (async (): Promise<ResultItem> => {\n                try {\n                  const element = await next.value;\n                  const result = await mapper(element, index);\n                  return { value: result, done: false };\n                } catch (error) {\n                  return { error: error as Error, done: false };\n                } finally {\n                  runningCount--;\n                  schedulePull();\n                }\n              })();\n\n              resultQueue.push(promise);\n            }\n          } finally {\n            pulling = false;\n          }\n        })();\n      };\n\n      schedulePull();\n\n      while (resultQueue.length > 0) {\n        const result = await resultQueue.shift()!;\n\n        if (result.error) {\n          await safeCloseIterator();\n          throw result.error;\n        }\n\n        if (result.done) {\n          await safeCloseIterator();\n          return;\n        }\n\n        schedulePull();\n\n        if (result.value !== pMapSkip) {\n          yield result.value as Exclude<NewElement, typeof pMapSkip>;\n        }\n      }\n\n      // If we exhausted the queue without seeing a done marker, ensure cleanup.\n      await safeCloseIterator();\n    },\n  };\n}\n",
    "// packages/launcher/src/impl/launcher/discovery.ts\n\nimport pMap from \"@reliverse/dler-mapper\";\nimport { Glob } from \"bun\";\nimport { loadMetadataCache, saveMetadataCache } from \"./cache\";\nimport { CommandLoadError } from \"./errors\";\nimport type {\n  CmdDefinition,\n  CmdMetadata,\n  CmdNode,\n  DiscoveryResult,\n} from \"./types\";\n\n// Cache for file stats to avoid repeated filesystem calls\nconst fileStatsCache = new Map<string, { mtime: number; size: number }>();\n\n// Module instance cache to prevent duplicate imports\nconst moduleCache = new Map<string, CmdDefinition>();\n\nconst getFileStats = async (filePath: string) => {\n  const cached = fileStatsCache.get(filePath);\n  if (cached) return cached;\n\n  const stats = await Bun.file(filePath).stat();\n  const result = { mtime: stats.mtime.getTime(), size: stats.size };\n  fileStatsCache.set(filePath, result);\n  return result;\n};\n\n// Lazy metadata loader that only loads when needed\nconst createLazyMetadataLoader = (filePath: string, cmdName: string) => {\n  let cachedMetadata: CmdMetadata | null = null;\n  let isLoading = false;\n  let loadPromise: Promise<CmdMetadata> | null = null;\n\n  return async (): Promise<CmdMetadata> => {\n    if (cachedMetadata) return cachedMetadata;\n\n    if (isLoading && loadPromise) {\n      return loadPromise;\n    }\n\n    isLoading = true;\n    loadPromise = (async () => {\n      try {\n        // Only load the module to extract metadata, don't execute handler\n        const module = await import(filePath);\n        const definition = module.default;\n\n        if (!definition || !definition.cfg) {\n          throw new Error(\"Invalid command definition\");\n        }\n\n        const cmdMetadata: CmdMetadata = {\n          name: definition.cfg.name,\n          description: definition.cfg.description,\n          aliases: definition.cfg.aliases,\n          version: definition.cfg.version,\n          examples: definition.cfg.examples,\n        };\n\n        cachedMetadata = cmdMetadata;\n        return cmdMetadata;\n      } catch (error) {\n        throw new CommandLoadError(cmdName, error);\n      } finally {\n        isLoading = false;\n        loadPromise = null;\n      }\n    })();\n\n    return loadPromise;\n  };\n};\n\nexport const discoverCommands = async (\n  cmdsDir: string,\n  baseDir?: string,\n): Promise<DiscoveryResult> => {\n  const registry = new Map();\n  const aliases = new Map();\n  const metadata = new Map<string, () => Promise<CmdMetadata>>();\n  const hierarchy = new Map<string, CmdNode>();\n  const rootCommands = new Set<string>();\n  const fileStats = new Map<string, { mtime: number; size: number }>();\n  const filePaths = new Map<string, string>();\n  const loadedMetadata = new Map<string, CmdMetadata>();\n\n  // Try to load from cache first\n  const cachedMetadata = await loadMetadataCache();\n  const cachedMetadataMap = new Map<string, CmdMetadata>();\n\n  if (cachedMetadata) {\n    for (const [cmdName, cmdMetadata] of cachedMetadata) {\n      cachedMetadataMap.set(cmdName, cmdMetadata);\n    }\n  }\n\n  const glob = new Glob(\"**/cmd.ts\");\n  const cwd = baseDir ? `${baseDir}/${cmdsDir}` : `${process.cwd()}/${cmdsDir}`;\n\n  // Collect all files first, then process in parallel\n  const files = await Array.fromAsync(glob.scan(cwd));\n\n  // Process all files in parallel with controlled concurrency\n  const fileData = await pMap(\n    files,\n    async (file) => {\n      const pathParts = file.split(/[/\\\\]/);\n      const cmdName = pathParts[pathParts.length - 2]; // Get parent directory name\n      const filePath = `${cwd}/${file}`;\n      const stats = await getFileStats(filePath);\n\n      // Calculate depth and parent\n      const depth = pathParts.length - 1; // Subtract 1 for cmd.ts\n      const parent = depth > 1 ? pathParts[0] : undefined;\n      const fullPath = pathParts.slice(0, -1).join(\"/\"); // Full path without cmd.ts\n\n      return {\n        cmdName: cmdName!,\n        filePath,\n        stats,\n        file,\n        depth,\n        parent,\n        fullPath,\n      };\n    },\n    { concurrency: 10 }, // Limit concurrency to avoid overwhelming filesystem\n  );\n\n  // Process all file data\n  for (const {\n    cmdName,\n    filePath,\n    stats,\n    depth,\n    parent,\n    fullPath,\n  } of fileData) {\n    const loader = async (): Promise<CmdDefinition> => {\n      // Check module cache first\n      if (moduleCache.has(filePath)) {\n        return moduleCache.get(filePath)!;\n      }\n\n      try {\n        const module = await import(filePath);\n        const definition = module.default;\n\n        if (!definition || typeof definition.handler !== \"function\") {\n          throw new Error(\"Invalid command definition\");\n        }\n\n        // Cache the module instance\n        moduleCache.set(filePath, definition);\n        return definition;\n      } catch (error) {\n        throw new CommandLoadError(cmdName, error);\n      }\n    };\n\n    fileStats.set(cmdName, stats);\n    filePaths.set(cmdName, filePath);\n\n    // Check if we have valid cached metadata\n    const cachedMeta = cachedMetadataMap.get(cmdName);\n    if (cachedMeta && (await isCacheValid(filePath, stats))) {\n      // Use cached metadata\n      const lazyMetadataLoader = () => Promise.resolve(cachedMeta);\n      metadata.set(cmdName, lazyMetadataLoader);\n      loadedMetadata.set(cmdName, cachedMeta);\n\n      // Register aliases from cached metadata\n      if (cachedMeta.aliases) {\n        for (const alias of cachedMeta.aliases) {\n          aliases.set(alias, cmdName);\n        }\n      }\n    } else {\n      // Create lazy metadata loader for uncached commands\n      const lazyMetadataLoader = createLazyMetadataLoader(filePath, cmdName);\n      metadata.set(cmdName, lazyMetadataLoader);\n    }\n\n    registry.set(cmdName, loader);\n\n    // Create command node for hierarchy\n    const cmdNode: CmdNode = {\n      name: cmdName,\n      path: fullPath,\n      depth,\n      parent,\n      children: new Map(),\n      loader,\n      metadata: metadata.get(cmdName)!,\n    };\n\n    hierarchy.set(cmdName, cmdNode);\n\n    // Track root commands (depth 1)\n    if (depth === 1) {\n      rootCommands.add(cmdName);\n    }\n  }\n\n  // Build parent-child relationships\n  for (const [cmdName, node] of hierarchy) {\n    if (node.parent) {\n      const parentNode = hierarchy.get(node.parent);\n      if (parentNode) {\n        parentNode.children.set(cmdName, node);\n      }\n    }\n  }\n\n  // Save updated cache in background (don't await)\n  saveMetadataCache(loadedMetadata, fileStats, filePaths).catch(() => {\n    // Ignore cache save errors\n  });\n\n  return { registry, aliases, metadata, hierarchy, rootCommands };\n};\n\nconst isCacheValid = async (\n  filePath: string,\n  stats: { mtime: number; size: number },\n): Promise<boolean> => {\n  try {\n    const file = Bun.file(filePath);\n    const fileStats = await file.stat();\n    return (\n      fileStats.mtime.getTime() === stats.mtime && fileStats.size === stats.size\n    );\n  } catch {\n    return false;\n  }\n};\n\nexport const validateCommandStructure = (\n  definition: unknown,\n): definition is CmdDefinition => {\n  if (typeof definition !== \"object\" || definition === null) return false;\n\n  const def = definition as Record<string, unknown>;\n\n  return (\n    typeof def.handler === \"function\" &&\n    typeof def.args === \"object\" &&\n    def.args !== null &&\n    typeof def.cfg === \"object\" &&\n    def.cfg !== null &&\n    typeof (def.cfg as Record<string, unknown>).name === \"string\"\n  );\n};\n",
    "// packages/launcher/src/impl/launcher/cache.ts\n\nimport { existsSync, mkdirSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport pMap from \"@reliverse/dler-mapper\";\nimport type { CmdMetadata } from \"./types\";\n\ninterface CacheEntry {\n  metadata: CmdMetadata;\n  filePath: string;\n  mtime: number;\n  size: number;\n}\n\ninterface CacheData {\n  entries: Record<string, CacheEntry>;\n  version: string;\n}\n\nconst CACHE_VERSION = \"1.0.0\";\nconst CACHE_DIR = \".reliverse/dler/cache/launcher\";\nconst CACHE_FILE = \"metadata.json\";\n\nconst getCachePath = (): string => {\n  const homeDir = homedir();\n  const cacheDir = join(homeDir, CACHE_DIR);\n  if (!existsSync(cacheDir)) {\n    mkdirSync(cacheDir, { recursive: true });\n  }\n  return join(cacheDir, CACHE_FILE);\n};\n\nconst isCacheValid = async (entry: CacheEntry): Promise<boolean> => {\n  try {\n    const file = Bun.file(entry.filePath);\n    const stats = await file.stat();\n    return entry.mtime === stats.mtime.getTime() && entry.size === stats.size;\n  } catch {\n    return false;\n  }\n};\n\nexport const loadMetadataCache = async (): Promise<Map<\n  string,\n  CmdMetadata\n> | null> => {\n  const cachePath = getCachePath();\n\n  if (!existsSync(cachePath)) {\n    return null;\n  }\n\n  try {\n    const cacheFile = Bun.file(cachePath);\n    const cacheData: CacheData = await cacheFile.json();\n\n    if (cacheData.version !== CACHE_VERSION) {\n      return null;\n    }\n\n    // Validate all cache entries in parallel with controlled concurrency\n    const results = await pMap(\n      Object.entries(cacheData.entries),\n      async ([cmdName, entry]) => ({\n        cmdName,\n        metadata: (await isCacheValid(entry)) ? entry.metadata : null,\n      }),\n      { concurrency: 20 }, // Higher concurrency for cache validation\n    );\n\n    const metadataMap = new Map<string, CmdMetadata>();\n    for (const { cmdName, metadata } of results) {\n      if (metadata) {\n        metadataMap.set(cmdName, metadata);\n      }\n    }\n\n    return metadataMap.size > 0 ? metadataMap : null;\n  } catch {\n    return null;\n  }\n};\n\nexport const saveMetadataCache = async (\n  metadata: Map<string, CmdMetadata>,\n  fileStats: Map<string, { mtime: number; size: number }>,\n  filePaths: Map<string, string>,\n): Promise<void> => {\n  const cachePath = getCachePath();\n  const entries: Record<string, CacheEntry> = {};\n\n  for (const [cmdName, cmdMetadata] of metadata) {\n    const stats = fileStats.get(cmdName);\n    const filePath = filePaths.get(cmdName);\n    if (stats && filePath) {\n      entries[cmdName] = {\n        metadata: cmdMetadata,\n        filePath,\n        mtime: stats.mtime,\n        size: stats.size,\n      };\n    }\n  }\n\n  const cacheData: CacheData = {\n    entries,\n    version: CACHE_VERSION,\n  };\n\n  await Bun.write(cachePath, JSON.stringify(cacheData, null, 2));\n};\n\nexport const clearMetadataCache = (): void => {\n  const cachePath = getCachePath();\n  if (existsSync(cachePath)) {\n    Bun.write(cachePath, \"{}\");\n  }\n};\n",
    "// packages/launcher/src/impl/launcher/errors.ts\n\nexport class LauncherError extends Error {\n  constructor(\n    message: string,\n    public code: string,\n  ) {\n    super(message);\n    this.name = \"LauncherError\";\n  }\n}\n\nexport class CommandNotFoundError extends LauncherError {\n  constructor(cmdName: string, availableCmds: string[]) {\n    super(\n      `Command \"${cmdName}\" not found. Available commands: ${availableCmds.join(\", \")}`,\n      \"CMD_NOT_FOUND\",\n    );\n    this.name = \"CommandNotFoundError\";\n  }\n}\n\nexport class ArgumentValidationError extends LauncherError {\n  constructor(\n    public argName: string,\n    public reason: string,\n  ) {\n    super(`Invalid argument \"${argName}\": ${reason}`, \"ARG_VALIDATION_ERROR\");\n    this.name = \"ArgumentValidationError\";\n  }\n}\n\nexport class CommandLoadError extends LauncherError {\n  constructor(cmdName: string, cause: unknown) {\n    super(`Failed to load command \"${cmdName}\"`, \"CMD_LOAD_ERROR\");\n    this.name = \"CommandLoadError\";\n    this.cause = cause;\n  }\n}\n",
    "// packages/launcher/src/impl/launcher/help.ts\n\nimport pMap from \"@reliverse/dler-mapper\";\nimport type {\n  CmdArgsSchema,\n  CmdDefinition,\n  CmdMetadata,\n  DiscoveryResult,\n} from \"./types\";\n\n// Pre-computed help templates to avoid string concatenation\nconst HELP_TEMPLATES = {\n  commandHeader: (name: string, description: string) =>\n    `\\n${name} - ${description}`,\n  version: (version: string) => `Version: ${version}`,\n  usage: (name: string) => `\\nUsage:\\n  ${name} [options]`,\n  usageWithSubCommands: (name: string) =>\n    `\\nUsage:\\n  ${name} [subcommand] [options]`,\n  optionsHeader: `\\nOptions:`,\n  requiredNote: `\\n* = required`,\n  examplesHeader: `\\nExamples:`,\n  globalHeader: `\\nAvailable commands:\\n`,\n  helpFooter: `\\nUse \"command --help\" for command-specific help\\n`,\n} as const;\n\nconst formatArgName = (name: string, def: CmdArgsSchema[string]): string => {\n  const aliases = def.aliases ? ` (-${def.aliases.join(\", -\")})` : \"\";\n  const required = def.required ? \"*\" : \"\";\n  return `--${name}${aliases}${required}`;\n};\n\nconst formatArgType = (def: CmdArgsSchema[string]): string => {\n  if (def.type === \"boolean\") return \"\";\n  return `<${def.type}>`;\n};\n\n// Cache for formatted argument help to avoid recomputation\nconst argHelpCache = new Map<string, string>();\n\n// Cache for generated help text with file hash validation\ninterface HelpCacheEntry {\n  commandHelp: string;\n  globalHelp: string;\n  fileHash: string;\n  lastModified: number;\n}\n\nconst helpCache = new Map<string, HelpCacheEntry>();\n\nconst getArgHelp = (name: string, def: CmdArgsSchema[string]): string => {\n  const cacheKey = `${name}:${JSON.stringify(def)}`;\n  let cached = argHelpCache.get(cacheKey);\n\n  if (!cached) {\n    const argName = formatArgName(name, def);\n    const argType = formatArgType(def);\n    const desc = def.description ?? \"\";\n    const defaultVal =\n      \"default\" in def && def.default !== undefined\n        ? ` (default: ${def.default})`\n        : \"\";\n\n    cached = `  ${argName} ${argType}\\n      ${desc}${defaultVal}`;\n    argHelpCache.set(cacheKey, cached);\n  }\n\n  return cached;\n};\n\nexport const generateCommandHelp = async (\n  definition: CmdDefinition,\n): Promise<string> => {\n  const { cfg, args } = definition;\n\n  // Create cache key based on command configuration\n  const cacheKey = `${cfg.name}:${JSON.stringify(cfg)}:${JSON.stringify(args)}`;\n  const cached = helpCache.get(cacheKey);\n\n  if (cached) {\n    return cached.commandHelp;\n  }\n\n  const lines: string[] = [\n    HELP_TEMPLATES.commandHeader(\n      cfg.name,\n      cfg.description || \"No description available\",\n    ),\n  ];\n\n  if (cfg.version) {\n    lines.push(HELP_TEMPLATES.version(cfg.version));\n  }\n\n  lines.push(HELP_TEMPLATES.usage(cfg.name));\n\n  if (Object.keys(args).length > 0) {\n    lines.push(HELP_TEMPLATES.optionsHeader);\n\n    // Use cached argument help\n    for (const [name, def] of Object.entries(args)) {\n      lines.push(getArgHelp(name, def));\n    }\n\n    lines.push(HELP_TEMPLATES.requiredNote);\n  }\n\n  if (cfg.examples && cfg.examples.length > 0) {\n    lines.push(HELP_TEMPLATES.examplesHeader);\n    for (const example of cfg.examples) {\n      lines.push(`  ${example}`);\n    }\n  }\n\n  const helpText = lines.join(\"\\n\");\n\n  // Cache the generated help\n  helpCache.set(cacheKey, {\n    commandHelp: helpText,\n    globalHelp: \"\",\n    fileHash: \"\",\n    lastModified: Date.now(),\n  });\n\n  return helpText;\n};\n\n// Cache for command help formatting\nconst commandHelpCache = new Map<string, string>();\n\nconst formatCommandHelp = (name: string, metadata: CmdMetadata): string => {\n  const cacheKey = `${name}:${JSON.stringify(metadata)}`;\n  let cached = commandHelpCache.get(cacheKey);\n\n  if (!cached) {\n    const aliases = metadata.aliases ? ` (${metadata.aliases.join(\", \")})` : \"\";\n    const description = metadata.description || \"No description available\";\n    cached = `  ${name}${aliases}\\n      ${description}`;\n    commandHelpCache.set(cacheKey, cached);\n  }\n\n  return cached;\n};\n\nexport const generateGlobalHelp = async (\n  registry: DiscoveryResult,\n): Promise<string> => {\n  // Create cache key for global help\n  const cacheKey = `global:${Array.from(registry.metadata.keys()).sort().join(\",\")}`;\n  const cached = helpCache.get(cacheKey);\n\n  if (cached && cached.globalHelp) {\n    return cached.globalHelp;\n  }\n\n  const lines: string[] = [HELP_TEMPLATES.globalHeader];\n\n  // Load all metadata in parallel with controlled concurrency\n  const metadataResults = await pMap(\n    Array.from(registry.metadata.entries()),\n    async ([name, metadataLoader]) => {\n      const metadata = await metadataLoader();\n      return [name, metadata] as [string, CmdMetadata];\n    },\n    { concurrency: 5 }, // Limit concurrency for metadata loading\n  );\n\n  // Sort commands alphabetically by name\n  metadataResults.sort(([a], [b]) => a.localeCompare(b));\n\n  // Build help text using cached formatting\n  for (const [name, metadata] of metadataResults) {\n    lines.push(formatCommandHelp(name, metadata));\n  }\n\n  lines.push(HELP_TEMPLATES.helpFooter);\n\n  const helpText = lines.join(\"\\n\");\n\n  // Cache the global help\n  helpCache.set(cacheKey, {\n    commandHelp: \"\",\n    globalHelp: helpText,\n    fileHash: \"\",\n    lastModified: Date.now(),\n  });\n\n  return helpText;\n};\n",
    "// packages/launcher/src/impl/launcher/validator.ts\n\nimport { ArgumentValidationError } from \"./errors\";\nimport type { CmdArgDefinition, CmdArgsSchema } from \"./types\";\n\nexport const validateArgValue = (\n  argName: string,\n  value: unknown,\n  definition: CmdArgDefinition,\n): boolean => {\n  const expectedType =\n    definition.type === \"boolean\"\n      ? \"boolean\"\n      : definition.type === \"number\"\n        ? \"number\"\n        : \"string\";\n\n  if (typeof value !== expectedType) {\n    throw new ArgumentValidationError(\n      argName,\n      `Expected ${expectedType}, got ${typeof value}`,\n    );\n  }\n\n  if (\"validate\" in definition && definition.validate) {\n    const result = definition.validate(value as never);\n    if (result !== true) {\n      throw new ArgumentValidationError(\n        argName,\n        typeof result === \"string\" ? result : \"Validation failed\",\n      );\n    }\n  }\n\n  return true;\n};\n\nexport const validateRequiredArgs = (\n  args: Record<string, unknown>,\n  schema: CmdArgsSchema,\n): void => {\n  for (const [key, def] of Object.entries(schema)) {\n    if (def.required && !(key in args)) {\n      throw new ArgumentValidationError(\n        key,\n        `Required argument \"${key}\" is missing`,\n      );\n    }\n  }\n};\n",
    "// packages/launcher/src/impl/launcher/parser.ts\n\nimport { ArgumentValidationError } from \"./errors\";\nimport type { CmdArgsSchema } from \"./types\";\nimport { validateArgValue } from \"./validator\";\n\ninterface ParseResult {\n  cmdName: string;\n  parsedArgs: Record<string, unknown>;\n}\n\ninterface ChainParseResult {\n  cmdChain: string[];\n  parsedArgs: Record<string, unknown>[];\n  remainingArgs: string[];\n}\n\ninterface SchemaMetadata {\n  aliasMap: Map<string, string>;\n  camelCaseCache: Map<string, string>;\n  defaults: Record<string, unknown>;\n  requiredKeys: Set<string>;\n  availableKeys: string[];\n}\n\nconst camelCase = (str: string): string =>\n  str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n\n// Global cache for schema metadata to avoid recomputation\nconst schemaMetadataCache = new Map<string, SchemaMetadata>();\n\nconst createSchemaMetadata = (schema: CmdArgsSchema): SchemaMetadata => {\n  const aliasMap = new Map<string, string>();\n  const camelCaseCache = new Map<string, string>();\n  const defaults: Record<string, unknown> = {};\n  const requiredKeys = new Set<string>();\n  const availableKeys: string[] = [];\n\n  for (const [key, def] of Object.entries(schema)) {\n    availableKeys.push(key);\n\n    // Pre-cache camelCase conversion for main key\n    const camelKey = camelCase(key);\n    if (camelKey !== key) {\n      camelCaseCache.set(key, camelKey);\n    }\n\n    // Handle aliases\n    if (def.aliases) {\n      for (const alias of def.aliases) {\n        aliasMap.set(alias, key);\n        // Pre-cache camelCase conversion for aliases\n        const camelAlias = camelCase(alias);\n        if (camelAlias !== alias) {\n          camelCaseCache.set(alias, camelAlias);\n        }\n      }\n    }\n\n    // Track defaults and required keys\n    if (\"default\" in def && def.default !== undefined) {\n      defaults[key] = def.default;\n    }\n    if (def.required) {\n      requiredKeys.add(key);\n    }\n  }\n\n  return {\n    aliasMap,\n    camelCaseCache,\n    defaults,\n    requiredKeys,\n    availableKeys,\n  };\n};\n\n// Lightweight hash function for schema keys\nconst hashSchema = (schema: CmdArgsSchema): string => {\n  const keys = Object.keys(schema).sort();\n  return keys.join(\"|\");\n};\n\nconst getSchemaMetadata = (schema: CmdArgsSchema): SchemaMetadata => {\n  // Create a cache key from schema structure using lightweight hash\n  const schemaKey = hashSchema(schema);\n\n  let metadata = schemaMetadataCache.get(schemaKey);\n  if (!metadata) {\n    metadata = createSchemaMetadata(schema);\n    schemaMetadataCache.set(schemaKey, metadata);\n  }\n\n  return metadata;\n};\n\nexport const parseArgs = (\n  argv: string[],\n  schema: CmdArgsSchema,\n): ParseResult => {\n  const [cmdName, ...rawArgs] = argv;\n\n  if (!cmdName) {\n    throw new ArgumentValidationError(\"command\", \"No command provided\");\n  }\n\n  // Get pre-computed schema metadata\n  const { aliasMap, camelCaseCache, defaults, requiredKeys, availableKeys } =\n    getSchemaMetadata(schema);\n\n  const parsedArgs: Record<string, unknown> = { ...defaults };\n\n  // Single-pass argument parsing\n  for (let i = 0; i < rawArgs.length; i++) {\n    const arg = rawArgs[i];\n    if (!arg || !arg.startsWith(\"-\")) continue;\n\n    const isLongForm = arg.startsWith(\"--\");\n    const flagName = arg.slice(isLongForm ? 2 : 1);\n    const actualKey =\n      aliasMap.get(flagName) ??\n      camelCaseCache.get(flagName) ??\n      camelCase(flagName);\n\n    const definition = schema[actualKey];\n\n    if (!definition) {\n      throw new ArgumentValidationError(\n        flagName,\n        `Unknown argument. Available: ${availableKeys.join(\", \")}`,\n      );\n    }\n\n    if (definition.type === \"boolean\") {\n      parsedArgs[actualKey] = true;\n      continue;\n    }\n\n    const nextArg = rawArgs[++i];\n    if (nextArg === undefined || nextArg.startsWith(\"-\")) {\n      throw new ArgumentValidationError(\n        flagName,\n        `Expected value for argument \"${flagName}\"`,\n      );\n    }\n\n    let value: string | number = nextArg;\n    if (definition.type === \"number\") {\n      value = Number(nextArg);\n      if (Number.isNaN(value)) {\n        throw new ArgumentValidationError(\n          flagName,\n          `Expected number, got \"${nextArg}\"`,\n        );\n      }\n    }\n\n    validateArgValue(actualKey, value, definition);\n    parsedArgs[actualKey] = value;\n  }\n\n  // Validate required arguments\n  for (const requiredKey of requiredKeys) {\n    if (!(requiredKey in parsedArgs)) {\n      throw new ArgumentValidationError(\n        requiredKey,\n        `Required argument \"${requiredKey}\" is missing`,\n      );\n    }\n  }\n\n  return { cmdName, parsedArgs };\n};\n\nexport const parseCommandChain = (\n  argv: string[],\n  schemas: CmdArgsSchema[],\n): ChainParseResult => {\n  const cmdChain: string[] = [];\n  const parsedArgs: Record<string, unknown>[] = [];\n  let remainingArgs = [...argv];\n\n  for (let i = 0; i < schemas.length; i++) {\n    const schema = schemas[i];\n    if (!schema) break;\n\n    // Find the next command in the chain\n    let cmdName = \"\";\n    let argsStartIndex = 0;\n\n    for (let j = 0; j < remainingArgs.length; j++) {\n      const arg = remainingArgs[j];\n      if (arg && !arg.startsWith(\"-\")) {\n        cmdName = arg;\n        argsStartIndex = j + 1;\n        break;\n      }\n    }\n\n    if (!cmdName) {\n      throw new ArgumentValidationError(\"command\", \"No command provided\");\n    }\n\n    cmdChain.push(cmdName);\n\n    // Extract args for this command\n    const commandArgs: string[] = [];\n    for (let j = argsStartIndex; j < remainingArgs.length; j++) {\n      const arg = remainingArgs[j];\n      if (!arg) continue;\n\n      if (!arg.startsWith(\"-\")) {\n        // Found next command, stop here\n        remainingArgs = remainingArgs.slice(j);\n        break;\n      }\n      commandArgs.push(arg);\n    }\n\n    // Parse args for this command\n    const { parsedArgs: cmdParsedArgs } = parseArgs(\n      [cmdName, ...commandArgs],\n      schema,\n    );\n    parsedArgs.push(cmdParsedArgs);\n  }\n\n  return { cmdChain, parsedArgs, remainingArgs };\n};\n",
    "// packages/launcher/src/impl/launcher/registry.ts\n\nimport type { CmdNode, DiscoveryResult } from \"./types\";\n\nlet cachedRegistry: DiscoveryResult | null = null;\n\nexport const getRegistry = (): DiscoveryResult | null => cachedRegistry;\n\nexport const setRegistry = (registry: DiscoveryResult): void => {\n  cachedRegistry = registry;\n};\n\nexport const clearRegistry = (): void => {\n  cachedRegistry = null;\n};\n\nexport const resolveCommand = (\n  registry: DiscoveryResult,\n  cmdNameOrAlias: string,\n): string => {\n  const resolvedName = registry.aliases.get(cmdNameOrAlias) ?? cmdNameOrAlias;\n  return resolvedName;\n};\n\nexport const resolveCommandChain = (\n  registry: DiscoveryResult,\n  cmdChain: string[],\n): { parent?: CmdNode; child?: CmdNode; fullPath: string[] } => {\n  if (cmdChain.length === 0) {\n    throw new Error(\"Empty command chain\");\n  }\n\n  if (cmdChain.length === 1) {\n    const cmdName = resolveCommand(registry, cmdChain[0]!);\n    const node = registry.hierarchy.get(cmdName);\n    if (!node) {\n      throw new Error(`Command not found: ${cmdChain[0]}`);\n    }\n    return { fullPath: [cmdName] };\n  }\n\n  // Multi-level command chain\n  const parentName = resolveCommand(registry, cmdChain[0]!);\n  const childName = resolveCommand(registry, cmdChain[1]!);\n\n  const parentNode = registry.hierarchy.get(parentName);\n  const childNode = registry.hierarchy.get(childName);\n\n  if (!parentNode) {\n    throw new Error(`Parent command not found: ${cmdChain[0]}`);\n  }\n\n  if (!childNode || childNode.parent !== parentName) {\n    throw new Error(\n      `Sub-command not found: ${cmdChain[1]} under ${cmdChain[0]}`,\n    );\n  }\n\n  return {\n    parent: parentNode,\n    child: childNode,\n    fullPath: [parentName, childName],\n  };\n};\n",
    "#!/usr/bin/env bun\n\n// 👉 bun dler <cmd> <args>\n// 💡 dler === apps/dler/src/cli.ts\n\nimport { runLauncher } from \"@reliverse/dler-launcher\";\n\nawait runLauncher(import.meta.url);\n"
  ],
  "mappings": "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",
  "debugId": "E90D77EA3D02CDB664756E2164756E21",
  "names": []
}