padrone 1.3.0 → 1.5.0

package/src/types.ts

@@ -2,8 +2,11 @@ import type { StandardJSONSchemaV1, StandardSchemaV1 } from '@standard-schema/sp
 import type { Tool } from 'ai';
 import type { PadroneArgsSchemaMeta } from './args.ts';
 import type { HelpPreferences } from './help.ts';
-import type { PadroneRuntime, ResolvedPadroneRuntime } from './runtime.ts';
+import type { PadroneMcpPreferences } from './mcp.ts';
+import type { PadroneProgressIndicator, PadroneRuntime, PadroneSpinnerConfig, ResolvedPadroneRuntime } from './runtime.ts';
+import type { PadroneServePreferences } from './serve.ts';
 import type {
+  Drained,
   FindDirectChild,
   FlattenCommands,
   FullCommandName,
@@ -36,6 +39,11 @@ export type PadroneActionContext = {
   command: AnyPadroneCommand;
   /** The root program instance. */
   program: AnyPadroneProgram;
+  /**
+   * The active auto-managed progress indicator, or a no-op if none is configured.
+   * Use `.update()` to change the in-progress message mid-execution.
+   */
+  progress: PadroneProgressIndicator;
 };
 
 /**
@@ -178,8 +186,24 @@ export type PadroneCommand<
   aliases?: TAliases;
   deprecated?: boolean | string;
   hidden?: boolean;
+  /** Group name for organizing this command under a labeled section in help output. */
+  group?: string;
+  /** Whether this command performs a mutation (create, update, delete). Affects HTTP method in serve (POST-only) and MCP tool annotations (destructiveHint). */
+  mutation?: boolean;
   needsApproval?: boolean | ((args: TArgs) => Promise<boolean> | boolean);
   autoOutput?: boolean;
+  /** Usage examples shown in help output. Each entry is a command-line invocation string. */
+  examples?: string[];
+  /**
+   * Auto-start a progress indicator when the command's execute phase begins.
+   * - `true` — generic message based on command name.
+   * - `string` — custom message for all states.
+   * - `PadroneProgressConfig` — separate messages for progress, success, and error states.
+   *
+   * The indicator is automatically stopped on success (`.succeed()`) or failure (`.fail()`).
+   * Requires a `progress` factory on the runtime — silently skipped if not available.
+   */
+  progress?: boolean | string | PadroneProgressPrefs;
   argsSchema?: TArgs;
   configSchema?: TConfig;
   envSchema?: TEnv;
@@ -193,7 +217,7 @@ export type PadroneCommand<
   runtime?: PadroneRuntime;
 
   /** Plugins registered on this command. Collected from the parent chain at execution time. */
-  plugins?: PadronePlugin[];
+  plugins?: PadronePlugin<any, any>[];
 
   /** Update check configuration. Only used on the root program. */
   updateCheck?: UpdateCheckConfig;
@@ -233,6 +257,33 @@ type CommandTypesBase = {
 /**
  * Configuration for a command.
  */
+/**
+ * A progress message value: a plain string, `null` to suppress, or an object with a message and custom indicator icon.
+ */
+export type PadroneProgressMessage = string | null | { message?: string | null; indicator?: string };
+
+/**
+ * Progress indicator configuration with per-state messages and optional dynamic callbacks.
+ *
+ * The `success` and `error` fields accept either a static value or a callback function:
+ * - `string` — static message.
+ * - `null` — suppress the message entirely.
+ * - `{ message, indicator }` — custom message with a per-call indicator icon override.
+ * - `(result) => PadroneProgressMessage` / `(error) => PadroneProgressMessage` — dynamic from the actual result/error.
+ */
+export type PadroneProgressPrefs<TRes = unknown> = {
+  /** Message shown during async validation. Defaults to `''` (spinner only). */
+  validation?: string;
+  /** Message shown while the command's action is running. */
+  progress?: string;
+  /** Message shown when the command succeeds. `null` to suppress. Defaults to the `progress` message. */
+  success?: PadroneProgressMessage | ((result: TRes) => PadroneProgressMessage);
+  /** Message shown when the command fails. `null` to suppress. Defaults to the error message. */
+  error?: PadroneProgressMessage | ((error: unknown) => PadroneProgressMessage);
+  /** Spinner configuration: a preset name, custom frames/interval, or `false` to disable. */
+  spinner?: PadroneSpinnerConfig;
+};
+
 export type PadroneCommandConfig = {
   /** A short title for the command, displayed in help. */
   title?: string;
@@ -244,12 +295,23 @@ export type PadroneCommandConfig = {
   deprecated?: boolean | string;
   /** Whether the command should be hidden from help output. */
   hidden?: boolean;
+  /** Group name for organizing this command under a labeled section in help output. */
+  group?: string;
   /**
    * 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;
+  /** Usage examples shown in help output. Each entry is a command-line invocation string. */
+  examples?: string[];
+  /**
+   * Whether this command performs a mutation (create, update, delete).
+   * - In `serve()`: mutation commands accept POST only; non-mutation commands accept GET and POST.
+   * - In `mcp()`: sets `annotations.destructiveHint` on the tool definition.
+   * - In `tool()`: defaults `needsApproval` to `true` when not explicitly set.
+   */
+  mutation?: boolean;
 };
 
 /**
@@ -325,7 +387,7 @@ export type PadroneBuilderMethods<
    * On subcommands, only validate and execute plugins apply (parse is handled by the root program).
    */
   use: (
-    plugin: PadronePlugin,
+    plugin: PadronePlugin<StandardSchemaV1.InferOutput<TArgs>, TRes>,
   ) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
 
   configure: (
@@ -463,6 +525,31 @@ export type PadroneBuilderMethods<
     OrAsync<TAsync, TNewEnv>
   >;
 
+  /**
+   * Configures an auto-managed progress indicator for this command.
+   * The indicator starts before validation and is automatically stopped on success or failure.
+   *
+   * - `true` — generic message based on command name.
+   * - `string` — custom message for all states.
+   * - `PadroneProgressConfig` — full control: per-state messages, dynamic callbacks, spinner config.
+   *
+   * Requires a `progress` factory on the runtime — silently skipped if not available.
+   *
+   * @example
+   * ```ts
+   * .progress('Deploying...')
+   * .progress({
+   *   progress: 'Deploying...',
+   *   success: (result) => `Deployed ${result.version}`,
+   *   error: (err) => `Deploy failed: ${err.message}`,
+   *   spinner: 'line',
+   * })
+   * ```
+   */
+  progress: (
+    config?: boolean | string | PadroneProgressPrefs<Awaited<TRes>>,
+  ) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TConfig, TEnv, TAsync>;
+
   /**
    * 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.
@@ -479,6 +566,8 @@ export type PadroneBuilderMethods<
    * Wraps an external CLI tool with optional schema transformation.
    * The config can include a schema that transforms command arguments to external CLI arguments.
    *
+   * @experimental This API is experimental and may change in future releases.
+   *
    * @example
    * ```ts
    * // No transformation - pass arguments as-is
@@ -769,8 +858,8 @@ export type PadroneProgram<
   eval: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], true, true>>(
     input: TCommand | SafeString,
     prefs?: PadroneEvalPreferences,
-  ) => MaybePromise<
-    PadroneCommandResult<PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>,
+  ) => MaybePromiseCommandResult<
+    PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>,
     PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>['~types']['async']
   >;
 
@@ -781,7 +870,7 @@ export type PadroneProgram<
    */
   cli: (
     prefs?: PadroneCliPreferences<PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>,
-  ) => MaybePromise<PadroneCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>, TAsync>;
+  ) => MaybePromiseCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>, TAsync>;
 
   /**
    * Parses CLI input (or the provided input string) into command and arguments without executing anything.
@@ -831,9 +920,11 @@ export type PadroneProgram<
    * - 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>]>>>;
+  repl: (options?: PadroneReplPreferences<PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>) => AsyncIterable<
+    PadroneCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>
+  > & {
+    drain: () => Promise<PadroneDrainResult<PadroneCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>[]>>;
+  };
 
   /**
    * Returns a tool definition that can be passed to AI SDK.
@@ -863,6 +954,34 @@ export type PadroneProgram<
    * ```
    */
   completion: (shell?: 'bash' | 'zsh' | 'fish' | 'powershell') => Promise<string>;
+
+  /**
+   * Starts a Model Context Protocol (MCP) server that exposes commands as tools for AI assistants.
+   * Communicates over stdio using JSON-RPC with Content-Length framing.
+   * Returns a Promise that resolves when the connection closes.
+   *
+   * @experimental This API is experimental and may change in future releases.
+   *
+   * @example
+   * ```ts
+   * await program.mcp();
+   * ```
+   */
+  mcp: (prefs?: PadroneMcpPreferences) => Promise<void>;
+
+  /**
+   * Starts a REST HTTP server that exposes commands as endpoints.
+   * Each command becomes a route: `users list` → `GET/POST /users/list`.
+   * Commands with `mutation: true` only accept POST.
+   *
+   * @experimental This API is experimental and may change in future releases.
+   *
+   * @example
+   * ```ts
+   * await program.serve({ port: 3000 });
+   * ```
+   */
+  serve: (prefs?: PadroneServePreferences) => Promise<void>;
 };
 
 export type AnyPadroneProgram = PadroneProgram<string, string, string, any, any, [...AnyPadroneCommand[]]>;
@@ -959,10 +1078,48 @@ export type PadroneEvalPreferences = {
 export 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;
+  /** MCP server preferences used when `mcp` command is used. Set to `false` to disable. */
+  mcp?: PadroneMcpPreferences | false;
+  /** REST server preferences used when `serve` command is used. Set to `false` to disable. */
+  serve?: PadroneServePreferences | false;
 };
 
-export type PadroneCommandResult<TCommand extends AnyPadroneCommand = AnyPadroneCommand> = PadroneParseResult<TCommand> & {
-  result: GetResults<TCommand>;
+/**
+ * Result of `drain()` — a discriminated union that never throws.
+ * On success, `value` holds the fully resolved/collected result; on failure, `error` holds the error.
+ */
+export type PadroneDrainResult<TResult> = { value: Drained<TResult>; error?: never } | { error: unknown; value?: never };
+
+/**
+ * Result returned by `eval()`, `cli()`, and `run()`. Never thrown — errors are captured in the `error` field.
+ * Discriminated union: check `error` to distinguish success from failure.
+ *
+ * On success: `command`, `args`, `argsResult`, `result` are populated; `error` is absent.
+ * On failure: `error` is populated; `command` may be present if routing succeeded.
+ */
+export type PadroneCommandResult<TCommand extends AnyPadroneCommand = AnyPadroneCommand> =
+  | (PadroneParseResult<TCommand> & {
+      result: GetResults<TCommand>;
+      error?: never;
+      /** Flattens the result: awaits Promises, collects iterables, catches errors. Never throws. */
+      drain: () => Promise<PadroneDrainResult<GetResults<TCommand>>>;
+    })
+  | {
+      command?: TCommand;
+      args?: GetArguments<'out', TCommand>;
+      argsResult?: StandardSchemaV1.Result<GetArguments<'out', TCommand>>;
+      error: unknown;
+      result?: never;
+      /** Returns `{ error }` since there is no result to drain. */
+      drain: () => Promise<PadroneDrainResult<GetResults<TCommand>>>;
+    };
+
+/**
+ * Like `MaybePromise<PadroneCommandResult<TCommand>, TAsync>` but ensures `drain()` is available
+ * at the outer level in all cases — both sync (Thenable) and async (Promise).
+ */
+type MaybePromiseCommandResult<TCommand extends AnyPadroneCommand, TAsync> = MaybePromise<PadroneCommandResult<TCommand>, TAsync> & {
+  drain: () => Promise<PadroneDrainResult<GetResults<TCommand>>>;
 };
 
 export type PadroneParseResult<TCommand extends AnyPadroneCommand = AnyPadroneCommand> = {
@@ -1020,20 +1177,20 @@ export type PluginValidateContext = PluginBaseContext & {
 };
 
 /** Result returned by the validate phase's `next()`. */
-export type PluginValidateResult = {
-  args: unknown;
-  argsResult: StandardSchemaV1.Result<unknown>;
+export type PluginValidateResult<TArgs = unknown> = {
+  args: TArgs;
+  argsResult: StandardSchemaV1.Result<TArgs>;
 };
 
 /** Context for the execute phase. */
-export type PluginExecuteContext = PluginBaseContext & {
+export type PluginExecuteContext<TArgs = unknown> = PluginBaseContext & {
   /** Validated arguments that will be passed to the action. Mutable — modify before `next()` to override. */
-  args: unknown;
+  args: TArgs;
 };
 
 /** Result returned by the execute phase's `next()`. */
-export type PluginExecuteResult = {
-  result: unknown;
+export type PluginExecuteResult<TResult = unknown> = {
+  result: TResult;
 };
 
 /** Context for the start phase. Runs before parsing, wraps the entire pipeline. */
@@ -1049,26 +1206,45 @@ export type PluginErrorContext = PluginBaseContext & {
 };
 
 /** Result returned by the error phase's `next()`. */
-export type PluginErrorResult = {
+export type PluginErrorResult<TResult = unknown> = {
   /** The error (possibly transformed). Set to `undefined` to suppress the error. */
   error?: unknown;
   /** A replacement result when suppressing the error. */
-  result?: unknown;
+  result?: TResult;
 };
 
 /** Context for the shutdown phase. Always runs after the pipeline (success or failure). */
-export type PluginShutdownContext = PluginBaseContext & {
+export type PluginShutdownContext<TResult = unknown> = PluginBaseContext & {
   /** The error, if the pipeline failed (after error phase processing). */
   error?: unknown;
   /** The pipeline result, if it succeeded. */
-  result?: unknown;
+  result?: TResult;
 };
 
-type PluginPhaseHandler<TCtx, TResult> = (ctx: TCtx, next: () => TResult | Promise<TResult>) => TResult | Promise<TResult>;
+/**
+ * A phase handler function for the plugin middleware chain.
+ *
+ * - `TCtx` — the context object available to the handler.
+ * - `TNextResult` — the typed result returned by `next()`, giving the handler type-safe access to downstream output.
+ * - `TReturn` — the type the handler itself returns. Defaults to `TNextResult` but can be wider,
+ *   allowing plugins to transform or replace the result (e.g., error-recovery plugins returning a different type).
+ */
+type PluginPhaseHandler<TCtx, TNextResult, TReturn = TNextResult> = (
+  ctx: TCtx,
+  next: () => TNextResult | Promise<TNextResult>,
+) => TReturn | Promise<TReturn>;
 
 /**
  * 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.
+ * Plugins are registered at the program or subcommand level with `.use()`.
+ *
+ * Type parameters:
+ * - `TArgs` — the validated arguments type (output of the args schema). Provides typed `ctx.args` in the execute phase
+ *   and typed `args` in the validate result from `next()`.
+ * - `TResult` — the command's return type. Provides typed `result` in execute/error/shutdown phases.
+ *
+ * When registered inline on a builder, these are inferred from the command's types automatically.
+ * For reusable plugins that work with any command, use `PadronePlugin<any, any>`.
  *
  * 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.
@@ -1077,9 +1253,15 @@ type PluginPhaseHandler<TCtx, TResult> = (ctx: TCtx, next: () => TResult | Promi
  * - Modify context fields before `next()` to alter inputs.
  * - Transform the return value of `next()` to alter outputs.
  */
-export type PadronePlugin = {
-  /** Unique name for this plugin. Used for identification and future disable/override support. */
+export type PadronePlugin<TArgs = unknown, TResult = unknown> = {
+  /** Display name for this plugin. Used for identification in logs and debugging. */
   name: string;
+  /**
+   * Optional unique identifier for deduplication. When multiple plugins share the same `id`,
+   * only the last one registered is kept. Useful for allowing downstream code to override
+   * a plugin without accumulating duplicates.
+   */
+  id?: 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`.
@@ -1093,17 +1275,17 @@ export type PadronePlugin = {
   /** Intercepts command routing and raw argument extraction. */
   parse?: PluginPhaseHandler<PluginParseContext, PluginParseResult>;
   /** Intercepts argument preprocessing, interactive prompting, and schema validation. */
-  validate?: PluginPhaseHandler<PluginValidateContext, PluginValidateResult>;
+  validate?: PluginPhaseHandler<PluginValidateContext, PluginValidateResult<TArgs>, PluginValidateResult>;
   /** Intercepts handler execution. */
-  execute?: PluginPhaseHandler<PluginExecuteContext, PluginExecuteResult>;
+  execute?: PluginPhaseHandler<PluginExecuteContext<TArgs>, PluginExecuteResult<TResult>, 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>;
+  error?: PluginPhaseHandler<PluginErrorContext, PluginErrorResult<TResult>, 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>;
+  shutdown?: PluginPhaseHandler<PluginShutdownContext<TResult>, void>;
 };

package/src/wrap.ts

@@ -58,7 +58,7 @@ export type WrapResult = {
 /**
  * Converts parsed arguments to CLI arguments for an external command.
  */
-function argsToCliArgs(input: Record<string, unknown> | undefined, positional: string[] = []): string[] {
+function argsToCliArgs(input: Record<string, unknown> | undefined, positional: readonly string[] = []): string[] {
   const args: string[] = [];
 
   // Handle undefined or null input
@@ -122,7 +122,7 @@ function argsToCliArgs(input: Record<string, unknown> | undefined, positional: s
 export function createWrapHandler<TCommandArgs extends PadroneSchema, TWrapArgs extends PadroneSchema>(
   config: WrapConfig<TCommandArgs, TWrapArgs>,
   commandArguments: TCommandArgs,
-  commandPositional?: string[],
+  commandPositional?: readonly string[],
 ): (args: StandardSchemaV1.InferOutput<TCommandArgs>) => Promise<WrapResult> {
   return async (args: StandardSchemaV1.InferOutput<TCommandArgs>): Promise<WrapResult> => {
     const { command, args: fixedArgs = [], inheritStdio = true, positional = commandPositional, schema: wrapSchema } = config;
@@ -153,33 +153,31 @@ export function createWrapHandler<TCommandArgs extends PadroneSchema, TWrapArgs
     const allArgs = [...fixedArgs, ...regularArgs];
 
     // Execute the external command
-    const proc = Bun.spawn([command, ...allArgs], {
-      stdout: inheritStdio ? 'inherit' : 'pipe',
-      stderr: inheritStdio ? 'inherit' : 'pipe',
-      stdin: inheritStdio ? 'inherit' : 'ignore',
-    });
+    const { spawn } = await import('node:child_process');
 
-    const exitCode = await proc.exited;
+    return new Promise<WrapResult>((resolve, reject) => {
+      const proc = spawn(command, allArgs, {
+        stdio: inheritStdio ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+      });
 
-    let stdout: string | undefined;
-    let stderr: string | undefined;
+      const stdoutChunks: Buffer[] = [];
+      const stderrChunks: Buffer[] = [];
 
-    if (!inheritStdio) {
-      if (proc.stdout) {
-        const stdoutBuffer = await new Response(proc.stdout).arrayBuffer();
-        stdout = new TextDecoder().decode(stdoutBuffer);
-      }
-      if (proc.stderr) {
-        const stderrBuffer = await new Response(proc.stderr).arrayBuffer();
-        stderr = new TextDecoder().decode(stderrBuffer);
+      if (!inheritStdio) {
+        proc.stdout!.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
+        proc.stderr!.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
       }
-    }
 
-    return {
-      exitCode,
-      stdout,
-      stderr,
-      success: exitCode === 0,
-    };
+      proc.on('error', reject);
+      proc.on('close', (code) => {
+        const exitCode = code ?? 1;
+        resolve({
+          exitCode,
+          stdout: inheritStdio ? undefined : Buffer.concat(stdoutChunks).toString(),
+          stderr: inheritStdio ? undefined : Buffer.concat(stderrChunks).toString(),
+          success: exitCode === 0,
+        });
+      });
+    });
   };
 }

package/src/zod.ts

@@ -0,0 +1,50 @@
+import * as z from 'zod/v4';
+import { asyncStream } from './stream.ts';
+import type { PadroneSchema } from './types.ts';
+
+/**
+ * Creates a Zod schema for an async stream field, ready to use in `.arguments()`.
+ * Wraps `z.custom<AsyncIterable<T>>()` with the `asyncStream()` metadata automatically.
+ *
+ * @param itemSchema - Optional item schema for per-item validation.
+ *
+ * @example
+ * ```ts
+ * import { zodAsyncStream } from 'padrone/zod';
+ *
+ * // String lines
+ * z.object({ lines: zodAsyncStream() })
+ *
+ * // Typed items — each line JSON.parse'd and validated
+ * const recordSchema = z.object({ name: z.string(), age: z.number() });
+ * z.object({ records: zodAsyncStream(jsonCodec(recordSchema)) })
+ * ```
+ */
+export function zodAsyncStream<T = string>(itemSchema?: PadroneSchema<unknown, T>) {
+  return z.custom<AsyncIterable<T>>().meta(asyncStream(itemSchema));
+}
+
+/**
+ * JSON codec for Zod schemas
+ * @see https://zod.dev/codecs?id=jsonschema
+ * Unlike the example in the docs, this codec also handles the case where the input is already an object
+ */
+export const jsonCodec = <T extends z.ZodType>(schema: T) =>
+  z.codec(z.union([z.string(), z.unknown()]), schema, {
+    decode: (jsonString, ctx) => {
+      try {
+        // HACK: in some cases the object is already deserialized, we just need to validate it
+        if (typeof jsonString !== 'string') return jsonString as z.input<T>;
+        return JSON.parse(jsonString) as z.input<T>;
+      } catch (err: any) {
+        ctx.issues.push({
+          code: 'invalid_format',
+          format: 'json',
+          input: typeof jsonString === 'string' ? jsonString : JSON.stringify(jsonString),
+          message: err.message,
+        });
+        return z.NEVER;
+      }
+    },
+    encode: (value) => JSON.stringify(value),
+  });

package/dist/args-DFEI7_G_.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"args-DFEI7_G_.mjs","names":[],"sources":["../src/args.ts"],"sourcesContent":["import type { StandardJSONSchemaV1 } from '@standard-schema/spec';\n\ntype Letter =\n  | 'a'\n  | 'b'\n  | 'c'\n  | 'd'\n  | 'e'\n  | 'f'\n  | 'g'\n  | 'h'\n  | 'i'\n  | 'j'\n  | 'k'\n  | 'l'\n  | 'm'\n  | 'n'\n  | 'o'\n  | 'p'\n  | 'q'\n  | 'r'\n  | 's'\n  | 't'\n  | 'u'\n  | 'v'\n  | 'w'\n  | 'x'\n  | 'y'\n  | 'z';\n\n/** A single letter character, valid as a short CLI flag (e.g. `'v'`, `'n'`, `'V'`). */\nexport type SingleChar = Letter | Uppercase<Letter>;\n\nexport interface PadroneFieldMeta {\n  description?: string;\n  /** Single-character short flags (stackable: `-abc` = `-a -b -c`). Used with single dash. */\n  flags?: SingleChar[] | SingleChar;\n  /** Multi-character alternative long names. Used with double dash (e.g. `--dry-run` for `--dryRun`). */\n  alias?: string[] | string;\n  deprecated?: boolean | string;\n  hidden?: boolean;\n  examples?: unknown[];\n}\n\ntype PositionalArgs<TObj> =\n  TObj extends Record<string, any>\n    ? {\n        [K in keyof TObj]: TObj[K] extends Array<any> ? `...${K & string}` : K & string;\n      }[keyof TObj]\n    : string;\n\n/**\n * Meta configuration for arguments, including positional arguments.\n * The `positional` array defines which arguments are positional and their order.\n * Use '...name' prefix to indicate variadic (rest) arguments, matching JS/TS rest syntax.\n *\n * @example\n * ```ts\n * .arguments(schema, {\n *   positional: ['source', '...files', 'dest'],  // '...files' is variadic\n * })\n * ```\n */\n/**\n * Configuration for reading from stdin and mapping it to an argument field.\n */\nexport type StdinConfig<TObj = Record<string, any>> =\n  | (keyof TObj & string)\n  | {\n      /** The argument field to populate with stdin data. */\n      field: keyof TObj & string;\n      /**\n       * How to consume stdin:\n       * - `'text'` (default): read all stdin as a single string.\n       * - `'lines'`: read stdin as an array of lines (string[]).\n       */\n      as?: 'text' | 'lines';\n    };\n\nexport interface PadroneArgsSchemaMeta<TObj = Record<string, any>> {\n  /**\n   * Array of argument names that should be treated as positional arguments.\n   * Order in array determines position. Use '...name' prefix for variadic args.\n   * @example ['source', '...files', 'dest'] - 'files' captures multiple values\n   */\n  positional?: PositionalArgs<TObj>[];\n  /**\n   * Per-argument metadata.\n   */\n  fields?: { [K in keyof TObj]?: PadroneFieldMeta };\n  /**\n   * Automatically generate kebab-case aliases for camelCase option names.\n   * For example, `dryRun` automatically gets `--dry-run` as an alias.\n   * Defaults to `true`. Set to `false` to disable.\n   *\n   * @default true\n   * @example\n   * ```ts\n   * // Auto-aliases enabled (default): --dry-run → dryRun\n   * .arguments(z.object({ dryRun: z.boolean() }))\n   *\n   * // Disable auto-aliases\n   * .arguments(z.object({ dryRun: z.boolean() }), { autoAlias: false })\n   * ```\n   */\n  autoAlias?: boolean;\n  /**\n   * Read from stdin and inject the data into the specified argument field.\n   * Only reads when stdin is piped (not a TTY) and the field wasn't already provided via CLI flags.\n   *\n   * - `string`: shorthand for `{ field: name, as: 'text' }` — read all stdin as a string.\n   * - `{ field, as }`: explicit form. `as: 'text'` reads all stdin as a string,\n   *   `as: 'lines'` reads stdin as an array of line strings.\n   *\n   * Precedence: CLI flags > stdin > env vars > config file > schema defaults.\n   *\n   * @example\n   * ```ts\n   * // Shorthand: read all stdin as text into 'data' field\n   * .arguments(z.object({ data: z.string() }), { stdin: 'data' })\n   *\n   * // Explicit: read stdin lines into 'lines' field\n   * .arguments(z.object({ lines: z.string().array() }), {\n   *   stdin: { field: 'lines', as: 'lines' },\n   * })\n   * ```\n   */\n  stdin?: StdinConfig<TObj>;\n  /**\n   * Fields to interactively prompt for when their values are missing after CLI/env/config resolution.\n   * - `true`: prompt for all required fields that are missing.\n   * - `string[]`: prompt for these specific fields if missing.\n   *\n   * Interactive prompting only occurs in `cli()` when the runtime has `interactive: true`.\n   * Setting this makes `parse()` and `cli()` return Promises.\n   *\n   * @example\n   * ```ts\n   * .arguments(schema, {\n   *   interactive: true,                        // prompt all missing required fields\n   *   interactive: ['name', 'template'],         // prompt only these fields\n   * })\n   * ```\n   */\n  interactive?: true | (keyof TObj & string)[];\n  /**\n   * Optional fields offered after required interactive prompts.\n   * Users are shown a multi-select to choose which of these fields to configure.\n   * - `true`: offer all optional fields that are missing.\n   * - `string[]`: offer these specific fields.\n   *\n   * @example\n   * ```ts\n   * .arguments(schema, {\n   *   interactive: ['name'],\n   *   optionalInteractive: ['typescript', 'eslint', 'prettier'],\n   * })\n   * ```\n   */\n  optionalInteractive?: true | (keyof TObj & string)[];\n}\n\n/**\n * Convert a camelCase string to kebab-case.\n * Returns null if the string has no uppercase letters (no conversion needed).\n */\nexport function camelToKebab(str: string): string | null {\n  if (!/[A-Z]/.test(str)) return null;\n  return str.replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`);\n}\n\n/**\n * Normalizes stdin config into its explicit form.\n */\nexport function parseStdinConfig(stdin: StdinConfig): { field: string; as: 'text' | 'lines' } {\n  if (typeof stdin === 'string') return { field: stdin, as: 'text' };\n  return { field: stdin.field as string, as: stdin.as ?? 'text' };\n}\n\n/**\n * Parse positional configuration to extract names and variadic info.\n */\nexport function parsePositionalConfig(positional: string[]): { name: string; variadic: boolean }[] {\n  return positional.map((p) => {\n    const isVariadic = p.startsWith('...');\n    const name = isVariadic ? p.slice(3) : p;\n    return { name, variadic: isVariadic };\n  });\n}\n\n/**\n * Result type for extractSchemaMetadata function.\n */\ninterface SchemaMetadataResult {\n  /** Single-char flags: maps flag char → full arg name (e.g. `{ v: 'verbose' }`) */\n  flags: Record<string, string>;\n  /** Multi-char aliases: maps alias → full arg name (e.g. `{ 'dry-run': 'dryRun' }`) */\n  aliases: Record<string, string>;\n}\n\nfunction addEntries(target: Record<string, string>, key: string, items: string | string[], filter?: (item: string) => boolean) {\n  const list = typeof items === 'string' ? [items] : items;\n  for (const item of list) {\n    if (typeof item === 'string' && item && item !== key && !(item in target) && (!filter || filter(item))) {\n      target[item] = key;\n    }\n  }\n}\n\n/**\n * Extract all arg metadata from schema and meta in a single pass.\n * Returns flags (single-char, stackable) and aliases (multi-char, long names) separately.\n * When `autoAlias` is true (default), camelCase property names automatically get kebab-case aliases.\n */\nexport function extractSchemaMetadata(\n  schema: StandardJSONSchemaV1,\n  meta?: Record<string, PadroneFieldMeta | undefined>,\n  autoAlias?: boolean,\n): SchemaMetadataResult {\n  const flags: Record<string, string> = {};\n  const aliases: Record<string, string> = {};\n\n  // Extract from meta object\n  if (meta) {\n    for (const [key, value] of Object.entries(meta)) {\n      if (!value) continue;\n\n      if (value.flags) {\n        addEntries(flags, key, value.flags, (item) => item.length === 1);\n      }\n      if (value.alias) {\n        addEntries(aliases, key, value.alias, (item) => item.length > 1);\n      }\n    }\n  }\n\n  // Extract from JSON schema properties\n  try {\n    const jsonSchema = schema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;\n    if (jsonSchema.type === 'object' && jsonSchema.properties) {\n      for (const [propertyName, propertySchema] of Object.entries(jsonSchema.properties as Record<string, any>)) {\n        if (!propertySchema) continue;\n\n        // Extract flags from schema `.meta({ flags: ... })`\n        const propFlags = propertySchema.flags;\n        if (propFlags) {\n          addEntries(flags, propertyName, propFlags, (item) => item.length === 1);\n        }\n\n        // Extract aliases from schema `.meta({ alias: ... })`\n        const propAlias = propertySchema.alias;\n        if (propAlias) {\n          const list = typeof propAlias === 'string' ? [propAlias] : propAlias;\n          if (Array.isArray(list)) {\n            addEntries(aliases, propertyName, list, (item) => item.length > 1);\n          }\n        }\n\n        // Auto-generate kebab-case alias for camelCase property names\n        if (autoAlias !== false) {\n          const kebab = camelToKebab(propertyName);\n          if (kebab && !(kebab in aliases)) {\n            aliases[kebab] = propertyName;\n          }\n        }\n      }\n    }\n  } catch {\n    // Ignore errors from JSON schema generation\n  }\n\n  return { flags, aliases };\n}\n\nfunction preprocessMappings(data: Record<string, unknown>, mappings: Record<string, string>): Record<string, unknown> {\n  const result = { ...data };\n\n  for (const [mappedKey, fullArgName] of Object.entries(mappings)) {\n    if (mappedKey in data && mappedKey !== fullArgName) {\n      const mappedValue = data[mappedKey];\n      // Prefer full arg name if it exists\n      if (!(fullArgName in result)) result[fullArgName] = mappedValue;\n      delete result[mappedKey];\n    }\n  }\n\n  return result;\n}\n\ninterface ParseArgsContext {\n  flags?: Record<string, string>;\n  aliases?: Record<string, string>;\n  stdinData?: Record<string, unknown>;\n  envData?: Record<string, unknown>;\n  configData?: Record<string, unknown>;\n}\n\n/**\n * Apply values directly to arguments.\n * CLI values take precedence over the provided values.\n */\nfunction applyValues(data: Record<string, unknown>, values: Record<string, unknown>): Record<string, unknown> {\n  const result = { ...data };\n\n  for (const [key, value] of Object.entries(values)) {\n    // Only apply value if arg wasn't already set\n    if (key in result && result[key] !== undefined) continue;\n    if (value !== undefined) {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Combined preprocessing of arguments with all features.\n * Precedence order (highest to lowest): CLI args > stdin > env vars > config file\n */\nexport function preprocessArgs(data: Record<string, unknown>, ctx: ParseArgsContext): Record<string, unknown> {\n  let result = { ...data };\n\n  // 1. Apply flags and aliases first\n  if (ctx.flags && Object.keys(ctx.flags).length > 0) {\n    result = preprocessMappings(result, ctx.flags);\n  }\n  if (ctx.aliases && Object.keys(ctx.aliases).length > 0) {\n    result = preprocessMappings(result, ctx.aliases);\n  }\n\n  // 2. Apply stdin data (higher precedence than env)\n  // Only applies if CLI didn't set the arg\n  if (ctx.stdinData) {\n    result = applyValues(result, ctx.stdinData);\n  }\n\n  // 3. Apply environment variables (higher precedence than config)\n  // These only apply if CLI/stdin didn't set the arg\n  if (ctx.envData) {\n    result = applyValues(result, ctx.envData);\n  }\n\n  // 4. Apply config file values (lowest precedence)\n  // These only apply if neither CLI, stdin, nor env set the arg\n  if (ctx.configData) {\n    result = applyValues(result, ctx.configData);\n  }\n\n  return result;\n}\n\n/**\n * Auto-coerce CLI string values to match the expected schema types.\n * Handles: string → number, string → boolean for primitive schema fields.\n * Arrays of primitives are also coerced element-wise.\n */\nexport function coerceArgs(data: Record<string, unknown>, schema: StandardJSONSchemaV1): Record<string, unknown> {\n  let properties: Record<string, any>;\n  try {\n    const jsonSchema = schema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;\n    if (jsonSchema.type !== 'object' || !jsonSchema.properties) return data;\n    properties = jsonSchema.properties;\n  } catch {\n    return data;\n  }\n\n  const result = { ...data };\n\n  for (const [key, value] of Object.entries(result)) {\n    const prop = properties[key];\n    if (!prop) continue;\n\n    const targetType = prop.type as string | undefined;\n\n    if (targetType === 'number' || targetType === 'integer') {\n      if (typeof value === 'string') {\n        const num = Number(value);\n        if (!Number.isNaN(num)) result[key] = num;\n      }\n    } else if (targetType === 'boolean') {\n      if (typeof value === 'string') {\n        if (value === 'true' || value === '1') result[key] = true;\n        else if (value === 'false' || value === '0') result[key] = false;\n      }\n    } else if (targetType === 'array' && Array.isArray(value)) {\n      const itemType = prop.items?.type as string | undefined;\n      if (itemType === 'number' || itemType === 'integer') {\n        result[key] = value.map((v) => {\n          if (typeof v === 'string') {\n            const num = Number(v);\n            return Number.isNaN(num) ? v : num;\n          }\n          return v;\n        });\n      } else if (itemType === 'boolean') {\n        result[key] = value.map((v) => {\n          if (typeof v === 'string') {\n            if (v === 'true' || v === '1') return true;\n            if (v === 'false' || v === '0') return false;\n          }\n          return v;\n        });\n      }\n    }\n  }\n\n  return result;\n}\n\n/** Keys consumed by the CLI framework that are not user-defined args. */\nconst frameworkReservedKeys = new Set(['config', 'c']);\n\n/**\n * Detect unknown keys in the args that don't match any schema property.\n * Returns an array of { key, suggestion? } for each unknown key.\n * Framework-reserved keys (--config, -c) are always allowed.\n */\nexport function detectUnknownArgs(\n  data: Record<string, unknown>,\n  schema: StandardJSONSchemaV1,\n  flags: Record<string, string>,\n  aliases: Record<string, string>,\n  suggestFn: (input: string, candidates: string[]) => string,\n): { key: string; suggestion: string }[] {\n  let properties: Record<string, any>;\n  let isLoose = false;\n  try {\n    const jsonSchema = schema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;\n    if (jsonSchema.type !== 'object' || !jsonSchema.properties) return [];\n    properties = jsonSchema.properties;\n    // If additionalProperties is set (true, {}, or a schema), the schema allows extra keys\n    if (jsonSchema.additionalProperties !== undefined && jsonSchema.additionalProperties !== false) isLoose = true;\n  } catch {\n    return [];\n  }\n\n  if (isLoose) return [];\n\n  const knownKeys = new Set<string>([\n    ...Object.keys(properties),\n    ...Object.keys(flags),\n    ...Object.values(flags),\n    ...Object.keys(aliases),\n    ...Object.values(aliases),\n  ]);\n  const propertyNames = Object.keys(properties);\n  const unknowns: { key: string; suggestion: string }[] = [];\n\n  for (const key of Object.keys(data)) {\n    if (!knownKeys.has(key) && !frameworkReservedKeys.has(key)) {\n      const suggestion = suggestFn(key, propertyNames);\n      unknowns.push({ key, suggestion });\n    }\n  }\n\n  return unknowns;\n}\n"],"mappings":";;;;;AAsKA,SAAgB,aAAa,KAA4B;AACvD,KAAI,CAAC,QAAQ,KAAK,IAAI,CAAE,QAAO;AAC/B,QAAO,IAAI,QAAQ,WAAW,OAAO,IAAI,GAAG,aAAa,GAAG;;;;;AAM9D,SAAgB,iBAAiB,OAA6D;AAC5F,KAAI,OAAO,UAAU,SAAU,QAAO;EAAE,OAAO;EAAO,IAAI;EAAQ;AAClE,QAAO;EAAE,OAAO,MAAM;EAAiB,IAAI,MAAM,MAAM;EAAQ;;;;;AAMjE,SAAgB,sBAAsB,YAA6D;AACjG,QAAO,WAAW,KAAK,MAAM;EAC3B,MAAM,aAAa,EAAE,WAAW,MAAM;AAEtC,SAAO;GAAE,MADI,aAAa,EAAE,MAAM,EAAE,GAAG;GACxB,UAAU;GAAY;GACrC;;AAaJ,SAAS,WAAW,QAAgC,KAAa,OAA0B,QAAoC;CAC7H,MAAM,OAAO,OAAO,UAAU,WAAW,CAAC,MAAM,GAAG;AACnD,MAAK,MAAM,QAAQ,KACjB,KAAI,OAAO,SAAS,YAAY,QAAQ,SAAS,OAAO,EAAE,QAAQ,YAAY,CAAC,UAAU,OAAO,KAAK,EACnG,QAAO,QAAQ;;;;;;;AAUrB,SAAgB,sBACd,QACA,MACA,WACsB;CACtB,MAAM,QAAgC,EAAE;CACxC,MAAM,UAAkC,EAAE;AAG1C,KAAI,KACF,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,EAAE;AAC/C,MAAI,CAAC,MAAO;AAEZ,MAAI,MAAM,MACR,YAAW,OAAO,KAAK,MAAM,QAAQ,SAAS,KAAK,WAAW,EAAE;AAElE,MAAI,MAAM,MACR,YAAW,SAAS,KAAK,MAAM,QAAQ,SAAS,KAAK,SAAS,EAAE;;AAMtE,KAAI;EACF,MAAM,aAAa,OAAO,aAAa,WAAW,MAAM,EAAE,QAAQ,iBAAiB,CAAC;AACpF,MAAI,WAAW,SAAS,YAAY,WAAW,WAC7C,MAAK,MAAM,CAAC,cAAc,mBAAmB,OAAO,QAAQ,WAAW,WAAkC,EAAE;AACzG,OAAI,CAAC,eAAgB;GAGrB,MAAM,YAAY,eAAe;AACjC,OAAI,UACF,YAAW,OAAO,cAAc,YAAY,SAAS,KAAK,WAAW,EAAE;GAIzE,MAAM,YAAY,eAAe;AACjC,OAAI,WAAW;IACb,MAAM,OAAO,OAAO,cAAc,WAAW,CAAC,UAAU,GAAG;AAC3D,QAAI,MAAM,QAAQ,KAAK,CACrB,YAAW,SAAS,cAAc,OAAO,SAAS,KAAK,SAAS,EAAE;;AAKtE,OAAI,cAAc,OAAO;IACvB,MAAM,QAAQ,aAAa,aAAa;AACxC,QAAI,SAAS,EAAE,SAAS,SACtB,SAAQ,SAAS;;;SAKnB;AAIR,QAAO;EAAE;EAAO;EAAS;;AAG3B,SAAS,mBAAmB,MAA+B,UAA2D;CACpH,MAAM,SAAS,EAAE,GAAG,MAAM;AAE1B,MAAK,MAAM,CAAC,WAAW,gBAAgB,OAAO,QAAQ,SAAS,CAC7D,KAAI,aAAa,QAAQ,cAAc,aAAa;EAClD,MAAM,cAAc,KAAK;AAEzB,MAAI,EAAE,eAAe,QAAS,QAAO,eAAe;AACpD,SAAO,OAAO;;AAIlB,QAAO;;;;;;AAeT,SAAS,YAAY,MAA+B,QAA0D;CAC5G,MAAM,SAAS,EAAE,GAAG,MAAM;AAE1B,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,EAAE;AAEjD,MAAI,OAAO,UAAU,OAAO,SAAS,KAAA,EAAW;AAChD,MAAI,UAAU,KAAA,EACZ,QAAO,OAAO;;AAIlB,QAAO;;;;;;AAOT,SAAgB,eAAe,MAA+B,KAAgD;CAC5G,IAAI,SAAS,EAAE,GAAG,MAAM;AAGxB,KAAI,IAAI,SAAS,OAAO,KAAK,IAAI,MAAM,CAAC,SAAS,EAC/C,UAAS,mBAAmB,QAAQ,IAAI,MAAM;AAEhD,KAAI,IAAI,WAAW,OAAO,KAAK,IAAI,QAAQ,CAAC,SAAS,EACnD,UAAS,mBAAmB,QAAQ,IAAI,QAAQ;AAKlD,KAAI,IAAI,UACN,UAAS,YAAY,QAAQ,IAAI,UAAU;AAK7C,KAAI,IAAI,QACN,UAAS,YAAY,QAAQ,IAAI,QAAQ;AAK3C,KAAI,IAAI,WACN,UAAS,YAAY,QAAQ,IAAI,WAAW;AAG9C,QAAO;;;;;;;AAQT,SAAgB,WAAW,MAA+B,QAAuD;CAC/G,IAAI;AACJ,KAAI;EACF,MAAM,aAAa,OAAO,aAAa,WAAW,MAAM,EAAE,QAAQ,iBAAiB,CAAC;AACpF,MAAI,WAAW,SAAS,YAAY,CAAC,WAAW,WAAY,QAAO;AACnE,eAAa,WAAW;SAClB;AACN,SAAO;;CAGT,MAAM,SAAS,EAAE,GAAG,MAAM;AAE1B,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,EAAE;EACjD,MAAM,OAAO,WAAW;AACxB,MAAI,CAAC,KAAM;EAEX,MAAM,aAAa,KAAK;AAExB,MAAI,eAAe,YAAY,eAAe;OACxC,OAAO,UAAU,UAAU;IAC7B,MAAM,MAAM,OAAO,MAAM;AACzB,QAAI,CAAC,OAAO,MAAM,IAAI,CAAE,QAAO,OAAO;;aAE/B,eAAe;OACpB,OAAO,UAAU;QACf,UAAU,UAAU,UAAU,IAAK,QAAO,OAAO;aAC5C,UAAU,WAAW,UAAU,IAAK,QAAO,OAAO;;aAEpD,eAAe,WAAW,MAAM,QAAQ,MAAM,EAAE;GACzD,MAAM,WAAW,KAAK,OAAO;AAC7B,OAAI,aAAa,YAAY,aAAa,UACxC,QAAO,OAAO,MAAM,KAAK,MAAM;AAC7B,QAAI,OAAO,MAAM,UAAU;KACzB,MAAM,MAAM,OAAO,EAAE;AACrB,YAAO,OAAO,MAAM,IAAI,GAAG,IAAI;;AAEjC,WAAO;KACP;YACO,aAAa,UACtB,QAAO,OAAO,MAAM,KAAK,MAAM;AAC7B,QAAI,OAAO,MAAM,UAAU;AACzB,SAAI,MAAM,UAAU,MAAM,IAAK,QAAO;AACtC,SAAI,MAAM,WAAW,MAAM,IAAK,QAAO;;AAEzC,WAAO;KACP;;;AAKR,QAAO;;;AAIT,MAAM,wBAAwB,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC;;;;;;AAOtD,SAAgB,kBACd,MACA,QACA,OACA,SACA,WACuC;CACvC,IAAI;CACJ,IAAI,UAAU;AACd,KAAI;EACF,MAAM,aAAa,OAAO,aAAa,WAAW,MAAM,EAAE,QAAQ,iBAAiB,CAAC;AACpF,MAAI,WAAW,SAAS,YAAY,CAAC,WAAW,WAAY,QAAO,EAAE;AACrE,eAAa,WAAW;AAExB,MAAI,WAAW,yBAAyB,KAAA,KAAa,WAAW,yBAAyB,MAAO,WAAU;SACpG;AACN,SAAO,EAAE;;AAGX,KAAI,QAAS,QAAO,EAAE;CAEtB,MAAM,YAAY,IAAI,IAAY;EAChC,GAAG,OAAO,KAAK,WAAW;EAC1B,GAAG,OAAO,KAAK,MAAM;EACrB,GAAG,OAAO,OAAO,MAAM;EACvB,GAAG,OAAO,KAAK,QAAQ;EACvB,GAAG,OAAO,OAAO,QAAQ;EAC1B,CAAC;CACF,MAAM,gBAAgB,OAAO,KAAK,WAAW;CAC7C,MAAM,WAAkD,EAAE;AAE1D,MAAK,MAAM,OAAO,OAAO,KAAK,KAAK,CACjC,KAAI,CAAC,UAAU,IAAI,IAAI,IAAI,CAAC,sBAAsB,IAAI,IAAI,EAAE;EAC1D,MAAM,aAAa,UAAU,KAAK,cAAc;AAChD,WAAS,KAAK;GAAE;GAAK;GAAY,CAAC;;AAItC,QAAO"}

package/dist/chunk-y_GBKt04.mjs

@@ -1,5 +0,0 @@
-import { createRequire } from "node:module";
-//#region \0rolldown/runtime.js
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
-export { __require as t };

package/dist/formatter-XroimS3Q.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatter-XroimS3Q.d.mts","names":[],"sources":["../src/formatter.ts"],"mappings":";KAGY,UAAA;AAAA,KACA,UAAA;;;;KASA,kBAAA;EACV,IAAA;EACA,WAAA;EACA,QAAA;EACA,OAAA;EACA,IAAA;AAAA;;;;KAMU,gBAAA;EACV,IAAA;EACA,WAAA;EACA,QAAA;EACA,OAAA;EACA,IAAA;EACA,IAAA,aANU;EAQV,KAAA;EAEA,OAAA;EACA,UAAA;EACA,MAAA;EACA,QAAA,cATA;EAWA,GAAA,sBATA;EAWA,QAAA,YAPA;EASA,SAAA,YAPA;EASA,SAAA;AAAA;;;;KAMU,kBAAA;EACV,IAAA;EACA,KAAA;EACA,WAAA;EACA,OAAA;EACA,UAAA;EACA,MAAA;EACA,cAAA;AAAA;;;;KAMU,eAAA;EACV,IAAA;EACA,WAAA;EACA,GAAA;IAAQ,IAAA;IAAc,WAAA;EAAA;AAAA;;;;;KAOZ,QAAA;EAPuB,4DASjC,IAAA,UAFkB;EAIlB,KAAA,WAmBc;EAjBd,WAAA,WAqBY;EAnBZ,OAAA,aAuBiB;EArBjB,UAAA,qBAqByB;EAnBzB,MAAA,YARA;EAUA,KAAA;IACE,OAAA;IACA,cAAA;IACA,cAAA;IACA,YAAA,WAHA;IAKA,UAAA;EAAA,GAFA;EAKF,WAAA,GAAc,kBAAA,IAAd;EAEA,WAAA,GAAc,kBAAA,IAAd;EAEA,SAAA,GAAY,gBAAA,IAAZ;EAEA,QAAA,GAAW,eAAA,IAAX;EAEA,cAAA,GAAiB,QAAA;AAAA"}