@reliverse/rempts 1.7.49 → 1.7.51

package/dist-npm/bin/mod.mjs

@@ -16,23 +16,13 @@ import readline__default from 'node:readline';
 import { ReadStream, WriteStream } from 'node:tty';
 import readline$1 from 'node:readline/promises';
 import { repeat, digit, buildRegExp, startOfString, endOfString } from 'ts-regex-builder';
-import path, { resolve, dirname } from '@reliverse/pathkit';
-import fs from '@reliverse/relifso';
-import { loadConfig } from 'c12';
-import termkit from 'terminal-kit';
+import { realpathSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
+import path from 'path';
+import readline$2 from 'readline';
 import { homedir } from 'node:os';
-import { createJiti } from 'jiti';
-import { reliArgParser } from '@reliverse/reliarg';
+import { readdir, stat } from 'node:fs/promises';
 import { readPackageJSON } from 'pkg-types';
-import { inspect } from 'node:util';
-import * as trpcServer11 from '@trpc/server';
-export { trpcServer11 as trpcServer };
-import { Command, Option, Argument, InvalidArgumentError } from 'commander';
-import * as zod4 from 'zod/v4/core';
-import zodToJsonSchema from 'zod-to-json-schema';
-import * as zod from 'zod';
-export { zod };
-export { z } from 'zod/v4';
 
 const colorMap = {
   // @reliverse/relico
@@ -1374,7 +1364,275 @@ async function datePrompt(opts) {
   }
 }
 
-const { terminal: term } = termkit;
+class TerminalInterface {
+  rl;
+  _width;
+  _height;
+  keyListeners = [];
+  resizeListeners = [];
+  constructor() {
+    this.rl = readline$2.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    });
+    this._width = process.stdout.columns || 80;
+    this._height = process.stdout.rows || 24;
+    process.stdout.on("resize", () => {
+      this._width = process.stdout.columns || 80;
+      this._height = process.stdout.rows || 24;
+      this.resizeListeners.forEach((listener) => listener(this._width, this._height));
+    });
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (data) => {
+      const key = this.parseKey(data);
+      if (key) {
+        this.keyListeners.forEach(
+          (listener) => listener(key, [], {
+            isCharacter: this.isCharacter(key),
+            code: data,
+            codepoint: data.toString().charCodeAt(0)
+          })
+        );
+      }
+    });
+  }
+  parseKey(data) {
+    const str = data.toString();
+    if (str === "") return "CTRL_C";
+    if (str === "
") return "CTRL_A";
+    if (str === "") return "CTRL_O";
+    if (str === "") return "CTRL_S";
+    if (str === "") return "CTRL_X";
+    if (str === "") return "CTRL_F";
+    if (str === "\v") return "CTRL_K";
+    if (str === "") return "CTRL_U";
+    if (str === "") return "CTRL_T";
+    if (str === "	") return "TAB";
+    if (str === "\r" || str === "\n") return "ENTER";
+    if (str === "\x7F" || str === "\b") return "BACKSPACE";
+    if (str === "\x1B[3~") return "DELETE";
+    if (str === "\x1B[A") return "UP";
+    if (str === "\x1B[B") return "DOWN";
+    if (str === "\x1B[C") return "RIGHT";
+    if (str === "\x1B[D") return "LEFT";
+    if (str === "\x1B[5~") return "PAGE_UP";
+    if (str === "\x1B[6~") return "PAGE_DOWN";
+    if (str === "\x1B[H") return "HOME";
+    if (str === "\x1B[F") return "END";
+    if (str === "\x1B[1;5H") return "CTRL_HOME";
+    if (str === "\x1B[1;5F") return "CTRL_END";
+    if (str === "\x1B[1;3C") return "ALT_C";
+    if (str === "\x1B[2;2~") return "SHIFT_INSERT";
+    if (str === "\x1B[2;5~") return "CTRL_INSERT";
+    return str.length === 1 ? str : "";
+  }
+  isCharacter(key) {
+    return key.length === 1 && !key.startsWith("\x1B") && ![
+      "CTRL_C",
+      "CTRL_A",
+      "CTRL_O",
+      "CTRL_S",
+      "CTRL_X",
+      "CTRL_F",
+      "CTRL_K",
+      "CTRL_U",
+      "CTRL_T",
+      "TAB",
+      "ENTER",
+      "BACKSPACE",
+      "DELETE",
+      "UP",
+      "DOWN",
+      "RIGHT",
+      "LEFT",
+      "PAGE_UP",
+      "PAGE_DOWN",
+      "HOME",
+      "END",
+      "CTRL_HOME",
+      "CTRL_END",
+      "ALT_C",
+      "SHIFT_INSERT",
+      "CTRL_INSERT"
+    ].includes(key);
+  }
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  fullscreen(enabled) {
+    if (enabled) {
+      process.stdout.write("\x1B[?1049h");
+    } else {
+      process.stdout.write("\x1B[?1049l");
+    }
+  }
+  grabInput(enabled) {
+    if (enabled) {
+      process.stdin.setRawMode(true);
+    } else {
+      process.stdin.setRawMode(false);
+    }
+  }
+  on(event, listener) {
+    if (event === "key") {
+      this.keyListeners.push(listener);
+    } else if (event === "resize") {
+      this.resizeListeners.push(listener);
+    }
+  }
+  off(event, listener) {
+    if (event === "key") {
+      const index = this.keyListeners.indexOf(listener);
+      if (index > -1) this.keyListeners.splice(index, 1);
+    } else if (event === "resize") {
+      const index = this.resizeListeners.indexOf(listener);
+      if (index > -1) this.resizeListeners.splice(index, 1);
+    }
+  }
+  moveTo(x, y) {
+    process.stdout.write(ansiEscapes.cursorTo(x, y));
+  }
+  clear() {
+    process.stdout.write(ansiEscapes.clearScreen);
+  }
+  eraseLine() {
+    process.stdout.write(ansiEscapes.eraseLine);
+  }
+  eraseLineAfter() {
+    process.stdout.write(ansiEscapes.eraseLine);
+  }
+  hideCursor() {
+    process.stdout.write(cursor.hide);
+  }
+  restoreCursor() {
+    process.stdout.write(cursor.show);
+  }
+  styleReset() {
+    process.stdout.write(ansiEscapes.cursorShow + "\x1B[0m");
+  }
+  bgColor(color) {
+    const colorMap = {
+      black: "\x1B[40m",
+      white: "\x1B[47m",
+      red: "\x1B[41m",
+      green: "\x1B[42m",
+      yellow: "\x1B[43m",
+      blue: "\x1B[44m",
+      magenta: "\x1B[45m",
+      cyan: "\x1B[46m",
+      brown: "\x1B[43m"
+    };
+    process.stdout.write(colorMap[color] || "");
+    return this;
+  }
+  color(color) {
+    const colorMap = {
+      black: "\x1B[30m",
+      white: "\x1B[37m",
+      red: "\x1B[31m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      blue: "\x1B[34m",
+      magenta: "\x1B[35m",
+      cyan: "\x1B[36m",
+      gray: "\x1B[90m"
+    };
+    process.stdout.write(colorMap[color] || "");
+    return this;
+  }
+  inputField(options) {
+    return {
+      promise: new Promise((resolve) => {
+        const prompt = "> ";
+        process.stdout.write(prompt);
+        let input = "";
+        const onData = (data) => {
+          const char = data.toString();
+          if (char === "\n" || char === "\r") {
+            process.stdout.write("\n");
+            process.stdin.removeListener("data", onData);
+            resolve(input);
+            return;
+          }
+          if (char === "") {
+            process.stdout.write("\n");
+            process.stdin.removeListener("data", onData);
+            resolve("");
+            return;
+          }
+          if (char === "\x7F" || char === "\b") {
+            if (input.length > 0) {
+              input = input.slice(0, -1);
+              process.stdout.write("\b \b");
+            }
+          } else if (options.echo) {
+            input += char;
+            process.stdout.write(char);
+          } else {
+            input += char;
+            process.stdout.write("*");
+          }
+        };
+        process.stdin.on("data", onData);
+      })
+    };
+  }
+  yesOrNo(options) {
+    return {
+      promise: new Promise((resolve) => {
+        const prompt = "(y/N) ";
+        process.stdout.write(prompt);
+        const onData = (data) => {
+          const char = data.toString().toLowerCase();
+          if (char === "\n" || char === "\r") {
+            process.stdout.write("\n");
+            process.stdin.removeListener("data", onData);
+            resolve(false);
+            return;
+          }
+          if (char === "") {
+            process.stdout.write("\n");
+            process.stdin.removeListener("data", onData);
+            resolve(null);
+            return;
+          }
+          if (options.yes.includes(char)) {
+            process.stdout.write(char + "\n");
+            process.stdin.removeListener("data", onData);
+            resolve(true);
+            return;
+          }
+          if (options.no.includes(char)) {
+            process.stdout.write(char + "\n");
+            process.stdin.removeListener("data", onData);
+            resolve(false);
+            return;
+          }
+        };
+        process.stdin.on("data", onData);
+      })
+    };
+  }
+  // Callable interface for writing text
+  write(text) {
+    process.stdout.write(text);
+  }
+  red(text) {
+    process.stdout.write("\x1B[31m" + text + "\x1B[0m");
+  }
+  destroy() {
+    this.rl.close();
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+  }
+}
+const term = new TerminalInterface();
 let state = {
   lines: [""],
   // Document content as an array of strings
@@ -1424,24 +1682,6 @@ let state = {
   exitResolver: null,
   exitRejecter: null
 };
-async function loadEditorConfig(cwd = process.cwd(), overrides = {}) {
-  const { config } = await loadConfig({
-    name: "minedit",
-    cwd,
-    defaults: {
-      // Low priority defaults
-      syntaxHighlighting: false,
-      theme: "auto",
-      defaultAllowSaveAs: true,
-      defaultAllowOpen: true,
-      defaultAutoCloseOnSave: false,
-      defaultReturnContentOnSave: false
-    },
-    // user provided overrides during programmatic call have higher priority
-    overrides
-  });
-  return config || {};
-}
 function setupTheme(configTheme) {
   let mode = configTheme;
   if (mode === "auto") {
@@ -1500,13 +1740,13 @@ function renderStatusBar() {
   const middlePart = hints + " ".repeat(hintPadding);
   const statusBar = leftPart + middlePart + rightPart;
   term.moveTo(1, term.height - 1);
-  term(state.theme.statusBarBg(state.theme.statusBarText(statusBar.padEnd(width))));
+  term.write(state.theme.statusBarBg(state.theme.statusBarText(statusBar.padEnd(width))));
 }
 function renderMessageBar() {
   term.moveTo(1, term.height);
   term.eraseLine();
   if (state.statusMessage) {
-    term(state.theme.highlight(state.statusMessage.slice(0, term.width)));
+    term.write(state.theme.highlight(state.statusMessage.slice(0, term.width)));
     setTimeout(() => {
       if (state.isRunning) {
         state.statusMessage = "";
@@ -1549,11 +1789,11 @@ function renderEditor() {
     term.moveTo(1, y + 1);
     if (fileLineIndex < state.lines.length) {
       const lineNum = String(fileLineIndex + 1).padStart(3);
-      term(state.theme.lineNumber(`${lineNum} `));
+      term.write(state.theme.lineNumber(`${lineNum} `));
       const line = state.lines[fileLineIndex];
       const displayLine = line?.substring(state.leftCol, state.leftCol + displayWidth);
       const highlightedDisplayLine = applySyntaxHighlighting(displayLine ?? "");
-      term(highlightedDisplayLine);
+      term.write(highlightedDisplayLine);
       term.eraseLineAfter();
     } else {
       term.eraseLine();
@@ -1693,13 +1933,15 @@ async function promptForFilename(promptMessage = "File path: ") {
   renderMessageBar();
   term.moveTo(1, term.height);
   term.eraseLine();
-  term(promptMessage);
+  term.write(promptMessage);
   try {
     const input = await term.inputField({ echo: true }).promise;
-    term.moveTo(1, term.height).eraseLine();
+    term.moveTo(1, term.height);
+    term.eraseLine();
     return input ? input.trim() : null;
   } catch (_error) {
-    term.moveTo(1, term.height).eraseLine();
+    term.moveTo(1, term.height);
+    term.eraseLine();
     state.statusMessage = "Cancelled";
     render();
     return null;
@@ -1710,16 +1952,18 @@ async function confirmAction(promptMessage = "Are you sure? (y/N)") {
   renderMessageBar();
   term.moveTo(1, term.height);
   term.eraseLine();
-  term(`${promptMessage} `);
+  term.write(`${promptMessage} `);
   try {
     const confirm = await term.yesOrNo({
       yes: ["y", "Y"],
       no: ["n", "N", "ENTER"]
     }).promise;
-    term.moveTo(1, term.height).eraseLine();
+    term.moveTo(1, term.height);
+    term.eraseLine();
     return confirm ?? false;
   } catch (_error) {
-    term.moveTo(1, term.height).eraseLine();
+    term.moveTo(1, term.height);
+    term.eraseLine();
     state.statusMessage = "Cancelled";
     render();
     return false;
@@ -1766,7 +2010,7 @@ async function saveFile() {
     return true;
   }
   try {
-    await fs.writeFile(state.filename, contentToSave);
+    await writeFile(state.filename, contentToSave);
     state.originalContent = contentToSave;
     state.modified = false;
     state.statusMessage = `Saved to ${state.filename}`;
@@ -1832,7 +2076,7 @@ async function loadFile(filePath) {
     const absolutePath = path.resolve(cwd, filePath);
     let content = "";
     try {
-      content = await fs.readFile(absolutePath, "utf-8");
+      content = await readFile(absolutePath, "utf-8");
       state.statusMessage = `Opened ${absolutePath}`;
     } catch (error) {
       if (error && error.code === "ENOENT") {
@@ -2056,7 +2300,7 @@ async function cleanupAndExit(saved = false, content = null) {
   }
   term.off("key", handleInputWrapper);
   term.off("resize", handleResize);
-  term.hideCursor(false);
+  term.hideCursor();
   term.grabInput(false);
   term.fullscreen(false);
   term.styleReset();
@@ -2141,8 +2385,15 @@ async function initializeEditorState(options) {
     // Reset toggle state
   };
   try {
-    const loadedConfig = await loadEditorConfig(state.options.cwd, options.configOverrides);
-    state.editorConfig = loadedConfig;
+    state.editorConfig = {
+      defaultAllowSaveAs: true,
+      defaultAllowOpen: true,
+      defaultAutoCloseOnSave: false,
+      defaultReturnContentOnSave: false,
+      syntaxHighlighting: false,
+      theme: "light",
+      ...options.configOverrides
+    };
     state.options.allowSaveAs = options.allowSaveAs ?? state.editorConfig.defaultAllowSaveAs ?? true;
     state.options.allowOpen = options.allowOpen ?? state.editorConfig.defaultAllowOpen ?? true;
     state.options.autoCloseOnSave = options.autoCloseOnSave ?? state.editorConfig.defaultAutoCloseOnSave ?? false;
@@ -2216,8 +2467,8 @@ async function startEditor(options = {}) {
 }
 const isDirectRun = (() => {
   try {
-    const scriptPath = fs.realpathSync(process.argv[1] || "");
-    const modulePath = fs.realpathSync(import.meta.filename);
+    const scriptPath = realpathSync(process.argv[1] || "");
+    const modulePath = realpathSync(import.meta.filename);
     return scriptPath === modulePath;
   } catch (_e) {
     return false;
@@ -3112,2208 +3363,513 @@ async function introPrompt(optionsOrTitle) {
 const startPrompt = introPrompt;
 const intro = introPrompt;
 
-const jiti = createJiti(import.meta.url, {
-  debug: process$1.env.NODE_ENV === "development",
-  fsCache: true,
-  sourceMaps: true
-});
-const COMMAND_EXTENSIONS = [".ts", ".js"];
-const COMMAND_FILENAMES = ["cmd.ts", "cmd.js"];
-const getCallerDirectory = async () => {
-  const stack = new Error().stack?.split("\n") ?? [];
-  const cwd = process$1.cwd();
-  if (process$1.env.NODE_ENV === "development") {
-    relinka("log", "Stack trace for getCallerDirectory:");
-    stack.forEach((line, index) => {
-      relinka("log", `  [${index}]: ${line.trim()}`);
-    });
-  }
-  for (const line of stack) {
-    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-    if (match?.[1]) {
-      const filePath = match[1];
-      if (process$1.env.NODE_ENV === "development") {
-        relinka("log", `Checking file path: ${filePath}`);
-      }
-      if (!filePath.includes("node_modules") && !filePath.includes("command-runner") && !filePath.includes("command-typed") && !filePath.includes("launcher-mod") && !filePath.includes("launcher-types") && !filePath.endsWith("mod.mjs") && // Skip compiled output
-      !filePath.endsWith("mod.js") && // Skip compiled output
-      !filePath.endsWith("mod.ts")) {
-        try {
-          const fileDir = dirname(filePath);
-          let currentDir2 = fileDir;
-          let packageRoot = null;
-          while (currentDir2 !== dirname(currentDir2)) {
-            try {
-              const packageJsonPath = resolve(currentDir2, "package.json");
-              if (await fs.pathExists(packageJsonPath)) {
-                packageRoot = currentDir2;
-                if (process$1.env.NODE_ENV === "development") {
-                  relinka("log", `Found package.json at: ${packageRoot}`);
-                }
-                const cwdPackageJsonPath = resolve(cwd, "package.json");
-                if (await fs.pathExists(cwdPackageJsonPath)) {
-                  try {
-                    const callerPackage = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
-                    const cwdPackage = JSON.parse(await fs.readFile(cwdPackageJsonPath, "utf-8"));
-                    if (callerPackage.name !== cwdPackage.name || callerPackage.version !== cwdPackage.version) {
-                      if (process$1.env.NODE_ENV === "development") {
-                        relinka("log", `Using caller package root: ${packageRoot} (${callerPackage.name}@${callerPackage.version})`);
-                      }
-                      return packageRoot;
-                    }
-                  } catch {
-                    if (resolve(packageRoot) !== resolve(cwd)) {
-                      if (process$1.env.NODE_ENV === "development") {
-                        relinka("log", `Using caller package root (different path): ${packageRoot}`);
-                      }
-                      return packageRoot;
-                    }
-                  }
-                } else {
-                  if (process$1.env.NODE_ENV === "development") {
-                    relinka("log", `Using caller package root (no CWD package.json): ${packageRoot}`);
-                  }
-                  return packageRoot;
-                }
-                break;
-              }
-            } catch {
-            }
-            currentDir2 = dirname(currentDir2);
-          }
-          const resolvedFileDir = resolve(fileDir);
-          const resolvedCwd = resolve(cwd);
-          if (resolvedFileDir !== resolvedCwd && !resolvedFileDir.startsWith(resolvedCwd)) {
-            if (process$1.env.NODE_ENV === "development") {
-              relinka("log", `Using caller directory (different from CWD): ${fileDir}`);
-            }
-            return packageRoot || fileDir;
-          }
-        } catch {
-          continue;
-        }
-      }
+const NEGATIVE_NUMBER_REGEX = /^[0-9]+(\.[0-9]+)?$/;
+function isAsciiLetter(ch) {
+  const code = ch.charCodeAt(0);
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function reliArgParser(argv, opts = {}) {
+  const context = createParserContext(opts);
+  prePopulateDefaults(context);
+  let i = 0;
+  const argvLength = argv.length;
+  while (i < argvLength) {
+    const arg = argv[i];
+    if (!arg) {
+      i++;
+      continue;
     }
-  }
-  for (const line of stack) {
-    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-    if (match?.[1]) {
-      const filePath = match[1];
-      if (filePath.includes("node_modules")) {
-        try {
-          const nodeModulesMatch = filePath.match(/(.+\/node_modules\/[^\/]+)/);
-          if (nodeModulesMatch?.[1]) {
-            const packageDir = nodeModulesMatch[1];
-            const packageJsonPath = resolve(packageDir, "package.json");
-            if (await fs.pathExists(packageJsonPath)) {
-              if (process$1.env.NODE_ENV === "development") {
-                relinka("log", `Found command package in node_modules: ${packageDir}`);
-              }
-              return packageDir;
-            }
-          }
-        } catch {
-          continue;
-        }
-      }
+    if (arg === "--") {
+      context.result._.push(...argv.slice(i + 1));
+      break;
     }
-  }
-  let currentDir = cwd;
-  while (currentDir !== dirname(currentDir)) {
-    try {
-      const packageJsonPath = resolve(currentDir, "package.json");
-      if (await fs.pathExists(packageJsonPath)) {
-        if (process$1.env.NODE_ENV === "development") {
-          relinka("log", `Found package.json at: ${currentDir}`);
-        }
-        return currentDir;
+    if (context.allowNegativeNumbers && isNegativeNumber(arg)) {
+      if (context.stopEarly) {
+        context.result._.push(...argv.slice(i));
+        break;
+      } else {
+        context.result._.push(arg);
+        i++;
+        continue;
       }
-    } catch {
     }
-    currentDir = dirname(currentDir);
-  }
-  if (process$1.env.NODE_ENV === "development") {
-    relinka("log", `No suitable caller found, using cwd: ${cwd}`);
-  }
-  return process$1.cwd();
-};
-const getNodeModulesPackageDirsFromStack = async () => {
-  const stack = new Error().stack?.split("\n") ?? [];
-  const packageDirs = /* @__PURE__ */ new Set();
-  for (const line of stack) {
-    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-    if (!match?.[1]) continue;
-    const filePath = match[1];
-    if (!filePath.includes("node_modules")) continue;
-    try {
-      const nodeModulesMatch = filePath.match(/(.+\\node_modules\\(?:@[^\\/]+\\)?[^\\/]+)|(.+\/node_modules\/(?:@[^\/]+\/)?[^\/]+)/);
-      const packageDir = (nodeModulesMatch?.[1] || nodeModulesMatch?.[2])?.trim();
-      if (!packageDir) continue;
-      const packageJsonPath = resolve(packageDir, "package.json");
-      if (await fs.pathExists(packageJsonPath)) {
-        packageDirs.add(packageDir);
-      }
-    } catch {
+    if (shouldHandleNegatedBoolean(arg, context)) {
+      handleNegatedBooleanFlag(arg, context);
+      i++;
+      continue;
     }
-  }
-  return Array.from(packageDirs);
-};
-const tryLoadCommand = async (path) => {
-  if (!await fs.pathExists(path)) return null;
-  try {
-    const cmd = await jiti.import(path, { default: true });
-    return cmd;
-  } catch {
-    relinka("log", `Failed to load ${path} as a command file`);
-    return null;
-  }
-};
-const generateCandidatePaths = async (resolvedPath) => {
-  if (!await fs.pathExists(resolvedPath)) {
-    return COMMAND_EXTENSIONS.map((ext) => `${resolvedPath}${ext}`);
-  }
-  if (await fs.isDirectory(resolvedPath)) {
-    return COMMAND_FILENAMES.map((filename) => resolve(resolvedPath, filename));
-  }
-  return [resolvedPath];
-};
-const generateAlternativePaths = async (cmdPath, callerDir) => {
-  const normalizedCmdPath = cmdPath.replace(/^\.\//, "");
-  const paths = [];
-  const commonCommandLocations = [
-    // Direct command file
-    resolve(callerDir, `${normalizedCmdPath}.ts`),
-    resolve(callerDir, `${normalizedCmdPath}.js`),
-    // Command in cmd subdirectory
-    resolve(callerDir, normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, normalizedCmdPath, "cmd.js"),
-    // Command in app subdirectory
-    resolve(callerDir, "app", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "app", normalizedCmdPath, "cmd.js"),
-    // Command in src subdirectory
-    resolve(callerDir, "src", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "src", normalizedCmdPath, "cmd.js"),
-    // Command in src/app subdirectory
-    resolve(callerDir, "src", "app", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "src", "app", normalizedCmdPath, "cmd.js"),
-    // Command in src-ts subdirectory
-    resolve(callerDir, "src-ts", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "src-ts", normalizedCmdPath, "cmd.js"),
-    // Command in src-ts/app subdirectory (for dler-like structures)
-    resolve(callerDir, "src-ts", "app", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "src-ts", "app", normalizedCmdPath, "cmd.js"),
-    // Command in lib subdirectory
-    resolve(callerDir, "lib", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "lib", normalizedCmdPath, "cmd.js"),
-    // Command in lib/app subdirectory
-    resolve(callerDir, "lib", "app", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "lib", "app", normalizedCmdPath, "cmd.js"),
-    // Command in dist subdirectory (compiled)
-    resolve(callerDir, "dist", normalizedCmdPath, "cmd.js"),
-    resolve(callerDir, "dist", "app", normalizedCmdPath, "cmd.js"),
-    // Command in bin subdirectory
-    resolve(callerDir, "bin", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "bin", normalizedCmdPath, "cmd.js"),
-    // Command in bin/app subdirectory (common for CLI tools)
-    resolve(callerDir, "bin", "app", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "bin", "app", normalizedCmdPath, "cmd.js"),
-    // Command in commands subdirectory
-    resolve(callerDir, "commands", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "commands", normalizedCmdPath, "cmd.js"),
-    // Command in cli subdirectory
-    resolve(callerDir, "cli", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "cli", normalizedCmdPath, "cmd.js"),
-    // Command in cli/commands subdirectory
-    resolve(callerDir, "cli", "commands", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "cli", "commands", normalizedCmdPath, "cmd.js"),
-    // Command in tools subdirectory
-    resolve(callerDir, "tools", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "tools", normalizedCmdPath, "cmd.js"),
-    // Command in scripts subdirectory
-    resolve(callerDir, "scripts", normalizedCmdPath, "cmd.ts"),
-    resolve(callerDir, "scripts", normalizedCmdPath, "cmd.js")
-  ];
-  for (const path of commonCommandLocations) {
-    if (await fs.pathExists(path)) {
-      paths.push(path);
+    if (arg.length > 2 && arg[0] === "-" && arg[1] === "-") {
+      i = handleLongFlag(argv, i, context);
+      continue;
+    }
+    if (arg.length > 1 && arg[0] === "-" && arg[1] !== "-") {
+      i = handleShortFlags(argv, i, context);
+      continue;
+    }
+    if (context.stopEarly) {
+      context.result._.push(...argv.slice(i));
+      break;
     }
+    context.result._.push(arg);
+    i++;
   }
-  return paths;
-};
-const createCommandNotFoundError = (cmdPath, searchedPaths) => new Error(
-  `No command file found for "${cmdPath}". Expected to find either:
-  - A valid command file at the specified path
-  - A directory containing cmd.ts or cmd.js  
-  - A file path that can be resolved with .ts or .js extension
-  
-Searched paths: ${searchedPaths.join(", ")}
-Please ensure one of these exists and exports a default command.`
-);
-const createLoadError = (cmdPath, originalError) => new Error(
-  `Failed to load command from "${cmdPath}"
-  
-For developers: Ensure the command file:
-  - Exists and is accessible
-  - Exports a default command (e.g., export default defineCommand({...}))
-  - Is a valid TypeScript/JavaScript module
-  
-Original error: ${originalError instanceof Error ? originalError.message : String(originalError)}`
-);
-async function loadCommand(cmdPath) {
-  try {
-    const callerDir = await getCallerDirectory();
-    const normalizedPath = cmdPath.replace(/^\.\//, "");
-    const resolvedPath = resolve(callerDir, normalizedPath);
-    if (process$1.env.NODE_ENV === "development") {
-      relinka("log", `Loading command: ${cmdPath}`);
-      relinka("log", `Caller directory: ${callerDir}`);
-      relinka("log", `Normalized path: ${normalizedPath}`);
-      relinka("log", `Resolved path: ${resolvedPath}`);
-    }
-    const searchedPaths = [];
-    const baseDirs = [callerDir];
-    const stackPackageDirs = await getNodeModulesPackageDirsFromStack();
-    for (const dir of stackPackageDirs) {
-      if (!baseDirs.includes(dir)) baseDirs.push(dir);
-    }
-    for (const baseDir of baseDirs) {
-      const alternativePaths = await generateAlternativePaths(cmdPath, baseDir);
-      if (process$1.env.NODE_ENV === "development") {
-        relinka("log", `Trying alternative paths in base ${baseDir}: ${alternativePaths.join(", ")}`);
-      }
-      searchedPaths.push(...alternativePaths);
-      for (const path of alternativePaths) {
-        const command = await tryLoadCommand(path);
-        if (command) {
-          if (process$1.env.NODE_ENV === "development") {
-            relinka("log", `Successfully loaded command from alternative path: ${path}`);
-          }
-          return command;
+  return context.result;
+}
+function createParserContext(opts) {
+  const booleanFlags = new Set(opts.boolean || []);
+  const arrayFlags = new Set(opts.array || []);
+  const stringFlags = new Set(opts.string || []);
+  const aliasMap = buildAliasMap(opts.alias || {});
+  const result = { _: [] };
+  return {
+    result,
+    booleanFlags,
+    arrayFlags,
+    stringFlags,
+    aliasMap,
+    options: opts,
+    stopEarlyTriggered: false,
+    // Cache frequently accessed options for performance
+    allowNegativeNumbers: opts.allowNegativeNumbers !== false,
+    negatedBoolean: opts.negatedBoolean !== false,
+    parseNumbers: opts.parseNumbers || false,
+    stopEarly: opts.stopEarly || false,
+    warnOnUnknown: opts.warnOnUnknown || false,
+    strict: opts.strict || false
+  };
+}
+function prePopulateDefaults(context) {
+  const { defaults = {} } = context.options;
+  for (const [key, val] of Object.entries(defaults)) {
+    context.result[key] = val;
+  }
+}
+function buildAliasMap(aliasObj) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(aliasObj)) {
+    if (Array.isArray(value)) {
+      const canonical = value[0];
+      if (canonical) {
+        map.set(key, canonical);
+        for (const alias of value) {
+          map.set(alias, canonical);
         }
       }
+    } else {
+      map.set(key, value);
+      map.set(value, value);
+    }
+  }
+  return map;
+}
+function isNegativeNumber(arg) {
+  if (arg.length < 2 || arg[0] !== "-") return false;
+  if (arg[1] === "-") return false;
+  return NEGATIVE_NUMBER_REGEX.test(arg.slice(1));
+}
+function shouldHandleNegatedBoolean(arg, context) {
+  return context.negatedBoolean && arg.length > 5 && arg[0] === "-" && arg[1] === "-" && arg[2] === "n" && arg[3] === "o" && arg[4] === "-";
+}
+function handleNegatedBooleanFlag(arg, context) {
+  const flagName = arg.slice(5);
+  const resolvedName = resolveFlagName(flagName, context);
+  if (context.booleanFlags.has(resolvedName)) {
+    setFlagValue(resolvedName, false, context);
+  } else {
+    handleUnknownFlag(resolvedName, context);
+  }
+}
+function handleLongFlag(argv, index, context) {
+  const arg = argv[index];
+  if (arg === void 0) {
+    return index + 1;
+  }
+  const flagBody = arg.slice(2);
+  const eqIndex = flagBody.indexOf("=");
+  let rawFlagName = flagBody;
+  let value = true;
+  let nextIndex = index;
+  if (eqIndex !== -1) {
+    rawFlagName = flagBody.slice(0, eqIndex);
+    value = flagBody.slice(eqIndex + 1);
+  } else {
+    const nextArg = argv[index + 1];
+    if (nextArg && nextArg.length > 0 && nextArg[0] !== "-") {
+      value = nextArg;
+      nextIndex++;
+    }
+  }
+  const flagName = resolveFlagName(rawFlagName, context);
+  const parsedValue = parseValue(value, flagName, context);
+  setFlagValue(flagName, parsedValue, context);
+  validateOrWarn(flagName, context);
+  return nextIndex + 1;
+}
+function handleShortFlags(argv, index, context) {
+  const arg = argv[index];
+  if (arg === void 0) {
+    return index + 1;
+  }
+  const shortFlags = arg.slice(1);
+  const booleanFlags = context.booleanFlags;
+  const aliasMap = context.aliasMap;
+  const shortFlagsLength = shortFlags.length;
+  let j = 0;
+  while (j < shortFlagsLength) {
+    const flagChar = shortFlags[j];
+    if (!flagChar) {
+      j++;
+      continue;
     }
-    const looksLikeExplicitPath = /[\\\/]|\.ts$|\.js$/.test(normalizedPath);
-    if (looksLikeExplicitPath) {
-      const candidatePaths = await generateCandidatePaths(resolvedPath);
-      if (process$1.env.NODE_ENV === "development") {
-        relinka("log", `Candidate paths: ${candidatePaths.join(", ")}`);
+    const resolvedName = aliasMap.get(flagChar) || flagChar;
+    const nextChar = shortFlags[j + 1];
+    if (booleanFlags.has(resolvedName)) {
+      if (nextChar === "=") {
+        const attachedValue = shortFlags.slice(j + 2);
+        const parsed = parseValue(attachedValue, resolvedName, context);
+        setFlagValue(resolvedName, parsed, context);
+        j = shortFlagsLength;
+      } else if (nextChar && !isAsciiLetter(nextChar)) {
+        const attachedValue = shortFlags.slice(j + 1);
+        const parsed = parseValue(attachedValue, resolvedName, context);
+        setFlagValue(resolvedName, parsed, context);
+        j = shortFlagsLength;
+      } else {
+        setFlagValue(resolvedName, true, context);
+        j++;
       }
-      searchedPaths.push(...candidatePaths);
-      for (const path of candidatePaths) {
-        const command = await tryLoadCommand(path);
-        if (command) {
-          if (process$1.env.NODE_ENV === "development") {
-            relinka("log", `Successfully loaded command from: ${path}`);
+    } else {
+      const remainder = shortFlags.slice(j + 1);
+      if (remainder.startsWith("=")) {
+        const val = remainder.slice(1);
+        const parsedVal = parseValue(val, resolvedName, context);
+        setFlagValue(resolvedName, parsedVal, context);
+        validateOrWarn(resolvedName, context);
+        j = shortFlagsLength;
+      } else if (remainder.length > 0) {
+        const parsedVal = parseValue(remainder, resolvedName, context);
+        setFlagValue(resolvedName, parsedVal, context);
+        validateOrWarn(resolvedName, context);
+        j = shortFlagsLength;
+      } else {
+        const nextArgIndex = index + 1;
+        if (nextArgIndex < argv.length) {
+          const nextArg = argv[nextArgIndex];
+          if (nextArg && nextArg.length > 0 && nextArg[0] !== "-") {
+            const parsedVal = parseValue(nextArg, resolvedName, context);
+            setFlagValue(resolvedName, parsedVal, context);
+            validateOrWarn(resolvedName, context);
+            return index + 2;
           }
-          return command;
         }
+        setFlagValue(resolvedName, true, context);
+        validateOrWarn(resolvedName, context);
+        break;
       }
     }
-    throw createCommandNotFoundError(cmdPath, searchedPaths);
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("No command file found")) {
-      throw error;
-    }
-    relinka("error", `Failed to load command from ${cmdPath}:`, error);
-    throw createLoadError(cmdPath, error);
   }
+  return index + 1;
 }
-
-function addCompletions(program, completion) {
-  const commandSymbol = Symbol("command");
-  const cTree = {};
-  function addCommandCompletions(command, cTreeNode) {
-    command.commands.forEach((c) => {
-      const node = cTreeNode[c.name()] ||= {};
-      Object.defineProperty(node, commandSymbol, {
-        value: c,
-        enumerable: false
-      });
-      addCommandCompletions(c, node);
-    });
-  }
-  addCommandCompletions(program, cTree);
-  completion.on("complete", (fragment, params) => {
-    const segments = params.line.split(/ +/).slice(1, params.fragment);
-    const last = segments.at(-1);
-    let node = cTree;
-    const existingFlags = /* @__PURE__ */ new Set();
-    for (const segment of segments) {
-      if (segment.startsWith("-")) {
-        existingFlags.add(segment);
-        continue;
-      }
-      if (existingFlags.size > 0) continue;
-      node = node[segment];
-      if (!node) return;
-    }
-    const correspondingCommand = node[commandSymbol];
-    if (correspondingCommand?.options?.length) {
-      const suggestions = [];
-      for (const o of correspondingCommand.options) {
-        if (last === o.long || last === o.short) {
-          if (o.argChoices) suggestions.push(...o.argChoices);
-          if (!o.isBoolean()) break;
+function resolveFlagName(rawName, context) {
+  return context.aliasMap.get(rawName) || rawName;
+}
+function setFlagValue(flagName, value, context) {
+  if (context.arrayFlags.has(flagName)) {
+    if (!Array.isArray(context.result[flagName])) {
+      context.result[flagName] = [];
+    }
+    context.result[flagName].push(value);
+  } else {
+    context.result[flagName] = value;
+  }
+}
+function parseValue(val, flagName, context) {
+  if (typeof val === "boolean") {
+    return val;
+  }
+  const strVal = String(val);
+  if (context.stringFlags.has(flagName)) {
+    return strVal;
+  }
+  if (context.booleanFlags.has(flagName)) {
+    if (strVal === "true") return true;
+    if (strVal === "false") return false;
+    return strVal;
+  }
+  if (context.parseNumbers && strVal.length > 0) {
+    const firstChar = strVal.charAt(0);
+    const lastChar = strVal.charAt(strVal.length - 1);
+    if (firstChar >= "0" && firstChar <= "9" || firstChar === "-" || firstChar === "+") {
+      if (lastChar >= "0" && lastChar <= "9") {
+        const maybeNum = Number(strVal);
+        if (!Number.isNaN(maybeNum)) {
+          return maybeNum;
         }
-        if (existingFlags.has(o.long)) continue;
-        if (existingFlags.has(o.short)) continue;
-        suggestions.push(o.long);
       }
-      return params.reply(suggestions);
     }
-  });
-  completion.tree(cTree).init();
-}
-
-class CliValidationError extends Error {
-}
-class FailedToExitError extends Error {
-  exitCode;
-  constructor(message, { exitCode, cause }) {
-    const fullMessage = `${message}. The process was expected to exit with exit code ${exitCode} but did not. This may be because a custom \`process\` parameter was used. The exit reason is in the \`cause\` property.`;
-    super(fullMessage, { cause });
-    this.exitCode = exitCode;
   }
+  return strVal;
 }
-
-const commandToJSON = (command) => {
-  const json = {};
-  const name = command.name();
-  if (name) json.name = name;
-  const version = command.version();
-  if (version) json.version = version;
-  const description = command.description();
-  if (description) json.description = description;
-  const usage = command.usage();
-  if (usage) json.usage = usage;
-  json.arguments = command.registeredArguments.map((arg) => {
-    const result = { name: arg.name() };
-    result.variadic = arg.variadic;
-    result.required = arg.required;
-    if (arg.description) result.description = arg.description;
-    if (arg.defaultValue) result.defaultValue = arg.defaultValue;
-    if (arg.defaultValueDescription) result.defaultValueDescription = arg.defaultValueDescription;
-    if (arg.argChoices) result.choices = arg.argChoices;
-    return result;
-  });
-  json.options = command.options.map((o) => {
-    const result = { name: o.name() };
-    result.required = o.required;
-    result.optional = o.optional;
-    result.negate = o.negate;
-    result.variadic = o.variadic;
-    if (o.flags) result.flags = o.flags;
-    if (o.short) result.short = o.short;
-    if (o.description) result.description = o.description;
-    if (o.argChoices) result.choices = o.argChoices;
-    const attributeName = o.attributeName();
-    if (attributeName) result.attributeName = attributeName;
-    if (o.defaultValue) result.defaultValue = o.defaultValue;
-    if (o.defaultValueDescription) result.defaultValueDescription = o.defaultValueDescription;
-    return result;
-  });
-  json.commands = command.commands.map((c) => commandToJSON(c));
-  return json;
-};
-
-const capitaliseFromCamelCase = (camel) => {
-  const parts = camel.split(/(?=[A-Z])/);
-  return capitalise(parts.map((p) => p.toLowerCase()).join(" "));
-};
-const capitalise = (s) => s.slice(0, 1).toUpperCase() + s.slice(1);
-const flattenedProperties = (sch) => {
-  if ("properties" in sch) {
-    return sch.properties;
-  }
-  if ("allOf" in sch) {
-    return Object.fromEntries(
-      sch.allOf.flatMap(
-        (subSchema) => Object.entries(flattenedProperties(subSchema))
-      )
-    );
-  }
-  if ("anyOf" in sch) {
-    const isExcluded = (v) => Object.keys(v).join(",") === "not";
-    const entries = sch.anyOf.flatMap((subSchema) => {
-      const flattened = flattenedProperties(subSchema);
-      const excluded = Object.entries(flattened).flatMap(([name, propSchema]) => {
-        return isExcluded(propSchema) ? [`--${name}`] : [];
-      });
-      return Object.entries(flattened).map(([k, v]) => {
-        if (!isExcluded(v) && excluded.length > 0) {
-          return [k, { ...v, "Do not use with": excluded }];
-        }
-        return [k, v];
-      });
-    });
-    return Object.fromEntries(
-      entries.sort((a, b) => {
-        const scores = [a, b].map(([_k, v]) => isExcluded(v) ? 0 : 1);
-        return scores[0] - scores[1];
-      })
-    );
-  }
-  return {};
-};
-const incompatiblePropertyPairs = (sch) => {
-  const isUnion = "anyOf" in sch;
-  if (!isUnion) return [];
-  const sets = sch.anyOf.map((subSchema) => {
-    const keys = Object.keys(flattenedProperties(subSchema));
-    return { keys, set: new Set(keys) };
-  });
-  const compatiblityEntries = sets.flatMap(({ keys }) => {
-    return keys.map((key) => {
-      return [
-        key,
-        new Set(sets.filter((other) => other.set.has(key)).flatMap((other) => other.keys))
-      ];
-    });
-  });
-  const allKeys = sets.flatMap(({ keys }) => keys);
-  return compatiblityEntries.flatMap(([key, compatibleWith]) => {
-    const incompatibleEntries = allKeys.filter((other) => key < other && !compatibleWith.has(other)).map((other) => [key, other]);
-    return incompatibleEntries;
-  });
-};
-const getDescription = (v, depth = 0) => {
-  if ("items" in v && v.items) {
-    const { items, ...rest } = v;
-    return [getDescription(items, 1), getDescription(rest), "array"].filter(Boolean).join(" ");
-  }
-  return Object.entries(v).filter(([k, vv]) => {
-    if (k === "default" || k === "additionalProperties" || k === "optional") return false;
-    if (k === "type" && typeof vv === "string") return depth > 0;
-    if (k.startsWith("$")) return false;
-    if (k === "maximum" && vv === Number.MAX_SAFE_INTEGER) return false;
-    if (depth <= 1 && k === "enum" && getEnumChoices(v)?.type === "string_enum") return false;
-    return true;
-  }).sort(([a], [b]) => {
-    const scores = [a, b].map((k) => k === "description" ? 0 : 1);
-    return scores[0] - scores[1];
-  }).map(([k, vv], i) => {
-    if (k === "type" && Array.isArray(vv)) return `type: ${vv.join(" or ")}`;
-    if (k === "description" && i === 0) return String(vv);
-    if (k === "properties") return "Object (json formatted)";
-    if (typeof vv === "object") return `${capitaliseFromCamelCase(k)}: ${JSON.stringify(vv)}`;
-    return `${capitaliseFromCamelCase(k)}: ${vv}`;
-  }).join("; ") || "";
-};
-const getSchemaTypes = (propertyValue) => {
-  const array = [];
-  if ("type" in propertyValue) {
-    array.push(...[propertyValue.type].flat());
-  }
-  if ("enum" in propertyValue && Array.isArray(propertyValue.enum)) {
-    array.push(...propertyValue.enum.flatMap((s) => typeof s));
-  }
-  if ("const" in propertyValue && propertyValue.const === null) {
-    array.push("null");
-  } else if ("const" in propertyValue) {
-    array.push(typeof propertyValue.const);
-  }
-  if ("oneOf" in propertyValue) {
-    array.push(...propertyValue.oneOf.flatMap(getSchemaTypes));
+function validateOrWarn(flagName, context) {
+  const { unknown, defaults } = context.options;
+  if (unknown) {
+    if (!unknown(flagName)) {
+      handleUnknownFlag(flagName, context);
+    }
+    return;
   }
-  if ("anyOf" in propertyValue) {
-    array.push(...propertyValue.anyOf.flatMap(getSchemaTypes));
+  if (context.booleanFlags.has(flagName) || context.arrayFlags.has(flagName) || context.stringFlags.has(flagName) || context.aliasMap.has(flagName)) {
+    return;
   }
-  return [...new Set(array)];
-};
-const getEnumChoices = (propertyValue) => {
-  if (!propertyValue) return null;
-  if (!("enum" in propertyValue && Array.isArray(propertyValue.enum))) {
-    if ("anyOf" in propertyValue && propertyValue.anyOf?.every((subSchema) => {
-      if (subSchema && "const" in subSchema && Object.keys(subSchema).length === 1 && typeof subSchema.const === "string") {
-        return true;
-      }
-      return false;
-    })) {
-      return {
-        type: "string_enum",
-        choices: propertyValue.anyOf.map((subSchema) => subSchema.const)
-      };
-    }
-    if ("anyOf" in propertyValue && propertyValue.anyOf?.every((subSchema) => {
-      if (subSchema && "const" in subSchema && Object.keys(subSchema).length === 1 && typeof subSchema.const === "number") {
-        return true;
-      }
-      return false;
-    })) {
-      return {
-        type: "number_enum",
-        choices: propertyValue.anyOf.map((subSchema) => subSchema.const)
-      };
-    }
-    return null;
+  if (defaults && Object.hasOwn(defaults, flagName)) {
+    return;
   }
-  if (propertyValue.enum.every((s) => typeof s === "string")) {
-    return {
-      type: "string_enum",
-      choices: propertyValue.enum
-    };
+  handleUnknownFlag(flagName, context);
+}
+function handleUnknownFlag(flagName, context) {
+  if (context.strict) {
+    throw new Error(`Unknown flag: --${flagName}`);
   }
-  if (propertyValue.enum.every((s) => typeof s === "number")) {
-    return {
-      type: "number_enum",
-      choices: propertyValue.enum
-    };
+  if (context.warnOnUnknown) {
+    console.warn(`Unknown flag: --${flagName}`);
   }
-  return null;
-};
+}
 
-const lineByLineLogger = getLoggerTransformer((log) => {
-  const wrapper = (args, depth) => {
-    if (args.length === 1 && Array.isArray(args[0]) && depth === 0) {
-      args[0].forEach((item) => wrapper([item], 1));
-    } else if (args.every(isPrimitive)) {
-      log(...args);
-    } else if (args.length === 1) {
-      log(JSON.stringify(args[0], null, 2));
-    } else {
-      log(JSON.stringify(args, null, 2));
+async function callCmd(command, input, options = {}) {
+  const { autoExit = false, debug = false, useLifecycleHooks = true, parserOptions = {} } = options;
+  const debugLog = (...args) => {
+    if (debug) {
+      relinka("log", "[callCmd DEBUG]", ...args);
     }
   };
-  return (...args) => wrapper(args, 0);
-});
-const isPrimitive = (value) => {
-  const type = typeof value;
-  return type === "string" || type === "number" || type === "boolean";
-};
-function getLoggerTransformer(transform) {
-  return (logger) => {
-    const info = logger.info && transform(logger.info);
-    const error = logger.error && transform(logger.error);
-    return { info, error };
-  };
-}
-const lineByLineConsoleLogger = lineByLineLogger(console);
-
-function toJsonSchema(input, dependencies) {
+  debugLog("Calling command with input:", input);
+  debugLog("Command meta:", command.meta);
   try {
-    const jsonSchemaConverters = getJsonSchemaConverters(dependencies);
-    const vendor = getVendor(input);
-    if (vendor && vendor in jsonSchemaConverters) {
-      const converter = jsonSchemaConverters[vendor];
-      const converted = converter(input);
-      return { success: true, value: converted };
-    }
-    return { success: false, error: "Schema not convertible to JSON schema" };
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    return {
-      success: false,
-      error: `Failed to convert input to JSON Schema: ${message}`
-    };
-  }
-}
-function looksLikeJsonSchema(value) {
-  return typeof value === "object" && value !== null && ("type" in value && (typeof value.type === "string" || Array.isArray(value.type)) || "const" in value || "oneOf" in value || "anyOf" in value);
-}
-function parseProcedureInputs(inputs, dependencies) {
-  if (inputs.length === 0) {
-    return {
-      success: true,
-      value: {
-        positionalParameters: [],
-        optionsJsonSchema: {},
-        getPojoInput: () => ({})
+    let ctx;
+    if (Array.isArray(input)) {
+      debugLog("Processing argv input:", input);
+      ctx = await parseArgsFromArgv(command, input, parserOptions);
+    } else {
+      debugLog("Processing object input:", input);
+      ctx = await createContextFromArgs(command, input);
+    }
+    debugLog("Created context:", ctx);
+    if (useLifecycleHooks && command.onCmdInit) {
+      debugLog("Calling onCmdInit hook");
+      await command.onCmdInit(ctx);
+    }
+    if (command.run) {
+      debugLog("Executing command run function");
+      await command.run(ctx);
+    } else {
+      const error = "Command has no run function defined";
+      debugLog(error);
+      if (autoExit) {
+        relinka("error", error);
+        process$1.exit(1);
       }
-    };
-  }
-  const allJsonSchemaable = inputs.every((input) => looksJsonSchemaable(input));
-  if (!allJsonSchemaable) {
-    return {
-      success: false,
-      error: `Invalid input type ${inputs.map((s) => s?.constructor.name).join(", ")}, only inputs that can be converted to JSON Schema are supported`
-    };
-  }
-  if (inputs.length > 1) {
-    return parseMultiInputs(inputs, dependencies);
-  }
-  const mergedSchemaResult = toJsonSchema(inputs[0], dependencies);
-  if (!mergedSchemaResult.success) {
-    return {
-      success: false,
-      error: mergedSchemaResult.error
-    };
+      throw new Error(error);
+    }
+    if (useLifecycleHooks && command.onCmdExit) {
+      debugLog("Calling onCmdExit hook");
+      await command.onCmdExit(ctx);
+    }
+    debugLog("Command execution completed successfully");
+    return ctx;
+  } catch (error) {
+    debugLog("Error during command execution:", error);
+    if (autoExit) {
+      relinka("error", `Error while executing command: ${String(error)}`);
+      process$1.exit(1);
+    }
+    throw error;
   }
-  const mergedSchema = mergedSchemaResult.value;
-  return handleMergedSchema(mergedSchema);
 }
-function handleMergedSchema(mergedSchema) {
-  if (mergedSchema.additionalProperties) {
-    return {
-      success: false,
-      error: "Inputs with additional properties are not currently supported"
-    };
-  }
-  if (mergedSchema.type === "string") {
-    return {
-      success: true,
-      value: {
-        positionalParameters: [
-          {
-            type: "string",
-            array: false,
-            description: mergedSchema.description || "",
-            name: mergedSchema.title || "string",
-            required: !isOptional(mergedSchema)
-          }
-        ],
-        optionsJsonSchema: {},
-        getPojoInput: (argv) => argv.positionalValues[0]
-      }
-    };
-  }
-  if (acceptedPrimitiveTypes(mergedSchema).length > 0) {
-    return parsePrimitiveInput(mergedSchema);
-  }
-  if (isTuple(mergedSchema)) {
-    return parseTupleInput(mergedSchema);
-  }
-  if (mergedSchema.type === "array") {
-    return parseArrayInput(mergedSchema);
-  }
-  if (mergedSchema.anyOf) {
-    const allObjects = mergedSchema.anyOf.every((sub) => acceptsObject(toRoughJsonSchema7(sub)));
-    if (allObjects) {
-      return {
-        success: true,
-        value: {
-          positionalParameters: [],
-          optionsJsonSchema: mergedSchema,
-          getPojoInput: (argv) => argv.options
-        }
-      };
-    }
-    if (mergedSchema.anyOf.length === 2 && JSON.stringify(mergedSchema.anyOf[0]) === '{"not":{}}') {
-      return handleMergedSchema(mergedSchema.anyOf[1]);
-    }
-  }
-  if (mergedSchema.type !== "object") {
-    return {
-      success: false,
-      error: `Invalid input type ${inspect(mergedSchema, { depth: 2, breakLength: Number.POSITIVE_INFINITY })}, expected object or tuple.`
-    };
-  }
-  return {
-    success: true,
-    value: {
-      positionalParameters: [],
-      optionsJsonSchema: mergedSchema,
-      getPojoInput: (argv) => argv.options
-    }
-  };
-}
-function isOptional(schema) {
-  if (schema && typeof schema === "object" && "optional" in schema) return schema.optional === true;
-  const anyOf = schemaDefPropValue(schema, "anyOf");
-  if (anyOf?.length === 2 && JSON.stringify(anyOf[0]) === '{"not":{}}') return true;
-  if (anyOf?.some((sub) => isOptional(sub))) return true;
-  return false;
-}
-function parsePrimitiveInput(schema) {
-  const typeName = acceptedPrimitiveTypes(schema).join(" | ");
-  const name = (schema.title || schema.description || /\W/.test(typeName) ? "value" : typeName).replaceAll(/\s+/g, "_");
-  return {
-    success: true,
-    value: {
-      positionalParameters: [
-        {
-          name,
-          array: false,
-          description: schema.description || "",
-          required: !isOptional(schema),
-          type: typeName
-        }
-      ],
-      optionsJsonSchema: {},
-      getPojoInput: (argv) => convertPositional(schema, argv.positionalValues[0])
-    }
-  };
-}
-const schemaDefPropValue = (schema, prop) => {
-  if (schema && typeof schema === "object" && prop in schema) return schema[prop];
-  return;
-};
-const primitiveCandidateTypes = ["string", "number", "boolean", "integer"];
-function acceptedPrimitiveTypes(schema) {
-  let constVals = [
-    toRoughJsonSchema7(schema).const,
-    toRoughJsonSchema7(schema).enum
-  ].flat().filter(Boolean).map((s) => typeof s);
-  if (constVals.length === 0) constVals = void 0;
-  const typeList = constVals || schemaDefPropValue(schema, "type") || schemaDefPropValue(schema, "oneOf")?.flatMap((s) => acceptedPrimitiveTypes(s)) || schemaDefPropValue(schema, "anyOf")?.flatMap((s) => acceptedPrimitiveTypes(s));
-  const acceptedJsonSchemaTypes = new Set([typeList].flat().filter(Boolean));
-  return primitiveCandidateTypes.filter((c) => acceptedJsonSchemaTypes.has(c));
-}
-function parseMultiInputs(inputs, dependencies) {
-  const parsedIndividually = inputs.map((input) => parseProcedureInputs([input], dependencies));
-  const failures = parsedIndividually.flatMap((p) => p.success ? [] : [p.error]);
-  if (failures.length > 0) {
-    return { success: false, error: failures.join("\n") };
-  }
-  const allObjects = parsedIndividually.every(
-    (p) => p.success && p.value.positionalParameters.length === 0
+async function parseArgsFromArgv(command, argv, parserOptions) {
+  const booleanKeys = Object.keys(command.args || {}).filter(
+    (k) => command.args?.[k]?.type === "boolean"
   );
-  if (!allObjects) {
-    return {
-      success: false,
-      error: `Can't use positional parameters with multi-input type.`
-    };
-  }
-  return {
-    success: true,
-    value: {
-      positionalParameters: [],
-      optionsJsonSchema: {
-        allOf: parsedIndividually.map((p) => {
-          const successful = p;
-          const optionsSchema = successful.value.optionsJsonSchema;
-          if ("additionalProperties" in optionsSchema && optionsSchema.additionalProperties === false) {
-            const { additionalProperties, ...rest } = optionsSchema;
-            return rest;
-          }
-          return optionsSchema;
-        })
-      },
-      getPojoInput: (argv) => argv.options
-    }
-  };
-}
-function isNullable(schema) {
-  if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
-  if (schema.type === "null") return true;
-  if ((schema.anyOf || schema.oneOf)?.some((sub) => isNullable(toRoughJsonSchema7(sub))))
-    return true;
-  if (schema.const === null) return true;
-  return false;
-}
-const tupleItemsSchemas = (schema) => {
-  if (!schema || typeof schema !== "object") return;
-  if (Array.isArray(schema.items)) return schema.items;
-  if ("prefixItems" in schema && Array.isArray(schema.prefixItems))
-    return schema.prefixItems;
-  return;
-};
-function isTuple(schema) {
-  return Array.isArray(tupleItemsSchemas(schema));
-}
-function parseArrayInput(array) {
-  if (looksLikeJsonSchema(array.items) && isNullable(array.items)) {
-    return {
-      success: false,
-      error: `Invalid input type Array<${getSchemaTypes(array.items).join(" | ")}>. Nullable arrays are not supported.`
-    };
-  }
-  return {
-    success: true,
-    value: {
-      positionalParameters: [
-        {
-          name: parameterName(array, 1),
-          array: true,
-          description: array.description || "",
-          required: !isOptional(array),
-          type: "string"
-        }
-      ],
-      optionsJsonSchema: {},
-      getPojoInput: (argv) => argv.positionalValues.at(-1).map(
-        (s) => convertPositional(array.items, s)
-      )
-    }
-  };
-}
-function parseTupleInput(tuple) {
-  const items = tupleItemsSchemas(tuple);
-  if (!Array.isArray(items)) throw new Error(".items is not an array, is this really a tuple?");
-  const flagsSchemaIndex = items.findIndex((item) => {
-    if (acceptedPrimitiveTypes(item).length > 0) {
-      return false;
-    }
-    if (looksLikeArray(item) && acceptedPrimitiveTypes(item.items).length > 0) {
-      return false;
-    }
-    return true;
-  });
-  const types = `[${items.map((s) => schemaDefPropValue(s, "type")).join(", ")}]`;
-  if (flagsSchemaIndex > -1 && flagsSchemaIndex !== items.length - 1) {
-    return {
-      success: false,
-      error: `Invalid input type ${types}. Positional parameters must be strings, numbers or booleans.`
-    };
-  }
-  const flagsSchema = flagsSchemaIndex === -1 ? null : items[flagsSchemaIndex];
-  if (flagsSchema && !acceptsObject(flagsSchema)) {
-    return {
-      success: false,
-      error: `Invalid input type ${types}. The last type must accept object inputs.`
-    };
-  }
-  const positionalSchemas = flagsSchemaIndex === -1 ? items : items.slice(0, flagsSchemaIndex);
-  return {
-    success: true,
-    value: {
-      positionalParameters: positionalSchemas.map((schema, i) => ({
-        name: parameterName(schema, i + 1),
-        array: looksLikeArray(schema),
-        description: schemaDefPropValue(schema, "description") || "",
-        required: !isOptional(schema),
-        type: getSchemaTypes(toRoughJsonSchema7(schema)).join(" | ")
-      })),
-      optionsJsonSchema: flagsSchema && typeof flagsSchema === "object" ? flagsSchema : {},
-      getPojoInput: (commandArgs) => {
-        const inputs = commandArgs.positionalValues.map((v, i) => {
-          const correspondingSchema = positionalSchemas[i];
-          if (!correspondingSchema) {
-            throw new CliValidationError(`No schema found for position ${i}`);
-          }
-          if (looksLikeArray(correspondingSchema)) {
-            if (!Array.isArray(v)) {
-              throw new CliValidationError(`Expected array at position ${i}, got ${typeof v}`);
-            }
-            return v.map((s) => {
-              if (!correspondingSchema.items || Array.isArray(correspondingSchema.items)) return s;
-              return convertPositional(correspondingSchema.items, s);
-            });
-          }
-          if (typeof v !== "string" && v !== void 0) {
-            throw new CliValidationError(`Expected string at position ${i}, got ${typeof v}`);
-          }
-          return convertPositional(correspondingSchema, v);
-        });
-        if (flagsSchema) {
-          inputs.push(commandArgs.options);
-        }
-        return inputs;
-      }
-    }
-  };
-}
-const convertPositional = (schema, value) => {
-  let preprocessed;
-  const acceptedTypes = new Set(acceptedPrimitiveTypes(schema));
-  if (acceptedTypes.has("string")) {
-    preprocessed = value;
-  }
-  if (acceptedTypes.has("boolean")) {
-    if (value === "true") preprocessed = true;
-    else if (value === "false") preprocessed = false;
-  }
-  if (acceptedTypes.has("number")) {
-    const number = Number(value);
-    if (!Number.isNaN(number)) {
-      preprocessed = number;
-    }
-  }
-  if (acceptedTypes.has("integer")) {
-    const num = Number(value);
-    if (Number.isInteger(num)) {
-      preprocessed = num;
-    } else if (!Number.isNaN(num) && acceptedTypes === void 0) {
-      preprocessed = value;
-    }
-  }
-  if (preprocessed === void 0) {
-    return value;
-  }
-  return preprocessed;
-};
-const looksLikeArray = (schema) => {
-  return schemaDefPropValue(schema, "type") === "array";
-};
-const toRoughJsonSchema7 = (schema) => {
-  if (!schema || typeof schema !== "object") {
-    return {};
-  }
-  return schema;
-};
-const parameterName = (s, position) => {
-  if (looksLikeArray(s)) {
-    const items = toRoughJsonSchema7(s).items;
-    const elementName = parameterName(!items || Array.isArray(items) ? {} : items, position);
-    return `[${elementName.slice(1, -1)}...]`;
-  }
-  let name = schemaDefPropValue(s, "title") || schemaDefPropValue(s, "description") || `parameter_${position}`;
-  name = name.replaceAll(/\W+/g, " ").trim();
-  return isOptional(s) ? `[${name}]` : `<${name}>`;
-};
-const acceptsObject = (schema) => {
-  return (schema.type === "object" || schema.anyOf?.some((sub) => acceptsObject(toRoughJsonSchema7(sub)))) ?? false;
-};
-const getJsonSchemaConverters = (dependencies) => {
-  return {
-    zod: (input) => {
-      if (input._zod?.version?.major === 4) {
-        return zod4.toJSONSchema(input, {
-          // todo[zod@>=4.0.0] remove the line if https://github.com/colinhacks/zod/issues/4167 is resolved, or this comment if it's closed
-          io: "input",
-          // todo[zod@>=4.0.0] remove the override if https://github.com/colinhacks/zod/issues/4164 is resolved, or this comment if it's closed
-          unrepresentable: "any",
-          // todo[zod@>=4.0.0] remove the override if https://github.com/colinhacks/zod/issues/4164 is resolved, or this comment if it's closed
-          override: (ctx) => {
-            if (ctx.zodSchema?.constructor?.name === "ZodOptional") {
-              ctx.jsonSchema.optional = true;
-            }
-          }
-        });
-      }
-      return zodToJsonSchema(input);
-    },
-    arktype: (input) => {
-      const type = prepareArktypeType(input);
-      return type.toJsonSchema({
-        fallback: (ctx) => {
-          if (ctx.code === "unit" && ctx.unit === void 0) return { ...ctx.base, optional: true };
-          return ctx.base;
-        }
-      });
-    },
-    valibot: (input) => {
-      let valibotToJsonSchemaLib = dependencies["@valibot/to-json-schema"];
-      if (!valibotToJsonSchemaLib) {
-        try {
-          valibotToJsonSchemaLib = require("@valibot/to-json-schema");
-        } catch (e) {
-          throw new Error(
-            "@valibot/to-json-schema could not be found - try installing it and re-running",
-            { cause: e }
-          );
-        }
-      }
-      const valibotToJsonSchema = valibotToJsonSchemaLib?.toJsonSchema;
-      if (!valibotToJsonSchema) {
-        throw new Error(
-          `no 'toJsonSchema' function found in @valibot/to-json-schema - check you are using a supported version`
-        );
-      }
-      let v;
-      try {
-        v = require("valibot");
-      } catch {
-        return valibotToJsonSchema(input);
-      }
-      const parent = valibotToJsonSchema(
-        v.object({ child: input }),
-        {
-          errorMode: "ignore"
-        }
-      );
-      const child = parent.properties.child;
-      return parent.required?.length === 0 ? Object.assign(child, { optional: true }) : child;
-    },
-    effect: (input) => {
-      const effect = dependencies.effect || (() => {
-        try {
-          return require("effect");
-        } catch {
-          return null;
-        }
-      })();
-      if (!effect) {
-        throw new Error("effect dependency could not be found - try installing it and re-running");
-      }
-      if (!effect.Schema.isSchema(input)) {
-        const message = "input was not an effect schema - please use effect version 3.14.2 or higher. See https://github.com/mmkal/trpc-cli/pull/63";
-        throw new Error(message);
-      }
-      return effect.JSONSchema.make(input);
-    }
-  };
-};
-function getVendor(schema) {
-  return schema?.["~standard"]?.vendor ?? null;
-}
-const jsonSchemaVendorNames = new Set(Object.keys(getJsonSchemaConverters({})));
-function looksJsonSchemaable(value) {
-  const vendor = getVendor(value);
-  return !!vendor && jsonSchemaVendorNames.has(vendor);
-}
-function prepareArktypeType(type) {
-  let innerType = type;
-  while (innerType) {
-    if (innerType?.in && innerType.in !== innerType) {
-      innerType = innerType.in;
-    } else {
-      break;
-    }
-  }
-  return innerType;
-}
-
-const parseUpstreamOptionInfo = (value) => {
-  if (typeof value !== "string" || !value.startsWith("{")) return null;
-  try {
-    const info = JSON.parse(value);
-    if (info.typeName !== "UpstreamOptionInfo") return null;
-    return info;
-  } catch {
-    return null;
-  }
-};
-const parseUpstreamArgumentInfo = (value) => {
-  if (typeof value !== "string" || !value.startsWith("{")) return null;
-  try {
-    const info = JSON.parse(value);
-    if (info.typeName !== "UpstreamArgumentInfo") return null;
-    return info;
-  } catch {
-    return null;
-  }
-};
-const getDefaultSubcommand = (command) => {
-  const defaultChild = /Available subcommands:.* (\S+) \(default\)/.exec(
-    command.description()
-  )?.[1];
-  return defaultChild ? command.commands.find((c) => c.name() === defaultChild) : void 0;
-};
-const createShadowCommand = (command, onAnalyze) => {
-  const shadow = new Command(command.name());
-  shadow.exitOverride();
-  shadow.configureOutput({
-    writeOut: () => {
-    },
-    writeErr: () => {
-    }
-  });
-  const argumentsMap = /* @__PURE__ */ new Map();
-  const optionsMap = /* @__PURE__ */ new Map();
-  command.options.forEach((original) => {
-    const id = Date.now().toString() + Math.random().toString().slice(1);
-    const shadowOption = new Option(
-      original.flags.replace("<", "[").replace(">", "]"),
-      JSON.stringify([`id=${id}`, original.description])
-    );
-    const upstreamOptionInfo = {
-      typeName: "UpstreamOptionInfo",
-      id,
-      specified: false
-    };
-    shadowOption.default(JSON.stringify(upstreamOptionInfo));
-    shadowOption.argParser(
-      (value) => JSON.stringify({ ...upstreamOptionInfo, specified: true, value })
-    );
-    shadow.addOption(shadowOption);
-    optionsMap.set(id, { shadow: shadowOption, original });
-  });
-  command.registeredArguments.forEach((original) => {
-    const shadowArgument = new Argument(original.name(), original.description);
-    const id = Date.now().toString() + Math.random().toString().slice(1);
-    shadowArgument.argOptional();
-    const upstreamArgumentInfo = {
-      typeName: "UpstreamArgumentInfo",
-      id,
-      specified: false
-    };
-    shadowArgument.default(JSON.stringify(upstreamArgumentInfo));
-    shadowArgument.argParser(
-      (value) => JSON.stringify({ ...upstreamArgumentInfo, specified: true, value })
-    );
-    shadow.addArgument(shadowArgument);
-    argumentsMap.set(id, { shadow: shadowArgument, original });
-  });
-  const analysis = {
-    command: { shadow, original: command },
-    arguments: [],
-    options: []
-  };
-  shadow.action(async (...args) => {
-    const positionalValues = args.slice(0, -2);
-    const options = shadow.opts();
-    if (args.at(-2) !== options) {
-      throw new Error("Unexpected args format, second last arg is not the options object", {
-        cause: args
-      });
-    }
-    if (args.at(-1) !== shadow) {
-      throw new Error("Unexpected args format, last arg is not the Command instance", {
-        cause: args
-      });
-    }
-    positionalValues.forEach((value) => {
-      const argumentInfo = parseUpstreamArgumentInfo(value);
-      if (argumentInfo) {
-        analysis.arguments.push({
-          ...argumentsMap.get(argumentInfo.id),
-          value: argumentInfo.value,
-          specified: argumentInfo.specified
-        });
-      }
-    });
-    Object.values(options).forEach((value) => {
-      const upstreamOptionInfo = parseUpstreamOptionInfo(value);
-      if (upstreamOptionInfo) {
-        analysis.options.push({
-          ...optionsMap.get(upstreamOptionInfo.id),
-          value: upstreamOptionInfo.value,
-          specified: upstreamOptionInfo.specified
-        });
-      }
-    });
-    await onAnalyze(analysis);
-  });
-  command.commands.forEach((subcommand) => {
-    const shadowSubcommand = createShadowCommand(subcommand, onAnalyze);
-    shadow.addCommand(shadowSubcommand);
-  });
-  return shadow;
-};
-const inquirerPrompter = (prompts) => {
-  return prompts;
-};
-const clackPrompter = (prompts) => {
-  const clack = prompts;
-  class ExitPromptError extends Error {
-  }
-  const throwOnCancel = (value) => {
-    if (clack.isCancel(value)) throw new ExitPromptError();
-    return value;
-  };
-  return {
-    input: async (params) => {
-      return clack.text({
-        message: params.message,
-        initialValue: params.default,
-        defaultValue: params.default,
-        placeholder: params.default,
-        validate: params.validate ? (input) => {
-          const result = params.validate(input);
-          if (result === true) return;
-          if (result === false) return "Invalid input";
-          return result;
-        } : void 0
-      }).then(throwOnCancel);
-    },
-    checkbox: async (params) => {
-      return clack.multiselect({
-        message: params.message,
-        options: params.choices.map((c) => ({
-          label: c.name,
-          value: c.value
-        })),
-        initialValues: params.choices.flatMap((c) => c.checked ? [c.value] : [])
-      }).then(throwOnCancel);
-    },
-    confirm: async (params) => {
-      return clack.confirm({
-        message: params.message,
-        initialValue: params.default
-      }).then(throwOnCancel);
-    },
-    select: async (params) => {
-      return clack.select({
-        message: params.message,
-        options: params.choices.map((sorc) => {
-          const c = typeof sorc === "string" ? { name: sorc, value: sorc } : sorc;
-          return {
-            label: c.name,
-            value: c.value,
-            hint: c.description
-          };
-        }),
-        initialValue: params.default
-      }).then(throwOnCancel);
-    }
-  };
-};
-const promptsPrompter = (prompts) => {
-  const p = prompts;
-  function x() {
-    return (value) => value.x;
-  }
-  return {
-    input: async (params) => {
-      return p({
-        name: "x",
-        type: "text",
-        message: params.message,
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    confirm: async (params) => {
-      return p({
-        name: "x",
-        type: "confirm",
-        message: params.message,
-        active: params.default ? "yes" : "no"
-      }).then(x());
-    },
-    select: async (params) => {
-      const choicesObjects = params.choices.map(
-        (c) => typeof c === "string" ? { name: c, value: c } : c
-      );
-      return p({
-        name: "x",
-        type: "select",
-        message: params.message,
-        active: params.default,
-        choices: choicesObjects.map((c) => ({
-          title: c.name || c.value,
-          value: c.value
-        })),
-        initial: params.default ? choicesObjects.findIndex((c) => c.value === params.default) : void 0
-      }).then(x());
-    },
-    checkbox: async (params) => {
-      const choicesObjects = params.choices.map(
-        (c) => typeof c === "string" ? { name: c, value: c } : c
-      );
-      return p({
-        name: "x",
-        type: "multiselect",
-        message: params.message,
-        choices: choicesObjects.map((c) => ({
-          title: c.name || c.value,
-          value: c.value,
-          selected: c.checked
-        }))
-      }).then(x());
-    }
-  };
-};
-const enquirerPrompter = (prompts) => {
-  const enquirer = prompts;
-  function x() {
-    return (value) => value.x;
-  }
-  return {
-    input: async (params) => {
-      return enquirer.prompt({
-        type: "input",
-        name: "x",
-        message: params.message,
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    confirm: async (params) => {
-      return enquirer.prompt({
-        type: "confirm",
-        name: "x",
-        message: params.message,
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    select: async (params) => {
-      return enquirer.prompt({
-        type: "select",
-        name: "x",
-        message: params.message,
-        // @ts-expect-error not sure why this is an error, in the IDE it infers the type correctly
-        choices: params.choices.slice(),
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    checkbox: async (params) => {
-      return enquirer.prompt({
-        type: "multiselect",
-        name: "x",
-        message: params.message,
-        // @ts-expect-error not sure why this is an error, in the IDE it infers the type correctly
-        choices: params.choices.slice().map((c) => ({
-          name: c.name,
-          value: c.value
-        })),
-        // validate: params.validate ? v => params.validate!([{value: v}]) : undefined,
-        initial: params.choices.flatMap((c, i) => c.checked ? [i] : [])
-      }).then(x());
+  const defaultMap = {};
+  for (const [argKey, def] of Object.entries(command.args || {})) {
+    if (def.type === "boolean") {
+      defaultMap[argKey] = def.default !== void 0 ? def.default : false;
+    } else if (def.default !== void 0) {
+      defaultMap[argKey] = def.type === "array" && typeof def.default === "string" ? [def.default] : def.default;
     }
-  };
-};
-const promptify = (program, prompts) => {
-  let promptsInput = prompts;
-  if (promptsInput?.default) promptsInput = promptsInput.default;
-  let prompter;
-  if (typeof promptsInput === "function" && typeof promptsInput.inject === "function") {
-    prompter = promptsPrompter(promptsInput);
-  } else if (promptsInput?.name === "Enquirer") {
-    prompter = enquirerPrompter(promptsInput);
-  } else if (typeof promptsInput?.rawlist === "function") {
-    prompter = inquirerPrompter(promptsInput);
-  } else if (typeof promptsInput?.intro === "function") {
-    prompter = clackPrompter(promptsInput);
-  } else if (typeof promptsInput === "function") {
-    prompter = promptsInput(program);
-  } else {
-    prompter = promptsInput;
   }
-  const command = program;
-  const analyseThenParse = async (argv, parseOptions) => {
-    if (parseOptions?.from === "electron") {
-      console.warn(
-        `Warning: using prompts in electron mode is untested. The first two args of $0 are not available in electron mode. Assuming that the first two args of ${JSON.stringify(argv)} are electron-related and not intended for the CLI.`
-      );
-    }
-    if (parseOptions?.from !== "user") {
-      argv = argv.slice(2);
-      parseOptions = { from: "user" };
-    }
-    const f = { command, args: [...argv] };
-    const nextArgv = [...f.args];
-    let analysis;
-    const maxAttempts = 100;
-    for (let i = maxAttempts; i >= 0 && !analysis; i--) {
-      analysis = await new Promise((resolve, reject) => {
-        const shadow = createShadowCommand(f.command, async (an) => {
-          if (an.command.original.commands.length === 0) {
-            resolve(an);
-            return;
-          }
-          const defaultSubcommand = getDefaultSubcommand(an.command.original);
-          if (defaultSubcommand) {
-            resolve(an);
-            return;
-          }
-          const name = await prompter.select(
-            {
-              message: `Select a ${an.command.original.name() || ""} subcommand`.replace("  ", " "),
-              choices: an.command.original.commands.map((c) => ({
-                name: c.name(),
-                value: c.name(),
-                description: c.description()
-              }))
-            },
-            {}
-          );
-          nextArgv.push(name);
-          resolve(void 0);
-        });
-        shadow.parseAsync(nextArgv, parseOptions).catch((e) => {
-          if (e?.constructor?.name === "CommanderError") {
-            resolve({
-              command: { shadow: f.command, original: f.command },
-              arguments: [],
-              options: []
-            });
-          } else {
-            reject(e);
-          }
-        });
-      });
-    }
-    if (!analysis) {
-      const message = `Failed to find a subcommand after ${maxAttempts} attempts - failing to avoid an infinite loop. This is probably a bug in @reliverse/rempts.`;
-      throw new Error(message);
-    }
-    const getMessage = (argOrOpt) => {
-      const name = "long" in argOrOpt ? argOrOpt.flags : `[${argOrOpt.name()}]`;
-      const parts = [
-        name,
-        argOrOpt.description,
-        argOrOpt.defaultValue && `(default: ${argOrOpt.defaultValue})`,
-        !argOrOpt.defaultValue && !argOrOpt.required && "(optional)"
-      ];
-      return `${parts.filter(Boolean).join(" ").trim()}:`;
-    };
-    const baseContext = {
-      command: analysis.command.original,
-      inputs: {
-        argv,
-        arguments: analysis.arguments.map((a) => ({
-          name: a.original.name(),
-          specified: a.specified,
-          value: a.value
-        })),
-        options: analysis.options.map((o) => ({
-          name: o.original.name(),
-          specified: o.specified,
-          value: o.value
-        }))
-      }
-    };
-    await prompter.setup?.(baseContext);
-    let shouldPrompt;
-    {
-      const someRequiredArgsUnspecified = analysis.arguments.some(
-        (a) => a.original.required && !a.specified
-      );
-      const someRequiredOptionsUnspecified = analysis.options.some(
-        (o) => o.original.required && !o.specified
-      );
-      shouldPrompt = someRequiredArgsUnspecified || someRequiredOptionsUnspecified;
-    }
-    if (shouldPrompt) {
-      for (const arg of analysis.arguments) {
-        const ctx = { ...baseContext, argument: arg.original };
-        if (!arg.specified) {
-          const parseArg = "parseArg" in arg.original && typeof arg.original.parseArg === "function" ? arg.original.parseArg : void 0;
-          const promptedValue = await prompter.input(
-            {
-              message: getMessage(arg.original),
-              required: arg.original.required,
-              default: arg.value,
-              validate: (input) => {
-                try {
-                  parseArg?.(input);
-                  return true;
-                } catch (e) {
-                  return e?.message || e;
-                }
-              }
-            },
-            ctx
-          );
-          nextArgv.push(promptedValue);
-        }
-      }
-      for (const option of analysis.options) {
-        const ctx = { ...baseContext, option: option.original };
-        if (!option.specified) {
-          const fullFlag = option.original.long || `--${option.original.name()}`;
-          const isBoolean = option.original.isBoolean() || option.original.flags.includes("[boolean]");
-          if (isBoolean) {
-            const promptedValue = await prompter.confirm(
-              {
-                message: getMessage(option.original),
-                default: option.original.defaultValue ?? false
-              },
-              ctx
-            );
-            if (promptedValue) nextArgv.push(fullFlag);
-          } else if (option.original.variadic && option.original.argChoices) {
-            const choices = option.original.argChoices.slice();
-            const results = await prompter.checkbox(
-              {
-                message: getMessage(option.original),
-                choices: choices.map((choice) => ({
-                  value: choice,
-                  name: choice,
-                  checked: true
-                }))
-              },
-              ctx
-            );
-            results.forEach((result) => {
-              if (typeof result === "string") nextArgv.push(fullFlag, result);
-            });
-          } else if (option.original.argChoices) {
-            const choices = option.original.argChoices.slice();
-            const set = new Set(choices);
-            const promptedValue = await prompter.select(
-              {
-                message: getMessage(option.original),
-                choices,
-                default: option.original.defaultValue
-                // required: option.original.required,
-              },
-              ctx
-            );
-            if (set.has(promptedValue)) {
-              nextArgv.push(fullFlag, promptedValue);
-            }
-          } else if (option.original.variadic) {
-            const values = [];
-            do {
-              const promptedValue = await prompter.input(
-                {
-                  message: getMessage(option.original),
-                  default: option.original.defaultValue?.[values.length]
-                },
-                ctx
-              );
-              if (!promptedValue) break;
-              values.push(fullFlag, promptedValue);
-            } while (values);
-            nextArgv.push(...values);
-          } else {
-            const getParsedValue = (input) => {
-              return option.original.parseArg ? option.original.parseArg(input, void 0) : input;
-            };
-            const promptedValue = await prompter.input(
-              {
-                message: getMessage(option.original),
-                default: option.value,
-                required: option.original.required,
-                validate: (input) => {
-                  const parsed = getParsedValue(input);
-                  if (parsed == null && input != null) return "Invalid value";
-                  return true;
-                }
-              },
-              ctx
-            );
-            if (promptedValue)
-              nextArgv.push(fullFlag, getParsedValue(promptedValue) ?? promptedValue);
-          }
-        }
-      }
-    }
-    await prompter.teardown?.(baseContext);
-    return f.command.parseAsync(nextArgv, parseOptions);
+  const mergedParserOptions = {
+    ...parserOptions,
+    boolean: [...parserOptions.boolean || [], ...booleanKeys],
+    defaults: { ...defaultMap, ...parserOptions.defaults || {} }
   };
-  const parseAsync = (args, parseOptions) => analyseThenParse(args, parseOptions).catch((e) => {
-    if (e?.constructor?.name === "ExitPromptError") return;
-    throw e;
-  });
-  return new Proxy(program, {
-    get(target, prop, receiver) {
-      if (prop === "parseAsync") return parseAsync;
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-};
-
-const looksLikeStandardSchemaFailure = (error) => {
-  return !!error && typeof error === "object" && "issues" in error && Array.isArray(error.issues);
-};
-const looksLikeStandardSchema = (thing) => {
-  return !!thing && typeof thing === "object" && "~standard" in thing && typeof thing["~standard"] === "object";
-};
-
-const prettifyStandardSchemaError = (error) => {
-  if (!looksLikeStandardSchemaFailure(error)) return null;
-  const issues = [...error.issues].map((issue) => {
-    const path = issue.path || [];
-    const primitivePathSegments = path.map((segment) => {
-      if (typeof segment === "string" || typeof segment === "number" || typeof segment === "symbol")
-        return segment;
-      return segment.key;
-    });
-    const dotPath = toDotPath(primitivePathSegments);
-    return {
-      issue,
-      path,
-      primitivePathSegments,
-      dotPath
-    };
-  }).sort((a, b) => a.path.length - b.path.length);
-  const lines = [];
-  for (const { issue, dotPath } of issues) {
-    let message = `\u2716 ${issue.message}`;
-    if (dotPath) message += ` \u2192 at ${dotPath}`;
-    lines.push(message);
-  }
-  return lines.join("\n");
-};
-function toDotPath(path) {
-  const segs = [];
-  for (const seg of path) {
-    if (typeof seg === "number") segs.push(`[${seg}]`);
-    else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
-    else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
-    else {
-      if (segs.length) segs.push(".");
-      segs.push(seg);
-    }
-  }
-  return segs.join("");
-}
-class StandardSchemaV1Error extends Error {
-  issues;
-  constructor(failure, options) {
-    super("Standard Schema error - details in `issues`.", options);
-    this.issues = failure.issues;
-  }
-}
-
-const isTrpc11Procedure = (procedure) => {
-  return "type" in procedure._def && typeof procedure._def.type === "string";
-};
-const isTrpc11Router = (router) => {
-  if (isOrpcRouter(router)) return false;
-  const procedure = Object.values(router._def.procedures)[0];
-  return Boolean(procedure && isTrpc11Procedure(procedure));
-};
-const isOrpcRouter = (router) => {
-  return !("_def" in router) || router._def && "~orpc" in router._def;
-};
-
-const looksLikeInstanceof = (value, target) => {
-  let current = value?.constructor;
-  while (current?.name) {
-    if (current?.name === (typeof target === "string" ? target : target.name)) return true;
-    current = Object.getPrototypeOf(current);
+  const parsed = reliArgParser(argv, mergedParserOptions);
+  const finalArgs = {};
+  const positionalKeys = Object.keys(command.args || {}).filter(
+    (k) => command.args?.[k]?.type === "positional"
+  );
+  const leftoverPositionals = [...parsed._ || []];
+  for (let i = 0; i < positionalKeys.length; i++) {
+    const key = positionalKeys[i];
+    if (!key || !command.args) continue;
+    const def = command.args[key];
+    const val = leftoverPositionals[i];
+    finalArgs[key] = val != null && def ? castArgValue$1(def, val, key) : def?.default;
   }
-  return false;
-};
-
-class TrpcCommand extends Command {
-  /** @internal track the commands that have been run, so that we can find the `__result` of the last command */
-  __ran = [];
-  __input;
-  /** @internal stash the return value of the underlying procedure on the command so to pass to `FailedToExitError` for use in a pinch */
-  __result;
-}
-const parseRouter = ({ router, ...params }) => {
-  if (isOrpcRouter(router)) return parseOrpcRouter({ router, ...params });
-  return parseTrpcRouter({ router, ...params });
-};
-const parseTrpcRouter = ({
-  router,
-  ...params
-}) => {
-  const defEntries = Object.entries(router._def.procedures);
-  return defEntries.map(([procedurePath, procedure]) => {
-    const meta = getMeta(procedure);
-    if (meta.jsonInput) {
-      return [
-        procedurePath,
-        {
-          meta,
-          parsedProcedure: jsonProcedureInputs(),
-          incompatiblePairs: [],
-          procedure
-        }
-      ];
-    }
-    const procedureInputsResult = parseProcedureInputs(procedure._def.inputs, params);
-    if (!procedureInputsResult.success) {
-      const procedureInputs2 = jsonProcedureInputs(
-        `procedure's schema couldn't be converted to CLI arguments: ${procedureInputsResult.error}`
-      );
-      return [
-        procedurePath,
-        {
-          meta,
-          parsedProcedure: procedureInputs2,
-          incompatiblePairs: [],
-          procedure
-        }
-      ];
-    }
-    const procedureInputs = procedureInputsResult.value;
-    const incompatiblePairs = incompatiblePropertyPairs(procedureInputs.optionsJsonSchema);
-    return [
-      procedurePath,
-      {
-        meta: getMeta(procedure),
-        parsedProcedure: procedureInputs,
-        incompatiblePairs,
-        procedure
-      }
-    ];
-  });
-};
-const parseOrpcRouter = (params) => {
-  const entries = [];
-  const { traverseContractProcedures, isProcedure } = (() => {
-    try {
-      return require("@orpc/server");
-    } catch (e) {
-      throw new Error(
-        "@orpc/server dependency could not be found - try installing it and re-running",
-        { cause: e }
-      );
-    }
-  })();
-  const router = params.router;
-  const lazyRoutes = traverseContractProcedures({ path: [], router }, ({ contract, path }) => {
-    let procedure = params.router;
-    for (const p of path) procedure = procedure[p];
-    if (!isProcedure(procedure)) return;
-    const procedureInputsResult = parseProcedureInputs([contract["~orpc"].inputSchema], {
-      "@valibot/to-json-schema": params["@valibot/to-json-schema"],
-      effect: params.effect
-    });
-    const procedurePath = path.join(".");
-    const procedureish = {
-      _def: { meta: contract["~orpc"].meta }
-    };
-    const meta = getMeta(procedureish);
-    if (meta.jsonInput) {
-      entries.push([
-        procedurePath,
-        {
-          meta,
-          parsedProcedure: jsonProcedureInputs(),
-          incompatiblePairs: [],
-          procedure
-        }
-      ]);
-      return;
-    }
-    if (!procedureInputsResult.success) {
-      const parsedProcedure2 = jsonProcedureInputs(
-        `procedure's schema couldn't be converted to CLI arguments: ${procedureInputsResult.error}`
-      );
-      entries.push([
-        procedurePath,
-        {
-          meta,
-          parsedProcedure: parsedProcedure2,
-          incompatiblePairs: [],
-          procedure
-        }
-      ]);
-      return;
+  const otherKeys = Object.keys(command.args || {}).filter(
+    (k) => command.args?.[k]?.type !== "positional"
+  );
+  for (const key of otherKeys) {
+    const def = command.args?.[key];
+    if (!def) continue;
+    let rawVal = parsed[key];
+    if (def.type === "array" && rawVal !== void 0 && !Array.isArray(rawVal)) {
+      rawVal = [rawVal];
     }
-    const parsedProcedure = procedureInputsResult.value;
-    const incompatiblePairs = incompatiblePropertyPairs(parsedProcedure.optionsJsonSchema);
-    entries.push([procedurePath, { procedure, meta, incompatiblePairs, parsedProcedure }]);
-  });
-  if (lazyRoutes.length) {
-    const suggestion = `Please use \`import {unlazyRouter} from '@orpc/server'\` to unlazy the router before passing it to @reliverse/rempts`;
-    const routes = lazyRoutes.map(({ path }) => path.join(".")).join(", ");
-    throw new Error(
-      `Lazy routers are not supported. ${suggestion}. Lazy routes detected: ${routes}`
-    );
-  }
-  return entries;
-};
-const jsonProcedureInputs = (reason) => {
-  let description = "Input formatted as JSON";
-  if (reason) description += ` (${reason})`;
-  return {
-    positionalParameters: [],
-    optionsJsonSchema: {
-      type: "object",
-      properties: {
-        input: { type: "json", description }
-      }
-    },
-    getPojoInput: (parsedCliParams) => {
-      if (parsedCliParams.options.input == null) return parsedCliParams.options.input;
-      return JSON.parse(parsedCliParams.options.input);
+    const casted = rawVal !== void 0 ? castArgValue$1(def, rawVal, key) : def.default;
+    const argUsed = rawVal !== void 0 && (def.type === "boolean" ? casted === true : true);
+    if (casted == null && def.required) {
+      throw new Error(`Missing required argument: --${key}`);
     }
-  };
-};
-function createRpcCli({
-  router,
-  ...params
-}) {
-  const procedureEntries = parseRouter({ router, ...params });
-  function buildProgram(runParams) {
-    const logger = { ...lineByLineConsoleLogger, ...runParams?.logger };
-    const program = new TrpcCommand(params.name);
-    if (params.version) program.version(params.version);
-    if (params.description) program.description(params.description);
-    if (params.usage) [params.usage].flat().forEach((usage) => program.usage(usage));
-    program.showHelpAfterError();
-    program.showSuggestionAfterError();
-    const commandTree = {
-      "": program
-      // Root level
-    };
-    const defaultCommands = {};
-    const _process = runParams?.process || process;
-    const configureCommand = (command, procedurePath, { meta, parsedProcedure, incompatiblePairs, procedure }) => {
-      const optionJsonSchemaProperties = flattenedProperties(parsedProcedure.optionsJsonSchema);
-      command.exitOverride((ec) => {
-        _process.exit(ec.exitCode);
-        throw new FailedToExitError(`Command ${command.name()} exitOverride`, {
-          exitCode: ec.exitCode,
-          cause: ec
-        });
-      });
-      command.configureOutput({
-        writeOut: (str) => {
-          logger.info?.(str);
-        },
-        writeErr: (str) => {
-          logger.error?.(str);
-        }
-      });
-      command.showHelpAfterError();
-      if (meta.usage) command.usage([meta.usage].flat().join("\n"));
-      if (meta.examples)
-        command.addHelpText("after", `
-Examples:
-${[meta.examples].flat().join("\n")}`);
-      meta?.aliases?.command?.forEach((alias) => {
-        command.alias(alias);
-      });
-      command.description(meta?.description || "");
-      parsedProcedure.positionalParameters.forEach((param) => {
-        const descriptionParts = [
-          param.type === "string" ? "" : param.type,
-          // "string" is the default assumption, don't bother showing it
-          param.description,
-          param.required ? "(required)" : ""
-        ];
-        const argument = new Argument(param.name, descriptionParts.filter(Boolean).join(" "));
-        if (param.type === "number") {
-          argument.argParser((value) => {
-            const number = numberParser(value, { fallback: null });
-            if (number == null) throw new InvalidArgumentError(`Invalid number: ${value}`);
-            return value;
-          });
-        }
-        argument.required = param.required;
-        argument.variadic = param.array;
-        command.addArgument(argument);
-      });
-      const unusedOptionAliases = {
-        ...meta.aliases?.options
-      };
-      const addOptionForProperty = ([propertyKey, propertyValue]) => {
-        const description = getDescription(propertyValue);
-        const longOption = `--${kebabCase(propertyKey)}`;
-        let flags = longOption;
-        const alias = meta.aliases?.options?.[propertyKey];
-        if (alias) {
-          let prefix = "-";
-          if (alias.startsWith("-")) prefix = "";
-          else if (alias.length > 1) prefix = "--";
-          flags = `${prefix}${alias}, ${flags}`;
-          delete unusedOptionAliases[propertyKey];
-        }
-        const defaultValue = "default" in propertyValue ? { exists: true, value: propertyValue.default } : { exists: false };
-        const rootTypes = getSchemaTypes(propertyValue).sort();
-        const getValueParser = (types) => {
-          types = types.map((t) => t === "integer" ? "number" : t);
-          if (types.length === 2 && types[0] === "boolean" && types[1] === "number") {
-            return {
-              type: "boolean|number",
-              parser: (value) => booleanParser(value, { fallback: null }) ?? numberParser(value)
-            };
-          }
-          if (types.length === 1 && types[0] === "boolean") {
-            return {
-              type: "boolean",
-              parser: (value) => booleanParser(value)
-            };
-          }
-          if (types.length === 1 && types[0] === "number") {
-            return {
-              type: "number",
-              parser: (value) => numberParser(value)
-            };
-          }
-          if (types.length === 1 && types[0] === "string") {
-            return { type: "string", parser: null };
-          }
-          return {
-            type: "json",
-            parser: (value) => {
-              let parsed;
-              try {
-                parsed = JSON.parse(value);
-              } catch {
-                throw new InvalidArgumentError("Malformed JSON.");
-              }
-              const jsonSchemaType = Array.isArray(parsed) ? "array" : parsed === null ? "null" : typeof parsed;
-              if (!types.includes(jsonSchemaType)) {
-                throw new InvalidArgumentError(
-                  `Got ${jsonSchemaType} but expected ${types.join(" or ")}`
-                );
-              }
-              return parsed;
-            }
-          };
-        };
-        const propertyType = rootTypes[0];
-        const isValueRequired = "required" in parsedProcedure.optionsJsonSchema && parsedProcedure.optionsJsonSchema.required?.includes(propertyKey);
-        const isCliOptionRequired = isValueRequired && propertyType !== "boolean" && !defaultValue.exists;
-        function negate() {
-          const negation = new Option(
-            longOption.replace("--", "--no-"),
-            `Negate \`${longOption}\` option.`.trim()
-          );
-          command.addOption(negation);
-        }
-        const bracketise = (name) => isCliOptionRequired ? `<${name}>` : `[${name}]`;
-        if (rootTypes.length === 2 && rootTypes[0] === "boolean" && rootTypes[1] === "string") {
-          const option2 = new Option(`${flags} [value]`, description);
-          option2.default(defaultValue.exists ? defaultValue.value : false);
-          command.addOption(option2);
-          negate();
-          return;
-        }
-        if (rootTypes.length === 2 && rootTypes[0] === "boolean" && rootTypes[1] === "number") {
-          const option2 = new Option(`${flags} [value]`, description);
-          option2.argParser(getValueParser(rootTypes).parser);
-          option2.default(defaultValue.exists ? defaultValue.value : false);
-          command.addOption(option2);
-          negate();
-          return;
-        }
-        if (rootTypes.length === 2 && rootTypes[0] === "number" && rootTypes[1] === "string") {
-          const option2 = new Option(`${flags} ${bracketise("value")}`, description);
-          option2.argParser((value) => {
-            const number = numberParser(value, { fallback: null });
-            return number ?? value;
-          });
-          if (defaultValue.exists) option2.default(defaultValue.value);
-          command.addOption(option2);
-          return;
-        }
-        if (rootTypes.length !== 1) {
-          const option2 = new Option(
-            `${flags} ${bracketise("json")}`,
-            `${description} (value will be parsed as JSON)`
-          );
-          option2.argParser(getValueParser(rootTypes).parser);
-          command.addOption(option2);
-          return;
-        }
-        if (propertyType === "boolean" && isValueRequired) {
-          const option2 = new Option(flags, description);
-          option2.default(defaultValue.exists ? defaultValue.value : false);
-          command.addOption(option2);
-          negate();
-          return;
-        }
-        if (propertyType === "boolean") {
-          const option2 = new Option(`${flags} [boolean]`, description);
-          option2.argParser((value) => booleanParser(value));
-          if (defaultValue.exists) option2.default(defaultValue.value);
-          command.addOption(option2);
-          negate();
-          return;
-        }
-        let option;
-        if (propertyType === "string") {
-          option = new Option(`${flags} ${bracketise("string")}`, description);
-        } else if (propertyType === "boolean") {
-          option = new Option(flags, description);
-        } else if (propertyType === "number" || propertyType === "integer") {
-          option = new Option(`${flags} ${bracketise("number")}`, description);
-          option.argParser((value) => numberParser(value, { fallback: null }));
-        } else if (propertyType === "array") {
-          option = new Option(`${flags} [values...]`, description);
-          if (defaultValue.exists) option.default(defaultValue.value);
-          else if (isValueRequired) option.default([]);
-          const itemsProp = "items" in propertyValue ? propertyValue.items : null;
-          const itemTypes = itemsProp ? getSchemaTypes(itemsProp) : [];
-          const itemEnumTypes = itemsProp && getEnumChoices(itemsProp);
-          if (itemEnumTypes?.type === "string_enum") {
-            option.choices(itemEnumTypes.choices);
-          }
-          const itemParser = getValueParser(itemTypes);
-          if (itemParser.parser) {
-            option.argParser((value, previous) => {
-              const parsed = itemParser.parser(value);
-              if (Array.isArray(previous)) return [...previous, parsed];
-              return [parsed];
-            });
-          }
-        }
-        option ||= new Option(`${flags} [json]`, description);
-        if (defaultValue.exists && option.defaultValue !== defaultValue.value) {
-          option.default(defaultValue.value);
-        }
-        if (option.flags.includes("<")) {
-          option.makeOptionMandatory();
-        }
-        const enumChoices = getEnumChoices(propertyValue);
-        if (enumChoices?.type === "string_enum") {
-          option.choices(enumChoices.choices);
-        }
-        option.conflicts(
-          incompatiblePairs.flatMap((pair) => {
-            const filtered = pair.filter((p) => p !== propertyKey);
-            if (filtered.length === pair.length) return [];
-            return filtered;
-          })
+    if (argUsed && def.dependencies?.length) {
+      const missingDeps = def.dependencies.filter((d) => {
+        const depVal = parsed[d] ?? defaultMap[d];
+        return !depVal;
+      });
+      if (missingDeps.length > 0) {
+        const depsList = missingDeps.map((d) => `--${d}`).join(", ");
+        throw new Error(
+          `Argument --${key} can only be used when ${depsList} ${missingDeps.length === 1 ? "is" : "are"} set`
         );
-        command.addOption(option);
-        if (propertyType === "boolean") negate();
-      };
-      Object.entries(optionJsonSchemaProperties).forEach(addOptionForProperty);
-      const invalidOptionAliases = Object.entries(unusedOptionAliases).map(
-        ([option, alias]) => `${option}: ${alias}`
-      );
-      if (invalidOptionAliases.length) {
-        throw new Error(`Invalid option aliases: ${invalidOptionAliases.join(", ")}`);
       }
-      command.action(async (...args) => {
-        program.__ran ||= [];
-        program.__ran.push(command);
-        const options = command.opts();
-        if (args.at(-2) !== options) {
-          throw new Error("Unexpected args format, second last arg is not the options object", {
-            cause: args
-          });
-        }
-        if (args.at(-1) !== command) {
-          throw new Error("Unexpected args format, last arg is not the Command instance", {
-            cause: args
-          });
-        }
-        const positionalValues = args.slice(0, -2);
-        const input = parsedProcedure.getPojoInput({
-          positionalValues,
-          options
-        });
-        const resolvedTrpcServer = await (params.trpcServer || trpcServer11);
-        let caller;
-        const deprecatedCreateCaller = Reflect.get(params, "createCallerFactory");
-        if (deprecatedCreateCaller) {
-          const message = `Using deprecated \`createCallerFactory\` option. Use \`trpcServer\` instead. e.g. \`createRpcCli({router: myRouter, trpcServer: import('@trpc/server')})\``;
-          logger.error?.(message);
-          caller = deprecatedCreateCaller(router)(params.context);
-        } else if (isOrpcRouter(router)) {
-          const { call } = (() => {
-            try {
-              return require("@orpc/server");
-            } catch (e) {
-              throw new Error(
-                "@orpc/server dependency could not be found - try installing it and re-running",
-                { cause: e }
-              );
-            }
-          })();
-          caller = {
-            [procedurePath]: (_input) => call(procedure, _input, { context: params.context })
-          };
-        } else {
-          const createCallerFactor = resolvedTrpcServer.initTRPC.create().createCallerFactory;
-          caller = createCallerFactor(router)(params.context);
-        }
-        const result = await (caller[procedurePath]?.(input)).catch((err) => {
-          throw transformError(err, command);
-        });
-        command.__result = result;
-        if (result != null) logger.info?.(result);
+    }
+    finalArgs[key] = def.type === "boolean" ? Boolean(casted) : casted;
+  }
+  return {
+    args: finalArgs,
+    raw: argv
+  };
+}
+async function createContextFromArgs(command, inputArgs) {
+  const finalArgs = {};
+  for (const [key, def] of Object.entries(command.args || {})) {
+    const inputValue = inputArgs[key];
+    let value;
+    if (inputValue !== void 0) {
+      value = castArgValue$1(def, inputValue, key);
+    } else if (def.default !== void 0) {
+      value = def.type === "array" && typeof def.default === "string" ? [def.default] : def.default;
+    } else if (def.type === "boolean") {
+      value = false;
+    } else {
+      value = void 0;
+    }
+    if (value == null && def.required) {
+      throw new Error(`Missing required argument: ${key}`);
+    }
+    if (value != null && def.dependencies?.length) {
+      const missingDeps = def.dependencies.filter((d) => {
+        const depVal = inputArgs[d];
+        return !depVal;
       });
-    };
-    procedureEntries.forEach(([procedurePath, commandConfig]) => {
-      const segments = procedurePath.split(".");
-      let currentPath = "";
-      for (let i = 0; i < segments.length - 1; i++) {
-        const segment = segments[i];
-        if (!segment) continue;
-        const parentPath2 = currentPath;
-        currentPath = currentPath ? `${currentPath}.${segment}` : segment;
-        if (!commandTree[currentPath]) {
-          const parentCommand2 = commandTree[parentPath2];
-          if (!parentCommand2) continue;
-          const newCommand = new TrpcCommand(kebabCase(segment));
-          newCommand.showHelpAfterError();
-          parentCommand2.addCommand(newCommand);
-          commandTree[currentPath] = newCommand;
-        }
-      }
-      const leafName = segments.at(-1);
-      if (!leafName) return;
-      const parentPath = segments.length > 1 ? segments.slice(0, -1).join(".") : "";
-      const parentCommand = commandTree[parentPath];
-      if (!parentCommand) return;
-      const leafCommand = new TrpcCommand(kebabCase(leafName));
-      configureCommand(leafCommand, procedurePath, commandConfig);
-      parentCommand.addCommand(leafCommand);
-      const meta = commandConfig.meta;
-      if (meta.default === true) {
-        parentCommand.allowExcessArguments();
-        parentCommand.allowUnknownOption();
-        parentCommand.addHelpText("after", leafCommand.helpInformation());
-        parentCommand.action(async () => {
-          await leafCommand.parseAsync([...parentCommand.args], {
-            from: "user"
-          });
-        });
-        defaultCommands[parentPath] = {
-          procedurePath,
-          config: commandConfig,
-          command: leafCommand
-        };
+      if (missingDeps.length > 0) {
+        const depsList = missingDeps.join(", ");
+        throw new Error(
+          `Argument '${key}' can only be used when ${depsList} ${missingDeps.length === 1 ? "is" : "are"} provided`
+        );
       }
-    });
-    Object.entries(commandTree).forEach(([path, command]) => {
-      if (command.commands.length === 0) return;
-      const subcommandNames = command.commands.map((cmd) => cmd.name());
-      const defaultCommand = defaultCommands[path]?.command.name();
-      const formattedSubcommands = subcommandNames.map((name) => name === defaultCommand ? `${name} (default)` : name).join(", ");
-      const existingDescription = command.description() || "";
-      const descriptionParts = [
-        existingDescription,
-        `Available subcommands: ${formattedSubcommands}`
-      ];
-      command.description(descriptionParts.filter(Boolean).join("\n"));
-    });
-    return program;
-  }
-  const run = async (runParams, program = buildProgram(runParams)) => {
-    if (!looksLikeInstanceof(program, "TrpcCommand"))
-      throw new Error("program is not a TrpcCommand instance");
-    const opts = runParams?.argv ? { from: "user" } : void 0;
-    const argv = [...runParams?.argv || process.argv];
-    const _process = runParams?.process || process;
-    const logger = { ...lineByLineConsoleLogger, ...runParams?.logger };
-    program.exitOverride((exit) => {
-      _process.exit(exit.exitCode);
-      throw new FailedToExitError("Root command exitOverride", {
-        exitCode: exit.exitCode,
-        cause: exit
-      });
-    });
-    program.configureOutput({
-      writeOut: (str) => logger.info?.(str),
-      writeErr: (str) => logger.error?.(str)
-    });
-    if (runParams?.completion) {
-      const completion = typeof runParams.completion === "function" ? await runParams.completion() : runParams.completion;
-      addCompletions(program, completion);
     }
-    const formatError = runParams?.formatError || ((err) => {
-      if (err instanceof CliValidationError) {
-        return err.message;
-      }
-      return inspect(err);
-    });
-    if (runParams?.prompts) {
-      program = promptify(program, runParams.prompts);
-    }
-    await program.parseAsync(argv, opts).catch((err) => {
-      if (err instanceof FailedToExitError) throw err;
-      const logMessage = looksLikeInstanceof(err, Error) ? formatError(err) || err.message : `Non-error of type ${typeof err} thrown: ${err}`;
-      logger.error?.(logMessage);
-      _process.exit(1);
-      throw new FailedToExitError("Program exit after failure", {
-        exitCode: 1,
-        cause: err
-      });
-    });
-    _process.exit(0);
-    throw new FailedToExitError("Program exit after success", {
-      exitCode: 0,
-      cause: program.__ran.at(-1)?.__result
-    });
-  };
+    finalArgs[key] = value;
+  }
   return {
-    run,
-    buildProgram,
-    toJSON: (program = buildProgram()) => commandToJSON(program)
+    args: finalArgs,
+    raw: []
+    // No raw argv for object input
   };
 }
-function getMeta(procedure) {
-  const meta = procedure._def.meta;
-  return meta?.cliMeta || meta || {};
-}
-function kebabCase(propName) {
-  return propName.replaceAll(/([A-Z])/g, "-$1").toLowerCase();
-}
-function transformError(err, command) {
-  if (looksLikeInstanceof(err, Error) && err.message.includes("This is a client-only function")) {
-    return new Error(
-      "Failed to create trpc caller. If using trpc v10, either upgrade to v11 or pass in the `@trpc/server` module to `createRpcCli` explicitly"
-    );
-  }
-  if (looksLikeInstanceof(err, "TRPCError")) {
-    const cause = err.cause;
-    if (looksLikeStandardSchemaFailure(cause)) {
-      const prettyMessage = prettifyStandardSchemaError(cause);
-      return new CliValidationError(`${prettyMessage}
-
-${command.helpInformation()}`);
+function castArgValue$1(def, rawVal, argName) {
+  if (rawVal == null) {
+    if (def.type === "array" && typeof def.default === "string") {
+      return [def.default];
     }
-    if (err.code === "BAD_REQUEST" && (err.cause?.constructor?.name === "TraversalError" || // arktype error
-    err.cause?.constructor?.name === "StandardSchemaV1Error")) {
-      return new CliValidationError(`${err.cause.message}
-
-${command.helpInformation()}`);
+    return def.default ?? void 0;
+  }
+  let castedValue;
+  switch (def.type) {
+    case "boolean":
+      if (typeof rawVal === "string") {
+        const lower = rawVal.toLowerCase();
+        if (lower === "true") castedValue = true;
+        else if (lower === "false") castedValue = false;
+        else castedValue = Boolean(rawVal);
+      } else {
+        castedValue = Boolean(rawVal);
+      }
+      if (def.allowed && !def.allowed.includes(castedValue)) {
+        throw new Error(
+          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
+      }
+      return castedValue;
+    case "string":
+      castedValue = typeof rawVal === "string" ? rawVal : String(rawVal);
+      if (def.allowed && !def.allowed.includes(castedValue)) {
+        throw new Error(
+          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
+      }
+      return castedValue;
+    case "number": {
+      const n = Number(rawVal);
+      if (Number.isNaN(n)) {
+        throw new Error(`Invalid number provided for ${argName}: ${rawVal}`);
+      }
+      if (def.allowed && !def.allowed.includes(n)) {
+        throw new Error(
+          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
+      }
+      return n;
     }
-    if (err.code === "INTERNAL_SERVER_ERROR") {
-      return cause;
+    case "positional":
+      castedValue = String(rawVal);
+      if (def.allowed && !def.allowed.includes(castedValue)) {
+        throw new Error(
+          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
+      }
+      return castedValue;
+    case "array": {
+      const arrVal = Array.isArray(rawVal) ? rawVal : [String(rawVal)];
+      const result = [];
+      for (let v of arrVal.map(String)) {
+        if (v.startsWith("[") && v.endsWith("]")) {
+          v = v.slice(1, -1);
+        }
+        const parts = v.split(/\s*,\s*/).filter(Boolean);
+        for (const p of parts) {
+          if (def.allowed && !def.allowed.includes(p)) {
+            throw new Error(
+              `Invalid value in array ${argName}: ${p}. Allowed values are: ${def.allowed.join(", ")}`
+            );
+          }
+        }
+        result.push(...parts);
+      }
+      return result;
     }
+    default:
+      return rawVal;
   }
-  return err;
 }
-const numberParser = (val, { fallback = val } = {}) => {
-  const number = Number(val);
-  return Number.isNaN(number) ? fallback : number;
-};
-const booleanParser = (val, { fallback = val } = {}) => {
-  if (val === "true") return true;
-  if (val === "false") return false;
-  return fallback;
-};
 
+async function pathExists(path2) {
+  try {
+    await stat(path2);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
 function buildExampleArgs(args) {
   const parts = [];
   const positionalKeys = Object.keys(args || {}).filter((k) => args?.[k]?.type === "positional");
@@ -5376,7 +3932,6 @@ function defineCommand(options) {
     onCmdExit,
     onLauncherInit,
     onLauncherExit,
-    router: options.router,
     // Backward-compatible aliases
     setup: onCmdInit,
     cleanup: onCmdExit
@@ -5410,7 +3965,7 @@ async function getDefaultCliNameAndVersion() {
 }
 async function findRecursiveFileBasedCommands(baseDir, currentPath = []) {
   const results = [];
-  const items = await fs.readdir(path.join(baseDir, ...currentPath), {
+  const items = await readdir(path.join(baseDir, ...currentPath), {
     withFileTypes: true
   });
   for (const dirent of items) {
@@ -5418,7 +3973,7 @@ async function findRecursiveFileBasedCommands(baseDir, currentPath = []) {
       const newPath = [...currentPath, dirent.name];
       for (const fname of ["cmd.ts", "cmd.js"]) {
         const fpath = path.join(baseDir, ...newPath, fname);
-        if (await fs.pathExists(fpath)) {
+        if (await pathExists(fpath)) {
           try {
             const imported = await import(path.resolve(fpath));
             if (imported.default && !imported.default.meta?.hidden) {
@@ -5676,84 +4231,6 @@ function createCli(options, legacyParserOptions) {
     };
   }
   const execute = async (_ctx) => {
-    if (options && typeof options === "object" && "rpc" in options && options.rpc) {
-      const rpcOptions = options.rpc;
-      const rpcRunParams = options.rpcRunParams || {};
-      debugLog("RPC integration detected, creating RPC CLI...");
-      try {
-        require("tsx/cjs");
-        await import('tsx/esm');
-        debugLog("tsx loaded successfully for TypeScript support");
-      } catch {
-        debugLog("tsx not available, continuing without TypeScript support");
-      }
-      const getRouterMeta = (router) => {
-        if ("_def" in router && router._def && "meta" in router._def) {
-          return router._def.meta;
-        }
-        return;
-      };
-      const routerMeta = getRouterMeta(rpcOptions.router);
-      const rpcCli = createRpcCli({
-        router: rpcOptions.router,
-        name: globalCliMeta.name || routerMeta?.name,
-        version: globalCliMeta.version || routerMeta?.version,
-        description: globalCliMeta.description || routerMeta?.description,
-        usage: rpcOptions.usage,
-        context: rpcOptions.context,
-        trpcServer: rpcOptions.trpcServer,
-        "@valibot/to-json-schema": rpcOptions["@valibot/to-json-schema"],
-        effect: rpcOptions.effect
-      });
-      debugLog("RPC CLI created, running with argv:", rpcRunParams.argv || process$1.argv.slice(2));
-      await rpcCli.run({
-        argv: rpcRunParams.argv || process$1.argv.slice(2),
-        logger: rpcRunParams.logger || {
-          info: console.log,
-          error: console.error
-        },
-        completion: rpcRunParams.completion,
-        prompts: rpcRunParams.prompts,
-        formatError: rpcRunParams.formatError,
-        process: rpcRunParams.process
-      });
-      return;
-    }
-    if (command.router) {
-      debugLog("Router detected in command, automatically enabling RPC mode...");
-      try {
-        require("tsx/cjs");
-        await import('tsx/esm');
-        debugLog("tsx loaded successfully for TypeScript support");
-      } catch {
-        debugLog("tsx not available, continuing without TypeScript support");
-      }
-      const getRouterMeta = (router) => {
-        if ("_def" in router && router._def && "meta" in router._def) {
-          return router._def.meta;
-        }
-        return;
-      };
-      const routerMeta = getRouterMeta(command.router);
-      const rpcCli = createRpcCli({
-        router: command.router,
-        name: globalCliMeta.name || command.meta?.name || routerMeta?.name,
-        version: globalCliMeta.version || command.meta?.version || routerMeta?.version,
-        description: globalCliMeta.description || command.meta?.description || routerMeta?.description
-      });
-      debugLog("RPC CLI created from command router, running with argv:", process$1.argv.slice(2));
-      await rpcCli.run({
-        argv: process$1.argv.slice(2),
-        logger: {
-          info: console.log,
-          error: console.error
-        },
-        process: {
-          exit: process$1.exit
-        }
-      });
-      return;
-    }
     if (typeof command.onLauncherInit === "function") {
       try {
         await command.onLauncherInit();
@@ -5767,7 +4244,7 @@ function createCli(options, legacyParserOptions) {
       if (!parserOptions.fileBased && !command.commands) {
         const mainEntry = process$1.argv[1] ? path.dirname(path.resolve(process$1.argv[1])) : process$1.cwd();
         const defaultCmdsRoot = path.join(mainEntry, "src", "app");
-        const exists = await fs.pathExists(defaultCmdsRoot);
+        const exists = await pathExists(defaultCmdsRoot);
         const finalCmdsRoot = exists ? defaultCmdsRoot : path.join(mainEntry, "app");
         parserOptions.fileBased = {
           enable: true,
@@ -5776,10 +4253,10 @@ function createCli(options, legacyParserOptions) {
       }
       const rawArgv = process$1.argv.slice(2);
       const autoExit = parserOptions.autoExit !== false;
-      if (!(parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0 || command.run || command.router)) {
+      if (!(parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0 || command.run)) {
         relinka(
           "error",
-          "Invalid CLI configuration: No file-based commands, subCommands, run() handler, or router are defined. This CLI will not do anything.\n\u2502   To fix: add file-based commands (./app), or provide at least one subCommand, a run() handler, or a router."
+          "Invalid CLI configuration: No file-based commands, subCommands, or run() handler are defined. This CLI will not do anything.\n\u2502   To fix: add file-based commands (./app), or provide at least one subCommand, or a run() handler."
         );
         process$1.exit(1);
       }
@@ -5961,7 +4438,7 @@ async function runFileBasedSubCmd(subName, argv, fileCmdOpts, parserOptions, par
     if (args.length === 0 || args[0] && isFlag(args[0])) {
       const possibleFiles2 = [path.join(baseDir, "cmd.js"), path.join(baseDir, "cmd.ts")];
       for (const file of possibleFiles2) {
-        if (await fs.pathExists(file)) {
+        if (await pathExists(file)) {
           return { importPath: file, leftoverArgv: args };
         }
       }
@@ -5973,12 +4450,12 @@ Info for this CLI's developer: No valid command file found in ${baseDir}`
       );
     }
     const nextDir = path.join(baseDir, args[0] || "");
-    if (await fs.pathExists(nextDir) && (await fs.stat(nextDir)).isDirectory()) {
+    if (await pathExists(nextDir) && (await stat(nextDir)).isDirectory()) {
       return resolveCmdPath(nextDir, args.slice(1));
     }
     const possibleFiles = [path.join(baseDir, "cmd.js"), path.join(baseDir, "cmd.ts")];
     for (const file of possibleFiles) {
-      if (await fs.pathExists(file)) {
+      if (await pathExists(file)) {
         return { importPath: file, leftoverArgv: args };
       }
     }
@@ -5990,7 +4467,7 @@ Info for this CLI's developer: No valid command file found in ${baseDir}`
     );
   }
   const startDir = path.join(fileCmdOpts.cmdsRootPath, subName);
-  if (!await fs.pathExists(startDir) || !(await fs.stat(startDir)).isDirectory()) {
+  if (!await pathExists(startDir) || !(await stat(startDir)).isDirectory()) {
     const attempted = [subName, ...argv].join(" ");
     const expectedPath = path.relative(
       process$1.cwd(),
@@ -6113,7 +4590,7 @@ async function runCommandWithArgs(command, argv, parserOptions, globalCliMeta, r
     if (command.run) {
       await command.run(ctx);
     } else {
-      const isDispatcher = parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0 || command.router;
+      const isDispatcher = parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0;
       const noSubcommandArgInCurrentCall = !argv.some((arg) => !isFlag(arg));
       if (isDispatcher && noSubcommandArgInCurrentCall) {
         relinka("warn", "Please specify a command");
@@ -6250,110 +4727,6 @@ function normalizeArgv(argv) {
   }
   return normalized;
 }
-async function runCmdWithSubcommands(command, argv = [], parserOptions = {}) {
-  const normalizedArgv = normalizeArgv(argv);
-  let currentCommand = command;
-  let currentArgv = normalizedArgv;
-  while (currentCommand.commands && currentArgv.length > 0 && currentArgv[0] && !isFlag(currentArgv[0])) {
-    const [maybeSub, ...restArgv] = currentArgv;
-    let subSpec;
-    for (const [key, spec] of Object.entries(currentCommand.commands)) {
-      if (key === maybeSub) {
-        subSpec = spec;
-        break;
-      }
-      try {
-        const cmd = await loadSubCommand(spec);
-        if (cmd.meta?.aliases?.includes(maybeSub)) {
-          subSpec = spec;
-          break;
-        }
-      } catch (err) {
-        debugLog(`Error checking alias for command ${key}:`, err);
-      }
-    }
-    if (!subSpec) break;
-    const loaded = await loadSubCommand(subSpec);
-    currentCommand = loaded;
-    currentArgv = restArgv;
-  }
-  return await runCommandWithArgs(currentCommand, currentArgv, {
-    ...parserOptions,
-    autoExit: false
-    // Don't exit process in programmatic usage
-  });
-}
-async function runCmd(command, argv = [], parserOptions = {}) {
-  const normalizedArgv = normalizeArgv(argv);
-  const booleanKeys = Object.keys(command.args || {}).filter(
-    (k) => command.args?.[k]?.type === "boolean"
-  );
-  const defaultMap = {};
-  for (const [argKey, def] of Object.entries(command.args || {})) {
-    if (def.type === "boolean") {
-      defaultMap[argKey] = def.default !== void 0 ? def.default : false;
-    } else if (def.default !== void 0) {
-      defaultMap[argKey] = def.type === "array" && typeof def.default === "string" ? [def.default] : def.default;
-    }
-  }
-  const mergedParserOptions = {
-    ...parserOptions,
-    boolean: [...parserOptions.boolean || [], ...booleanKeys],
-    defaults: { ...defaultMap, ...parserOptions.defaults || {} }
-  };
-  const parsed = reliArgParser(normalizedArgv, mergedParserOptions);
-  debugLog("Parsed arguments (runCmd):", parsed);
-  const finalArgs = {};
-  const positionalKeys = Object.keys(command.args || {}).filter(
-    (k) => command.args?.[k]?.type === "positional"
-  );
-  const leftoverPositionals = [...parsed._ || []];
-  for (let i = 0; i < positionalKeys.length; i++) {
-    const key = positionalKeys[i];
-    if (!key || !command.args) continue;
-    const def = command.args[key];
-    const val = leftoverPositionals[i];
-    finalArgs[key] = val != null && def ? castArgValue(def, val, key) : def?.default;
-  }
-  const otherKeys = Object.keys(command.args || {}).filter(
-    (k) => command.args?.[k]?.type !== "positional"
-  );
-  for (const key of otherKeys) {
-    const def = command.args?.[key];
-    if (!def) continue;
-    let rawVal = parsed[key];
-    if (def.type === "array" && rawVal !== void 0 && !Array.isArray(rawVal)) {
-      rawVal = [rawVal];
-    }
-    const casted = rawVal !== void 0 ? castArgValue(def, rawVal, key) : def.default;
-    const argUsed = rawVal !== void 0 && (def.type === "boolean" ? casted === true : true);
-    if (casted == null && def.required) {
-      throw new Error(`Missing required argument: --${key}`);
-    }
-    if (argUsed && def.dependencies?.length) {
-      const missingDeps = def.dependencies.filter((d) => {
-        const depVal = parsed[d] ?? defaultMap[d];
-        return !depVal;
-      });
-      if (missingDeps.length) {
-        const depsList = missingDeps.map((d) => `--${d}`).join(", ");
-        throw new Error(
-          `Argument --${key} can only be used when ${depsList} ${missingDeps.length === 1 ? "is" : "are"} set`
-        );
-      }
-    }
-    finalArgs[key] = def.type === "boolean" ? Boolean(casted) : casted;
-  }
-  const ctx = {
-    args: finalArgs,
-    raw: argv
-  };
-  if (typeof command.run === "function") {
-    await command.run(ctx);
-  } else {
-    throw new Error("Command has no run() handler.");
-  }
-}
 function getParsedContext(command, argv, parserOptions) {
   const normalizedArgv = normalizeArgv(argv);
   const booleanKeys = Object.keys(command.args || {}).filter(
@@ -6409,7 +4782,7 @@ async function resolveFileBasedCommandPath(cmdsRoot, argv) {
   let leftover = [...argv];
   while (leftover.length > 0 && leftover[0] && !isFlag(leftover[0])) {
     const nextDir = path.join(currentDir, leftover[0]);
-    if (await fs.pathExists(nextDir) && (await fs.stat(nextDir)).isDirectory()) {
+    if (await pathExists(nextDir) && (await stat(nextDir)).isDirectory()) {
       currentDir = nextDir;
       pathSegments.push(leftover[0]);
       leftover = leftover.slice(1);
@@ -6419,7 +4792,7 @@ async function resolveFileBasedCommandPath(cmdsRoot, argv) {
   }
   for (const fname of ["cmd.ts", "cmd.js"]) {
     const fpath = path.join(currentDir, fname);
-    if (await fs.pathExists(fpath)) {
+    if (await pathExists(fpath)) {
       const imported = await import(path.resolve(fpath));
       if (imported.default) {
         return {
@@ -6461,65 +4834,6 @@ function levenshteinDistance(a, b) {
   return matrix[b.length][a.length];
 }
 
-function argsToStringArray(args) {
-  const result = [];
-  for (const [key, value] of Object.entries(args)) {
-    if (value === void 0 || value === null) continue;
-    if (typeof value === "boolean") {
-      result.push(`--${key}=${value}`);
-    } else if (Array.isArray(value)) {
-      result.push(`--${key}=${value.join(",")}`);
-    } else {
-      result.push(`--${key}=${String(value)}`);
-    }
-  }
-  return result;
-}
-async function createCallCmd() {
-  return async function callCmd(cmdName, args) {
-    try {
-      const command = await loadCommand(cmdName);
-      const stringArgs = args ? argsToStringArray(args) : [];
-      await runCmd(command, stringArgs);
-    } catch (error) {
-      console.error(`Error running command '${String(cmdName)}':`, error);
-      throw error;
-    }
-  };
-}
-async function createGetTypedCmd() {
-  return async function getTypedCmd(cmdName) {
-    const command = await loadCommand(cmdName);
-    return {
-      command,
-      run: async (args) => {
-        const stringArgs = args ? argsToStringArray(args) : [];
-        await runCmd(command, stringArgs);
-      }
-    };
-  };
-}
-async function callCmdImpl(cmdName, args) {
-  try {
-    const command = await loadCommand(cmdName);
-    const stringArgs = args ? argsToStringArray(args) : [];
-    await runCmd(command, stringArgs);
-  } catch (error) {
-    console.error(`Error running command '${String(cmdName)}':`, error);
-    throw error;
-  }
-}
-async function getTypedCmdImpl(cmdName) {
-  const command = await loadCommand(cmdName);
-  return {
-    command,
-    run: async (args) => {
-      const stringArgs = args ? argsToStringArray(args) : [];
-      await runCmd(command, stringArgs);
-    }
-  };
-}
-
 const runMain = createCli;
 
 const log = relinka;
@@ -8462,4 +6776,4 @@ function normalizeName(name) {
   return lastSegment.replace(/[^a-zA-Z0-9-]/g, "");
 }
 
-export { CANCEL, CliValidationError, FailedToExitError, StandardSchemaV1Error, TrpcCommand, addCompletions, animateText, animationMap, anykeyPrompt, applyVariant, argsToStringArray, bar, block, breakLines, callCmdImpl, cancel, colorMap, colorize, commandToJSON, completePrompt, confirm, confirmPrompt, countLines$1 as countLines, createAsciiArt, createCallCmd, createCancel, createCli, createGetTypedCmd, createMultiStep, createRpcCli, createShadowCommand, createStep, datePrompt, defineArgs, defineCommand, deleteLastLine, deleteLastLines, endPrompt, errorHandler, fallbackSymbols, figures, flattenedProperties, fmt, getColumns, getDescription, getEnumChoices, getExactTerminalWidth, getSchemaTypes, getTerminalHeight, getTerminalWidth$1 as getTerminalWidth, getTypedCmdImpl, group, incompatiblePropertyPairs, input, inputPrompt, intro, introPrompt, isCancel, isOrpcRouter, isTerminalInteractive, isTrpc11Procedure, isTrpc11Router, isValidName, isValidVariant, isWindows, lineByLineConsoleLogger, lineByLineLogger, loadCommand, log, looksLikeInstanceof, looksLikeStandardSchema, looksLikeStandardSchemaFailure, mainSymbols, msg, msgUndo, msgUndoAll, multiselect, multiselectPrompt, nextStepsPrompt, normalizeName, numMultiSelectPrompt, numSelectPrompt, numberPrompt, outro, outroPrompt, parseProcedureInputs, parseRouter, password, pm, prettifyStandardSchemaError, preventUnsupportedTTY, preventWindowsHomeDirRoot, preventWrongTerminalSize, printLineBar, promptify, relinkaAsyncByRemptsDeprecated, relinkaByRemptsDeprecated, reliversePrompts, removeCursor, renderEndLine, renderEndLineInput, restoreCursor, resultPrompt, runCmd, runCmdWithSubcommands, runMain, select, selectPrompt, selectSimple, setRawMode, showUsage, spinner, startEditor, startPrompt, streamText, streamTextBox, streamTextWithSpinner, symbols, taskProgressPrompt, taskSpinPrompt, text, throwError, toBaseColor, toDotPath, toSolidColor, togglePrompt, typographyMap, useSpinner, variantMap };
+export { CANCEL, animateText, animationMap, anykeyPrompt, applyVariant, bar, block, breakLines, callCmd, cancel, colorMap, colorize, completePrompt, confirm, confirmPrompt, countLines$1 as countLines, createAsciiArt, createCancel, createCli, createMultiStep, createStep, datePrompt, defineArgs, defineCommand, deleteLastLine, deleteLastLines, endPrompt, errorHandler, fallbackSymbols, figures, fmt, getColumns, getExactTerminalWidth, getTerminalHeight, getTerminalWidth$1 as getTerminalWidth, group, input, inputPrompt, intro, introPrompt, isCancel, isTerminalInteractive, isValidName, isValidVariant, isWindows, log, mainSymbols, msg, msgUndo, msgUndoAll, multiselect, multiselectPrompt, nextStepsPrompt, normalizeName, numMultiSelectPrompt, numSelectPrompt, numberPrompt, outro, outroPrompt, password, pm, preventUnsupportedTTY, preventWindowsHomeDirRoot, preventWrongTerminalSize, printLineBar, relinkaAsyncByRemptsDeprecated, relinkaByRemptsDeprecated, reliversePrompts, removeCursor, renderEndLine, renderEndLineInput, restoreCursor, resultPrompt, runMain, select, selectPrompt, selectSimple, setRawMode, showUsage, spinner, startEditor, startPrompt, streamText, streamTextBox, streamTextWithSpinner, symbols, taskProgressPrompt, taskSpinPrompt, text, throwError, toBaseColor, toSolidColor, togglePrompt, typographyMap, useSpinner, variantMap };