halfcode-compiler.xnl 0.2.8 → 0.2.9

package/dist/authoring-runtime.d.ts

@@ -1,2 +1,164 @@
+import { I as EffectiveResourceRegistry, n as LoadedResourceTree } from "./index-CDIT65pI.js";
+import { n as ResourceLayerContentIdentityInput } from "./effective-content-identities-CSVFi-N5.js";
 import { a as createAuthoringBindings, c as logger, i as RuntimeEffects, l as runWithRuntime, n as AuthoringRuntime, o as currentRuntime, r as Logger, s as invokeEffect, t as AuthoringBindings, u as runtimeAuthoringPackage } from "./index-Dg0imcjf.js";
-export { AuthoringBindings, AuthoringRuntime, Logger, RuntimeEffects, createAuthoringBindings, currentRuntime, invokeEffect, logger, runWithRuntime, runtimeAuthoringPackage };
+//#region ../runtime-authoring/src/resource-authoring.d.ts
+declare const RESOURCE_AUTHORING_SCHEMA_VERSION: "halfcode.resource-authoring/v1";
+type ResourceAuthoringOperation = "create" | "update";
+type ResourceAuthoringSourceShape = "single-file";
+type ResourceAuthoringDocumentUri = `vfs://@/${string}`;
+interface ResourceAuthoringExpectedAbsent {
+  readonly state: "absent";
+  readonly registryRevision: string;
+}
+interface ResourceAuthoringExpectedPresent {
+  readonly state: "present";
+  readonly authorityDigest: string;
+  readonly registryRevision: string;
+}
+type ResourceAuthoringExpectedState = ResourceAuthoringExpectedAbsent | ResourceAuthoringExpectedPresent;
+interface ResourceAuthoringProposal {
+  readonly schemaVersion: typeof RESOURCE_AUTHORING_SCHEMA_VERSION;
+  readonly operation: ResourceAuthoringOperation;
+  readonly catalogId: string;
+  readonly resourceId: string;
+  readonly kind: string;
+  readonly apiVersion: string;
+  readonly sourceShape: ResourceAuthoringSourceShape;
+  readonly documentUri: ResourceAuthoringDocumentUri;
+  readonly authorityText: string;
+  readonly expected: ResourceAuthoringExpectedState;
+}
+interface ResourceAuthoringKindDefinition {
+  readonly kind: string;
+  readonly supportedApiVersions: readonly string[];
+  readonly sourceShapes: readonly ResourceAuthoringSourceShape[];
+  readonly documentCardinality: "one" | "many";
+}
+interface ResourceAuthoringCatalogBinding {
+  readonly catalogId: string;
+  readonly resourceKind: string;
+  readonly sourceShape: ResourceAuthoringSourceShape;
+  readonly rootUri: ResourceAuthoringDocumentUri;
+  readonly entry?: string;
+}
+interface ResourceAuthoringPlanningAuthority {
+  readonly registryRevision: string;
+  readonly kindDefinitions: readonly ResourceAuthoringKindDefinition[];
+  readonly catalogs: readonly ResourceAuthoringCatalogBinding[];
+}
+type ResourceAuthoringPlanningConfig = Readonly<Record<never, never>>;
+interface ResourceAuthoringInspectedRoot {
+  readonly resourceId: string;
+  readonly kind: string;
+  readonly apiVersion: string;
+}
+interface ResourceAuthoringAuthorityInspection {
+  readonly documentUri: ResourceAuthoringDocumentUri;
+  readonly resources: readonly ResourceAuthoringInspectedRoot[];
+}
+interface ResourceAuthoringAuthorityInspector {
+  inspectAuthority(input: {
+    readonly documentUri: ResourceAuthoringDocumentUri;
+    readonly sourceShape: ResourceAuthoringSourceShape;
+    readonly authorityText: string;
+  }): ResourceAuthoringAuthorityInspection;
+}
+interface ResourceAuthoringPlanningRuntime extends ResourceAuthoringAuthorityInspector {
+  /** Long-lived authentic registry/catalog snapshot; never supplied as per-call config. */
+  readonly planningAuthority: ResourceAuthoringPlanningAuthority;
+}
+interface ResourceAuthoringPlan {
+  readonly schemaVersion: typeof RESOURCE_AUTHORING_SCHEMA_VERSION;
+  readonly proposal: ResourceAuthoringProposal;
+  readonly kindDefinition: ResourceAuthoringKindDefinition;
+  readonly catalog: ResourceAuthoringCatalogBinding;
+  readonly resources: readonly ResourceAuthoringInspectedRoot[];
+  readonly authorityDigest: string;
+  readonly planDigest: string;
+}
+interface ResourceAuthoringPreparedWrite {
+  readonly transactionId: string;
+  readonly planDigest: string;
+  readonly authorityDigestBefore: string | null;
+  readonly registryRevisionBefore: string;
+}
+interface ResourceAuthoringRefreshCandidate {
+  readonly transactionId: string;
+  readonly candidateId: string;
+  readonly targetLayerId: string;
+  readonly tree: LoadedResourceTree;
+  readonly registry: EffectiveResourceRegistry;
+  readonly layers: readonly ResourceLayerContentIdentityInput[];
+}
+interface ResourceAuthoringEffectiveOriginReceipt {
+  readonly layerId: string;
+  readonly layerIndex: number;
+  readonly packageId: string;
+  readonly documentUri: string;
+  readonly logicalPath?: string;
+}
+interface ResourceAuthoringReceipt {
+  readonly schemaVersion: typeof RESOURCE_AUTHORING_SCHEMA_VERSION;
+  readonly planDigest: string;
+  readonly transactionId: string;
+  readonly operation: ResourceAuthoringOperation;
+  readonly catalogId: string;
+  readonly resourceId: string;
+  readonly kind: string;
+  readonly apiVersion: string;
+  readonly sourceShape: ResourceAuthoringSourceShape;
+  readonly documentUri: ResourceAuthoringDocumentUri;
+  readonly authorityDigestBefore: string | null;
+  readonly authorityDigestAfter: string;
+  readonly registryRevisionBefore: string;
+  readonly registryRevisionAfter: string;
+  readonly contentDigest: string;
+  readonly effectiveOrigin: ResourceAuthoringEffectiveOriginReceipt;
+  readonly authorityResourceIds: readonly string[];
+  /** Content address of every preceding receipt field; the transaction port persists it immutably. */
+  readonly receiptDigest: string;
+}
+interface ResourceAuthoringTransactionPort {
+  loadReceipt(planDigest: string): Promise<ResourceAuthoringReceipt | undefined>;
+  prepare(input: {
+    readonly planDigest: string;
+    readonly operation: ResourceAuthoringOperation;
+    readonly documentUri: ResourceAuthoringDocumentUri;
+    readonly expected: ResourceAuthoringExpectedState;
+    readonly authorityDigest: string;
+    readonly authorityText: string;
+  }): Promise<ResourceAuthoringPreparedWrite>;
+  refreshCandidate(input: {
+    readonly transactionId: string;
+    readonly planDigest: string;
+  }): Promise<ResourceAuthoringRefreshCandidate>;
+  commit(input: {
+    readonly transactionId: string;
+    readonly candidateId: string;
+    readonly receipt: ResourceAuthoringReceipt;
+  }): Promise<ResourceAuthoringReceipt>;
+  rollback(input: {
+    readonly transactionId: string;
+    readonly planDigest: string;
+  }): Promise<void>;
+}
+interface ResourceAuthoringRuntime extends ResourceAuthoringPlanningRuntime {
+  readonly transaction: ResourceAuthoringTransactionPort;
+}
+type ApplyResourceAuthoringConfig = ResourceAuthoringPlanningConfig;
+interface ResourceAuthoringRegistryRevisionInput {
+  readonly registry: EffectiveResourceRegistry;
+  readonly layers: readonly ResourceLayerContentIdentityInput[];
+}
+type ResourceAuthoringErrorCode = "RESOURCE_AUTHORING_INPUT_INVALID" | "RESOURCE_AUTHORING_KIND_UNKNOWN" | "RESOURCE_AUTHORING_API_VERSION_UNSUPPORTED" | "RESOURCE_AUTHORING_SOURCE_SHAPE_UNSUPPORTED" | "RESOURCE_AUTHORING_CATALOG_UNKNOWN" | "RESOURCE_AUTHORING_CATALOG_MISMATCH" | "RESOURCE_AUTHORING_TARGET_UNSAFE" | "RESOURCE_AUTHORING_EXPECTED_STATE_INVALID" | "RESOURCE_AUTHORING_AUTHORITY_INVALID" | "RESOURCE_AUTHORING_PLAN_FORGED" | "RESOURCE_AUTHORING_CAS_CONFLICT" | "RESOURCE_AUTHORING_PREPARE_INVALID" | "RESOURCE_AUTHORING_REFRESH_INVALID" | "RESOURCE_AUTHORING_COMMIT_INVALID" | "RESOURCE_AUTHORING_ROLLBACK_FAILED";
+declare class ResourceAuthoringError extends Error {
+  readonly code: ResourceAuthoringErrorCode;
+  readonly cause?: unknown | undefined;
+  constructor(code: ResourceAuthoringErrorCode, message: string, cause?: unknown | undefined);
+}
+/** Derives the content-sensitive revision used by planning and CAS from canonical projections. */
+declare function deriveResourceAuthoringRegistryRevision(input: ResourceAuthoringRegistryRevisionInput): string;
+declare function planResourceAuthoring(runtime: ResourceAuthoringPlanningRuntime, input: ResourceAuthoringProposal, _config: ResourceAuthoringPlanningConfig): ResourceAuthoringPlan;
+declare function applyResourceAuthoring(runtime: ResourceAuthoringRuntime, input: ResourceAuthoringPlan, config: ApplyResourceAuthoringConfig): Promise<ResourceAuthoringReceipt>;
+//#endregion
+export { ApplyResourceAuthoringConfig, AuthoringBindings, AuthoringRuntime, Logger, RESOURCE_AUTHORING_SCHEMA_VERSION, ResourceAuthoringAuthorityInspection, ResourceAuthoringAuthorityInspector, ResourceAuthoringCatalogBinding, ResourceAuthoringDocumentUri, ResourceAuthoringEffectiveOriginReceipt, ResourceAuthoringError, ResourceAuthoringErrorCode, ResourceAuthoringExpectedAbsent, ResourceAuthoringExpectedPresent, ResourceAuthoringExpectedState, ResourceAuthoringInspectedRoot, ResourceAuthoringKindDefinition, ResourceAuthoringOperation, ResourceAuthoringPlan, ResourceAuthoringPlanningAuthority, ResourceAuthoringPlanningConfig, ResourceAuthoringPlanningRuntime, ResourceAuthoringPreparedWrite, ResourceAuthoringProposal, ResourceAuthoringReceipt, ResourceAuthoringRefreshCandidate, ResourceAuthoringRegistryRevisionInput, ResourceAuthoringRuntime, ResourceAuthoringSourceShape, ResourceAuthoringTransactionPort, RuntimeEffects, applyResourceAuthoring, createAuthoringBindings, currentRuntime, deriveResourceAuthoringRegistryRevision, invokeEffect, logger, planResourceAuthoring, runWithRuntime, runtimeAuthoringPackage };

package/dist/authoring-runtime.js

@@ -1,2 +1,2 @@
-import { a as runWithRuntime, i as logger, n as currentRuntime, o as runtimeAuthoringPackage, r as invokeEffect, t as createAuthoringBindings } from "./src-B87eJQat.js";
-export { createAuthoringBindings, currentRuntime, invokeEffect, logger, runWithRuntime, runtimeAuthoringPackage };
+import { a as runWithRuntime, c as ResourceAuthoringError, d as planResourceAuthoring, i as logger, l as applyResourceAuthoring, n as currentRuntime, o as runtimeAuthoringPackage, r as invokeEffect, s as RESOURCE_AUTHORING_SCHEMA_VERSION, t as createAuthoringBindings, u as deriveResourceAuthoringRegistryRevision } from "./src-3MZLm339.js";
+export { RESOURCE_AUTHORING_SCHEMA_VERSION, ResourceAuthoringError, applyResourceAuthoring, createAuthoringBindings, currentRuntime, deriveResourceAuthoringRegistryRevision, invokeEffect, logger, planResourceAuthoring, runWithRuntime, runtimeAuthoringPackage };

package/dist/effective-content-identities-CSVFi-N5.d.ts

@@ -0,0 +1,14 @@
+import { I as EffectiveResourceRegistry, O as ResourceDigestContribution, T as ResourceContentIdentity, n as LoadedResourceTree } from "./index-CDIT65pI.js";
+//#region ../resource-core/src/effective-content-identities.d.ts
+interface ResourceLayerContentIdentityInput {
+  readonly id: string;
+  readonly tree: LoadedResourceTree;
+}
+interface ResolveEffectiveResourceContentIdentitiesInput {
+  readonly registry: EffectiveResourceRegistry;
+  readonly layers: readonly ResourceLayerContentIdentityInput[];
+  readonly contributions?: ReadonlyMap<string, readonly ResourceDigestContribution[]>;
+}
+declare function resolveEffectiveResourceContentIdentities(input: ResolveEffectiveResourceContentIdentitiesInput): ReadonlyMap<string, ResourceContentIdentity>;
+//#endregion
+export { ResourceLayerContentIdentityInput as n, resolveEffectiveResourceContentIdentities as r, ResolveEffectiveResourceContentIdentitiesInput as t };

package/dist/effective-content-identities-DV5fTr5Q.js

@@ -0,0 +1,118 @@
+import { a as isLoadedResourceTreeAuthentic, f as ResourceCompositionError, i as readonlyMap, l as effectiveRegistryLayerBindings, p as compareCodeUnits, s as createResourceContentIdentity, u as isEffectiveRegistryAuthentic } from "./src-D3qSzGFn.js";
+//#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;
+		}
+	}
+	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: 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.`));
+	}
+	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 { resolveEffectiveResourceContentIdentities as t };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { A as ObjectTargets, B as applicationAssemblyPackage, C as ObjectOperationDefinition, D as ObjectOperationTargetDeclaration, E as ObjectOperationOwnerKind, F as ResourceSource, G as loadApplicationAssembly, H as assertObjectOperationCall, I as SkillCapsuleDependency, K as resolveApplicationAssembly, L as SkillCapsuleResource, M as ResolveApplicationAssemblyOptions, N as ResolvedAssemblyPortBinding, O as ObjectTargetKindDefinition, P as ResourceInclude, R as TextMaterial, S as ObjectOperationContractError, T as ObjectOperationHandler, U as assertObjectOperationCatalog, V as assertExecuteObjectOperationRequest, W as assertObjectOperationDefinition, _ 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, q as resourceRefToFqn, 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 TextResource } from "./index-Cqh9pEBa.js";
 import { A as buildResourceDependencySnapshot, B as ResourceTombstone, C as BuildResourceDependencySnapshotInput, D as ResourceDependencySnapshot, E as ResourceDependencyEdge, F as EffectiveResourceEntry, H as composeLayeredResourceRegistry, I as EffectiveResourceRegistry, L as ResourceLayerDescriptor, M as sha256Digest, N as ComposeLayeredResourceRegistryInput, O as ResourceDigestContribution, P as EffectiveKindDefinition, R as ResourceLayerInput, S as validateResourceTree, T as ResourceContentIdentity, U as Sha256Digest, V as ResourceTombstoneOrigin, _ as ResourceValue, a as ResourceDescriptor, b as SourceShape, c as ResourceKindContract, d as ResourceRecord, f as ResourceRegistry, g as ResourceValidationError, h as ResourceTreeBuildResult, i as RegisteredKindDefinition, j as createResourceContentIdentity, k as SnapshotResource, l as ResourceMetadata, m as ResourceTree, n as LoadedResourceTree, o as ResourceDiagnostic, p as ResourceScalar, r as LoadedResourceTreeBuildResult, s as ResourceIdentity, t as LoadResourceTreeOptions, u as ResourceNode, v as ResourceValueList, w as CreateResourceContentIdentityInput, x as loadResourceTree, y as ResourceValueMap, z as ResourceOrigin } from "./index-CDIT65pI.js";
-import { a as ResolveEffectiveResourceContentIdentitiesInput, c as ResourceCompositionError, i as readResourceMaterial, n as ResourceMaterial, o as ResourceLayerContentIdentityInput, r as ResourceMaterialError, s as resolveEffectiveResourceContentIdentities, t as ReadResourceMaterialInput } from "./resource-core-C8IonwKw.js";
+import { a as ResourceCompositionError, i as readResourceMaterial, n as ResourceMaterial, r as ResourceMaterialError, t as ReadResourceMaterialInput } from "./resource-core-C0Fj-VJA.js";
+import { n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./effective-content-identities-CSVFi-N5.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";
 //#region src/bundled-system-skills.d.ts
 declare function loadHalfcodeResourceDslSystemSkillModule(): AuthoringModuleDescriptor;

package/dist/index.js

@@ -1,7 +1,8 @@
 import { c as sha256Digest, f as ResourceCompositionError, n as loadResourceTree, o as buildResourceDependencySnapshot, r as validateResourceTree, s as createResourceContentIdentity, t as ResourceValidationError } from "./src-D3qSzGFn.js";
+import { t as resolveEffectiveResourceContentIdentities } from "./effective-content-identities-DV5fTr5Q.js";
 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-3pnDAjBD.js";
 import "./application-assembly.js";
-import { ResourceMaterialError, composeLayeredResourceRegistry, readResourceMaterial, resolveEffectiveResourceContentIdentities } from "./resource-core.js";
+import { ResourceMaterialError, composeLayeredResourceRegistry, readResourceMaterial } from "./resource-core.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";
 import { fileURLToPath } from "node:url";
 //#region src/bundled-system-skills.ts

package/dist/resource-core-C0Fj-VJA.d.ts

@@ -0,0 +1,29 @@
+import { O as ResourceDigestContribution, n as LoadedResourceTree, o as ResourceDiagnostic } from "./index-CDIT65pI.js";
+//#region ../resource-core/src/composition-error.d.ts
+declare class ResourceCompositionError extends Error {
+  readonly diagnostics: readonly ResourceDiagnostic[];
+  constructor(diagnostics: readonly ResourceDiagnostic[]);
+}
+//#endregion
+//#region ../resource-core/src/resource-material.d.ts
+interface ReadResourceMaterialInput {
+  readonly tree: LoadedResourceTree;
+  readonly rootDir: string;
+  readonly resourceId: string;
+  readonly uri: string;
+}
+interface ResourceMaterial {
+  readonly resourceId: string;
+  readonly uri: string;
+  readonly sourceUri: string;
+  readonly digest: string;
+  readonly contribution: ResourceDigestContribution;
+  bytes(): Uint8Array;
+}
+declare class ResourceMaterialError extends Error {
+  readonly diagnostics: readonly ResourceDiagnostic[];
+  constructor(diagnostics: readonly ResourceDiagnostic[]);
+}
+declare function readResourceMaterial(input: ReadResourceMaterialInput): Promise<ResourceMaterial>;
+//#endregion
+export { ResourceCompositionError as a, readResourceMaterial as i, ResourceMaterial as n, ResourceMaterialError as r, ReadResourceMaterialInput as t };

package/dist/resource-core.d.ts

@@ -1,3 +1,4 @@
 import { A as buildResourceDependencySnapshot, B as ResourceTombstone, C as BuildResourceDependencySnapshotInput, D as ResourceDependencySnapshot, E as ResourceDependencyEdge, F as EffectiveResourceEntry, H as composeLayeredResourceRegistry, I as EffectiveResourceRegistry, L as ResourceLayerDescriptor, M as sha256Digest, N as ComposeLayeredResourceRegistryInput, O as ResourceDigestContribution, P as EffectiveKindDefinition, R as ResourceLayerInput, S as validateResourceTree, T as ResourceContentIdentity, U as Sha256Digest, V as ResourceTombstoneOrigin, _ as ResourceValue, a as ResourceDescriptor, b as SourceShape, c as ResourceKindContract, d as ResourceRecord, f as ResourceRegistry, g as ResourceValidationError, h as ResourceTreeBuildResult, i as RegisteredKindDefinition, j as createResourceContentIdentity, k as SnapshotResource, l as ResourceMetadata, m as ResourceTree, n as LoadedResourceTree, o as ResourceDiagnostic, p as ResourceScalar, r as LoadedResourceTreeBuildResult, s as ResourceIdentity, t as LoadResourceTreeOptions, u as ResourceNode, v as ResourceValueList, w as CreateResourceContentIdentityInput, x as loadResourceTree, y as ResourceValueMap, z as ResourceOrigin } from "./index-CDIT65pI.js";
-import { a as ResolveEffectiveResourceContentIdentitiesInput, c as ResourceCompositionError, i as readResourceMaterial, n as ResourceMaterial, o as ResourceLayerContentIdentityInput, r as ResourceMaterialError, s as resolveEffectiveResourceContentIdentities, t as ReadResourceMaterialInput } from "./resource-core-C8IonwKw.js";
+import { a as ResourceCompositionError, i as readResourceMaterial, n as ResourceMaterial, r as ResourceMaterialError, t as ReadResourceMaterialInput } from "./resource-core-C0Fj-VJA.js";
+import { n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./effective-content-identities-CSVFi-N5.js";
 export { BuildResourceDependencySnapshotInput, ComposeLayeredResourceRegistryInput, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, LoadResourceTreeOptions, LoadedResourceTree, LoadedResourceTreeBuildResult, ReadResourceMaterialInput, RegisteredKindDefinition, ResolveEffectiveResourceContentIdentitiesInput, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMaterial, ResourceMaterialError, ResourceMetadata, ResourceNode, ResourceOrigin, ResourceRecord, ResourceRegistry, ResourceScalar, ResourceTombstone, ResourceTombstoneOrigin, ResourceTree, ResourceTreeBuildResult, ResourceValidationError, ResourceValue, ResourceValueList, ResourceValueMap, type Sha256Digest, SnapshotResource, SourceShape, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadResourceTree, readResourceMaterial, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };

package/dist/resource-core.js

@@ -1,4 +1,5 @@
-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-D3qSzGFn.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
@@ -12,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);
@@ -29,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();
@@ -75,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);
@@ -89,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);
@@ -100,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);
@@ -124,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);
@@ -140,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({
@@ -301,122 +302,9 @@ function compareOrigins(left, right) {
 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: [...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;
-		}
-	}
-	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: 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.`));
-	}
-	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$1(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$1(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,
@@ -424,11 +312,8 @@ function diagnostic(code, location, message) {
 		message
 	});
 }
-function layerLocation(index, layerId, resourceId) {
-	return `content-layer:${index ?? "unknown"}:${layerId}${resourceId === void 0 ? "" : `:${resourceId}`}`;
-}
-function contentLocation(resourceId) {
-	return `content:${resourceId || "unnamed"}`;
+function layerLocation(index, layerId, subject) {
+	return `layer:${index}:${layerId ?? "unnamed"}${subject === void 0 ? "" : `:${subject}`}`;
 }
 //#endregion
 //#region ../resource-core/src/resource-material.ts