halfcode-compiler.xnl 0.2.0 → 0.2.2

package/dist/src-B36aAZZE.js

@@ -1,561 +0,0 @@
-import { l as resourceRefToFqn, u as resolveObjectOperationCompilation } from "./src-DJr-I4Kc.js";
-import { n as parseResourceMappings, r as planResourceMappings, t as applyResourceMappingPlan } from "./src-BlKlpg0J.js";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-//#region ../compiler-skill/src/index.ts
-async function compileSkillCapsule(input) {
-	validateSkillDescriptor(input.skill);
-	const references = input.references ?? [];
-	for (const reference of references) validateReferencePath(reference.path);
-	await rm(input.outputDir, {
-		recursive: true,
-		force: true
-	});
-	await mkdir(join(input.outputDir, "references"), { recursive: true });
-	const files = [];
-	const skillText = renderSkill(input.skill, input.registry, references);
-	await writeFile(join(input.outputDir, "SKILL.md"), skillText);
-	files.push("SKILL.md");
-	for (const reference of references) {
-		const target = join(input.outputDir, "references", reference.path);
-		await mkdir(dirname(target), { recursive: true });
-		await writeFile(target, reference.content);
-		files.push(`references/${reference.path}`);
-	}
-	return {
-		skillName: input.skill.name,
-		outputRoot: input.outputDir,
-		files
-	};
-}
-async function compileResourceSkillCapsule(input) {
-	const skill = input.assembly.skillCapsules.find((item) => item.fqn === input.skillFqn);
-	if (!skill) throw new Error(`SkillCapsule not found: ${input.skillFqn}`);
-	const schemas = schemaReader(input.schemas);
-	const selection = selectSkillResources(input.assembly, skill);
-	const mappings = parseResourceMappings(skill.resourceMappings?.content ?? "<ResourceMappings/>", skill.resourceMappings?.absolutePath ?? `${skill.source.logicalPath}#ResourceMappings`);
-	const callableResources = [...selection.functions, ...selection.composedFunctions];
-	assertCallableClosure(callableResources, schemas);
-	assertObjectOperationArtifactClosure(selection, schemas);
-	const generatedTargets = plannedGeneratedTargets(selection, callableResources, mappings);
-	assertNoGeneratedTargetCollisions(generatedTargets);
-	const resourceMappingPlan = await planResourceMappings(mappings, {
-		moduleRoots: new Map(input.assembly.modules.map((module) => [module.id, module.resourceRootDir])),
-		defaultSourceRoot: skill.source.directory,
-		reservedTargetPaths: generatedTargets
-	});
-	await rm(input.outputDir, {
-		recursive: true,
-		force: true
-	});
-	await mkdir(input.outputDir, { recursive: true });
-	const files = [];
-	const referenceFiles = await writeReferenceFiles(input.outputDir, selection, schemas, mappings);
-	files.push(...referenceFiles);
-	const callableFiles = await writeCallableArtifacts(input.outputDir, callableResources, schemas, mappings.callableArtifactsTarget);
-	files.push(...callableFiles);
-	files.push(...await writeObjectOperationArtifacts(input.outputDir, selection, schemas));
-	files.push(...await applyResourceMappingPlan(resourceMappingPlan, input.outputDir));
-	const skillName = stringField(skill.metadata, "name") ?? lastFqnSegment(skill.fqn);
-	const skillText = renderEjsTemplate(skill.template.content, {
-		skill,
-		metadata: skill.metadata,
-		references: referenceModel(selection, mappings),
-		renderPromptFragment: (fqn) => {
-			return selection.promptFragments.find((item) => item.fqn === fqn)?.instruction?.content.trim() ?? "";
-		}
-	});
-	await writeFile(join(input.outputDir, "SKILL.md"), skillText.trimEnd() + "\n");
-	files.push("SKILL.md");
-	return {
-		skillName,
-		outputRoot: input.outputDir,
-		files: files.sort()
-	};
-}
-function renderSkill(skill, registry, references) {
-	const lines = [
-		"---",
-		`name: ${skill.name}`,
-		`description: ${skill.description}`,
-		"---",
-		"",
-		`# ${skill.name}`,
-		"",
-		skill.description,
-		""
-	];
-	if (skill.instructions?.trim()) lines.push("## Instructions", "", skill.instructions.trim(), "");
-	if (registry) {
-		lines.push("## Resources", "");
-		for (const [kind, records] of [...registry.byKind.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-			lines.push(`### ${kind}`, "");
-			for (const record of [...records].sort((a, b) => (a.fqn ?? a.name ?? "").localeCompare(b.fqn ?? b.name ?? ""))) lines.push(`- ${record.fqn ?? record.name}: ${record.description}`);
-			lines.push("");
-		}
-	}
-	if (references.length > 0) {
-		lines.push("## References", "");
-		for (const reference of references) lines.push(`- references/${reference.path}`);
-		lines.push("");
-	}
-	return `${lines.join("\n").trimEnd()}\n`;
-}
-function validateSkillDescriptor(skill) {
-	if (!skill.name.trim()) throw new Error("Skill name is required");
-	if (!skill.description.trim()) throw new Error("Skill description is required");
-}
-function validateReferencePath(path) {
-	if (path.startsWith("/") || path.includes("\\") || path.split("/").includes("..") || path.trim() !== path || path.length === 0) throw new Error(`Invalid Skill reference path: ${path}`);
-}
-function selectSkillResources(assembly, skill) {
-	const includes = skill.includes.length > 0 ? skill.includes : [
-		...assembly.functions.map((item) => ({
-			kind: item.kind,
-			ref: `resource://${item.fqn}`
-		})),
-		...assembly.composedFunctions.map((item) => ({
-			kind: item.kind,
-			ref: `resource://${item.fqn}`
-		})),
-		...assembly.businessObjects.map((item) => ({
-			kind: item.kind,
-			ref: `resource://${item.fqn}`
-		})),
-		...assembly.pageObjects.map((item) => ({
-			kind: item.kind,
-			ref: `resource://${item.fqn}`
-		})),
-		...assembly.applicationSops.map((item) => ({
-			kind: item.kind,
-			ref: `resource://${item.fqn}`
-		})),
-		...assembly.promptFragments.map((item) => ({
-			kind: item.kind,
-			ref: `resource://${item.fqn}`
-		})),
-		...assembly.wikiPages.map((item) => ({
-			kind: item.kind,
-			ref: `resource://${item.fqn}`
-		}))
-	];
-	const fqnSet = new Set(includes.map((include) => resourceRefToFqn(include.ref)));
-	const businessObjects = assembly.businessObjects.filter((item) => fqnSet.has(item.fqn));
-	const pageObjects = assembly.pageObjects.filter((item) => fqnSet.has(item.fqn));
-	const businessSopRefs = new Set(businessObjects.flatMap((item) => item.sopRefs).map(resourceRefToFqn));
-	return {
-		assembly,
-		functions: assembly.functions.filter((item) => fqnSet.has(item.fqn)),
-		composedFunctions: assembly.composedFunctions.filter((item) => fqnSet.has(item.fqn)),
-		businessObjects,
-		pageObjects,
-		businessObjectSops: assembly.businessObjectSops.filter((item) => businessSopRefs.has(item.fqn)),
-		applicationSops: assembly.applicationSops.filter((item) => fqnSet.has(item.fqn)),
-		promptFragments: assembly.promptFragments.filter((item) => fqnSet.has(item.fqn)),
-		wikiPages: assembly.wikiPages.filter((item) => fqnSet.has(item.fqn))
-	};
-}
-async function writeReferenceFiles(outputDir, selection, schemas, mappings) {
-	const files = [];
-	for (const item of selection.composedFunctions) files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), callableReferenceMarkdown(item, schemas)));
-	for (const item of selection.functions) files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), callableReferenceMarkdown(item, schemas)));
-	for (const item of selection.businessObjects) {
-		const sops = selection.businessObjectSops.filter((sop) => item.sopRefs.map(resourceRefToFqn).includes(sop.fqn));
-		files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), businessObjectMarkdown(item, sops, (kind, fqn) => mappedResourcePath(mappings, kind, fqn))));
-	}
-	for (const item of selection.pageObjects) files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), objectOwnerMarkdown(item)));
-	for (const item of selection.businessObjectSops) files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), textReferenceMarkdown(item)));
-	for (const item of selection.applicationSops) files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), textReferenceMarkdown(item)));
-	for (const item of selection.promptFragments) files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), textReferenceMarkdown(item)));
-	for (const item of selection.wikiPages) files.push(await writeReference(outputDir, mappedResourcePath(mappings, item.kind, item.fqn), textReferenceMarkdown(item)));
-	return files;
-}
-function objectOwnerMarkdown(resource) {
-	return [
-		`# ${lastFqnSegment(resource.fqn)}`,
-		"",
-		`<fqn>${resource.fqn}</fqn>`,
-		`<kind>${resource.kind}</kind>`,
-		`<description>${resource.description}</description>`,
-		"",
-		"<available_operations>",
-		...resource.operations.map((operation) => `- ${operation.ref}: ${operation.behavior}, targets=${operation.targets.kind}, modes=${operation.invocationModes.join(",")}`),
-		"</available_operations>",
-		"",
-		"<usage>",
-		"Call `run_object_operation({ targets, invocation, config })`; action invocation uses input and mutation invocation uses desired.",
-		"</usage>",
-		""
-	].join("\n");
-}
-async function writeReference(outputDir, path, content) {
-	validateReferencePath(path);
-	const target = join(outputDir, path);
-	await mkdir(dirname(target), { recursive: true });
-	await writeFile(target, content.trimEnd() + "\n");
-	return path;
-}
-function callableReferenceMarkdown(resource, schemas) {
-	return [
-		`# ${lastFqnSegment(resource.fqn)}`,
-		"",
-		`<fqn>${resource.fqn}</fqn>`,
-		`<kind>${resource.kind}</kind>`,
-		`<description>${resource.description}</description>`,
-		"",
-		"<usage>",
-		`Call \`run_callable_resource(${JSON.stringify(resource.fqn)}, input, config)\` with an input object matching <input_schema>. The host supplies runtime separately; omit config when the capability does not need it.`,
-		"</usage>",
-		"",
-		"<input_schema>",
-		"```json",
-		JSON.stringify(schemas(resource.inputContractRef), null, 2),
-		"```",
-		"</input_schema>",
-		"",
-		"<output_schema>",
-		"```json",
-		JSON.stringify(schemas(resource.outputContractRef), null, 2),
-		"```",
-		"</output_schema>",
-		"",
-		"<instruction>",
-		resource.instruction?.content.trim() ?? "",
-		"</instruction>",
-		""
-	].join("\n");
-}
-function businessObjectMarkdown(resource, sops, mappedPath) {
-	return [
-		`# ${lastFqnSegment(resource.fqn)}`,
-		"",
-		`<fqn>${resource.fqn}</fqn>`,
-		`<kind>${resource.kind}</kind>`,
-		`<description>${resource.description}</description>`,
-		"",
-		"<available_operations>",
-		...resource.operations.map((operation) => `- ${operation.ref}: ${operation.behavior}, targets=${operation.targets.kind}, modes=${operation.invocationModes.join(",")}`),
-		"</available_operations>",
-		"",
-		"<available_sops>",
-		...sops.map((item) => `- ${item.fqn}: ${mappedPath(item.kind, item.fqn)}`),
-		"</available_sops>",
-		"",
-		"<usage>",
-		"Call `run_object_operation({ targets, invocation, config })`; action invocation uses input and mutation invocation uses desired.",
-		"</usage>",
-		"",
-		"<instruction>",
-		resource.instruction?.content.trim() ?? "",
-		"</instruction>",
-		""
-	].join("\n");
-}
-function textReferenceMarkdown(resource) {
-	return [
-		`# ${lastFqnSegment(resource.fqn)}`,
-		"",
-		`<fqn>${resource.fqn}</fqn>`,
-		`<kind>${resource.kind}</kind>`,
-		`<description>${resource.description}</description>`,
-		"",
-		resource.instruction?.content.trim() ?? "",
-		""
-	].join("\n");
-}
-async function writeCallableArtifacts(outputDir, resources, schemas, targetBase) {
-	const files = [];
-	const imports = [];
-	const entries = [];
-	for (const resource of resources) {
-		const filePath = `${`${resource.kind}s`}/${lastFqnSegment(resource.fqn)}.js`;
-		const target = join(outputDir, targetBase, filePath);
-		const symbol = safeJsIdentifier(resource.fqn);
-		await mkdir(dirname(target), { recursive: true });
-		await writeFile(target, [
-			`import { ${resource.codeBinding.exportName} as entry } from ${JSON.stringify(resource.codeBinding.moduleSpecifier)}`,
-			"",
-			"export default entry",
-			""
-		].join("\n"));
-		files.push(`${targetBase}${filePath}`);
-		imports.push(`import ${symbol} from ${JSON.stringify(`./${filePath}`)}`);
-		entries.push(JSON.stringify(resource.fqn) + `: { kind: ${JSON.stringify(resource.kind)}, handler: ${symbol} }`);
-	}
-	const registry = resources.map((resource) => ({
-		fqn: resource.fqn,
-		kind: resource.kind,
-		description: resource.description,
-		inputContractRef: resource.inputContractRef,
-		outputContractRef: resource.outputContractRef,
-		inputSchema: schemas(resource.inputContractRef),
-		outputSchema: schemas(resource.outputContractRef),
-		module: `./${resource.kind}s/${lastFqnSegment(resource.fqn)}.js`
-	}));
-	await mkdir(join(outputDir, targetBase), { recursive: true });
-	await writeFile(join(outputDir, targetBase, "registry.json"), `${JSON.stringify({ callableResources: registry }, null, 2)}\n`);
-	files.push(`${targetBase}registry.json`);
-	await writeFile(join(outputDir, targetBase, "bundle.js"), [
-		"import { runWithRuntime } from \"halfcode-compiler.xnl/authoring-runtime\"",
-		...imports,
-		"",
-		`const registry = { ${entries.join(", ")} }`,
-		"let callableRuntime",
-		"",
-		"/**",
-		" * Host-only initialization boundary. Bind runtime capabilities before exposing",
-		" * run_callable_resource to AI-authored code; runtime is never an AI argument.",
-		" */",
-		"export function initialize_callable_runtime(runtime) {",
-		"  if (!runtime) throw new Error(\"Callable runtime is required\")",
-		"  callableRuntime = runtime",
-		"}",
-		"",
-		"/**",
-		" * AI-facing callable entry. Callers provide only the resource identity, business",
-		" * input, and optional invocation config; the host-owned runtime stays hidden.",
-		" */",
-		"export async function run_callable_resource(fqn, input, config) {",
-		"  if (!callableRuntime) throw new Error(\"Callable runtime has not been initialized\")",
-		"  return invokeCallableResource(callableRuntime, fqn, input, config)",
-		"}",
-		"",
-		"/**",
-		" * Framework-internal bridge. It activates the host runtime context and forwards",
-		" * input/config unchanged to the deterministic resource handler.",
-		" */",
-		"async function invokeCallableResource(runtime, fqn, input, config) {",
-		"  const entry = registry[fqn]",
-		"  if (!entry) throw new Error(`Unknown callable resource: ${fqn}`)",
-		"  return runWithRuntime(runtime, () => entry.handler(input, config))",
-		"}",
-		"",
-		"export function resolve_callable_resource(fqn) {",
-		"  const entry = registry[fqn]",
-		"  if (!entry) throw new Error(`Unknown callable resource: ${fqn}`)",
-		"  return { fqn, kind: entry.kind }",
-		"}",
-		""
-	].join("\n"));
-	files.push(`${targetBase}bundle.js`);
-	return files;
-}
-async function writeObjectOperationArtifacts(outputDir, selection, schemas) {
-	const targetBase = "objects/";
-	const owners = [...selection.businessObjects, ...selection.pageObjects];
-	const operations = owners.flatMap((owner) => owner.operations).sort((left, right) => left.ref.localeCompare(right.ref));
-	const targetKinds = owners.flatMap((owner) => owner.targetKinds).sort((left, right) => left.kindFqn.localeCompare(right.kindFqn));
-	const files = [];
-	const imports = [];
-	const entries = [];
-	for (const definition of operations) {
-		const binding = resolveObjectOperationCompilation(selection.assembly, definition.ref);
-		const filePath = `handlers/${`${safeJsIdentifier(definition.ref)}.js`}`;
-		const target = join(outputDir, targetBase, filePath);
-		const symbol = safeJsIdentifier(definition.ref);
-		await mkdir(dirname(target), { recursive: true });
-		await writeFile(target, [
-			`import { ${binding.codeBinding.exportName} as entry } from ${JSON.stringify(binding.codeBinding.moduleSpecifier)}`,
-			"",
-			"export default entry",
-			""
-		].join("\n"));
-		files.push(`${targetBase}${filePath}`);
-		imports.push(`import ${symbol} from ${JSON.stringify(`./${filePath}`)}`);
-		entries.push(`${JSON.stringify(definition.ref)}: ${symbol}`);
-	}
-	await mkdir(join(outputDir, targetBase), { recursive: true });
-	const registry = {
-		targetKinds,
-		operations: operations.map((definition) => ({
-			...definition,
-			...objectOperationContractProjection(selection.assembly, definition, schemas)
-		}))
-	};
-	await writeFile(join(outputDir, targetBase, "registry.json"), `${JSON.stringify(registry, null, 2)}\n`);
-	files.push(`${targetBase}registry.json`);
-	await writeFile(join(outputDir, targetBase, "bundle.js"), [
-		"import { assertObjectOperationCall } from \"halfcode-compiler.xnl\"",
-		"import { runWithRuntime } from \"halfcode-compiler.xnl/authoring-runtime\"",
-		"import catalog from \"./registry.json\" with { type: \"json\" }",
-		...imports,
-		"",
-		`const handlers = { ${entries.join(", ")} }`,
-		"const definitions = Object.fromEntries(catalog.operations.map((definition) => [definition.ref, definition]))",
-		"let objectOperationRuntime",
-		"",
-		"/** Host-only runtime initialization; runtime is never an AI argument. */",
-		"export function initialize_object_operation_runtime(runtime) {",
-		"  if (!runtime) throw new Error(\"Object operation runtime is required\")",
-		"  objectOperationRuntime = runtime",
-		"}",
-		"",
-		"/** AI-facing object entry with orthogonal targets, invocation and config. */",
-		"export async function run_object_operation(call) {",
-		"  if (!objectOperationRuntime) throw new Error(\"Object operation runtime has not been initialized\")",
-		"  const operationRef = call?.invocation?.operationRef",
-		"  const definition = definitions[operationRef]",
-		"  if (!definition) throw new Error(`Unknown object operation: ${operationRef}`)",
-		"  const handler = handlers[operationRef]",
-		"  if (!handler) throw new Error(`Object operation handler is unavailable: ${operationRef}`)",
-		"  assertObjectOperationCall(call, definition)",
-		"  return runWithRuntime(objectOperationRuntime, () =>",
-		"    handler(objectOperationRuntime, call.targets, call.invocation, call.config)",
-		"  )",
-		"}",
-		"",
-		"export function resolve_object_operation(operationRef) {",
-		"  const definition = definitions[operationRef]",
-		"  if (!definition) throw new Error(`Unknown object operation: ${operationRef}`)",
-		"  return definition",
-		"}",
-		""
-	].join("\n"));
-	files.push(`${targetBase}bundle.js`);
-	return files;
-}
-function objectOperationContractProjection(assembly, definition, schemas) {
-	const compilation = resolveObjectOperationCompilation(assembly, definition.ref);
-	if (!compilation.inputContractRef || !compilation.outputContractRef) return {};
-	return {
-		inputContractRef: compilation.inputContractRef,
-		outputContractRef: compilation.outputContractRef,
-		inputSchema: schemas(compilation.inputContractRef),
-		outputSchema: schemas(compilation.outputContractRef)
-	};
-}
-function referenceModel(selection, mappings) {
-	const ref = (kind, item) => ({
-		fqn: item.fqn,
-		description: item.description,
-		path: mappedResourcePath(mappings, kind, item.fqn)
-	});
-	return {
-		composedFunctions: selection.composedFunctions.map((item) => ref(item.kind, item)),
-		functions: selection.functions.map((item) => ref(item.kind, item)),
-		businessObjects: selection.businessObjects.map((item) => ({
-			fqn: item.fqn,
-			description: item.description,
-			path: mappedResourcePath(mappings, item.kind, item.fqn)
-		})),
-		pageObjects: selection.pageObjects.map((item) => ref(item.kind, item)),
-		applicationSops: selection.applicationSops.map((item) => ref(item.kind, item)),
-		promptFragments: selection.promptFragments.map((item) => ref(item.kind, item)),
-		wikiPages: selection.wikiPages.map((item) => ref(item.kind, item)),
-		callableArtifacts: {
-			registryPath: `${mappings.callableArtifactsTarget}registry.json`,
-			bundlePath: `${mappings.callableArtifactsTarget}bundle.js`
-		},
-		objectArtifacts: {
-			registryPath: "objects/registry.json",
-			bundlePath: "objects/bundle.js"
-		}
-	};
-}
-function mappedResourcePath(mappings, kind, fqn) {
-	return `${mappings.referenceTargets.get(kind) ?? defaultReferenceTarget(kind)}${kind === "BusinessObject" ? `${lastFqnSegment(fqn)}/BUSINESS_OBJECT.md` : kind === "PageObject" ? `${lastFqnSegment(fqn)}/PAGE_OBJECT.md` : `${lastFqnSegment(fqn)}.md`}`;
-}
-function defaultReferenceTarget(kind) {
-	return {
-		Function: "references/Functions/",
-		ComposedFunction: "references/ComposedFunctions/",
-		BusinessObject: "references/BusinessObjects/",
-		PageObject: "references/PageObjects/",
-		BusinessObjectSOP: "references/BusinessObjectSOPs/",
-		ApplicationSOP: "references/ApplicationSOPs/",
-		PromptFragment: "references/PromptFragments/",
-		WikiPage: "references/Wiki/"
-	}[kind] ?? `references/${kind}/`;
-}
-function schemaReader(schemas) {
-	return (ref) => {
-		const fqn = resourceRefToFqn(ref);
-		if (!schemas) return void 0;
-		if (typeof schemas.get === "function") return schemas.get(fqn);
-		return schemas[fqn];
-	};
-}
-function renderEjsTemplate(template, context) {
-	let cursor = 0;
-	let code = "let __out = '';\nconst __append = (value) => { __out += value == null ? '' : String(value) };\nwith (ctx) {\n";
-	for (const match of template.matchAll(/<%([=-]?)([\s\S]*?)%>/g)) {
-		code += `__append(${JSON.stringify(template.slice(cursor, match.index))});\n`;
-		const [, mode, body] = match;
-		if (mode === "=" || mode === "-") code += `__append(${body.trim()});\n`;
-		else code += `${body}\n`;
-		cursor = (match.index ?? 0) + match[0].length;
-	}
-	code += `__append(${JSON.stringify(template.slice(cursor))});\n`;
-	code += "}\nreturn __out";
-	return new Function("ctx", code)(context);
-}
-function stringField(source, name) {
-	const value = source[name];
-	return typeof value === "string" && value.trim() ? value : void 0;
-}
-function lastFqnSegment(fqn) {
-	return fqn.split(".").at(-1) ?? fqn;
-}
-function safeJsIdentifier(fqn) {
-	return fqn.replace(/[^A-Za-z0-9_$]/g, "_");
-}
-function plannedGeneratedTargets(selection, callableResources, mappings) {
-	return [
-		"SKILL.md",
-		...[
-			...selection.functions,
-			...selection.composedFunctions,
-			...selection.businessObjects,
-			...selection.pageObjects,
-			...selection.businessObjectSops,
-			...selection.applicationSops,
-			...selection.promptFragments,
-			...selection.wikiPages
-		].map((item) => mappedResourcePath(mappings, item.kind, item.fqn)),
-		...callableResources.map((resource) => {
-			return `${mappings.callableArtifactsTarget}${resource.kind}s/${lastFqnSegment(resource.fqn)}.js`;
-		}),
-		`${mappings.callableArtifactsTarget}registry.json`,
-		`${mappings.callableArtifactsTarget}bundle.js`,
-		...[...selection.businessObjects, ...selection.pageObjects].flatMap((owner) => owner.operations).map((operation) => `objects/handlers/${safeJsIdentifier(operation.ref)}.js`),
-		"objects/registry.json",
-		"objects/bundle.js"
-	];
-}
-function assertNoGeneratedTargetCollisions(paths) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const path of paths) {
-		validateReferencePath(path);
-		if (seen.has(path)) throw new Error(`Generated Skill target collision: ${path}`);
-		seen.add(path);
-	}
-}
-function assertCallableClosure(resources, schemas) {
-	const fqns = /* @__PURE__ */ new Set();
-	for (const resource of resources) {
-		if (fqns.has(resource.fqn)) throw new Error(`Callable resource FQN appears more than once: ${resource.fqn}`);
-		fqns.add(resource.fqn);
-		if (schemas(resource.inputContractRef) === void 0) throw new Error(`Callable resource ${resource.fqn} is missing input schema ${resource.inputContractRef}`);
-		if (schemas(resource.outputContractRef) === void 0) throw new Error(`Callable resource ${resource.fqn} is missing output schema ${resource.outputContractRef}`);
-		if (!resource.codeBinding.moduleSpecifier || !resource.codeBinding.exportName) throw new Error(`Callable resource ${resource.fqn} is missing an executable code binding`);
-	}
-}
-function assertObjectOperationArtifactClosure(selection, schemas) {
-	const operationRefs = /* @__PURE__ */ new Set();
-	for (const owner of [...selection.businessObjects, ...selection.pageObjects]) for (const definition of owner.operations) {
-		if (operationRefs.has(definition.ref)) throw new Error(`Object operation ref appears more than once: ${definition.ref}`);
-		operationRefs.add(definition.ref);
-		const binding = resolveObjectOperationCompilation(selection.assembly, definition.ref);
-		if (!binding.codeBinding.moduleSpecifier || !binding.codeBinding.exportName) throw new Error(`Object operation ${definition.ref} is missing an executable code binding`);
-		if (!binding.inputContractRef || !binding.outputContractRef) continue;
-		if (schemas(binding.inputContractRef) === void 0) throw new Error(`Object operation ${definition.ref} is missing input schema ${binding.inputContractRef}`);
-		if (schemas(binding.outputContractRef) === void 0) throw new Error(`Object operation ${definition.ref} is missing output schema ${binding.outputContractRef}`);
-	}
-}
-const compilerSkillPackage = {
-	role: "framework",
-	area: "compiler-skill",
-	owns: "standard Skill capsule projection"
-};
-//#endregion
-export { compileSkillCapsule as n, compilerSkillPackage as r, compileResourceSkillCapsule as t };