halfcode-compiler.xnl 0.2.7 → 0.2.9

package/dist/resource-core.js

@@ -1,4 +1,7 @@
-import { _ as ResourceCompositionError, a as CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, c as admitCodePackages, d as buildResourceDependencySnapshot, f as createResourceContentIdentity, g as markEffectiveRegistryAuthentic, h as isEffectiveRegistryAuthentic, i as readonlyMap, l as loadCodePackageModule, m as effectiveRegistryLayerBindings, n as loadResourceTree, o as CodePackageLoadError, p as sha256Digest, r as validateResourceTree, s as admitCodePackageExports, t as ResourceValidationError, u as isLoadedResourceTreeAuthentic, v as compareCodeUnits, y as digestCanonical } from "./src-88_zDKZE.js";
+import { a as isLoadedResourceTreeAuthentic, c as sha256Digest, d as markEffectiveRegistryAuthentic, f as ResourceCompositionError, i as readonlyMap, m as digestCanonical, n as loadResourceTree, o as buildResourceDependencySnapshot, p as compareCodeUnits, r as validateResourceTree, s as createResourceContentIdentity, t as ResourceValidationError } from "./src-D3qSzGFn.js";
+import { t as resolveEffectiveResourceContentIdentities } from "./effective-content-identities-DV5fTr5Q.js";
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 //#region ../resource-core/src/layered-registry.ts
 function composeLayeredResourceRegistry(input) {
 	const diagnostics = [];
@@ -10,11 +13,11 @@ function composeLayeredResourceRegistry(input) {
 		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."));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_ID_EMPTY", layerLocation(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.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_ID_DUPLICATE", layerLocation(layerIndex, layerId), `Resource layer id '${layerId}' is declared more than once.`));
 			return;
 		}
 		layerIds.add(layerId);
@@ -27,7 +30,7 @@ function composeLayeredResourceRegistry(input) {
 		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));
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(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();
@@ -73,7 +76,7 @@ function composeLayeredResourceRegistry(input) {
 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.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation(layerIndex, layerId, kind), `Resource kind '${kind}' must use canonical VFS document provenance.`));
 			continue;
 		}
 		const definition = cloneRegisteredKindDefinition(inputDefinition);
@@ -87,7 +90,7 @@ function mergeKindDefinitions(tree, layerId, layerIndex, packageId, definitions,
 			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.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_KIND_DEFINITION_CONFLICT", layerLocation(layerIndex, layerId, kind), `Resource kind '${kind}' has incompatible KindDefinition contracts across layers.`));
 			continue;
 		}
 		current.origins.push(origin);
@@ -98,12 +101,12 @@ function mergeResources(tree, layerId, layerIndex, packageId, entries, diagnosti
 	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}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_RESOURCE_DUPLICATE", layerLocation(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.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' must use matching canonical VFS documentUri and safe logicalPath provenance.`));
 			continue;
 		}
 		const immutableResource = cloneResourceRecord(resource);
@@ -122,7 +125,7 @@ function mergeResources(tree, layerId, layerIndex, packageId, entries, diagnosti
 			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.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_IDENTITY_KIND_CONFLICT", layerLocation(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);
@@ -138,25 +141,25 @@ function applyTombstones(layer, layerId, layerIndex, packageId, entries, diagnos
 	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."));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_ID_EMPTY", layerLocation(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}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_DUPLICATE", layerLocation(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.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_TARGET_MISSING", layerLocation(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}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_RESOURCE_CONFLICT", layerLocation(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}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_KIND_MISMATCH", layerLocation(layerIndex, layerId, resourceId), `Tombstone for '${resourceId}' expects kind '${tombstone.expectedKind}', but the target kind is '${current.kind}'.`));
 			continue;
 		}
 		const origin = Object.freeze({
@@ -299,134 +302,102 @@ function compareOrigins(left, right) {
 function compareTombstones(left, right) {
 	return left.layerIndex - right.layerIndex || compareCodeUnits(left.resourceId, right.resourceId);
 }
-function stableDiagnostics$1(diagnostics) {
+function stableDiagnostics(diagnostics) {
 	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
 }
-function diagnostic$1(code, location, message) {
+function diagnostic(code, location, message) {
 	return Object.freeze({
 		code,
 		location,
 		message
 	});
 }
-function layerLocation$1(index, layerId, subject) {
+function layerLocation(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: [...authorityIdentity.contributions, ...input.contributions?.get(entry.resourceId) ?? []]
-			});
-			output.push([entry.resourceId, identity]);
-		} catch (error) {
-			if (error instanceof ResourceCompositionError) diagnostics.push(...error.diagnostics);
-			else throw error;
-		}
+//#region ../resource-core/src/resource-material.ts
+var ResourceMaterialError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(`Resource material read failed with ${diagnostics.length} diagnostic(s)`);
+		this.name = "ResourceMaterialError";
+		this.diagnostics = Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
 	}
-	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
-	return readonlyMap(output.sort(([left], [right]) => compareCodeUnits(left, right)));
+};
+async function readResourceMaterial(input) {
+	if (!isLoadedResourceTreeAuthentic(input.tree)) throw materialError("RESOURCE_MATERIAL_TREE_UNTRUSTED", input.resourceId, "Resource materials require an authentic LoadedResourceTree.");
+	const record = findResource(input.tree, input.resourceId);
+	const identity = input.tree.contentIdentities.get(input.resourceId);
+	if (!record || record.sourceShape !== "directory" || !identity) throw materialError("RESOURCE_MATERIAL_RESOURCE_INVALID", input.resourceId, `Resource '${input.resourceId}' is not an authentic directory resource.`);
+	const materialPath = materialRelativePath(input.uri);
+	if (!materialPath) throw materialError("RESOURCE_MATERIAL_URI_INVALID", input.resourceId, "Resource material URI must be a non-empty lexical-safe vfs://./ reference.");
+	const requestedRoot = resolve(input.rootDir);
+	const root = await realpath(requestedRoot).catch(() => requestedRoot);
+	const authorityCandidate = resolve(root, record.logicalPath);
+	const authorityPath = await realpath(authorityCandidate).catch(() => authorityCandidate);
+	if (!contains(root, authorityPath) || record.documentUri !== documentUri(root, authorityPath) || sha256Digest(await readFile(authorityPath).catch(() => /* @__PURE__ */ new Uint8Array())) !== identity.authorityDigest) throw materialError("RESOURCE_MATERIAL_AUTHORITY_MISMATCH", input.resourceId, "Directory resource authority does not match the loaded tree provenance.");
+	const ownerDirectory = dirname(authorityPath);
+	const candidate = resolve(ownerDirectory, materialPath);
+	if (!contains(ownerDirectory, candidate)) throw materialError("RESOURCE_MATERIAL_URI_INVALID", input.resourceId, "Resource material URI escapes its owning directory resource.");
+	const before = await lstat(candidate).catch(() => void 0);
+	if (!before) throw materialError("RESOURCE_MATERIAL_MISSING", input.resourceId, `Resource material '${input.uri}' does not exist.`);
+	if (before.isSymbolicLink()) throw materialError("RESOURCE_MATERIAL_SYMLINK_UNSUPPORTED", input.resourceId, `Resource material '${input.uri}' must not be a symbolic link.`);
+	if (!before.isFile()) throw materialError("RESOURCE_MATERIAL_NOT_FILE", input.resourceId, `Resource material '${input.uri}' must be a regular file.`);
+	const canonicalPath = await realpath(candidate).catch(() => candidate);
+	if (!contains(ownerDirectory, canonicalPath)) throw materialError("RESOURCE_MATERIAL_CONTAINMENT", input.resourceId, `Resource material '${input.uri}' resolves outside its owning directory resource.`);
+	const source = await readFile(canonicalPath).catch(() => void 0);
+	const after = await lstat(candidate).catch(() => void 0);
+	const afterCanonical = await realpath(candidate).catch(() => void 0);
+	if (!source || !after || after.isSymbolicLink() || !after.isFile() || afterCanonical !== canonicalPath) throw materialError("RESOURCE_MATERIAL_CHANGED", input.resourceId, `Resource material '${input.uri}' changed while it was being read.`);
+	const bytes = new Uint8Array(source);
+	const digest = sha256Digest(bytes);
+	const sourceUri = documentUri(root, canonicalPath);
+	const contribution = Object.freeze({
+		key: `material:${input.uri}`,
+		digest,
+		sourceUri
+	});
+	return Object.freeze({
+		resourceId: input.resourceId,
+		uri: input.uri,
+		sourceUri,
+		digest,
+		contribution,
+		bytes: () => new Uint8Array(bytes)
+	});
 }
-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: identity.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.`));
+function materialRelativePath(uri) {
+	const match = /^vfs:\/\/\.\/(.+)$/u.exec(uri);
+	if (!match || /%2f|%5c/i.test(uri)) return void 0;
+	let decoded;
+	try {
+		decoded = decodeURIComponent(match[1]);
+	} catch {
+		return;
 	}
-	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.`));
+	const segments = decoded.split(/[\\/]+/u);
+	if (isAbsolute(decoded) || decoded.includes("\\") || segments.some((segment) => !segment || segment === "." || segment === "..")) return void 0;
+	return segments.join(sep);
 }
 function findResource(tree, resourceId) {
 	for (const records of tree.registry.byKind.values()) {
-		const resource = records.find((record) => record.resourceId === resourceId);
-		if (resource) return resource;
+		const record = records.find((item) => item.resourceId === resourceId);
+		if (record) return record;
 	}
 }
-function stableDiagnostics(diagnostics) {
-	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
+function contains(boundary, candidate) {
+	return candidate === boundary || candidate.startsWith(`${boundary}${sep}`);
 }
-function compositionError(diagnosticValue) {
-	return new ResourceCompositionError(Object.freeze([diagnosticValue]));
+function documentUri(root, filePath) {
+	return `vfs://@/${relative(root, filePath).split(sep).join("/")}`;
 }
-function diagnostic(code, location, message) {
-	return Object.freeze({
+function materialError(code, resourceId, message) {
+	return new ResourceMaterialError([Object.freeze({
 		code,
-		location,
+		location: `resource-material:${resourceId || "unknown"}`,
 		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 { CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, CodePackageLoadError, ResourceCompositionError, ResourceValidationError, admitCodePackageExports, admitCodePackages, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadCodePackageModule, loadResourceTree, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };
+export { ResourceCompositionError, ResourceMaterialError, ResourceValidationError, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadResourceTree, readResourceMaterial, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };

package/dist/resource-projection.d.ts

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

package/dist/skill-capsule.d.ts

@@ -1,3 +1,3 @@
 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-X6R_4lMW.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-B515mMkO.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 { a as compilerSkillPackage, i as compileSkillCapsule, n as applySkillCapsuleDistributionPlan, o as planSkillCapsuleDistribution, r as compileResourceSkillCapsule, s as skillCapsuleDistributionProjection, t as SkillCapsuleDistributionError } from "./src-BxyKIkBg.js";
+import { a as compilerSkillPackage, i as compileSkillCapsule, n as applySkillCapsuleDistributionPlan, o as planSkillCapsuleDistribution, r as compileResourceSkillCapsule, s as skillCapsuleDistributionProjection, t as SkillCapsuleDistributionError } from "./src-CaQ25rMj.js";
 export { SkillCapsuleDistributionError, applySkillCapsuleDistributionPlan, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, planSkillCapsuleDistribution, skillCapsuleDistributionProjection };