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

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

@@ -1,23 +0,0 @@
-import { join, resolve } from "node:path";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { NornRunResources } from "../resources.ts";
-import { NornJsonWorkflowState } from "./state-store.ts";
-
-export async function initializeRunResources(runRoot: string): Promise<{ readonly resources: NornRunResources; readonly state: NornJsonWorkflowState }> {
-	const resources = await NornRunResources.initialize(runRoot);
-	const state = await resources.ensure({
-		name: "workflow-state",
-		kind: "norn.state",
-		configuration: { format: 1, path: "state.json" },
-		async initialize({ files, mode }) {
-			const state = new NornJsonWorkflowState({
-				stateFile: join(resolve(runRoot), "current", "state.json"),
-				files,
-				coordinateMutation: withFileMutationQueue,
-			});
-			await state.initialize(mode);
-			return state;
-		},
-	});
-	return { resources, state };
-}

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

@@ -1,83 +0,0 @@
-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<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<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined> {
-		if (!this.data.has(state.id)) return undefined;
-		return copyStateValue(state.schema, this.data.get(state.id));
-	}
-
-	async set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void> {
-		this.data.set(state.id, copyStateValue(state.schema, value));
-	}
-}
-
-export class NornJsonWorkflowState implements NornWorkflowState {
-	readonly stateFile: string;
-
-	constructor(private readonly input: {
-		readonly stateFile: string;
-		readonly files: NornFileCoordinator;
-		readonly coordinateMutation: <T>(path: string, operation: () => Promise<T>) => Promise<T>;
-	}) {
-		this.stateFile = input.stateFile;
-	}
-
-	async initialize(mode: "create" | "open"): Promise<void> {
-		await this.input.files.withExclusiveLock(this.stateFile, async (path) => {
-			try {
-				await this.readStateFile(path);
-			} catch (error) {
-				if (mode !== "create" || !isNodeError(error) || error.code !== "ENOENT") throw error;
-				await writeJsonAtomically(path, {});
-			}
-		});
-	}
-
-	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<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 copyStateValue(state.schema, data[state.id]);
-	}
-
-	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 });
-			await writeJsonAtomically(path, data);
-		}));
-	}
-
-	private async readStateFile(path: string): Promise<Record<string, unknown>> {
-		const content = await readFile(path, "utf8");
-		const parsed = JSON.parse(content) as unknown;
-		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as Record<string, unknown>;
-		throw new Error(`Invalid workflow state document: ${path}`);
-	}
-}

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

@@ -1,400 +0,0 @@
-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 { 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 { NornMemoryWorkflowState } from "./internal/state-store.ts";
-import { decodePluginConfiguration, NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
-
-export const NORN_PROJECT_FILE_NAME = "norn.project.json";
-
-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 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;
-};
-
-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 plugins: readonly NornWorkflowPlugin[];
-	readonly pluginInfos: readonly NornProjectPluginInfo[];
-	readonly registry: NornWorkflowRegistry;
-	readonly workflows: readonly NornRegisteredWorkflow[];
-	readonly state: NornMemoryWorkflowState;
-};
-
-type LoadedNornWorkflowPlugin = {
-	readonly plugin: NornWorkflowPlugin;
-	readonly info: NornProjectPluginInfo;
-};
-
-export async function loadNornProject(cwd: string): Promise<NornLoadedProject> {
-	const { project, diagnostics } = await collectNornProject(cwd);
-	if (diagnostics.length > 0) 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 === 0) throw new Error(`Unknown workflow: ${input.workflowId}`);
-		return { workflow: null, isComplete: false, diagnostics };
-	}
-	const info = summary.plugin;
-	if (!info?.path || !info.configPath) throw new Error(`Loaded workflow lacks plugin source: ${input.workflowId}`);
-	try {
-		return { workflow: project.registry.inspect(input.workflowId) ?? null, isComplete: diagnostics.length === 0, diagnostics };
-	} catch (error) {
-		return { workflow: null, isComplete: false, diagnostics: [...diagnostics, createPluginDiagnostic({
-			source: { configPath: info.configPath, pluginPath: info.path, pluginId: info.id },
-			workflowId: input.workflowId, 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), plugins: project.pluginInfos,
-	};
-}
-
-export async function findNornProject(cwd: string): Promise<NornProject> {
-	const projectPath = await findNearestNornProject(cwd);
-	const projectRootConfig = await readNornProjectConfigFile(projectPath);
-	const configFiles = await loadIncludedNornConfigFiles(projectRootConfig, new Set([projectRootConfig.path]));
-	return {
-		cwd: resolve(cwd),
-		projectPath: projectRootConfig.path,
-		projectRoot: projectRootConfig.root,
-		configPath: projectRootConfig.path,
-		configRoot: projectRootConfig.root,
-		config: projectRootConfig.config,
-		configFiles,
-		projectConfig: mergeProjectConfig(configFiles),
-	};
-}
-
-async function findNearestNornProject(cwd: string): Promise<string> {
-	let current = resolve(cwd);
-	while (true) {
-		const projectPath = join(current, NORN_PROJECT_FILE_NAME);
-		try {
-			await access(projectPath);
-			return projectPath;
-		} 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;
-	}
-}
-
-type NornProjectConfigFile = {
-	readonly path: string;
-	readonly root: string;
-	readonly config: NornProjectConfig;
-};
-
-async function loadIncludedNornConfigFiles(projectFile: NornProjectConfigFile, visitedPaths: Set<string>): Promise<NornConfigFile[]> {
-	const includedConfigFiles = await Promise.all(projectFile.config.includes.map(async (includePath) => {
-		const configPaths = await expandIncludePath(projectFile.root, includePath);
-		return Promise.all(configPaths.map(readNornConfigFile));
-	}));
-	const descendants = await Promise.all(includedConfigFiles.flat().map((includedConfigFile) => loadNornConfigTree(includedConfigFile, visitedPaths)));
-	return [createProjectConfigEntry(projectFile), ...descendants.flat()];
-}
-
-async function loadNornConfigTree(configFile: NornConfigFile, visitedPaths: Set<string>): Promise<NornConfigFile[]> {
-	if (visitedPaths.has(configFile.path)) return [];
-	visitedPaths.add(configFile.path);
-	const includedConfigFiles = await Promise.all(configFile.config.includes.map(async (includePath) => {
-		const configPaths = await expandIncludePath(configFile.root, includePath);
-		return Promise.all(configPaths.map(readNornConfigFile));
-	}));
-	const descendants = await Promise.all(includedConfigFiles.flat().map((includedConfigFile) => loadNornConfigTree(includedConfigFile, visitedPaths)));
-	return [configFile, ...descendants.flat()];
-}
-
-async function readNornProjectConfigFile(path: string): Promise<NornProjectConfigFile> {
-	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 = Value.Parse(nornConfigSchema, Value.Default(nornConfigSchema, JSON.parse(await readFile(path, "utf8"))));
-	return { path, root: dirname(path), config };
-}
-
-function createProjectConfigEntry(projectFile: NornProjectConfigFile): NornConfigFile {
-	return {
-		path: projectFile.path,
-		root: projectFile.root,
-		config: {
-			plugins: projectFile.config.plugins,
-			includes: projectFile.config.includes,
-			config: projectFile.config.config,
-		},
-	};
-}
-
-type NornPluginSource = Pick<NornPluginDiagnostic, "configPath" | "pluginPath" | "pluginId">;
-type ImportedNornPlugin = { readonly plugin: NornWorkflowPlugin; readonly source: NornPluginSource };
-
-async function collectNornProject(cwd: string): Promise<{ readonly project: NornLoadedProject; readonly diagnostics: NornPluginDiagnostic[] }> {
-	const project = await findNornProject(cwd);
-	const imported = await importWorkflowPlugins(project);
-	const diagnostics = [...imported.diagnostics];
-	const registry = new NornWorkflowRegistry();
-	const state = new NornMemoryWorkflowState();
-	const loaded: LoadedNornWorkflowPlugin[] = [];
-	const conflicts = collectPluginConflicts(imported.plugins);
-	for (const candidate of imported.plugins) {
-		const pluginConflicts = conflicts.get(candidate);
-		if (pluginConflicts) {
-			diagnostics.push(...pluginConflicts);
-			continue;
-		}
-		const result = registerProjectPlugin({ candidate, project, registry, state });
-		diagnostics.push(...result.diagnostics);
-		if (result.loaded) loaded.push(result.loaded);
-	}
-	return {
-		project: { ...project, plugins: loaded.map(entry => entry.plugin), pluginInfos: loaded.map(entry => entry.info), registry, workflows: registry.launchableEntries(), state },
-		diagnostics,
-	};
-}
-
-function collectPluginConflicts(plugins: readonly ImportedNornPlugin[]): Map<ImportedNornPlugin, NornPluginDiagnostic[]> {
-	const byPluginId = new Map<string, ImportedNornPlugin[]>();
-	const byWorkflowId = new Map<string, ImportedNornPlugin[]>();
-	for (const candidate of plugins) {
-		const id = candidate.plugin.manifest.id;
-		byPluginId.set(id, [...(byPluginId.get(id) ?? []), candidate]);
-		for (const workflowId of new Set(Object.values(candidate.plugin.manifest.workflows).map(workflow => workflow.id))) {
-			byWorkflowId.set(workflowId, [...(byWorkflowId.get(workflowId) ?? []), candidate]);
-		}
-	}
-	const conflicts = new Map<ImportedNornPlugin, NornPluginDiagnostic[]>();
-	for (const [pluginId, candidates] of byPluginId) {
-		if (candidates.length < 2) continue;
-		for (const candidate of candidates) conflicts.set(candidate, [createPluginDiagnostic({
-			source: candidate.source, workflowId: null, stage: "duplicate",
-			error: new Error(`Duplicate Norn plugin id: ${pluginId} (${candidates.map(other => other.source.pluginPath).join(", ")})`),
-		})]);
-	}
-	for (const [workflowId, candidates] of byWorkflowId) {
-		const distinctPlugins = candidates.filter(candidate => byPluginId.get(candidate.plugin.manifest.id)?.length === 1);
-		if (distinctPlugins.length < 2) continue;
-		for (const candidate of distinctPlugins) conflicts.set(candidate, [...(conflicts.get(candidate) ?? []), createPluginDiagnostic({
-			source: candidate.source, workflowId, stage: "duplicate",
-			error: new Error(`Workflow already registered: ${workflowId} (${distinctPlugins.map(other => other.source.pluginPath).join(", ")})`),
-		})]);
-	}
-	return conflicts;
-}
-
-async function importWorkflowPlugins(project: NornProject): Promise<{ readonly plugins: ImportedNornPlugin[]; readonly diagnostics: NornPluginDiagnostic[] }> {
-	const plugins: ImportedNornPlugin[] = [];
-	const diagnostics: NornPluginDiagnostic[] = [];
-	for (const configFile of project.configFiles) {
-		const jiti = createJiti(pathToFileURL(configFile.path).href, { moduleCache: false, virtualModules: nornWorkflowVirtualModules() });
-		for (const pluginPath of configFile.config.plugins) {
-			const source: NornPluginSource = { configPath: configFile.path, pluginPath: resolveConfigPath(configFile.root, pluginPath), pluginId: null };
-			let stage: NornPluginDiagnostic["stage"] = "import";
-			try {
-				const module = await jiti.import(pathToFileURL(source.pluginPath).href) as { default?: unknown };
-				stage = "declaration";
-				if (!isWorkflowPlugin(module?.default)) throw new Error(`Norn plugin must be the default export: ${source.pluginPath}`);
-				plugins.push({ plugin: module.default, source: { ...source, pluginId: module.default.manifest.id } });
-			} catch (error) {
-				diagnostics.push(createPluginDiagnostic({ source, workflowId: null, stage, error }));
-			}
-		}
-	}
-	return { plugins, diagnostics };
-}
-
-function registerProjectPlugin(input: {
-	readonly candidate: ImportedNornPlugin;
-	readonly project: NornProject;
-	readonly registry: NornWorkflowRegistry;
-	readonly state: NornMemoryWorkflowState;
-}): { readonly loaded: LoadedNornWorkflowPlugin | null; readonly diagnostics: NornPluginDiagnostic[] } {
-	const { plugin, source } = input.candidate;
-	const diagnostics: NornPluginDiagnostic[] = [];
-	const unregister: NornDispose[] = [];
-	let stage: NornPluginDiagnostic["stage"] = "config";
-	try {
-		const configInput = input.project.projectConfig[plugin.manifest.id];
-		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 ? 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;
-		for (const [key, workflow] of Object.entries(plugin.manifest.workflows)) {
-			stage = "implementation";
-			try {
-				const workflowImplementation = implementation.workflows?.[key];
-				if (typeof workflowImplementation?.execute !== "function") throw new Error(`Missing implementation for workflow ${workflow.id}`);
-				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), configuration }));
-			} catch (error) {
-				diagnostics.push(createPluginDiagnostic({ source, workflowId: workflow.id, stage, error }));
-			}
-		}
-		if (diagnostics.length === 0) return { loaded: { plugin, info }, diagnostics };
-	} catch (error) {
-		diagnostics.push(createPluginDiagnostic({ source, workflowId: null, stage, error }));
-	}
-	for (const dispose of unregister) dispose();
-	return { loaded: null, diagnostics };
-}
-
-function createPluginDiagnostic(input: {
-	readonly source: NornPluginSource;
-	readonly workflowId: string | null;
-	readonly stage: NornPluginDiagnostic["stage"];
-	readonly error: unknown;
-}): NornPluginDiagnostic {
-	return {
-		...input.source, workflowId: input.workflowId, stage: input.stage, message: errorMessage(input.error),
-		issues: input.error instanceof AssertError ? input.error.cause.errors : [],
-	};
-}
-
-function workflowPluginInfo(info: NornProjectPluginInfo): NornWorkflowPluginInfo {
-	return { id: info.id, path: info.path, configPath: info.configPath };
-}
-
-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(configFiles: readonly NornConfigFile[]): Record<string, unknown> {
-	const [projectFile, ...reusableConfigFiles] = configFiles;
-	let reusableConfig: Record<string, unknown> = {};
-	for (const configFile of reusableConfigFiles) {
-		reusableConfig = mergeReusableConfigObjects(reusableConfig, configFile.config.config, ["config"]);
-	}
-	return mergeProjectConfigObjects(reusableConfig, projectFile?.config.config ?? {});
-}
-
-function mergeReusableConfigObjects(base: Record<string, unknown>, override: Record<string, unknown>, path: readonly string[]): Record<string, unknown> {
-	const result: Record<string, unknown> = { ...base };
-	for (const [key, overrideValue] of Object.entries(override)) {
-		result[key] = Object.prototype.hasOwnProperty.call(result, key)
-			? mergeReusableConfigValue(result[key], overrideValue, [...path, key])
-			: overrideValue;
-	}
-	return result;
-}
-
-function mergeReusableConfigValue(base: unknown, override: unknown, path: readonly string[]): unknown {
-	if (isPlainObject(base) && isPlainObject(override)) return mergeReusableConfigObjects(base, override, path);
-	if (JSON.stringify(base) === JSON.stringify(override)) return base;
-	throw new Error(`Conflicting Norn reusable config at ${path.join(".")}`);
-}
-
-function mergeProjectConfigObjects(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> {
-	const result: Record<string, unknown> = { ...base };
-	for (const [key, overrideValue] of Object.entries(override)) {
-		result[key] = isPlainObject(result[key]) && isPlainObject(overrideValue)
-			? mergeProjectConfigObjects(result[key], overrideValue)
-			: overrideValue;
-	}
-	return result;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-async function expandIncludePath(configRoot: string, includePath: string): Promise<string[]> {
-	const resolvedIncludePath = resolveConfigPath(configRoot, includePath);
-	if (!hasGlobSegment(includePath)) return [resolvedIncludePath];
-	return expandGlobSegments(isAbsolute(includePath) ? sep : configRoot, splitPathSegments(includePath));
-}
-
-async function expandGlobSegments(root: string, segments: readonly string[]): Promise<string[]> {
-	if (segments.length === 0) return [root];
-	const [segment, ...remainingSegments] = segments;
-	if (segment === "*") {
-		const entries = await readdir(root, { withFileTypes: true });
-		const expanded = await Promise.all(entries
-			.filter((entry) => entry.isDirectory())
-			.sort((left, right) => left.name.localeCompare(right.name))
-			.map((entry) => expandGlobSegments(join(root, entry.name), remainingSegments)));
-		return expanded.flat();
-	}
-	return expandGlobSegments(join(root, segment), remainingSegments);
-}
-
-function resolveConfigPath(configRoot: string, path: string): string {
-	if (path.length === 0) throw new Error("Norn path must not be empty");
-	return isAbsolute(path) ? path : resolve(configRoot, path);
-}
-
-function hasGlobSegment(path: string): boolean {
-	return splitPathSegments(path).includes("*");
-}
-
-function splitPathSegments(path: string): string[] {
-	return path.split(/[\\/]+/).filter((segment) => segment.length > 0 && segment !== ".");
-}

package/dist/internal/run-resources.d.ts

@@ -1,6 +0,0 @@
-import { NornRunResources } from "../resources.ts";
-import { NornJsonWorkflowState } from "./state-store.ts";
-export declare function initializeRunResources(runRoot: string): Promise<{
-    readonly resources: NornRunResources;
-    readonly state: NornJsonWorkflowState;
-}>;

package/dist/internal/run-resources.js

@@ -1,26 +0,0 @@
-// src/internal/run-resources.ts
-import { join, resolve } from "node:path";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { NornRunResources } from "../resources.js";
-import { NornJsonWorkflowState } from "./state-store.js";
-async function initializeRunResources(runRoot) {
-  const resources = await NornRunResources.initialize(runRoot);
-  const state = await resources.ensure({
-    name: "workflow-state",
-    kind: "norn.state",
-    configuration: { format: 1, path: "state.json" },
-    async initialize({ files, mode }) {
-      const state2 = new NornJsonWorkflowState({
-        stateFile: join(resolve(runRoot), "current", "state.json"),
-        files,
-        coordinateMutation: withFileMutationQueue
-      });
-      await state2.initialize(mode);
-      return state2;
-    }
-  });
-  return { resources, state };
-}
-export {
-  initializeRunResources
-};

package/dist/internal/state-store.d.ts

@@ -1,23 +0,0 @@
-import type { NornWorkflowState, NornWorkflowStateDefinition } from "@vimhead.dev/norn";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
-import type { Static, TSchema } from "typebox";
-export declare class NornMemoryWorkflowState implements NornWorkflowState {
-    private readonly data;
-    get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>>;
-    getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined>;
-    set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
-}
-export declare class NornJsonWorkflowState implements NornWorkflowState {
-    private readonly input;
-    readonly stateFile: string;
-    constructor(input: {
-        readonly stateFile: string;
-        readonly files: NornFileCoordinator;
-        readonly coordinateMutation: <T>(path: string, operation: () => Promise<T>) => Promise<T>;
-    });
-    initialize(mode: "create" | "open"): Promise<void>;
-    get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>>;
-    getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined>;
-    set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
-    private readStateFile;
-}

package/dist/internal/state-store.js

@@ -1,103 +0,0 @@
-// ../core/src/atomic-files.ts
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-
-// ../core/src/errors.ts
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
-}
-
-// ../core/src/atomic-files.ts
-async function writeJsonAtomically(path, value) {
-  await writeTextAtomically(path, `${JSON.stringify(value, null, 2)}
-`);
-}
-async function writeTextAtomically(path, content) {
-  await mkdir(dirname(path), { recursive: true });
-  let existingMode;
-  try {
-    existingMode = (await stat(path)).mode & 511;
-  } catch (error) {
-    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-  }
-  const tmpPath = `${path}.${randomUUID()}.tmp`;
-  try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
-    if (existingMode !== void 0) await chmod(tmpPath, existingMode);
-    await rename(tmpPath, path);
-  } catch (error) {
-    await rm(tmpPath, { force: true }).catch(() => void 0);
-    throw error;
-  }
-}
-
-// src/internal/state-store.ts
-import { jsonValueSchema } from "@vimhead.dev/norn/schema";
-import { readFile } from "node:fs/promises";
-import { Value } from "typebox/value";
-function copyStateValue(schema, value) {
-  Value.Assert(jsonValueSchema, value);
-  return structuredClone(Value.Parse(schema, value));
-}
-var NornMemoryWorkflowState = class {
-  data = /* @__PURE__ */ new Map();
-  async get(state) {
-    const value = await this.getOptional(state);
-    if (value === void 0) throw new Error(`Missing workflow state: ${state.id}`);
-    return value;
-  }
-  async getOptional(state) {
-    if (!this.data.has(state.id)) return void 0;
-    return copyStateValue(state.schema, this.data.get(state.id));
-  }
-  async set(state, value) {
-    this.data.set(state.id, copyStateValue(state.schema, value));
-  }
-};
-var NornJsonWorkflowState = class {
-  constructor(input) {
-    this.input = input;
-    this.stateFile = input.stateFile;
-  }
-  input;
-  stateFile;
-  async initialize(mode) {
-    await this.input.files.withExclusiveLock(this.stateFile, async (path) => {
-      try {
-        await this.readStateFile(path);
-      } catch (error) {
-        if (mode !== "create" || !isNodeError(error) || error.code !== "ENOENT") throw error;
-        await writeJsonAtomically(path, {});
-      }
-    });
-  }
-  async get(state) {
-    const value = await this.getOptional(state);
-    if (value === void 0) throw new Error(`Missing workflow state: ${state.id}`);
-    return value;
-  }
-  async getOptional(state) {
-    const data = await this.input.files.withExclusiveLock(this.stateFile, (path) => this.readStateFile(path));
-    if (!Object.prototype.hasOwnProperty.call(data, state.id)) return void 0;
-    return copyStateValue(state.schema, data[state.id]);
-  }
-  async set(state, value) {
-    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 });
-      await writeJsonAtomically(path, data);
-    }));
-  }
-  async readStateFile(path) {
-    const content = await readFile(path, "utf8");
-    const parsed = JSON.parse(content);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
-    throw new Error(`Invalid workflow state document: ${path}`);
-  }
-};
-export {
-  NornJsonWorkflowState,
-  NornMemoryWorkflowState
-};