@crustjs/core 0.0.7 → 0.0.9

package/dist/index.d.ts

@@ -375,8 +375,8 @@ interface Command<
 	readonly args?: A;
 	/** Flag definitions */
 	readonly flags?: F;
-	/** Named subcommands */
-	readonly subCommands?: Record<string, AnyCommand>;
+	/** Named subcommands (always initialized, may be empty) */
+	readonly subCommands: Record<string, AnyCommand>;
 	/** Called before `run()` — useful for initialization */
 	preRun?(context: CommandContext<A, F>): void | Promise<void>;
 	/** The main command handler */
@@ -567,6 +567,19 @@ interface SetupActions {
 	* @param def - The flag definition
 	*/
 	addFlag(command: AnyCommand, name: string, def: FlagDef): void;
+	/**
+	* Inject a subcommand into a command's `subCommands` record.
+	*
+	* Use this in plugin `setup()` hooks to register plugin-provided commands
+	* (e.g. a "skill" management command). If the parent already has a
+	* subcommand with the same name (user-defined), the call is silently
+	* skipped — user definitions always take priority over plugin injections.
+	*
+	* @param parent - The parent command to add the subcommand to
+	* @param name - The subcommand name (used for routing)
+	* @param command - The subcommand to register
+	*/
+	addSubCommand(parent: AnyCommand, name: string, command: AnyCommand): void;
 }
 /** Shared context fields available in both setup and middleware phases. */
 interface BaseContext {
@@ -588,10 +601,21 @@ interface CrustPlugin {
 	setup?: (context: SetupContext, actions: SetupActions) => void | Promise<void>;
 	middleware?: PluginMiddleware;
 }
+/**
+* Build-time validation protocol.
+*
+* `crust build` spawns the user's entrypoint as a subprocess with
+* `CRUST_INTERNAL_VALIDATE_ONLY=1`. When `runMain` detects this env flag it
+* runs validation, surfaces errors via stderr/exitCode, then force-exits.
+*
+* `VALIDATION_RESULT_GLOBAL_KEY` stores the result on `globalThis` for
+* in-process consumers (tests that call `runMain` directly).
+*/
+declare const VALIDATION_MODE_ENV = "CRUST_INTERNAL_VALIDATE_ONLY";
 interface RunOptions {
 	argv?: string[];
 	plugins?: CrustPlugin[];
 }
 declare function runCommand(command: AnyCommand, options?: RunOptions): Promise<void>;
 declare function runMain(command: AnyCommand, options?: RunOptions): Promise<void>;
-export { runMain, runCommand, resolveCommand, parseArgs, defineCommand, ValueType, ValidateVariadicArgs, ValidateNoPrefixedFlags, ValidateFlagAliases, SetupContext, RunOptions, PluginMiddleware, ParseResult, MiddlewareContext, InferFlags, InferArgs, FlagsDef, FlagDef, CrustPlugin, CrustErrorCode, CrustError, CommandRoute, CommandMeta, CommandDef, CommandContext, Command, ArgsDef, ArgDef, AnyCommand };
+export { runMain, runCommand, resolveCommand, parseArgs, defineCommand, ValueType, ValidateVariadicArgs, ValidateNoPrefixedFlags, ValidateFlagAliases, VALIDATION_MODE_ENV, SetupContext, SetupActions, RunOptions, PluginMiddleware, ParseResult, MiddlewareContext, InferFlags, InferArgs, FlagsDef, FlagDef, CrustPlugin, CrustErrorCode, CrustError, CommandRoute, CommandMeta, CommandDef, CommandContext, Command, ArgsDef, ArgDef, AnyCommand };

package/dist/index.js

@@ -1,453 +1,2 @@
 // @bun
-// src/errors.ts
-class CrustError extends Error {
-  code;
-  details;
-  cause;
-  constructor(code, message, ...details) {
-    super(message);
-    this.name = "CrustError";
-    this.code = code;
-    this.details = details[0];
-  }
-  is(code) {
-    return this.code === code;
-  }
-  withCause(cause) {
-    this.cause = cause;
-    return this;
-  }
-}
-
-// src/command.ts
-function defineCommand(config) {
-  if (!config.meta.name.trim()) {
-    throw new CrustError("DEFINITION", "defineCommand: meta.name is required and must be a non-empty string");
-  }
-  if (config.flags) {
-    for (const [name, def] of Object.entries(config.flags)) {
-      if (name.startsWith("no-")) {
-        const base = name.slice(3);
-        throw new CrustError("DEFINITION", `Flag name "--${name}" must not start with "no-"; define "${base}" instead and use "--no-${base}" at runtime`);
-      }
-      if (def.alias) {
-        const aliases = Array.isArray(def.alias) ? def.alias : [def.alias];
-        for (const alias of aliases) {
-          if (alias.startsWith("no-")) {
-            throw new CrustError("DEFINITION", `Alias "--${alias}" on flag "--${name}" must not start with "no-"; the "no-" prefix is reserved for boolean negation`);
-          }
-        }
-      }
-    }
-  }
-  const copy = {
-    ...config,
-    meta: { ...config.meta },
-    ...config.args && {
-      args: config.args.map((def) => ({ ...def }))
-    },
-    flags: config.flags ? Object.fromEntries(Object.entries(config.flags).map(([k, v]) => [k, { ...v }])) : {},
-    ...config.subCommands && {
-      subCommands: { ...config.subCommands }
-    }
-  };
-  return Object.freeze(copy);
-}
-// src/parser.ts
-import {
-  parseArgs as nodeParseArgs
-} from "util";
-function buildParseArgsOptionDescriptor(flagsDef) {
-  const options = {};
-  const aliasToName = {};
-  if (!flagsDef)
-    return { options, aliasToName };
-  const aliasRegistry = new Map;
-  for (const name of Object.keys(flagsDef)) {
-    aliasRegistry.set(name, name);
-  }
-  for (const [name, def] of Object.entries(flagsDef)) {
-    if (name.startsWith("no-")) {
-      const base = name.slice(3);
-      throw new CrustError("DEFINITION", `Flag name "--${name}" must not start with "no-"; define "${base}" instead and use "--no-${base}" at runtime`);
-    }
-    const parseType = def.type === "boolean" ? "boolean" : "string";
-    const opt = { type: parseType };
-    if (def.multiple) {
-      opt.multiple = true;
-    }
-    if (def.alias) {
-      const aliases = Array.isArray(def.alias) ? def.alias : [def.alias];
-      for (const alias of aliases) {
-        if (alias.startsWith("no-")) {
-          throw new CrustError("DEFINITION", `Alias "--${alias}" on flag "--${name}" must not start with "no-"; the "no-" prefix is reserved for boolean negation`);
-        }
-        const existing = aliasRegistry.get(alias);
-        if (existing) {
-          throw new CrustError("DEFINITION", `Alias collision: "${alias.length === 1 ? "-" : "--"}${alias}" is used by both "--${existing}" and "--${name}"`);
-        }
-        aliasRegistry.set(alias, name);
-        aliasToName[alias] = name;
-        if (alias.length === 1 && !opt.short) {
-          opt.short = alias;
-        } else {
-          const aliasOpt = { type: parseType };
-          if (def.multiple) {
-            aliasOpt.multiple = true;
-          }
-          options[alias] = aliasOpt;
-        }
-      }
-    }
-    options[name] = opt;
-  }
-  return { options, aliasToName };
-}
-function coerceValue(value, type, label) {
-  if (type === "number") {
-    const num = Number(value);
-    if (Number.isNaN(num)) {
-      throw new CrustError("PARSE", `Expected number for ${label}, got "${value}"`);
-    }
-    return num;
-  }
-  if (type === "boolean") {
-    return value === "true" || value === "1";
-  }
-  return value;
-}
-function applyDefaultOrThrow(def, label) {
-  if (def.default !== undefined)
-    return def.default;
-  if (def.required === true) {
-    throw new CrustError("VALIDATION", `Missing required ${label}`);
-  }
-  return;
-}
-function coerceFlagValue(name, def, parsedValue) {
-  const label = `--${name}`;
-  if (def.multiple && Array.isArray(parsedValue)) {
-    return def.type === "boolean" ? parsedValue.filter((v) => typeof v === "boolean") : parsedValue.map((v) => coerceValue(v, def.type, label));
-  }
-  if (def.type === "boolean") {
-    if (typeof parsedValue === "boolean") {
-      return parsedValue;
-    }
-    throw new CrustError("PARSE", `Expected boolean value for flag "${label}", got ${typeof parsedValue}`);
-  }
-  if (typeof parsedValue === "string") {
-    return coerceValue(parsedValue, def.type, label);
-  }
-  if (parsedValue === true) {
-    return def.default ?? undefined;
-  }
-  return parsedValue;
-}
-function resolveAliases(parsedValues, aliasToName, flagsDef) {
-  const canonical = {};
-  for (const key in parsedValues) {
-    const canonicalName = aliasToName[key] ?? key;
-    if (!(canonicalName in flagsDef))
-      continue;
-    const value = parsedValues[key];
-    const existing = canonical[canonicalName];
-    if (existing !== undefined && Array.isArray(existing) && Array.isArray(value)) {
-      existing.push(...value);
-    } else {
-      canonical[canonicalName] = value;
-    }
-  }
-  return canonical;
-}
-function resolveFlags(flagsDef, parsedValues, aliasToName) {
-  if (!flagsDef)
-    return {};
-  const canonical = resolveAliases(parsedValues, aliasToName, flagsDef);
-  const resolved = {};
-  for (const [name, def] of Object.entries(flagsDef)) {
-    const parsedValue = canonical[name];
-    if (parsedValue !== undefined) {
-      resolved[name] = coerceFlagValue(name, def, parsedValue);
-      continue;
-    }
-    resolved[name] = def.default ?? undefined;
-  }
-  return resolved;
-}
-function validateRequiredFlags(flagsDef, resolvedFlags) {
-  if (!flagsDef)
-    return;
-  for (const [name, def] of Object.entries(flagsDef)) {
-    if (def.required === true && def.default === undefined) {
-      if (resolvedFlags[name] === undefined) {
-        throw new CrustError("VALIDATION", `Missing required flag "--${name}"`);
-      }
-    }
-  }
-}
-function resolveArgs(argsDef, positionals) {
-  if (!argsDef)
-    return {};
-  const resolved = {};
-  let index = 0;
-  for (const def of argsDef) {
-    const { name } = def;
-    const label = `argument "<${name}>"`;
-    if (def.variadic) {
-      const remaining = positionals.slice(index);
-      if (def.required === true && remaining.length === 0) {
-        throw new CrustError("VALIDATION", `Missing required ${label}`);
-      }
-      resolved[name] = def.type === "string" ? remaining : remaining.map((v) => coerceValue(v, def.type, `<${name}>`));
-      index = positionals.length;
-    } else if (index < positionals.length) {
-      resolved[name] = coerceValue(positionals[index], def.type, `<${name}>`);
-      index++;
-    } else {
-      resolved[name] = applyDefaultOrThrow(def, label);
-    }
-  }
-  return resolved;
-}
-function validateCanonicalNegationUsage(argv, flagsDef, aliasToName) {
-  if (!flagsDef)
-    return;
-  for (const arg of argv) {
-    if (arg === "--")
-      return;
-    if (!arg.startsWith("--no-"))
-      continue;
-    const assignmentIndex = arg.indexOf("=");
-    const rawName = assignmentIndex === -1 ? arg.slice("--no-".length) : arg.slice("--no-".length, assignmentIndex);
-    if (!rawName)
-      continue;
-    const canonical = aliasToName[rawName];
-    if (!canonical)
-      continue;
-    if (canonical === rawName)
-      continue;
-    const def = flagsDef[canonical];
-    if (def?.type !== "boolean")
-      continue;
-    throw new CrustError("PARSE", `Cannot negate alias "--no-${rawName}"; use "--no-${canonical}" instead`);
-  }
-}
-function parseArgs(command, argv) {
-  const argsDef = command.args;
-  const flagsDef = command.flags;
-  const { options: parseOptions, aliasToName } = buildParseArgsOptionDescriptor(flagsDef);
-  validateCanonicalNegationUsage(argv, flagsDef, aliasToName);
-  let parsed;
-  try {
-    parsed = nodeParseArgs({
-      args: argv,
-      options: parseOptions,
-      strict: true,
-      allowPositionals: true,
-      allowNegative: true,
-      tokens: true
-    });
-  } catch (error) {
-    if (error instanceof Error) {
-      const unknownMatch = error.message.match(/Unknown option '(.+?)'/);
-      if (unknownMatch) {
-        throw new CrustError("PARSE", `Unknown flag "${unknownMatch[1]}"`).withCause(error);
-      }
-    }
-    throw new CrustError("PARSE", "Failed to parse command arguments").withCause(error);
-  }
-  const rawArgs = [];
-  const preSeparatorPositionals = [];
-  if (parsed.tokens) {
-    let afterSeparator = false;
-    for (const token of parsed.tokens) {
-      if (token.kind === "option-terminator") {
-        afterSeparator = true;
-        continue;
-      }
-      if (token.kind === "positional") {
-        (afterSeparator ? rawArgs : preSeparatorPositionals).push(token.value ?? "");
-      }
-    }
-  } else {
-    preSeparatorPositionals.push(...parsed.positionals);
-  }
-  const resolvedFlags = resolveFlags(flagsDef, parsed.values, aliasToName);
-  const resolvedArgs = resolveArgs(argsDef, preSeparatorPositionals);
-  validateRequiredFlags(flagsDef, resolvedFlags);
-  return {
-    args: resolvedArgs,
-    flags: resolvedFlags,
-    rawArgs
-  };
-}
-// src/router.ts
-function resolveCommand(command, argv) {
-  const path = [command.meta.name];
-  let current = command;
-  let routedArgv = argv;
-  while (routedArgv.length > 0) {
-    const subCommands = current.subCommands;
-    if (!subCommands || Object.keys(subCommands).length === 0) {
-      break;
-    }
-    const candidate = routedArgv[0];
-    if (!candidate || candidate.startsWith("-")) {
-      break;
-    }
-    if (candidate in subCommands) {
-      current = subCommands[candidate];
-      path.push(candidate);
-      routedArgv = routedArgv.slice(1);
-      continue;
-    }
-    if (current.run) {
-      break;
-    }
-    const available = Object.keys(subCommands);
-    throw new CrustError("COMMAND_NOT_FOUND", `Unknown command "${candidate}".`, {
-      input: candidate,
-      available,
-      commandPath: [...path],
-      parentCommand: current
-    });
-  }
-  return {
-    command: current,
-    argv: routedArgv,
-    commandPath: path
-  };
-}
-// src/run.ts
-function createPluginState() {
-  const map = new Map;
-  return {
-    get(key) {
-      return map.get(key);
-    },
-    has(key) {
-      return map.has(key);
-    },
-    set(key, value) {
-      map.set(key, value);
-    },
-    delete(key) {
-      return map.delete(key);
-    }
-  };
-}
-async function runSetupHooks(plugins, context, actions) {
-  for (const plugin of plugins) {
-    if (!plugin.setup)
-      continue;
-    await plugin.setup(context, actions);
-  }
-}
-async function executeCommand(command, parsed) {
-  if (!command.run)
-    return;
-  const context = {
-    args: parsed.args,
-    flags: parsed.flags,
-    rawArgs: parsed.rawArgs,
-    command
-  };
-  try {
-    if (command.preRun) {
-      await command.preRun(context);
-    }
-    await command.run(context);
-  } finally {
-    if (command.postRun) {
-      await command.postRun(context);
-    }
-  }
-}
-async function runMiddlewareChain(plugins, context, terminal) {
-  const stack = plugins.map((plugin) => plugin.middleware).filter((middleware) => Boolean(middleware));
-  let index = -1;
-  const dispatch = async (i) => {
-    if (i <= index) {
-      throw new CrustError("DEFINITION", "Plugin middleware called next() multiple times");
-    }
-    index = i;
-    if (i === stack.length) {
-      await terminal();
-      return;
-    }
-    const middleware = stack[i];
-    if (!middleware) {
-      throw new CrustError("DEFINITION", "Plugin middleware stack is invalid");
-    }
-    await middleware(context, () => dispatch(i + 1));
-  };
-  await dispatch(0);
-}
-async function runCommand(command, options) {
-  const argv = options?.argv ?? process.argv.slice(2);
-  const plugins = options?.plugins ?? [];
-  const actions = {
-    addFlag(target, name, def) {
-      if (!target.flags) {
-        throw new CrustError("DEFINITION", `Cannot add flag "${name}": command "${target.meta.name}" has no flags object.`);
-      }
-      target.flags[name] = def;
-    }
-  };
-  const middlewareContext = {
-    argv: [...argv],
-    rootCommand: command,
-    state: createPluginState(),
-    route: null,
-    input: null
-  };
-  try {
-    await runSetupHooks(plugins, middlewareContext, actions);
-    let parsed;
-    let resolvedCommand;
-    try {
-      const resolved = resolveCommand(command, [...argv]);
-      middlewareContext.route = resolved;
-      parsed = parseArgs(resolved.command, resolved.argv);
-      middlewareContext.input = {
-        args: parsed.args,
-        flags: parsed.flags,
-        rawArgs: parsed.rawArgs
-      };
-      resolvedCommand = resolved.command;
-    } catch (error) {
-      await runMiddlewareChain(plugins, middlewareContext, async () => {
-        throw error;
-      });
-      return;
-    }
-    await runMiddlewareChain(plugins, middlewareContext, async () => {
-      await executeCommand(resolvedCommand, parsed);
-    });
-  } catch (error) {
-    if (error instanceof CrustError) {
-      throw error;
-    }
-    if (error instanceof Error) {
-      throw new CrustError("EXECUTION", error.message).withCause(error);
-    }
-    throw new CrustError("EXECUTION", String(error)).withCause(error);
-  }
-}
-async function runMain(command, options) {
-  try {
-    await runCommand(command, options);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`Error: ${message}`);
-    process.exitCode = 1;
-  }
-}
-export {
-  runMain,
-  runCommand,
-  resolveCommand,
-  parseArgs,
-  defineCommand,
-  CrustError
-};
+import{a as K,b as I,c as W}from"./shared/chunk-36287c08.js";function G(D){if(!D.meta.name.trim())throw new I("DEFINITION","meta.name must be a non-empty string");if(D.flags)for(let[F,M]of Object.entries(D.flags)){if(F.startsWith("no-")){let P=F.slice(3);throw new I("DEFINITION",`Flag "--${F}" must not use "no-" prefix; define "${P}" and negate with "--no-${P}"`)}if(M.alias){let P=Array.isArray(M.alias)?M.alias:[M.alias];for(let q of P)if(q.startsWith("no-"))throw new I("DEFINITION",`Alias "--${q}" on "--${F}" must not use "no-" prefix (reserved for negation)`)}}let V={...D,meta:{...D.meta},...D.args&&{args:D.args.map((F)=>({...F}))},flags:D.flags?Object.fromEntries(Object.entries(D.flags).map(([F,M])=>[F,{...M}])):{},subCommands:D.subCommands?{...D.subCommands}:{}};return Object.freeze(V)}function Q(D,V){let F=[D.meta.name],M=D,P=V;while(P.length>0){let q=M.subCommands;if(!q||Object.keys(q).length===0)break;let R=P[0];if(!R||R.startsWith("-"))break;if(R in q){M=q[R],F.push(R),P=P.slice(1);continue}if(M.run)break;let J=Object.keys(q);throw new I("COMMAND_NOT_FOUND",`Unknown command "${R}".`,{input:R,available:J,commandPath:[...F],parentCommand:M})}return{command:M,argv:P,commandPath:F}}var Z="CRUST_INTERNAL_VALIDATE_ONLY",O="__CRUST_VALIDATE_RESULT__";function $(){let D=new Map;return{get(V){return D.get(V)},has(V){return D.has(V)},set(V,F){D.set(V,F)},delete(V){return D.delete(V)}}}async function j(D,V,F){for(let M of D){if(!M.setup)continue;await M.setup(V,F)}}function z(D){return{addFlag(V,F,M){if(!V.flags)throw new I("DEFINITION",`Cannot add flag "${F}": "${V.meta.name}" has no flags object`);if(F in V.flags)D?.push(`Plugin flag "--${F}" on "${V.meta.name}" overrides existing flag`);V.flags[F]=M},addSubCommand(V,F,M){if(!F.trim())throw new I("DEFINITION","addSubCommand: name must be a non-empty string");if(V.subCommands[F]){D?.push(`Plugin subcommand "${F}" on "${V.meta.name}" skipped (already exists)`);return}V.subCommands[F]=M}}}async function Y(D,V){let F=V?.argv??process.argv.slice(2),M=V?.plugins??[],P=[],q={argv:[...F],rootCommand:D,state:$()};await j(M,q,z(P));let{validateCommandTree:R}=await import("./shared/chunk-n6bfy2wh.js");R(D);for(let J of P)console.warn(`Warning: ${J}`)}async function y(D,V){if(!D.run)return;let F={args:V.args,flags:V.flags,rawArgs:V.rawArgs,command:D};try{if(D.preRun)await D.preRun(F);await D.run(F)}finally{if(D.postRun)await D.postRun(F)}}async function X(D,V,F){let M=D.map((R)=>R.middleware).filter((R)=>Boolean(R)),P=-1,q=async(R)=>{if(R<=P)throw new I("DEFINITION","Plugin middleware called next() multiple times");if(P=R,R===M.length){await F();return}let J=M[R];if(!J)throw new I("DEFINITION","Plugin middleware stack is invalid");await J(V,()=>q(R+1))};await q(0)}async function B(D,V){let F=V?.argv??process.argv.slice(2),M=V?.plugins??[],P=z(),q={argv:[...F],rootCommand:D,state:$(),route:null,input:null};try{await j(M,q,P);let R,J;try{let N=Q(D,[...F]);q.route=N,R=W(N.command,N.argv),q.input={args:R.args,flags:R.flags,rawArgs:R.rawArgs},J=N.command}catch(N){await X(M,q,async()=>{throw N});return}await X(M,q,async()=>{await y(J,R)})}catch(R){if(R instanceof I)throw R;if(R instanceof Error)throw new I("EXECUTION",R.message).withCause(R);throw new I("EXECUTION",String(R)).withCause(R)}}async function H(D,V){if(process.env[Z]==="1"){let F=(async()=>{try{return await Y(D,V),{ok:!0}}catch(M){let P=M instanceof Error?M.message:String(M);return console.error(P),process.exitCode=1,{ok:!1,error:M}}})();return globalThis[O]=F,await F,process.exit(process.exitCode??0)}try{await B(D,V)}catch(F){let M=F instanceof Error?F.message:String(F);console.error(`Error: ${M}`),process.exitCode=1}}export{H as runMain,B as runCommand,Q as resolveCommand,W as parseArgs,G as defineCommand,Z as VALIDATION_MODE_ENV,I as CrustError};

package/dist/shared/chunk-36287c08.js

@@ -0,0 +1,3 @@
+// @bun
+var A=import.meta.require;class W extends Error{code;details;cause;constructor(j,G,...H){super(G);this.name="CrustError",this.code=j,this.details=H[0]}is(j){return this.code===j}withCause(j){return this.cause=j,this}}import{parseArgs as q}from"util";function U(j){let G={},H={};if(!j)return{options:G,aliasToName:H};let z=new Map;for(let B of Object.keys(j))z.set(B,B);for(let[B,J]of Object.entries(j)){if(B.startsWith("no-")){let X=B.slice(3);throw new W("DEFINITION",`Flag "--${B}" must not use "no-" prefix; define "${X}" and negate with "--no-${X}"`)}let K=J.type==="boolean"?"boolean":"string",L={type:K};if(J.multiple)L.multiple=!0;if(J.alias){let X=Array.isArray(J.alias)?J.alias:[J.alias];for(let Q of X){if(Q.startsWith("no-"))throw new W("DEFINITION",`Alias "--${Q}" on "--${B}" must not use "no-" prefix (reserved for negation)`);let _=z.get(Q);if(_)throw new W("DEFINITION",`Alias collision: "${Q.length===1?"-":"--"}${Q}" is used by both "--${_}" and "--${B}"`);if(z.set(Q,B),H[Q]=B,Q.length===1&&!L.short)L.short=Q;else{let Y={type:K};if(J.multiple)Y.multiple=!0;G[Q]=Y}}}G[B]=L}return{options:G,aliasToName:H}}function $(j,G,H){if(G==="number"){let z=Number(j);if(Number.isNaN(z))throw new W("PARSE",`Expected number for ${H}, got "${j}"`);return z}if(G==="boolean")return j==="true"||j==="1";return j}function I(j,G){if(j.default!==void 0)return j.default;if(j.required===!0)throw new W("VALIDATION",`Missing required ${G}`);return}function M(j,G,H){let z=`--${j}`;if(G.multiple&&Array.isArray(H))return G.type==="boolean"?H.filter((B)=>typeof B==="boolean"):H.map((B)=>$(B,G.type,z));if(G.type==="boolean"){if(typeof H==="boolean")return H;throw new W("PARSE",`Expected boolean value for flag "${z}", got ${typeof H}`)}if(typeof H==="string")return $(H,G.type,z);if(H===!0)return G.default??void 0;return H}function R(j,G,H){let z={};for(let B in j){let J=G[B]??B;if(!(J in H))continue;let K=j[B],L=z[J];if(L!==void 0&&Array.isArray(L)&&Array.isArray(K))L.push(...K);else z[J]=K}return z}function h(j,G,H){if(!j)return{};let z=R(G,H,j),B={};for(let[J,K]of Object.entries(j)){let L=z[J];if(L!==void 0){B[J]=M(J,K,L);continue}B[J]=K.default??void 0}return B}function P(j,G){if(!j)return;for(let[H,z]of Object.entries(j))if(z.required===!0&&z.default===void 0){if(G[H]===void 0)throw new W("VALIDATION",`Missing required flag "--${H}"`)}}function S(j,G){if(!j)return{};let H={},z=0;for(let B of j){let{name:J}=B,K=`argument "<${J}>"`;if(B.variadic){let L=G.slice(z);if(B.required===!0&&L.length===0)throw new W("VALIDATION",`Missing required ${K}`);H[J]=B.type==="string"?L:L.map((X)=>$(X,B.type,`<${J}>`)),z=G.length}else if(z<G.length)H[J]=$(G[z],B.type,`<${J}>`),z++;else H[J]=I(B,K)}return H}function O(j,G,H){if(!G)return;for(let z of j){if(z==="--")return;if(!z.startsWith("--no-"))continue;let B=z.indexOf("="),J=B===-1?z.slice(5):z.slice(5,B);if(!J)continue;let K=H[J];if(!K)continue;if(K===J)continue;if(G[K]?.type!=="boolean")continue;throw new W("PARSE",`Cannot negate alias "--no-${J}"; use "--no-${K}" instead`)}}function x(j,G){let{args:H,flags:z}=j,{options:B,aliasToName:J}=U(z);O(G,z,J);let K;try{K=q({args:G,options:B,strict:!0,allowPositionals:!0,allowNegative:!0,tokens:!0})}catch(Y){if(Y instanceof Error){let Z=Y.message.match(/Unknown option '(.+?)'/);if(Z)throw new W("PARSE",`Unknown flag "${Z[1]}"`).withCause(Y)}throw new W("PARSE","Failed to parse command arguments").withCause(Y)}let L=[],X=[];if(K.tokens){let Y=!1;for(let Z of K.tokens){if(Z.kind==="option-terminator"){Y=!0;continue}if(Z.kind==="positional")(Y?L:X).push(Z.value??"")}}else X.push(...K.positionals);let Q=h(z,K.values,J),_=S(H,X);return P(z,Q),{args:_,flags:Q,rawArgs:L}}
+export{A as a,W as b,x as c};

package/dist/shared/chunk-n6bfy2wh.js

@@ -0,0 +1,2 @@
+// @bun
+import{b as G,c as H}from"./chunk-36287c08.js";function F(j){switch(j.type){case"number":return"1";case"boolean":return"true";default:return"sample"}}function I(j){let q=[];if(j.flags)for(let[w,x]of Object.entries(j.flags)){if(x.required!==!0||x.default!==void 0)continue;if(q.push(`--${w}`),x.type!=="boolean")q.push(F(x))}if(j.args)for(let w of j.args){if(w.required!==!0||w.default!==void 0)continue;q.push(F(w))}return q}function L(j){let q=[{command:j,path:[j.meta.name]}],w=new Set;while(q.length>0){let x=q.pop();if(!x)break;let{command:y,path:D}=x;if(w.has(y))continue;w.add(y);try{H(y,I(y))}catch(z){let B=z instanceof Error?z.message:"Unknown validation error";throw new G("DEFINITION",`Command "${D.join(" ")}" failed runtime validation: ${B}`).withCause(z)}for(let[z,B]of Object.entries(y.subCommands))q.push({command:B,path:[...D,z]})}}export{L as validateCommandTree};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@crustjs/core",
-	"version": "0.0.7",
+	"version": "0.0.9",
 	"description": "Core library for the Crust CLI framework",
 	"type": "module",
 	"license": "MIT",