halfcode-compiler.xnl 0.1.1

package/dist/src-Dv8bfFUo.js

@@ -0,0 +1,607 @@
+import { n as loadResourceTree } from "./src-COEMEqZw.js";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { parse } from "yaml";
+//#region ../application-assembly/src/internal-bindings.ts
+const bindingsByDefinition = /* @__PURE__ */ new WeakMap();
+const compilationsByAssembly = /* @__PURE__ */ new WeakMap();
+const compilationsByBusinessObjects = /* @__PURE__ */ new WeakMap();
+function setObjectOperationBinding(definition, binding) {
+	bindingsByDefinition.set(definition, binding);
+}
+function requireObjectOperationBinding(definition) {
+	const binding = bindingsByDefinition.get(definition);
+	if (!binding) throw new Error(`Object operation ${definition.ref} has no internal binding`);
+	return binding;
+}
+function setObjectOperationCompilations(assembly, compilations) {
+	compilationsByAssembly.set(assembly, compilations);
+	compilationsByBusinessObjects.set(assembly.businessObjects, compilations);
+}
+function resolveObjectOperationCompilation(assembly, operationRef) {
+	const compilation = (compilationsByAssembly.get(assembly) ?? compilationsByBusinessObjects.get(assembly.businessObjects))?.get(operationRef);
+	if (!compilation) throw new Error(`Unknown object operation: ${operationRef}`);
+	return compilation;
+}
+//#endregion
+//#region ../application-assembly/src/index.ts
+var ObjectOperationContractError = class extends TypeError {
+	code;
+	path;
+	constructor(code, message, path) {
+		super(`${code}: ${message}${path ? ` at ${path}` : ""}`);
+		this.code = code;
+		this.path = path;
+		this.name = "ObjectOperationContractError";
+	}
+};
+function assertObjectOperationCatalog(catalog) {
+	const targetKinds = /* @__PURE__ */ new Map();
+	for (const definition of catalog.targetKinds) {
+		assertNonEmptyString(definition.kindFqn, "OBJECT_TARGET_KIND_INVALID", "target kind FQN", "targetKinds.kindFqn");
+		assertNonEmptyString(definition.ownerKindFqn, "OBJECT_OWNER_KIND_INVALID", "owner kind FQN", "targetKinds.ownerKindFqn");
+		if (definition.role !== "object" && definition.role !== "nested-subject") fail("OBJECT_TARGET_ROLE_INVALID", "target role must be object or nested-subject", "targetKinds.role");
+		if (targetKinds.has(definition.kindFqn)) fail("OBJECT_TARGET_KIND_DUPLICATE", `duplicate target kind ${definition.kindFqn}`, "targetKinds");
+		targetKinds.set(definition.kindFqn, definition);
+	}
+	const operationRefs = /* @__PURE__ */ new Set();
+	for (const definition of catalog.operations) {
+		assertObjectOperationDefinition(definition);
+		if (operationRefs.has(definition.ref)) fail("OBJECT_OPERATION_REF_DUPLICATE", `duplicate operation ref ${definition.ref}`, "operations");
+		operationRefs.add(definition.ref);
+		const ownerTarget = targetKinds.get(definition.ownerKindFqn);
+		if (!ownerTarget || ownerTarget.ownerKindFqn !== definition.ownerKindFqn || ownerTarget.role !== "object") fail("OBJECT_OWNER_TARGET_MISSING", `owner ${definition.ownerKindFqn} must publish itself as an object target`, "targetKinds");
+		if (definition.targets.kind !== "none") {
+			const targetKind = targetKinds.get(definition.targets.kindFqn);
+			if (!targetKind) fail("OBJECT_TARGET_KIND_UNPUBLISHED", `operation ${definition.ref} targets unpublished kind ${definition.targets.kindFqn}`, "operations.targets.kindFqn");
+			if (targetKind.ownerKindFqn !== definition.ownerKindFqn) fail("OBJECT_TARGET_OWNER_MISMATCH", `target kind ${targetKind.kindFqn} is owned by ${targetKind.ownerKindFqn}`, "operations.targets.kindFqn");
+		}
+	}
+}
+function assertObjectOperationDefinition(definition) {
+	assertNonEmptyString(definition.id, "OBJECT_OPERATION_ID_INVALID", "operation id", "operation.id");
+	assertNonEmptyString(definition.ownerKindFqn, "OBJECT_OWNER_KIND_INVALID", "owner kind FQN", "operation.ownerKindFqn");
+	const expectedRef = `${definition.ownerKindFqn}.${definition.id}`;
+	if (definition.ref !== expectedRef) fail("OBJECT_OPERATION_REF_INVALID", `operation ref must be ${expectedRef}`, "operation.ref");
+	if (definition.ownerResourceKind !== "PageObject" && definition.ownerResourceKind !== "BusinessObject") fail("OBJECT_OWNER_RESOURCE_KIND_INVALID", "owner resource kind must be PageObject or BusinessObject", "operation.ownerResourceKind");
+	if (definition.behavior !== "action" && definition.behavior !== "mutation") fail("OBJECT_OPERATION_BEHAVIOR_INVALID", "behavior must be action or mutation", "operation.behavior");
+	if (definition.effect !== "read-only" && definition.effect !== "write" && definition.effect !== "mixed") fail("OBJECT_OPERATION_EFFECT_INVALID", "effect must be read-only, write or mixed", "operation.effect");
+	if (definition.targets.kind !== "none" && definition.targets.kind !== "single" && definition.targets.kind !== "selection") fail("OBJECT_TARGET_CARDINALITY_INVALID", "target cardinality must be none, single or selection", "operation.targets.kind");
+	if (definition.targets.kind !== "none") assertNonEmptyString(definition.targets.kindFqn, "OBJECT_TARGET_KIND_INVALID", "target kind FQN", "operation.targets.kindFqn");
+	if (definition.invocationModes.length === 0 || new Set(definition.invocationModes).size !== definition.invocationModes.length || definition.invocationModes.some((mode) => mode !== "single" && mode !== "batch")) fail("OBJECT_INVOCATION_MODES_INVALID", "invocationModes must contain distinct single or batch modes", "operation.invocationModes");
+}
+function assertObjectOperationCall(call, definition, mode = "single") {
+	assertObjectOperationDefinition(definition);
+	if (!definition.invocationModes.includes(mode)) fail("OBJECT_INVOCATION_MODE_UNSUPPORTED", `operation ${definition.ref} does not support ${mode}`, "mode");
+	if (call.invocation.operationRef !== definition.ref) fail("OBJECT_OPERATION_REF_MISMATCH", `expected ${definition.ref}`, "invocation.operationRef");
+	if (call.invocation.kind !== definition.behavior) fail("OBJECT_OPERATION_BEHAVIOR_MISMATCH", `expected ${definition.behavior}`, "invocation.kind");
+	assertObjectTargets(call.targets, definition.targets);
+	if (call.invocation.kind === "action") {
+		if (call.invocation.input !== void 0) assertJsonValue(call.invocation.input, "invocation.input");
+	} else {
+		if (!("desired" in call.invocation)) fail("OBJECT_MUTATION_DESIRED_REQUIRED", "mutation invocation requires desired", "invocation.desired");
+		assertJsonValue(call.invocation.desired, "invocation.desired");
+	}
+	if (call.config !== void 0) assertJsonValue(call.config, "config", true);
+}
+function assertExecuteObjectOperationRequest(request, resolveDefinition) {
+	if (request.mode === "single") {
+		const definition = requiredOperationDefinition(request.call.invocation.operationRef, resolveDefinition);
+		assertObjectOperationCall(request.call, definition);
+		return;
+	}
+	if (request.config.atomicity !== "best-effort") fail("OBJECT_BATCH_ATOMICITY_UNSUPPORTED", "object operation batch only supports best-effort atomicity", "config.atomicity");
+	if (request.items.length === 0) fail("OBJECT_BATCH_EMPTY", "batch requires at least one item", "items");
+	const keys = /* @__PURE__ */ new Set();
+	let operationRef;
+	for (const [index, item] of request.items.entries()) {
+		assertNonEmptyString(item.key, "OBJECT_BATCH_KEY_INVALID", "batch item key", `items[${index}].key`);
+		if (keys.has(item.key)) fail("OBJECT_BATCH_KEY_DUPLICATE", `duplicate batch key ${item.key}`, `items[${index}].key`);
+		keys.add(item.key);
+		if (operationRef !== void 0 && item.call.invocation.operationRef !== operationRef) fail("OBJECT_BATCH_OPERATION_MISMATCH", "all batch items must use the same operation", `items[${index}].call.invocation.operationRef`);
+		operationRef = item.call.invocation.operationRef;
+		const definition = requiredOperationDefinition(operationRef, resolveDefinition);
+		assertObjectOperationCall(item.call, definition, "batch");
+	}
+}
+function requiredOperationDefinition(operationRef, resolveDefinition) {
+	const definition = resolveDefinition(operationRef);
+	if (!definition) fail("OBJECT_OPERATION_UNKNOWN", `unknown operation ${operationRef}`, "invocation.operationRef");
+	return definition;
+}
+function assertObjectTargets(actual, expected) {
+	if (actual.kind !== expected.kind) fail("OBJECT_TARGET_CARDINALITY_MISMATCH", `expected ${expected.kind}, received ${actual.kind}`, "targets.kind");
+	if (actual.kind === "none" || expected.kind === "none") return;
+	if (actual.kind === "single" && expected.kind === "single") {
+		assertTargetRef(actual.ref, expected.kindFqn, "targets.ref");
+		return;
+	}
+	if (actual.kind !== "selection" || expected.kind !== "selection") return;
+	if (actual.kindFqn !== expected.kindFqn) fail("OBJECT_TARGET_KIND_MISMATCH", `expected ${expected.kindFqn}, received ${actual.kindFqn}`, "targets.kindFqn");
+	if (actual.selector.kind === "all") return;
+	if (actual.selector.kind === "filter") {
+		assertJsonValue(actual.selector.where, "targets.selector.where", true);
+		return;
+	}
+	if (actual.selector.kind === "refs") {
+		if (actual.selector.refs.length === 0) fail("OBJECT_TARGET_REFS_EMPTY", "refs selector requires at least one ref", "targets.selector.refs");
+		actual.selector.refs.forEach((ref, index) => assertTargetRef(ref, expected.kindFqn, `targets.selector.refs[${index}]`));
+		return;
+	}
+	fail("OBJECT_TARGET_SELECTOR_UNSUPPORTED", "selector kind must be all, filter or refs", "targets.selector.kind");
+}
+function assertTargetRef(ref, expectedKindFqn, path) {
+	if (!ref || typeof ref !== "object" || ref.kindFqn !== expectedKindFqn) fail("OBJECT_TARGET_KIND_MISMATCH", `expected ${expectedKindFqn}`, `${path}.kindFqn`);
+	assertJsonValue(ref.key, `${path}.key`, true);
+}
+function assertJsonValue(value, path, requireObject = false) {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (current, currentPath) => {
+		if (current === null || typeof current === "string" || typeof current === "boolean") return;
+		if (typeof current === "number" && Number.isFinite(current)) return;
+		if (typeof current !== "object") fail("OBJECT_JSON_VALUE_INVALID", "value must be JSON-compatible", currentPath);
+		if (seen.has(current)) fail("OBJECT_JSON_VALUE_INVALID", "cyclic values are not JSON-compatible", currentPath);
+		seen.add(current);
+		if (Array.isArray(current)) current.forEach((item, index) => visit(item, `${currentPath}[${index}]`));
+		else {
+			const prototype = Object.getPrototypeOf(current);
+			if (prototype !== Object.prototype && prototype !== null) fail("OBJECT_JSON_VALUE_INVALID", "value must use plain JSON objects", currentPath);
+			for (const [key, item] of Object.entries(current)) visit(item, `${currentPath}.${key}`);
+		}
+		seen.delete(current);
+	};
+	if (requireObject && (!value || typeof value !== "object" || Array.isArray(value))) fail("OBJECT_JSON_OBJECT_REQUIRED", "value must be a JSON object", path);
+	visit(value, path);
+}
+function assertNonEmptyString(value, code, label, path) {
+	if (typeof value !== "string" || !value.trim()) fail(code, `${label} must be a non-empty string`, path);
+}
+function fail(code, message, path) {
+	throw new ObjectOperationContractError(code, message, path);
+}
+async function loadApplicationAssembly(options) {
+	return resolveApplicationAssembly({ modules: [{
+		id: "DefaultAuthoringModule",
+		packageName: options.packageName ?? "anonymous-authoring-module",
+		family: "standalone",
+		scope: "domain",
+		resourceRootDir: options.resourceRootDir,
+		manifestPath: options.manifestPath
+	}] });
+}
+async function resolveApplicationAssembly(options) {
+	if (options.modules.length === 0) throw new Error("Application assembly requires at least one authoring module");
+	assertUniqueModuleIds(options.modules);
+	const loaded = await Promise.all(options.modules.map(loadAuthoringModule));
+	const all = loaded.flatMap((module) => module.resources);
+	const internalOperationResources = loaded.flatMap((module) => module.internalOperationResources);
+	const byFqn = uniqueResourceMap(all);
+	const compilations = assertObjectOperationAssemblyClosure(all, uniqueResourceMap([...all, ...internalOperationResources]));
+	const portBindings = resolvePortBindings(options.modules.flatMap((module) => module.ports ?? []), options.portBindings ?? [], byFqn);
+	const assembly = {
+		rootDir: options.modules[0]?.resourceRootDir ?? "",
+		modules: [...options.modules],
+		portBindings,
+		functions: loaded.flatMap((module) => module.functions),
+		composedFunctions: loaded.flatMap((module) => module.composedFunctions),
+		businessObjects: loaded.flatMap((module) => module.businessObjects),
+		businessObjectSops: loaded.flatMap((module) => module.businessObjectSops),
+		applicationSops: loaded.flatMap((module) => module.applicationSops),
+		promptFragments: loaded.flatMap((module) => module.promptFragments),
+		wikiPages: loaded.flatMap((module) => module.wikiPages),
+		skillCapsules: loaded.flatMap((module) => module.skillCapsules),
+		pageObjects: loaded.flatMap((module) => module.pageObjects),
+		byFqn
+	};
+	setObjectOperationCompilations(assembly, compilations);
+	return assembly;
+}
+async function loadAuthoringModule(module) {
+	const records = [...(await loadResourceTree({
+		rootDir: module.resourceRootDir,
+		manifestPath: module.manifestPath
+	})).registry.byKind.values()].flat();
+	const functions = await Promise.all(records.filter((record) => record.kind === "Function").map((record) => readContractedCallable(module, record, "Function")));
+	const composedFunctions = await Promise.all(records.filter((record) => record.kind === "ComposedFunction").map((record) => readContractedCallable(module, record, "ComposedFunction")));
+	const businessActions = await Promise.all(records.filter((record) => record.kind === "BusinessAction").map((record) => readContractedCallable(module, record, "BusinessAction")));
+	const businessObjects = await Promise.all(records.filter((record) => record.kind === "BusinessObject").map((record) => readBusinessObject(module, record)));
+	const businessMutations = await Promise.all(records.filter((record) => record.kind === "BusinessMutation").map((record) => readBusinessMutation(module, record)));
+	const businessObjectSops = await Promise.all(records.filter((record) => record.kind === "BusinessObjectSOP").map((record) => readBusinessObjectSop(module, record)));
+	const applicationSops = await Promise.all(records.filter((record) => record.kind === "ApplicationSOP").map((record) => readTextResource(module, record, "ApplicationSOP")));
+	const promptFragments = await Promise.all(records.filter((record) => record.kind === "PromptFragment").map((record) => readTextResource(module, record, "PromptFragment")));
+	const wikiPages = await Promise.all(records.filter((record) => record.kind === "WikiPage").map((record) => readTextResource(module, record, "WikiPage")));
+	const skillCapsules = await Promise.all(records.filter((record) => record.kind === "SkillCapsule").map((record) => readSkillCapsule(module, record)));
+	const pageObjects = records.filter((record) => record.kind === "PageObject").map((record) => readPageObject(module, record));
+	return {
+		functions,
+		composedFunctions,
+		businessObjects,
+		businessActions,
+		businessMutations,
+		businessObjectSops,
+		applicationSops,
+		promptFragments,
+		wikiPages,
+		skillCapsules,
+		pageObjects,
+		resources: [
+			...functions,
+			...composedFunctions,
+			...businessObjects,
+			...businessObjectSops,
+			...applicationSops,
+			...promptFragments,
+			...wikiPages,
+			...skillCapsules,
+			...pageObjects
+		],
+		internalOperationResources: [...businessActions, ...businessMutations]
+	};
+}
+function readPageObject(module, record) {
+	const ownerKindFqn = requiredFqn(record);
+	const operations = requiredNode(record, "Operations");
+	const moduleBinding = requiredNodeCodeModuleBinding(record);
+	const operationDefinitions = readXnlObjectOperations(operations, "PageObject", ownerKindFqn, record, (operation) => ({
+		kind: "export",
+		codeBinding: {
+			...moduleBinding,
+			exportName: requiredNodeProperty(operation, "export", record)
+		}
+	}));
+	if (operationDefinitions.length === 0) throw new Error(`${record.logicalPath} is missing Action or Mutation operation`);
+	return {
+		kind: "PageObject",
+		fqn: ownerKindFqn,
+		id: requiredRootProperty(record, "localId"),
+		description: requiredDescription(record),
+		targetKinds: readXnlObjectTargetKinds(record.node.subdomains.TargetKinds, ownerKindFqn, record),
+		operations: operationDefinitions,
+		source: sourceFor(module, record)
+	};
+}
+function readXnlObjectOperations(operations, ownerResourceKind, ownerKindFqn, record, binding) {
+	const result = [];
+	for (const operation of nodeMembers(operations).filter((node) => node.tag === "Action" || node.tag === "Mutation")) {
+		const id = operation.resourceId;
+		if (!id) throw new Error(`${record.logicalPath} ${operation.tag} is missing #id`);
+		const target = requiredNodeProperty(operation, "target", record);
+		const targetKindFqn = optionalNodeProperty(operation, "targetKindFqn");
+		let targets;
+		if (target === "none") targets = { kind: "none" };
+		else if (target === "single" || target === "selection") targets = {
+			kind: target,
+			kindFqn: targetKindFqn ?? ""
+		};
+		else invalidObjectOperation(record, `${operation.tag} target must be none, single or selection`);
+		if (target === "none" && targetKindFqn) throw new Error(`${record.logicalPath} ${operation.tag} target none must not declare targetKindFqn`);
+		const definition = {
+			ref: `${ownerKindFqn}.${id}`,
+			id,
+			ownerKindFqn,
+			ownerResourceKind,
+			behavior: operation.tag === "Action" ? "action" : "mutation",
+			targets,
+			invocationModes: requiredNodeStringList(operation, "invocationModes", record),
+			effect: requiredNodeProperty(operation, "effect", record)
+		};
+		try {
+			assertObjectOperationDefinition(definition);
+		} catch (error) {
+			throw new Error(`${record.logicalPath} has invalid ${operation.tag} '${id}': ${error.message}`);
+		}
+		setObjectOperationBinding(definition, binding(operation));
+		result.push(definition);
+	}
+	return result;
+}
+function readXnlObjectTargetKinds(value, ownerKindFqn, record) {
+	const result = [{
+		kindFqn: ownerKindFqn,
+		ownerKindFqn,
+		role: "object"
+	}];
+	if (!value) return result;
+	for (const targetKind of nodeMembers(value).filter((node) => node.tag === "TargetKind")) {
+		const role = requiredNodeProperty(targetKind, "role", record);
+		if (role !== "nested-subject") throw new Error(`${record.logicalPath} explicit TargetKind role must be nested-subject`);
+		result.push({
+			kindFqn: requiredNodeProperty(targetKind, "kindFqn", record),
+			ownerKindFqn,
+			role
+		});
+	}
+	return result;
+}
+function invalidObjectOperation(record, message) {
+	throw new Error(`${record.logicalPath} ${message}`);
+}
+async function readContractedCallable(module, record, kind) {
+	const common = {
+		kind,
+		fqn: requiredFqn(record),
+		description: requiredDescription(record),
+		instruction: await readOptionalMaterial(module, record, "Instruction"),
+		inputContractRef: requiredNodeRef(record, "InputContract"),
+		outputContractRef: requiredNodeRef(record, "OutputContract"),
+		codeBinding: requiredNodeCodeBinding(record),
+		mutationRefs: refsFromNodeContainer(record.node.subdomains.Mutations, "Mutation"),
+		source: sourceFor(module, record)
+	};
+	return kind === "BusinessAction" ? {
+		...common,
+		kind,
+		ownerRef: requiredRootProperty(record, "ownerRef")
+	} : {
+		...common,
+		kind
+	};
+}
+async function readBusinessObject(module, record) {
+	const ownerKindFqn = requiredFqn(record);
+	const operations = record.node.subdomains.Operations;
+	return {
+		kind: "BusinessObject",
+		fqn: ownerKindFqn,
+		description: requiredDescription(record),
+		instruction: await readOptionalMaterial(module, record, "Instruction"),
+		sopRefs: refsFromNodeContainer(record.node.subdomains.SOPs, "SOP"),
+		relatedRefs: refsFromNodeContainer(record.node.subdomains.RelatedResources, "Resource"),
+		targetKinds: readXnlObjectTargetKinds(record.node.subdomains.TargetKinds, ownerKindFqn, record),
+		operations: operations ? readXnlObjectOperations(operations, "BusinessObject", ownerKindFqn, record, (operation) => ({
+			kind: "resource",
+			resourceRef: requiredNodeProperty(operation, "resourceRef", record)
+		})) : [],
+		source: sourceFor(module, record)
+	};
+}
+async function readBusinessMutation(module, record) {
+	return {
+		kind: "BusinessMutation",
+		fqn: requiredFqn(record),
+		description: requiredDescription(record),
+		instruction: await readOptionalMaterial(module, record, "Instruction"),
+		ownerRef: requiredRootProperty(record, "ownerRef"),
+		codeBinding: requiredNodeCodeBinding(record),
+		source: sourceFor(module, record)
+	};
+}
+async function readBusinessObjectSop(module, record) {
+	return {
+		kind: "BusinessObjectSOP",
+		fqn: requiredFqn(record),
+		description: requiredDescription(record),
+		instruction: await readOptionalMaterial(module, record, "Instruction"),
+		source: sourceFor(module, record)
+	};
+}
+async function readTextResource(module, record, kind) {
+	return {
+		kind,
+		fqn: requiredFqn(record),
+		description: requiredDescription(record),
+		instruction: await readOptionalMaterial(module, record, "Instruction"),
+		source: sourceFor(module, record)
+	};
+}
+async function readSkillCapsule(module, record) {
+	const metadata = await readRequiredMaterial(module, record, "SkillMetadata");
+	const template = await readRequiredMaterial(module, record, "Template");
+	return {
+		kind: "SkillCapsule",
+		fqn: requiredFqn(record),
+		description: requiredDescription(record),
+		metadata: parse(metadata.content),
+		template,
+		resourceMappings: await readOptionalMaterial(module, record, "ResourceMappings"),
+		includes: nodeMembers(record.node.subdomains.Includes).filter((node) => node.tag === "Include").map((include) => ({
+			kind: requiredNodeProperty(include, "kind", record),
+			ref: requiredNodeProperty(include, "ref", record)
+		})),
+		source: sourceFor(module, record)
+	};
+}
+async function readOptionalMaterial(module, record, childName) {
+	const child = record.node.subdomains[childName];
+	if (!child) return void 0;
+	const href = optionalNodeProperty(child, "href");
+	if (!href) return void 0;
+	return readMaterial(module, record, href, optionalNodeProperty(child, "format"));
+}
+async function readRequiredMaterial(module, record, childName) {
+	const material = await readOptionalMaterial(module, record, childName);
+	if (!material) throw new Error(`${record.logicalPath} is missing required ${childName} material`);
+	return material;
+}
+async function readMaterial(module, record, href, format) {
+	const absolutePath = resolveMaterialHref(module, record, href);
+	return {
+		href,
+		format,
+		absolutePath,
+		content: await readFile(absolutePath, "utf8")
+	};
+}
+function requiredNodeCodeBinding(record) {
+	const moduleBinding = requiredNodeCodeModuleBinding(record);
+	const codeBinding = requiredNode(record, "CodeBinding");
+	return {
+		...moduleBinding,
+		exportName: requiredNodeProperty(codeBinding, "export", record)
+	};
+}
+function requiredNodeCodeModuleBinding(record) {
+	const codeBinding = requiredNode(record, "CodeBinding");
+	const packageName = requiredNodeProperty(codeBinding, "package", record);
+	const module = requiredNodeProperty(codeBinding, "module", record);
+	return {
+		packageName,
+		module,
+		moduleSpecifier: module.startsWith("./") ? `${packageName}/${module.slice(2)}` : module
+	};
+}
+function refsFromNodeContainer(value, childName) {
+	return nodeMembers(value).filter((node) => node.tag === childName).map((node) => optionalNodeProperty(node, "ref")).filter((ref) => Boolean(ref));
+}
+function resolveMaterialHref(module, record, href) {
+	const relativePrefix = href.startsWith("vfs://./") ? "vfs://./" : void 0;
+	const rootPrefix = href.startsWith("vfs://@/") ? "vfs://@/" : void 0;
+	const prefix = relativePrefix ?? rootPrefix;
+	if (!prefix) throw new Error(`Unsupported material href '${href}' in ${record.logicalPath}`);
+	const local = href.slice(prefix.length);
+	if (!local || local.includes("..") || local.includes("\\") || local.startsWith("/")) throw new Error(`Unsafe material href '${href}' in ${record.logicalPath}`);
+	const source = sourceFor(module, record);
+	const base = rootPrefix ? source.resourceRootDir : source.directory;
+	return join(base, local);
+}
+function sourceFor(module, record) {
+	const relative = record.logicalPath.replace(/^vfs:\/\/@\//, "");
+	return {
+		logicalPath: record.logicalPath,
+		directory: join(module.resourceRootDir, dirname(relative)),
+		moduleId: module.id,
+		packageName: module.packageName,
+		resourceRootDir: module.resourceRootDir
+	};
+}
+function assertUniqueModuleIds(modules) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const module of modules) {
+		if (!/^[A-Z][A-Za-z0-9]*$/.test(module.id)) throw new Error(`Authoring module id must be a PascalCase segment: ${module.id}`);
+		if (ids.has(module.id)) throw new Error(`Duplicate authoring module id: ${module.id}`);
+		ids.add(module.id);
+	}
+}
+function uniqueResourceMap(resources) {
+	const byFqn = /* @__PURE__ */ new Map();
+	for (const resource of resources) {
+		const prior = byFqn.get(resource.fqn);
+		if (prior) throw new Error(`Duplicate resource FQN ${resource.fqn} from ${prior.source.packageName}:${prior.source.logicalPath} and ${resource.source.packageName}:${resource.source.logicalPath}`);
+		byFqn.set(resource.fqn, resource);
+	}
+	return byFqn;
+}
+function assertObjectOperationAssemblyClosure(resources, byFqn) {
+	const owners = resources.filter(isObjectOperationOwner);
+	assertObjectOperationCatalog({
+		targetKinds: owners.flatMap((owner) => owner.targetKinds),
+		operations: owners.flatMap((owner) => owner.operations)
+	});
+	const boundResources = /* @__PURE__ */ new Set();
+	const compilations = /* @__PURE__ */ new Map();
+	for (const owner of owners) for (const definition of owner.operations) {
+		const binding = requireObjectOperationBinding(definition);
+		if (binding.kind === "export") {
+			compilations.set(definition.ref, { codeBinding: binding.codeBinding });
+			continue;
+		}
+		const resourceFqn = resourceRefToFqn(binding.resourceRef);
+		if (boundResources.has(resourceFqn)) throw new Error(`Object operation resource ${resourceFqn} is bound more than once`);
+		boundResources.add(resourceFqn);
+		const resource = byFqn.get(resourceFqn);
+		const expectedKind = definition.behavior === "action" ? "BusinessAction" : "BusinessMutation";
+		if (!resource) throw new Error(`Object operation ${definition.ref} binds unknown resource ${resourceFqn}`);
+		if (resource.kind !== expectedKind) throw new Error(`Object operation ${definition.ref} requires ${expectedKind}, received ${resource.kind}`);
+		const expectedOwnerRef = `resource://${definition.ownerKindFqn}`;
+		if (resource.ownerRef !== expectedOwnerRef) throw new Error(`Object operation ${definition.ref} binding owner does not match ${expectedOwnerRef}`);
+		compilations.set(definition.ref, {
+			codeBinding: resource.codeBinding,
+			...resource.kind === "BusinessAction" ? {
+				inputContractRef: resource.inputContractRef,
+				outputContractRef: resource.outputContractRef
+			} : {}
+		});
+	}
+	return compilations;
+}
+function isObjectOperationOwner(resource) {
+	return resource.kind === "PageObject" || resource.kind === "BusinessObject";
+}
+function resolvePortBindings(ports, bindings, resources) {
+	const portsByFqn = /* @__PURE__ */ new Map();
+	for (const port of ports) {
+		if (portsByFqn.has(port.fqn)) throw new Error(`Duplicate assembly port FQN: ${port.fqn}`);
+		portsByFqn.set(port.fqn, port);
+	}
+	const resolved = [];
+	const boundPorts = /* @__PURE__ */ new Set();
+	for (const binding of bindings) {
+		if (boundPorts.has(binding.portFqn)) throw new Error(`Assembly port is bound more than once: ${binding.portFqn}`);
+		const port = portsByFqn.get(binding.portFqn);
+		if (!port) throw new Error(`Unknown assembly port: ${binding.portFqn}`);
+		const resourceFqn = resourceRefToFqn(binding.resourceRef);
+		const resource = resources.get(resourceFqn);
+		if (!resource) throw new Error(`Assembly port ${binding.portFqn} targets unknown resource: ${resourceFqn}`);
+		if (resource.kind !== port.resourceKind) throw new Error(`Assembly port ${binding.portFqn} requires ${port.resourceKind}, received ${resource.kind}`);
+		if (port.contractRef && isContractedCallable(resource)) {
+			if (![resource.inputContractRef, resource.outputContractRef].includes(port.contractRef)) throw new Error(`Assembly port ${binding.portFqn} requires contract ${port.contractRef}`);
+		}
+		boundPorts.add(binding.portFqn);
+		resolved.push({
+			...binding,
+			port,
+			resource
+		});
+	}
+	for (const port of ports) if (!port.optional && !boundPorts.has(port.fqn)) throw new Error(`Required assembly port is not bound: ${port.fqn}`);
+	return resolved.sort((left, right) => left.portFqn.localeCompare(right.portFqn));
+}
+function isContractedCallable(resource) {
+	return resource.kind === "Function" || resource.kind === "ComposedFunction";
+}
+function requiredFqn(record) {
+	if (!record.fqn) throw new Error(`${record.logicalPath} is missing fqn`);
+	return record.fqn;
+}
+function requiredDescription(record) {
+	if (!record.description) throw new Error(`${record.logicalPath} ${record.kind} is missing description`);
+	return record.description;
+}
+function requiredNode(record, childName) {
+	const child = record.node.subdomains[childName];
+	if (!child) throw new Error(`${record.logicalPath} is missing ${childName}`);
+	return child;
+}
+function requiredNodeRef(record, childName) {
+	return requiredNodeProperty(requiredNode(record, childName), "ref", record);
+}
+function requiredRootProperty(record, name) {
+	const value = stringResourceValue(record.node.properties[name]);
+	if (!value) throw new Error(`${record.logicalPath} ${record.kind} is missing ${name}`);
+	return value;
+}
+function requiredNodeProperty(node, name, record) {
+	const value = optionalNodeProperty(node, name);
+	if (!value) throw new Error(`${record.logicalPath} ${node.tag} is missing ${name}`);
+	return value;
+}
+function optionalNodeProperty(node, name) {
+	return stringResourceValue(node.properties[name]);
+}
+function requiredNodeStringList(node, name, record) {
+	const value = node.properties[name];
+	if (!Array.isArray(value)) throw new Error(`${record.logicalPath} ${node.tag} is missing ${name}`);
+	const strings = value.map(stringResourceValue);
+	if (strings.some((item) => !item)) throw new Error(`${record.logicalPath} ${node.tag} ${name} must contain strings`);
+	return strings;
+}
+function nodeMembers(node) {
+	return (node?.body ?? []).filter(isResourceNode);
+}
+function isResourceNode(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "tag" in value;
+}
+function stringResourceValue(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function resourceRefToFqn(ref) {
+	if (!ref.startsWith("resource://")) throw new Error(`Unsupported resource reference '${ref}'`);
+	return ref.slice(11);
+}
+const applicationAssemblyPackage = {
+	role: "framework",
+	area: "application-assembly",
+	owns: "resource registry facts normalized for target-neutral compiler projections"
+};
+//#endregion
+export { assertObjectOperationCatalog as a, resolveApplicationAssembly as c, assertObjectOperationCall as i, resourceRefToFqn as l, applicationAssemblyPackage as n, assertObjectOperationDefinition as o, assertExecuteObjectOperationRequest as r, loadApplicationAssembly as s, ObjectOperationContractError as t, resolveObjectOperationCompilation as u };

package/dist/testing.d.ts

@@ -0,0 +1,30 @@
+import { n as AuthoringRuntime } from "./index-Dg0imcjf.js";
+//#region ../runtime-mock/src/index.d.ts
+interface MockEffectCall {
+  effectFqn: string;
+  input: unknown;
+}
+interface MockLogEntry {
+  level: "info" | "warn" | "error";
+  message: string;
+  fields?: Readonly<Record<string, unknown>>;
+}
+interface MockRuntime extends AuthoringRuntime {
+  readonly mock: {
+    readonly effectCalls: MockEffectCall[];
+    readonly logs: MockLogEntry[];
+  };
+}
+interface MockRuntimeOptions {
+  context?: Readonly<Record<string, unknown>>;
+  handlers?: Readonly<Record<string, (input: unknown) => unknown | Promise<unknown>>>;
+}
+declare function createMockRuntime(options?: MockRuntimeOptions): MockRuntime;
+declare function runWithMockRuntime<T>(runtime: MockRuntime, callback: () => T): T;
+declare const runtimeMockPackage: {
+  readonly role: "framework";
+  readonly area: "runtime-mock";
+  readonly owns: "inspectable target-neutral effect harness for deterministic authoring tests";
+};
+//#endregion
+export { MockEffectCall, MockLogEntry, MockRuntime, MockRuntimeOptions, createMockRuntime, runWithMockRuntime, runtimeMockPackage };