@vimhead.dev/norn-cli 0.1.0-tip.35359392805.1 → 0.1.0-tip.35390859630.1

package/assets/packages/cli/src/internal/workflow-registry.ts

@@ -1,24 +1,40 @@
-import { isWorkflowComplete, isWorkflowFail, isWorkflowNext, type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRunFor, type NornRunNext, type NornWorkflowGateInfo, type NornWorkflowImplementation, type NornWorkflowParams, type NornWorkflowPluginInfo } from "@vimhead.dev/norn";
+import { isWorkflowComplete, isWorkflowDeclaration, isWorkflowFail, isWorkflowNext, type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRunFor, type NornRunNext, type NornWorkflowContext, type NornWorkflowGateInfo, type NornWorkflowSource, type NornWorkflowScopeInfo, type NornProjectConfigurationInfo } from "@vimhead.dev/norn";
 import { assertWorkflowMetadata, inspectSchema, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
-import { type TSchema } from "typebox";
+import type { TSchema } from "typebox";
 import { Value } from "typebox/value";
 
+export type NornRegisteredConfiguration = { readonly key: string; readonly schema: TSchema | undefined; readonly input: unknown; readonly value: unknown };
 export type NornRegisteredWorkflow = {
-	workflow: NornAnyWorkflowDeclaration;
-	implementation: NornWorkflowImplementation<NornAnyWorkflowDeclaration, unknown>;
-	configuration?: NornRegisteredConfiguration;
-	plugin?: NornWorkflowPluginInfo;
+	readonly workflow: NornAnyWorkflowDeclaration;
+	readonly configuration: NornRegisteredConfiguration;
+	readonly scopeId: string | undefined;
+	readonly source: NornWorkflowSource | undefined;
 };
 
-export type NornRegisteredConfiguration = { readonly schema: TSchema; readonly input: unknown; readonly value: unknown };
+type NornRegisteredScope = { readonly definition: NornWorkflowScopeInfo; readonly configuration: NornRegisteredConfiguration };
 
-export function decodePluginConfiguration(input: { readonly pluginId: string; readonly schema: TSchema | undefined; readonly value: unknown }): NornRegisteredConfiguration | undefined {
+export function decodeConfiguration(input: { readonly key: string; readonly schema: TSchema | undefined; readonly value: unknown }): NornRegisteredConfiguration {
 	if (!input.schema) {
-		if (input.value !== undefined) throw new Error(`Norn config provided for plugin without config schema: ${input.pluginId}`);
-		return undefined;
+		if (input.value !== undefined) throw new Error(`Norn config provided without config schema: ${input.key}`);
+		return { key: input.key, schema: undefined, input: undefined, value: undefined };
+	}
+	const value = input.value === undefined && schemaType(unwrapSchema(input.schema)) === "object" ? {} : input.value;
+	return { key: input.key, schema: input.schema, input: value, value: Value.Decode(input.schema, value) };
+}
+
+export function assertCompatibleConfigurationOwners(workflows: readonly NornAnyWorkflowDeclaration[]): void {
+	const owners = new Map<string, { readonly kind: "workflow" | "scope"; readonly definition: object }>();
+	for (const workflow of workflows) {
+		for (const owner of [
+			{ key: workflow.id, kind: "workflow" as const, definition: workflow },
+			...(workflow.scope ? [{ key: workflow.scope.id, kind: "scope" as const, definition: workflow.scope }] : []),
+		]) {
+			const previous = owners.get(owner.key);
+			if (previous && previous.kind !== owner.kind) throw new Error(`Ambiguous configuration key: ${owner.key}`);
+			if (previous && owner.kind === "scope" && previous.definition !== owner.definition) throw new Error(`Duplicate workflow scope id: ${owner.key}; import one shared scope definition`);
+			owners.set(owner.key, owner);
+		}
 	}
-	const value = defaultConfigInput(input.schema, input.value);
-	return { schema: input.schema, input: value, value: Value.Decode(input.schema, value) };
 }
 
 export type NornWorkflowStepResult =
@@ -28,155 +44,142 @@ export type NornWorkflowStepResult =
 
 export class NornWorkflowRegistry {
 	private readonly entries = new Map<string, NornRegisteredWorkflow>();
+	private readonly scopes = new Map<string, NornRegisteredScope>();
 
-	register<TWorkflow extends NornAnyWorkflowDeclaration>(
-		workflow: TWorkflow,
-		implementation: NornWorkflowImplementation<TWorkflow, unknown>,
-		metadata: { readonly plugin?: NornWorkflowPluginInfo; readonly configuration?: NornRegisteredConfiguration } = {},
-	): NornDispose {
+	register(input: { readonly workflow: NornAnyWorkflowDeclaration; readonly config: Readonly<Record<string, unknown>>; readonly source: NornWorkflowSource | undefined }): NornDispose {
+		const { workflow, config, source } = input;
+		assertWorkflowDefinition(workflow);
 		if (this.entries.has(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
-
+		assertCompatibleConfigurationOwners([...this.sortedEntries().map(entry => entry.workflow), workflow]);
 		const entry: NornRegisteredWorkflow = {
-			workflow,
-			implementation: implementation as NornWorkflowImplementation<NornAnyWorkflowDeclaration, unknown>,
-			configuration: metadata.configuration,
-			plugin: metadata.plugin,
+			workflow, source, scopeId: workflow.scope?.id,
+			configuration: decodeConfiguration({ key: workflow.id, schema: workflow.config, value: configurationInput(config, workflow.id) }),
 		};
-		assertWorkflowMetadata(workflow);
-		assertGateWorkflow(workflow);
+		if (workflow.scope && !this.scopes.has(workflow.scope.id)) {
+			this.scopes.set(workflow.scope.id, {
+				definition: workflow.scope,
+				configuration: decodeConfiguration({ key: workflow.scope.id, schema: workflow.scope.config, value: configurationInput(config, workflow.scope.id) }),
+			});
+		}
 		this.entries.set(workflow.id, entry);
-
 		return () => {
-			if (this.entries.get(workflow.id) === entry) this.entries.delete(workflow.id);
+			if (this.entries.get(workflow.id) !== entry) return;
+			this.entries.delete(workflow.id);
+			if (entry.scopeId && ![...this.entries.values()].some(other => other.scopeId === entry.scopeId)) this.scopes.delete(entry.scopeId);
 		};
 	}
 
 	list(options: { readonly entrypointsOnly?: boolean } = {}): NornRegisteredWorkflowInfo[] {
-		const entries = options.entrypointsOnly ? this.launchableEntries() : this.sortedEntries();
-		return entries.map((entry) => workflowInfo(entry));
+		return (options.entrypointsOnly ? this.launchableEntries() : this.sortedEntries()).map(workflowInfo);
 	}
 
 	inspect(workflowId: string): NornInspectedWorkflowInfo | undefined {
 		const entry = this.entries.get(workflowId);
-		return entry ? inspectedWorkflowInfo(entry) : undefined;
+		const scope = entry?.scopeId ? this.scopes.get(entry.scopeId) : undefined;
+		return entry ? {
+			...workflowInfo(entry),
+			argsSchema: inspectSchema(entry.workflow.args),
+			configSchema: entry.configuration.schema ? inspectSchema(entry.configuration.schema) : null,
+			scope: scope ? {
+				id: scope.definition.id,
+				configKey: scope.configuration.key,
+				configSchema: scope.configuration.schema ? inspectSchema(scope.configuration.schema) : null,
+			} : undefined,
+			gate: gateInfo(entry.workflow),
+		} : undefined;
 	}
 
-	launchableEntries(): NornRegisteredWorkflow[] {
-		return this.sortedEntries().filter(({ workflow }) => workflow.isEntrypoint);
+	configurationInfos(): NornProjectConfigurationInfo[] {
+		return [
+			...this.sortedEntries().map(entry => ({ configuration: entry.configuration, scopeId: null })),
+			...[...this.scopes.values()].map(scope => ({ configuration: scope.configuration, scopeId: scope.definition.id })),
+		].map(({ configuration, scopeId }) => ({ key: configuration.key, scopeId, configSchema: configuration.schema ? inspectSchema(configuration.schema) : null, config: configuration.value }));
 	}
 
-	workflowById(workflowId: string): NornAnyWorkflowDeclaration | undefined {
-		return this.entries.get(workflowId)?.workflow;
-	}
+	launchableEntries(): NornRegisteredWorkflow[] { return this.sortedEntries().filter(({ workflow }) => workflow.isEntrypoint); }
+	workflowById(workflowId: string): NornAnyWorkflowDeclaration | undefined { return this.entries.get(workflowId)?.workflow; }
 
-	async describeGate<TWorkflow extends NornAnyWorkflowDeclaration>(
-		workflow: TWorkflow,
-		run: NornRunFor<TWorkflow>,
-		params: unknown,
-		configOverride?: unknown,
-	): Promise<string> {
-		const entry = this.entries.get(workflow.id);
-		if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
+	async describeGate<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<string> {
+		const entry = this.requireEntry(workflow.id);
 		if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
-		const parsedParams = Value.Decode(workflow.params, params) as NornWorkflowParams<TWorkflow>;
-		const parsedConfig = parseExecutionConfig(entry, configOverride);
-		const description = await (entry.implementation as NornWorkflowImplementation<TWorkflow, unknown>).gate?.describe(run, parsedParams, parsedConfig);
-		return validateGateDescription(description ?? workflow.id, workflow.id);
+		const context = this.createExecutionContext({ entry, run, args, configOverride });
+		const description = await entry.workflow.gate?.describe?.(context) ?? workflow.id;
+		if (typeof description !== "string" || description.trim().length === 0) throw new Error(`Workflow gate description must not be empty: ${workflow.id}`);
+		return description.trim();
 	}
 
-	async execute<TWorkflow extends NornAnyWorkflowDeclaration>(
-		workflow: TWorkflow,
-		run: NornRunFor<TWorkflow>,
-		params: unknown,
-		configOverride?: unknown,
-	): Promise<NornWorkflowStepResult> {
-		const entry = this.entries.get(workflow.id);
-		if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
-
-		const parsedParams = Value.Decode(workflow.params, params) as NornWorkflowParams<TWorkflow>;
-		const parsedConfig = parseExecutionConfig(entry, configOverride);
-		const result = await (entry.implementation as NornWorkflowImplementation<TWorkflow, unknown>).execute(run, parsedParams, parsedConfig);
+	async execute<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<NornWorkflowStepResult> {
+		const entry = this.requireEntry(workflow.id);
+		const result = await entry.workflow.execute(this.createExecutionContext({ entry, run, args, configOverride }));
 		if (isWorkflowNext(result)) return result;
 		if (isWorkflowComplete(result)) return { type: "complete", workflow, metadata: result.metadata };
 		if (isWorkflowFail(result)) return { type: "fail", workflow, metadata: result.metadata };
 		throw new Error(`Workflow returned invalid control result: ${workflow.id}`);
 	}
 
-	private sortedEntries(): NornRegisteredWorkflow[] {
-		return Array.from(this.entries.values()).sort((left, right) => left.workflow.id.localeCompare(right.workflow.id));
+	private createExecutionContext(input: { readonly entry: NornRegisteredWorkflow; readonly run: NornRunFor<NornAnyWorkflowDeclaration>; readonly args: unknown; readonly configOverride: unknown }): NornWorkflowContext {
+		const { entry, run, configOverride } = input;
+		const scope = entry.scopeId ? this.scopes.get(entry.scopeId) : undefined;
+		return {
+			args: Value.Decode(entry.workflow.args, input.args),
+			config: parseExecutionConfig(entry.configuration, configOverride),
+			...(scope ? { scope: { id: scope.definition.id, config: parseExecutionConfig(scope.configuration, configOverride) } } : {}),
+			run,
+		};
 	}
-}
 
-function defaultConfigInput(configSchema: TSchema, config: unknown): unknown {
-	if (config !== undefined) return config;
-	return schemaType(unwrapSchema(configSchema)) === "object" ? {} : undefined;
+	private requireEntry(id: string): NornRegisteredWorkflow {
+		const entry = this.entries.get(id);
+		if (!entry) throw new Error(`Unknown workflow: ${id}`);
+		return entry;
+	}
+	private sortedEntries(): NornRegisteredWorkflow[] { return [...this.entries.values()].sort((left, right) => left.workflow.id.localeCompare(right.workflow.id)); }
 }
 
-function parseExecutionConfig(entry: NornRegisteredWorkflow, configOverride: unknown): unknown {
-	const pluginConfigOverride = pluginConfigOverrideInput(entry, configOverride);
-	if (!entry.configuration) {
-		if (pluginConfigOverride !== undefined) throw new Error(`Run config override provided for plugin without config schema: ${entry.plugin?.id ?? entry.workflow.id}`);
-		return undefined;
-	}
-	if (pluginConfigOverride === undefined) return entry.configuration.value;
-	const rawConfig = isPlainObject(entry.configuration.input) && isPlainObject(pluginConfigOverride)
-		? deepMerge(entry.configuration.input, pluginConfigOverride)
-		: pluginConfigOverride;
-	return Value.Decode(entry.configuration.schema, rawConfig);
+function configurationInput(config: Readonly<Record<string, unknown>>, key: string): unknown {
+	return Object.hasOwn(config, key) ? config[key] : undefined;
 }
 
-function pluginConfigOverrideInput(entry: NornRegisteredWorkflow, configOverride: unknown): unknown {
-	if (configOverride === undefined) return undefined;
-	if (!isPlainObject(configOverride)) throw new Error("Run config override must be an object keyed by plugin id");
-	const pluginId = entry.plugin?.id;
-	return pluginId ? configOverride[pluginId] : undefined;
+function parseExecutionConfig(configuration: NornRegisteredConfiguration, overrides: unknown): unknown {
+	if (overrides !== undefined && !isPlainObject(overrides)) throw new Error("Run config override must be an object keyed by workflow or scope id");
+	const override = overrides ? configurationInput(overrides, configuration.key) : undefined;
+	if (override === undefined) return configuration.value;
+	if (!configuration.schema) throw new Error(`Run config override provided without config schema: ${configuration.key}`);
+	const input = isPlainObject(configuration.input) && isPlainObject(override) ? deepMerge(configuration.input, override) : override;
+	return Value.Decode(configuration.schema, input);
 }
 
 function deepMerge(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> {
-	const result: Record<string, unknown> = { ...base };
-	for (const [key, value] of Object.entries(override)) {
-		const baseValue = result[key];
-		result[key] = isPlainObject(baseValue) && isPlainObject(value) ? deepMerge(baseValue, value) : value;
-	}
+	const result = { ...base };
+	for (const [key, value] of Object.entries(override)) result[key] = isPlainObject(result[key]) && isPlainObject(value) ? deepMerge(result[key], value) : value;
 	return result;
 }
 
+export function assertWorkflowDefinition(workflow: NornAnyWorkflowDeclaration): void {
+	assertWorkflowMetadata(workflow);
+	if (!isWorkflowDeclaration(workflow)) throw new Error("Invalid workflow definition");
+	assertGateWorkflow(workflow);
+}
+
 function assertGateWorkflow(workflow: NornAnyWorkflowDeclaration): void {
 	if (!workflow.gate) return;
 	if (workflow.gate.enabled !== true) throw new Error(`Workflow gate must be enabled with true: ${workflow.id}`);
+	if (workflow.gate.describe !== undefined && typeof workflow.gate.describe !== "function") throw new Error(`Invalid gate description callback: ${workflow.id}`);
 	if (!workflow.gate.fields) return;
-	const paramsSchema = unwrapSchema(workflow.params);
-	if (schemaType(paramsSchema) !== "object") throw new Error(`Workflow gate fields require object params: ${workflow.id}`);
-	const paramsShape = schemaShape(paramsSchema);
-	for (const field of workflow.gate.fields) {
-		if (!Object.prototype.hasOwnProperty.call(paramsShape, field)) throw new Error(`Unknown workflow gate field ${field}: ${workflow.id}`);
-	}
-}
-
-function validateGateDescription(description: string, workflowId: string): string {
-	const trimmed = description.trim();
-	if (trimmed.length === 0) throw new Error(`Workflow gate description must not be empty: ${workflowId}`);
-	return trimmed;
-}
-
-function inspectedWorkflowInfo(entry: NornRegisteredWorkflow): NornInspectedWorkflowInfo {
-	return {
-		...workflowInfo(entry),
-		paramsSchema: inspectSchema(entry.workflow.params),
-		gate: gateInfo(entry.workflow),
-	};
+	const argsSchema = unwrapSchema(workflow.args);
+	if (schemaType(argsSchema) !== "object") throw new Error(`Workflow gate fields require object args: ${workflow.id}`);
+	const shape = schemaShape(argsSchema);
+	for (const field of workflow.gate.fields) if (!Object.hasOwn(shape, field)) throw new Error(`Unknown workflow gate field ${field}: ${workflow.id}`);
 }
 
 function workflowInfo(entry: NornRegisteredWorkflow): NornRegisteredWorkflowInfo {
 	return {
-		id: entry.workflow.id,
-		instructions: entry.workflow.instructions,
-		isEntrypoint: entry.workflow.isEntrypoint,
-		isolation: entry.workflow.isolation,
-		plugin: entry.plugin,
+		id: entry.workflow.id, instructions: entry.workflow.instructions, isEntrypoint: entry.workflow.isEntrypoint,
+		isolation: entry.workflow.isolation, source: entry.source,
+		configKey: entry.workflow.id,
+		scope: entry.scopeId ? { id: entry.scopeId } : undefined,
 	};
 }
-
 function gateInfo(workflow: NornAnyWorkflowDeclaration): NornWorkflowGateInfo | null {
 	return workflow.gate ? { enabled: true, fields: workflow.gate.fields } : null;
 }

package/assets/packages/cli/src/workflow-loader.ts

@@ -0,0 +1,214 @@
+import * as nornModule from "@vimhead.dev/norn";
+import { isWorkflowDeclaration, type NornAnyWorkflowDeclaration, type NornDispose, type NornWorkflowDiagnostic, type NornProjectInfo, type NornProjectInspection, type NornProjectConfigurationInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowSource } from "@vimhead.dev/norn";
+import { isNodeError } from "@vimhead.dev/norn-core/errors";
+import * as nornFilesModule from "@vimhead.dev/norn/files";
+import * as nornSchemaModule from "@vimhead.dev/norn/schema";
+import { inspectSchema, isPlainObject } from "@vimhead.dev/norn/schema";
+import { createJiti, type ModuleCache } from "jiti/static";
+import { access, readdir, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import * as typeboxModule from "typebox";
+import { Type, type StaticDecode } from "typebox";
+import * as typeboxCompileModule from "typebox/compile";
+import * as typeboxSchemaModule from "typebox/schema";
+import * as typeboxValueModule from "typebox/value";
+import { AssertError, Value } from "typebox/value";
+import { errorMessage, NornProjectLoadError } from "./internal/errors.ts";
+import { assertCompatibleConfigurationOwners, assertWorkflowDefinition, NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
+
+export const NORN_PROJECT_FILE_NAME = "norn.project.json";
+const nornConfigSchema = Type.Object({
+	workflows: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+	includes: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+	config: Type.Record(Type.String(), Type.Unknown(), { default: {} }),
+});
+const nornProjectConfigSchema = Type.Object({ ...nornConfigSchema.properties, version: Type.Literal(1, { default: 1 }) });
+type NornConfig = StaticDecode<typeof nornConfigSchema>;
+type NornProjectConfig = StaticDecode<typeof nornProjectConfigSchema>;
+type NornConfigFile = { readonly path: string; readonly root: string; readonly config: NornConfig };
+type NornProjectConfigFile = Omit<NornConfigFile, "config"> & { readonly config: NornProjectConfig };
+export type NornProject = {
+	readonly cwd: string; readonly projectPath: string; readonly projectRoot: string;
+	readonly configPath: string; readonly configRoot: string; readonly config: NornProjectConfig;
+	readonly configFiles: readonly NornConfigFile[]; readonly projectConfig: Record<string, unknown>;
+};
+export type NornLoadedProject = NornProject & {
+	readonly definitions: readonly NornAnyWorkflowDeclaration[];
+	readonly modules: readonly NornWorkflowSource[];
+	readonly configurations: readonly NornProjectConfigurationInfo[];
+	readonly registry: NornWorkflowRegistry;
+	readonly workflows: readonly NornRegisteredWorkflow[];
+};
+type ImportedWorkflowModule = { readonly definitions: readonly NornAnyWorkflowDeclaration[]; readonly source: NornWorkflowSource };
+
+export async function loadNornProject(cwd: string): Promise<NornLoadedProject> {
+	const { project, diagnostics } = await collectNornProject(cwd);
+	if (diagnostics.length) throw new NornProjectLoadError({ diagnostics });
+	return project;
+}
+export async function discoverNornProject(cwd: string): Promise<NornProjectInspection & NornWorkflowCatalogInfo> {
+	const { project, diagnostics } = await collectNornProject(cwd);
+	return { project: buildProjectInfo(project), workflows: project.registry.list(), isComplete: diagnostics.length === 0, diagnostics };
+}
+export async function inspectNornWorkflow(input: { readonly cwd: string; readonly workflowId: string }): Promise<NornWorkflowInspection> {
+	const { project, diagnostics } = await collectNornProject(input.cwd);
+	const summary = project.registry.list().find(workflow => workflow.id === input.workflowId);
+	if (!summary) {
+		if (!diagnostics.length) throw new Error(`Unknown workflow: ${input.workflowId}`);
+		return { workflow: null, isComplete: false, diagnostics };
+	}
+	try { return { workflow: project.registry.inspect(input.workflowId) ?? null, isComplete: diagnostics.length === 0, diagnostics }; }
+	catch (error) {
+		if (!summary.source) throw error;
+		return { workflow: null, isComplete: false, diagnostics: [...diagnostics, createDiagnostic({ source: summary.source, workflowId: summary.id, scopeId: summary.scope?.id ?? null, stage: "schema", error })] };
+	}
+}
+function buildProjectInfo(project: NornLoadedProject): NornProjectInfo {
+	return {
+		cwd: project.cwd, projectPath: project.projectPath, projectRoot: project.projectRoot,
+		configPath: project.configPath, configRoot: project.configRoot, configFiles: project.configFiles.map(file => file.path),
+		modules: project.modules, configurations: project.configurations,
+	};
+}
+export async function findNornProject(cwd: string): Promise<NornProject> {
+	const projectPath = await findNearestNornProject(cwd);
+	const projectFile = await readConfigFile({ path: projectPath, isProject: true });
+	const configFiles = await loadConfigTree(projectFile, new Set());
+	return {
+		cwd: resolve(cwd), projectPath, projectRoot: projectFile.root, configPath: projectPath, configRoot: projectFile.root,
+		config: projectFile.config, configFiles, projectConfig: mergeProjectConfig(configFiles),
+	};
+}
+async function findNearestNornProject(cwd: string): Promise<string> {
+	let current = resolve(cwd);
+	while (true) {
+		const path = join(current, NORN_PROJECT_FILE_NAME);
+		try { await access(path); return path; }
+		catch (error) { if (!isNodeError(error) || error.code !== "ENOENT") throw error; }
+		const parent = dirname(current);
+		if (parent === current) throw new Error(`Could not find ${NORN_PROJECT_FILE_NAME} from ${cwd}`);
+		current = parent;
+	}
+}
+async function loadConfigTree(file: NornConfigFile, visited: Set<string>): Promise<NornConfigFile[]> {
+	if (visited.has(file.path)) return [];
+	visited.add(file.path);
+	const files: NornConfigFile[] = [file];
+	for (const include of file.config.includes) {
+		for (const path of await expandIncludePath(file.root, include)) files.push(...await loadConfigTree(await readConfigFile({ path, isProject: false }), visited));
+	}
+	return files;
+}
+async function readConfigFile(input: { readonly path: string; readonly isProject: boolean }): Promise<NornProjectConfigFile> {
+	const raw: unknown = JSON.parse(await readFile(input.path, "utf8"));
+	if (isPlainObject(raw) && Object.hasOwn(raw, "plugins")) throw new Error(`Replace plugins with workflows in ${input.path}; registration modules must export workflow arrays`);
+	const schema = input.isProject ? nornProjectConfigSchema : nornConfigSchema;
+	const config = Value.Parse(schema, Value.Default(schema, raw));
+	return { path: input.path, root: dirname(input.path), config: { ...config, version: 1 } };
+}
+async function collectNornProject(cwd: string): Promise<{ readonly project: NornLoadedProject; readonly diagnostics: NornWorkflowDiagnostic[] }> {
+	const project = await findNornProject(cwd);
+	const imported = await importWorkflowModules(project);
+	const diagnostics = [...imported.diagnostics];
+	const registry = new NornWorkflowRegistry();
+	const loaded: ImportedWorkflowModule[] = [];
+	const conflicts = collectModuleConflicts(imported.modules);
+	for (const candidate of imported.modules) {
+		const conflict = conflicts.get(candidate);
+		if (conflict) { diagnostics.push(...conflict); continue; }
+		const unregister: NornDispose[] = [];
+		const errors: NornWorkflowDiagnostic[] = [];
+		for (const workflow of candidate.definitions) {
+			let stage: NornWorkflowDiagnostic["stage"] = "schema";
+			try {
+				if (workflow.config) inspectSchema(workflow.config);
+				if (workflow.scope?.config) inspectSchema(workflow.scope.config);
+				stage = "declaration";
+				assertWorkflowDefinition(workflow);
+				stage = "config";
+				unregister.push(registry.register({ workflow, config: project.projectConfig, source: candidate.source }));
+			} catch (error) { errors.push(createDiagnostic({ source: candidate.source, workflowId: workflow.id, scopeId: workflow.scope?.id ?? null, stage, error })); }
+		}
+		if (errors.length) { for (const dispose of unregister) dispose(); diagnostics.push(...errors); }
+		else loaded.push(candidate);
+	}
+	const definitions = loaded.flatMap(module => module.definitions);
+	return { project: { ...project, definitions, modules: loaded.map(module => module.source), configurations: registry.configurationInfos(), registry, workflows: registry.launchableEntries() }, diagnostics };
+}
+function collectModuleConflicts(modules: readonly ImportedWorkflowModule[]): Map<ImportedWorkflowModule, NornWorkflowDiagnostic[]> {
+	const conflicts = new Map<ImportedWorkflowModule, NornWorkflowDiagnostic[]>();
+	const byId = new Map<string, ImportedWorkflowModule[]>();
+	for (const module of modules) for (const workflow of module.definitions) byId.set(workflow.id, [...byId.get(workflow.id) ?? [], module]);
+	for (const [id, owners] of byId) {
+		if (owners.length < 2) continue;
+		for (const module of new Set(owners)) conflicts.set(module, [...conflicts.get(module) ?? [], createDiagnostic({ source: module.source, workflowId: id, scopeId: null, stage: "duplicate", error: new Error(`Workflow already registered: ${id}`) })]);
+	}
+	for (let index = 0; index < modules.length; index++) {
+		for (let other = index; other < modules.length; other++) {
+			const candidates = [...new Set([modules[index], modules[other]])];
+			try { assertCompatibleConfigurationOwners(candidates.flatMap(module => module.definitions)); }
+			catch (error) { for (const module of candidates) conflicts.set(module, [...conflicts.get(module) ?? [], createDiagnostic({ source: module.source, workflowId: null, scopeId: null, stage: "config", error })]); }
+		}
+	}
+	return conflicts;
+}
+async function importWorkflowModules(project: NornProject): Promise<{ readonly modules: ImportedWorkflowModule[]; readonly diagnostics: NornWorkflowDiagnostic[] }> {
+	const modules: ImportedWorkflowModule[] = [];
+	const diagnostics: NornWorkflowDiagnostic[] = [];
+	const jiti = createJiti(pathToFileURL(project.configPath).href, { moduleCache: false, tryNative: false, virtualModules: nornWorkflowVirtualModules() });
+	const cache: ModuleCache = Object.create(null);
+	for (const file of project.configFiles) for (const path of file.config.workflows) {
+		const source = { configPath: file.path, path: resolveConfigPath(file.root, path) };
+		let stage: NornWorkflowDiagnostic["stage"] = "import";
+		try {
+			const cached = cache[source.path];
+			const module = (cached?.loaded ? cached.exports : await jiti.evalModule(await readFile(source.path, "utf8"), { filename: source.path, cache, async: true })) as { default?: unknown };
+			stage = "declaration";
+			if (!Array.isArray(module?.default) || !Array.from(module.default).every(isWorkflowDeclaration)) throw new Error(`Workflow module must default-export an array of complete workflow definitions: ${source.path}`);
+			modules.push({ definitions: module.default, source });
+		} catch (error) {
+			for (const [path, module] of Object.entries(cache)) if (!module.loaded) delete cache[path];
+			diagnostics.push(createDiagnostic({ source, workflowId: null, scopeId: null, stage, error }));
+		}
+	}
+	return { modules, diagnostics };
+}
+function createDiagnostic(input: { readonly source: NornWorkflowSource; readonly workflowId: string | null; readonly scopeId: string | null; readonly stage: NornWorkflowDiagnostic["stage"]; readonly error: unknown }): NornWorkflowDiagnostic {
+	return { configPath: input.source.configPath, modulePath: input.source.path, scopeId: input.scopeId, workflowId: input.workflowId, stage: input.stage, message: errorMessage(input.error), issues: input.error instanceof AssertError ? input.error.cause.errors : [] };
+}
+function nornWorkflowVirtualModules(): Record<string, unknown> {
+	return { "@vimhead.dev/norn": nornModule, "@vimhead.dev/norn/files": nornFilesModule, "@vimhead.dev/norn/schema": nornSchemaModule, typebox: typeboxModule, "typebox/value": typeboxValueModule, "typebox/compile": typeboxCompileModule, "typebox/schema": typeboxSchemaModule };
+}
+function mergeProjectConfig(files: readonly NornConfigFile[]): Record<string, unknown> {
+	const [project, ...reusable] = files;
+	let config: Record<string, unknown> = {};
+	for (const file of reusable) config = mergeConfig({ base: config, override: file.config.config, path: ["config"], rejectConflicts: true });
+	return mergeConfig({ base: config, override: project?.config.config ?? {}, path: ["config"], rejectConflicts: false });
+}
+function mergeConfig(input: { readonly base: Record<string, unknown>; readonly override: Record<string, unknown>; readonly path: readonly string[]; readonly rejectConflicts: boolean }): Record<string, unknown> {
+	const result = { ...input.base };
+	for (const [key, value] of Object.entries(input.override)) {
+		const previous = result[key];
+		const path = [...input.path, key];
+		if (isPlainObject(previous) && isPlainObject(value)) result[key] = mergeConfig({ base: previous, override: value, path, rejectConflicts: input.rejectConflicts });
+		else if (input.rejectConflicts && Object.hasOwn(result, key) && JSON.stringify(previous) !== JSON.stringify(value)) throw new Error(`Conflicting Norn reusable config at ${path.join(".")}`);
+		else result[key] = value;
+	}
+	return result;
+}
+async function expandIncludePath(root: string, path: string): Promise<string[]> {
+	const segments = path.split(/[\\/]+/).filter(segment => segment.length && segment !== ".");
+	return segments.includes("*") ? expandGlobSegments(isAbsolute(path) ? sep : root, segments) : [resolveConfigPath(root, path)];
+}
+async function expandGlobSegments(root: string, segments: readonly string[]): Promise<string[]> {
+	if (!segments.length) return [root];
+	const [segment, ...remaining] = segments;
+	if (segment !== "*") return expandGlobSegments(join(root, segment), remaining);
+	const entries = await readdir(root, { withFileTypes: true });
+	return (await Promise.all(entries.filter(entry => entry.isDirectory()).sort((left, right) => left.name.localeCompare(right.name)).map(entry => expandGlobSegments(join(root, entry.name), remaining)))).flat();
+}
+function resolveConfigPath(root: string, path: string): string {
+	if (!path.length) throw new Error("Norn path must not be empty");
+	return isAbsolute(path) ? path : resolve(root, path);
+}

package/assets/packages/core/src/workflow-transition.ts

@@ -1,4 +1,4 @@
-export function createWorkflowTransition(input: { readonly workflowId: string; readonly params: unknown }): { readonly type: "next"; readonly workflowId: string; readonly params: unknown } {
+export function createWorkflowTransition(input: { readonly workflowId: string; readonly args: unknown }): { readonly type: "next"; readonly workflowId: string; readonly args: unknown } {
 	if (typeof input.workflowId !== "string" || input.workflowId.trim().length === 0) throw new Error("Workflow transition requires a nonempty workflow ID");
-	return { type: "next", workflowId: input.workflowId, params: input.params };
+	return { type: "next", workflowId: input.workflowId, args: input.args };
 }