@vimhead.dev/norn-cli 0.1.0-tip.35240723931.1 → 0.1.0-tip.35343816255.1

package/assets/packages/cli/src/internal/run-state.ts

@@ -7,6 +7,8 @@ import { getRunLeaseHealth } from "./run-lease.ts";
 import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
 import { createRunFileCoordinator, type NornFileCoordinator } from "@vimhead.dev/norn/files";
 import { runCurrentRoot } from "./run-store.ts";
+import { jsonValueSchema } from "@vimhead.dev/norn/schema";
+import { Value } from "typebox/value";
 
 export const RUN_STATE_FILE_NAME = "run-state.json";
 const LEGACY_RUN_STATE_FILE_NAME = "runtime-state.json";
@@ -208,12 +210,14 @@ export class NornRunStateStore {
 		await this.files.withExclusiveLock(this.path, async (path) => {
 			const current = parseNornRunState(await readRunStateFile({ path, legacyPath: join(dirname(this.path), LEGACY_RUN_STATE_FILE_NAME) }));
 			const next = { ...current, ...patch, updatedAt: new Date().toISOString() };
+			if (next.current?.params !== undefined) Value.Assert(jsonValueSchema, next.current.params);
 			await writeJsonAtomically(path, next);
 			this.state = next;
 		});
 	}
 
 	private async write(): Promise<void> {
+		if (this.state.current?.params !== undefined) Value.Assert(jsonValueSchema, this.state.current.params);
 		await mkdir(dirname(this.path), { recursive: true });
 		await this.files.withExclusiveLock(this.path, (path) => writeJsonAtomically(path, this.state));
 	}

package/assets/packages/cli/src/internal/run.ts

@@ -1,6 +1,7 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
-import type { NornAnyWorkflowDeclaration, NornProjectRun, NornRunOutcomeMetadata, NornWorkflowIsolationMode, NornWorkflowTarget, NornWorkflowTargetParamsInput, NornRun } from "@vimhead.dev/norn";
+import type { NornAnyWorkflowDeclaration, NornProjectRun, NornRunOutcomeMetadata, NornWorkflowIsolationMode, NornRun } from "@vimhead.dev/norn";
+import { createWorkflowTransition } from "@vimhead.dev/norn-core/workflow-transition";
 import type { NornAgentResponseCollector } from "./agent-response-tool.ts";
 import type { NornArtifacts } from "./artifacts.ts";
 import { NornAgentRunner } from "./agents.ts";
@@ -106,12 +107,8 @@ export class NornRunContext implements NornProjectRun {
 		return this.resolveFromRoot(this.projectRoot, this.projectRoot, relativePath);
 	}
 
-	next<TWorkflow extends NornWorkflowTarget<any>>(workflow: TWorkflow, params: NornWorkflowTargetParamsInput<TWorkflow>): ReturnType<NornRun["next"]> {
-		return {
-			type: "next",
-			workflowId: typeof workflow === "string" ? workflow : workflow.id,
-			params,
-		};
+	next(workflowId: string, params: unknown): ReturnType<NornRun["next"]> {
+		return createWorkflowTransition({ workflowId, params });
 	}
 
 	complete(metadata?: NornRunOutcomeMetadata): ReturnType<NornRun["complete"]> {

package/assets/packages/cli/src/internal/state-store.ts

@@ -1,25 +1,33 @@
-import { readFile } from "node:fs/promises";
-import type { NornWorkflowStateDefinition, NornWorkflowState } from "@vimhead.dev/norn";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
-import { isNodeError } from "@vimhead.dev/norn-core/errors";
+import type { NornWorkflowState, NornWorkflowStateDefinition } from "@vimhead.dev/norn";
 import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
+import { isNodeError } from "@vimhead.dev/norn-core/errors";
+import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import { jsonValueSchema } from "@vimhead.dev/norn/schema";
+import { readFile } from "node:fs/promises";
+import type { Static, TSchema } from "typebox";
+import { Value } from "typebox/value";
+
+function copyStateValue<Schema extends TSchema>(schema: Schema, value: unknown): Static<Schema> {
+	Value.Assert(jsonValueSchema, value);
+	return structuredClone(Value.Parse(schema, value));
+}
 
 export class NornMemoryWorkflowState implements NornWorkflowState {
 	private readonly data = new Map<string, unknown>();
 
-	async get<T>(state: NornWorkflowStateDefinition<T>): Promise<T> {
+	async get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>> {
 		const value = await this.getOptional(state);
 		if (value === undefined) throw new Error(`Missing workflow state: ${state.id}`);
 		return value;
 	}
 
-	async getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined> {
+	async getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined> {
 		if (!this.data.has(state.id)) return undefined;
-		return state.schema.parse(this.data.get(state.id));
+		return copyStateValue(state.schema, this.data.get(state.id));
 	}
 
-	async set<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void> {
-		this.data.set(state.id, state.schema.parse(value));
+	async set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void> {
+		this.data.set(state.id, copyStateValue(state.schema, value));
 	}
 }
 
@@ -45,20 +53,20 @@ export class NornJsonWorkflowState implements NornWorkflowState {
 		});
 	}
 
-	async get<T>(state: NornWorkflowStateDefinition<T>): Promise<T> {
+	async get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>> {
 		const value = await this.getOptional(state);
 		if (value === undefined) throw new Error(`Missing workflow state: ${state.id}`);
 		return value;
 	}
 
-	async getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined> {
+	async getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined> {
 		const data = await this.input.files.withExclusiveLock(this.stateFile, (path) => this.readStateFile(path));
 		if (!Object.prototype.hasOwnProperty.call(data, state.id)) return undefined;
-		return state.schema.parse(data[state.id]);
+		return copyStateValue(state.schema, data[state.id]);
 	}
 
-	async set<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void> {
-		const parsedValue = state.schema.parse(value);
+	async set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void> {
+		const parsedValue = copyStateValue(state.schema, value);
 		await this.input.coordinateMutation(this.stateFile, () => this.input.files.withExclusiveLock(this.stateFile, async (path) => {
 			const data = await this.readStateFile(path);
 			Object.defineProperty(data, state.id, { value: parsedValue, enumerable: true, configurable: true, writable: true });

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

@@ -1,15 +1,26 @@
-import { z } from "zod";
-import { isWorkflowComplete, isWorkflowFail, isWorkflowNext, type NornAnyWorkflowDeclaration, type NornInspectedWorkflowInfo, type NornJsonSchema, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornDispose, type NornRunFail, type NornWorkflowGateInfo, type NornWorkflowImplementation, type NornRunNext, type NornRunFor, type NornWorkflowParams, type NornWorkflowPluginInfo } from "@vimhead.dev/norn";
-import { assertWorkflowMetadata, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
+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 { assertWorkflowMetadata, inspectSchema, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
+import { type TSchema } from "typebox";
+import { Value } from "typebox/value";
 
 export type NornRegisteredWorkflow = {
 	workflow: NornAnyWorkflowDeclaration;
 	implementation: NornWorkflowImplementation<NornAnyWorkflowDeclaration, unknown>;
-	configSchema?: z.ZodType;
-	config: unknown;
+	configuration?: NornRegisteredConfiguration;
 	plugin?: NornWorkflowPluginInfo;
 };
 
+export type NornRegisteredConfiguration = { readonly schema: TSchema; readonly input: unknown; readonly value: unknown };
+
+export function decodePluginConfiguration(input: { readonly pluginId: string; readonly schema: TSchema | undefined; readonly value: unknown }): NornRegisteredConfiguration | undefined {
+	if (!input.schema) {
+		if (input.value !== undefined) throw new Error(`Norn config provided for plugin without config schema: ${input.pluginId}`);
+		return undefined;
+	}
+	const value = defaultConfigInput(input.schema, input.value);
+	return { schema: input.schema, input: value, value: Value.Decode(input.schema, value) };
+}
+
 export type NornWorkflowStepResult =
 	| NornRunNext
 	| { readonly type: "complete"; readonly workflow: NornAnyWorkflowDeclaration; readonly metadata?: NornRunComplete["metadata"] }
@@ -21,15 +32,14 @@ export class NornWorkflowRegistry {
 	register<TWorkflow extends NornAnyWorkflowDeclaration>(
 		workflow: TWorkflow,
 		implementation: NornWorkflowImplementation<TWorkflow, unknown>,
-		metadata: { readonly plugin?: NornWorkflowPluginInfo; readonly configSchema?: z.ZodType; readonly config?: unknown } = {},
+		metadata: { readonly plugin?: NornWorkflowPluginInfo; readonly configuration?: NornRegisteredConfiguration } = {},
 	): NornDispose {
 		if (this.entries.has(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
 
 		const entry: NornRegisteredWorkflow = {
 			workflow,
 			implementation: implementation as NornWorkflowImplementation<NornAnyWorkflowDeclaration, unknown>,
-			configSchema: metadata.configSchema,
-			config: metadata.configSchema ? metadata.configSchema.parse(defaultConfigInput(metadata.configSchema, metadata.config)) : undefined,
+			configuration: metadata.configuration,
 			plugin: metadata.plugin,
 		};
 		assertWorkflowMetadata(workflow);
@@ -68,7 +78,7 @@ export class NornWorkflowRegistry {
 		const entry = this.entries.get(workflow.id);
 		if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
 		if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
-		const parsedParams = workflow.params.parse(params) as NornWorkflowParams<TWorkflow>;
+		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);
@@ -83,7 +93,7 @@ export class NornWorkflowRegistry {
 		const entry = this.entries.get(workflow.id);
 		if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
 
-		const parsedParams = workflow.params.parse(params) as Parameters<NornWorkflowImplementation<TWorkflow, unknown>["execute"]>[1];
+		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);
 		if (isWorkflowNext(result)) return result;
@@ -97,22 +107,22 @@ export class NornWorkflowRegistry {
 	}
 }
 
-function defaultConfigInput(configSchema: z.ZodType, config: unknown): unknown {
+function defaultConfigInput(configSchema: TSchema, config: unknown): unknown {
 	if (config !== undefined) return config;
 	return schemaType(unwrapSchema(configSchema)) === "object" ? {} : undefined;
 }
 
 function parseExecutionConfig(entry: NornRegisteredWorkflow, configOverride: unknown): unknown {
 	const pluginConfigOverride = pluginConfigOverrideInput(entry, configOverride);
-	if (!entry.configSchema) {
+	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.config;
-	const rawConfig = isPlainObject(entry.config) && isPlainObject(pluginConfigOverride)
-		? deepMerge(entry.config, pluginConfigOverride)
+	if (pluginConfigOverride === undefined) return entry.configuration.value;
+	const rawConfig = isPlainObject(entry.configuration.input) && isPlainObject(pluginConfigOverride)
+		? deepMerge(entry.configuration.input, pluginConfigOverride)
 		: pluginConfigOverride;
-	return entry.configSchema.parse(rawConfig);
+	return Value.Decode(entry.configuration.schema, rawConfig);
 }
 
 function pluginConfigOverrideInput(entry: NornRegisteredWorkflow, configOverride: unknown): unknown {
@@ -152,7 +162,7 @@ function validateGateDescription(description: string, workflowId: string): strin
 function inspectedWorkflowInfo(entry: NornRegisteredWorkflow): NornInspectedWorkflowInfo {
 	return {
 		...workflowInfo(entry),
-		paramsSchema: jsonSchema(entry.workflow.params),
+		paramsSchema: inspectSchema(entry.workflow.params),
 		gate: gateInfo(entry.workflow),
 	};
 }
@@ -170,7 +180,3 @@ function workflowInfo(entry: NornRegisteredWorkflow): NornRegisteredWorkflowInfo
 function gateInfo(workflow: NornAnyWorkflowDeclaration): NornWorkflowGateInfo | null {
 	return workflow.gate ? { enabled: true, fields: workflow.gate.fields } : null;
 }
-
-function jsonSchema(schema: z.ZodType): NornJsonSchema {
-	return z.toJSONSchema(schema, { io: "input" }) as NornJsonSchema;
-}

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

@@ -1,39 +1,37 @@
-import { access, readFile, readdir } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { pathToFileURL } from "node:url";
-import { createJiti } from "jiti/static";
-import * as typeboxModule from "typebox";
-import { z } from "zod";
-import * as zodModule from "zod";
 import * as nornModule from "@vimhead.dev/norn";
+import { isWorkflowPlugin, type NornDispose, type NornPluginDiagnostic, type NornProjectInfo, type NornProjectInspection, type NornProjectPluginInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowPlugin, type NornWorkflowPluginInfo } 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 * as nornSeerModule from "@vimhead.dev/norn/seer";
-import { isWorkflowPlugin, type NornDispose, type NornPluginDiagnostic, type NornProjectInfo, type NornProjectInspection, type NornProjectPluginInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowPlugin, type NornWorkflowPluginInfo } from "@vimhead.dev/norn";
+import { inspectSchema } from "@vimhead.dev/norn/schema";
+import { createJiti } 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 { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { NornMemoryWorkflowState } from "./internal/state-store.ts";
-import { NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
-import { schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
-import { resolveSeerModeConfig, type NornResolvedSeerModeConfig } from "@vimhead.dev/norn/seer";
+import { decodePluginConfiguration, NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
 
 export const NORN_PROJECT_FILE_NAME = "norn.project.json";
 
-const seerModeConfigSchema = z.object({
-	writableRoots: z.array(z.string().min(1)).min(1),
+const nornConfigSchema = Type.Object({
+	plugins: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+	includes: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+	config: Type.Record(Type.String(), Type.Unknown(), { default: {} }),
 });
-const nornConfigSchema = z.object({
-	plugins: z.array(z.string().min(1)).default([]),
-	includes: z.array(z.string().min(1)).default([]),
-	config: z.record(z.string(), z.unknown()).default({}),
-});
-const nornProjectConfigSchema = nornConfigSchema.extend({
-	version: z.literal(1).default(1),
-	seerMode: seerModeConfigSchema.optional(),
+const nornProjectConfigSchema = Type.Object({
+	...nornConfigSchema.properties,
+	version: Type.Literal(1, { default: 1 }),
 });
 
-type NornConfig = z.output<typeof nornConfigSchema> & { readonly seerMode?: never };
-type NornProjectConfig = z.output<typeof nornProjectConfigSchema>;
+type NornConfig = StaticDecode<typeof nornConfigSchema>;
+type NornProjectConfig = StaticDecode<typeof nornProjectConfigSchema>;
 
 type NornConfigFile = {
 	readonly path: string;
@@ -50,7 +48,6 @@ export type NornProject = {
 	readonly config: NornProjectConfig;
 	readonly configFiles: readonly NornConfigFile[];
 	readonly projectConfig: Record<string, unknown>;
-	readonly seerMode?: NornResolvedSeerModeConfig;
 };
 
 export type NornLoadedProject = NornProject & {
@@ -101,7 +98,6 @@ function buildProjectInfo(project: NornLoadedProject): NornProjectInfo {
 		cwd: project.cwd, projectPath: project.projectPath, projectRoot: project.projectRoot,
 		configPath: project.configPath, configRoot: project.configRoot,
 		configFiles: project.configFiles.map(file => file.path), plugins: project.pluginInfos,
-		seerMode: project.seerMode ?? null,
 	};
 }
 
@@ -118,7 +114,6 @@ export async function findNornProject(cwd: string): Promise<NornProject> {
 		config: projectRootConfig.config,
 		configFiles,
 		projectConfig: mergeProjectConfig(configFiles),
-		seerMode: resolveSeerModeConfig({ configPath: projectRootConfig.path, configRoot: projectRootConfig.root, seerMode: projectRootConfig.config.seerMode }),
 	};
 }
 
@@ -165,12 +160,12 @@ async function loadNornConfigTree(configFile: NornConfigFile, visitedPaths: Set<
 }
 
 async function readNornProjectConfigFile(path: string): Promise<NornProjectConfigFile> {
-	const config = nornProjectConfigSchema.parse(JSON.parse(await readFile(path, "utf8")));
+	const config = Value.Parse(nornProjectConfigSchema, Value.Default(nornProjectConfigSchema, JSON.parse(await readFile(path, "utf8"))));
 	return { path, root: dirname(path), config };
 }
 
 async function readNornConfigFile(path: string): Promise<NornConfigFile> {
-	const config = nornConfigSchema.parse(JSON.parse(await readFile(path, "utf8")));
+	const config = Value.Parse(nornConfigSchema, Value.Default(nornConfigSchema, JSON.parse(await readFile(path, "utf8"))));
 	return { path, root: dirname(path), config };
 }
 
@@ -275,12 +270,11 @@ function registerProjectPlugin(input: {
 	let stage: NornPluginDiagnostic["stage"] = "config";
 	try {
 		const configInput = input.project.projectConfig[plugin.manifest.id];
-		if (!plugin.manifest.config && configInput !== undefined) throw new Error(`Norn config provided for plugin without config schema: ${plugin.manifest.id}`);
-		const config = plugin.manifest.config ? plugin.manifest.config.parse(defaultConfigInput(plugin.manifest.config, configInput)) : undefined;
+		const configuration = decodePluginConfiguration({ pluginId: plugin.manifest.id, schema: plugin.manifest.config, value: configInput });
 		stage = "schema";
 		const info: NornProjectPluginInfo = {
 			id: plugin.manifest.id, path: source.pluginPath, configPath: source.configPath,
-			configSchema: plugin.manifest.config ? z.toJSONSchema(plugin.manifest.config, { io: "input" }) : null, config,
+			configSchema: plugin.manifest.config ? inspectSchema(plugin.manifest.config) : null, config: configuration?.value,
 		};
 		stage = "implementation";
 		const implementation = typeof plugin.implementation === "function" ? plugin.implementation({ cwd: input.project.cwd, state: input.state }) : plugin.implementation;
@@ -292,9 +286,9 @@ function registerProjectPlugin(input: {
 				stage = "duplicate";
 				if (input.registry.workflowById(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
 				stage = "declaration";
-				unregister.push(input.registry.register(workflow, workflowImplementation, { plugin: workflowPluginInfo(info), configSchema: plugin.manifest.config, config }));
+				unregister.push(input.registry.register(workflow, workflowImplementation, { plugin: workflowPluginInfo(info), configuration }));
 			} catch (error) {
-				diagnostics.push(createPluginDiagnostic({ source, workflowId: workflow.id, stage: error instanceof z.ZodError ? "config" : stage, error }));
+				diagnostics.push(createPluginDiagnostic({ source, workflowId: workflow.id, stage, error }));
 			}
 		}
 		if (diagnostics.length === 0) return { loaded: { plugin, info }, diagnostics };
@@ -313,9 +307,7 @@ function createPluginDiagnostic(input: {
 }): NornPluginDiagnostic {
 	return {
 		...input.source, workflowId: input.workflowId, stage: input.stage, message: errorMessage(input.error),
-		issues: input.error instanceof z.ZodError ? input.error.issues.map(issue => ({
-			path: issue.path.map(part => typeof part === "symbol" ? String(part) : part), code: issue.code, message: issue.message,
-		})) : [],
+		issues: input.error instanceof AssertError ? input.error.cause.errors : [],
 	};
 }
 
@@ -328,9 +320,10 @@ function nornWorkflowVirtualModules(): Record<string, unknown> {
 		"@vimhead.dev/norn": nornModule,
 		"@vimhead.dev/norn/files": nornFilesModule,
 		"@vimhead.dev/norn/schema": nornSchemaModule,
-		"@vimhead.dev/norn/seer": nornSeerModule,
 		typebox: typeboxModule,
-		zod: zodModule,
+		"typebox/value": typeboxValueModule,
+		"typebox/compile": typeboxCompileModule,
+		"typebox/schema": typeboxSchemaModule,
 	};
 }
 
@@ -373,11 +366,6 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function defaultConfigInput(configSchema: z.ZodType, config: unknown): unknown {
-	if (config !== undefined) return config;
-	return schemaType(unwrapSchema(configSchema)) === "object" ? {} : undefined;
-}
-
 async function expandIncludePath(configRoot: string, includePath: string): Promise<string[]> {
 	const resolvedIncludePath = resolveConfigPath(configRoot, includePath);
 	if (!hasGlobSegment(includePath)) return [resolvedIncludePath];

package/assets/packages/cli/src/resources.ts

@@ -1,18 +1,20 @@
+import type { NornResourceDefinition, NornResources } from "@vimhead.dev/norn";
+import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
+import { isNodeError } from "@vimhead.dev/norn-core/errors";
+import { createRunFileCoordinator, type NornFileCoordinator } from "@vimhead.dev/norn/files";
+import { jsonValueSchema } from "@vimhead.dev/norn/schema";
 import { mkdir, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { z } from "zod";
-import { createRunFileCoordinator, type NornFileCoordinator } from "@vimhead.dev/norn/files";
-import type { NornResourceDefinition, NornResources } from "@vimhead.dev/norn";
-import { isNodeError } from "@vimhead.dev/norn-core/errors";
-import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
+import { Type, type StaticDecode } from "typebox";
+import { Value } from "typebox/value";
 
-const definitionSchema = z.strictObject({ name: z.string(), kind: z.string().min(1), configuration: z.json() });
-const recordSchema = definitionSchema.extend({ isInitialized: z.boolean() });
+const definitionSchema = Type.Object({ name: Type.String(), kind: Type.String({ minLength: 1 }), configuration: jsonValueSchema }, { additionalProperties: false });
+const recordSchema = Type.Object({ ...definitionSchema.properties, isInitialized: Type.Boolean() }, { additionalProperties: false });
 
 export class NornRunResources implements NornResources {
 	readonly files: NornFileCoordinator;
-	private readonly entries = new Map<string, { readonly definition: z.output<typeof definitionSchema>; readonly value: Promise<unknown> }>();
+	private readonly entries = new Map<string, { readonly definition: StaticDecode<typeof definitionSchema>; readonly value: Promise<unknown> }>();
 
 	private constructor(private readonly runRoot: string) {
 		this.files = createRunFileCoordinator(runRoot);
@@ -26,7 +28,7 @@ export class NornRunResources implements NornResources {
 
 	async ensure<T>(definition: NornResourceDefinition<T>): Promise<T> {
 		if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(definition.name)) throw new Error(`Invalid resource name: ${definition.name}`);
-		const identity = definitionSchema.parse({ name: definition.name, kind: definition.kind, configuration: definition.configuration });
+		const identity = structuredClone(Value.Parse(definitionSchema, { name: definition.name, kind: definition.kind, configuration: definition.configuration }));
 		const existing = this.entries.get(definition.name);
 		if (existing) {
 			if (!isDeepStrictEqual(existing.definition, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
@@ -43,13 +45,13 @@ export class NornRunResources implements NornResources {
 		}
 	}
 
-	private async initializeResource<T>(definition: NornResourceDefinition<T>, identity: z.output<typeof definitionSchema>): Promise<T> {
+	private async initializeResource<T>(definition: NornResourceDefinition<T>, identity: StaticDecode<typeof definitionSchema>): Promise<T> {
 		const directory = join(this.runRoot, "current", "resources", definition.name);
 		await mkdir(directory, { recursive: true });
 		return this.files.withExclusiveLock(join(directory, "definition.json"), async (path) => {
-			let stored: z.output<typeof recordSchema> | undefined;
+			let stored: StaticDecode<typeof recordSchema> | undefined;
 			try {
-				stored = recordSchema.parse(JSON.parse(await readFile(path, "utf8")));
+				stored = Value.Parse(recordSchema, JSON.parse(await readFile(path, "utf8")));
 			} catch (error) {
 				if (!isNodeError(error) || error.code !== "ENOENT") throw error;
 			}

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

@@ -0,0 +1,4 @@
+export function createWorkflowTransition(input: { readonly workflowId: string; readonly params: unknown }): { readonly type: "next"; readonly workflowId: string; readonly params: 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 };
+}