npm - @crustjs/core - Versions diffs - 0.2.1 → 0.3.1 - Mend

@crustjs/core 0.2.1 → 0.3.1

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.

Files changed (8) hide show

package/README.md +1 -1
package/dist/{types-DjMHz7M6.d.ts → artifacts-D8Jlug-a.d.ts} +46 -4
package/dist/index.d.ts +113 -50
package/dist/index.js +21 -4
package/dist/{invocation-DcA5FqF7.js → invocation-CIvHShiW.js} +129 -25
package/dist/tooling.d.ts +2 -3
package/dist/tooling.js +1 -1
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -5,7 +5,7 @@ Core library for the Crust CLI framework.
 ## Install
 ```sh
-bun add @crustjs/core
+npm install @crustjs/core
 ```
 ## Documentation

package/dist/{types-DjMHz7M6.d.ts → artifacts-D8Jlug-a.d.ts} RENAMED Viewed

@@ -92,6 +92,14 @@ type MergeProviders<A, B> = keyof A extends never ? B : keyof B extends never ?
 type DefName<T> = T extends {
   name: infer N extends string;
 } ? IsClosedName<N> extends true ? N : never : never;
+/**
+ * Statically known `name` members of a definition (or definition union), for spelling grammar.
+ * Filtered per variant: combining names first would let an open variant's `string` absorb
+ * a literal sibling before {@link ClosedMembers} can see it.
+ */
+type DefNameMembers<T> = T extends {
+  name: infer N extends string;
+} ? ClosedMembers<N> : never;
 type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
 type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
 /**
@@ -108,8 +116,14 @@ type HasClosedNames<Ds extends readonly unknown[]> = number extends Ds["length"]
 } ? IsUnion<N> extends true ? false : IsClosedName<N> : false; }[number] ? false : true;
 /** Brand statically known spelling collisions while allowing open names. */
 type CollisionBrand<S extends string, Existing extends string, Key extends string, Before extends string, After extends string> = string extends S | Existing ? {} : [S & Existing] extends [never] ? {} : { readonly [K in Key]: `${Before}"${S & Existing}"${After}`; };
-/** Brand a statically known empty literal while allowing widened and generic names. */
-type EmptyLiteralNameBrand<Name extends string, Err> = IsClosedName<Name> extends true ? ("" extends Name ? Err : {}) : {};
+/**
+ * The statically known members of a name union; open members stay runtime-owned.
+ * Only for local spelling grammar: a literal beside an open template is still
+ * independently invalid, but must never become key or collision evidence.
+ */
+type ClosedMembers<N extends string> = N extends unknown ? IsClosedName<N> extends true ? N : never : never;
+/** Brand a statically known empty literal member while allowing widened and generic names. */
+type EmptyLiteralNameBrand<Name extends string, Err> = "" extends ClosedMembers<Name> ? Err : {};
 /**
  * Brand a definition whose custom parser can return a Promise — parse results
  * are consumed synchronously during argv parsing. `Extract` keeps the check
@@ -600,7 +614,7 @@ type InferArgValue<A extends ArgDef> = A extends {
 } ? ResolveBaseType<A> : A extends {
   default: infer Default;
 } ? undefined extends Default ? ResolveBaseType<A> | undefined : ResolveBaseType<A> : ResolveBaseType<A> | undefined);
-type DuplicateArgNames<A extends readonly ArgDef[], Seen extends string = never> = A extends readonly [infer Head extends ArgDef, ...infer Tail extends readonly ArgDef[]] ? (Head["name"] & Seen) | DuplicateArgNames<Tail, Seen | Head["name"]> : never;
+type DuplicateArgNames<A extends readonly ArgDef[], Seen extends string = never, Duplicates extends string = never> = A extends readonly [infer Head extends ArgDef, ...infer Tail extends readonly ArgDef[]] ? DuplicateArgNames<Tail, Seen | Head["name"], Duplicates | (Head["name"] & Seen)> : Duplicates;
 type InferDuplicateArgs<A extends readonly ArgDef[]> = A extends readonly [infer Head extends ArgDef, ...infer Tail extends readonly ArgDef[]] ? { [K in Head["name"]]: InferArgValue<Head>; } & InferDuplicateArgs<Tail> : {};
 /**
  * Convert a literal ArgsDef tuple into resolved values keyed by argument name.
@@ -825,4 +839,32 @@ interface ValidatedInput<A extends ArgsDef = ArgsDef, F extends FlagsDef = Flags
   flags: InferFlags<F>;
 }
 //#endregion
-export { CollisionBrand as A, UnionToIntersection as B, ValidatedInput as C, CommandSnapshot as D, ArgSnapshot as E, IsStaticTuple as F, defineExtensionId as H, IsUnion as I, LocalValueBrand as L, EmptyLiteralNameBrand as M, HasClosedNames as N, FlagSnapshot as O, IsClosedName as P, MergeContext as R, SectionConsumer as S, RunInputPayload as T, JsonCompatible as U, ExtensionId as V, JsonValue as W, ParseResult as _, CommandSectionInput as a, RuntimeCommandSectionInput as b, FlagsDef as c, InputArgs as d, InputFlags as f, NamedFlagsRecord as g, NamedFlagDef as h, CommandSection as i, DefName as j, Awaitable as k, InferArgs as l, MergeFlags as m, ArgsDef as n, DeclaredDefault as o, InvocationIO as p, CommandMeta as r, FlagDef as s, ArgDef as t, InferFlags as u, ParsedArgValue as v, ValueType as w, SectionAudience as x, ParsedFlagValue as y, MergeProviders as z };
+//#region ../utils/src/artifacts.d.ts
+/**
+ * Set by `crust build` while it prepares the Command Snapshot: the absolute
+ * entry-isolated directory Extension build hooks write into. Core reads it
+ * to run the hooks; `resolveArtifactDir` reads it so sections evaluated during
+ * that run see the artifacts being built instead of the wiped `.crust/root`.
+ */
+declare const BUILD_OUT_DIR_ENV = "CRUST_INTERNAL_BUILD_OUT_DIR";
+/**
+ * Absolute path of a build artifact or `crust.include` directory shipped with
+ * this CLI. `name` is a top-level directory name such as `"skills"`.
+ *
+ * The artifact path is computed from how the CLI is running — never probed:
+ * - Compiled executable (Bun or Deno): `<dir of the executable>/<name>`, which
+ *   is a platform package's `bin/` or wherever the binary was placed.
+ * - Crust-built Node bundle: `<name>` next to the bundle's `bin/` directory,
+ *   i.e. `.crust/root/<name>` in place and `<installed root>/<name>` after install.
+ * - Snapshot preparation inside `crust build`: `<build output dir>/<name>`, the
+ *   artifacts earlier Extension build hooks wrote in this same build.
+ * - Source (`bun run`, `node`, `deno run`): `.crust/root/<name>` under the
+ *   nearest package root of the real `process.argv[1]` entrypoint (following source
+ *   links) — the output of the last `crust build`.
+ *
+ * @throws {Error} when `name` is not a single path segment, or in source mode
+ *   when the entrypoint cannot be resolved or has no enclosing `package.json`.
+ */
+declare function resolveArtifactDir(name: string): string;
+//#endregion
+export { FlagSnapshot as A, IsUnion as B, SectionAudience as C, RunInputPayload as D, ValueType as E, DefNameMembers as F, ExtensionId as G, MergeContext as H, EmptyLiteralNameBrand as I, JsonValue as J, defineExtensionId as K, HasClosedNames as L, ClosedMembers as M, CollisionBrand as N, ArgSnapshot as O, DefName as P, IsClosedName as R, RuntimeCommandSectionInput as S, ValidatedInput as T, MergeProviders as U, LocalValueBrand as V, UnionToIntersection as W, NamedFlagDef as _, CommandMeta as a, ParsedArgValue as b, DeclaredDefault as c, InferArgs as d, InferFlags as f, MergeFlags as g, InvocationIO as h, ArgsDef as i, Awaitable as j, CommandSnapshot as k, FlagDef as l, InputFlags as m, resolveArtifactDir as n, CommandSection as o, InputArgs as p, JsonCompatible as q, ArgDef as r, CommandSectionInput as s, BUILD_OUT_DIR_ENV as t, FlagsDef as u, NamedFlagsRecord as v, SectionConsumer as w, ParsedFlagValue as x, ParseResult as y, IsStaticTuple as z };

package/dist/index.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { A as CollisionBrand, B as UnionToIntersection, C as ValidatedInput, D as CommandSnapshot, E as ArgSnapshot, F as IsStaticTuple, H as defineExtensionId, I as IsUnion, L as LocalValueBrand, M as EmptyLiteralNameBrand, N as HasClosedNames, O as FlagSnapshot, P as IsClosedName, R as MergeContext, S as SectionConsumer, T as RunInputPayload, U as JsonCompatible, V as ExtensionId, W as JsonValue, _ as ParseResult, a as CommandSectionInput, b as RuntimeCommandSectionInput, c as FlagsDef, d as InputArgs, f as InputFlags, g as NamedFlagsRecord, h as NamedFlagDef, i as CommandSection, j as DefName, k as Awaitable, l as InferArgs, m as MergeFlags, n as ArgsDef, p as InvocationIO, r as CommandMeta, s as FlagDef, t as ArgDef, u as InferFlags, v as ParsedArgValue, w as ValueType, x as SectionAudience, y as ParsedFlagValue, z as MergeProviders } from "./types-DjMHz7M6.js";
+import { A as FlagSnapshot, B as IsUnion, C as SectionAudience, D as RunInputPayload, E as ValueType, F as DefNameMembers, G as ExtensionId, H as MergeContext, I as EmptyLiteralNameBrand, J as JsonValue, K as defineExtensionId, L as HasClosedNames, M as ClosedMembers, N as CollisionBrand, O as ArgSnapshot, P as DefName, R as IsClosedName, S as RuntimeCommandSectionInput, T as ValidatedInput, U as MergeProviders, V as LocalValueBrand, W as UnionToIntersection, _ as NamedFlagDef, a as CommandMeta, b as ParsedArgValue, d as InferArgs, f as InferFlags, g as MergeFlags, h as InvocationIO, i as ArgsDef, j as Awaitable, k as CommandSnapshot, l as FlagDef, m as InputFlags, n as resolveArtifactDir, o as CommandSection, p as InputArgs, q as JsonCompatible, r as ArgDef, s as CommandSectionInput, u as FlagsDef, v as NamedFlagsRecord, w as SectionConsumer, x as ParsedFlagValue, y as ParseResult, z as IsStaticTuple } from "./artifacts-D8Jlug-a.js";
 //#region src/validation/args.brands.d.ts
 type ArgNames<A extends readonly object[]> = DefName<A[number]>;
 type DuplicateArgBrand<A, Existing extends string> = CollisionBrand<DefName<A>, Existing, "FIX_DUPLICATE_ARG", "Argument name ", " is already defined">;
@@ -7,7 +7,7 @@ type EmptyArgNameError = {
 };
 /** Reject empty argument names, including empty members of a name union. */
 type EmptyArgNameBrand<Name extends string> = EmptyLiteralNameBrand<Name, EmptyArgNameError>;
-type EmptyArgDefinitionNameBrand<A> = "" extends DefName<A> ? EmptyArgNameError : {};
+type EmptyArgDefinitionNameBrand<A> = EmptyArgNameBrand<DefNameMembers<A>>;
 type ArgChecks<A, Existing extends string> = A & DuplicateArgBrand<A, Existing> & LocalValueBrand<A> & EmptyArgDefinitionNameBrand<A>;
 /**
  * Per-arg validation tuple type. Resolves to `A` when the constraints are
@@ -44,8 +44,9 @@ type AliasesOf<C> = C extends {
   readonly aliases: infer A extends readonly string[];
 } ? A : "aliases" extends keyof C ? readonly string[] : readonly [];
 type NarrowAliases<A extends readonly string[]> = IsClosedName<A[number]> extends true ? A[number] : never;
+type AliasMembers<A extends readonly string[]> = ClosedMembers<A[number]>;
 type AliasShapeError<Name extends string, Alias extends string> = Alias extends "" ? `Subcommand "${Name}" has an invalid alias: must be a non-empty string` : Alias extends `${string} ${string}` | `${string}\t${string}` | `${string}\n${string}` | `${string}\r${string}` | `${string}\v${string}` | `${string}\f${string}` ? `Subcommand "${Name}" alias "${Alias}" must not contain whitespace` : Alias extends `-${string}` ? `Subcommand "${Name}" alias "${Alias}" must not start with "-" (reserved for flags)` : string extends Name ? never : Alias extends Name ? `Subcommand "${Name}" alias "${Alias}" must not equal its own canonical name` : never;
-type AliasShapeErrors<Name extends string, C> = NarrowAliases<AliasesOf<C>> extends (infer Alias) ? Alias extends string ? AliasShapeError<Name, Alias> : never : never;
+type AliasShapeErrors<Name extends string, C> = AliasMembers<AliasesOf<C>> extends (infer Alias) ? Alias extends string ? AliasShapeError<Name, Alias> : never : never;
 type AliasShapeBrand<Name extends string, C> = [AliasShapeErrors<Name, C>] extends [never] ? {} : {
   readonly FIX_ALIAS_SHAPE: AliasShapeErrors<Name, C>;
 };
@@ -59,8 +60,8 @@ type EmptyNameError = {
 };
 type TrimWhitespace = " " | "\t" | "\n" | "\r" | "\v" | "\f" | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | "　" | "";
 type BlankName<Name extends string> = Name extends `${TrimWhitespace}${infer Tail}` ? BlankName<Tail> : Name extends "" ? true : false;
-/** Runtime checks own open names; provably invalid literal members remain errors. */
-type CommandNameBrand<Name extends string> = IsClosedName<Name> extends false ? {} : true extends BlankName<Name> ? EmptyNameError : "__proto__" extends Name ? {
+/** Runtime checks own open members; every statically known member is validated, even beside an open one. */
+type CommandNameBrand<Name extends string> = true extends BlankName<ClosedMembers<Name>> ? EmptyNameError : "__proto__" extends ClosedMembers<Name> ? {
   readonly FIX_RESERVED_NAME: "Command name \"__proto__\" is reserved";
 } : {};
 type DefinitionAliases<D> = CommandDefinitionData<D> extends {
@@ -70,9 +71,9 @@ type DefinitionAliases<D> = CommandDefinitionData<D> extends {
 type CommandDefinitionSpellings<D> = D extends unknown ? D extends {
   name: infer N extends string;
 } ? IsUnion<N> extends true ? never : DefName<D> extends (infer Name extends string) ? [Name] extends [never] ? never : Name | NarrowAliases<DefinitionAliases<D>> : never : never : never;
-type SelfAliasBrand<D> = DefName<D> & NarrowAliases<DefinitionAliases<D>> extends (infer Dup extends string) ? [Dup] extends [never] ? {} : {
+type SelfAliasBrand<D> = UnionToIntersection<D extends unknown ? DefNameMembers<D> & AliasMembers<DefinitionAliases<D>> extends (infer Dup extends string) ? [Dup] extends [never] ? {} : {
   readonly FIX_ALIAS_SHAPE: `Command "${Dup}" must not list its own canonical name as an alias`;
-} : never;
+} : never : never>;
 type CommandCollisionBrand<Spellings extends string, Existing extends string> = CollisionBrand<Spellings, Existing, "FIX_COMMAND_COLLISION", "Command name or alias ", " collides with a sibling command">;
 /**
  * Validate definitions against existing siblings and definitions earlier in
@@ -80,7 +81,7 @@ type CommandCollisionBrand<Spellings extends string, Existing extends string> =
  * not statically knowable; their literal aliases opt out with them
  * (see {@link CommandDefinitionSpellings}).
  */
-type ValidateCommandDefinitions<Ds extends readonly unknown[], Existing extends string = never> = Ds extends readonly [infer Head, ...infer Tail] ? CommandDefinitionSpellings<Head> extends (infer Spellings extends string) ? readonly [Head & CommandCollisionBrand<Spellings, Existing> & CommandNameBrand<DefName<Head>> & SelfAliasBrand<Head>, ...ValidateCommandDefinitions<Tail, Existing | Spellings>] : never : Ds;
+type ValidateCommandDefinitions<Ds extends readonly unknown[], Existing extends string = never> = Ds extends readonly [infer Head, ...infer Tail] ? CommandDefinitionSpellings<Head> extends (infer Spellings extends string) ? readonly [Head & CommandCollisionBrand<Spellings, Existing> & CommandNameBrand<DefNameMembers<Head>> & SelfAliasBrand<Head>, ...ValidateCommandDefinitions<Tail, Existing | Spellings>] : never : Ds;
 type ExtensionCommandDefs<E> = [E] extends [never] ? readonly [] : DefiningOf<E> extends {
   readonly commands?: infer Cs extends readonly unknown[];
 } ? Cs : readonly [];
@@ -180,17 +181,29 @@ type KnownContextInstances<Cs extends readonly AnyContextInstance[]> = { [I in k
 //#region src/validation/flags.brands.d.ts
 /** Brand an incoming definition when one of its spellings is already claimed. */
 type ExistingFlagCollisionBrand<F, Existing extends string> = CollisionBrand<DefName<F> | ExtractAllAliases<F>, Existing, "FIX_ALIAS_COLLISION", "Flag spelling ", " collides with an existing flag">;
+/**
+ * Every statically known canonical, short, and long-alias member, including literals
+ * beside an open member. Spelling grammar only: collision evidence stays with
+ * {@link ExtractAllAliases}, which must not leak literals out of an open domain.
+ * Each field is filtered on its own so a `string`-typed field cannot absorb a
+ * sibling field's invalid literal before the filter runs.
+ */
+type SpellingMembers<F> = DefNameMembers<F> | ClosedMembers<F extends {
+  short: infer S extends string;
+} ? S : never> | ClosedMembers<F extends {
+  aliases: infer A extends readonly string[];
+} ? A[number] : never>;
 /** Reject `__proto__`, which mutates the prototype of plain-object flag registries. */
-type ReservedSpellingBrand<F> = "__proto__" extends DefName<F> | ExtractAllAliases<F> ? {
+type ReservedSpellingBrand<F> = "__proto__" extends SpellingMembers<F> ? {
   readonly FIX_RESERVED_SPELLING: "Flag spelling \"__proto__\" is reserved";
 } : {};
 type EmptySpellingError = {
   readonly FIX_EMPTY_SPELLING: "Flag names and aliases must be non-empty strings";
 };
-/** Reject empty flag names, including empty members of a name union. */
+/** Reject empty flag names, including an empty member of a name union beside an open member. */
 type EmptyFlagSpellingBrand<Name extends string> = EmptyLiteralNameBrand<Name, EmptySpellingError>;
 /** Reject empty spellings: their CLI tokens (`--`, `-`) are unparseable, so the flag can never be supplied. */
-type EmptySpellingBrand<F> = "" extends DefName<F> | ExtractAllAliases<F> ? EmptySpellingError : {};
+type EmptySpellingBrand<F> = "" extends SpellingMembers<F> ? EmptySpellingError : {};
 type RepeatedAliases<Aliases extends readonly string[], Seen extends string> = Aliases extends readonly [infer Head extends string, ...infer Tail extends readonly string[]] ? (Head & Seen) | RepeatedAliases<Tail, Seen | Head> : never;
 type OwnAliasesBrand<F> = F extends {
   aliases: infer Aliases extends readonly string[];
@@ -298,7 +311,7 @@ type HasClosedFlagSpellings<F> = F extends {
   aliases: infer A extends readonly string[];
 } ? false extends IsStaticTuple<A> | IsClosedName<A[number]> ? false : true : false : true) ? false : true : false;
 type LocalFlagBrand<F> = UnionToIntersection<F extends unknown ? LocalFlagBranchBrand<F> : never>;
-type LocalFlagBranchBrand<F> = LocalValueBrand<F> & OwnAliasesBrand<F> & ShortLengthBrand<F> & ReservedSpellingBrand<F> & EmptySpellingBrand<F> & NoPrefixBrand<DefName<F> | ExtractAllAliases<F>> & ([DefName<F> & ExtractAllAliases<F>] extends [never] ? {} : {
+type LocalFlagBranchBrand<F> = LocalValueBrand<F> & OwnAliasesBrand<F> & ShortLengthBrand<F> & ReservedSpellingBrand<F> & EmptySpellingBrand<F> & NoPrefixBrand<SpellingMembers<F>> & ([DefName<F> & ExtractAllAliases<F>] extends [never] ? {} : {
   readonly FIX_ALIAS_COLLISION: "Flag repeats one of its own spellings";
 });
 /** Validate provable local fields and destination relations without inventing names for open inputs. */
@@ -379,6 +392,18 @@ type CompatibleRunBranch<Expected, Actual> = Actual extends Expected ? Actual :
 type CompatibleRunInput<Shape extends CommandShape, Input> = CompatibleRunValue<RunInput<Shape>, Input>;
 type RunInputArguments<Shape extends CommandShape> = {} extends RunInput<Shape> ? readonly [input?: RunInput<Shape>] : readonly [input: RunInput<Shape>];
 type RunArguments<Shape extends CommandShape> = readonly [...RunInputArguments<Shape>, io?: Partial<InvocationIO>];
+/**
+ * Typed invoker bound to one command in an app, returned by {@link Crust.at}.
+ *
+ * `run` accepts the same structured input and IO as `Crust.run` with the path
+ * already applied, so a handle can be re-exported as a plain typed function.
+ */
+interface CommandHandle<Shape extends CommandShape> {
+  /** The typed path this handle was created with (`[]` selects the root). */
+  readonly path: readonly string[];
+  run(...args: RunArguments<Shape>): Promise<RunOutcome<Shape["result"]>>;
+  run<const Input>(input: Input, ...validation: [Input] extends [CompatibleRunInput<Shape, Input>] ? readonly [io?: Partial<InvocationIO>] : readonly [invalidInput: never]): Promise<RunOutcome<Shape["result"]>>;
+}
 /** Static configuration for a reusable command definition. */
 interface CommandConfig extends Omit<CommandMeta, "name" | "sections" | "version"> {
   /** Plain-text sections rendered after built-in command documentation. */
@@ -435,9 +460,9 @@ type DepsOfBuilder<B> = UnionToIntersection<B extends {
     deps: infer Deps extends ContextMap;
   };
 } ? Deps : {}> extends (infer Merged extends ContextMap) ? Merged : {};
-type DefinitionShapeForSpelling<D, Spelling extends string> = CommandDefinitionData<D> extends {
+type DefinitionShapeForSpelling<D, Spelling extends string> = D extends unknown ? CommandDefinitionData<D> extends {
   readonly _shape?: infer Shape extends CommandShape;
-} ? Spelling extends CommandDefinitionSpellings<D> ? Shape : never : never;
+} ? Spelling extends CommandDefinitionSpellings<D> ? Shape : never : never : never;
 type ShapeWithInheritedFlags<S, CF extends FlagsDef> = keyof CF extends never ? S : S extends CommandShape<infer SA, infer SF, infer SC, infer SR, infer P> ? CommandShape<SA, MergeFlags<CF, SF>, { [K in keyof SC]: ShapeWithInheritedFlags<SC[K], CF>; }, SR, P> : never;
 type DefinitionsTree<Ds extends readonly CommandDefinition<any, any, any, any>[], CtxFlags extends FlagsDef = {}> = string extends AttachedCommandSpellings<Ds> ? Record<string, CommandShape> & KnownDefinitionTree<Ds, CtxFlags> : { [K in CommandDefinitionSpellings<Ds[number]>]: ShapeWithInheritedFlags<DefinitionShapeForSpelling<Ds[number], K>, CtxFlags>; };
 type KnownDefinitionTree<Ds extends readonly unknown[], CF extends FlagsDef> = IsUnion<Ds> extends true ? {} : Ds extends readonly [infer H, ...infer T] ? (IsUnion<H> extends true ? {} : { [K in CommandDefinitionSpellings<H>]: ShapeWithInheritedFlags<DefinitionShapeForSpelling<H, K>, CF>; }) & KnownDefinitionTree<T, CF> : {};
@@ -502,7 +527,8 @@ export declare function defineCommand<const Name extends string, const C extends
  *   });
  * ```
  */
-type CollisionSpellings<Extensions extends string = never, Tree extends string = never, Demands extends ContextMap = {}, Pending extends string = never, RecipeDeps extends ContextMap = {}, Providers extends Record<string, ContextValue> = {}> = {
+type CollisionSpellings<Extensions extends string = never, Tree extends string = never, Demands extends ContextMap = {}, Pending extends string = never, RecipeDeps extends ContextMap = {}, Providers extends Record<string, ContextValue> = {}, ActionDeps extends ContextMap = {}> = {
+  readonly actionDeps: ActionDeps;
   readonly pending: Pending;
   readonly demands: Demands;
   readonly extension: Extensions;
@@ -511,6 +537,7 @@ type CollisionSpellings<Extensions extends string = never, Tree extends string =
   readonly providers: Providers;
 };
 type AnyCollisionSpellings = {
+  readonly actionDeps?: ContextMap;
   readonly pending: string;
   readonly demands: ContextMap;
   readonly extension: string;
@@ -524,13 +551,19 @@ type RecipeDepsOf<S extends AnyCollisionSpellings> = S extends {
 type ProvidersOf<S extends AnyCollisionSpellings> = S extends {
   readonly providers: infer Providers extends Record<string, ContextValue>;
 } ? Providers : {};
+/** Obligations of this node's stored action, never inherited by descendants. */
+type ActionDepsOf<S extends AnyCollisionSpellings> = S extends {
+  readonly actionDeps: infer Deps extends ContextMap;
+} ? Deps : {};
 type AfterFlags<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Defs extends readonly NamedFlagDef[], Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<MergeFlags<Flags, AttachedFlags<Defs>>, A, Ctx, Sibs, Sp | AttachedSpellings<Defs>, Tree, CtxFlags, CollisionSp, Result, Meta, string, Caps>;
 type AfterArgs<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, NewA extends ArgsDef, Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<Flags, AppendedArgs<A, NewA>, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, Meta, string, Caps>;
-type AfterUse<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Fs extends readonly AnyContextFactory[], Meta extends RootCommandMeta | undefined> = Crust<Flags, A, MergeContext<Ctx, ContextDependencies<Fs>>, Sibs, Sp, Tree, CtxFlags, CollisionSpellings<CollisionSp["extension"], CollisionSp["tree"], CollisionSp["demands"], CollisionSp["pending"], MergeContext<RecipeDepsOf<CollisionSp>, ContextDependencies<Fs>>, ProvidersOf<CollisionSp>>, Result, Meta, string, "recipe">;
-type AfterProvide<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Cs extends readonly AnyContextInstance[], Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<MergeFlags<Flags, ContextsOwnedFlags<Cs>>, A, MergeProviders<Ctx, ContextsOutput<Cs>>, Sibs, Sp | LocalSpellingsOf<ContextsOwnedFlags<Cs>>, Tree, MergeFlags<CtxFlags, ContextsOwnedFlags<Cs>>, CollisionSpellings<CollisionSp["extension"], CollisionSp["tree"], CollisionSp["demands"], CollisionSp["pending"], RecipeDepsOf<CollisionSp>, MergeProviders<ProvidersOf<CollisionSp>, ContextsOutput<Cs>>>, Result, Meta, string, Caps>;
-type AfterAction<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, R, Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Awaited<R>, Meta, string, Caps>;
-type AfterExtend<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Es extends readonly AnyExtension[], Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<MergeFlags<Flags, ExtensionFlags<Es>>, A, MergeProviders<Ctx, ExtensionsProvidesOutput<Es>>, Sibs | ExtensionsCommandSpellings<Es>, Sp | ExtensionsSpellings<Es>, ExtendedTree<Tree, Es, RecursiveExtensionFlags<Es>, CtxFlags>, MergeFlags<CtxFlags, RecursiveExtensionFlags<Es>>, CollisionSpellings<CollisionSp["extension"] | ExtensionsSpellings<Es>, CollisionSp["tree"] | DefinitionTreeSpellings<ExtensionCommands<Es>>, CollisionSp["demands"] & ExtensionDemandValues<Es>, CollisionSp["pending"] | DefinitionTreeSpellings<ExtensionCommands<Es>>, RecipeDepsOf<CollisionSp>, MergeProviders<ProvidersOf<CollisionSp>, ExtensionsProvidesOutput<Es>>>, Result, Meta, string, Caps>;
-type AfterAdd<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Ds extends readonly CommandDefinition<any, any, any, any>[], Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<Flags, A, Ctx, Sibs | AttachedCommandSpellings<Ds>, Sp, Tree & DefinitionsTree<Ds, CtxFlags>, CtxFlags, CollisionSpellings<CollisionSp["extension"], CollisionSp["tree"] | DefinitionTreeSpellings<Ds>, CollisionSp["demands"], CollisionSp["pending"], RecipeDepsOf<CollisionSp>, ProvidersOf<CollisionSp>>, Result, Meta, string, Caps>;
+type AfterUse<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Fs extends readonly AnyContextFactory[], Meta extends RootCommandMeta | undefined> = Crust<Flags, A, MergeContext<Ctx, ContextDependencies<Fs>>, Sibs, Sp, Tree, CtxFlags, CollisionSpellings<CollisionSp["extension"], CollisionSp["tree"], CollisionSp["demands"], CollisionSp["pending"], MergeContext<RecipeDepsOf<CollisionSp>, ContextDependencies<Fs>>, ProvidersOf<CollisionSp>, ActionDepsOf<CollisionSp>>, Result, Meta, string, "recipe">;
+type AfterProvide<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Cs extends readonly AnyContextInstance[], Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<MergeFlags<Flags, ContextsOwnedFlags<Cs>>, A, MergeProviders<Ctx, ContextsOutput<Cs>>, Sibs, Sp | LocalSpellingsOf<ContextsOwnedFlags<Cs>>, Tree, MergeFlags<CtxFlags, ContextsOwnedFlags<Cs>>, CollisionSpellings<CollisionSp["extension"], CollisionSp["tree"], CollisionSp["demands"], CollisionSp["pending"], RecipeDepsOf<CollisionSp>, MergeProviders<ProvidersOf<CollisionSp>, ContextsOutput<Cs>>, ActionDepsOf<CollisionSp>>, Result, Meta, string, Caps>;
+type AfterAction<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, R, Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, Omit<CollisionSp, "actionDeps"> & {
+  readonly actionDeps: Ctx;
+}, Awaited<R>, Meta, string, Caps>;
+type AfterExtend<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Es extends readonly AnyExtension[], Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<MergeFlags<Flags, ExtensionFlags<Es>>, A, MergeProviders<Ctx, ExtensionsProvidesOutput<Es>>, Sibs | ExtensionsCommandSpellings<Es>, Sp | ExtensionsSpellings<Es>, ExtendedTree<Tree, Es, RecursiveExtensionFlags<Es>, CtxFlags>, MergeFlags<CtxFlags, RecursiveExtensionFlags<Es>>, CollisionSpellings<CollisionSp["extension"] | ExtensionsSpellings<Es>, CollisionSp["tree"] | DefinitionTreeSpellings<ExtensionCommands<Es>>, CollisionSp["demands"] & ExtensionDemandValues<Es>, CollisionSp["pending"] | DefinitionTreeSpellings<ExtensionCommands<Es>>, RecipeDepsOf<CollisionSp>, MergeProviders<ProvidersOf<CollisionSp>, ExtensionsProvidesOutput<Es>>, ActionDepsOf<CollisionSp>>, Result, Meta, string, Caps>;
+type AfterAdd<Flags extends FlagsDef, A extends ArgsDef, Ctx extends ContextMap, Sibs extends string, Sp extends string, Tree extends object, CtxFlags extends FlagsDef, CollisionSp extends AnyCollisionSpellings, Result, Ds extends readonly CommandDefinition<any, any, any, any>[], Meta extends RootCommandMeta | undefined, Caps extends "app" | "recipe"> = Crust<Flags, A, Ctx, Sibs | AttachedCommandSpellings<Ds>, Sp, Tree & DefinitionsTree<Ds, CtxFlags>, CtxFlags, CollisionSpellings<CollisionSp["extension"], CollisionSp["tree"] | DefinitionTreeSpellings<Ds>, CollisionSp["demands"], CollisionSp["pending"], RecipeDepsOf<CollisionSp>, ProvidersOf<CollisionSp>, ActionDepsOf<CollisionSp>>, Result, Meta, string, Caps>;
 type ExtensionDemandValues<Es extends readonly AnyExtension[]> = UnionToIntersection<DefiningOf<Es[number]> extends {
   readonly _hookDeps?: infer H extends ContextMap;
 } ? H : Record<string, ContextValue>> extends (infer D extends ContextMap) ? D : {};
@@ -588,7 +621,7 @@ export declare class Crust<Flags extends FlagsDef = {}, A extends ArgsDef = [],
    * @param defs - Named flag definitions
    * @returns A new `Crust` instance with the given flags
    */
-  flags<const Defs extends readonly NamedFlagDef[]>(...defs: ValidateLocalFlagDefs<Defs, Sp>): AfterFlags<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, Defs, Meta, Caps>;
+  flags<const Defs extends readonly NamedFlagDef[], _Union extends this = never>(...defs: ValidateLocalFlagDefs<Defs, Sp>): AfterFlags<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, Defs, Meta, Caps>;
   /**
    * Define positional arguments for this command; argument order is the
    * order they are passed (created with `defineArg(name, def)` or written
@@ -600,12 +633,12 @@ export declare class Crust<Flags extends FlagsDef = {}, A extends ArgsDef = [],
    * @param defs - Positional argument definitions, in positional order
    * @returns A new `Crust` instance with the combined args
    */
-  args<const NewA extends ArgsDef>(...defs: NewA & AppendArgsChecks<A, NewA>): AfterArgs<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, NewA, Meta, Caps>;
+  args<const NewA extends ArgsDef, _Union extends this = never>(...defs: NewA & AppendArgsChecks<A, NewA>): AfterArgs<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, NewA, Meta, Caps>;
   /**
    * Declare Contexts this command consumes without supplying their values.
    * Factory references are retained while setup stays lazy.
    */
-  use<const Fs extends readonly [AnyContextFactory, ...AnyContextFactory[]]>(this: {
+  use<const Fs extends readonly [AnyContextFactory, ...AnyContextFactory[]] = never>(this: {
     readonly _types: {
       readonly caps: "recipe";
     };
@@ -620,7 +653,7 @@ export declare class Crust<Flags extends FlagsDef = {}, A extends ArgsDef = [],
    * Extension commands. Consuming operations throw `DEFINITION` for actual collisions.
    *
    */
-  provide<const Cs extends readonly AnyContextInstance[]>(...instances: KnownContextInstances<Cs> & ProvideChecks<Sp | CollisionSp["pending"], Cs> & ValidateContextNames<Caps extends "recipe" ? ProvidersOf<CollisionSp> : Ctx, Cs> & ValidateContextDeps<Ctx, Cs> & DeclaredDependencyValuesBrand<CollisionSp["demands"] & RecipeDepsOf<CollisionSp>, ContextsOutput<NoInfer<Cs>>>): AfterProvide<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, Cs, Meta, Caps>;
+  provide<const Cs extends readonly AnyContextInstance[] = never>(...instances: KnownContextInstances<Cs> & ProvideChecks<Sp | CollisionSp["pending"], Cs> & ValidateContextNames<Caps extends "recipe" ? ProvidersOf<CollisionSp> : Ctx, Cs> & ValidateContextDeps<Ctx, Cs> & DeclaredDependencyValuesBrand<CollisionSp["demands"] & RecipeDepsOf<CollisionSp> & ActionDepsOf<CollisionSp>, ContextsOutput<NoInfer<Cs>>>): AfterProvide<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, Cs, Meta, Caps>;
   /**
    * Define the Command Action — the function that implements this
    * command's behavior after its inputs are ready.
@@ -628,8 +661,9 @@ export declare class Crust<Flags extends FlagsDef = {}, A extends ArgsDef = [],
    * The action receives a {@link CrustCommandContext} with `args` typed from
    * `.args()` and `flags` typed from the accumulated `Flags`.
    *
-   * Calling `.action()` again replaces the command behavior on the new builder.
-   * The original builder is not mutated.
+   * Calling `.action()` again replaces the command behavior and its Context obligations
+   * on the new builder. Later local providers must satisfy the bound Context value types;
+   * descendants may shadow independently. The original builder is not mutated.
    *
    * @param action - The Command Action function
    * @returns A new `Crust` instance with the action registered
@@ -650,7 +684,7 @@ export declare class Crust<Flags extends FlagsDef = {}, A extends ArgsDef = [],
    * metadata by TypeScript, not at runtime.
    * Recipe builders cannot call this root-only method.
    */
-  extend<const Es extends readonly Extension<any, any, any, any, DefinedRootMetaKeys<Meta>>[]>(this: {
+  extend<const Es extends readonly Extension<any, any, any, any, DefinedRootMetaKeys<Meta>>[], _Union extends this = never>(this: {
     readonly _types: {
       readonly caps: "app";
     };
@@ -662,7 +696,7 @@ export declare class Crust<Flags extends FlagsDef = {}, A extends ArgsDef = [],
    * under its own carried name (use `.as(name)` to rename).
    *
    */
-  add<const Ds extends readonly CommandDefinition<any, any, any, any>[]>(...definitions: Ds & ValidateCommandDefinitions<Ds, Sibs> & ValidateDeclaredDeps<Ctx, Ds> & DefinitionDescendantValuesBrand<Ds, CollisionSp["demands"]> & ValidateDefinitionFlags<Ds, CollisionSp["extension"] | LocalSpellingsOf<CtxFlags>>): AfterAdd<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, Ds, Meta, Caps>;
+  add<const Ds extends readonly CommandDefinition<any, any, any, any>[] = never>(...definitions: Ds & ValidateCommandDefinitions<Ds, Sibs> & ValidateDeclaredDeps<Ctx, Ds> & DefinitionDescendantValuesBrand<Ds, CollisionSp["demands"]> & ValidateDefinitionFlags<Ds, CollisionSp["extension"] | LocalSpellingsOf<CtxFlags>>): AfterAdd<Flags, A, Ctx, Sibs, Sp, Tree, CtxFlags, CollisionSp, Result, Ds, Meta, Caps>;
   /**
    * Define an app-local leaf subcommand inline (root-only sugar for
    * `.add(defineCommand(name, recipe))`).
@@ -714,6 +748,22 @@ export declare class Crust<Flags extends FlagsDef = {}, A extends ArgsDef = [],
       readonly caps: "app";
     };
   }, path: Path & KnownCommandPath<Path, Tree>, input: Input, ...validation: [Input] extends [CompatibleRunInput<CommandShapeAt<CommandShape<A, Flags, Tree, Result>, NoInfer<Path>>, Input>] ? readonly [io?: Partial<InvocationIO>] : readonly [invalidInput: never]): Promise<RunOutcome<CommandShapeAt<CommandShape<A, Flags, Tree, Result>, Path>["result"]>>;
+  /**
+   * Bind a typed command path into a reusable {@link CommandHandle}.
+   *
+   * Validates the path eagerly against the prepared command tree, so an
+   * unknown path throws `COMMAND_NOT_FOUND` here rather than on the first
+   * `handle.run()`. The handle is bound to this builder's tree; commands added
+   * afterwards belong to the new builder returned by `.add()`.
+   *
+   * @param path - Typed path to the command to bind (`[]` selects the root)
+   * @throws {CrustError} COMMAND_NOT_FOUND when the path does not name a command
+   */
+  at<const Path extends CommandPath<Tree>>(this: {
+    readonly _types: {
+      readonly caps: "app";
+    };
+  }, path: Path & KnownCommandPath<Path, Tree>): CommandHandle<CommandShapeAt<CommandShape<A, Flags, Tree, Result>, Path>>;
   /**
    * Parse `process.argv`, resolve subcommands, run Extension hooks, and
    * execute the matched Command Action.
@@ -867,24 +917,31 @@ type RootMetaKey = keyof RootCommandMeta;
 type RootCommandSnapshot<K extends RootMetaKey> = CommandSnapshot & {
   readonly meta: Readonly<Required<Pick<CommandMeta, K>>>;
 };
-/** Artifact paths relative to `outDir`. */
-type BuildArtifacts = readonly string[];
-/** Artifacts reported by Extension build hooks, in hook execution order. */
+/** One file a build hook produces; `path` is POSIX-relative to the build output directory. */
+interface BuildFile {
+  readonly path: string;
+  readonly content: string | Uint8Array;
+}
+/** Files returned by a build hook; build tooling writes them into the build output directory. */
+type BuildArtifacts = readonly BuildFile[];
+/** Files written for each Extension build hook, in hook execution order. */
 interface BuildReport {
   readonly extensions: readonly {
     readonly id: ExtensionId;
-    readonly files: readonly string[] | "unknown";
+    readonly files: readonly string[];
   }[];
 }
-/** Build-time context passed to an Extension's artifact generator. */
+/**
+ * Build-time context passed to an Extension's artifact generator. It deliberately
+ * carries no output directory: build tooling owns that tree, so every shipped file
+ * is a returned {@link BuildFile} and the {@link BuildReport} is exact.
+ */
 interface ExtensionBuildContext<MetaKeys extends RootMetaKey = never> {
   /**
    * Frozen snapshot prepared before this hook starts. It does not include this hook's own
    * outputs; later-registered hooks receive refreshed snapshots.
    */
   readonly snapshot: RootCommandSnapshot<MetaKeys>;
-  /** Resolved absolute output directory. */
-  readonly outDir: string;
 }
 /**
  * Readonly invocation view passed to Extension hooks.
@@ -998,15 +1055,14 @@ type ExtensionFlagDef = FlagDef & {
 type NamedExtensionFlagDef = NamedFlagDef & {
   readonly recursive?: boolean;
 };
+type SchemaToken<F> = F extends {
+  type: "boolean";
+} ? boolean : string;
 type InferPreSchemaExtensionFlag<F extends ExtensionFlagDef> = F extends {
   schema: unknown;
-} ? F extends {
+} ? (F extends {
   multiple: true;
-} ? F extends {
-  type: "boolean";
-} ? boolean[] | undefined : string[] | undefined : F extends {
-  type: "boolean";
-} ? boolean | undefined : string | undefined : F extends {
+} ? never : SchemaToken<F>) | ("multiple" extends keyof F ? true extends F["multiple"] ? SchemaToken<F>[] : never : never) | undefined : F extends {
   required: true;
 } ? F extends {
   default: unknown;
@@ -1017,11 +1073,9 @@ type InferPreSchemaExtensionFlag<F extends ExtensionFlagDef> = F extends {
 }>["value"] | undefined : InferFlags<{
   value: F;
 }>["value"];
-type InferExtensionFlag<F> = F extends ExtensionFlagDef ? F extends {
-  recursive: false;
-} ? InferPreSchemaExtensionFlag<F> | undefined : InferPreSchemaExtensionFlag<F> : never;
-/** Infer the syntax-parsed values visible to an Extension's hooks. */
-type InferExtensionFlags<Defs extends readonly NamedExtensionFlagDef[]> = { [K in keyof NamedFlagsRecord<Defs>]: InferExtensionFlag<NamedFlagsRecord<Defs>[K]>; };
+type InferExtensionFlag<F> = F extends ExtensionFlagDef ? InferPreSchemaExtensionFlag<F> | ("recursive" extends keyof F ? (false extends F["recursive"] ? undefined : never) : never) : never;
+/** Infer pre-validation hook values; uncertain collections claim no typed ownership. */
+type InferExtensionFlags<Defs extends readonly NamedExtensionFlagDef[]> = IsStaticTuple<Defs> extends true ? HasClosedNames<Defs> extends true ? { [K in keyof NamedFlagsRecord<Defs>]: InferExtensionFlag<NamedFlagsRecord<Defs>[K]>; } : Record<string, ParsedFlagValue> : Record<string, ParsedFlagValue>;
 /** A documentation section an Extension contributes to one command path. */
 type ExtensionSectionContribution = RuntimeCommandSectionInput & {
   readonly command: readonly string[];
@@ -1033,7 +1087,7 @@ interface ExtensionConfig<Defs extends readonly NamedExtensionFlagDef[] = readon
   readonly uses?: Uses;
   readonly provides?: Provides;
   readonly sections?: (snapshot: RootCommandSnapshot<MetaKeys>) => readonly ExtensionSectionContribution[];
-  readonly build?: (ctx: ExtensionBuildContext<MetaKeys>) => BuildArtifacts | void | Promise<BuildArtifacts | void>;
+  readonly build?: (ctx: ExtensionBuildContext<MetaKeys>) => Awaitable<BuildArtifacts>;
   readonly hooks?: ExtensionHooks<Defs, ContextDependencies<Uses>, MetaKeys>;
 }
 type ValidateExtensionConfig<Defs extends readonly NamedExtensionFlagDef[], Provides extends readonly AnyContextInstance[], Commands extends readonly CommandDefinition<any, any, any, any>[], Uses extends readonly AnyContextFactory[]> = {
@@ -1055,7 +1109,7 @@ interface Extension<Deps extends ContextMap = ContextMap, Provides extends reado
   readonly uses: readonly AnyContextFactory[];
   readonly provides?: Provides;
   readonly sections?: (snapshot: RootCommandSnapshot<MetaKeys>) => readonly ExtensionSectionContribution[];
-  readonly build?: (ctx: ExtensionBuildContext<MetaKeys>) => BuildArtifacts | void | Promise<BuildArtifacts | void>;
+  readonly build?: (ctx: ExtensionBuildContext<MetaKeys>) => Awaitable<BuildArtifacts>;
   readonly hooks?: ExtensionHooks<any, Deps, MetaKeys>;
   readonly _deps?: Deps;
 }
@@ -1148,8 +1202,15 @@ interface Defining<T> {
 }
 /** @internal */
 type DefiningOf<T> = T extends Defining<unknown> ? T[typeof defining] : T;
+/**
+ * Adapter hook: the Context sources a bag was built from, exposed as a
+ * non-enumerable symbol property. Reading it never starts construction.
+ */
+export declare const contextSources: unique symbol;
 /** Lazy, invocation-scoped Context values. Reading a property starts construction. */
-type ContextBag<Deps extends ContextMap = {}> = { readonly [K in keyof Deps]: Promise<Deps[K]>; };
+type ContextBag<Deps extends ContextMap = {}> = { readonly [K in keyof Deps]: Promise<Deps[K]>; } & {
+  readonly [contextSources]?: readonly (AnyContextFactory | AnyContextInstance)[];
+};
 interface ContextConfig {
   readonly flags?: readonly NamedFlagDef[];
   readonly uses?: readonly AnyContextFactory[];
@@ -1169,6 +1230,8 @@ interface ContextInstance<Name extends string = string, Value = unknown, OF exte
   readonly ownedFlags: FlagsDef;
   /** @internal — declared direct dependency factories */
   readonly uses: readonly AnyContextFactory[];
+  /** @internal defining factory, for adapters that identify Contexts by factory */
+  readonly factory: AnyContextFactory;
   setup(input: ContextSetupInput<OF>): Awaitable<Value>;
   readonly _ownedFlags?: OF;
   /** @internal — phantom carrying the transitive dependency closure */
@@ -1241,4 +1304,4 @@ export declare function defineFlag<const N extends string, const D extends FlagD
 /** Define and own one positional argument; layout belongs to its consuming command. */
 export declare function defineArg<const N extends string, const D extends UnnamedArgDef>(name: N & EmptyArgNameBrand<N>, def: D & LocalValueBrand<D>): Named<N, D>;
 //#endregion
-export { type AnyContextFactory, type AnyCrust, type ArgDef, type ArgSnapshot, type ArgsDef, type BuildArtifacts, type BuildReport, type CommandConfig, type CommandDefinition, type CommandDefinitionBuilder, type CommandMeta, type CommandNotFoundErrorDetails, type CommandPath, type CommandSection, type CommandSectionInput, type CommandShape, type CommandShapeAt, type CommandSnapshot, type CommandTree, type ContextBag, type ContextConfig, type ContextFactory, type ContextInstance, type ContextMap, type ContextSetup, type CrustCommandContext, type CrustErrorCode, type CrustErrorDetails, type CrustErrorDetailsMap, type CrustErrorJson, type DefineExtensionWith, type DefinitionErrorDetails, type Extension, type ExtensionBuildContext, type ExtensionConfig, type ExtensionContext, type ExtensionFactory, type ExtensionFlagDef, type ExtensionHooks, type ExtensionId, type ExtensionSectionContribution, type FactoryValueOf, type Finished, type FlagDef, type FlagSnapshot, type FlagsDef, type InferExtensionFlags, type InputArgs, type InputFlags, type InvocationIO, type InvocationOutcome, type MergeContext, type MergeFlags, type NamedExtensionFlagDef, type NamedFlagDef, type ParseErrorDetails, type ParseResult, type ParsedArgValue, type ParsedFlagValue, type RootCommandMeta, type RootMetaKey, type RunArguments, type RunInput, type RunInputArguments, type RunOutcome, type SectionAudience, type SectionConsumer, type UnnamedArgDef, type ValidatedInput, type ValidationErrorDetails, type ValueType, defineExtensionId };
+export { type AnyContextFactory, type AnyCrust, type ArgDef, type ArgSnapshot, type ArgsDef, type BuildArtifacts, type BuildFile, type BuildReport, type CommandConfig, type CommandDefinition, type CommandDefinitionBuilder, type CommandHandle, type CommandMeta, type CommandNotFoundErrorDetails, type CommandPath, type CommandSection, type CommandSectionInput, type CommandShape, type CommandShapeAt, type CommandSnapshot, type CommandTree, type ContextBag, type ContextConfig, type ContextFactory, type ContextInstance, type ContextMap, type ContextSetup, type CrustCommandContext, type CrustErrorCode, type CrustErrorDetails, type CrustErrorDetailsMap, type CrustErrorJson, type DefineExtensionWith, type DefinitionErrorDetails, type Extension, type ExtensionBuildContext, type ExtensionConfig, type ExtensionContext, type ExtensionFactory, type ExtensionFlagDef, type ExtensionHooks, type ExtensionId, type ExtensionSectionContribution, type FactoryValueOf, type Finished, type FlagDef, type FlagSnapshot, type FlagsDef, type InferExtensionFlags, type InputArgs, type InputFlags, type InvocationIO, type InvocationOutcome, type MergeContext, type MergeFlags, type NamedExtensionFlagDef, type NamedFlagDef, type ParseErrorDetails, type ParseResult, type ParsedArgValue, type ParsedFlagValue, type RootCommandMeta, type RootMetaKey, type RunArguments, type RunInput, type RunInputArguments, type RunOutcome, type SectionAudience, type SectionConsumer, type UnnamedArgDef, type ValidatedInput, type ValidationErrorDetails, type ValueType, defineExtensionId, resolveArtifactDir };

package/dist/index.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { _ as definingOf, a as runInvocation, b as normalizeFlag, d as installExtensionContexts, f as validateCommandSections, g as defineContext, h as defineExtension, i as prepareInvocation, m as registerFlag, o as snapshotCommand, p as createCommandNode, r as executeInvocation, u as cloneCommandNode, v as validateContextAvailability, x as CrustError, y as normalizeArg } from "./invocation-DcA5FqF7.js";
+import { C as normalizeFlag, S as normalizeArg, _ as defineExtension, a as runInvocation, b as definingOf, d as resolveArtifactDir, f as cloneCommandNode, g as registerFlag, h as createCommandNode, i as resolveTypedPath, m as validateCommandSections, n as executeInvocation, o as snapshotCommand, p as installExtensionContexts, r as prepareInvocation, v as contextSources, w as CrustError, x as validateContextAvailability, y as defineContext } from "./invocation-CIvHShiW.js";
 //#region src/identity.ts
 /** Mint an Extension identity from any non-blank, trimmed string. */
 function defineExtensionId(id) {
@@ -173,8 +173,9 @@ var Crust = class {
 	* The action receives a {@link CrustCommandContext} with `args` typed from
 	* `.args()` and `flags` typed from the accumulated `Flags`.
 	*
-	* Calling `.action()` again replaces the command behavior on the new builder.
-	* The original builder is not mutated.
+	* Calling `.action()` again replaces the command behavior and its Context obligations
+	* on the new builder. Later local providers must satisfy the bound Context value types;
+	* descendants may shadow independently. The original builder is not mutated.
 	*
 	* @param action - The Command Action function
 	* @returns A new `Crust` instance with the action registered
@@ -224,9 +225,25 @@ var Crust = class {
 			input: structuredInput
 		}, io, materializeCommandDefinition);
 	}
+	at(path) {
+		resolveTypedPath(prepareInvocation(this._node, materializeCommandDefinition).rootNode, path);
+		const node = this._node;
+		const boundPath = Object.freeze([...path]);
+		return {
+			path: boundPath,
+			async run(...args) {
+				const structuredInput = args[0] ?? {};
+				const io = args[1];
+				return await runInvocation(node, {
+					path: boundPath,
+					input: structuredInput
+				}, io, materializeCommandDefinition);
+			}
+		};
+	}
 	async execute(options) {
 		return await executeInvocation(this._node, options, materializeCommandDefinition);
 	}
 };
 //#endregion
-export { Crust, CrustError, defineArg, defineCommand, defineContext, defineExtension, defineExtensionId, defineFlag };
+export { Crust, CrustError, contextSources, defineArg, defineCommand, defineContext, defineExtension, defineExtensionId, defineFlag, resolveArtifactDir };

package/dist/{invocation-DcA5FqF7.js → invocation-CIvHShiW.js} RENAMED Viewed

@@ -1,5 +1,7 @@
-import { writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, posix, resolve, win32 } from "node:path";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Writable } from "node:stream";
 import { parseArgs } from "node:util";
@@ -148,6 +150,11 @@ function definingOf(value) {
 function seal(value) {
 	return Object.freeze(Object.assign(value, { [defining]: value }));
 }
+/**
+* Adapter hook: the Context sources a bag was built from, exposed as a
+* non-enumerable symbol property. Reading it never starts construction.
+*/
+const contextSources = Symbol.for("crust.contextSources");
 /** Check only declared availability; setup, callback values, and cycles belong to invocation. */
 function validateContextAvailability(contexts, sources) {
 	const names = new Set(contexts.map((instance) => instance.name));
@@ -179,6 +186,7 @@ function defineContext(name, configOrSetup, maybeSetup) {
 			name,
 			ownedFlags,
 			uses: instanceUses,
+			factory: sealed,
 			setup: run
 		});
 	};
@@ -191,7 +199,8 @@ function defineContext(name, configOrSetup, maybeSetup) {
 	factory.contextName = name;
 	factory.uses = uses;
 	factory.of = (value) => instance(Object.freeze([]), () => value);
-	return seal(factory);
+	const sealed = seal(factory);
+	return sealed;
 }
 function isDisposeCallback(value) {
 	return typeof value === "function";
@@ -370,6 +379,7 @@ function createContextResolver(contexts, io, disposal) {
 			for (const dependency of source.uses ?? []) add(dependency);
 		};
 		for (const source of sources) add(source);
+		Object.defineProperty(bag, contextSources, { value: Object.freeze([...sources]) });
 		return Object.freeze(bag);
 	};
 	return {
@@ -604,6 +614,83 @@ function installExtensionContexts(node, extensions, reRegisteredIds) {
 	return cloned;
 }
 //#endregion
+//#region ../utils/src/source.ts
+/**
+* Find the nearest directory containing `package.json` by walking up the
+* filesystem from `startPath`.
+*
+* If `startPath` points at an existing file, its parent directory is used as
+* the starting point. The directory walk uses `path.resolve()` (lexical), not
+* `fs.realpath()`, so a symlink's parent chain is walked rather than the
+* symlink target's parent chain.
+*
+* @param startPath - Directory or file path to start walking from.
+* @returns The absolute path of the nearest enclosing directory containing
+*   `package.json`, or `null` if the filesystem root is reached first.
+*
+* @internal Shared by {@link resolveSourceDir} and `resolveArtifactDir`.
+*/
+function findNearestPackageRoot(startPath) {
+	let current = resolve(startPath);
+	if (existsSync(current) && !statSync(current).isDirectory()) current = dirname(current);
+	while (true) {
+		if (existsSync(join(current, "package.json"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+//#endregion
+//#region ../utils/src/artifacts.ts
+/**
+* Set by `crust build` while it prepares the Command Snapshot: the absolute
+* entry-isolated directory Extension build hooks write into. Core reads it
+* to run the hooks; `resolveArtifactDir` reads it so sections evaluated during
+* that run see the artifacts being built instead of the wiped `.crust/root`.
+*/
+const BUILD_OUT_DIR_ENV = "CRUST_INTERNAL_BUILD_OUT_DIR";
+/** True inside a `bun build --compile` or `deno compile` executable. */
+function isCompiledExecutable() {
+	const { Bun, Deno } = globalThis;
+	const bunMain = Bun?.main ?? "";
+	return bunMain.startsWith("/$bunfs/") || /^[A-Za-z]:[\\/]~BUN[\\/]/.test(bunMain) || Deno?.build?.standalone === true;
+}
+/**
+* Absolute path of a build artifact or `crust.include` directory shipped with
+* this CLI. `name` is a top-level directory name such as `"skills"`.
+*
+* The artifact path is computed from how the CLI is running — never probed:
+* - Compiled executable (Bun or Deno): `<dir of the executable>/<name>`, which
+*   is a platform package's `bin/` or wherever the binary was placed.
+* - Crust-built Node bundle: `<name>` next to the bundle's `bin/` directory,
+*   i.e. `.crust/root/<name>` in place and `<installed root>/<name>` after install.
+* - Snapshot preparation inside `crust build`: `<build output dir>/<name>`, the
+*   artifacts earlier Extension build hooks wrote in this same build.
+* - Source (`bun run`, `node`, `deno run`): `.crust/root/<name>` under the
+*   nearest package root of the real `process.argv[1]` entrypoint (following source
+*   links) — the output of the last `crust build`.
+*
+* @throws {Error} when `name` is not a single path segment, or in source mode
+*   when the entrypoint cannot be resolved or has no enclosing `package.json`.
+*/
+function resolveArtifactDir(name) {
+	if (name === "" || name === "." || name === ".." || /[\\/]/.test(name)) throw new Error(`Artifact name must be a single directory name, got ${JSON.stringify(name)}.`);
+	if (isCompiledExecutable()) return join(dirname(process.execPath), name);
+	if (process.env.CRUST_INTERNAL_BUILD === "1") return resolve(fileURLToPath(import.meta.url), "..", "..", name);
+	const buildOutDir = process.env[BUILD_OUT_DIR_ENV];
+	if (buildOutDir) return join(buildOutDir, name);
+	const entrypoint = process.argv[1];
+	let sourceEntrypoint = entrypoint;
+	if (entrypoint) try {
+		sourceEntrypoint = realpathSync(entrypoint);
+	} catch (cause) {
+		throw new Error(`Could not resolve artifact "${name}": could not resolve source entrypoint "${entrypoint}".`, { cause });
+	}
+	const packageRoot = sourceEntrypoint ? findNearestPackageRoot(sourceEntrypoint) : null;
+	if (!packageRoot) throw new Error(`Could not resolve artifact "${name}": no package.json was found above ${entrypoint ? `entrypoint "${entrypoint}"` : "process.argv[1] (unset)"}.`);
+	return join(packageRoot, ".crust", "root", name);
+}
+//#endregion
 //#region ../utils/src/terminal.ts
 const STORAGE_KEY = Symbol.for("crustjs.terminal.io");
 const AMBIENT_CALLBACKS_KEY = Symbol.for("crustjs.terminal.ambient-callbacks");
@@ -733,11 +820,9 @@ function coerceJson(raw) {
 //#region src/parsing/parser.ts
 /**
 * Build the options config for `util.parseArgs` from the shared spelling table.
-* Also returns a reverse alias→name mapping for resolving parsed results.
 */
 function buildParseArgsOptionDescriptor(spellings) {
 	const options = {};
-	const aliasToName = {};
 	for (const [spelling, entry] of spellings) {
 		const descriptor = { type: entry.def.type === "boolean" ? "boolean" : "string" };
 		if (entry.def.multiple) descriptor.multiple = true;
@@ -746,13 +831,9 @@ function buildParseArgsOptionDescriptor(spellings) {
 			options[spelling] = descriptor;
 			continue;
 		}
-		aliasToName[spelling] = entry.canonicalName;
 		if (entry.kind === "alias") options[spelling] = descriptor;
 	}
-	return {
-		options,
-		aliasToName
-	};
+	return options;
 }
 /**
 * Coerce a string value to the expected type based on the type literal.
@@ -848,12 +929,11 @@ function coerceFlagValue(name, def, parsed) {
 * must be `true`), and `multiple` flags spread across aliases would lose
 * their interleaved argv order.
 */
-function resolveAliases(tokens, aliasToName, flagsDef) {
+function resolveAliases(tokens, spellings) {
 	const canonical = {};
 	for (const token of tokens) {
 		if (token.kind !== "option") continue;
-		const canonicalName = aliasToName[token.name] ?? token.name;
-		const def = flagsDef[canonicalName];
+		const { canonicalName, def } = spellings.get(token.name);
 		const existing = canonical[canonicalName];
 		if (def.type === "boolean") {
 			const value = !token.rawName.startsWith("--no-");
@@ -913,6 +993,12 @@ function resolveArgs(argsDef, positionals, coerce) {
 	for (const def of argsDef) {
 		const { name } = def;
 		const label = `<${name}>`;
+		Object.defineProperty(resolved, name, {
+			value: void 0,
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
 		if (def.variadic) {
 			resolved[name] = positionals.slice(index).map((v, i) => coerce(def, v, label, i));
 			index = positionals.length;
@@ -947,7 +1033,7 @@ function validateNoNegateUsage(argv, spellings) {
 }
 function tokenizeArgv(command, argv) {
 	const spellings = command.flagSpellings;
-	const { options: parseOptions, aliasToName } = buildParseArgsOptionDescriptor(spellings);
+	const parseOptions = buildParseArgsOptionDescriptor(spellings);
 	validateNoNegateUsage(argv, spellings);
 	let parsed;
 	try {
@@ -979,7 +1065,7 @@ function tokenizeArgv(command, argv) {
 	}
 	return {
 		positionals: preSeparatorPositionals,
-		flagValues: resolveAliases(parsed.tokens, aliasToName, command.effectiveFlags),
+		flagValues: resolveAliases(parsed.tokens, spellings),
 		rawArgs
 	};
 }
@@ -1180,8 +1266,7 @@ function normalizeStandardIssues(issues, prefix = []) {
 //#endregion
 //#region src/parsing/schema.ts
 async function runSchema(schema, raw, path, issues) {
-	let result = schema["~standard"].validate(raw);
-	if (result instanceof Promise) result = await result;
+	const result = await schema["~standard"].validate(raw);
 	if (result.issues) {
 		issues.push(...normalizeStandardIssues(result.issues, path));
 		return { ok: false };
@@ -1374,8 +1459,8 @@ function matchKnownFlagToken(spellings, token) {
 * Resolve a command from an argv array by walking the subcommand tree.
 *
 * Subcommand matching happens BEFORE flag parsing, so:
-* `crust build --entry src/cli.ts` first resolves "build" as a subcommand,
-* then passes `["--entry", "src/cli.ts"]` to the build command's parser.
+* `crust build --target host` first resolves "build" as a subcommand,
+* then passes `["--target", "host"]` to the build command's parser.
 *
 * Resolution rules:
 * 1. If `argv[0]` matches a subcommand key, recurse into that subcommand
@@ -1545,7 +1630,6 @@ const DEFAULT_IO = {
 * without dispatching a Command Action. In-process callers use `Crust.snapshot()`.
 */
 const SNAPSHOT_PATH_ENV = "CRUST_INTERNAL_SNAPSHOT_PATH";
-const BUILD_OUT_DIR_ENV = "CRUST_INTERNAL_BUILD_OUT_DIR";
 const EXIT_CODE_CANCELLED = 130;
 function isAbortError(error) {
 	if (!(error instanceof Error)) return false;
@@ -1611,7 +1695,8 @@ function resolveArgvInput(root, argv) {
 		parsed: parseArgs$1(route.command, route.argv)
 	};
 }
-function resolveStructuredInput(root, path, input) {
+/** Resolve a typed path, rejecting any element the router cannot consume as a command. */
+function resolveTypedPath(root, path) {
 	const route = resolveCommand(root, [...path]);
 	if (route.argv.length > 0) {
 		const candidate = route.argv[0];
@@ -1623,6 +1708,10 @@ function resolveStructuredInput(root, path, input) {
 			parentCommand
 		});
 	}
+	return route;
+}
+function resolveStructuredInput(root, path, input) {
+	const route = resolveTypedPath(root, path);
 	return {
 		argv: path,
 		route,
@@ -1805,16 +1894,31 @@ async function executeInvocation(node, options, materializeCommandDefinition) {
 			const buildOutDir = process.env[BUILD_OUT_DIR_ENV];
 			if (buildOutDir) {
 				const extensions = [];
+				const owners = /* @__PURE__ */ new Map();
 				for (const extension of base.extensions) {
 					if (!extension.build) continue;
 					try {
-						const artifacts = await extension.build({
-							snapshot,
-							outDir: buildOutDir
+						const files = (await extension.build({ snapshot })).map((file) => {
+							const path = normalizeArtifactPath(file.path);
+							const key = path.toLowerCase();
+							for (const [ownedKey, owner] of owners) if (ownedKey === key || ownedKey.startsWith(`${key}/`) || key.startsWith(`${ownedKey}/`)) throw new Error(`Artifact path "${path}" collides with "${owner.path}" produced by Extension "${owner.id}".`);
+							owners.set(key, {
+								id: extension.id,
+								path
+							});
+							return {
+								path,
+								content: file.content
+							};
 						});
+						for (const file of files) {
+							const target = join(buildOutDir, file.path);
+							await mkdir(dirname(target), { recursive: true });
+							await writeFile(target, file.content);
+						}
 						extensions.push({
 							id: extension.id,
-							files: artifacts === void 0 ? "unknown" : artifacts.map(normalizeArtifactPath)
+							files: files.map((file) => file.path)
 						});
 					} catch (error) {
 						const message = error instanceof Error ? error.message : String(error);
@@ -1872,4 +1976,4 @@ async function executeInvocation(node, options, materializeCommandDefinition) {
 	return await (hasInjectedIO(options?.io) ? withAmbientTerminalIO(io, invoke) : invoke());
 }
 //#endregion
-export { definingOf as _, runInvocation as a, normalizeFlag as b, sectionsFor as c, installExtensionContexts as d, validateCommandSections as f, defineContext as g, defineExtension as h, prepareInvocation as i, visibleSectionsFor as l, registerFlag as m, SNAPSHOT_PATH_ENV as n, snapshotCommand as o, createCommandNode as p, executeInvocation as r, isListed as s, BUILD_OUT_DIR_ENV as t, cloneCommandNode as u, validateContextAvailability as v, CrustError as x, normalizeArg as y };
+export { normalizeFlag as C, normalizeArg as S, defineExtension as _, runInvocation as a, definingOf as b, sectionsFor as c, resolveArtifactDir as d, cloneCommandNode as f, registerFlag as g, createCommandNode as h, resolveTypedPath as i, visibleSectionsFor as l, validateCommandSections as m, executeInvocation as n, snapshotCommand as o, installExtensionContexts as p, prepareInvocation as r, isListed as s, SNAPSHOT_PATH_ENV as t, BUILD_OUT_DIR_ENV as u, contextSources as v, CrustError as w, validateContextAvailability as x, defineContext as y };

package/dist/tooling.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { D as CommandSnapshot, O as FlagSnapshot, V as ExtensionId, i as CommandSection, o as DeclaredDefault } from "./types-DjMHz7M6.js";
+import { A as FlagSnapshot, G as ExtensionId, c as DeclaredDefault, k as CommandSnapshot, o as CommandSection, t as BUILD_OUT_DIR_ENV } from "./artifacts-D8Jlug-a.js";
 //#region src/command/invocation.d.ts
 /**
  * Snapshot subprocess protocol used by first-party build tooling.
@@ -9,7 +9,6 @@ import { D as CommandSnapshot, O as FlagSnapshot, V as ExtensionId, i as Command
  * without dispatching a Command Action. In-process callers use `Crust.snapshot()`.
  */
 export declare const SNAPSHOT_PATH_ENV = "CRUST_INTERNAL_SNAPSHOT_PATH";
-export declare const BUILD_OUT_DIR_ENV = "CRUST_INTERNAL_BUILD_OUT_DIR";
 //#endregion
 //#region src/command/documentation.d.ts
 /** Format a declared default value for command documentation. */
@@ -157,4 +156,4 @@ export declare function visibleSectionsFor(snapshot: CommandSnapshot, consumer:
   readonly sections: readonly CommandSection[];
 }[];
 //#endregion
-export type { CommandDocumentation, CommandSnapshot, DocumentationArg, DocumentationFlag, UsageSegment };
+export { BUILD_OUT_DIR_ENV, type CommandDocumentation, type CommandSnapshot, type DocumentationArg, type DocumentationFlag, type UsageSegment };

package/dist/tooling.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { c as sectionsFor, l as visibleSectionsFor, n as SNAPSHOT_PATH_ENV, s as isListed, t as BUILD_OUT_DIR_ENV } from "./invocation-DcA5FqF7.js";
+import { c as sectionsFor, l as visibleSectionsFor, s as isListed, t as SNAPSHOT_PATH_ENV, u as BUILD_OUT_DIR_ENV } from "./invocation-CIvHShiW.js";
 //#region src/command/documentation.ts
 function isNonFiniteNumber(value) {
 	return typeof value === "number" && !Number.isFinite(value);

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "@crustjs/core",
-	"version": "0.2.1",
+	"version": "0.3.1",
 	"description": "Core library for the Crust CLI framework",
 	"type": "module",
 	"sideEffects": false,