halfcode-compiler.xnl 0.2.1 → 0.2.2

package/dist/resource-core.js

@@ -1,2 +1,432 @@
-import { n as loadResourceTree, r as validateResourceTree, t as ResourceValidationError } from "./src-DKkIFGWH.js";
-export { ResourceValidationError, loadResourceTree, validateResourceTree };
+import { a as isLoadedResourceTreeAuthentic, c as sha256Digest, d as markEffectiveRegistryAuthentic, f as ResourceCompositionError, i as readonlyMap, l as effectiveRegistryLayerBindings, m as digestCanonical, n as loadResourceTree, o as buildResourceDependencySnapshot, p as compareCodeUnits, r as validateResourceTree, s as createResourceContentIdentity, t as ResourceValidationError, u as isEffectiveRegistryAuthentic } from "./src-DCRih45n.js";
+//#region ../resource-core/src/layered-registry.ts
+function composeLayeredResourceRegistry(input) {
+	const diagnostics = [];
+	const layerIds = /* @__PURE__ */ new Set();
+	const layers = [];
+	const entries = /* @__PURE__ */ new Map();
+	const kindDefinitions = /* @__PURE__ */ new Map();
+	input.layers.forEach((layer, layerIndex) => {
+		const layerId = layer.id.trim();
+		const packageId = layer.tree.manifest.resourceId;
+		if (layerId.length === 0) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_ID_EMPTY", layerLocation$1(layerIndex), "Resource layer id must be a non-empty explicit value."));
+			return;
+		}
+		if (layerIds.has(layerId)) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_ID_DUPLICATE", layerLocation$1(layerIndex, layerId), `Resource layer id '${layerId}' is declared more than once.`));
+			return;
+		}
+		layerIds.add(layerId);
+		layers.push(Object.freeze({
+			id: layerId,
+			index: layerIndex,
+			packageId
+		}));
+		mergeKindDefinitions(layer.tree, layerId, layerIndex, packageId, kindDefinitions, diagnostics);
+		mergeResources(layer.tree, layerId, layerIndex, packageId, entries, diagnostics);
+		applyTombstones(layer, layerId, layerIndex, packageId, entries, diagnostics);
+	});
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
+	const frozenEntries = [...entries.values()].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)).map((entry) => freezeEntry(entry));
+	const byId = readonlyMap(frozenEntries.map((entry) => [entry.resourceId, entry]));
+	const byKindValues = /* @__PURE__ */ new Map();
+	for (const entry of frozenEntries) {
+		if (!entry.resource) continue;
+		const records = byKindValues.get(entry.kind) ?? [];
+		records.push(entry.resource);
+		byKindValues.set(entry.kind, records);
+	}
+	const byKind = readonlyMap([...byKindValues.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([kind, records]) => [kind, Object.freeze([...records].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)))]));
+	const frozenDefinitions = [...kindDefinitions.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([kind, value]) => [kind, Object.freeze({
+		definition: value.definition,
+		origins: Object.freeze([...value.origins].sort(compareOrigins))
+	})]);
+	const publicKindDefinitions = readonlyMap(frozenDefinitions);
+	const frozenLayers = Object.freeze([...layers]);
+	const compositionRevision = digestCanonical({
+		layers: frozenLayers.map((layer) => ({
+			id: layer.id,
+			index: layer.index,
+			packageId: layer.packageId
+		})),
+		entries: frozenEntries.map(entryRevisionFact),
+		kindDefinitions: frozenDefinitions.map(([kind, value]) => ({
+			kind,
+			definitionResourceId: value.definition.resourceId,
+			contract: normalizedKindContract(value.definition),
+			origins: value.origins.map(stableOriginFact)
+		}))
+	});
+	return markEffectiveRegistryAuthentic(Object.freeze({
+		byId,
+		byKind,
+		kindDefinitions: publicKindDefinitions,
+		layers: frozenLayers,
+		compositionRevision,
+		revision: compositionRevision
+	}), frozenLayers.map((layer) => ({
+		id: layer.id,
+		tree: input.layers[layer.index].tree
+	})));
+}
+function mergeKindDefinitions(tree, layerId, layerIndex, packageId, definitions, diagnostics) {
+	for (const [kind, inputDefinition] of [...tree.registry.kindDefinitions.entries()].sort(([left], [right]) => compareCodeUnits(left, right))) {
+		if (!isCanonicalVfsDocumentUri(inputDefinition.documentUri)) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation$1(layerIndex, layerId, kind), `Resource kind '${kind}' must use canonical VFS document provenance.`));
+			continue;
+		}
+		const definition = cloneRegisteredKindDefinition(inputDefinition);
+		const origin = kindDefinitionOrigin(layerId, layerIndex, packageId, definition);
+		const current = definitions.get(kind);
+		if (!current) {
+			definitions.set(kind, {
+				definition,
+				origins: [origin]
+			});
+			continue;
+		}
+		if (JSON.stringify(normalizedKindContract(current.definition)) !== JSON.stringify(normalizedKindContract(definition))) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_KIND_DEFINITION_CONFLICT", layerLocation$1(layerIndex, layerId, kind), `Resource kind '${kind}' has incompatible KindDefinition contracts across layers.`));
+			continue;
+		}
+		current.origins.push(origin);
+	}
+}
+function mergeResources(tree, layerId, layerIndex, packageId, entries, diagnostics) {
+	const records = [...tree.registry.byKind.values()].flatMap((values) => [...values]).sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId) || compareCodeUnits(left.kind, right.kind));
+	const seenInLayer = /* @__PURE__ */ new Set();
+	for (const resource of records) {
+		if (seenInLayer.has(resource.resourceId)) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_RESOURCE_DUPLICATE", layerLocation$1(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' occurs more than once in layer '${layerId}'.`));
+			continue;
+		}
+		seenInLayer.add(resource.resourceId);
+		if (!isSafeLogicalPath(resource.logicalPath) || resource.documentUri !== `vfs://@/${resource.logicalPath}`) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation$1(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' must use matching canonical VFS documentUri and safe logicalPath provenance.`));
+			continue;
+		}
+		const immutableResource = cloneResourceRecord(resource);
+		const origin = resourceOrigin(layerId, layerIndex, packageId, immutableResource);
+		const current = entries.get(resource.resourceId);
+		if (!current) {
+			entries.set(resource.resourceId, {
+				resourceId: resource.resourceId,
+				kind: resource.kind,
+				resource: immutableResource,
+				effectiveLayerId: layerId,
+				effectiveOrigin: origin,
+				shadowed: [],
+				tombstones: []
+			});
+			continue;
+		}
+		if (current.kind !== resource.kind) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_IDENTITY_KIND_CONFLICT", layerLocation$1(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' changes kind from '${current.kind}' to '${resource.kind}' across layers.`));
+			continue;
+		}
+		if (current.effectiveOrigin) current.shadowed.push(current.effectiveOrigin);
+		current.resource = immutableResource;
+		current.effectiveLayerId = layerId;
+		current.effectiveOrigin = origin;
+		current.tombstone = void 0;
+	}
+}
+function applyTombstones(layer, layerId, layerIndex, packageId, entries, diagnostics) {
+	const tombstones = [...layer.tombstones ?? []].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId));
+	const seen = /* @__PURE__ */ new Set();
+	for (const tombstone of tombstones) {
+		const resourceId = tombstone.resourceId.trim();
+		if (resourceId.length === 0) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_ID_EMPTY", layerLocation$1(layerIndex, layerId), "Resource tombstone target must be a non-empty resource id."));
+			continue;
+		}
+		if (seen.has(resourceId)) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_DUPLICATE", layerLocation$1(layerIndex, layerId, resourceId), `Resource '${resourceId}' has more than one tombstone in layer '${layerId}'.`));
+			continue;
+		}
+		seen.add(resourceId);
+		const current = entries.get(resourceId);
+		if (!current) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_TARGET_MISSING", layerLocation$1(layerIndex, layerId, resourceId), `Tombstone target '${resourceId}' does not exist in a lower or current layer.`));
+			continue;
+		}
+		if (current.effectiveLayerId === layerId) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_RESOURCE_CONFLICT", layerLocation$1(layerIndex, layerId, resourceId), `Resource '${resourceId}' cannot be both effective and tombstoned in layer '${layerId}'.`));
+			continue;
+		}
+		if (tombstone.expectedKind !== void 0 && tombstone.expectedKind !== current.kind) {
+			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_KIND_MISMATCH", layerLocation$1(layerIndex, layerId, resourceId), `Tombstone for '${resourceId}' expects kind '${tombstone.expectedKind}', but the target kind is '${current.kind}'.`));
+			continue;
+		}
+		const origin = Object.freeze({
+			resourceId,
+			...tombstone.expectedKind === void 0 ? {} : { expectedKind: tombstone.expectedKind },
+			...tombstone.reason === void 0 ? {} : { reason: tombstone.reason },
+			layerId,
+			layerIndex,
+			packageId
+		});
+		if (current.effectiveOrigin) current.shadowed.push(current.effectiveOrigin);
+		current.resource = void 0;
+		current.effectiveLayerId = void 0;
+		current.effectiveOrigin = void 0;
+		current.tombstone = origin;
+		current.tombstones.push(origin);
+	}
+}
+function resourceOrigin(layerId, layerIndex, packageId, resource) {
+	return Object.freeze({
+		layerId,
+		layerIndex,
+		packageId,
+		documentUri: resource.documentUri,
+		logicalPath: resource.logicalPath
+	});
+}
+function kindDefinitionOrigin(layerId, layerIndex, packageId, definition) {
+	return Object.freeze({
+		layerId,
+		layerIndex,
+		packageId,
+		documentUri: definition.documentUri
+	});
+}
+function freezeEntry(entry) {
+	return Object.freeze({
+		resourceId: entry.resourceId,
+		kind: entry.kind,
+		...entry.resource === void 0 ? {} : { resource: entry.resource },
+		...entry.effectiveLayerId === void 0 ? {} : { effectiveLayerId: entry.effectiveLayerId },
+		...entry.effectiveOrigin === void 0 ? {} : { effectiveOrigin: entry.effectiveOrigin },
+		shadowed: Object.freeze([...entry.shadowed].sort(compareOrigins)),
+		...entry.tombstone === void 0 ? {} : { tombstone: entry.tombstone },
+		tombstones: Object.freeze([...entry.tombstones].sort(compareTombstones))
+	});
+}
+function entryRevisionFact(entry) {
+	return {
+		resourceId: entry.resourceId,
+		kind: entry.kind,
+		resourcePresent: entry.resource !== void 0,
+		effectiveLayerId: entry.effectiveLayerId,
+		effectiveOrigin: entry.effectiveOrigin === void 0 ? void 0 : stableOriginFact(entry.effectiveOrigin),
+		shadowed: entry.shadowed.map(stableOriginFact),
+		tombstone: entry.tombstone === void 0 ? void 0 : stableTombstoneFact(entry.tombstone),
+		tombstones: entry.tombstones.map(stableTombstoneFact)
+	};
+}
+function cloneResourceRecord(resource) {
+	return Object.freeze({
+		kind: resource.kind,
+		...resource.fqn === void 0 ? {} : { fqn: resource.fqn },
+		...resource.name === void 0 ? {} : { name: resource.name },
+		...resource.description === void 0 ? {} : { description: resource.description },
+		resourceId: resource.resourceId,
+		metadata: cloneResourceMetadata(resource.metadata),
+		sourceShape: resource.sourceShape,
+		logicalPath: resource.logicalPath,
+		documentUri: resource.documentUri,
+		format: resource.format,
+		node: cloneResourceValue(resource.node)
+	});
+}
+function cloneResourceMetadata(metadata) {
+	return Object.freeze({
+		apiVersion: metadata.apiVersion,
+		...metadata.lifecycle === void 0 ? {} : { lifecycle: metadata.lifecycle },
+		...metadata.version === void 0 ? {} : { version: metadata.version }
+	});
+}
+function cloneResourceValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return Object.freeze(value.map((item) => cloneResourceValue(item)));
+	const clone = {};
+	for (const key of Object.keys(value).sort(compareCodeUnits)) clone[key] = cloneResourceValue(value[key]);
+	return Object.freeze(clone);
+}
+function cloneRegisteredKindDefinition(definition) {
+	return Object.freeze({
+		resourceId: definition.resourceId,
+		resourceKind: definition.resourceKind,
+		sourceShapes: Object.freeze([...definition.sourceShapes].sort(compareCodeUnits)),
+		requiredFiles: Object.freeze([...definition.requiredFiles].sort(compareCodeUnits)),
+		currentApiVersion: definition.currentApiVersion,
+		supportedApiVersions: Object.freeze([...definition.supportedApiVersions].sort(compareCodeUnits)),
+		documentCardinality: definition.documentCardinality,
+		documentUri: definition.documentUri
+	});
+}
+function normalizedKindContract(definition) {
+	return {
+		resourceKind: definition.resourceKind,
+		sourceShapes: [...definition.sourceShapes].sort(compareCodeUnits),
+		requiredFiles: [...definition.requiredFiles].sort(compareCodeUnits),
+		currentApiVersion: definition.currentApiVersion,
+		supportedApiVersions: [...definition.supportedApiVersions].sort(compareCodeUnits),
+		documentCardinality: definition.documentCardinality
+	};
+}
+function stableOriginFact(origin) {
+	return {
+		layerId: origin.layerId,
+		layerIndex: origin.layerIndex,
+		packageId: origin.packageId,
+		documentUri: origin.documentUri,
+		logicalPath: origin.logicalPath
+	};
+}
+function stableTombstoneFact(origin) {
+	return {
+		resourceId: origin.resourceId,
+		expectedKind: origin.expectedKind,
+		reason: origin.reason,
+		layerId: origin.layerId,
+		layerIndex: origin.layerIndex,
+		packageId: origin.packageId
+	};
+}
+function isCanonicalVfsDocumentUri(documentUri) {
+	return documentUri.startsWith("vfs://@/") && isSafeLogicalPath(documentUri.slice(8));
+}
+function isSafeLogicalPath(logicalPath) {
+	if (logicalPath.length === 0 || logicalPath.startsWith("/") || logicalPath.includes("\\")) return false;
+	return logicalPath.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function compareOrigins(left, right) {
+	return left.layerIndex - right.layerIndex || compareCodeUnits(left.layerId, right.layerId);
+}
+function compareTombstones(left, right) {
+	return left.layerIndex - right.layerIndex || compareCodeUnits(left.resourceId, right.resourceId);
+}
+function stableDiagnostics$1(diagnostics) {
+	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
+}
+function diagnostic$1(code, location, message) {
+	return Object.freeze({
+		code,
+		location,
+		message
+	});
+}
+function layerLocation$1(index, layerId, subject) {
+	return `layer:${index}:${layerId ?? "unnamed"}${subject === void 0 ? "" : `:${subject}`}`;
+}
+//#endregion
+//#region ../resource-core/src/effective-content-identities.ts
+function resolveEffectiveResourceContentIdentities(input) {
+	const diagnostics = [];
+	if (!isEffectiveRegistryAuthentic(input.registry)) throw compositionError(diagnostic("RESOURCE_CONTENT_IDENTITY_REGISTRY_UNTRUSTED", "content-projector:registry", "Effective content identities require an authentic registry returned by composeLayeredResourceRegistry()."));
+	const bindings = effectiveRegistryLayerBindings(input.registry) ?? [];
+	if (input.layers.length !== input.registry.layers.length || bindings.length !== input.registry.layers.length) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_COUNT_MISMATCH", "content-projector:layers", "Effective content identity layers must exactly match the composed registry layers."));
+	const loadedById = /* @__PURE__ */ new Map();
+	for (let index = 0; index < input.registry.layers.length; index += 1) {
+		const descriptor = input.registry.layers[index];
+		const layer = input.layers[index];
+		const binding = bindings[index];
+		if (!layer) continue;
+		if (!isLoadedResourceTreeAuthentic(layer.tree)) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_UNTRUSTED", layerLocation(index, layer.id), `Layer '${layer.id}' must use an authentic LoadedResourceTree returned by loadResourceTree().`));
+			continue;
+		}
+		if (layer.id !== descriptor.id || binding?.id !== descriptor.id) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_ID_MISMATCH", layerLocation(index, layer.id), `Layer at index ${index} must retain exact id '${descriptor.id}'.`));
+			continue;
+		}
+		if (descriptor.index !== index) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_INDEX_MISMATCH", layerLocation(index, layer.id), `Layer '${layer.id}' has inconsistent registry index ${descriptor.index}.`));
+			continue;
+		}
+		if (layer.tree.manifest.resourceId !== descriptor.packageId) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_PACKAGE_MISMATCH", layerLocation(index, layer.id), `Layer '${layer.id}' must retain package '${descriptor.packageId}'.`));
+			continue;
+		}
+		if (binding?.tree !== layer.tree) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_BINDING_MISMATCH", layerLocation(index, layer.id), `Layer '${layer.id}' must use the exact loaded tree composed into the registry.`));
+			continue;
+		}
+		validateLoadedIdentityCoverage(layer.tree, layer.id, diagnostics);
+		loadedById.set(layer.id, layer.tree);
+	}
+	const effectiveEntries = [...input.registry.byId.values()].filter((entry) => entry.resource !== void 0).sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId));
+	const effectiveIds = new Set(effectiveEntries.map((entry) => entry.resourceId));
+	for (const resourceId of input.contributions?.keys() ?? []) if (!effectiveIds.has(resourceId)) diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_OWNER_UNKNOWN", contentLocation(resourceId), `Digest contributions target unknown effective resource '${resourceId}'.`));
+	const output = [];
+	for (const entry of effectiveEntries) {
+		const tree = entry.effectiveLayerId === void 0 ? void 0 : loadedById.get(entry.effectiveLayerId);
+		if (!tree || !entry.effectiveOrigin) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_EFFECTIVE_ORIGIN_MISSING", contentLocation(entry.resourceId), `Effective resource '${entry.resourceId}' has no exact loaded layer origin.`));
+			continue;
+		}
+		validateEffectiveOrigin(entry, input.registry, tree, diagnostics);
+		const authorityIdentity = tree.contentIdentities.get(entry.resourceId);
+		if (!authorityIdentity) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_MISSING", contentLocation(entry.resourceId), `Effective resource '${entry.resourceId}' is missing its loader authority identity.`));
+			continue;
+		}
+		try {
+			const identity = createResourceContentIdentity({
+				resourceId: entry.resourceId,
+				authorityDigest: authorityIdentity.authorityDigest,
+				contributions: input.contributions?.get(entry.resourceId) ?? []
+			});
+			output.push([entry.resourceId, identity]);
+		} catch (error) {
+			if (error instanceof ResourceCompositionError) diagnostics.push(...error.diagnostics);
+			else throw error;
+		}
+	}
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
+	return readonlyMap(output.sort(([left], [right]) => compareCodeUnits(left, right)));
+}
+function validateLoadedIdentityCoverage(tree, layerId, diagnostics) {
+	const resources = [...tree.registry.byKind.values()].flatMap((records) => [...records]).sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId));
+	const resourcesById = new Map(resources.map((resource) => [resource.resourceId, resource]));
+	for (const resource of resources) {
+		const identity = tree.contentIdentities.get(resource.resourceId);
+		if (!identity) {
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_MISSING", layerLocation(void 0, layerId, resource.resourceId), `Loaded resource '${resource.resourceId}' has no authority identity.`));
+			continue;
+		}
+		const normalized = createResourceContentIdentity({
+			resourceId: identity.resourceId,
+			authorityDigest: identity.authorityDigest,
+			contributions: []
+		});
+		if (identity.resourceId !== resource.resourceId || identity.contentDigest !== normalized.contentDigest) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_INVALID", layerLocation(void 0, layerId, resource.resourceId), `Loaded resource '${resource.resourceId}' has an inconsistent authority identity.`));
+	}
+	for (const resourceId of tree.contentIdentities.keys()) if (!resourcesById.has(resourceId)) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_EXTRA", layerLocation(void 0, layerId, resourceId), `Loaded tree contains an extra authority identity '${resourceId}'.`));
+}
+function validateEffectiveOrigin(entry, registry, tree, diagnostics) {
+	const origin = entry.effectiveOrigin;
+	const descriptor = registry.layers[origin.layerIndex];
+	const loadedRecord = findResource(tree, entry.resourceId);
+	if (!descriptor || descriptor.id !== origin.layerId || descriptor.packageId !== origin.packageId || tree.manifest.resourceId !== origin.packageId || !loadedRecord || loadedRecord.documentUri !== origin.documentUri || loadedRecord.logicalPath !== origin.logicalPath) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_EFFECTIVE_ORIGIN_MISMATCH", contentLocation(entry.resourceId), `Effective resource '${entry.resourceId}' does not match its exact layer/package/origin facts.`));
+}
+function findResource(tree, resourceId) {
+	for (const records of tree.registry.byKind.values()) {
+		const resource = records.find((record) => record.resourceId === resourceId);
+		if (resource) return resource;
+	}
+}
+function stableDiagnostics(diagnostics) {
+	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
+}
+function compositionError(diagnosticValue) {
+	return new ResourceCompositionError(Object.freeze([diagnosticValue]));
+}
+function diagnostic(code, location, message) {
+	return Object.freeze({
+		code,
+		location,
+		message
+	});
+}
+function layerLocation(index, layerId, resourceId) {
+	return `content-layer:${index ?? "unknown"}:${layerId}${resourceId === void 0 ? "" : `:${resourceId}`}`;
+}
+function contentLocation(resourceId) {
+	return `content:${resourceId || "unnamed"}`;
+}
+//#endregion
+export { ResourceCompositionError, ResourceValidationError, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadResourceTree, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };

package/dist/resource-mapping.d.ts

@@ -31,13 +31,26 @@ interface PlanResourceMappingsOptions {
   defaultSourceRoot?: string;
   reservedTargetPaths?: readonly string[];
 }
+type SafePathLexicalKind = "segment" | "relative-path" | "relative-directory";
+declare class ResourceMappingPathError extends Error {
+  readonly uri: string;
+  readonly attribute: "from" | "to";
+  readonly owner: string;
+  readonly rawPath: string;
+  readonly issue: string;
+  readonly code = "RESOURCE_MAPPING_PATH_INVALID";
+  constructor(uri: string, attribute: "from" | "to", owner: string, rawPath: string, issue: 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 function safePathLexicalIssue(value: string, kind: SafePathLexicalKind): string | undefined;
+declare function unsafeUnicodeCodeUnitIssue(value: string): string | undefined;
+declare function unsafeControlCodePointIssue(value: string): string | undefined;
 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 };
+export { NamedResourceMapping, PlanResourceMappingsOptions, PlannedResourceCopy, ResourceMappingOperation, ResourceMappingOperationKind, ResourceMappingPathError, ResourceMappingPlan, ResourceMappings, SafePathLexicalKind, applyResourceMappingPlan, parseResourceMappings, planResourceMappings, resourceMappingPackage, safePathLexicalIssue, unsafeControlCodePointIssue, unsafeUnicodeCodeUnitIssue };

package/dist/resource-mapping.js

@@ -1,2 +1,2 @@
-import { i as resourceMappingPackage, n as parseResourceMappings, r as planResourceMappings, t as applyResourceMappingPlan } from "./src-BlKlpg0J.js";
-export { applyResourceMappingPlan, parseResourceMappings, planResourceMappings, resourceMappingPackage };
+import { a as resourceMappingPackage, c as unsafeUnicodeCodeUnitIssue, i as planResourceMappings, n as applyResourceMappingPlan, o as safePathLexicalIssue, r as parseResourceMappings, s as unsafeControlCodePointIssue, t as ResourceMappingPathError } from "./src-25wZPUyX.js";
+export { ResourceMappingPathError, applyResourceMappingPlan, parseResourceMappings, planResourceMappings, resourceMappingPackage, safePathLexicalIssue, unsafeControlCodePointIssue, unsafeUnicodeCodeUnitIssue };

package/dist/resource-projection.d.ts

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

package/dist/skill-capsule.d.ts

@@ -1,2 +1,3 @@
-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-wU-iKJnW.js";
-export { CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, SkillCapsulePlan, SkillDescriptor, SkillReference, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage };
+import { I as SkillCapsuleDependency } from "./index-Cqh9pEBa.js";
+import { S as skillCapsuleDistributionProjection, _ as applySkillCapsuleDistributionPlan, a as PlannedSkillCapsule, b as compilerSkillPackage, c as SkillCapsuleContentDigest, d as SkillCapsuleDistributionReceipt, f as SkillCapsuleIdentity, g as SkillReference, h as SkillDescriptor, i as PlanSkillCapsuleDistributionInput, l as SkillCapsuleDistributionError, m as SkillCapsuleProvenanceManifest, n as CompileResourceSkillCapsuleInput, o as PlannedSkillFile, p as SkillCapsulePlan, r as CompileSkillCapsuleInput, s as SkillCapsuleApplyStep, t as ApplySkillCapsuleDistributionOptions, u as SkillCapsuleDistributionPlan, v as compileResourceSkillCapsule, x as planSkillCapsuleDistribution, y as compileSkillCapsule } from "./index-96qHPZj2.js";
+export { ApplySkillCapsuleDistributionOptions, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, PlanSkillCapsuleDistributionInput, PlannedSkillCapsule, PlannedSkillFile, SkillCapsuleApplyStep, SkillCapsuleContentDigest, type SkillCapsuleDependency, SkillCapsuleDistributionError, SkillCapsuleDistributionPlan, SkillCapsuleDistributionReceipt, SkillCapsuleIdentity, SkillCapsulePlan, SkillCapsuleProvenanceManifest, SkillDescriptor, SkillReference, applySkillCapsuleDistributionPlan, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, planSkillCapsuleDistribution, skillCapsuleDistributionProjection };

package/dist/skill-capsule.js

@@ -1,2 +1,2 @@
-import { n as compileSkillCapsule, r as compilerSkillPackage, t as compileResourceSkillCapsule } from "./src-D8xlMdXx.js";
-export { compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage };
+import { a as compilerSkillPackage, i as compileSkillCapsule, n as applySkillCapsuleDistributionPlan, o as planSkillCapsuleDistribution, r as compileResourceSkillCapsule, s as skillCapsuleDistributionProjection, t as SkillCapsuleDistributionError } from "./src-D1Bmq7Lo.js";
+export { SkillCapsuleDistributionError, applySkillCapsuleDistributionPlan, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, planSkillCapsuleDistribution, skillCapsuleDistributionProjection };