@reliverse/rempts 1.7.48 → 1.7.50

package/dist-npm/bin/mod.d.mts

@@ -1152,40 +1152,43 @@ type EmptyArgs = Record<string, never>;
 interface BaseArgProps {
     description?: string;
     required?: boolean;
-    allowed?: string[];
+    allowed?: readonly string[];
 }
 interface BaseArgDefinition {
     type: string;
     description?: string;
     required?: boolean;
     default?: any;
-    allowed?: any[];
+    allowed?: readonly any[];
     dependencies?: string[];
 }
 type PositionalArgDefinition = BaseArgDefinition & {
     type: "positional";
     default?: string;
+    allowed?: readonly string[];
 };
 type BooleanArgDefinition = BaseArgDefinition & {
     type: "boolean";
     default?: boolean;
-    allowed?: boolean[];
+    allowed?: readonly boolean[];
     alias?: string;
 };
 type StringArgDefinition = BaseArgDefinition & {
     type: "string";
     default?: string;
+    allowed?: readonly string[];
     alias?: string;
 };
 type NumberArgDefinition = BaseArgDefinition & {
     type: "number";
     default?: number;
-    allowed?: number[];
+    allowed?: readonly number[];
     alias?: string;
 };
 type ArrayArgDefinition = BaseArgDefinition & {
     type: "array";
     default?: string | readonly string[];
+    allowed?: readonly string[];
     alias?: string;
 };
 type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
@@ -1297,49 +1300,69 @@ interface Command<A extends ArgDefinitions = EmptyArgs> {
      */
     router?: AnyRouter;
 }
+type ExtractAllowed<T extends ArgDefinition> = T extends {
+    type: "positional";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "positional";
+} ? string : T extends {
+    type: "boolean";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "boolean";
+} ? boolean : T extends {
+    type: "string";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "string";
+} ? string : T extends {
+    type: "number";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "number";
+} ? number : T extends {
+    type: "array";
+    allowed: readonly (infer U)[];
+} ? U[] : T extends {
+    type: "array";
+} ? string[] : never;
 type InferArgTypes<A extends ArgDefinitions> = {
-    [K in keyof A]: A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
-        type: "array";
-    } ? string[] : never;
+    [K in keyof A]: ExtractAllowed<A[K]>;
 };
 interface FileBasedOptions {
     enable: boolean;
     cmdsRootPath: string;
 }
 
+interface CallCmdOptions {
+    /** Whether to automatically exit process on errors (default: false for programmatic usage) */
+    autoExit?: boolean;
+    /** Whether to show debug output */
+    debug?: boolean;
+    /** Whether to call lifecycle hooks (onCmdInit/onCmdExit) */
+    useLifecycleHooks?: boolean;
+    /** Custom parser options for argv processing */
+    parserOptions?: ReliArgParserOptions;
+}
 /**
- * Load a command from the filesystem.
+ * Programmatically call a defineCommand command with arguments.
+ * Fully compatible with launcher-mod.ts execution logic.
  *
- * @param cmdPath - Path to the command file or directory containing cmd.ts/cmd.js
- * @returns Promise<Command> - The loaded command
+ * @param command - The command definition created with defineCommand()
+ * @param input - Either argv array (CLI-style) or args object (programmatic style)
+ * @param options - Optional configuration for execution
+ * @returns Promise resolving to the command context
  *
  * @example
  * ```ts
- * // Load a command
- * const cmd = await loadCommand("./web/cmd");
+ * // CLI-style with argv array
+ * const result = await callCmd(myCommand, ['--flag', 'value', 'positional']);
  *
- * // Use with runCmd - pass args as separate array elements
- * await runCmd(cmd, ["--dev", "true"]); // ✅ Correct
- * await runCmd(cmd, [`--dev ${isDev}`]); // ❌ Wrong - creates single string
+ * // Programmatic style with object
+ * const result = await callCmd(myCommand, { flag: true, name: 'value' });
  * ```
  */
-declare function loadCommand(cmdPath: string): Promise<Command>;
-
-/**
- * Static implementation functions for the typed command system.
- * These functions are imported by the generated cmds.ts file.
- */
-declare function argsToStringArray(args: Record<string, unknown>): string[];
-declare function createCallCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T, args?: TCommandArgsMap[T]) => Promise<void>)>;
-declare function createGetTypedCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T) => Promise<{
-    command: Command;
-    run: (args?: TCommandArgsMap[T]) => Promise<void>;
-}>)>;
-declare function callCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap, args?: TCommandArgsMap[keyof TCommandArgsMap]): Promise<void>;
-declare function getTypedCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap): Promise<{
-    command: Command;
-    run: (args?: TCommandArgsMap[keyof TCommandArgsMap]) => Promise<void>;
-}>;
+declare function callCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, input: string[] | Partial<InferArgTypes<A>>, options?: CallCmdOptions): Promise<CommandContext<InferArgTypes<A>>>;
 
 /**
  * JSON representation of a commander `Command` instance
@@ -1758,64 +1781,6 @@ declare function createCli<A extends ArgDefinitions = EmptyArgs>(options: Comman
  * for IntelliSense and validation for array defaults against options.
  */
 declare function defineArgs<A extends ArgDefinitions>(args: A): A;
-/**
- * Programmatically run a command with subcommand support and flexible argument handling.
- * This function can handle subcommands (including nested), positional arguments, and automatically normalizes
- * template literals and space-separated strings.
- *
- * @param command The command definition (from defineCommand)
- * @param argv The argv array to parse (default: []). Supports template literals and subcommands.
- * @param parserOptions Optional reliArgParser options
- *
- * @example
- * ```ts
- * // ✅ Single command with template literals
- * await runCmdWithSubcommands(cmd, [`--dev ${isDev}`]);
- *
- * // ✅ Subcommand with arguments
- * await runCmdWithSubcommands(cmd, [`build --input src/mod.ts --someBoolean`]);
- *
- * // ✅ Subcommand with positional arguments
- * await runCmdWithSubcommands(cmd, [`build src/mod.ts --someBoolean`]);
- *
- * // ✅ Nested subcommands
- * await runCmdWithSubcommands(cmd, [`build someSubCmd src/mod.ts --no-cjs`]);
- * await runCmdWithSubcommands(cmd, [`build sub1 sub2 sub3 file.ts --flag`]);
- *
- * // ✅ Mixed array with subcommands
- * await runCmdWithSubcommands(cmd, [
- *   `build someSubCmd src/mod.ts`,
- *   "--no-cjs",
- *   "--verbose"
- * ]);
- * ```
- */
-declare function runCmdWithSubcommands<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions & {
-    fileBased?: FileBasedOptions;
-    autoExit?: boolean;
-}): Promise<any>;
-/**
- * Programmatically run a command's run() handler with parsed arguments.
- * Does not handle subcommands, file-based commands, or global hooks.
- * Suitable for use in demos, tests, or programmatic invocation.
- *
- * @param command The command definition (from defineCommand)
- * @param argv The argv array to parse (default: []). Each argument should be a separate array element.
- * @param parserOptions Optional reliArgParser options
- *
- * @example
- * **each argument as separate array element**:
- * ```ts
- * await runCmd(cmd, ["--dev", "true"]);
- * await runCmd(cmd, ["--name", "John", "--verbose"]);
- * ```
- * **automatic normalization of template literals**:
- * ```ts
- * await runCmd(cmd, [`--dev ${isDev}`]); // Automatically converted to ["--dev", "true"]
- * await runCmd(cmd, [`--dev ${isDev} --build mod.ts`]); // ["--dev", "true", "--build", "mod.ts"]
- * ```
- */
-declare function runCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions): Promise<void>;
 
 declare const runMain: typeof createCli;
 
@@ -2329,5 +2294,5 @@ declare function createAsciiArt({ message, font, clearConsole, }: {
     clearConsole?: boolean;
 }): Promise<void>;
 
-export { CANCEL, CliValidationError, FailedToExitError, StandardSchemaV1Error, TrpcCommand, addCompletions, animateText, animationMap, anykeyPrompt, applyVariant, argsToStringArray, bar, block, breakLines, callCmdImpl, cancel, colorMap, colorize, commandToJSON, completePrompt, confirm, confirmPrompt, 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, 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 type { AllKinds, AnyProcedure, AnyRouter, ArgDefinition, ArgDefinitions, ArrayArgDefinition, BaseArgDefinition, BaseArgProps, BooleanArgDefinition, BorderColorName, CancelValue, ChoiceOptions, ClackPromptsLike, ColorName, Command, CommandContext, CommandHook, CommandJSON, CommandMeta, CommandRun, CommandSpec, CommanderProgramLike, CommandsMap, ConfirmPromptOptions, CreateCallerFactoryLike, DatePromptOptions, DefineCommandOptions, Dependencies, EditorExitResult, EmptyArgs, EnquirerLike, FileBasedOptions, FmtMsgOptions, GroupContext, GroupOptions, GroupStep, GroupSteps, InferArgTypes, InputPromptOptions, InquirerPromptOptions, InquirerPromptsLike, Log, Logger, MessageConfig, MessageKind, MsgConfig, MsgType, MultiselectPromptParams, NumberArgDefinition, OmeletteInstanceLike, OrpcProcedureLike, OrpcRouterLike, OutputColor, ParsedProcedure, PositionalArgDefinition, PreventWrongTerminalSizeOptions, ProgressBar, ProgressBarOptions, PromptContext, PromptOptions, PromptType, Promptable, Prompter, PromptsLike, RenderParams, Result, ResultsType, SelectOption, SelectPromptParams, SeparatorOption, StandardColor, StandardSchemaV1, StandardSchemaV1FailureResult, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue, StandardSchemaV1PathSegment, StandardSchemaV1Props, StandardSchemaV1Result, StandardSchemaV1SuccessResult, StandardSchemaV1Types, StreamOptions, StreamTextOptions, StringArgDefinition, SymbolName, Symbols, TogglePromptParams, Trpc10ProcedureLike, Trpc10RouterLike, Trpc11ProcedureLike, Trpc11ProcedureRecordLike, Trpc11RouterLike, TrpcCli, TrpcCliMeta, TrpcCliParams, TrpcCliRunParams, TrpcServerModuleLike, TypographyName, VariantName$1 as VariantName, inferRouterContext };
+export { CANCEL, CliValidationError, FailedToExitError, StandardSchemaV1Error, TrpcCommand, addCompletions, animateText, animationMap, anykeyPrompt, applyVariant, bar, block, breakLines, callCmd, cancel, colorMap, colorize, commandToJSON, completePrompt, confirm, confirmPrompt, countLines, createAsciiArt, createCancel, createCli, createMultiStep, createRpcCli, createShadowCommand, createStep, datePrompt, defineArgs, defineCommand, deleteLastLine, deleteLastLines, endPrompt, errorHandler, fallbackSymbols, figures, flattenedProperties, fmt, getColumns, getDescription, getEnumChoices, getExactTerminalWidth, getSchemaTypes, getTerminalHeight, getTerminalWidth, group, incompatiblePropertyPairs, input, inputPrompt, intro, introPrompt, isCancel, isOrpcRouter, isTerminalInteractive, isTrpc11Procedure, isTrpc11Router, isValidName, isValidVariant, isWindows, lineByLineConsoleLogger, lineByLineLogger, 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, 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 type { AllKinds, AnyProcedure, AnyRouter, ArgDefinition, ArgDefinitions, ArrayArgDefinition, BaseArgDefinition, BaseArgProps, BooleanArgDefinition, BorderColorName, CallCmdOptions, CancelValue, ChoiceOptions, ClackPromptsLike, ColorName, Command, CommandContext, CommandHook, CommandJSON, CommandMeta, CommandRun, CommandSpec, CommanderProgramLike, CommandsMap, ConfirmPromptOptions, CreateCallerFactoryLike, DatePromptOptions, DefineCommandOptions, Dependencies, EditorExitResult, EmptyArgs, EnquirerLike, FileBasedOptions, FmtMsgOptions, GroupContext, GroupOptions, GroupStep, GroupSteps, InferArgTypes, InputPromptOptions, InquirerPromptOptions, InquirerPromptsLike, Log, Logger, MessageConfig, MessageKind, MsgConfig, MsgType, MultiselectPromptParams, NumberArgDefinition, OmeletteInstanceLike, OrpcProcedureLike, OrpcRouterLike, OutputColor, ParsedProcedure, PositionalArgDefinition, PreventWrongTerminalSizeOptions, ProgressBar, ProgressBarOptions, PromptContext, PromptOptions, PromptType, Promptable, Prompter, PromptsLike, RenderParams, Result, ResultsType, SelectOption, SelectPromptParams, SeparatorOption, StandardColor, StandardSchemaV1, StandardSchemaV1FailureResult, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue, StandardSchemaV1PathSegment, StandardSchemaV1Props, StandardSchemaV1Result, StandardSchemaV1SuccessResult, StandardSchemaV1Types, StreamOptions, StreamTextOptions, StringArgDefinition, SymbolName, Symbols, TogglePromptParams, Trpc10ProcedureLike, Trpc10RouterLike, Trpc11ProcedureLike, Trpc11ProcedureRecordLike, Trpc11RouterLike, TrpcCli, TrpcCliMeta, TrpcCliParams, TrpcCliRunParams, TrpcServerModuleLike, TypographyName, VariantName$1 as VariantName, inferRouterContext };

package/dist-npm/bin/mod.mjs

@@ -16,12 +16,11 @@ 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 path from '@reliverse/pathkit';
 import fs from '@reliverse/relifso';
 import { loadConfig } from 'c12';
 import termkit from 'terminal-kit';
 import { homedir } from 'node:os';
-import { createJiti } from 'jiti';
 import { reliArgParser } from '@reliverse/reliarg';
 import { readPackageJSON } from 'pkg-types';
 import { inspect } from 'node:util';
@@ -3112,286 +3111,230 @@ 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 () => {
-  if (process$1.env._REMPTS_CALLER_DIR) {
-    if (process$1.env.NODE_ENV === "development") {
-      relinka("verbose", `Using explicit caller directory: ${process$1.env._REMPTS_CALLER_DIR}`);
-    }
-    return process$1.env._REMPTS_CALLER_DIR;
-  }
-  const stack = new Error().stack?.split("\n") ?? [];
-  const cwd = process$1.cwd();
-  if (process$1.env.NODE_ENV === "development") {
-    relinka("verbose", "Stack trace for getCallerDirectory:");
-    stack.forEach((line, index) => {
-      relinka("verbose", `  [${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("verbose", `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("verbose", `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("verbose", `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("verbose", `Using caller package root (different path): ${packageRoot}`);
-                      }
-                      return packageRoot;
-                    }
-                  }
-                } else {
-                  if (process$1.env.NODE_ENV === "development") {
-                    relinka("verbose", `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("verbose", `Using caller directory (different from CWD): ${fileDir}`);
-            }
-            return packageRoot || fileDir;
-          }
-        } catch {
-          continue;
-        }
-      }
+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);
     }
-  }
-  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("verbose", `Found command package in node_modules: ${packageDir}`);
-              }
-              return packageDir;
-            }
-          }
-        } catch {
-          continue;
-        }
-      }
+  };
+  debugLog("Calling command with input:", input);
+  debugLog("Command meta:", command.meta);
+  try {
+    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);
     }
-  }
-  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("verbose", `Found package.json at: ${currentDir}`);
-        }
-        return currentDir;
+    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);
       }
-    } catch {
+      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);
     }
-    currentDir = dirname(currentDir);
+    throw error;
   }
-  if (process$1.env.NODE_ENV === "development") {
-    relinka("verbose", `No suitable caller found, using cwd: ${cwd}`);
+}
+async function parseArgsFromArgv(command, argv, parserOptions) {
+  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;
+    }
   }
-  return process$1.cwd();
-};
-const tryLoadCommand = async (path) => {
-  if (!await fs.pathExists(path)) return null;
-  try {
-    const cmd = await jiti.import(path, { default: true });
-    return cmd;
-  } catch {
-    relinka("verbose", `Failed to load ${path} as a command file`);
-    return null;
+  const mergedParserOptions = {
+    ...parserOptions,
+    boolean: [...parserOptions.boolean || [], ...booleanKeys],
+    defaults: { ...defaultMap, ...parserOptions.defaults || {} }
+  };
+  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;
   }
-};
-const generateCandidatePaths = async (resolvedPath) => {
-  if (!await fs.pathExists(resolvedPath)) {
-    return COMMAND_EXTENSIONS.map((ext) => `${resolvedPath}${ext}`);
+  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$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}`);
+    }
+    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`
+        );
+      }
+    }
+    finalArgs[key] = def.type === "boolean" ? Boolean(casted) : casted;
   }
-  if (await fs.isDirectory(resolvedPath)) {
-    return COMMAND_FILENAMES.map((filename) => resolve(resolvedPath, filename));
+  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;
+      });
+      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`
+        );
+      }
+    }
+    finalArgs[key] = value;
   }
-  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);
+  return {
+    args: finalArgs,
+    raw: []
+    // No raw argv for object input
+  };
+}
+function castArgValue$1(def, rawVal, argName) {
+  if (rawVal == null) {
+    if (def.type === "array" && typeof def.default === "string") {
+      return [def.default];
     }
+    return def.default ?? void 0;
   }
-  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("verbose", `Loading command: ${cmdPath}`);
-      relinka("verbose", `Caller directory: ${callerDir}`);
-      relinka("verbose", `Normalized path: ${normalizedPath}`);
-      relinka("verbose", `Resolved path: ${resolvedPath}`);
-    }
-    const candidatePaths = await generateCandidatePaths(resolvedPath);
-    if (process$1.env.NODE_ENV === "development") {
-      relinka("verbose", `Candidate paths: ${candidatePaths.join(", ")}`);
-    }
-    for (const path of candidatePaths) {
-      const command = await tryLoadCommand(path);
-      if (command) {
-        if (process$1.env.NODE_ENV === "development") {
-          relinka("verbose", `Successfully loaded command from: ${path}`);
-        }
-        return command;
+  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;
     }
-    let allSearchedPaths = [...candidatePaths];
-    if (callerDir !== process$1.cwd()) {
-      const alternativePaths = await generateAlternativePaths(cmdPath, callerDir);
-      allSearchedPaths.push(...alternativePaths);
-      if (process$1.env.NODE_ENV === "development") {
-        relinka("verbose", `Trying alternative paths: ${alternativePaths.join(", ")}`);
+    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(", ")}`
+        );
       }
-      for (const path of alternativePaths) {
-        const command = await tryLoadCommand(path);
-        if (command) {
-          if (process$1.env.NODE_ENV === "development") {
-            relinka("verbose", `Successfully loaded command from alternative path: ${path}`);
+      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(", ")}`
+            );
           }
-          return command;
         }
+        result.push(...parts);
       }
+      return result;
     }
-    throw createCommandNotFoundError(cmdPath, allSearchedPaths);
-  } 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);
+    default:
+      return rawVal;
   }
 }
 
@@ -6226,110 +6169,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(
@@ -6437,149 +6276,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) {
-    const originalCaller = await getOriginalCallerDirectory();
-    try {
-      const command = await loadCommandWithCaller(cmdName, originalCaller);
-      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 originalCaller = await getOriginalCallerDirectory();
-    const command = await loadCommandWithCaller(cmdName, originalCaller);
-    return {
-      command,
-      run: async (args) => {
-        const stringArgs = args ? argsToStringArray(args) : [];
-        await runCmd(command, stringArgs);
-      }
-    };
-  };
-}
-async function callCmdImpl(cmdName, args) {
-  const originalCaller = await getOriginalCallerDirectory();
-  try {
-    const command = await loadCommandWithCaller(cmdName, originalCaller);
-    const stringArgs = args ? argsToStringArray(args) : [];
-    await runCmd(command, stringArgs);
-  } catch (error) {
-    console.error(`Error running command '${String(cmdName)}':`, error);
-    throw error;
-  }
-}
-async function getOriginalCallerDirectory() {
-  const stack = new Error().stack?.split("\n") ?? [];
-  const cwd = process.cwd();
-  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") && !filePath.includes("command-runner") && !filePath.includes("command-typed") && // Skip this current file
-      !filePath.includes("launcher-mod") && !filePath.includes("launcher-types") && !filePath.endsWith("mod.mjs") && !filePath.endsWith("mod.js") && !filePath.endsWith("mod.ts")) {
-        try {
-          const fileDir = dirname(filePath);
-          let currentDir = fileDir;
-          while (currentDir !== dirname(currentDir)) {
-            try {
-              const packageJsonPath = resolve(currentDir, "package.json");
-              if (await fs.pathExists(packageJsonPath)) {
-                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) {
-                      return currentDir;
-                    }
-                  } catch {
-                    if (resolve(currentDir) !== resolve(cwd)) {
-                      return currentDir;
-                    }
-                  }
-                } else {
-                  return currentDir;
-                }
-                break;
-              }
-            } catch {
-            }
-            currentDir = dirname(currentDir);
-          }
-        } catch {
-          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)) {
-              return packageDir;
-            }
-          }
-        } catch {
-          continue;
-        }
-      }
-    }
-  }
-  return cwd;
-}
-async function loadCommandWithCaller(cmdPath, callerDir) {
-  const originalEnvVar = process.env._REMPTS_CALLER_DIR;
-  process.env._REMPTS_CALLER_DIR = callerDir;
-  try {
-    const command = await loadCommand(cmdPath);
-    return command;
-  } finally {
-    if (originalEnvVar !== void 0) {
-      process.env._REMPTS_CALLER_DIR = originalEnvVar;
-    } else {
-      delete process.env._REMPTS_CALLER_DIR;
-    }
-  }
-}
-async function getTypedCmdImpl(cmdName) {
-  const originalCaller = await getOriginalCallerDirectory();
-  const command = await loadCommandWithCaller(cmdName, originalCaller);
-  return {
-    command,
-    run: async (args) => {
-      const stringArgs = args ? argsToStringArray(args) : [];
-      await runCmd(command, stringArgs);
-    }
-  };
-}
-
 const runMain = createCli;
 
 const log = relinka;
@@ -8522,4 +8218,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, CliValidationError, FailedToExitError, StandardSchemaV1Error, TrpcCommand, addCompletions, animateText, animationMap, anykeyPrompt, applyVariant, bar, block, breakLines, callCmd, cancel, colorMap, colorize, commandToJSON, completePrompt, confirm, confirmPrompt, countLines$1 as countLines, createAsciiArt, createCancel, createCli, 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, group, incompatiblePropertyPairs, input, inputPrompt, intro, introPrompt, isCancel, isOrpcRouter, isTerminalInteractive, isTrpc11Procedure, isTrpc11Router, isValidName, isValidVariant, isWindows, lineByLineConsoleLogger, lineByLineLogger, 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, runMain, select, selectPrompt, selectSimple, setRawMode, showUsage, spinner, startEditor, startPrompt, streamText, streamTextBox, streamTextWithSpinner, symbols, taskProgressPrompt, taskSpinPrompt, text, throwError, toBaseColor, toDotPath, toSolidColor, togglePrompt, typographyMap, useSpinner, variantMap };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@reliverse/rempts",
   "author": "reliverse",
-  "version": "1.7.48",
+  "version": "1.7.50",
   "type": "module",
   "license": "MIT",
   "main": "./dist-npm/bin/mod.mjs",
@@ -36,8 +36,8 @@
   ],
   "description": "@reliverse/rempts is a modern, type-safe toolkit for building delightful cli experiences. it's fast, flexible, and made for developer happiness. file-based commands keep things simple.",
   "scripts": {
+    "dev": "bun example/cli.ts",
     "pub": "bun unbuild && bun publish",
-    "dev": "node -e 'console.log(`👉 bun dev:[prompts,modern,classic]`)'",
     "dev:prompts": "bun example/prompts/mod.ts",
     "dev:modern": "bun example/launcher/modern.ts",
     "dev:classic": "bun example/launcher/classic.ts",
@@ -51,12 +51,12 @@
     "@clack/prompts": "^0.11.0",
     "@figliolia/chalk-animation": "^1.0.4",
     "@inquirer/prompts": "^7.8.3",
-    "@orpc/server": "^1.8.3",
+    "@orpc/server": "^1.8.4",
     "@reliverse/pathkit": "^1.3.4",
     "@reliverse/reliarg": "^1.0.3",
     "@reliverse/relico": "^1.3.5",
     "@reliverse/relifso": "^1.4.5",
-    "@reliverse/relinka": "^1.5.5",
+    "@reliverse/relinka": "^1.5.6",
     "@reliverse/runtime": "^1.0.3",
     "@trpc/server": "^11.5.0",
     "ansi-escapes": "^7.0.0",
@@ -85,13 +85,13 @@
     "unicorn-magic": "^0.3.0",
     "valibot": "^1.1.0",
     "wrap-ansi": "^9.0.0",
-    "zod": "^4.0.17",
+    "zod": "^4.1.0",
     "zod-to-json-schema": "^3.24.6"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.0",
-    "@orpc/contract": "^1.8.3",
-    "@reliverse/dler": "1.7.96",
+    "@biomejs/biome": "^2.2.2",
+    "@orpc/contract": "^1.8.4",
+    "@reliverse/dler": "1.7.101",
     "@reliverse/rse": "^1.7.12",
     "@total-typescript/ts-reset": "^0.6.1",
     "@types/bun": "^1.2.20",