@crustjs/core 0.4.1 → 0.5.0

package/dist/{invocation-ka-BNJKZ.js → invocation-ljkrw2dt.js}

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, posix, resolve, win32 } from "node:path";
-import { BUILD_OUT_DIR_ENV } from "@crustjs/utils/artifacts";
+import { BUILD_OUT_DIR_ENV, isPackagedBuild } from "@crustjs/utils/artifacts";
 import { withAmbientTerminalIO } from "@crustjs/utils/terminal";
 import { parseArgs } from "node:util";
 import { isPromise } from "node:util/types";
@@ -170,6 +170,74 @@ function normalizeArg(def) {
 	return ownDefinition(def);
 }
 //#endregion
+//#region src/sections.ts
+/** Whether a command belongs in user-facing listings. */
+function isListed(command) {
+	return command.meta.hidden !== true;
+}
+/** Select and merge sections visible to the given consumer. */
+function sectionsFor(sections, consumer) {
+	const visible = (sections ?? []).filter((section) => {
+		if (section.only) return section.only.includes(consumer);
+		if (section.except) return !section.except.includes(consumer);
+		return true;
+	});
+	const merged = /* @__PURE__ */ new Map();
+	for (const section of visible) {
+		const existing = merged.get(section.title);
+		merged.set(section.title, existing ? {
+			title: section.title,
+			body: `${existing.body}\n${section.body}`
+		} : section);
+	}
+	return [...merged.values()];
+}
+/** Collect section-bearing visible commands in canonical path order. The root path is `[]`. */
+function visibleSectionsFor(snapshot, consumer) {
+	const groups = [];
+	function visit(command, path) {
+		const sections = sectionsFor(command.meta.sections, consumer);
+		if (sections.length > 0) groups.push({
+			path,
+			sections
+		});
+		for (const [name, child] of Object.entries(command.subCommands).sort(([a], [b]) => a.localeCompare(b))) if (isListed(child)) visit(child, [...path, name]);
+	}
+	visit(snapshot, []);
+	return groups;
+}
+const sectionOwnerLabels = {
+	command: "Command",
+	context: "Context",
+	extension: "Extension"
+};
+function invalidSections({ subject, name }) {
+	const label = sectionOwnerLabels[subject];
+	return new CrustError("DEFINITION", `${label} "${name}" contains invalid documentation sections`, {
+		subject,
+		name,
+		reason: "invalid-sections"
+	});
+}
+function normalizeSection(section, owner) {
+	const { title, body, only, except } = section;
+	if (!title.trim() || /[\r\n]/.test(title) || !body.trim() || only?.length === 0 || except?.length === 0 || only !== void 0 && except !== void 0) throw invalidSections(owner);
+	const audience = (ids) => {
+		return Object.freeze(ids.map((consumer) => typeof consumer === "string" ? consumer : consumer.id));
+	};
+	return Object.freeze({
+		title,
+		body,
+		...only ? { only: audience(only) } : except ? { except: audience(except) } : {}
+	});
+}
+function validateCommandSections(name, sections, subject = "command") {
+	return sections.map((section) => normalizeSection(section, {
+		subject,
+		name
+	}));
+}
+//#endregion
 //#region src/api/context.ts
 const defining = Symbol("crust.defining");
 /** @internal */
@@ -178,7 +246,11 @@ function definingOf(value) {
 }
 /** @internal */
 function seal(value) {
-	return Object.freeze(Object.assign(value, { [defining]: value }));
+	return sealHandle(value, value);
+}
+/** @internal Freeze a public handle whose defining data is a separate record. */
+function sealHandle(handle, data) {
+	return Object.freeze(Object.assign(handle, { [defining]: data }));
 }
 /**
 * Adapter hook: the Context sources a bag was built from, exposed as a
@@ -198,40 +270,43 @@ function validateContextAvailability(contexts, sources) {
 			name,
 			reason: "missing-context"
 		});
-		for (const dependency of source.uses) visit(dependency);
+		for (const dependency of source.use) visit(dependency);
 	};
 	for (const source of sources) visit(source);
 }
-function isContextSetup(value) {
-	return typeof value === "function";
+function createContextBuilder(name, use, ownedFlags, sections) {
+	return Object.freeze({
+		use: (...factories) => createContextBuilder(name, Object.freeze([...use, ...factories.map(definingOf)]), ownedFlags, sections),
+		flags: (...defs) => createContextBuilder(name, use, Object.freeze(toFlagsRecord(defs, ownedFlags)), sections),
+		sections: (...inputs) => createContextBuilder(name, use, ownedFlags, Object.freeze([...sections, ...validateCommandSections(name, inputs, "context")])),
+		setup: (setup) => createContextFactory(name, use, ownedFlags, sections, setup)
+	});
 }
-function defineContext(name, configOrSetup, maybeSetup) {
-	const hasConfig = !isContextSetup(configOrSetup);
-	const config = hasConfig ? configOrSetup : {};
-	const setup = hasConfig ? maybeSetup : configOrSetup;
-	const ownedFlags = Object.freeze(toFlagsRecord(config.flags ?? []));
-	const uses = Object.freeze((config.uses ?? []).map(definingOf));
-	const instance = (instanceUses, run) => {
+function createContextFactory(name, use, ownedFlags, sections, setup) {
+	const instance = (instanceUse, run) => {
 		return seal({
 			name,
 			ownedFlags,
-			uses: instanceUses,
+			sections,
+			use: instanceUse,
 			factory: sealed,
 			setup: run
 		});
 	};
-	const factory = (options) => instance(uses, (input) => {
-		return setup({
-			options,
-			...input
-		});
-	});
+	const factory = (options) => instance(use, (input) => setup(input, options));
 	factory.contextName = name;
-	factory.uses = uses;
+	factory.use = use;
 	factory.of = (value) => instance(Object.freeze([]), () => value);
 	const sealed = seal(factory);
 	return sealed;
 }
+/**
+* Start an immutable fluent Context definition: a named, lazy command
+* dependency. Chain `.use()`, `.flags()`, and `.sections()`, then `.setup()` for the factory.
+*/
+function defineContext(name) {
+	return createContextBuilder(name, Object.freeze([]), Object.freeze({}), Object.freeze([]));
+}
 function isDisposeCallback(value) {
 	return typeof value === "function";
 }
@@ -373,7 +448,7 @@ function createContextResolver(contexts, io, disposal, signal) {
 						...io,
 						signal,
 						flags: ownedFlags,
-						ctx: makeBag(context.uses, current),
+						ctx: makeBag(context.use, current),
 						defer(cleanup) {
 							if (current.settled) throw new CrustError("DEFINITION", `Context "${name}" cannot register cleanup after its setup has finished.`, {
 								subject: "context",
@@ -414,7 +489,7 @@ function createContextResolver(contexts, io, disposal, signal) {
 				enumerable: true,
 				get: () => makePull(origin)(name)
 			});
-			for (const dependency of source.uses ?? []) add(dependency);
+			for (const dependency of source.use ?? []) add(dependency);
 		};
 		for (const source of sources) add(source);
 		Object.defineProperty(bag, contextSources, { value: Object.freeze([...sources]) });
@@ -444,24 +519,75 @@ const FINISHED = Object.freeze({ [Symbol("crust.finished")]: true });
 function finishInvocation() {
 	return FINISHED;
 }
-function isExtensionFactory(value) {
-	return typeof value === "function";
-}
-function defineExtension(id, config = {}) {
-	if (id === void 0) return defineExtension;
-	if (isExtensionFactory(config)) return Object.assign((...args) => defineExtension(id, config(...args)), { id });
-	const ownedFlags = Object.freeze(toFlagsRecord(config.flags ?? []));
-	toFlagsRecord((config.provides ?? []).flatMap((instance) => Object.entries(definingOf(instance).ownedFlags).map(([name, def]) => ({
+function createExtension(state) {
+	const flags = Object.freeze(toFlagsRecord(state.flags));
+	toFlagsRecord(state.provide.flatMap((instance) => Object.entries(instance.ownedFlags).map(([name, def]) => ({
 		...def,
 		name
-	}))), ownedFlags);
-	return seal({
-		...config,
-		uses: Object.freeze((config.uses ?? []).map(definingOf)),
-		...config.provides ? { provides: Object.freeze(config.provides.map(definingOf)) } : {},
-		...config.commands ? { commands: Object.freeze([...config.commands]) } : {},
+	}))), flags);
+	const data = Object.freeze({
+		id: state.id,
+		flags,
+		commands: Object.freeze([...state.commands]),
+		use: Object.freeze([...state.use]),
+		provide: Object.freeze([...state.provide]),
+		hooks: Object.freeze({ ...state.hooks }),
+		...state.sections ? { sections: state.sections } : {},
+		...state.build ? { build: state.build } : {}
+	});
+	const next = (change) => createExtension({
+		...state,
+		...change
+	});
+	const sealed = sealHandle({
+		id: state.id,
+		use: (...factories) => next({ use: [...state.use, ...factories.map(definingOf)] }),
+		provide: (...instances) => next({ provide: [...state.provide, ...instances.map(definingOf)] }),
+		flags: (...defs) => next({ flags: [...state.flags, ...defs.map(ownDefinition)] }),
+		add: (...definitions) => next({ commands: [...state.commands, ...definitions] }),
+		preRun: (preRun) => next({ hooks: {
+			...state.hooks,
+			preRun
+		} }),
+		postRun: (postRun) => next({ hooks: {
+			...state.hooks,
+			postRun
+		} }),
+		onError: (onError) => next({ hooks: {
+			...state.hooks,
+			onError
+		} }),
+		sections: (sections) => next({ sections }),
+		build: (build) => next({ build }),
+		factory: (define) => Object.assign((...args) => {
+			const extension = define(sealed, ...args);
+			const returned = definingOf(extension).id;
+			if (returned !== state.id) throw new CrustError("DEFINITION", `Extension factory "${state.id}" returned Extension "${returned}"; return an Extension built from the handle it receives`, {
+				subject: "extension",
+				name: state.id,
+				reason: "factory-id-mismatch"
+			});
+			return extension;
+		}, { id: state.id })
+	}, data);
+	return sealed;
+}
+/**
+* Start an immutable fluent Extension definition.
+*
+* Extensions apply to the whole application and own the flags and commands
+* they contribute. `defineExtension<"version">(id)` requires root metadata keys
+* without preventing inference of flags, Contexts, or commands; chain
+* `.factory()` for a configurable Extension whose identity is a section consumer.
+*/
+function defineExtension(id) {
+	return createExtension({
 		id,
-		...config.flags === void 0 ? {} : { flags: ownedFlags }
+		use: [],
+		provide: [],
+		flags: [],
+		commands: [],
+		hooks: {}
 	});
 }
 //#endregion
@@ -483,6 +609,7 @@ function createCommandNode(name) {
 		args: [],
 		subCommands: {},
 		contexts: [],
+		providedContexts: [],
 		demands: [],
 		extensions: [],
 		run: void 0
@@ -528,11 +655,11 @@ function injectExtensionFlag(node, name, def, recursive) {
 }
 /** Attach one Extension's owned root commands to a cloned tree. */
 function applyExtensionCommands(root, extension, materializeCommandDefinition) {
-	for (const definition of extension.commands ?? []) root.subCommands[definition.name] = materializeCommandDefinition(definition, root, extension.id);
+	for (const definition of extension.commands) root.subCommands[definition.name] = materializeCommandDefinition(definition, root, extension.id);
 }
 /** Inject one Extension's owned flags across a cloned tree. */
 function applyExtensionFlags(root, extension) {
-	for (const [name, defWithScope] of Object.entries(extension.flags ?? {})) {
+	for (const [name, defWithScope] of Object.entries(extension.flags)) {
 		const { recursive = true, ...def } = defWithScope;
 		injectExtensionFlag(root, name, def, recursive);
 	}
@@ -557,36 +684,12 @@ function cloneCommandNode(node) {
 		args: [...node.args],
 		subCommands,
 		contexts: node.contexts.map((context) => ({ ...context })),
+		providedContexts: [...node.providedContexts],
 		demands: [...node.demands],
 		extensions: [...node.extensions],
 		run: node.run
 	};
 }
-function invalidSections({ subject, name }) {
-	return new CrustError("DEFINITION", `${subject === "command" ? "Command" : "Extension"} "${name}" contains invalid documentation sections`, {
-		subject,
-		name,
-		reason: "invalid-sections"
-	});
-}
-function normalizeSection(section, owner) {
-	const { title, body, only, except } = section;
-	if (!title.trim() || /[\r\n]/.test(title) || !body.trim() || only?.length === 0 || except?.length === 0 || only !== void 0 && except !== void 0) throw invalidSections(owner);
-	const audience = (ids) => {
-		return Object.freeze(ids.map((consumer) => typeof consumer === "string" ? consumer : consumer.id));
-	};
-	return Object.freeze({
-		title,
-		body,
-		...only ? { only: audience(only) } : except ? { except: audience(except) } : {}
-	});
-}
-function validateCommandSections(name, sections) {
-	return sections.map((section) => normalizeSection(section, {
-		subject: "command",
-		name
-	}));
-}
 function contributionTarget(root, command, extension) {
 	let target = root;
 	for (const segment of command) {
@@ -613,6 +716,30 @@ function applyExtensionSections(root, extension, snapshot) {
 		target.meta.sections = [...target.meta.sections ?? [], section];
 	}
 }
+/**
+* Install Context sections where each Context is provided: `.provide()` on its own
+* command only, Extension providers once on the root. Unlike Extension section
+* contributions, a title already on the command is a `DEFINITION` error.
+*/
+function applyContextSections(root, extensions) {
+	const visit = (node, path, instances) => {
+		const effective = [...new Map(instances.map((instance) => [instance.name, instance])).values()];
+		if (effective.some((instance) => instance.sections.length > 0)) {
+			const titles = new Set((node.meta.sections ?? []).map(({ title }) => title));
+			for (const instance of effective) {
+				for (const { title } of instance.sections) if (titles.has(title)) throw new CrustError("DEFINITION", `Context "${instance.name}" section "${title}" duplicates a section on command "${path}"`, {
+					subject: "context",
+					name: instance.name,
+					reason: "duplicate-section"
+				});
+				for (const { title } of instance.sections) titles.add(title);
+			}
+			node.meta.sections = [...node.meta.sections ?? [], ...effective.flatMap((instance) => instance.sections)];
+		}
+		for (const [name, child] of Object.entries(node.subCommands)) visit(child, `${path} ${name}`, child.providedContexts);
+	};
+	visit(root, root.meta.name, [...root.providedContexts, ...extensions.flatMap((extension) => extension.provide)]);
+}
 function installExtensionContexts(node, extensions, reRegisteredIds) {
 	const cloned = cloneCommandNode(node);
 	const kept = new Set(extensions.flatMap((e) => !reRegisteredIds.has(e.id) && node.extensions.includes(e) ? [e.id] : []));
@@ -636,7 +763,7 @@ function installExtensionContexts(node, extensions, reRegisteredIds) {
 	prune(cloned);
 	for (const extension of extensions) {
 		if (kept.has(extension.id)) continue;
-		const instances = extension.provides ?? [];
+		const instances = extension.provide;
 		if (instances.length === 0) continue;
 		const walk = (target, skip) => {
 			const installed = instances.filter((instance) => !skip.has(instance.name));
@@ -711,6 +838,50 @@ function coerceJson(raw) {
 	}
 }
 //#endregion
+//#region src/parsing/schema.ts
+async function runSchema(schema, raw, path, issues) {
+	const result = await schema["~standard"].validate(raw);
+	if (result.issues) {
+		issues.push(...normalizeStandardIssues(result.issues, path));
+		return { ok: false };
+	}
+	return {
+		ok: true,
+		value: result.value
+	};
+}
+/**
+* Apply Standard Schemas declared on arg/flag definitions.
+*
+* Runs after syntax parsing and structural validation: each schema receives
+* the raw parsed value (`string | undefined` for args, the raw token value
+* for flags, arrays for variadic/multiple) and exclusively owns coercion,
+* defaults, requiredness, and validation. Returns transformed copies of
+* `args`/`flags`; definitions without a schema pass through unchanged.
+*
+* @throws {CrustError} `VALIDATION` aggregating every schema issue
+*/
+async function applySchemas(node, parsed) {
+	const issues = [];
+	const args = new Map(Object.entries(parsed.args));
+	const flags = new Map(Object.entries(parsed.flags));
+	for (const def of node.args) {
+		if (def.schema === void 0) continue;
+		const result = await runSchema(def.schema, args.get(def.name), ["args", def.name], issues);
+		if (result.ok) args.set(def.name, result.value);
+	}
+	for (const [name, def] of Object.entries(node.effectiveFlags)) {
+		if (def.schema === void 0) continue;
+		const result = await runSchema(def.schema, flags.get(name), ["flags", name], issues);
+		if (result.ok) flags.set(name, result.value);
+	}
+	if (issues.length > 0) throw new CrustError("VALIDATION", `Invalid input:\n${issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join("\n")}`, { issues });
+	return {
+		args: Object.fromEntries(args),
+		flags: Object.fromEntries(flags)
+	};
+}
+//#endregion
 //#region src/parsing/parser.ts
 /**
 * Build the options config for `util.parseArgs` from the shared spelling table.
@@ -945,7 +1116,8 @@ function resolveArgs(argsDef, positionals, coerce) {
 			configurable: true
 		});
 		if (def.variadic) {
-			resolved[name] = positionals.slice(index).map((v, i) => coerce(def, v, label, i));
+			const remaining = positionals.slice(index);
+			resolved[name] = remaining.length === 0 && def.default !== void 0 ? [resolveDefault(def, label)] : remaining.map((v, i) => coerce(def, v, label, i));
 			index = positionals.length;
 		} else if (index < positionals.length) {
 			resolved[name] = coerce(def, positionals[index], label);
@@ -1088,6 +1260,31 @@ function parseArgs$1(command, argv, env = process.env) {
 		rawArgs
 	};
 }
+/**
+* Resolve flags from their `env` bindings alone, as {@link parseArgs} does for an
+* empty argv: `env.delimiter` splitting, `choices`, `parse`, built-in coercion,
+* defaults, requiredness, then Standard Schemas. Flags without `env` resolve
+* to their defaults.
+*
+* @param flags - Flag definitions keyed by result name; each `env.name` selects its variable
+* @param env - Raw variable text; only own properties are read
+* @throws {CrustError} `DEFINITION` for a definition `defineFlag` rejects (e.g. a
+*   `__proto__` key or a default outside `choices`); `PARSE` or `VALIDATION` on the first
+*   coercion or requiredness failure, or `VALIDATION` aggregating schema issues. Messages
+*   may quote raw values.
+*/
+async function parseFlagValues(flags, env) {
+	for (const [name, def] of Object.entries(flags)) normalizeFlag(name, def);
+	const resolved = resolveFlags(flags, applyEnvAndDelimiter(flags, {}, env), coerceFlagValue);
+	validateRequiredFlags(flags, resolved);
+	return (await applySchemas({
+		args: [],
+		effectiveFlags: flags
+	}, {
+		args: {},
+		flags: resolved
+	})).flags;
+}
 /** Bind typed input without producing argv; the path alone selects the command. */
 function parseStructured(command, input) {
 	const { args: inputArgs, flags: inputFlags, raw } = input;
@@ -1149,87 +1346,6 @@ function validateParsed(command, parsed) {
 	validateRequiredFlags(flagsDef, flags);
 }
 //#endregion
-//#region src/parsing/schema.ts
-async function runSchema(schema, raw, path, issues) {
-	const result = await schema["~standard"].validate(raw);
-	if (result.issues) {
-		issues.push(...normalizeStandardIssues(result.issues, path));
-		return { ok: false };
-	}
-	return {
-		ok: true,
-		value: result.value
-	};
-}
-/**
-* Apply Standard Schemas declared on arg/flag definitions.
-*
-* Runs after syntax parsing and structural validation: each schema receives
-* the raw parsed value (`string | undefined` for args, the raw token value
-* for flags, arrays for variadic/multiple) and exclusively owns coercion,
-* defaults, requiredness, and validation. Returns transformed copies of
-* `args`/`flags`; definitions without a schema pass through unchanged.
-*
-* @throws {CrustError} `VALIDATION` aggregating every schema issue
-*/
-async function applySchemas(node, parsed) {
-	const issues = [];
-	const args = new Map(Object.entries(parsed.args));
-	const flags = new Map(Object.entries(parsed.flags));
-	for (const def of node.args) {
-		if (def.schema === void 0) continue;
-		const result = await runSchema(def.schema, args.get(def.name), ["args", def.name], issues);
-		if (result.ok) args.set(def.name, result.value);
-	}
-	for (const [name, def] of Object.entries(node.effectiveFlags)) {
-		if (def.schema === void 0) continue;
-		const result = await runSchema(def.schema, flags.get(name), ["flags", name], issues);
-		if (result.ok) flags.set(name, result.value);
-	}
-	if (issues.length > 0) throw new CrustError("VALIDATION", `Invalid input:\n${issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join("\n")}`, { issues });
-	return {
-		args: Object.fromEntries(args),
-		flags: Object.fromEntries(flags)
-	};
-}
-//#endregion
-//#region src/sections.ts
-/** Whether a command belongs in user-facing listings. */
-function isListed(command) {
-	return command.meta.hidden !== true;
-}
-/** Select and merge sections visible to the given consumer. */
-function sectionsFor(sections, consumer) {
-	const visible = (sections ?? []).filter((section) => {
-		if (section.only) return section.only.includes(consumer);
-		if (section.except) return !section.except.includes(consumer);
-		return true;
-	});
-	const merged = /* @__PURE__ */ new Map();
-	for (const section of visible) {
-		const existing = merged.get(section.title);
-		merged.set(section.title, existing ? {
-			title: section.title,
-			body: `${existing.body}\n${section.body}`
-		} : section);
-	}
-	return [...merged.values()];
-}
-/** Collect section-bearing visible commands in canonical path order. The root path is `[]`. */
-function visibleSectionsFor(snapshot, consumer) {
-	const groups = [];
-	function visit(command, path) {
-		const sections = sectionsFor(command.meta.sections, consumer);
-		if (sections.length > 0) groups.push({
-			path,
-			sections
-		});
-		for (const [name, child] of Object.entries(command.subCommands).sort(([a], [b]) => a.localeCompare(b))) if (isListed(child)) visit(child, [...path, name]);
-	}
-	visit(snapshot, []);
-	return groups;
-}
-//#endregion
 //#region src/command/snapshot.ts
 /** Drop keys with `undefined` values so snapshots serialize cleanly, then freeze. */
 function freezeCompact(obj) {
@@ -1449,7 +1565,7 @@ function resolveCommand(command, argv) {
 	};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.148.0/helpers/esm/usingCtx.js
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
 		var n = Error();
@@ -1545,7 +1661,9 @@ const DEFAULT_IO = {
 * without dispatching a Command Action. In-process callers use `Crust.snapshot()`.
 *
 * Only source entries run by `crust build` honor it: finished Bun/Node bundles carry
-* `process.env.CRUST_INTERNAL_BUILD === "1"` as a literal and compile the protocol out.
+* `process.env.CRUST_INTERNAL_BUILD === "1"` as a literal and compile the protocol out;
+* packaged Deno bundles set the `isPackagedBuild()` marker and skip it without
+* reading the environment.
 */
 const SNAPSHOT_PATH_ENV = "CRUST_INTERNAL_SNAPSHOT_PATH";
 const EXIT_CODE_CANCELLED = 130;
@@ -1655,8 +1773,9 @@ function buildExtensionTree(node, materializeCommandDefinition) {
 		extensions
 	};
 }
-/** Evaluate Extension section callbacks against current state and freeze the tree. */
+/** Install Context sections, evaluate Extension section callbacks, and freeze the tree. */
 function applySectionsAndFreeze(rootNode, extensions) {
+	applyContextSections(rootNode, extensions);
 	if (extensions.some((extension) => extension.sections !== void 0)) {
 		const authoredSnapshot = snapshotCommand(rootNode);
 		for (const extension of extensions) applyExtensionSections(rootNode, extension, authoredSnapshot);
@@ -1726,7 +1845,7 @@ async function dispatch(input, prepared, io, signal, onExtensionContext, onFailu
 			flags: parsed.flags,
 			rawArgs: parsed.rawArgs,
 			signal,
-			ctx: resolver.bag(extensions.flatMap((extension) => extension.uses ?? [])),
+			ctx: resolver.bag(extensions.flatMap((extension) => extension.use)),
 			finish: finishInvocation,
 			stdout: io.stdout,
 			stderr: io.stderr
@@ -1881,56 +2000,58 @@ async function executeInvocation(node, options, materializeCommandDefinition) {
 	};
 	const controller = new AbortController();
 	const signal = options?.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
-	const snapshotPath = process.env.CRUST_INTERNAL_BUILD === "1" ? void 0 : process.env[SNAPSHOT_PATH_ENV];
-	if (snapshotPath) {
-		try {
-			const base = buildExtensionTree(node, materializeCommandDefinition);
-			const takeSnapshot = () => snapshotCommand(applySectionsAndFreeze(cloneCommandNode(base.rootNode), base.extensions));
-			let snapshot = takeSnapshot();
-			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 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, {
+	if (!isPackagedBuild()) {
+		const snapshotPath = process.env.CRUST_INTERNAL_BUILD === "1" ? void 0 : process.env[SNAPSHOT_PATH_ENV];
+		if (snapshotPath) {
+			try {
+				const base = buildExtensionTree(node, materializeCommandDefinition);
+				const takeSnapshot = () => snapshotCommand(applySectionsAndFreeze(cloneCommandNode(base.rootNode), base.extensions));
+				let snapshot = takeSnapshot();
+				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 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,
-								path
+								files: files.map((file) => file.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);
+						} catch (error) {
+							const message = error instanceof Error ? error.message : String(error);
+							throw new Error(`Extension "${extension.id}" build failed: ${message}`, { cause: error });
 						}
-						extensions.push({
-							id: extension.id,
-							files: files.map((file) => file.path)
-						});
-					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
-						throw new Error(`Extension "${extension.id}" build failed: ${message}`, { cause: error });
+						snapshot = takeSnapshot();
 					}
-					snapshot = takeSnapshot();
+					await writeFile(join(dirname(snapshotPath), "build-report.json"), JSON.stringify({ extensions }));
 				}
-				await writeFile(join(dirname(snapshotPath), "build-report.json"), JSON.stringify({ extensions }));
+				await writeFile(snapshotPath, JSON.stringify(snapshot));
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				console.error(message);
+				return process.exit(1);
 			}
-			await writeFile(snapshotPath, JSON.stringify(snapshot));
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			console.error(message);
-			return process.exit(1);
+			return process.exit(0);
 		}
-		return process.exit(0);
 	}
 	const invoke = async () => {
 		let prepared;
@@ -1989,4 +2110,4 @@ async function executeInvocation(node, options, materializeCommandDefinition) {
 	return await (hasInjectedIO(options?.io) ? withAmbientTerminalIO(io, invoke) : invoke());
 }
 //#endregion
-export { CrustError as C, normalizeFlag as S, contextSources as _, runInvocation as a, validateContextAvailability as b, sectionsFor as c, cloneFlagRegistry as d, installExtensionContexts as f, defineExtension as g, registerFlag as h, resolveTypedPath as i, visibleSectionsFor as l, createCommandNode as m, executeInvocation as n, snapshotCommand as o, validateCommandSections as p, prepareInvocation as r, isListed as s, SNAPSHOT_PATH_ENV as t, cloneCommandNode as u, defineContext as v, normalizeArg as x, definingOf as y };
+export { normalizeFlag as C, normalizeArg as S, validateContextAvailability as _, runInvocation as a, validateCommandSections as b, cloneCommandNode as c, createCommandNode as d, registerFlag as f, definingOf as g, defineContext as h, resolveTypedPath as i, cloneFlagRegistry as l, contextSources as m, executeInvocation as n, snapshotCommand as o, defineExtension as p, prepareInvocation as r, parseFlagValues as s, SNAPSHOT_PATH_ENV as t, installExtensionContexts as u, isListed as v, CrustError as w, visibleSectionsFor as x, sectionsFor as y };