halfcode-compiler.xnl 0.1.1

package/dist/index-FdimP_SL.d.ts

@@ -0,0 +1,236 @@
+//#region ../application-assembly/src/index.d.ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+type ObjectOperationOwnerKind = "PageObject" | "BusinessObject";
+type ObjectOperationBehavior = "action" | "mutation";
+type ObjectInvocationMode = "single" | "batch";
+type ObjectOperationEffect = "read-only" | "write" | "mixed";
+interface ObjectTargetRef {
+  readonly kindFqn: string;
+  readonly key: JsonObject;
+}
+type ObjectTargets = {
+  readonly kind: "none";
+} | {
+  readonly kind: "single";
+  readonly ref: ObjectTargetRef;
+} | {
+  readonly kind: "selection";
+  readonly kindFqn: string;
+  readonly selector: {
+    readonly kind: "all";
+  } | {
+    readonly kind: "filter";
+    readonly where: JsonObject;
+  } | {
+    readonly kind: "refs";
+    readonly refs: readonly ObjectTargetRef[];
+  };
+};
+type ObjectOperationTargetDeclaration = {
+  readonly kind: "none";
+} | {
+  readonly kind: "single";
+  readonly kindFqn: string;
+} | {
+  readonly kind: "selection";
+  readonly kindFqn: string;
+};
+interface ObjectOperationDefinition {
+  readonly ref: string;
+  readonly id: string;
+  readonly ownerKindFqn: string;
+  readonly ownerResourceKind: ObjectOperationOwnerKind;
+  readonly behavior: ObjectOperationBehavior;
+  readonly targets: ObjectOperationTargetDeclaration;
+  readonly invocationModes: readonly ObjectInvocationMode[];
+  readonly effect: ObjectOperationEffect;
+}
+interface ObjectTargetKindDefinition {
+  readonly kindFqn: string;
+  readonly ownerKindFqn: string;
+  readonly role: "object" | "nested-subject";
+}
+interface ObjectOperationCatalog {
+  readonly targetKinds: readonly ObjectTargetKindDefinition[];
+  readonly operations: readonly ObjectOperationDefinition[];
+}
+type ObjectInvocation = {
+  readonly kind: "action";
+  readonly operationRef: string;
+  readonly input?: JsonValue;
+} | {
+  readonly kind: "mutation";
+  readonly operationRef: string;
+  readonly desired: JsonValue;
+};
+type ObjectOperationConfig = JsonObject;
+interface ObjectOperationCall {
+  readonly targets: ObjectTargets;
+  readonly invocation: ObjectInvocation;
+  readonly config?: ObjectOperationConfig;
+}
+type ExecuteObjectOperationRequest = {
+  readonly mode: "single";
+  readonly call: ObjectOperationCall;
+} | {
+  readonly mode: "batch";
+  readonly items: readonly {
+    readonly key: string;
+    readonly call: ObjectOperationCall;
+  }[];
+  readonly config: {
+    readonly atomicity: "atomic" | "best-effort";
+  };
+};
+type ObjectOperationHandler<TRuntime = unknown, TResult = unknown> = (runtime: TRuntime, targets: ObjectTargets, invocation: ObjectInvocation, config: ObjectOperationConfig | undefined) => TResult | Promise<TResult>;
+declare class ObjectOperationContractError extends TypeError {
+  readonly code: string;
+  readonly path?: string | undefined;
+  constructor(code: string, message: string, path?: string | undefined);
+}
+declare function assertObjectOperationCatalog(catalog: ObjectOperationCatalog): void;
+declare function assertObjectOperationDefinition(definition: ObjectOperationDefinition): void;
+declare function assertObjectOperationCall(call: ObjectOperationCall, definition: ObjectOperationDefinition, mode?: ObjectInvocationMode): void;
+declare function assertExecuteObjectOperationRequest(request: ExecuteObjectOperationRequest, resolveDefinition: (operationRef: string) => ObjectOperationDefinition | undefined): void;
+interface LoadApplicationAssemblyOptions {
+  resourceRootDir: string;
+  manifestPath?: string;
+  packageName?: string;
+}
+type ApplicationScope = "shared" | "domain";
+interface AuthoringModuleDescriptor {
+  id: string;
+  packageName: string;
+  family: string;
+  scope: ApplicationScope;
+  resourceRootDir: string;
+  manifestPath?: string;
+  ports?: readonly AssemblyPort[];
+}
+interface AssemblyPort {
+  fqn: string;
+  description: string;
+  resourceKind: AssemblyResource["kind"];
+  contractRef?: string;
+  optional?: boolean;
+}
+interface AssemblyPortBinding {
+  portFqn: string;
+  resourceRef: string;
+}
+interface ResolveApplicationAssemblyOptions {
+  modules: readonly AuthoringModuleDescriptor[];
+  portBindings?: readonly AssemblyPortBinding[];
+}
+interface ResolvedAssemblyPortBinding extends AssemblyPortBinding {
+  port: AssemblyPort;
+  resource: AssemblyResource;
+}
+interface ContractedCallableResource {
+  kind: "Function" | "ComposedFunction";
+  fqn: string;
+  description: string;
+  instruction?: TextMaterial;
+  inputContractRef: string;
+  outputContractRef: string;
+  codeBinding: CodeBinding;
+  mutationRefs: readonly string[];
+  source: ResourceSource;
+}
+interface BusinessObjectResource {
+  kind: "BusinessObject";
+  fqn: string;
+  description: string;
+  instruction?: TextMaterial;
+  sopRefs: readonly string[];
+  relatedRefs: readonly string[];
+  targetKinds: readonly ObjectTargetKindDefinition[];
+  operations: readonly ObjectOperationDefinition[];
+  source: ResourceSource;
+}
+interface BusinessObjectSopResource {
+  kind: "BusinessObjectSOP";
+  fqn: string;
+  description: string;
+  instruction?: TextMaterial;
+  source: ResourceSource;
+}
+interface TextResource {
+  kind: "ApplicationSOP" | "PromptFragment" | "WikiPage";
+  fqn: string;
+  description: string;
+  instruction?: TextMaterial;
+  source: ResourceSource;
+}
+interface SkillCapsuleResource {
+  kind: "SkillCapsule";
+  fqn: string;
+  description: string;
+  metadata: Record<string, unknown>;
+  template: TextMaterial;
+  resourceMappings?: TextMaterial;
+  includes: readonly ResourceInclude[];
+  source: ResourceSource;
+}
+interface PageObjectResource {
+  kind: "PageObject";
+  fqn: string;
+  id: string;
+  description: string;
+  targetKinds: readonly ObjectTargetKindDefinition[];
+  operations: readonly ObjectOperationDefinition[];
+  source: ResourceSource;
+}
+interface TextMaterial {
+  href: string;
+  format?: string;
+  absolutePath: string;
+  content: string;
+}
+interface CodeBinding {
+  packageName: string;
+  module: string;
+  exportName: string;
+  moduleSpecifier: string;
+}
+interface ResourceInclude {
+  kind: string;
+  ref: string;
+}
+interface ResourceSource {
+  logicalPath: string;
+  directory: string;
+  moduleId: string;
+  packageName: string;
+  resourceRootDir: string;
+}
+interface ApplicationAssembly {
+  rootDir: string;
+  modules: readonly AuthoringModuleDescriptor[];
+  portBindings: readonly ResolvedAssemblyPortBinding[];
+  functions: readonly ContractedCallableResource[];
+  composedFunctions: readonly ContractedCallableResource[];
+  businessObjects: readonly BusinessObjectResource[];
+  businessObjectSops: readonly BusinessObjectSopResource[];
+  applicationSops: readonly TextResource[];
+  promptFragments: readonly TextResource[];
+  wikiPages: readonly TextResource[];
+  skillCapsules: readonly SkillCapsuleResource[];
+  pageObjects: readonly PageObjectResource[];
+  byFqn: ReadonlyMap<string, AssemblyResource>;
+}
+type AssemblyResource = ContractedCallableResource | BusinessObjectResource | BusinessObjectSopResource | TextResource | SkillCapsuleResource | PageObjectResource;
+declare function loadApplicationAssembly(options: LoadApplicationAssemblyOptions): Promise<ApplicationAssembly>;
+declare function resolveApplicationAssembly(options: ResolveApplicationAssemblyOptions): Promise<ApplicationAssembly>;
+declare function resourceRefToFqn(ref: string): string;
+declare const applicationAssemblyPackage: {
+  readonly role: "framework";
+  readonly area: "application-assembly";
+  readonly owns: "resource registry facts normalized for target-neutral compiler projections";
+};
+//#endregion
+export { ObjectTargets as A, assertExecuteObjectOperationRequest as B, ObjectOperationDefinition as C, ObjectOperationTargetDeclaration as D, ObjectOperationOwnerKind as E, ResourceSource as F, resolveApplicationAssembly as G, assertObjectOperationCatalog as H, SkillCapsuleResource as I, resourceRefToFqn as K, TextMaterial as L, ResolveApplicationAssemblyOptions as M, ResolvedAssemblyPortBinding as N, ObjectTargetKindDefinition as O, ResourceInclude as P, TextResource as R, ObjectOperationContractError as S, ObjectOperationHandler as T, assertObjectOperationDefinition as U, assertObjectOperationCall as V, loadApplicationAssembly as W, ObjectInvocationMode as _, AssemblyResource as a, ObjectOperationCatalog as b, BusinessObjectSopResource as c, ExecuteObjectOperationRequest as d, JsonObject as f, ObjectInvocation as g, LoadApplicationAssemblyOptions as h, AssemblyPortBinding as i, PageObjectResource as j, ObjectTargetRef as k, CodeBinding as l, JsonValue as m, ApplicationScope as n, AuthoringModuleDescriptor as o, JsonPrimitive as p, AssemblyPort as r, BusinessObjectResource as s, ApplicationAssembly as t, ContractedCallableResource as u, ObjectOperationBehavior as v, ObjectOperationEffect as w, ObjectOperationConfig as x, ObjectOperationCall as y, applicationAssemblyPackage as z };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { A as ObjectTargets, B as assertExecuteObjectOperationRequest, C as ObjectOperationDefinition, D as ObjectOperationTargetDeclaration, E as ObjectOperationOwnerKind, F as ResourceSource, G as resolveApplicationAssembly, H as assertObjectOperationCatalog, I as SkillCapsuleResource, K as resourceRefToFqn, L as TextMaterial, M as ResolveApplicationAssemblyOptions, N as ResolvedAssemblyPortBinding, O as ObjectTargetKindDefinition, P as ResourceInclude, R as TextResource, S as ObjectOperationContractError, T as ObjectOperationHandler, U as assertObjectOperationDefinition, V as assertObjectOperationCall, W as loadApplicationAssembly, _ as ObjectInvocationMode, a as AssemblyResource, b as ObjectOperationCatalog, c as BusinessObjectSopResource, d as ExecuteObjectOperationRequest, f as JsonObject, g as ObjectInvocation, h as LoadApplicationAssemblyOptions, i as AssemblyPortBinding, j as PageObjectResource, k as ObjectTargetRef, l as CodeBinding, m as JsonValue, n as ApplicationScope, o as AuthoringModuleDescriptor, p as JsonPrimitive, r as AssemblyPort, s as BusinessObjectResource, t as ApplicationAssembly, u as ContractedCallableResource, v as ObjectOperationBehavior, w as ObjectOperationEffect, x as ObjectOperationConfig, y as ObjectOperationCall, z as applicationAssemblyPackage } from "./index-FdimP_SL.js";
+import { a as SkillReference, c as compilerSkillPackage, i as SkillDescriptor, n as CompileSkillCapsuleInput, o as compileResourceSkillCapsule, r as SkillCapsulePlan, s as compileSkillCapsule, t as CompileResourceSkillCapsuleInput } from "./index-D-cBhQVw.js";
+export { type ApplicationAssembly, type ApplicationScope, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, type AuthoringModuleDescriptor, type BusinessObjectResource, type BusinessObjectSopResource, type CodeBinding, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, type ContractedCallableResource, type ExecuteObjectOperationRequest, type JsonObject, type JsonPrimitive, type JsonValue, type LoadApplicationAssemblyOptions, type ObjectInvocation, type ObjectInvocationMode, type ObjectOperationBehavior, type ObjectOperationCall, type ObjectOperationCatalog, type ObjectOperationConfig, ObjectOperationContractError, type ObjectOperationDefinition, type ObjectOperationEffect, type ObjectOperationHandler, type ObjectOperationOwnerKind, type ObjectOperationTargetDeclaration, type ObjectTargetKindDefinition, type ObjectTargetRef, type ObjectTargets, type PageObjectResource, type ResolveApplicationAssemblyOptions, type ResolvedAssemblyPortBinding, type ResourceInclude, type ResourceSource, SkillCapsulePlan, type SkillCapsuleResource, SkillDescriptor, SkillReference, type TextMaterial, type TextResource, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { a as assertObjectOperationCatalog, c as resolveApplicationAssembly, i as assertObjectOperationCall, l as resourceRefToFqn, n as applicationAssemblyPackage, o as assertObjectOperationDefinition, r as assertExecuteObjectOperationRequest, s as loadApplicationAssembly, t as ObjectOperationContractError } from "./src-Dv8bfFUo.js";
+import "./application-assembly.js";
+import { n as compileSkillCapsule, r as compilerSkillPackage, t as compileResourceSkillCapsule } from "./src-DEuFHizY.js";
+export { ObjectOperationContractError, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };

package/dist/kind-definition.d.ts

@@ -0,0 +1,14 @@
+import { n as ResourceDescriptor } from "./index-Ba5Gt9iW.js";
+//#region ../kind-definition/src/index.d.ts
+interface KindDefinition extends ResourceDescriptor {
+  kind: "KindDefinition";
+  resourceKind: string;
+  sourceShapes: readonly ("file" | "directory" | "manifest")[];
+}
+declare const kindDefinitionPackage: {
+  readonly role: "framework";
+  readonly area: "kind-definition";
+  readonly owns: "resource kind validation authority";
+};
+//#endregion
+export { KindDefinition, kindDefinitionPackage };

package/dist/kind-definition.js

@@ -0,0 +1,8 @@
+//#region ../kind-definition/src/index.ts
+const kindDefinitionPackage = {
+	role: "framework",
+	area: "kind-definition",
+	owns: "resource kind validation authority"
+};
+//#endregion
+export { kindDefinitionPackage };

package/dist/resource-core.d.ts

@@ -0,0 +1,2 @@
+import { _ as loadResourceTree, a as ResourceMetadata, c as ResourceRegistry, d as ResourceTreeBuildResult, f as ResourceValidationError, g as SourceShape, h as ResourceValueMap, i as ResourceIdentity, l as ResourceScalar, m as ResourceValueList, n as ResourceDescriptor, o as ResourceNode, p as ResourceValue, r as ResourceDiagnostic, s as ResourceRecord, t as LoadResourceTreeOptions, u as ResourceTree, v as validateResourceTree } from "./index-Ba5Gt9iW.js";
+export { LoadResourceTreeOptions, ResourceDescriptor, ResourceDiagnostic, ResourceIdentity, ResourceMetadata, ResourceNode, ResourceRecord, ResourceRegistry, ResourceScalar, ResourceTree, ResourceTreeBuildResult, ResourceValidationError, ResourceValue, ResourceValueList, ResourceValueMap, SourceShape, loadResourceTree, validateResourceTree };

package/dist/resource-core.js

@@ -0,0 +1,2 @@
+import { n as loadResourceTree, r as validateResourceTree, t as ResourceValidationError } from "./src-COEMEqZw.js";
+export { ResourceValidationError, loadResourceTree, validateResourceTree };

package/dist/resource-mapping.d.ts

@@ -0,0 +1,43 @@
+//#region ../resource-mapping/src/index.d.ts
+type ResourceMappingOperationKind = "CopyDirectory" | "CopyFile";
+interface ResourceMappingOperation {
+  kind: ResourceMappingOperationKind;
+  from: string;
+  to: string;
+}
+interface NamedResourceMapping {
+  id: string;
+  sourceRoot: string;
+  operations: readonly ResourceMappingOperation[];
+}
+interface ResourceMappings {
+  referenceTargets: ReadonlyMap<string, string>;
+  callableArtifactsTarget: string;
+  sources: readonly NamedResourceMapping[];
+  source: {
+    uri: string;
+  };
+}
+interface PlannedResourceCopy {
+  sourcePath: string;
+  targetRelativePath: string;
+  mappingId: string;
+}
+interface ResourceMappingPlan {
+  entries: readonly PlannedResourceCopy[];
+}
+interface PlanResourceMappingsOptions {
+  moduleRoots: ReadonlyMap<string, string> | Readonly<Record<string, string>>;
+  defaultSourceRoot?: string;
+  reservedTargetPaths?: readonly string[];
+}
+declare function parseResourceMappings(source: string, uri?: string): ResourceMappings;
+declare function planResourceMappings(mappings: ResourceMappings, options: PlanResourceMappingsOptions): Promise<ResourceMappingPlan>;
+declare function applyResourceMappingPlan(plan: ResourceMappingPlan, outputRoot: string): Promise<string[]>;
+declare const resourceMappingPackage: {
+  readonly role: "framework";
+  readonly area: "resource-mapping";
+  readonly owns: "declarative multi-root resource copy planning and collision preflight";
+};
+//#endregion
+export { NamedResourceMapping, PlanResourceMappingsOptions, PlannedResourceCopy, ResourceMappingOperation, ResourceMappingOperationKind, ResourceMappingPlan, ResourceMappings, applyResourceMappingPlan, parseResourceMappings, planResourceMappings, resourceMappingPackage };

package/dist/resource-mapping.js

@@ -0,0 +1,2 @@
+import { i as resourceMappingPackage, n as parseResourceMappings, r as planResourceMappings, t as applyResourceMappingPlan } from "./src-BlKlpg0J.js";
+export { applyResourceMappingPlan, parseResourceMappings, planResourceMappings, resourceMappingPackage };

package/dist/resource-projection.d.ts

@@ -0,0 +1,2 @@
+import { n as resourceProjectionPackage, t as ResourceRegistry } from "./index-DuRG4TQo.js";
+export { ResourceRegistry, resourceProjectionPackage };

package/dist/resource-projection.js

@@ -0,0 +1,8 @@
+//#region ../resource-projection/src/index.ts
+const resourceProjectionPackage = {
+	role: "framework",
+	area: "resource-projection",
+	owns: "validated registry facts and target projection inputs"
+};
+//#endregion
+export { resourceProjectionPackage };

package/dist/skill-capsule.d.ts

@@ -0,0 +1,2 @@
+import { a as SkillReference, c as compilerSkillPackage, i as SkillDescriptor, n as CompileSkillCapsuleInput, o as compileResourceSkillCapsule, r as SkillCapsulePlan, s as compileSkillCapsule, t as CompileResourceSkillCapsuleInput } from "./index-D-cBhQVw.js";
+export { CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, SkillCapsulePlan, SkillDescriptor, SkillReference, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage };

package/dist/skill-capsule.js

@@ -0,0 +1,2 @@
+import { n as compileSkillCapsule, r as compilerSkillPackage, t as compileResourceSkillCapsule } from "./src-DEuFHizY.js";
+export { compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage };

package/dist/src-B87eJQat.js

@@ -0,0 +1,39 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../runtime-authoring/src/index.ts
+const runtimeScope = new AsyncLocalStorage();
+function runWithRuntime(runtime, callback) {
+	return runtimeScope.run(runtime, callback);
+}
+function currentRuntime() {
+	const runtime = runtimeScope.getStore();
+	if (!runtime) throw new Error("No authoring runtime is active in the current async scope");
+	return runtime;
+}
+function createAuthoringBindings(runtime = currentRuntime()) {
+	return {
+		runtime,
+		logger: runtime.effects.logger,
+		invokeEffect: (effectFqn, input) => runtime.effects.invoke(effectFqn, input)
+	};
+}
+const logger = {
+	info(message, fields) {
+		currentRuntime().effects.logger.info(message, fields);
+	},
+	warn(message, fields) {
+		currentRuntime().effects.logger.warn(message, fields);
+	},
+	error(message, fields) {
+		currentRuntime().effects.logger.error(message, fields);
+	}
+};
+function invokeEffect(effectFqn, input) {
+	return currentRuntime().effects.invoke(effectFqn, input);
+}
+const runtimeAuthoringPackage = {
+	role: "framework",
+	area: "runtime-authoring",
+	owns: "target-neutral deterministic-code runtime and effect boundary"
+};
+//#endregion
+export { runWithRuntime as a, logger as i, currentRuntime as n, runtimeAuthoringPackage as o, invokeEffect as r, createAuthoringBindings as t };

package/dist/src-BlKlpg0J.js

@@ -0,0 +1,180 @@
+import { n as wordToString, t as parseXnl } from "./dist-Bkv7YeVi.js";
+import { copyFile, lstat, mkdir, readdir } from "node:fs/promises";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+//#region ../resource-mapping/src/index.ts
+function parseResourceMappings(source, uri = "vfs://./resource-mappings.xnl") {
+	let root;
+	try {
+		const document = parseXnl(source);
+		if (document.warnings?.length || document.nodes.length !== 1 || !isDataElement(document.nodes[0])) throw new Error("expected exactly one ResourceMappings data root without warnings");
+		root = document.nodes[0];
+	} catch (error) {
+		throw new Error(`Invalid ResourceMappings at ${uri}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (root.tag !== "ResourceMappings") throw new Error(`Invalid ResourceMappings at ${uri}: root must be ResourceMappings`);
+	const referenceTargets = /* @__PURE__ */ new Map();
+	for (const entry of bodyElements(extension(root, "ReferenceTargets"), "ReferenceTarget")) {
+		const kind = requiredXnlProperty(entry, "kind", uri);
+		if (referenceTargets.has(kind)) throw new Error(`Invalid ResourceMappings at ${uri}: duplicate ReferenceTarget kind ${kind}`);
+		referenceTargets.set(kind, normalizeOutputDirectory(requiredXnlProperty(entry, "target", uri), uri));
+	}
+	const callable = extension(root, "CallableArtifacts");
+	const callableArtifactsTarget = normalizeOutputDirectory(callable ? requiredXnlProperty(callable, "target", uri) : "functions/", uri);
+	const sources = bodyElements(extension(root, "SourceRoots"), "SourceRoot").map((entry) => {
+		const id = wordToString(entry.id);
+		if (!id || !/^[A-Z][A-Za-z0-9]*$/.test(id)) throw new Error(`Invalid ResourceMappings at ${uri}: SourceRoot #id must be a PascalCase segment`);
+		const operations = (entry.body ?? []).filter(isDataElement).filter((operation) => operation.tag === "CopyDirectory" || operation.tag === "CopyFile").map((operation) => ({
+			kind: operation.tag,
+			from: normalizeRelativePath(requiredXnlProperty(operation, "from", uri), uri, "from"),
+			to: normalizeRelativePath(requiredXnlProperty(operation, "to", uri), uri, "to")
+		}));
+		return {
+			id,
+			sourceRoot: requiredXnlProperty(entry, "sourceRoot", uri),
+			operations
+		};
+	});
+	if (new Set(sources.map((item) => item.id)).size !== sources.length) throw new Error(`Invalid ResourceMappings at ${uri}: SourceRoot ids must be unique`);
+	return {
+		referenceTargets,
+		callableArtifactsTarget,
+		sources,
+		source: { uri }
+	};
+}
+function extension(node, name) {
+	const child = node.extend?.children[name];
+	return child?.kind === "DataElement" ? child : void 0;
+}
+function bodyElements(node, tag) {
+	return (node?.body ?? []).filter(isDataElement).filter((entry) => entry.tag === tag);
+}
+function requiredXnlProperty(node, name, uri) {
+	const value = node.attributes?.[name];
+	if (typeof value !== "string" || !value.trim()) throw new Error(`Invalid ResourceMappings at ${uri}: <${node.tag}> requires ${name}`);
+	return value;
+}
+function isDataElement(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "kind" in value && value.kind === "DataElement";
+}
+async function planResourceMappings(mappings, options) {
+	const roots = asRootMap(options.moduleRoots);
+	const claims = [];
+	const entries = [];
+	const reserved = (options.reservedTargetPaths ?? []).map((path) => normalizeRelativePath(path, mappings.source.uri, "to"));
+	for (const mapping of mappings.sources) {
+		const sourceRootPath = resolveSourceRoot(mapping.sourceRoot, roots, options.defaultSourceRoot, mappings.source.uri);
+		await assertDirectory(sourceRootPath, mappings.source.uri, mapping.sourceRoot);
+		for (const operation of mapping.operations) {
+			for (const prior of claims) if (pathsOverlap(prior.target, operation.to)) throw new Error(`ResourceMappings target collision between ${prior.mappingId}:${prior.from} -> ${prior.target} and ${mapping.id}:${operation.from} -> ${operation.to}`);
+			claims.push({
+				target: operation.to,
+				mappingId: mapping.id,
+				from: operation.from
+			});
+			const sourcePath = safeResolve(sourceRootPath, operation.from, mappings.source.uri);
+			if (operation.kind === "CopyFile") {
+				await assertFile(sourcePath, mappings.source.uri, operation.from);
+				assertNotReserved(operation.to, reserved, mappings.source.uri);
+				entries.push({
+					sourcePath,
+					targetRelativePath: operation.to,
+					mappingId: mapping.id
+				});
+				continue;
+			}
+			await assertDirectory(sourcePath, mappings.source.uri, operation.from);
+			for (const filePath of await listFiles(sourcePath, mappings.source.uri)) {
+				const child = relative(sourcePath, filePath).split(sep).join("/");
+				const targetRelativePath = posix.join(operation.to, child);
+				assertNotReserved(targetRelativePath, reserved, mappings.source.uri);
+				entries.push({
+					sourcePath: filePath,
+					targetRelativePath,
+					mappingId: mapping.id
+				});
+			}
+		}
+	}
+	const seenTargets = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const prior = seenTargets.get(entry.targetRelativePath);
+		if (prior) throw new Error(`ResourceMappings duplicate target ${entry.targetRelativePath} from ${prior.sourcePath} and ${entry.sourcePath}`);
+		seenTargets.set(entry.targetRelativePath, entry);
+	}
+	return { entries: entries.sort((a, b) => a.targetRelativePath.localeCompare(b.targetRelativePath)) };
+}
+async function applyResourceMappingPlan(plan, outputRoot) {
+	const files = [];
+	for (const entry of plan.entries) {
+		const target = resolve(outputRoot, entry.targetRelativePath);
+		if (!isWithinRoot(resolve(outputRoot), target)) throw new Error(`ResourceMappings output escapes target root: ${entry.targetRelativePath}`);
+		await mkdir(dirname(target), { recursive: true });
+		await copyFile(entry.sourcePath, target);
+		files.push(entry.targetRelativePath);
+	}
+	return files;
+}
+function resolveSourceRoot(uri, roots, defaultSourceRoot, mappingUri) {
+	const moduleMatch = /^vfs:\/\/module\/([A-Z][A-Za-z0-9]*)\/(.*)$/.exec(uri);
+	if (moduleMatch) {
+		const base = roots.get(moduleMatch[1]);
+		if (!base) throw new Error(`Invalid ResourceMappings at ${mappingUri}: unknown module root ${moduleMatch[1]}`);
+		return safeResolve(resolve(base), moduleMatch[2], mappingUri);
+	}
+	const localMatch = /^vfs:\/\/@\/(.*)$/.exec(uri);
+	if (localMatch && defaultSourceRoot) return safeResolve(resolve(defaultSourceRoot), localMatch[1], mappingUri);
+	throw new Error(`Invalid ResourceMappings at ${mappingUri}: unsupported sourceRoot ${uri}`);
+}
+async function listFiles(root, uri) {
+	const files = [];
+	for (const entry of (await readdir(root, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+		const path = join(root, entry.name);
+		if (entry.isSymbolicLink()) throw new Error(`Invalid ResourceMappings at ${uri}: symbolic links are not supported: ${path}`);
+		if (entry.isDirectory()) files.push(...await listFiles(path, uri));
+		else if (entry.isFile()) files.push(path);
+		else throw new Error(`Invalid ResourceMappings at ${uri}: unsupported source entry ${path}`);
+	}
+	return files;
+}
+async function assertDirectory(path, uri, label) {
+	const info = await lstat(path).catch(() => void 0);
+	if (!info || info.isSymbolicLink() || !info.isDirectory()) throw new Error(`Invalid ResourceMappings at ${uri}: directory source does not exist: ${label}`);
+}
+async function assertFile(path, uri, label) {
+	const info = await lstat(path).catch(() => void 0);
+	if (!info || info.isSymbolicLink() || !info.isFile()) throw new Error(`Invalid ResourceMappings at ${uri}: file source does not exist: ${label}`);
+}
+function safeResolve(root, path, uri) {
+	const target = resolve(root, path);
+	if (!isWithinRoot(root, target)) throw new Error(`Invalid ResourceMappings at ${uri}: path escapes source root: ${path}`);
+	return target;
+}
+function isWithinRoot(root, target) {
+	return target === root || target.startsWith(`${root}${sep}`);
+}
+function assertNotReserved(path, reserved, uri) {
+	for (const item of reserved) if (pathsOverlap(path, item)) throw new Error(`Invalid ResourceMappings at ${uri}: target ${path} conflicts with generated target ${item}`);
+}
+function pathsOverlap(left, right) {
+	return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+function normalizeRelativePath(value, uri, attribute) {
+	if (!value.trim() || value.includes("\\") || value.startsWith("/") || isAbsolute(value) || value.split("/").includes("..")) throw new Error(`Invalid ResourceMappings at ${uri}: ${attribute} must be a safe relative path: ${value}`);
+	const normalized = posix.normalize(value).replace(/^\.\//, "").replace(/\/$/, "");
+	if (!normalized || normalized === "." || normalized.startsWith("../")) throw new Error(`Invalid ResourceMappings at ${uri}: ${attribute} must identify a non-root path: ${value}`);
+	return normalized;
+}
+function normalizeOutputDirectory(value, uri) {
+	return `${normalizeRelativePath(value, uri, "to")}/`;
+}
+function asRootMap(value) {
+	return typeof value.get === "function" ? value : new Map(Object.entries(value));
+}
+const resourceMappingPackage = {
+	role: "framework",
+	area: "resource-mapping",
+	owns: "declarative multi-root resource copy planning and collision preflight"
+};
+//#endregion
+export { resourceMappingPackage as i, parseResourceMappings as n, planResourceMappings as r, applyResourceMappingPlan as t };