politty 0.11.1 → 0.11.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,4 +1,5 @@
1
- import { a as toCamelCase, c as listSubCommands, d as resolveSubcommandWithAlias, f as isLazyCommand, l as resolveLazyCommand, m as resolveSubCommandMeta, n as getAllAliases, o as toKebabCase, r as getExtractedFields, s as listSubCommandNamesWithAliases, t as extractFields } from "./schema-extractor-GEuI_L0X.js";
1
+ import { a as toCamelCase, n as getAllAliases, o as toKebabCase, r as getExtractedFields, t as extractFields } from "./schema-extractor-wzJ1cGon.js";
2
+ import { a as resolveSubcommandWithAlias, c as resolveSubCommandMeta, n as listSubCommands, o as isLazyCommand, r as resolveLazyCommand, t as listSubCommandNamesWithAliases } from "./subcommand-router-CTzHPGzF.js";
2
3
  import { n as emptyLogs, r as mergeLogs, t as createLogCollector } from "./log-collector-DK32-73m.js";
3
4
  import { a as symbols, i as styles } from "./logger-DbDkjdfO.js";
4
5
  import { stripVTControlCharacters } from "node:util";
@@ -995,6 +996,30 @@ var DuplicateNegationError = class extends Error {
995
996
  this.name = "DuplicateNegationError";
996
997
  }
997
998
  };
999
+ /**
1000
+ * Error thrown when a field name collides with a reserved, framework-injected
1001
+ * key on the final args object (e.g. `$source`).
1002
+ */
1003
+ var ReservedFieldNameError = class extends Error {
1004
+ constructor(message) {
1005
+ super(message);
1006
+ this.name = "ReservedFieldNameError";
1007
+ }
1008
+ };
1009
+ /**
1010
+ * Error thrown when a global field and a same-named local field have
1011
+ * different definitions (per `extractFields()`'s type bucket, whether the
1012
+ * field is positional, and enum values). Only exactly-matching definitions
1013
+ * are allowed to share a name across global/local schemas — anything else
1014
+ * is rejected at validation time rather than risking a value from one
1015
+ * schema silently flowing into the other.
1016
+ */
1017
+ var FieldTypeConflictError = class extends Error {
1018
+ constructor(message) {
1019
+ super(message);
1020
+ this.name = "FieldTypeConflictError";
1021
+ }
1022
+ };
998
1023
 
999
1024
  //#endregion
1000
1025
  //#region src/validator/command-validator.ts
@@ -1196,6 +1221,29 @@ function checkReservedAliases(extracted, commandPath) {
1196
1221
  return errors;
1197
1222
  }
1198
1223
  /**
1224
+ * Check for field names starting with `$`.
1225
+ *
1226
+ * The `$` prefix is reserved for framework-injected helpers on the final
1227
+ * args object (e.g. `$source`). It is also impractical as a real CLI flag
1228
+ * since an unquoted `$name` is expanded by the shell before it ever reaches
1229
+ * the program, so this is rejected outright rather than merely discouraged.
1230
+ *
1231
+ * Aliases can't start with `$` (schema extraction already restricts alias
1232
+ * characters to `[A-Za-z0-9-]`), and `cliName` is derived from `name` via
1233
+ * `toKebabCase`, which never strips or moves a leading `$` — so checking
1234
+ * `field.name` alone covers every way `$` could reach the final args object.
1235
+ */
1236
+ function checkReservedFieldNames(extracted, commandPath) {
1237
+ const errors = [];
1238
+ for (const field of extracted.fields) if (field.name.startsWith("$")) errors.push({
1239
+ commandPath,
1240
+ type: "reserved_field_name",
1241
+ message: `Field "${field.name}" starts with "$", which is reserved for framework-injected helpers (e.g. $source).`,
1242
+ field: field.name
1243
+ });
1244
+ return errors;
1245
+ }
1246
+ /**
1199
1247
  * Validate that no duplicate field names exist
1200
1248
  *
1201
1249
  * @param extracted - Extracted fields from schema
@@ -1262,6 +1310,28 @@ function validateReservedAliases(extracted, _hasSubCommands) {
1262
1310
  }
1263
1311
  }
1264
1312
  /**
1313
+ * Validate that no field name starts with `$`
1314
+ *
1315
+ * The `$` prefix is reserved for framework-injected helpers on the final
1316
+ * args object (e.g. `$source`), and is unusable as a real CLI flag anyway
1317
+ * since an unquoted `$name` gets shell-expanded before the program sees it.
1318
+ *
1319
+ * Checking `field.name` alone is sufficient: aliases can't start with `$`
1320
+ * (schema extraction already restricts alias characters to `[A-Za-z0-9-]`),
1321
+ * and `cliName` is derived from `name` via `toKebabCase`, which never strips
1322
+ * or moves a leading `$`. See {@link checkReservedFieldNames}.
1323
+ *
1324
+ * @param extracted - Extracted fields from schema
1325
+ * @throws {ReservedFieldNameError} If a field name starts with "$"
1326
+ */
1327
+ function validateReservedFieldNames(extracted) {
1328
+ const errors = checkReservedFieldNames(extracted, []);
1329
+ if (errors.length > 0) {
1330
+ const err = errors[0];
1331
+ throw new ReservedFieldNameError(err.message);
1332
+ }
1333
+ }
1334
+ /**
1265
1335
  * Validate that custom boolean negation names do not collide with anything
1266
1336
  *
1267
1337
  * @param extracted - Extracted fields from schema
@@ -1288,21 +1358,76 @@ function validateCaseVariantCollisions(extracted) {
1288
1358
  }
1289
1359
  }
1290
1360
  /**
1291
- * Validate that no case-variant collisions exist between two schemas
1292
- * (e.g., global args and command args).
1293
- *
1294
- * @param extractedA - Extracted fields from first schema (e.g., global args)
1295
- * @param extractedB - Extracted fields from second schema (e.g., command args)
1296
- * @throws {CaseVariantCollisionError} If cross-schema case-variant collisions are found
1361
+ * Check whether two same-named fields from different schemas (e.g. global
1362
+ * args and command args) have identical definitions. Only the facts
1363
+ * `extractFields()` already exposes are compared: the coarse type bucket,
1364
+ * whether the field is positional, and, for enum-like fields, the exact
1365
+ * set of allowed values. Anything `extractFields()` can't see (e.g. a
1366
+ * `.refine()`) is intentionally not compared — this is a coarse, cheap
1367
+ * equality check, not a full schema comparison.
1297
1368
  */
1298
- function validateCrossSchemaCollisions(extractedA, extractedB) {
1369
+ function fieldsAreIdentical(a, b) {
1370
+ if (a.type !== b.type) return false;
1371
+ if (a.positional !== b.positional) return false;
1372
+ const aEnum = a.enumValues;
1373
+ const bEnum = b.enumValues;
1374
+ if (!aEnum && !bEnum) return true;
1375
+ if (!aEnum || !bEnum) return false;
1376
+ const aSet = new Set(aEnum);
1377
+ const bSet = new Set(bEnum);
1378
+ if (aSet.size !== bSet.size) return false;
1379
+ for (const value of aSet) if (!bSet.has(value)) return false;
1380
+ return true;
1381
+ }
1382
+ /**
1383
+ * Check for cross-schema collisions between two schemas (e.g., global args
1384
+ * and command args): neither a case-variant collision (same canonical name,
1385
+ * different spelling) nor a same-named field with a different definition
1386
+ * (same spelling, but the two schemas don't agree on what values are valid).
1387
+ */
1388
+ function checkCrossSchemaCollisions(extractedA, extractedB, commandPath) {
1389
+ const errors = [];
1299
1390
  const canonicalMap = /* @__PURE__ */ new Map();
1300
- for (const field of extractedA.fields) canonicalMap.set(toCamelCase(field.name), field.name);
1391
+ for (const field of extractedA.fields) canonicalMap.set(toCamelCase(field.name), field);
1301
1392
  for (const field of extractedB.fields) {
1302
1393
  const camel = toCamelCase(field.name);
1303
1394
  const existing = canonicalMap.get(camel);
1304
- if (existing && existing !== field.name) throw new CaseVariantCollisionError(`Global field "${existing}" and command field "${field.name}" are case variants of each other and would collide.`);
1395
+ if (!existing) continue;
1396
+ if (existing.name !== field.name) {
1397
+ errors.push({
1398
+ commandPath,
1399
+ type: "case_variant_collision",
1400
+ message: `Global field "${existing.name}" and command field "${field.name}" are case variants of each other and would collide.`,
1401
+ field: field.name
1402
+ });
1403
+ continue;
1404
+ }
1405
+ if (!fieldsAreIdentical(existing, field)) errors.push({
1406
+ commandPath,
1407
+ type: "field_type_conflict",
1408
+ message: `Global field "${existing.name}" and command field "${field.name}" share the same name but have different definitions.`,
1409
+ field: field.name
1410
+ });
1305
1411
  }
1412
+ return errors;
1413
+ }
1414
+ /**
1415
+ * Validate that no cross-schema collisions exist between two schemas
1416
+ * (e.g., global args and command args): neither a case-variant collision
1417
+ * (same canonical name, different spelling) nor a same-named field with a
1418
+ * different definition (same spelling, but the two schemas don't agree on
1419
+ * what values are valid).
1420
+ *
1421
+ * @param extractedA - Extracted fields from first schema (e.g., global args)
1422
+ * @param extractedB - Extracted fields from second schema (e.g., command args)
1423
+ * @throws {CaseVariantCollisionError} If cross-schema case-variant collisions are found
1424
+ * @throws {FieldTypeConflictError} If a same-named field has a different definition on each schema
1425
+ */
1426
+ function validateCrossSchemaCollisions(extractedA, extractedB) {
1427
+ const err = checkCrossSchemaCollisions(extractedA, extractedB, [])[0];
1428
+ if (!err) return;
1429
+ if (err.type === "case_variant_collision") throw new CaseVariantCollisionError(err.message);
1430
+ throw new FieldTypeConflictError(err.message);
1306
1431
  }
1307
1432
  /**
1308
1433
  * Collect validation errors for a single command's schema (non-throwing)
@@ -1314,7 +1439,8 @@ function collectSchemaErrors(extracted, _hasSubCommands, commandPath) {
1314
1439
  ...checkDuplicateAliases(extracted, commandPath),
1315
1440
  ...checkDuplicateNegations(extracted, commandPath),
1316
1441
  ...checkPositionalConfig(extracted, commandPath),
1317
- ...checkReservedAliases(extracted, commandPath)
1442
+ ...checkReservedAliases(extracted, commandPath),
1443
+ ...checkReservedFieldNames(extracted, commandPath)
1318
1444
  ];
1319
1445
  }
1320
1446
  /**
@@ -1390,13 +1516,18 @@ async function validateCommand(command, options = {}) {
1390
1516
  const commandPath = options.commandPath ?? [command.name];
1391
1517
  const errors = [];
1392
1518
  const hasSubCommands = command.subCommands ? Object.keys(command.subCommands).length > 0 : false;
1519
+ const globalExtracted = options.globalArgs ? extractFields(options.globalArgs) : void 0;
1393
1520
  if (command.args) {
1394
1521
  const extracted = extractFields(command.args);
1395
1522
  errors.push(...collectSchemaErrors(extracted, hasSubCommands, commandPath));
1523
+ if (globalExtracted) errors.push(...checkCrossSchemaCollisions(globalExtracted, extracted, commandPath));
1396
1524
  }
1397
1525
  errors.push(...checkSubCommandAliasConflicts(command, commandPath));
1398
1526
  if (command.subCommands) for (const [name, subCmd] of Object.entries(command.subCommands)) {
1399
- const subResult = await validateCommand(await resolveLazyCommand(subCmd), { commandPath: [...commandPath, name] });
1527
+ const subResult = await validateCommand(await resolveLazyCommand(subCmd), {
1528
+ commandPath: [...commandPath, name],
1529
+ ...options.globalArgs ? { globalArgs: options.globalArgs } : {}
1530
+ });
1400
1531
  if (!subResult.valid) errors.push(...subResult.errors);
1401
1532
  }
1402
1533
  if (errors.length === 0) return { valid: true };
@@ -1977,6 +2108,7 @@ function parseArgs(argv, command, options = {}) {
1977
2108
  validateDuplicateNegations(extracted);
1978
2109
  validatePositionalConfig(extracted);
1979
2110
  validateReservedAliases(extracted, hasSubCommands);
2111
+ validateReservedFieldNames(extracted);
1980
2112
  if (options.globalExtracted) validateCrossSchemaCollisions(options.globalExtracted, extracted);
1981
2113
  }
1982
2114
  }
@@ -2028,12 +2160,14 @@ function parseArgs(argv, command, options = {}) {
2028
2160
  const parserOptions = buildParserOptions(extracted);
2029
2161
  const parsed = parseArgv(commandArgv, parserOptions);
2030
2162
  const rawArgs = mergeWithPositionals(parsed, extracted);
2163
+ const envFallbackFields = /* @__PURE__ */ new Set();
2031
2164
  for (const field of extracted.fields) if (field.env && rawArgs[field.name] === void 0) {
2032
2165
  const envNames = Array.isArray(field.env) ? field.env : [field.env];
2033
2166
  for (const envName of envNames) {
2034
2167
  const envValue = process.env[envName];
2035
2168
  if (envValue !== void 0) {
2036
2169
  rawArgs[field.name] = envValue;
2170
+ envFallbackFields.add(field.name);
2037
2171
  break;
2038
2172
  }
2039
2173
  }
@@ -2061,7 +2195,8 @@ function parseArgs(argv, command, options = {}) {
2061
2195
  unknownFlags,
2062
2196
  unknownGlobalFlags: suppressedGlobalFlags,
2063
2197
  extractedFields: extracted,
2064
- rawGlobalArgs
2198
+ rawGlobalArgs,
2199
+ envFallbackFields
2065
2200
  };
2066
2201
  }
2067
2202
  /**
@@ -2269,6 +2404,18 @@ const defaultLogger = {
2269
2404
  warn: (message) => console.warn(message)
2270
2405
  };
2271
2406
  /**
2407
+ * Attach a non-enumerable `$source` helper to the final args object so it
2408
+ * stays invisible to `Object.keys`/`JSON.stringify`/spread (those only ever
2409
+ * see real field values) while still being reachable via property access
2410
+ * (including through `createDualCaseProxy`).
2411
+ */
2412
+ function attachArgSource(target, sourceMap) {
2413
+ Object.defineProperty(target, "$source", {
2414
+ value: (name) => sourceMap.get(name) ?? sourceMap.get(toCamelCase(name)) ?? sourceMap.get(toKebabCase(name)) ?? "default",
2415
+ enumerable: false
2416
+ });
2417
+ }
2418
+ /**
2272
2419
  * Run a command with the given arguments (programmatic/test usage)
2273
2420
  *
2274
2421
  * This function parses arguments, validates them, routes to subcommands,
@@ -2682,6 +2829,8 @@ async function runCommandInternal(command, argv, options = {}) {
2682
2829
  }
2683
2830
  let validatedGlobalArgs = {};
2684
2831
  const isCompletionInvocation = command.name === "__complete";
2832
+ const cliProvidedGlobalFields = new Set(Object.keys(accumulatedGlobalArgs));
2833
+ const envFallbackGlobalFields = /* @__PURE__ */ new Set();
2685
2834
  if (options.globalArgs && options._globalExtracted && !isCompletionInvocation) {
2686
2835
  for (const field of options._globalExtracted.fields) if (field.env && accumulatedGlobalArgs[field.name] === void 0) {
2687
2836
  const envNames = Array.isArray(field.env) ? field.env : [field.env];
@@ -2689,13 +2838,14 @@ async function runCommandInternal(command, argv, options = {}) {
2689
2838
  const envValue = process.env[envName];
2690
2839
  if (envValue !== void 0) {
2691
2840
  accumulatedGlobalArgs[field.name] = envValue;
2841
+ envFallbackGlobalFields.add(field.name);
2692
2842
  break;
2693
2843
  }
2694
2844
  }
2695
2845
  }
2696
2846
  if (options.prompt) {
2697
2847
  const resolved = await options.prompt(accumulatedGlobalArgs, options._globalExtracted);
2698
- Object.assign(accumulatedGlobalArgs, resolved);
2848
+ for (const [key, value] of Object.entries(resolved)) if (value !== void 0) accumulatedGlobalArgs[key] = value;
2699
2849
  }
2700
2850
  const globalValidation = validateArgs(accumulatedGlobalArgs, options.globalArgs);
2701
2851
  if (!globalValidation.success) {
@@ -2710,6 +2860,10 @@ async function runCommandInternal(command, argv, options = {}) {
2710
2860
  validatedGlobalArgs = globalValidation.data;
2711
2861
  }
2712
2862
  if (!command.args) {
2863
+ const globalSourceMap = /* @__PURE__ */ new Map();
2864
+ for (const name of cliProvidedGlobalFields) globalSourceMap.set(name, "cli");
2865
+ for (const name of envFallbackGlobalFields) globalSourceMap.set(name, "env");
2866
+ attachArgSource(validatedGlobalArgs, globalSourceMap);
2713
2867
  const proxiedGlobalArgs = createDualCaseProxy(validatedGlobalArgs);
2714
2868
  if (options._globalExtracted && !isCompletionInvocation) await runEffects(proxiedGlobalArgs, options._globalExtracted, proxiedGlobalArgs);
2715
2869
  collector?.stop();
@@ -2721,12 +2875,25 @@ async function runCommandInternal(command, argv, options = {}) {
2721
2875
  });
2722
2876
  }
2723
2877
  let argsToValidate = parseResult.rawArgs;
2878
+ const promptResolvedFields = /* @__PURE__ */ new Set();
2724
2879
  if (options.prompt && parseResult.extractedFields) {
2725
2880
  const resolved = await options.prompt(argsToValidate, parseResult.extractedFields);
2726
- argsToValidate = {
2727
- ...argsToValidate,
2728
- ...resolved
2729
- };
2881
+ const nextArgsToValidate = { ...argsToValidate };
2882
+ for (const [key, value] of Object.entries(resolved)) if (value !== void 0) {
2883
+ nextArgsToValidate[key] = value;
2884
+ promptResolvedFields.add(key);
2885
+ }
2886
+ argsToValidate = nextArgsToValidate;
2887
+ }
2888
+ const globalPrefilledFields = /* @__PURE__ */ new Set();
2889
+ if (parseResult.extractedFields) {
2890
+ for (const field of parseResult.extractedFields.fields) if (!(Object.hasOwn(parseResult.rawArgs, field.name) || promptResolvedFields.has(field.name)) && cliProvidedGlobalFields.has(field.name) && Object.hasOwn(validatedGlobalArgs, field.name)) {
2891
+ argsToValidate = {
2892
+ ...argsToValidate,
2893
+ [field.name]: validatedGlobalArgs[field.name]
2894
+ };
2895
+ globalPrefilledFields.add(field.name);
2896
+ }
2730
2897
  }
2731
2898
  const validationResult = validateArgs(argsToValidate, command.args);
2732
2899
  if (!validationResult.success) {
@@ -2742,10 +2909,24 @@ async function runCommandInternal(command, argv, options = {}) {
2742
2909
  const proxiedGlobalArgs = createDualCaseProxy(validatedGlobalArgs);
2743
2910
  if (options._globalExtracted && !isCompletionInvocation) await runEffects(proxiedGlobalArgs, options._globalExtracted, proxiedGlobalArgs);
2744
2911
  if (parseResult.extractedFields && !isCompletionInvocation) await runEffects(proxiedCommandArgs, parseResult.extractedFields, proxiedGlobalArgs);
2745
- const mergedArgs = createDualCaseProxy({
2912
+ const mergedPlainArgs = {
2746
2913
  ...proxiedGlobalArgs,
2747
2914
  ...proxiedCommandArgs
2748
- });
2915
+ };
2916
+ const argSourceMap = /* @__PURE__ */ new Map();
2917
+ for (const name of cliProvidedGlobalFields) argSourceMap.set(name, "cli");
2918
+ for (const name of envFallbackGlobalFields) argSourceMap.set(name, "env");
2919
+ const localEnvFallbackFields = parseResult.envFallbackFields ?? /* @__PURE__ */ new Set();
2920
+ for (const field of parseResult.extractedFields?.fields ?? []) {
2921
+ if (globalPrefilledFields.has(field.name)) {
2922
+ argSourceMap.set(field.name, "cli");
2923
+ continue;
2924
+ }
2925
+ const localHasCliOrEnvValue = Object.hasOwn(parseResult.rawArgs, field.name) || localEnvFallbackFields.has(field.name);
2926
+ argSourceMap.set(field.name, localHasCliOrEnvValue ? localEnvFallbackFields.has(field.name) ? "env" : "cli" : "default");
2927
+ }
2928
+ attachArgSource(mergedPlainArgs, argSourceMap);
2929
+ const mergedArgs = createDualCaseProxy(mergedPlainArgs);
2749
2930
  collector?.stop();
2750
2931
  return await executeLifecycle(command, mergedArgs, {
2751
2932
  handleSignals: options.handleSignals,
@@ -2778,6 +2959,7 @@ function extractAndValidateGlobal(options) {
2778
2959
  validateDuplicateAliases(extracted);
2779
2960
  validateDuplicateNegations(extracted);
2780
2961
  validateReservedAliases(extracted, true);
2962
+ validateReservedFieldNames(extracted);
2781
2963
  const positionalNames = extracted.fields.filter((f) => f.positional).map((f) => f.name);
2782
2964
  if (positionalNames.length > 0) throw new Error(`Global options schema must not contain positional arguments. Found: ${positionalNames.join(", ")}`);
2783
2965
  }
@@ -2785,5 +2967,5 @@ function extractAndValidateGlobal(options) {
2785
2967
  }
2786
2968
 
2787
2969
  //#endregion
2788
- export { renderMarkdown as C, renderInline as S, DuplicateFieldError as _, parseArgv as a, ReservedAliasError as b, validateCommand as c, validateDuplicateFields as d, validateDuplicateNegations as f, DuplicateAliasError as g, CaseVariantCollisionError as h, formatValidationErrors as i, validateCrossSchemaCollisions as l, validateReservedAliases as m, runMain as n, formatCommandValidationErrors as o, validatePositionalConfig as p, runner_exports as r, validateCaseVariantCollisions as s, runCommand as t, validateDuplicateAliases as u, DuplicateNegationError as v, createDualCaseProxy as w, generateHelp as x, PositionalConfigError as y };
2789
- //# sourceMappingURL=runner-DpsAMVta.js.map
2970
+ export { ReservedFieldNameError as C, createDualCaseProxy as D, renderMarkdown as E, ReservedAliasError as S, renderInline as T, DuplicateAliasError as _, parseArgv as a, FieldTypeConflictError as b, validateCommand as c, validateDuplicateFields as d, validateDuplicateNegations as f, CaseVariantCollisionError as g, validateReservedFieldNames as h, formatValidationErrors as i, validateCrossSchemaCollisions as l, validateReservedAliases as m, runMain as n, formatCommandValidationErrors as o, validatePositionalConfig as p, runner_exports as r, validateCaseVariantCollisions as s, runCommand as t, validateDuplicateAliases as u, DuplicateFieldError as v, generateHelp as w, PositionalConfigError as x, DuplicateNegationError as y };
2971
+ //# sourceMappingURL=runner-CEDtiI7D.js.map
@@ -1,135 +1,23 @@
1
- import { n as getArgMeta$1 } from "./arg-registry-BeLLAW5-.js";
1
+ import { z } from "zod";
2
2
 
3
- //#region src/lazy.ts
3
+ //#region src/core/arg-registry.ts
4
4
  /**
5
- * Marker property for LazyCommand identification
5
+ * Custom registry for politty argument metadata
6
+ * This avoids polluting Zod's GlobalMeta
6
7
  */
7
- const LAZY_BRAND = "__politty_lazy__";
8
- /**
9
- * Type guard: check if a value is a LazyCommand
10
- */
11
- function isLazyCommand(value) {
12
- return typeof value === "object" && value !== null && LAZY_BRAND in value && value[LAZY_BRAND] === true;
13
- }
14
- /**
15
- * Create a lazily-loaded subcommand with synchronous metadata.
16
- *
17
- * The `meta` command provides names, descriptions, and args schema
18
- * for static analysis (completion scripts, help text) without loading
19
- * the full command module.
20
- *
21
- * The `load` function is called only at execution time.
22
- *
23
- * @example
24
- * ```ts
25
- * import { lazy, defineCommand } from "politty";
26
- *
27
- * const cli = defineCommand({
28
- * name: "mycli",
29
- * subCommands: {
30
- * deploy: lazy(
31
- * defineCommand({
32
- * name: "deploy",
33
- * description: "Deploy the application",
34
- * args: z.object({ env: arg(z.string()) }),
35
- * }),
36
- * () => import("./deploy.js").then((m) => m.deployCommand),
37
- * ),
38
- * },
39
- * });
40
- * ```
41
- */
42
- function lazy(meta, load) {
43
- return {
44
- [LAZY_BRAND]: true,
45
- meta,
46
- load
47
- };
48
- }
49
- /**
50
- * Resolve synchronous metadata from a SubCommandValue.
51
- * Returns null for legacy async subcommands whose metadata is unavailable.
52
- */
53
- function resolveSubCommandMeta(subCmd) {
54
- if (isLazyCommand(subCmd)) return subCmd.meta;
55
- if (typeof subCmd === "function") return null;
56
- return subCmd;
57
- }
58
-
59
- //#endregion
60
- //#region src/executor/subcommand-router.ts
61
- /**
62
- * Resolve a lazy-loaded command (sync or async)
63
- *
64
- * @param cmd - The command or lazy loader function
65
- * @returns The resolved command
66
- */
67
- async function resolveLazyCommand(cmd) {
68
- if (isLazyCommand(cmd)) return await cmd.load();
69
- if (typeof cmd === "function") return await cmd();
70
- return cmd;
71
- }
72
- /**
73
- * Resolve a subcommand by name (including alias lookup) and return both the
74
- * resolved command and the canonical name if accessed via alias.
75
- *
76
- * This avoids a redundant alias scan when the caller needs both pieces of info.
77
- */
78
- async function resolveSubcommandWithAlias(command, name) {
79
- if (!command.subCommands) return;
80
- const subCmd = Object.hasOwn(command.subCommands, name) ? command.subCommands[name] : void 0;
81
- if (subCmd) return {
82
- command: await resolveLazyCommand(subCmd),
83
- aliasFor: void 0
84
- };
85
- const canonicalName = resolveSubCommandAlias(command, name);
86
- if (canonicalName) return {
87
- command: await resolveLazyCommand(command.subCommands[canonicalName]),
88
- aliasFor: canonicalName
89
- };
90
- }
91
- /**
92
- * Resolve an alias to the canonical subcommand name.
93
- * Returns the canonical name if the given name is an alias, or undefined.
94
- *
95
- * Note: Aliases are only recognized for eagerly-defined commands and
96
- * `lazy()` commands (which carry synchronous metadata). Pure async
97
- * subcommand functions do not expose metadata synchronously, so their
98
- * aliases cannot be resolved without loading the module.
99
- *
100
- * @param command - The parent command
101
- * @param alias - The alias to look up
102
- * @returns The canonical subcommand name, or undefined
103
- */
104
- function resolveSubCommandAlias(command, alias) {
105
- if (!command.subCommands) return void 0;
106
- for (const [name, subCmd] of Object.entries(command.subCommands)) if (resolveSubCommandMeta(subCmd)?.aliases?.includes(alias)) return name;
107
- }
108
- /**
109
- * Build a set of all recognized subcommand names including aliases.
110
- *
111
- * @param command - The parent command
112
- * @returns Set of all names (canonical + aliases)
113
- */
114
- function listSubCommandNamesWithAliases(command) {
115
- const names = /* @__PURE__ */ new Set();
116
- if (!command.subCommands) return names;
117
- for (const [name, subCmd] of Object.entries(command.subCommands)) {
118
- names.add(name);
119
- const meta = resolveSubCommandMeta(subCmd);
120
- if (meta?.aliases) for (const alias of meta.aliases) names.add(alias);
121
- }
122
- return names;
8
+ const argRegistry = z.registry();
9
+ function arg(schema, meta) {
10
+ if (meta) argRegistry.add(schema, meta);
11
+ return schema;
123
12
  }
124
13
  /**
125
- * List all subcommand names for a command
14
+ * Get metadata for a schema from the registry
126
15
  *
127
- * @param command - The parent command
128
- * @returns Array of subcommand names
16
+ * @param schema - The Zod schema
17
+ * @returns The metadata if registered, undefined otherwise
129
18
  */
130
- function listSubCommands(command) {
131
- if (!command.subCommands) return [];
132
- return Object.keys(command.subCommands);
19
+ function getArgMeta$1(schema) {
20
+ return argRegistry.get(schema);
133
21
  }
134
22
 
135
23
  //#endregion
@@ -596,5 +484,5 @@ function getExtractedFields(command) {
596
484
  }
597
485
 
598
486
  //#endregion
599
- export { toCamelCase as a, listSubCommands as c, resolveSubcommandWithAlias as d, isLazyCommand as f, getUnknownKeysMode as i, resolveLazyCommand as l, resolveSubCommandMeta as m, getAllAliases as n, toKebabCase as o, lazy as p, getExtractedFields as r, listSubCommandNamesWithAliases as s, extractFields as t, resolveSubCommandAlias as u };
600
- //# sourceMappingURL=schema-extractor-GEuI_L0X.js.map
487
+ export { toCamelCase as a, getUnknownKeysMode as i, getAllAliases as n, toKebabCase as o, getExtractedFields as r, arg as s, extractFields as t };
488
+ //# sourceMappingURL=schema-extractor-wzJ1cGon.js.map