payload 4.0.0-internal.2fddfc0 → 4.0.0-internal.31ba7ee

package/dist/cli/program/normalizeHelpArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/program/normalizeHelpArguments.ts"],"sourcesContent":["import type { Command } from 'commander'\n\n/**\n * Sends both help syntaxes through Payload's `help` command.\n *\n * For example, `payload info --help --json` becomes\n * `payload help info --json`, so both forms use the same handler and output.\n */\nexport const normalizeHelpArguments = ({\n  args,\n  cli,\n}: {\n  args: string[]\n  cli: Command\n}): string[] => {\n  // Arguments after `--` belong to the program called by the Payload command.\n  // For example, `payload build -- --help` must show the framework's help,\n  // while `payload build --help` must show Payload's build-command help.\n  const separatorPosition = args.indexOf('--', 2)\n  const payloadArguments = args.slice(2, separatorPosition === -1 ? args.length : separatorPosition)\n\n  if (!payloadArguments.includes('--help') && !payloadArguments.includes('-h')) {\n    return args\n  }\n\n  const selectedCommand = payloadArguments\n    .map((argument) =>\n      cli.commands.find(\n        (command) => command.name() === argument || command.aliases().includes(argument),\n      ),\n    )\n    .find((command) => command !== undefined)\n\n  if (selectedCommand?.name() === 'help') {\n    return args\n  }\n\n  const [executable, script] = args\n\n  if (!executable || !script) {\n    return args\n  }\n\n  return [\n    executable,\n    script,\n    'help',\n    ...(selectedCommand ? [selectedCommand.name()] : []),\n    ...payloadArguments.filter((argument) => argument === '--json' || argument === '--no-json'),\n  ]\n}\n"],"names":["normalizeHelpArguments","args","cli","separatorPosition","indexOf","payloadArguments","slice","length","includes","selectedCommand","map","argument","commands","find","command","name","aliases","undefined","executable","script","filter"],"mappings":"AAEA;;;;;CAKC,GACD,OAAO,MAAMA,yBAAyB,CAAC,EACrCC,IAAI,EACJC,GAAG,EAIJ;IACC,4EAA4E;IAC5E,yEAAyE;IACzE,uEAAuE;IACvE,MAAMC,oBAAoBF,KAAKG,OAAO,CAAC,MAAM;IAC7C,MAAMC,mBAAmBJ,KAAKK,KAAK,CAAC,GAAGH,sBAAsB,CAAC,IAAIF,KAAKM,MAAM,GAAGJ;IAEhF,IAAI,CAACE,iBAAiBG,QAAQ,CAAC,aAAa,CAACH,iBAAiBG,QAAQ,CAAC,OAAO;QAC5E,OAAOP;IACT;IAEA,MAAMQ,kBAAkBJ,iBACrBK,GAAG,CAAC,CAACC,WACJT,IAAIU,QAAQ,CAACC,IAAI,CACf,CAACC,UAAYA,QAAQC,IAAI,OAAOJ,YAAYG,QAAQE,OAAO,GAAGR,QAAQ,CAACG,YAG1EE,IAAI,CAAC,CAACC,UAAYA,YAAYG;IAEjC,IAAIR,iBAAiBM,WAAW,QAAQ;QACtC,OAAOd;IACT;IAEA,MAAM,CAACiB,YAAYC,OAAO,GAAGlB;IAE7B,IAAI,CAACiB,cAAc,CAACC,QAAQ;QAC1B,OAAOlB;IACT;IAEA,OAAO;QACLiB;QACAC;QACA;WACIV,kBAAkB;YAACA,gBAAgBM,IAAI;SAAG,GAAG,EAAE;WAChDV,iBAAiBe,MAAM,CAAC,CAACT,WAAaA,aAAa,YAAYA,aAAa;KAChF;AACH,EAAC"}

package/dist/cli/program/registerCommand.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import type { CLICommand, CLIHelp, CLIRuntime } from '../../config/types.js';
+export declare const registerCLICommand: ({ name, cli, definition, help, runtime, }: {
+    cli: Command;
+    definition: CLICommand;
+    help: CLIHelp;
+    name: string;
+    runtime: CLIRuntime;
+}) => void;
+//# sourceMappingURL=registerCommand.d.ts.map

package/dist/cli/program/registerCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerCommand.d.ts","sourceRoot":"","sources":["../../../src/cli/program/registerCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,OAAO,EAAU,MAAM,WAAW,CAAA;AAErD,OAAO,KAAK,EAAE,UAAU,EAAoB,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAK9F,eAAO,MAAM,kBAAkB,8CAM5B;IACD,GAAG,EAAE,OAAO,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,UAAU,CAAA;CACpB,KAAG,IA0BH,CAAA"}

package/dist/cli/program/registerCommand.js

@@ -0,0 +1,185 @@
+import { Argument, Command, Option } from 'commander';
+import { toKebabCase } from '../../utilities/toKebabCase.js';
+import { invokeCLICommand } from '../runtime/invokeCommand.js';
+export const registerCLICommand = ({ name, cli, definition, help, runtime })=>{
+    const command = new Command(name).description(definition.description).aliases(definition.aliases ?? []).allowUnknownOption(definition.allowUnknownOption);
+    if (definition.helpGroup) {
+        command.helpGroup(definition.helpGroup);
+    }
+    addCommandInput({
+        command,
+        definition
+    });
+    if (definition.examples?.length) {
+        command.addHelpText('after', `\nExamples:\n${definition.examples.map((example)=>`  ${example}`).join('\n')}`);
+    }
+    command.action(()=>invokeCLICommand({
+            command,
+            definition,
+            help,
+            runtime
+        }));
+    // Let our runtime format the error and clean up Payload instead of exiting immediately.
+    command.exitOverride();
+    // Register the completed command with the root CLI.
+    cli.addCommand(command);
+};
+/**
+ * Turns a command definition's schema and CLI overrides into Commander inputs.
+ *
+ * For example:
+ *
+ * ```ts
+ * defineCLICommand({
+ *   description: 'Import a file.',
+ *   input: z.object({
+ *     file: z.string(),
+ *     force: z.optional(z.boolean()),
+ *   }),
+ *   cli: { file: 'argument' },
+ *   handler: ({ args }) => importFile(args),
+ * })
+ * ```
+ *
+ * registers `[file]`, `--force`, and the shared `--input <json|@file|->` option.
+ * This helper also:
+ *
+ * - infers parsers, descriptions, choices, required fields, and defaults from the schema
+ * - applies overrides such as positional arguments and custom flags
+ * - keeps positional arguments optional in Commander because `--input` may supply
+ *   them; the schema still checks whether they are required
+ */ const addCommandInput = ({ command, definition })=>{
+    const properties = definition.schema.properties ?? {};
+    const requiredFields = new Set(Array.isArray(definition.schema.required) ? definition.schema.required : []);
+    const overrides = definition.cli === false ? {} : definition.cli;
+    if (definition.cli !== false) {
+        const argumentOverrides = Object.entries(overrides).filter(([, override])=>isArgumentOverride(override)).sort(([, first], [, second])=>{
+            const firstPosition = getArgumentPosition(first);
+            const secondPosition = getArgumentPosition(second);
+            return (firstPosition ?? Number.MAX_SAFE_INTEGER) - (secondPosition ?? Number.MAX_SAFE_INTEGER);
+        });
+        for (const [field, override] of argumentOverrides){
+            const argumentOverride = typeof override === 'object' && override.type === 'argument' ? override : undefined;
+            const property = properties[field];
+            const isArray = property.type === 'array';
+            const argument = new Argument(argumentOverride?.syntax ?? `[${field}${isArray ? '...' : ''}]`, getInputDescription({
+                isRequired: requiredFields.has(field),
+                property
+            }));
+            const parser = argumentOverride?.parse ?? getInferredParser({
+                property
+            });
+            if (parser) {
+                argument.argParser(parser);
+            }
+            addChoices({
+                argument,
+                property
+            });
+            command.addArgument(argument);
+        }
+        const options = Object.entries(properties).sort(([firstField], [secondField])=>Number(requiredFields.has(secondField)) - Number(requiredFields.has(firstField)));
+        for (const [field, property] of options){
+            const override = overrides[field];
+            if (override === false || isArgumentOverride(override)) {
+                continue;
+            }
+            const optionOverride = typeof override === 'object' ? override : undefined;
+            const flags = optionOverride?.flags ?? getInferredOptionFlags({
+                field,
+                property
+            });
+            const option = new CLIInputOption(flags, getInputDescription({
+                isRequired: requiredFields.has(field),
+                property
+            }), field);
+            const parser = optionOverride?.parse ?? getInferredParser({
+                property
+            });
+            if (parser) {
+                option.argParser(parser);
+            }
+            addChoices({
+                argument: option,
+                property
+            });
+            command.addOption(option);
+        }
+    }
+    const reservedOption = command.options.find((option)=>[
+            'input',
+            'json'
+        ].includes(option.attributeName()));
+    if (reservedOption) {
+        throw new Error(`CLI command '${command.name()}' cannot register the reserved '--${reservedOption.attributeName()}' option.`);
+    }
+    for (const argument of command.registeredArguments){
+        argument.argOptional();
+    }
+    command.addOption(new Option('--input <json|@file|->', 'Pass base command input as JSON, from a file, or from stdin; explicit arguments and options override it.'));
+};
+const getInputDescription = ({ isRequired, property })=>{
+    const description = typeof property.description === 'string' ? property.description : '';
+    const annotations = [
+        isRequired ? '(required)' : '',
+        'default' in property ? `(default: ${JSON.stringify(property.default)})` : ''
+    ].filter(Boolean);
+    return [
+        description,
+        ...annotations
+    ].filter(Boolean).join(' ');
+};
+/** Keeps a custom flag such as `--file` mapped to its schema field, such as `filePath`. */ class CLIInputOption extends Option {
+    inputField;
+    constructor(flags, description, inputField){
+        super(flags, description), this.inputField = inputField;
+    }
+    attributeName() {
+        return this.inputField;
+    }
+}
+/**
+ * Checks whether a CLI override makes a schema field positional.
+ *
+ * For example, both `'argument'` and `{ type: 'argument', position: 1 }` return
+ * `true`, while an option override or `undefined` returns `false`.
+ */ const isArgumentOverride = (override)=>override === 'argument' || typeof override === 'object' && override !== null && override.type === 'argument';
+const getArgumentPosition = (override)=>typeof override === 'object' && override !== null && override.type === 'argument' ? override.position : undefined;
+const addChoices = ({ argument, property })=>{
+    const choices = property.enum;
+    if (Array.isArray(choices) && choices.every((choice)=>typeof choice === 'string')) {
+        argument.choices(choices);
+    }
+};
+const getInferredOptionFlags = ({ field, property })=>{
+    const flag = toKebabCase(field) ?? field;
+    if (property.type === 'boolean') {
+        return property.default === true ? `--no-${flag}` : `--${flag}`;
+    }
+    if (property.type === 'array') {
+        const items = property.items;
+        if (items?.type === 'integer' || items?.type === 'number' || items?.type === 'string') {
+            return `--${flag} <${field}...>`;
+        }
+    }
+    if (property.type === 'integer' || property.type === 'number') {
+        return `--${flag} <number>`;
+    }
+    if (property.type === 'string') {
+        return `--${flag} <${field}>`;
+    }
+    throw new Error(`Cannot infer a CLI option for input '${field}'. Configure its flags and parser, or set it to false.`);
+};
+const getInferredParser = ({ property })=>{
+    if (property.type === 'integer' || property.type === 'number') {
+        return Number;
+    }
+    if (property.type === 'array') {
+        const items = property.items;
+        if (items?.type === 'integer' || items?.type === 'number') {
+            return Number;
+        }
+    }
+};
+
+//# sourceMappingURL=registerCommand.js.map

package/dist/cli/program/registerCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/program/registerCommand.ts"],"sourcesContent":["import { Argument, Command, Option } from 'commander'\n\nimport type { CLICommand, CLIFieldOverride, CLIHelp, CLIRuntime } from '../../config/types.js'\n\nimport { toKebabCase } from '../../utilities/toKebabCase.js'\nimport { invokeCLICommand } from '../runtime/invokeCommand.js'\n\nexport const registerCLICommand = ({\n  name,\n  cli,\n  definition,\n  help,\n  runtime,\n}: {\n  cli: Command\n  definition: CLICommand\n  help: CLIHelp\n  name: string\n  runtime: CLIRuntime\n}): void => {\n  const command = new Command(name)\n    .description(definition.description)\n    .aliases(definition.aliases ?? [])\n    .allowUnknownOption(definition.allowUnknownOption)\n\n  if (definition.helpGroup) {\n    command.helpGroup(definition.helpGroup)\n  }\n\n  addCommandInput({ command, definition })\n\n  if (definition.examples?.length) {\n    command.addHelpText(\n      'after',\n      `\\nExamples:\\n${definition.examples.map((example) => `  ${example}`).join('\\n')}`,\n    )\n  }\n\n  command.action(() => invokeCLICommand({ command, definition, help, runtime }))\n\n  // Let our runtime format the error and clean up Payload instead of exiting immediately.\n  command.exitOverride()\n\n  // Register the completed command with the root CLI.\n  cli.addCommand(command)\n}\n\n/**\n * Turns a command definition's schema and CLI overrides into Commander inputs.\n *\n * For example:\n *\n * ```ts\n * defineCLICommand({\n *   description: 'Import a file.',\n *   input: z.object({\n *     file: z.string(),\n *     force: z.optional(z.boolean()),\n *   }),\n *   cli: { file: 'argument' },\n *   handler: ({ args }) => importFile(args),\n * })\n * ```\n *\n * registers `[file]`, `--force`, and the shared `--input <json|@file|->` option.\n * This helper also:\n *\n * - infers parsers, descriptions, choices, required fields, and defaults from the schema\n * - applies overrides such as positional arguments and custom flags\n * - keeps positional arguments optional in Commander because `--input` may supply\n *   them; the schema still checks whether they are required\n */\nconst addCommandInput = ({\n  command,\n  definition,\n}: {\n  command: Command\n  definition: CLICommand\n}): void => {\n  const properties = (definition.schema.properties ?? {}) as Record<string, Record<string, unknown>>\n  const requiredFields = new Set(\n    Array.isArray(definition.schema.required) ? definition.schema.required : [],\n  )\n  const overrides = definition.cli === false ? {} : definition.cli\n\n  if (definition.cli !== false) {\n    const argumentOverrides = Object.entries(overrides)\n      .filter(([, override]) => isArgumentOverride(override))\n      .sort(([, first], [, second]) => {\n        const firstPosition = getArgumentPosition(first)\n        const secondPosition = getArgumentPosition(second)\n\n        return (\n          (firstPosition ?? Number.MAX_SAFE_INTEGER) - (secondPosition ?? Number.MAX_SAFE_INTEGER)\n        )\n      })\n\n    for (const [field, override] of argumentOverrides) {\n      const argumentOverride =\n        typeof override === 'object' && override.type === 'argument' ? override : undefined\n      const property = properties[field]!\n      const isArray = property.type === 'array'\n      const argument = new Argument(\n        argumentOverride?.syntax ?? `[${field}${isArray ? '...' : ''}]`,\n        getInputDescription({ isRequired: requiredFields.has(field), property }),\n      )\n      const parser = argumentOverride?.parse ?? getInferredParser({ property })\n\n      if (parser) {\n        argument.argParser(parser)\n      }\n\n      addChoices({ argument, property })\n      command.addArgument(argument)\n    }\n\n    const options = Object.entries(properties).sort(\n      ([firstField], [secondField]) =>\n        Number(requiredFields.has(secondField)) - Number(requiredFields.has(firstField)),\n    )\n\n    for (const [field, property] of options) {\n      const override = overrides[field]\n\n      if (override === false || isArgumentOverride(override)) {\n        continue\n      }\n\n      const optionOverride = typeof override === 'object' ? override : undefined\n      const flags = optionOverride?.flags ?? getInferredOptionFlags({ field, property })\n      const option = new CLIInputOption(\n        flags,\n        getInputDescription({ isRequired: requiredFields.has(field), property }),\n        field,\n      )\n      const parser = optionOverride?.parse ?? getInferredParser({ property })\n\n      if (parser) {\n        option.argParser(parser)\n      }\n\n      addChoices({ argument: option, property })\n      command.addOption(option)\n    }\n  }\n\n  const reservedOption = command.options.find((option) =>\n    ['input', 'json'].includes(option.attributeName()),\n  )\n\n  if (reservedOption) {\n    throw new Error(\n      `CLI command '${command.name()}' cannot register the reserved '--${reservedOption.attributeName()}' option.`,\n    )\n  }\n\n  for (const argument of command.registeredArguments) {\n    argument.argOptional()\n  }\n\n  command.addOption(\n    new Option(\n      '--input <json|@file|->',\n      'Pass base command input as JSON, from a file, or from stdin; explicit arguments and options override it.',\n    ),\n  )\n}\n\nconst getInputDescription = ({\n  isRequired,\n  property,\n}: {\n  isRequired: boolean\n  property: Record<string, unknown>\n}): string => {\n  const description = typeof property.description === 'string' ? property.description : ''\n  const annotations = [\n    isRequired ? '(required)' : '',\n    'default' in property ? `(default: ${JSON.stringify(property.default)})` : '',\n  ].filter(Boolean)\n\n  return [description, ...annotations].filter(Boolean).join(' ')\n}\n\n/** Keeps a custom flag such as `--file` mapped to its schema field, such as `filePath`. */\nclass CLIInputOption extends Option {\n  constructor(\n    flags: string,\n    description: string,\n    private readonly inputField: string,\n  ) {\n    super(flags, description)\n  }\n\n  override attributeName(): string {\n    return this.inputField\n  }\n}\n\n/**\n * Checks whether a CLI override makes a schema field positional.\n *\n * For example, both `'argument'` and `{ type: 'argument', position: 1 }` return\n * `true`, while an option override or `undefined` returns `false`.\n */\nconst isArgumentOverride = (\n  override: CLIFieldOverride | undefined,\n): override is\n  | 'argument'\n  | {\n      parse?: (value: string, previous: unknown) => unknown\n      position?: number\n      syntax?: string\n      type: 'argument'\n    } =>\n  override === 'argument' ||\n  (typeof override === 'object' && override !== null && override.type === 'argument')\n\nconst getArgumentPosition = (override: CLIFieldOverride | undefined): number | undefined =>\n  typeof override === 'object' && override !== null && override.type === 'argument'\n    ? override.position\n    : undefined\n\nconst addChoices = ({\n  argument,\n  property,\n}: {\n  argument: Argument | Option\n  property: Record<string, unknown>\n}): void => {\n  const choices = property.enum\n\n  if (\n    Array.isArray(choices) &&\n    choices.every((choice): choice is string => typeof choice === 'string')\n  ) {\n    argument.choices(choices)\n  }\n}\n\nconst getInferredOptionFlags = ({\n  field,\n  property,\n}: {\n  field: string\n  property: Record<string, unknown>\n}): string => {\n  const flag = toKebabCase(field) ?? field\n\n  if (property.type === 'boolean') {\n    return property.default === true ? `--no-${flag}` : `--${flag}`\n  }\n\n  if (property.type === 'array') {\n    const items = property.items as Record<string, unknown> | undefined\n\n    if (items?.type === 'integer' || items?.type === 'number' || items?.type === 'string') {\n      return `--${flag} <${field}...>`\n    }\n  }\n\n  if (property.type === 'integer' || property.type === 'number') {\n    return `--${flag} <number>`\n  }\n\n  if (property.type === 'string') {\n    return `--${flag} <${field}>`\n  }\n\n  throw new Error(\n    `Cannot infer a CLI option for input '${field}'. Configure its flags and parser, or set it to false.`,\n  )\n}\n\nconst getInferredParser = ({\n  property,\n}: {\n  property: Record<string, unknown>\n}): ((value: string) => unknown) | undefined => {\n  if (property.type === 'integer' || property.type === 'number') {\n    return Number\n  }\n\n  if (property.type === 'array') {\n    const items = property.items as Record<string, unknown> | undefined\n\n    if (items?.type === 'integer' || items?.type === 'number') {\n      return Number\n    }\n  }\n}\n"],"names":["Argument","Command","Option","toKebabCase","invokeCLICommand","registerCLICommand","name","cli","definition","help","runtime","command","description","aliases","allowUnknownOption","helpGroup","addCommandInput","examples","length","addHelpText","map","example","join","action","exitOverride","addCommand","properties","schema","requiredFields","Set","Array","isArray","required","overrides","argumentOverrides","Object","entries","filter","override","isArgumentOverride","sort","first","second","firstPosition","getArgumentPosition","secondPosition","Number","MAX_SAFE_INTEGER","field","argumentOverride","type","undefined","property","argument","syntax","getInputDescription","isRequired","has","parser","parse","getInferredParser","argParser","addChoices","addArgument","options","firstField","secondField","optionOverride","flags","getInferredOptionFlags","option","CLIInputOption","addOption","reservedOption","find","includes","attributeName","Error","registeredArguments","argOptional","annotations","JSON","stringify","default","Boolean","inputField","position","choices","enum","every","choice","flag","items"],"mappings":"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"}

package/dist/cli/runtime/createRuntime.d.ts

@@ -0,0 +1,9 @@
+import type { CLIRuntime } from '../../config/types.js';
+/**
+ * Creates the shared resources used by the CLI.
+ *
+ * The config is loaded once, and any Payload instance opened by a command is tracked
+ * so the CLI can close it before exiting.
+ */
+export declare const createCLIRuntime: () => CLIRuntime;
+//# sourceMappingURL=createRuntime.d.ts.map

package/dist/cli/runtime/createRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRuntime.d.ts","sourceRoot":"","sources":["../../../src/cli/runtime/createRuntime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,uBAAuB,CAAA;AAMxE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAAO,UA6DnC,CAAA"}

package/dist/cli/runtime/createRuntime.js

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { findConfig } from '../../config/find.js';
+import { getPayload } from '../../index.js';
+/**
+ * Creates the shared resources used by the CLI.
+ *
+ * The config is loaded once, and any Payload instance opened by a command is tracked
+ * so the CLI can close it before exiting.
+ */ export const createCLIRuntime = ()=>{
+    let activePayload;
+    let configPromise;
+    let isScheduled = false;
+    const configPath = findConfig();
+    const getConfig = ()=>{
+        configPromise ??= (async ()=>{
+            const importedConfig = await import(pathToFileURL(configPath).toString());
+            const config = importedConfig.default ? await importedConfig.default : importedConfig;
+            return config;
+        })();
+        return configPromise;
+    };
+    const runtime = {
+        configDir: path.dirname(configPath),
+        async destroy () {
+            if (!activePayload) {
+                return;
+            }
+            const payload = activePayload;
+            activePayload = undefined;
+            await payload.destroy();
+        },
+        getConfig,
+        async getPayload (options = {}) {
+            const config = await getConfig();
+            const configuredLogger = config.logger;
+            const shouldRedirectLogger = process.env.PAYLOAD_CLI_JSON !== undefined;
+            if (shouldRedirectLogger) {
+                config.logger = getJSONLogger(configuredLogger);
+            }
+            try {
+                activePayload = await getPayload({
+                    config,
+                    ...options
+                });
+            } finally{
+                if (shouldRedirectLogger) {
+                    config.logger = configuredLogger;
+                }
+            }
+            return activePayload;
+        },
+        get isScheduled () {
+            return isScheduled;
+        },
+        markScheduled () {
+            isScheduled = true;
+        }
+    };
+    return runtime;
+};
+/** Redirects configurable stdout loggers while preserving opaque logger instances. */ const getJSONLogger = (configuredLogger)=>{
+    if (!configuredLogger || configuredLogger === 'sync') {
+        return {
+            destination: process.stderr,
+            options: {}
+        };
+    }
+    if (!('options' in configuredLogger)) {
+        return configuredLogger;
+    }
+    if (configuredLogger.options.transport || configuredLogger.destination && configuredLogger.destination !== process.stdout) {
+        return configuredLogger;
+    }
+    return {
+        ...configuredLogger,
+        destination: process.stderr
+    };
+};
+
+//# sourceMappingURL=createRuntime.js.map

package/dist/cli/runtime/createRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/runtime/createRuntime.ts"],"sourcesContent":["import path from 'node:path'\nimport { pathToFileURL } from 'node:url'\n\nimport type { CLIRuntime, SanitizedConfig } from '../../config/types.js'\nimport type { Payload } from '../../index.js'\n\nimport { findConfig } from '../../config/find.js'\nimport { getPayload } from '../../index.js'\n\n/**\n * Creates the shared resources used by the CLI.\n *\n * The config is loaded once, and any Payload instance opened by a command is tracked\n * so the CLI can close it before exiting.\n */\nexport const createCLIRuntime = (): CLIRuntime => {\n  let activePayload: Payload | undefined\n  let configPromise: Promise<SanitizedConfig> | undefined\n  let isScheduled = false\n  const configPath = findConfig()\n\n  const getConfig = (): Promise<SanitizedConfig> => {\n    configPromise ??= (async () => {\n      const importedConfig = await import(pathToFileURL(configPath).toString())\n      const config = importedConfig.default ? await importedConfig.default : importedConfig\n\n      return config as SanitizedConfig\n    })()\n\n    return configPromise\n  }\n\n  const runtime: CLIRuntime = {\n    configDir: path.dirname(configPath),\n    async destroy() {\n      if (!activePayload) {\n        return\n      }\n\n      const payload = activePayload\n\n      activePayload = undefined\n      await payload.destroy()\n    },\n    getConfig,\n    async getPayload(options = {}) {\n      const config = await getConfig()\n      const configuredLogger = config.logger\n      const shouldRedirectLogger = process.env.PAYLOAD_CLI_JSON !== undefined\n\n      if (shouldRedirectLogger) {\n        config.logger = getJSONLogger(configuredLogger)\n      }\n\n      try {\n        activePayload = await getPayload({\n          config,\n          ...options,\n        })\n      } finally {\n        if (shouldRedirectLogger) {\n          config.logger = configuredLogger\n        }\n      }\n\n      return activePayload\n    },\n    get isScheduled() {\n      return isScheduled\n    },\n    markScheduled() {\n      isScheduled = true\n    },\n  }\n\n  return runtime\n}\n\n/** Redirects configurable stdout loggers while preserving opaque logger instances. */\nconst getJSONLogger = (configuredLogger: SanitizedConfig['logger']): SanitizedConfig['logger'] => {\n  if (!configuredLogger || configuredLogger === 'sync') {\n    return { destination: process.stderr, options: {} }\n  }\n\n  if (!('options' in configuredLogger)) {\n    return configuredLogger\n  }\n\n  if (\n    configuredLogger.options.transport ||\n    (configuredLogger.destination && configuredLogger.destination !== process.stdout)\n  ) {\n    return configuredLogger\n  }\n\n  return { ...configuredLogger, destination: process.stderr }\n}\n"],"names":["path","pathToFileURL","findConfig","getPayload","createCLIRuntime","activePayload","configPromise","isScheduled","configPath","getConfig","importedConfig","toString","config","default","runtime","configDir","dirname","destroy","payload","undefined","options","configuredLogger","logger","shouldRedirectLogger","process","env","PAYLOAD_CLI_JSON","getJSONLogger","markScheduled","destination","stderr","transport","stdout"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAC5B,SAASC,aAAa,QAAQ,WAAU;AAKxC,SAASC,UAAU,QAAQ,uBAAsB;AACjD,SAASC,UAAU,QAAQ,iBAAgB;AAE3C;;;;;CAKC,GACD,OAAO,MAAMC,mBAAmB;IAC9B,IAAIC;IACJ,IAAIC;IACJ,IAAIC,cAAc;IAClB,MAAMC,aAAaN;IAEnB,MAAMO,YAAY;QAChBH,kBAAkB,AAAC,CAAA;YACjB,MAAMI,iBAAiB,MAAM,MAAM,CAACT,cAAcO,YAAYG,QAAQ;YACtE,MAAMC,SAASF,eAAeG,OAAO,GAAG,MAAMH,eAAeG,OAAO,GAAGH;YAEvE,OAAOE;QACT,CAAA;QAEA,OAAON;IACT;IAEA,MAAMQ,UAAsB;QAC1BC,WAAWf,KAAKgB,OAAO,CAACR;QACxB,MAAMS;YACJ,IAAI,CAACZ,eAAe;gBAClB;YACF;YAEA,MAAMa,UAAUb;YAEhBA,gBAAgBc;YAChB,MAAMD,QAAQD,OAAO;QACvB;QACAR;QACA,MAAMN,YAAWiB,UAAU,CAAC,CAAC;YAC3B,MAAMR,SAAS,MAAMH;YACrB,MAAMY,mBAAmBT,OAAOU,MAAM;YACtC,MAAMC,uBAAuBC,QAAQC,GAAG,CAACC,gBAAgB,KAAKP;YAE9D,IAAII,sBAAsB;gBACxBX,OAAOU,MAAM,GAAGK,cAAcN;YAChC;YAEA,IAAI;gBACFhB,gBAAgB,MAAMF,WAAW;oBAC/BS;oBACA,GAAGQ,OAAO;gBACZ;YACF,SAAU;gBACR,IAAIG,sBAAsB;oBACxBX,OAAOU,MAAM,GAAGD;gBAClB;YACF;YAEA,OAAOhB;QACT;QACA,IAAIE,eAAc;YAChB,OAAOA;QACT;QACAqB;YACErB,cAAc;QAChB;IACF;IAEA,OAAOO;AACT,EAAC;AAED,oFAAoF,GACpF,MAAMa,gBAAgB,CAACN;IACrB,IAAI,CAACA,oBAAoBA,qBAAqB,QAAQ;QACpD,OAAO;YAAEQ,aAAaL,QAAQM,MAAM;YAAEV,SAAS,CAAC;QAAE;IACpD;IAEA,IAAI,CAAE,CAAA,aAAaC,gBAAe,GAAI;QACpC,OAAOA;IACT;IAEA,IACEA,iBAAiBD,OAAO,CAACW,SAAS,IACjCV,iBAAiBQ,WAAW,IAAIR,iBAAiBQ,WAAW,KAAKL,QAAQQ,MAAM,EAChF;QACA,OAAOX;IACT;IAEA,OAAO;QAAE,GAAGA,gBAAgB;QAAEQ,aAAaL,QAAQM,MAAM;IAAC;AAC5D"}

package/dist/cli/runtime/getCommandInput.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'commander';
+/**
+ * Returns the raw value that the command schema will validate.
+ *
+ * For example, both commands return `{ migrationName: 'add-users' }`:
+ *
+ * ```sh
+ * payload migrate:create add-users
+ * payload migrate:create --input '{"migrationName":"add-users"}'
+ * ```
+ *
+ * Explicit shell values override values from `--input`. If `seed.json` contains
+ * `{ "returning": false }`, then `payload createDocuments --input @seed.json --returning`
+ * returns input with `{ returning: true }`.
+ */
+export declare const getCommandInput: (command: Command) => Promise<unknown>;
+//# sourceMappingURL=getCommandInput.d.ts.map

package/dist/cli/runtime/getCommandInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCommandInput.d.ts","sourceRoot":"","sources":["../../../src/cli/runtime/getCommandInput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAKxC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,YAAmB,OAAO,KAAG,OAAO,CAAC,OAAO,CAevE,CAAA"}

package/dist/cli/runtime/getCommandInput.js

@@ -0,0 +1,86 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Returns the raw value that the command schema will validate.
+ *
+ * For example, both commands return `{ migrationName: 'add-users' }`:
+ *
+ * ```sh
+ * payload migrate:create add-users
+ * payload migrate:create --input '{"migrationName":"add-users"}'
+ * ```
+ *
+ * Explicit shell values override values from `--input`. If `seed.json` contains
+ * `{ "returning": false }`, then `payload createDocuments --input @seed.json --returning`
+ * returns input with `{ returning: true }`.
+ */ export const getCommandInput = async (command)=>{
+    const input = command.getOptionValue('input');
+    const shellInput = getShellInput(command);
+    if (input === undefined) {
+        return shellInput;
+    }
+    const parsedInput = await parseJSONInput(input);
+    if (typeof parsedInput !== 'object' || parsedInput === null || Array.isArray(parsedInput)) {
+        command.error('error: --input must contain a JSON object');
+    }
+    return {
+        ...parsedInput,
+        ...shellInput
+    };
+};
+/**
+ * Combines Commander's parsed positional arguments and explicitly passed options.
+ *
+ * For example, `payload migrate:create add-users --skip-empty` returns:
+ *
+ * ```ts
+ * { migrationName: 'add-users', skipEmpty: true }
+ * ```
+ */ const getShellInput = (command)=>{
+    const input = {};
+    for (const [position, argument] of command.registeredArguments.entries()){
+        const value = command.processedArgs[position];
+        if (value !== undefined && (!Array.isArray(value) || value.length > 0)) {
+            input[argument.name()] = value;
+        }
+    }
+    for (const option of command.options){
+        const name = option.attributeName();
+        // The schema applies defaults later, so only include options the user passed.
+        if (name !== 'input' && name !== 'json' && command.getOptionValueSource(name) === 'cli') {
+            input[name] = command.getOptionValue(name);
+        }
+    }
+    return input;
+};
+/**
+ * Reads and parses the value passed to `--input`.
+ *
+ * For example, `'{}'` is parsed directly, `@input.json` reads the JSON from that file,
+ * and `-` reads it from stdin. An input of `'{"force":true}'` returns `{ force: true }`.
+ */ const parseJSONInput = async (input)=>{
+    let json = input;
+    switch(input){
+        case '-':
+            {
+                json = '';
+                for await (const chunk of process.stdin){
+                    json += chunk.toString();
+                }
+                break;
+            }
+        default:
+            {
+                if (input.startsWith('@')) {
+                    json = await readFile(path.resolve(process.cwd(), input.slice(1)), 'utf8');
+                }
+            }
+    }
+    try {
+        return JSON.parse(json);
+    } catch (error) {
+        throw new Error(`Could not parse --input as JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+
+//# sourceMappingURL=getCommandInput.js.map

package/dist/cli/runtime/getCommandInput.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/runtime/getCommandInput.ts"],"sourcesContent":["import type { Command } from 'commander'\n\nimport { readFile } from 'node:fs/promises'\nimport path from 'node:path'\n\n/**\n * Returns the raw value that the command schema will validate.\n *\n * For example, both commands return `{ migrationName: 'add-users' }`:\n *\n * ```sh\n * payload migrate:create add-users\n * payload migrate:create --input '{\"migrationName\":\"add-users\"}'\n * ```\n *\n * Explicit shell values override values from `--input`. If `seed.json` contains\n * `{ \"returning\": false }`, then `payload createDocuments --input @seed.json --returning`\n * returns input with `{ returning: true }`.\n */\nexport const getCommandInput = async (command: Command): Promise<unknown> => {\n  const input = command.getOptionValue('input') as string | undefined\n  const shellInput = getShellInput(command)\n\n  if (input === undefined) {\n    return shellInput\n  }\n\n  const parsedInput = await parseJSONInput(input)\n\n  if (typeof parsedInput !== 'object' || parsedInput === null || Array.isArray(parsedInput)) {\n    command.error('error: --input must contain a JSON object')\n  }\n\n  return { ...parsedInput, ...shellInput }\n}\n\n/**\n * Combines Commander's parsed positional arguments and explicitly passed options.\n *\n * For example, `payload migrate:create add-users --skip-empty` returns:\n *\n * ```ts\n * { migrationName: 'add-users', skipEmpty: true }\n * ```\n */\nconst getShellInput = (command: Command): Record<string, unknown> => {\n  const input: Record<string, unknown> = {}\n\n  for (const [position, argument] of command.registeredArguments.entries()) {\n    const value = command.processedArgs[position]\n\n    if (value !== undefined && (!Array.isArray(value) || value.length > 0)) {\n      input[argument.name()] = value\n    }\n  }\n\n  for (const option of command.options) {\n    const name = option.attributeName()\n\n    // The schema applies defaults later, so only include options the user passed.\n    if (name !== 'input' && name !== 'json' && command.getOptionValueSource(name) === 'cli') {\n      input[name] = command.getOptionValue(name)\n    }\n  }\n\n  return input\n}\n\n/**\n * Reads and parses the value passed to `--input`.\n *\n * For example, `'{}'` is parsed directly, `@input.json` reads the JSON from that file,\n * and `-` reads it from stdin. An input of `'{\"force\":true}'` returns `{ force: true }`.\n */\nconst parseJSONInput = async (input: string): Promise<unknown> => {\n  let json = input\n\n  switch (input) {\n    case '-': {\n      json = ''\n      for await (const chunk of process.stdin) {\n        json += chunk.toString()\n      }\n      break\n    }\n\n    default: {\n      if (input.startsWith('@')) {\n        json = await readFile(path.resolve(process.cwd(), input.slice(1)), 'utf8')\n      }\n    }\n  }\n\n  try {\n    return JSON.parse(json) as unknown\n  } catch (error) {\n    throw new Error(\n      `Could not parse --input as JSON: ${error instanceof Error ? error.message : 'Unknown error'}`,\n    )\n  }\n}\n"],"names":["readFile","path","getCommandInput","command","input","getOptionValue","shellInput","getShellInput","undefined","parsedInput","parseJSONInput","Array","isArray","error","position","argument","registeredArguments","entries","value","processedArgs","length","name","option","options","attributeName","getOptionValueSource","json","chunk","process","stdin","toString","startsWith","resolve","cwd","slice","JSON","parse","Error","message"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,mBAAkB;AAC3C,OAAOC,UAAU,YAAW;AAE5B;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMC,kBAAkB,OAAOC;IACpC,MAAMC,QAAQD,QAAQE,cAAc,CAAC;IACrC,MAAMC,aAAaC,cAAcJ;IAEjC,IAAIC,UAAUI,WAAW;QACvB,OAAOF;IACT;IAEA,MAAMG,cAAc,MAAMC,eAAeN;IAEzC,IAAI,OAAOK,gBAAgB,YAAYA,gBAAgB,QAAQE,MAAMC,OAAO,CAACH,cAAc;QACzFN,QAAQU,KAAK,CAAC;IAChB;IAEA,OAAO;QAAE,GAAGJ,WAAW;QAAE,GAAGH,UAAU;IAAC;AACzC,EAAC;AAED;;;;;;;;CAQC,GACD,MAAMC,gBAAgB,CAACJ;IACrB,MAAMC,QAAiC,CAAC;IAExC,KAAK,MAAM,CAACU,UAAUC,SAAS,IAAIZ,QAAQa,mBAAmB,CAACC,OAAO,GAAI;QACxE,MAAMC,QAAQf,QAAQgB,aAAa,CAACL,SAAS;QAE7C,IAAII,UAAUV,aAAc,CAAA,CAACG,MAAMC,OAAO,CAACM,UAAUA,MAAME,MAAM,GAAG,CAAA,GAAI;YACtEhB,KAAK,CAACW,SAASM,IAAI,GAAG,GAAGH;QAC3B;IACF;IAEA,KAAK,MAAMI,UAAUnB,QAAQoB,OAAO,CAAE;QACpC,MAAMF,OAAOC,OAAOE,aAAa;QAEjC,8EAA8E;QAC9E,IAAIH,SAAS,WAAWA,SAAS,UAAUlB,QAAQsB,oBAAoB,CAACJ,UAAU,OAAO;YACvFjB,KAAK,CAACiB,KAAK,GAAGlB,QAAQE,cAAc,CAACgB;QACvC;IACF;IAEA,OAAOjB;AACT;AAEA;;;;;CAKC,GACD,MAAMM,iBAAiB,OAAON;IAC5B,IAAIsB,OAAOtB;IAEX,OAAQA;QACN,KAAK;YAAK;gBACRsB,OAAO;gBACP,WAAW,MAAMC,SAASC,QAAQC,KAAK,CAAE;oBACvCH,QAAQC,MAAMG,QAAQ;gBACxB;gBACA;YACF;QAEA;YAAS;gBACP,IAAI1B,MAAM2B,UAAU,CAAC,MAAM;oBACzBL,OAAO,MAAM1B,SAASC,KAAK+B,OAAO,CAACJ,QAAQK,GAAG,IAAI7B,MAAM8B,KAAK,CAAC,KAAK;gBACrE;YACF;IACF;IAEA,IAAI;QACF,OAAOC,KAAKC,KAAK,CAACV;IACpB,EAAE,OAAOb,OAAO;QACd,MAAM,IAAIwB,MACR,CAAC,iCAAiC,EAAExB,iBAAiBwB,QAAQxB,MAAMyB,OAAO,GAAG,iBAAiB;IAElG;AACF"}

package/dist/cli/runtime/invokeCommand.d.ts

@@ -0,0 +1,23 @@
+import type { Command } from 'commander';
+import type { CLICommand, CLIHelp, CLIRuntime } from '../../config/types.js';
+/**
+ * Runs a command through Payload's shared CLI behavior.
+ *
+ * For example, `payload jobs:run --limit 2 --json` goes through these steps:
+ *
+ * - reads arguments and options and merges them over the JSON value passed through `--input`
+ * - validates the input and includes the schema when reporting validation errors
+ * - passes the validated `args` and runtime helpers to the command handler
+ * - sends logs to stderr and writes a consistent JSON response to stdout in JSON mode
+ * - normalizes handler results, errors, and exit codes
+ * - runs the handler on a schedule when using `--cron`
+ *
+ * Binding the handler directly to `command.action()` would skip this shared behavior.
+ */
+export declare const invokeCLICommand: ({ command, definition, help, runtime, }: {
+    command: Command;
+    definition: CLICommand;
+    help: CLIHelp;
+    runtime: CLIRuntime;
+}) => Promise<void>;
+//# sourceMappingURL=invokeCommand.d.ts.map

package/dist/cli/runtime/invokeCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invokeCommand.d.ts","sourceRoot":"","sources":["../../../src/cli/runtime/invokeCommand.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAIxC,OAAO,KAAK,EAAE,UAAU,EAAoB,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAW9F;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,4CAK1B;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;IACtB,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,UAAU,CAAA;CACpB,KAAG,OAAO,CAAC,IAAI,CAiGf,CAAA"}

package/dist/cli/runtime/invokeCommand.js

@@ -0,0 +1,107 @@
+/* eslint-disable no-console */ import { Cron } from 'croner';
+import { getCommandInput } from './getCommandInput.js';
+import { CLICommandError, getCLIErrorOutput, isJSONOutput, withCLIOutputMode, writeCLIJSON } from './output.js';
+/**
+ * Runs a command through Payload's shared CLI behavior.
+ *
+ * For example, `payload jobs:run --limit 2 --json` goes through these steps:
+ *
+ * - reads arguments and options and merges them over the JSON value passed through `--input`
+ * - validates the input and includes the schema when reporting validation errors
+ * - passes the validated `args` and runtime helpers to the command handler
+ * - sends logs to stderr and writes a consistent JSON response to stdout in JSON mode
+ * - normalizes handler results, errors, and exit codes
+ * - runs the handler on a schedule when using `--cron`
+ *
+ * Binding the handler directly to `command.action()` would skip this shared behavior.
+ */ export const invokeCLICommand = async ({ command, definition, help, runtime })=>{
+    const rawInput = await getCommandInput(command);
+    const validation = await definition.input['~standard'].validate(rawInput);
+    if (validation.issues) {
+        const issues = validation.issues.map((issue)=>({
+                message: issue.message,
+                path: issue.path?.map((part)=>String(typeof part === 'object' ? part.key : part)).join('.')
+            }));
+        throw new CLICommandError({
+            code: 'INVALID_INPUT',
+            command: command.name(),
+            inputSchema: definition.schema,
+            issues,
+            message: `Invalid command input:\n${issues.map((issue)=>`- ${issue.path ? `${issue.path}: ` : ''}${issue.message}`).join('\n')}`
+        });
+    }
+    const callHandler = async ()=>{
+        const isJSON = isJSONOutput(command);
+        let handlerResult;
+        try {
+            handlerResult = await withCLIOutputMode({
+                isJSON,
+                run: ()=>definition.handler({
+                        args: validation.value,
+                        getConfig: runtime.getConfig,
+                        getPayload: runtime.getPayload,
+                        help,
+                        isJSON
+                    })
+            });
+        } catch (error) {
+            if (error instanceof CLICommandError) {
+                throw error;
+            }
+            throw new CLICommandError({
+                cause: error,
+                code: error && typeof error === 'object' && 'code' in error && typeof error.code === 'string' ? error.code : undefined,
+                command: command.name(),
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+        const { exitCode, result } = typeof handlerResult === 'number' ? {
+            exitCode: handlerResult
+        } : handlerResult ?? {};
+        if (isJSON) {
+            writeCLIJSON({
+                command,
+                value: {
+                    command: command.name(),
+                    ...exitCode ? {
+                        exitCode
+                    } : {},
+                    ...result !== undefined ? {
+                        result
+                    } : {},
+                    success: !exitCode
+                }
+            });
+        }
+        if (typeof exitCode === 'number') {
+            process.exitCode = exitCode;
+        }
+    };
+    const { cron } = command.optsWithGlobals();
+    if (!cron) {
+        await callHandler();
+        return;
+    }
+    runtime.markScheduled();
+    new Cron(cron, async ()=>{
+        try {
+            await callHandler();
+        } catch (error) {
+            if (isJSONOutput(command)) {
+                writeCLIJSON({
+                    command,
+                    value: getCLIErrorOutput({
+                        error
+                    })
+                });
+            } else {
+                console.error(error);
+            }
+        }
+    }, {
+        protect: true
+    });
+    process.stdin.resume();
+};
+
+//# sourceMappingURL=invokeCommand.js.map

package/dist/cli/runtime/invokeCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/runtime/invokeCommand.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { Command } from 'commander'\n\nimport { Cron } from 'croner'\n\nimport type { CLICommand, CLICommandResult, CLIHelp, CLIRuntime } from '../../config/types.js'\n\nimport { getCommandInput } from './getCommandInput.js'\nimport {\n  CLICommandError,\n  getCLIErrorOutput,\n  isJSONOutput,\n  withCLIOutputMode,\n  writeCLIJSON,\n} from './output.js'\n\n/**\n * Runs a command through Payload's shared CLI behavior.\n *\n * For example, `payload jobs:run --limit 2 --json` goes through these steps:\n *\n * - reads arguments and options and merges them over the JSON value passed through `--input`\n * - validates the input and includes the schema when reporting validation errors\n * - passes the validated `args` and runtime helpers to the command handler\n * - sends logs to stderr and writes a consistent JSON response to stdout in JSON mode\n * - normalizes handler results, errors, and exit codes\n * - runs the handler on a schedule when using `--cron`\n *\n * Binding the handler directly to `command.action()` would skip this shared behavior.\n */\nexport const invokeCLICommand = async ({\n  command,\n  definition,\n  help,\n  runtime,\n}: {\n  command: Command\n  definition: CLICommand\n  help: CLIHelp\n  runtime: CLIRuntime\n}): Promise<void> => {\n  const rawInput = await getCommandInput(command)\n  const validation = await definition.input['~standard'].validate(rawInput)\n\n  if (validation.issues) {\n    const issues = validation.issues.map((issue) => ({\n      message: issue.message,\n      path: issue.path?.map((part) => String(typeof part === 'object' ? part.key : part)).join('.'),\n    }))\n\n    throw new CLICommandError({\n      code: 'INVALID_INPUT',\n      command: command.name(),\n      inputSchema: definition.schema,\n      issues,\n      message: `Invalid command input:\\n${issues\n        .map((issue) => `- ${issue.path ? `${issue.path}: ` : ''}${issue.message}`)\n        .join('\\n')}`,\n    })\n  }\n\n  const callHandler = async (): Promise<void> => {\n    const isJSON = isJSONOutput(command)\n    let handlerResult: CLICommandResult | number | void\n\n    try {\n      handlerResult = await withCLIOutputMode({\n        isJSON,\n        run: () =>\n          definition.handler({\n            args: validation.value,\n            getConfig: runtime.getConfig,\n            getPayload: runtime.getPayload,\n            help,\n            isJSON,\n          }),\n      })\n    } catch (error) {\n      if (error instanceof CLICommandError) {\n        throw error\n      }\n\n      throw new CLICommandError({\n        cause: error,\n        code:\n          error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'\n            ? error.code\n            : undefined,\n        command: command.name(),\n        message: error instanceof Error ? error.message : 'Unknown error',\n      })\n    }\n\n    const { exitCode, result } =\n      typeof handlerResult === 'number' ? { exitCode: handlerResult } : (handlerResult ?? {})\n\n    if (isJSON) {\n      writeCLIJSON({\n        command,\n        value: {\n          command: command.name(),\n          ...(exitCode ? { exitCode } : {}),\n          ...(result !== undefined ? { result } : {}),\n          success: !exitCode,\n        },\n      })\n    }\n\n    if (typeof exitCode === 'number') {\n      process.exitCode = exitCode\n    }\n  }\n\n  const { cron } = command.optsWithGlobals<{ cron?: string }>()\n\n  if (!cron) {\n    await callHandler()\n    return\n  }\n\n  runtime.markScheduled()\n  new Cron(\n    cron,\n    async () => {\n      try {\n        await callHandler()\n      } catch (error) {\n        if (isJSONOutput(command)) {\n          writeCLIJSON({ command, value: getCLIErrorOutput({ error }) })\n        } else {\n          console.error(error)\n        }\n      }\n    },\n    { protect: true },\n  )\n  process.stdin.resume()\n}\n"],"names":["Cron","getCommandInput","CLICommandError","getCLIErrorOutput","isJSONOutput","withCLIOutputMode","writeCLIJSON","invokeCLICommand","command","definition","help","runtime","rawInput","validation","input","validate","issues","map","issue","message","path","part","String","key","join","code","name","inputSchema","schema","callHandler","isJSON","handlerResult","run","handler","args","value","getConfig","getPayload","error","cause","undefined","Error","exitCode","result","success","process","cron","optsWithGlobals","markScheduled","console","protect","stdin","resume"],"mappings":"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"}

package/dist/cli/runtime/loadEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadEnv.d.ts","sourceRoot":"","sources":["../../../src/cli/runtime/loadEnv.ts"],"names":[],"mappings":"AAoCA;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,QAqBpC"}

package/dist/{bin → cli/runtime}/loadEnv.js

@@ -2,7 +2,7 @@ import dotenv from 'dotenv';
 import dotenvExpand from 'dotenv-expand';
 import { existsSync } from 'fs';
 import nodePath from 'path';
-import { findUpSync } from '../utilities/findUp.js';
+import { findUpSync } from '../../utilities/findUp.js';
 /**
  * Loads env files in priority order (same as Next.js convention):
  * .env.${NODE_ENV}.local, .env.local (not for test), .env.${NODE_ENV}, .env