padrone 1.4.0 → 1.6.0

package/dist/types-DjIdJN5G.d.mts

@@ -1,1059 +0,0 @@
-import { n as HelpFormat, t as HelpDetail } from "./formatter-ClUK5hcQ.mjs";
-import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
-import { Tool } from "ai";
-
-//#region src/args.d.ts
-type Letter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
-/** A single letter character, valid as a short CLI flag (e.g. `'v'`, `'n'`, `'V'`). */
-type SingleChar = Letter | Uppercase<Letter>;
-interface PadroneFieldMeta {
-  description?: string;
-  /** Single-character short flags (stackable: `-abc` = `-a -b -c`). Used with single dash. */
-  flags?: SingleChar[] | SingleChar;
-  /** Multi-character alternative long names. Used with double dash (e.g. `--dry-run` for `--dryRun`). */
-  alias?: string[] | string;
-  deprecated?: boolean | string;
-  hidden?: boolean;
-  examples?: unknown[];
-}
-type PositionalArgs<TObj> = TObj extends Record<string, any> ? { [K in keyof TObj]: NonNullable<TObj[K]> extends Array<any> ? `...${K & string}` | (K & string) : K & string }[keyof TObj] : string;
-/**
- * Meta configuration for arguments, including positional arguments.
- * The `positional` array defines which arguments are positional and their order.
- * Use '...name' prefix to indicate variadic (rest) arguments, matching JS/TS rest syntax.
- *
- * @example
- * ```ts
- * .arguments(schema, {
- *   positional: ['source', '...files', 'dest'],  // '...files' is variadic
- * })
- * ```
- */
-/**
- * Configuration for reading from stdin and mapping it to an argument field.
- */
-type StdinConfig<TObj = Record<string, any>> = (keyof TObj & string) | {
-  /** The argument field to populate with stdin data. */field: keyof TObj & string;
-  /**
-   * How to consume stdin:
-   * - `'text'` (default): read all stdin as a single string.
-   * - `'lines'`: read stdin as an array of lines (string[]).
-   */
-  as?: 'text' | 'lines';
-};
-interface PadroneArgsSchemaMeta<TObj = Record<string, any>> {
-  /**
-   * Array of argument names that should be treated as positional arguments.
-   * Order in array determines position. Use '...name' prefix for variadic args.
-   * @example ['source', '...files', 'dest'] - 'files' captures multiple values
-   */
-  positional?: PositionalArgs<TObj>[];
-  /**
-   * Per-argument metadata.
-   */
-  fields?: { [K in keyof TObj]?: PadroneFieldMeta };
-  /**
-   * Automatically generate kebab-case aliases for camelCase option names.
-   * For example, `dryRun` automatically gets `--dry-run` as an alias.
-   * Defaults to `true`. Set to `false` to disable.
-   *
-   * @default true
-   * @example
-   * ```ts
-   * // Auto-aliases enabled (default): --dry-run → dryRun
-   * .arguments(z.object({ dryRun: z.boolean() }))
-   *
-   * // Disable auto-aliases
-   * .arguments(z.object({ dryRun: z.boolean() }), { autoAlias: false })
-   * ```
-   */
-  autoAlias?: boolean;
-  /**
-   * Read from stdin and inject the data into the specified argument field.
-   * Only reads when stdin is piped (not a TTY) and the field wasn't already provided via CLI flags.
-   *
-   * - `string`: shorthand for `{ field: name, as: 'text' }` — read all stdin as a string.
-   * - `{ field, as }`: explicit form. `as: 'text'` reads all stdin as a string,
-   *   `as: 'lines'` reads stdin as an array of line strings.
-   *
-   * Precedence: CLI flags > stdin > env vars > config file > schema defaults.
-   *
-   * @example
-   * ```ts
-   * // Shorthand: read all stdin as text into 'data' field
-   * .arguments(z.object({ data: z.string() }), { stdin: 'data' })
-   *
-   * // Explicit: read stdin lines into 'lines' field
-   * .arguments(z.object({ lines: z.string().array() }), {
-   *   stdin: { field: 'lines', as: 'lines' },
-   * })
-   * ```
-   */
-  stdin?: StdinConfig<TObj>;
-  /**
-   * Fields to interactively prompt for when their values are missing after CLI/env/config resolution.
-   * - `true`: prompt for all required fields that are missing.
-   * - `string[]`: prompt for these specific fields if missing.
-   *
-   * Interactive prompting only occurs in `cli()` when the runtime has `interactive: true`.
-   * Setting this makes `parse()` and `cli()` return Promises.
-   *
-   * @example
-   * ```ts
-   * .arguments(schema, {
-   *   interactive: true,                        // prompt all missing required fields
-   *   interactive: ['name', 'template'],         // prompt only these fields
-   * })
-   * ```
-   */
-  interactive?: true | (keyof TObj & string)[];
-  /**
-   * Optional fields offered after required interactive prompts.
-   * Users are shown a multi-select to choose which of these fields to configure.
-   * - `true`: offer all optional fields that are missing.
-   * - `string[]`: offer these specific fields.
-   *
-   * @example
-   * ```ts
-   * .arguments(schema, {
-   *   interactive: ['name'],
-   *   optionalInteractive: ['typescript', 'eslint', 'prettier'],
-   * })
-   * ```
-   */
-  optionalInteractive?: true | (keyof TObj & string)[];
-}
-//#endregion
-//#region src/help.d.ts
-type HelpPreferences = {
-  format?: HelpFormat | 'auto';
-  detail?: HelpDetail;
-};
-//#endregion
-//#region src/runtime.d.ts
-/**
- * Controls interactive prompting capability and default behavior at the runtime level.
- * - `'supported'` — capable; caller decides.
- * - `'unsupported'` — hard veto; nothing can override.
- * - `'forced'` — capable and forces prompts by default.
- * - `'disabled'` — capable but suppresses prompts by default.
- */
-type InteractiveMode = 'supported' | 'unsupported' | 'forced' | 'disabled';
-/**
- * Configuration passed to the runtime's `prompt` function for interactive field prompting.
- * The prompt type and choices are auto-detected from the field's JSON schema.
- */
-type InteractivePromptConfig = {
-  /** The field name being prompted. */name: string; /** Human-readable message/label for the prompt, derived from the field's description or name. */
-  message: string; /** The prompt type, auto-detected from the JSON schema. */
-  type: 'input' | 'confirm' | 'select' | 'multiselect' | 'password'; /** Available choices for select/multiselect prompts. */
-  choices?: {
-    label: string;
-    value: unknown;
-  }[]; /** Default value from the schema. */
-  default?: unknown;
-};
-/**
- * Defines the execution context for a Padrone program.
- * Abstracts all environment-dependent I/O so the CLI framework
- * can run outside of a terminal (e.g., web UIs, chat interfaces, testing).
- *
- * All fields are optional — unspecified fields fall back to the Node.js/Bun defaults.
- */
-type PadroneRuntime = {
-  /** Write normal output (replaces console.log). Receives the raw value — runtime handles formatting. */output?: (...args: unknown[]) => void; /** Write error output (replaces console.error). */
-  error?: (text: string) => void; /** Return the raw CLI arguments (replaces process.argv.slice(2)). */
-  argv?: () => string[]; /** Return environment variables (replaces process.env). */
-  env?: () => Record<string, string | undefined>; /** Default help output format. */
-  format?: HelpFormat | 'auto'; /** Load and parse a config file by path. Return undefined if not found or unparsable. */
-  loadConfigFile?: (path: string) => Record<string, unknown> | undefined; /** Find the first existing file from a list of candidate names. */
-  findFile?: (names: string[]) => string | undefined;
-  /**
-   * Standard input abstraction. Provides methods to read piped data from stdin.
-   * When not provided, defaults to reading from `process.stdin`.
-   *
-   * Used by commands that declare a `stdin` field in their arguments meta.
-   * The framework reads stdin automatically during the validate phase and
-   * injects the data into the specified argument field.
-   */
-  stdin?: {
-    /** Whether stdin is a TTY (interactive terminal) vs a pipe/file. */isTTY?: boolean; /** Read all of stdin as a string. */
-    text: () => Promise<string>; /** Async iterable of lines for streaming. */
-    lines: () => AsyncIterable<string>;
-  };
-  /**
-   * Controls interactive prompting capability and default behavior.
-   * - `'supported'` — runtime can handle prompts; caller (flag/pref) decides whether to prompt. This is the default when `prompt` is provided.
-   * - `'unsupported'` — runtime cannot handle prompts; hard veto that nothing can override.
-   * - `'forced'` — runtime supports prompts and forces them by default (prompts even for provided values).
-   * - `'disabled'` — runtime supports prompts but suppresses them by default.
-   *
-   * `'unsupported'` is the only immutable state. For the others, the `--interactive`/`-i` flag
-   * and `cli()` preferences can override the default behavior.
-   */
-  interactive?: InteractiveMode;
-  /**
-   * Prompt the user for input. Called during `cli()` for fields marked as interactive.
-   * When `interactive` is `true` and this is not provided, defaults to an Enquirer-based terminal prompt.
-   */
-  prompt?: (config: InteractivePromptConfig) => Promise<unknown>;
-  /**
-   * Read a line of input from the user. Used by `repl()` for custom runtimes
-   * (web UIs, chat interfaces, testing).
-   * Returns the input string, `null` on EOF (e.g. Ctrl+D, closed connection),
-   * or `REPL_SIGINT` when the user presses Ctrl+C.
-   *
-   * When not provided, `repl()` uses a built-in Node.js readline session
-   * with command history (up/down arrows) and tab completion.
-   */
-  readLine?: (prompt: string) => Promise<string | typeof REPL_SIGINT | null>;
-};
-/**
- * Internal resolved runtime where all fields are guaranteed to be present.
- * The `prompt`, `interactive`, and `readLine` fields remain optional since not all runtimes provide them.
- */
-type ResolvedPadroneRuntime = Required<Omit<PadroneRuntime, 'prompt' | 'interactive' | 'readLine' | 'stdin'>> & Pick<PadroneRuntime, 'prompt' | 'interactive' | 'readLine' | 'stdin'>;
-/**
- * Creates a persistent Node.js readline session for the REPL.
- * Enables up/down arrow history navigation and tab completion.
- * Used internally by `repl()` when no custom `readLine` is provided.
- */
-/**
- * Sentinel value returned by the terminal REPL session when Ctrl+C is pressed.
- * Distinguished from empty string (user pressed enter) and null (EOF/Ctrl+D).
- */
-declare const REPL_SIGINT: unique symbol;
-//#endregion
-//#region src/type-utils.d.ts
-type SafeString = string & {};
-type IsUnknown<T> = unknown extends T ? true : false;
-type IsAny<T> = any extends T ? true : false;
-type IsNever<T> = [T] extends [never] ? true : false;
-type IsGeneric<T> = IsAny<T> extends true ? true : IsUnknown<T> extends true ? true : IsNever<T> extends true ? true : false;
-/**
- * Detects whether a schema has been branded as async via the `'~async'` property.
- * Standard Schema V1's `validate()` always types its return as `Result | Promise<Result>`
- * regardless of whether the schema is actually async, so we rely on an explicit brand instead.
- *
- * Use `asyncSchema(schema)` to brand a schema, or check for the `{ '~async': true }` property.
- */
-type IsAsyncSchema<T> = IsAny<T> extends true ? false : T extends {
-  '~async': true;
-} ? true : false;
-/**
- * Computes the new TAsync flag when a schema is added to a builder.
- * Once TAsync is `true`, it stays `true`. Otherwise, checks if the new schema is branded async.
- */
-type OrAsync<TExisting extends boolean, TSchema> = TExisting extends true ? true : IsAsyncSchema<TSchema> extends true ? true : false;
-/**
- * Detects whether argument meta contains interactive or optionalInteractive configuration.
- * When either is `true` or a `string[]`, the command requires async execution for prompting.
- */
-type HasInteractive<TMeta> = TMeta extends {
-  interactive: true | string[];
-} ? true : TMeta extends {
-  optionalInteractive: true | string[];
-} ? true : false;
-/**
- * Combines schema-level async detection with meta-level interactive detection.
- * Returns `true` if the existing async flag is set, the schema is branded async, or the meta has interactive fields.
- */
-type OrAsyncMeta<TExisting extends boolean, TMeta> = TExisting extends true ? true : HasInteractive<TMeta> extends true ? true : false;
-/**
- * Conditionally wraps a type in Promise based on the TAsync flag.
- * - `true` → `Promise<T>`
- * - `false` → `T & PromiseLike<T>` (thenable: supports `.then()` and `await`)
- * - `boolean` (union of true|false) → `Promise<T>` (safe default when async-ness is uncertain)
- * - `any` → `T` (for generic/any typed commands like AnyPadroneCommand)
- */
-type MaybePromise<T, TAsync> = IsAny<TAsync> extends true ? T : true extends TAsync ? Promise<T> : T & PromiseLike<T>;
-type SplitString<TName extends string, TSplitBy extends string = ' '> = TName extends `${infer FirstPart}${TSplitBy}${infer RestParts}` ? [FirstPart, ...SplitString<RestParts, TSplitBy>] : [TName];
-type JoinString<TParts extends string[], TJoinBy extends string = ' '> = TParts extends [infer FirstPart extends string, ...infer RestParts extends string[]] ? RestParts extends [] ? FirstPart : `${FirstPart}${TJoinBy}${JoinString<RestParts, TJoinBy>}` : TParts extends [] ? '' : TParts[number];
-type SplitLastSpace<S extends string> = SplitString<S> extends [...infer Init extends string[], infer Last extends string] ? Init extends [] ? [S, never] : [JoinString<Init>, Last] : [S, never];
-type AnyPartExtends<U, T> = [U] extends [never] ? false : U extends any ? (U extends T ? true : never) : never extends true ? true : false;
-type FullCommandName<TName extends string, TParentName extends string = ''> = TParentName extends '' ? TName : `${TParentName} ${TName}`;
-/**
- * Generate full alias paths by combining parent path with each alias.
- */
-type FullAliasPaths<TAliases extends string[], TParentName extends string = ''> = TAliases extends [infer First extends string, ...infer Rest extends string[]] ? FullCommandName<First, TParentName> | FullAliasPaths<Rest, TParentName> : never;
-/**
- * Get all paths for a command including its primary path and all alias paths.
- */
-type GetCommandPathsAndAliases<TCommand extends AnyPadroneCommand> = TCommand['~types']['path'] extends infer Path extends string ? TCommand['~types']['aliases'] extends infer Aliases extends string[] ? TCommand['~types']['parentName'] extends infer ParentName extends string ? Path | FullAliasPaths<Aliases, ParentName> : Path : Path : never;
-/**
- * Find a direct child command in a tuple by name.
- * Unlike PickCommandByName, this does NOT flatten — it only checks direct children by their `name` field.
- */
-type FindDirectChild<TCommands extends AnyPadroneCommand[], TName extends string> = TCommands extends [infer First extends AnyPadroneCommand, ...infer Rest extends AnyPadroneCommand[]] ? First['~types']['name'] extends TName ? First : FindDirectChild<Rest, TName> : never;
-/**
- * Replace a command in a tuple by name, or append if not found.
- * Used by `.command()` override semantics: re-registering a name replaces that entry.
- */
-type ReplaceOrAppendCommand<TCommands extends [...AnyPadroneCommand[]], TName extends string, TNew extends AnyPadroneCommand> = HasDirectChild<TCommands, TName> extends true ? ReplaceInTuple<TCommands, TName, TNew> : [...TCommands, TNew];
-type HasDirectChild<TCommands extends AnyPadroneCommand[], TName extends string> = TCommands extends [infer First extends AnyPadroneCommand, ...infer Rest extends AnyPadroneCommand[]] ? First['~types']['name'] extends TName ? true : HasDirectChild<Rest, TName> : false;
-type ReplaceInTuple<TCommands extends AnyPadroneCommand[], TName extends string, TNew extends AnyPadroneCommand> = TCommands extends [infer First extends AnyPadroneCommand, ...infer Rest extends AnyPadroneCommand[]] ? First['~types']['name'] extends TName ? [TNew, ...Rest] : [First, ...ReplaceInTuple<Rest, TName, TNew>] : [];
-type PickCommandByName<TCommands extends AnyPadroneCommand[], TName extends string | AnyPadroneCommand> = TName extends AnyPadroneCommand ? TName : FlattenCommands<TCommands> extends infer Cmd extends AnyPadroneCommand ? Cmd extends AnyPadroneCommand ? TName extends GetCommandPathsAndAliases<Cmd> ? Cmd : never : never : never;
-type FlattenCommands<TCommands extends AnyPadroneCommand[]> = TCommands extends [] ? never : TCommands extends [infer FirstCommand, ...infer RestCommands] ? (RestCommands extends AnyPadroneCommand[] ? FlattenCommands<RestCommands> : never) | (FirstCommand extends AnyPadroneCommand ? FlattenCommands<FirstCommand['~types']['commands']> | FirstCommand : never) : IsAny<TCommands[number]> extends true ? never : TCommands[number];
-/**
- * Get all command paths including alias paths for all commands.
- */
-type GetCommandPathsOrAliases<TCommands extends AnyPadroneCommand[]> = GetCommandPathsAndAliases<FlattenCommands<TCommands>>;
-/**
- * Find all the commands that are prefixed with a command name or alias.
- * This is needed to avoid matching other commands when followed by a space and another word.
- * For example, let's say `level1` and `level1 level2` are commands.
- * Then `level1 ${string}` would also match `level1 level2`,
- * and it would cause `level1 level2` to not show up in the autocomplete.
- * By excluding those cases, we can ensure autocomplete works correctly.
- */
-type PrefixedCommands<TCommands extends AnyPadroneCommand[]> = GetCommandPathsOrAliases<TCommands> extends infer CommandNames ? CommandNames extends string ? AnyPartExtends<GetCommandPathsOrAliases<TCommands>, `${CommandNames} ${string}`> extends true ? never : `${CommandNames} ${string}` : never : never;
-/**
- * The possible commands are the commands that can be parsed by the program.
- * This includes the string that are exact matches to a command name or alias, and strings that are prefixed with a command name or alias.
- */
-type PossibleCommands<TCommands extends AnyPadroneCommand[], TWithPrefixed extends boolean = false, TWithObjects extends boolean = false, TWithFallback extends boolean = true> = GetCommandPathsOrAliases<TCommands> | (TWithPrefixed extends true ? PrefixedCommands<TCommands> : never) | (TWithObjects extends true ? FlattenCommands<TCommands> : never) | (TWithFallback extends true ? SafeString : never);
-type CommandIsUnknownable<TCommand> = IsGeneric<TCommand> extends true ? true : string extends TCommand ? true : SafeString extends TCommand ? true : false;
-/**
- * Match a string to a command by the possible commands.
- * This is done by recursively splitting the string by the last space, and then checking if the prefix is a valid command name or alias.
- * This is needed to avoid matching the top-level command when there are nested commands.
- */
-/**
- * Recursively re-paths a command's children under a new parent path.
- * Used by `mount()` to update all nested command paths when a program is mounted as a subcommand.
- */
-type RepathCommands<TCommands extends [...AnyPadroneCommand[]], TNewParentPath extends string> = TCommands extends [infer First extends AnyPadroneCommand, ...infer Rest extends AnyPadroneCommand[]] ? [RepathCommand<First, TNewParentPath>, ...RepathCommands<Rest, TNewParentPath>] : [];
-type RepathCommand<TCommand extends AnyPadroneCommand, TNewParentName extends string> = PadroneCommand<TCommand['~types']['name'], TNewParentName, TCommand['~types']['argsSchema'], TCommand['~types']['result'], RepathCommands<TCommand['~types']['commands'], FullCommandName<TCommand['~types']['name'], TNewParentName>>, TCommand['~types']['aliases'], TCommand['~types']['configSchema'], TCommand['~types']['envSchema'], TCommand['~types']['async']>;
-type PickCommandByPossibleCommands<TCommands extends AnyPadroneCommand[], TCommand extends PossibleCommands<TCommands, true, true> | SafeString> = CommandIsUnknownable<TCommand> extends true ? FlattenCommands<TCommands> : TCommand extends AnyPadroneCommand ? TCommand : TCommand extends string ? TCommand extends GetCommandPathsOrAliases<TCommands> ? PickCommandByName<TCommands, TCommand> : SplitLastSpace<TCommand> extends [infer Prefix extends string, infer Rest] ? IsNever<Rest> extends true ? PickCommandByName<TCommands, Prefix> : PickCommandByPossibleCommands<TCommands, Prefix> : never : never;
-//#endregion
-//#region src/update-check.d.ts
-/**
- * Configuration for the update check feature.
- */
-type UpdateCheckConfig = {
-  /**
-   * The npm package name to check. Defaults to the program name.
-   */
-  packageName?: string;
-  /**
-   * Registry to check for updates.
-   * - `'npm'` — checks the npm registry (default)
-   * - A URL string — custom registry endpoint that returns JSON with a `version` or `dist-tags.latest` field
-   */
-  registry?: 'npm' | string;
-  /**
-   * How often to check for updates. Accepts shorthand like `'1d'`, `'12h'`, `'30m'`.
-   * Defaults to `'1d'` (once per day).
-   */
-  interval?: string;
-  /**
-   * Path to the cache file for storing the last check timestamp and latest version.
-   * Defaults to `~/.config/<programName>-update-check.json`.
-   */
-  cache?: string;
-  /**
-   * Environment variable name to disable update checks (e.g. `'MYAPP_NO_UPDATE_CHECK'`).
-   * When set to a truthy value, update checks are skipped.
-   * Defaults to `'<PROGRAM_NAME>_NO_UPDATE_CHECK'` (uppercased, hyphens to underscores).
-   */
-  disableEnvVar?: string;
-};
-//#endregion
-//#region src/wrap.d.ts
-/**
- * Configuration for wrapping an external CLI tool.
- */
-type WrapConfig<TCommandArgs extends PadroneSchema = PadroneSchema, TWrapArgs extends PadroneSchema = TCommandArgs> = {
-  /**
-   * The command to execute (e.g., 'git', 'docker', 'npm').
-   */
-  command: string;
-  /**
-   * Optional fixed arguments that always precede the arguments (e.g., ['commit'] for 'git commit').
-   */
-  args?: string[];
-  /**
-   * Positional argument configuration for the external command.
-   * If not provided, defaults to the wrapping command's positional configuration.
-   */
-  positional?: string[];
-  /**
-   * Whether to inherit stdio streams (stdin, stdout, stderr) from the parent process.
-   * Default: true
-   */
-  inheritStdio?: boolean;
-  /**
-   * Optional schema that transforms command arguments to external CLI arguments.
-   * The schema's input type should match the command arguments, and its output type defines
-   * the arguments expected by the external command.
-   * If not provided, command arguments are passed through as-is.
-   */
-  schema?: TWrapArgs | ((commandArguments: TCommandArgs) => TWrapArgs);
-};
-/**
- * Result from executing a wrapped CLI tool.
- */
-type WrapResult = {
-  /**
-   * The exit code of the process.
-   */
-  exitCode: number;
-  /**
-   * Standard output from the process (only if inheritStdio is false).
-   */
-  stdout?: string;
-  /**
-   * Standard error from the process (only if inheritStdio is false).
-   */
-  stderr?: string;
-  /**
-   * Whether the process exited successfully (exit code 0).
-   */
-  success: boolean;
-};
-//#endregion
-//#region src/types.d.ts
-type UnknownRecord = Record<string, unknown>;
-type EmptyRecord = Record<string, never>;
-type DefaultArgs = UnknownRecord | void;
-/**
- * Context object passed as the second argument to command action handlers.
- * Contains the resolved runtime, the executing command, and the program instance.
- */
-type PadroneActionContext = {
-  /** The resolved runtime for this command (I/O, env, config, etc.). */runtime: ResolvedPadroneRuntime; /** The command being executed. */
-  command: AnyPadroneCommand; /** The root program instance. */
-  program: AnyPadroneProgram;
-};
-/**
- * A schema that supports both validation (StandardSchemaV1) and JSON schema generation (StandardJSONSchemaV1).
- * This is the type required for command arguments in Padrone.
- */
-type PadroneSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
-/**
- * A schema branded as async. When passed to `.arguments()`, `.configFile()`, or `.env()`,
- * the command is automatically marked as async, causing `parse()` and `cli()` to return Promises.
- *
- * Use the `asyncSchema()` helper to brand an existing schema:
- * ```ts
- * import { asyncSchema } from 'padrone';
- * const schema = asyncSchema(z.object({ name: z.string() }).check(async (v) => { ... }));
- * ```
- */
-type AsyncPadroneSchema<Input = unknown, Output = Input> = PadroneSchema<Input, Output> & {
-  '~async': true;
-};
-/**
- * Helper type to set aliases on a command type.
- * Uses intersection to override just the aliases while preserving all other type information.
- */
-type WithAliases<TCommand extends AnyPadroneCommand, TAliases extends string[]> = Omit<TCommand, 'aliases' | '~types'> & {
-  aliases?: TAliases;
-  '~types': Omit<TCommand['~types'], 'aliases'> & {
-    aliases: TAliases;
-  };
-};
-/**
- * Resolves aliases for a command override: if new aliases are provided (non-empty), use them;
- * otherwise, preserve the existing command's aliases.
- */
-type ResolvedAliases<TCommands extends [...AnyPadroneCommand[]], TNameNested extends string, TAliases extends string[]> = TAliases extends [] ? FindDirectChild<TCommands, TNameNested> extends infer E extends AnyPadroneCommand ? E['~types']['aliases'] : [] : TAliases;
-/**
- * Resolves the initial builder type for a `.command()` call.
- * If TNameNested already exists in TCommands, the builder starts pre-populated with that command's types.
- * Otherwise, a fresh builder with default types is used.
- */
-type InitialCommandBuilder<TProgramName extends string, TNameNested extends string, TParentPath extends string, TParentArgs extends PadroneSchema, TCommands extends [...AnyPadroneCommand[]]> = [FindDirectChild<TCommands, TNameNested>] extends [never] ? PadroneBuilder<TProgramName, TNameNested, TParentPath, PadroneSchema<void>, void, [], TParentArgs, PadroneSchema<void>, PadroneSchema<void>, false> : FindDirectChild<TCommands, TNameNested> extends infer E extends AnyPadroneCommand ? PadroneBuilder<TProgramName, TNameNested, TParentPath, E['~types']['argsSchema'], E['~types']['result'], E['~types']['commands'], TParentArgs, E['~types']['configSchema'], E['~types']['envSchema'], E['~types']['async']> : PadroneBuilder<TProgramName, TNameNested, TParentPath, PadroneSchema<void>, void, [], TParentArgs, PadroneSchema<void>, PadroneSchema<void>, false>;
-type AnyPadroneBuilder = InitialCommandBuilder<string, string, string, any, [...AnyPadroneCommand[]]>;
-/**
- * Like InitialCommandBuilder but uses `any` for args/config/env in the fresh case.
- * Used as the default for TBuilder when no builderFn is provided.
- */
-type DefaultCommandBuilder<TProgramName extends string, TNameNested extends string, TParentPath extends string, TParentArgs extends PadroneSchema, TCommands extends [...AnyPadroneCommand[]]> = [FindDirectChild<TCommands, TNameNested>] extends [never] ? PadroneBuilder<TProgramName, TNameNested, TParentPath, any, void, [], TParentArgs, any, any, false> : FindDirectChild<TCommands, TNameNested> extends infer E extends AnyPadroneCommand ? PadroneBuilder<TProgramName, TNameNested, TParentPath, E['~types']['argsSchema'], E['~types']['result'], E['~types']['commands'], TParentArgs, E['~types']['configSchema'], E['~types']['envSchema'], E['~types']['async']> : PadroneBuilder<TProgramName, TNameNested, TParentPath, any, void, [], TParentArgs, any, any, false>;
-type PadroneCommand<TName extends string = string, TParentName extends string = '', TArgs extends PadroneSchema = PadroneSchema<DefaultArgs>, TRes = void, TCommands extends [...AnyPadroneCommand[]] = [], TAliases extends string[] = string[], TConfig extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = PadroneSchema<void>, TEnv extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = PadroneSchema<void>, TAsync extends boolean = false> = {
-  name: TName;
-  path: FullCommandName<TName, TParentName>;
-  title?: string;
-  description?: string;
-  version?: string; /** Alternative names that can be used to invoke this command. Derived from the names passed to command(). */
-  aliases?: TAliases;
-  deprecated?: boolean | string;
-  hidden?: boolean;
-  needsApproval?: boolean | ((args: TArgs) => Promise<boolean> | boolean);
-  autoOutput?: boolean;
-  argsSchema?: TArgs;
-  configSchema?: TConfig;
-  envSchema?: TEnv;
-  meta?: GetArgsMeta<TArgs>;
-  action?: (args: StandardSchemaV1.InferOutput<TArgs>, ctx: PadroneActionContext) => TRes; /** List of possible config file names to search for. */
-  configFiles?: string[]; /** Runtime flag indicating this command uses async validation. Set by `.async()` or `asyncSchema()`. */
-  isAsync?: boolean; /** Runtime configuration for I/O abstraction. */
-  runtime?: PadroneRuntime; /** Plugins registered on this command. Collected from the parent chain at execution time. */
-  plugins?: PadronePlugin[]; /** Update check configuration. Only used on the root program. */
-  updateCheck?: UpdateCheckConfig;
-  parent?: AnyPadroneCommand;
-  commands?: TCommands; /** @deprecated Internal use only */
-  '~types': {
-    name: TName;
-    parentName: TParentName;
-    path: FullCommandName<TName, TParentName>;
-    aliases: TAliases;
-    argsSchema: TArgs;
-    argsInput: StandardSchemaV1.InferInput<TArgs>;
-    argsOutput: StandardSchemaV1.InferOutput<TArgs>;
-    result: TRes;
-    commands: TCommands;
-    configSchema: TConfig;
-    envSchema: TEnv;
-    async: TAsync;
-  };
-};
-type AnyPadroneCommand = PadroneCommand<string, any, any, any, [...AnyPadroneCommand[]], string[], any, any, any>;
-/**
- * Base type for extracting command information from builder or program.
- * Both PadroneBuilder and PadroneProgram share this structure.
- */
-type CommandTypesBase = {
-  '~types': {
-    command: AnyPadroneCommand;
-  };
-};
-/**
- * Configuration for a command.
- */
-type PadroneCommandConfig = {
-  /** A short title for the command, displayed in help. */title?: string; /** A longer description of what the command does. */
-  description?: string; /** The version of the command. */
-  version?: string; /** Whether the command is deprecated, or a message explaining the deprecation. */
-  deprecated?: boolean | string; /** Whether the command should be hidden from help output. */
-  hidden?: boolean;
-  /**
-   * Automatically write this command's return value to output in CLI/eval/REPL mode.
-   * Overrides the `autoOutput` setting in eval/cli preferences for this command.
-   * See `PadroneEvalPreferences.autoOutput` for serialization details.
-   */
-  autoOutput?: boolean;
-};
-/**
- * Conditional type that returns either PadroneBuilder or PadroneProgram based on TReturn.
- * Used to avoid repetition in PadroneBuilderMethods return types.
- */
-type BuilderOrProgram<TReturn extends 'builder' | 'program', TProgramName extends string, TName extends string, TParentName extends string, TArgs extends PadroneSchema, TRes, TCommands extends [...AnyPadroneCommand[]], TParentArgs extends PadroneSchema, TConfig extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>>, TEnv extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>>, TAsync extends boolean> = TReturn extends 'builder' ? PadroneBuilder<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync> : PadroneProgram<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
-/**
- * Base builder methods shared between PadroneBuilder and PadroneProgram.
- * These methods are used for defining command structure (arguments, config, env, action, subcommands).
- */
-type PadroneBuilderMethods<TProgramName extends string, TName extends string, TParentName extends string, TArgs extends PadroneSchema, TRes, TCommands extends [...AnyPadroneCommand[]], TParentArgs extends PadroneSchema, TConfig extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>>, TEnv extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>>, TAsync extends boolean, /** The return type for builder methods - either PadroneBuilder or PadroneProgram */TReturn extends 'builder' | 'program'> = {
-  /**
-   * Enables automatic update checking against a package registry.
-   * When enabled, the program checks for a newer version in the background
-   * and displays a notification after command output if an update is available.
-   *
-   * - Non-blocking: check runs in background, never delays command execution.
-   * - Non-intrusive: shows a one-line notice after command output, not before.
-   * - Respects CI: disabled when `CI=true` or non-TTY.
-   * - Respects user preference: `--no-update-check` flag or env var.
-   * - Caches last check timestamp to avoid hitting the registry on every invocation.
-   *
-   * @example
-   * ```ts
-   * createPadrone('myapp')
-   *   .version('1.2.3')
-   *   .updateCheck({
-   *     registry: 'npm',         // or custom URL
-   *     interval: '1d',          // check at most once per day
-   *     cache: '~/.myapp-update' // where to store last check
-   *   })
-   * ```
-   */
-  updateCheck: (config?: UpdateCheckConfig) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
-  /**
-   * Registers a plugin that intercepts command execution phases (parse, validate, execute).
-   * Plugins are applied in order: first registered = outermost wrapper (runs first before `next()`).
-   * Use `plugin.order` for explicit ordering (lower = outermost).
-   *
-   * On the program, parse/validate/execute plugins all apply.
-   * On subcommands, only validate and execute plugins apply (parse is handled by the root program).
-   */
-  use: (plugin: PadronePlugin) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
-  configure: (config: PadroneCommandConfig) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
-  /**
-   * Configures the runtime adapter for I/O abstraction.
-   * Allows the CLI framework to work outside of a terminal (e.g., web UIs, chat interfaces, testing).
-   * Unspecified fields fall back to the Node.js/Bun defaults.
-   *
-   * @example
-   * ```ts
-   * .runtime({
-   *   output: (text) => panel.append(text),
-   *   error: (text) => panel.appendError(text),
-   *   format: 'html',
-   * })
-   * ```
-   */
-  runtime: (runtime: PadroneRuntime) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
-  /**
-   * Explicitly marks this command as using async validation.
-   * When a command is async, `parse()` and `cli()` return Promises.
-   *
-   * This is an alternative to using `asyncSchema()` on individual schemas.
-   * Use this when your schema has async refinements but you don't want to
-   * (or can't) brand the schema itself.
-   *
-   * @example
-   * ```ts
-   * .arguments(z.object({ name: z.string() }).check(async (v) => { ... }))
-   * .async()
-   * .action((args) => { ... })
-   * ```
-   */
-  async: () => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, true>;
-  /**
-   * Defines the arguments schema for the command, including positional arguments.
-   * Can accept either a schema directly or a function that takes parent args schema as a base and returns a schema.
-   * Use the `positional` array in meta to specify which arguments are positional args.
-   * Use '...name' prefix for variadic (rest) arguments, matching JS/TS rest syntax.
-   *
-   * @example
-   * ```ts
-   * // Direct schema
-   * .arguments(z.object({
-   *   source: z.string(),
-   *   files: z.string().array(),
-   *   dest: z.string(),
-   *   recursive: z.boolean().default(false),
-   * }), {
-   *   positional: ['source', '...files', 'dest'],
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Function-based schema extending parent arguments
-   * .arguments((parentArgs) => {
-   *   return z.object({
-   *     ...parentArgs.shape,
-   *     verbose: z.boolean().default(false),
-   *   });
-   * })
-   * ```
-   */
-  arguments: <TNewArgs extends PadroneSchema = PadroneSchema<void>, TMeta extends GetArgsMeta<TNewArgs> = GetArgsMeta<TNewArgs>>(schema?: TNewArgs | ((parentSchema: TParentArgs) => TNewArgs), meta?: TMeta) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TNewArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, OrAsyncMeta<OrAsync<TAsync, TNewArgs>, TMeta>>;
-  /**
-   * Configures config file path(s) and schema for parsing config files.
-   * @example
-   * ```ts
-   * .configFile('config.json', z.object({ port: z.number() }))
-   * ```
-   */
-  configFile: <TNewConfig extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = TArgs>(file: string | string[] | undefined, schema?: TNewConfig | ((argsSchema: TArgs) => TNewConfig)) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TNewConfig, TEnv, OrAsync<TAsync, TNewConfig>>;
-  /**
-   * Configures environment variable schema for parsing env vars into arguments.
-   * The schema should transform environment variables (typically SCREAMING_SNAKE_CASE)
-   * into the argument names used by the command.
-   * @example
-   * ```ts
-   * .env(z.object({ MY_APP_PORT: z.coerce.number() }).transform(e => ({ port: e.MY_APP_PORT })))
-   * ```
-   */
-  env: <TNewEnv extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = TArgs>(schema: TNewEnv | ((argsSchema: TArgs) => TNewEnv)) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TNewEnv, OrAsync<TAsync, TNewEnv>>;
-  /**
-   * Defines the handler function to be executed when the command is run.
-   * When overriding an existing command, the previous handler is passed as the third `base` parameter.
-   */
-  action: <TNewRes>(handler?: (args: StandardSchemaV1.InferOutput<TArgs>, ctx: PadroneActionContext, base: (args: StandardSchemaV1.InferOutput<TArgs>, ctx: PadroneActionContext) => TRes) => TNewRes) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TNewRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
-  /**
-   * Wraps an external CLI tool with optional schema transformation.
-   * The config can include a schema that transforms command arguments to external CLI arguments.
-   *
-   * @example
-   * ```ts
-   * // No transformation - pass arguments as-is
-   * .arguments(z.object({
-   *   message: z.string(),
-   * }))
-   * .wrap({
-   *   command: 'echo',
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With transformation schema
-   * .arguments(z.object({
-   *   message: z.string(),
-   *   all: z.boolean().optional(),
-   * }), {
-   *   positional: ['message'],
-   * })
-   * .wrap({
-   *   command: 'git',
-   *   args: ['commit'],
-   *   positional: ['m'],
-   *   schema: z.object({
-   *     message: z.string(),
-   *     all: z.boolean().optional(),
-   *   }).transform(args => ({
-   *     m: args.message,
-   *     a: args.all,
-   *   })),
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Using function-based schema for type inference
-   * .arguments(z.object({
-   *   image: z.string(),
-   *   detach: z.boolean().optional(),
-   * }))
-   * .wrap({
-   *   command: 'docker',
-   *   args: ['run'],
-   *   positional: ['image'],
-   *   schema: (schema) => schema.transform(args => ({
-   *     d: args.detach,
-   *     image: args.image,
-   *   })),
-   * })
-   * ```
-   */
-  wrap: <TWrapArgs extends PadroneSchema = TArgs>(config: WrapConfig<TArgs, TWrapArgs>) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, Promise<WrapResult>, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
-  /**
-   * Creates or extends a nested command within the current command.
-   * If a command with the same name already exists, it is extended:
-   * - Configuration is merged (new values override old).
-   * - The builder callback receives a builder pre-populated with the existing command's state.
-   * - `.action()` receives the previous handler as the third `base` parameter.
-   * - `.arguments()` callback receives the existing schema as its parameter.
-   * - Subcommands are recursively merged by name.
-   *
-   * @example
-   * ```ts
-   * // Fresh command
-   * .command('list', (c) => c.action(() => 'list'))
-   *
-   * // Override — extend an existing command
-   * .command('list', (c) => c.action((args, ctx, base) => {
-   *   const original = base(args, ctx);
-   *   return `modified: ${original}`;
-   * }))
-   *
-   * // Name with aliases
-   * .command(['list', 'ls', 'l'], (c) => c.action(() => 'list'))
-   * ```
-   */
-  command: <TNameNested extends string, TAliases extends string[] = [], TBuilder extends CommandTypesBase = DefaultCommandBuilder<TProgramName, TNameNested, FullCommandName<TName, TParentName>, TArgs, TCommands>>(name: TNameNested | readonly [TNameNested, ...TAliases], builderFn?: (builder: InitialCommandBuilder<TProgramName, TNameNested, FullCommandName<TName, TParentName>, TArgs, TCommands>) => TBuilder) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands extends [] ? [WithAliases<TBuilder['~types']['command'], TAliases>] : AnyPadroneCommand[] extends TCommands ? [WithAliases<TBuilder['~types']['command'], TAliases>] : ReplaceOrAppendCommand<TCommands, TNameNested, WithAliases<TBuilder['~types']['command'], ResolvedAliases<TCommands, TNameNested, TAliases>>>, TParentArgs, TConfig, TEnv, TAsync>;
-  /**
-   * Mounts an existing Padrone program as a subcommand.
-   * The program's root-level properties (name, path, parent) are replaced to fit the mount point.
-   * All subcommands are recursively re-pathed. Root-level `version` is dropped.
-   *
-   * @example
-   * ```ts
-   * const admin = createPadrone('admin')
-   *   .command('users', (c) => c.action(() => 'users'))
-   *   .command('roles', (c) => c.action(() => 'roles'));
-   *
-   * const app = createPadrone('app')
-   *   .mount('admin', admin)
-   *   // Now: app admin users, app admin roles
-   *
-   * // With aliases
-   * const app2 = createPadrone('app')
-   *   .mount(['admin', 'adm'], admin)
-   * ```
-   */
-  mount: <TNameNested extends string, TAliases extends string[] = [], TProgram extends CommandTypesBase = CommandTypesBase>(name: TNameNested | readonly [TNameNested, ...TAliases], program: TProgram) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands extends [] ? [WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['configSchema'], TProgram['~types']['command']['~types']['envSchema'], TProgram['~types']['command']['~types']['async']>, TAliases>] : AnyPadroneCommand[] extends TCommands ? [WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['configSchema'], TProgram['~types']['command']['~types']['envSchema'], TProgram['~types']['command']['~types']['async']>, TAliases>] : ReplaceOrAppendCommand<TCommands, TNameNested, WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['configSchema'], TProgram['~types']['command']['~types']['envSchema'], TProgram['~types']['command']['~types']['async']>, ResolvedAliases<TCommands, TNameNested, TAliases>>>, TParentArgs, TConfig, TEnv, TAsync>; /** @deprecated Internal use only */
-  '~types': {
-    programName: TProgramName;
-    name: TName;
-    parentName: TParentName;
-    path: FullCommandName<TName, TParentName>;
-    aliases: [];
-    argsSchema: TArgs;
-    result: TRes;
-    commands: TCommands;
-    async: TAsync;
-    command: PadroneCommand<TName, TParentName, TArgs, TRes, TCommands, [], TConfig, TEnv, TAsync>;
-  };
-};
-type PadroneBuilder<TProgramName extends string = '', TName extends string = string, TParentName extends string = '', TArgs extends PadroneSchema = PadroneSchema<DefaultArgs>, TRes = void, TCommands extends [...AnyPadroneCommand[]] = [], TParentArgs extends PadroneSchema = PadroneSchema<void>, TConfig extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = PadroneSchema<void>, TEnv extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = PadroneSchema<void>, TAsync extends boolean = false> = PadroneBuilderMethods<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync, 'builder'>;
-type PadroneProgram<TProgramName extends string = '', TName extends string = string, TParentName extends string = '', TArgs extends PadroneSchema = PadroneSchema<DefaultArgs>, TRes = void, TCommands extends [...AnyPadroneCommand[]] = [], TParentArgs extends PadroneSchema = PadroneSchema<void>, TConfig extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = PadroneSchema<void>, TEnv extends PadroneSchema<unknown, StandardSchemaV1.InferInput<TArgs>> = PadroneSchema<void>, TAsync extends boolean = false> = PadroneBuilderMethods<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync, 'program'> & {
-  /**
-   * Runs a command programmatically by name with provided arguments (including positional args).
-   */
-  run: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], true, true>>(name: TCommand | SafeString, args: NoInfer<GetArguments<'in', PickCommandByName<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>>) => PadroneCommandResult<PickCommandByName<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>;
-  /**
-   * Evaluates a command string: parses, validates, and executes.
-   * On validation errors, returns a result with issues instead of throwing.
-   * This is the method used by `repl()` internally, and the right choice for
-   * programmatic invocation, testing, chat interfaces, or any context where
-   * you have a command string and want a result — not a process exit.
-   *
-   * @example
-   * ```ts
-   * const result = await program.eval('greet --name Alice');
-   * if (result.argsResult?.issues) { /* handle validation errors *\/ }
-   * ```
-   */
-  eval: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], true, true>>(input: TCommand | SafeString, prefs?: PadroneEvalPreferences) => MaybePromise<PadroneCommandResult<PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>, PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>['~types']['async']>;
-  /**
-   * Runs the program as a CLI entry point, parsing `process.argv`.
-   * On validation errors, throws and prints help.
-   * For programmatic invocation with a command string, use `eval()` instead.
-   */
-  cli: (prefs?: PadroneCliPreferences<PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>) => MaybePromise<PadroneCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>, TAsync>;
-  /**
-   * Parses CLI input (or the provided input string) into command and arguments without executing anything.
-   */
-  parse: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], true, false>>(input?: TCommand | SafeString) => MaybePromise<PadroneParseResult<PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>, PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>['~types']['async']>;
-  /**
-   * Converts command and arguments back into a CLI string.
-   */
-  stringify: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], false, true>>(command?: TCommand | SafeString, args?: GetArguments<'out', PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>) => string;
-  /**
-   * Finds a command by name, returning `undefined` if not found.
-   */
-  find: <const TFind extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], false, true>>(command: TFind | SafeString) => PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TFind> | undefined;
-  /**
-   * Generates a type-safe API for invoking commands programmatically.
-   */
-  api: () => PadroneAPI<PadroneCommand<'', '', TArgs, TRes, TCommands>>;
-  /**
-   * Starts a REPL (Read-Eval-Print Loop) for running commands interactively.
-   * Returns an AsyncIterable that yields a `PadroneCommandResult` for each successfully executed command.
-   * Errors are printed via `runtime.error()` and the loop continues.
-   * The loop ends when the user sends EOF (Ctrl+D), types `.exit`/`.quit`,
-   * or presses Ctrl+C twice within 2 seconds.
-   *
-   * @example
-   * ```ts
-   * for await (const result of program.repl()) {
-   *   console.log(result.command.name, result.result);
-   * }
-   * ```
-   *
-   * TODO: REPL future enhancements:
-   * - History persistence: save/load history across sessions (currently in-memory only)
-   * - Middleware/hooks: onBeforeCommand, onAfterCommand, error interceptors (design alongside general middleware system)
-   */
-  repl: (options?: PadroneReplPreferences<PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>) => AsyncIterable<PadroneCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>>;
-  /**
-   * Returns a tool definition that can be passed to AI SDK.
-   */
-  tool: () => Tool<{
-    command: string;
-  }>;
-  /**
-   * Returns the help information for the program or a specific command.
-   */
-  help: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], false, true>>(command?: TCommand, prefs?: HelpPreferences) => string;
-  /**
-   * Generates and returns a shell completion script.
-   * If shell is not specified, automatically detects the current shell and provides instructions.
-   * @param shell - The shell type (bash, zsh, fish, powershell). If not provided, auto-detects.
-   * @returns The shell completion script as a string.
-   * @example
-   * ```ts
-   * // Get bash completion script
-   * const bashScript = program.completion('bash');
-   *
-   * // Auto-detect shell and get completion script with instructions
-   * const script = program.completion();
-   * ```
-   */
-  completion: (shell?: 'bash' | 'zsh' | 'fish' | 'powershell') => Promise<string>;
-};
-type AnyPadroneProgram = PadroneProgram<string, string, string, any, any, [...AnyPadroneCommand[]]>;
-/**
- * Options for `repl()` to customize the REPL session.
- */
-/** A single spacing value: blank line (`true`), separator string, or an array of these for multiple lines. */
-type PadroneReplSpacing = boolean | string | (boolean | string)[];
-type PadroneReplPreferences<TScope extends string = string> = {
-  /** The prompt string displayed before each input, or a function returning it. Defaults to `"<programName>> "`. */prompt?: string | (() => string);
-  /**
-   * A greeting message displayed when the REPL starts.
-   * When not provided, defaults to `"Welcome to <name> v<version>"` (or just `"Welcome to <name>"` if no version).
-   * Set to `false` to suppress the default greeting entirely.
-   */
-  greeting?: string | false;
-  /**
-   * A hint message displayed below the greeting in dimmed text.
-   * When not provided, defaults to `'Type ".help" for more information, ".exit" to quit.'`.
-   * Set to `false` to suppress the hint.
-   */
-  hint?: string | false; /** Initial history entries (most recent last). Arrow keys navigate history in the terminal. */
-  history?: string[]; /** Set to `false` to disable tab completion. Defaults to `true`. */
-  completion?: boolean;
-  /**
-   * Add spacing/separators around each command's output.
-   * A spacing value can be:
-   * - `true` — blank line
-   * - A string — separator line (single char like `'─'` repeats to terminal width, multi-char prints as-is)
-   * - An array of the above — multiple lines in order (e.g. `[true, '─']` for blank line then separator)
-   *
-   * Shorthand applies to both before and after. Use `{ before?, after? }` for independent control.
-   */
-  spacing?: PadroneReplSpacing | {
-    before?: PadroneReplSpacing;
-    after?: PadroneReplSpacing;
-  }; /** Prefix each line of command output/error with this string (e.g. `'│ '`, `'  '`, `'▎ '`). */
-  outputPrefix?: string;
-  /**
-   * Start the REPL scoped to a command subtree. The scope path is a space-separated command path
-   * (e.g. `'db'` or `'db migrate'`). Commands are resolved relative to the scoped command.
-   * Users can change scope at runtime with `.scope <subcommand>` and `.scope ..`/`..`.
-   */
-  scope?: TScope;
-  /**
-   * Automatically write each command's return value to output.
-   * See `PadroneEvalPreferences.autoOutput` for details on how values are serialized.
-   * Defaults to `true`.
-   */
-  autoOutput?: boolean;
-};
-/**
- * Options that can be passed to `eval()` to control execution behavior.
- */
-type PadroneEvalPreferences = {
-  /**
-   * Controls interactive prompting for this execution.
-   * Overrides the runtime's `interactive` setting, but is itself overridden by `--interactive` / `-i` flags.
-   *
-   * - `undefined`: inherit from runtime (default).
-   * - `true`: force prompting for all configured interactive fields, even if values are already provided.
-   * - `false`: suppress all interactive prompts.
-   */
-  interactive?: boolean;
-  /**
-   * Automatically write the command's return value to output.
-   *
-   * - Values are passed directly to the runtime's `output` function (no stringification).
-   * - Promises are awaited before output.
-   * - Iterators and async iterators are consumed, outputting each yielded value as it arrives.
-   * - `undefined` and `null` results produce no output.
-   *
-   * Defaults to `true`. Set to `false` to disable.
-   */
-  autoOutput?: boolean;
-  /**
-   * Override the runtime for this execution.
-   * Partial — only the provided fields replace the command's resolved runtime.
-   * Useful for capturing output, injecting test doubles, or running in non-terminal contexts (e.g. AI tool calls).
-   */
-  runtime?: PadroneRuntime;
-};
-/**
- * Options that can be passed to `cli()` to control execution behavior.
- */
-type PadroneCliPreferences<TScope extends string = string> = PadroneEvalPreferences & {
-  /** REPL preferences used when `--repl` flag is passed. Set to `false` to disable the `--repl` flag. */repl?: PadroneReplPreferences<TScope> | false;
-};
-type PadroneCommandResult<TCommand extends AnyPadroneCommand = AnyPadroneCommand> = PadroneParseResult<TCommand> & {
-  result: GetResults<TCommand>;
-};
-type PadroneParseResult<TCommand extends AnyPadroneCommand = AnyPadroneCommand> = {
-  command: TCommand;
-  args?: GetArguments<'out', TCommand>;
-  argsResult?: StandardSchemaV1.Result<GetArguments<'out', TCommand>>;
-};
-type PadroneAPI<TCommand extends AnyPadroneCommand> = PadroneAPICommand<TCommand> & { [K in TCommand['~types']['commands'][number] as K['name']]: PadroneAPI<K> };
-type PadroneAPICommand<TCommand extends AnyPadroneCommand> = (args: GetArguments<'in', TCommand>) => GetResults<TCommand>;
-type NormalizeArguments<TArgs> = IsGeneric<TArgs> extends true ? void | EmptyRecord : TArgs;
-type GetArguments<TDir extends 'in' | 'out', TCommand extends AnyPadroneCommand> = TDir extends 'in' ? NormalizeArguments<TCommand['~types']['argsInput']> : NormalizeArguments<TCommand['~types']['argsOutput']>;
-type GetResults<TCommand extends AnyPadroneCommand> = ReturnType<NonNullable<TCommand['action']>>;
-type GetArgsMeta<TArgs extends PadroneSchema> = PadroneArgsSchemaMeta<NonNullable<StandardSchemaV1.InferInput<TArgs>>>;
-/** Base context shared across all plugin phases within a single execution. */
-type PluginBaseContext = {
-  /** The resolved command for this execution. In the parse phase, this is the root program. */command: AnyPadroneCommand; /** Mutable state bag shared across phases for this execution. Plugins can store cross-phase data here. */
-  state: Record<string, unknown>;
-};
-/** Context for the parse phase. */
-type PluginParseContext = PluginBaseContext & {
-  /** The raw CLI input string (undefined when invoked without input). */input: string | undefined;
-};
-/** Result returned by the parse phase's `next()`. */
-type PluginParseResult = {
-  command: AnyPadroneCommand;
-  rawArgs: Record<string, unknown>;
-  positionalArgs: string[];
-};
-/** Context for the validate phase. */
-type PluginValidateContext = PluginBaseContext & {
-  /** Raw named arguments extracted by the parser. Mutable — modify before `next()` to inject/override values. */rawArgs: Record<string, unknown>; /** Positional argument strings extracted by the parser. */
-  positionalArgs: string[];
-};
-/** Result returned by the validate phase's `next()`. */
-type PluginValidateResult = {
-  args: unknown;
-  argsResult: StandardSchemaV1.Result<unknown>;
-};
-/** Context for the execute phase. */
-type PluginExecuteContext = PluginBaseContext & {
-  /** Validated arguments that will be passed to the action. Mutable — modify before `next()` to override. */args: unknown;
-};
-/** Result returned by the execute phase's `next()`. */
-type PluginExecuteResult = {
-  result: unknown;
-};
-/** Context for the start phase. Runs before parsing, wraps the entire pipeline. */
-type PluginStartContext = PluginBaseContext & {
-  /** The raw CLI input string (undefined when invoked without input). */input: string | undefined;
-};
-/** Context for the error phase. Called when the pipeline throws. */
-type PluginErrorContext = PluginBaseContext & {
-  /** The error that was thrown. */error: unknown;
-};
-/** Result returned by the error phase's `next()`. */
-type PluginErrorResult = {
-  /** The error (possibly transformed). Set to `undefined` to suppress the error. */error?: unknown; /** A replacement result when suppressing the error. */
-  result?: unknown;
-};
-/** Context for the shutdown phase. Always runs after the pipeline (success or failure). */
-type PluginShutdownContext = PluginBaseContext & {
-  /** The error, if the pipeline failed (after error phase processing). */error?: unknown; /** The pipeline result, if it succeeded. */
-  result?: unknown;
-};
-type PluginPhaseHandler<TCtx, TResult> = (ctx: TCtx, next: () => TResult | Promise<TResult>) => TResult | Promise<TResult>;
-/**
- * A Padrone plugin that can intercept the parse, validate, and execute phases of command execution.
- * Plugins are registered at the program level with `.use()` and apply to all commands.
- *
- * Each phase handler receives a context and a `next()` function (onion/middleware pattern):
- * - Call `next()` to proceed to the next plugin or the core operation.
- * - Return without calling `next()` to short-circuit.
- * - Wrap `next()` in try/catch for error handling.
- * - Modify context fields before `next()` to alter inputs.
- * - Transform the return value of `next()` to alter outputs.
- */
-type PadronePlugin = {
-  /** Unique name for this plugin. Used for identification and future disable/override support. */name: string;
-  /**
-   * Ordering hint. Lower values run as outer layers (earlier before `next()`, later after).
-   * Plugins with the same order preserve registration order. Defaults to `0`.
-   */
-  order?: number;
-  /**
-   * Runs before the pipeline (parse → validate → execute). `next()` proceeds to the pipeline.
-   * Root plugins only. Use for startup tasks like telemetry, update checks, or global config loading.
-   */
-  start?: PluginPhaseHandler<PluginStartContext, unknown>; /** Intercepts command routing and raw argument extraction. */
-  parse?: PluginPhaseHandler<PluginParseContext, PluginParseResult>; /** Intercepts argument preprocessing, interactive prompting, and schema validation. */
-  validate?: PluginPhaseHandler<PluginValidateContext, PluginValidateResult>; /** Intercepts handler execution. */
-  execute?: PluginPhaseHandler<PluginExecuteContext, PluginExecuteResult>;
-  /**
-   * Called when the pipeline throws an error. `next()` passes to the next error handler
-   * (innermost returns `{ error }` unchanged). Return `{ result }` without `error` to suppress.
-   */
-  error?: PluginPhaseHandler<PluginErrorContext, PluginErrorResult>;
-  /**
-   * Always runs after the pipeline completes (success or failure). `next()` calls the next shutdown handler.
-   * Use for cleanup: closing connections, flushing logs, etc.
-   */
-  shutdown?: PluginPhaseHandler<PluginShutdownContext, void>;
-};
-//#endregion
-export { PossibleCommands as _, PadroneActionContext as a, PadroneRuntime as b, PadroneCommandResult as c, PadroneProgram as d, PadroneSchema as f, PickCommandByName as g, UpdateCheckConfig as h, AsyncPadroneSchema as i, PadroneParseResult as l, WrapResult as m, AnyPadroneCommand as n, PadroneBuilder as o, WrapConfig as p, AnyPadroneProgram as r, PadroneCommand as s, AnyPadroneBuilder as t, PadronePlugin as u, InteractiveMode as v, REPL_SIGINT as x, InteractivePromptConfig as y };
-//# sourceMappingURL=types-DjIdJN5G.d.mts.map