halfcode-compiler.xnl 0.2.7 → 0.2.9

package/dist/application-assembly.js

@@ -1,2 +1,2 @@
-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-D2au7Wcj.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";
 export { ObjectOperationContractError, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };

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/{resource-core-zEONBZ_o.d.ts → effective-content-identities-CSVFi-N5.d.ts}

@@ -1,10 +1,4 @@
-import { G as EffectiveResourceRegistry, L as ResourceDigestContribution, P as ResourceContentIdentity, n as LoadedResourceTree, o as ResourceDiagnostic } from "./index-CEJBgfBZ.js";
-//#region ../resource-core/src/composition-error.d.ts
-declare class ResourceCompositionError extends Error {
-  readonly diagnostics: readonly ResourceDiagnostic[];
-  constructor(diagnostics: readonly ResourceDiagnostic[]);
-}
-//#endregion
+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;
@@ -17,4 +11,4 @@ interface ResolveEffectiveResourceContentIdentitiesInput {
 }
 declare function resolveEffectiveResourceContentIdentities(input: ResolveEffectiveResourceContentIdentitiesInput): ReadonlyMap<string, ResourceContentIdentity>;
 //#endregion
-export { ResourceCompositionError as i, ResourceLayerContentIdentityInput as n, resolveEffectiveResourceContentIdentities as r, ResolveEffectiveResourceContentIdentitiesInput as t };
+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-X6R_4lMW.d.ts → index-B515mMkO.d.ts}

@@ -1,5 +1,5 @@
 import { t as ApplicationAssembly } from "./index-Cqh9pEBa.js";
-import { t as ResourceRegistry } from "./index-DkqggaxV.js";
+import { t as ResourceRegistry } from "./index-CF4nEkOi.js";
 //#region ../compiler-skill/src/index.d.ts
 interface SkillDescriptor {
   name: string;

package/dist/{index-CEJBgfBZ.d.ts → index-CDIT65pI.d.ts}

@@ -103,38 +103,8 @@ declare function sha256Digest(value: string | Uint8Array): Sha256Digest;
 declare function createResourceContentIdentity(input: CreateResourceContentIdentityInput): ResourceContentIdentity;
 declare function buildResourceDependencySnapshot(input: BuildResourceDependencySnapshotInput): ResourceDependencySnapshot;
 //#endregion
-//#region ../resource-core/src/code-package.d.ts
-declare const CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY = "code-binding:module";
-interface CodePackageBinding {
-  readonly resourceId: string;
-  readonly moduleUri: string;
-  readonly exportName?: string;
-}
-interface LoadedCodePackageModule {
-  readonly resourceId: string;
-  readonly binding: CodePackageBinding;
-  readonly revision: string;
-  readonly moduleNamespace: Readonly<Record<string, unknown>>;
-}
-interface LoadCodePackageModuleInput {
-  readonly tree: LoadedResourceTree;
-  readonly resourceId: string;
-  readonly rootDir: string;
-}
-interface CodePackageExportContract<T> {
-  isDefinition(value: unknown): value is T;
-  identityOf(value: T): string;
-}
-declare class CodePackageLoadError extends Error {
-  readonly diagnostics: readonly ResourceDiagnostic[];
-  constructor(diagnostics: readonly ResourceDiagnostic[]);
-}
-declare function loadCodePackageModule(input: LoadCodePackageModuleInput): Promise<LoadedCodePackageModule>;
-declare function admitCodePackageExports<T>(loaded: LoadedCodePackageModule, contract: CodePackageExportContract<T>): readonly T[];
-declare function admitCodePackages<T>(loaded: readonly LoadedCodePackageModule[], contract: CodePackageExportContract<T>): readonly T[];
-//#endregion
 //#region ../resource-core/src/index.d.ts
-type SourceShape = "single-file" | "directory" | "manifest" | "code-package";
+type SourceShape = "single-file" | "directory" | "manifest";
 interface ResourceIdentity {
   kind: string;
   fqn?: string;
@@ -194,7 +164,6 @@ interface ResourceTree {
 }
 interface LoadedResourceTree extends ResourceTree {
   readonly contentIdentities: ReadonlyMap<string, ResourceContentIdentity>;
-  readonly codePackageBindings: ReadonlyMap<string, CodePackageBinding>;
 }
 interface ResourceDiagnostic {
   code: string;
@@ -220,4 +189,4 @@ declare class ResourceValidationError extends Error {
 declare function loadResourceTree(options: LoadResourceTreeOptions): Promise<LoadedResourceTree>;
 declare function validateResourceTree(options: LoadResourceTreeOptions): Promise<ResourceDiagnostic[]>;
 //#endregion
-export { admitCodePackages as A, createResourceContentIdentity as B, CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY as C, LoadCodePackageModuleInput as D, CodePackageLoadError as E, ResourceDependencyEdge as F, EffectiveResourceRegistry as G, ComposeLayeredResourceRegistryInput as H, ResourceDependencySnapshot as I, ResourceOrigin as J, ResourceLayerDescriptor as K, ResourceDigestContribution as L, BuildResourceDependencySnapshotInput as M, CreateResourceContentIdentityInput as N, LoadedCodePackageModule as O, ResourceContentIdentity as P, Sha256Digest as Q, SnapshotResource as R, validateResourceTree as S, CodePackageExportContract as T, EffectiveKindDefinition as U, sha256Digest as V, EffectiveResourceEntry as W, ResourceTombstoneOrigin as X, ResourceTombstone as Y, composeLayeredResourceRegistry as Z, ResourceValue as _, ResourceDescriptor as a, SourceShape as b, ResourceKindContract as c, ResourceRecord as d, ResourceRegistry as f, ResourceValidationError as g, ResourceTreeBuildResult as h, RegisteredKindDefinition as i, loadCodePackageModule as j, admitCodePackageExports as k, ResourceMetadata as l, ResourceTree as m, LoadedResourceTree as n, ResourceDiagnostic as o, ResourceScalar as p, ResourceLayerInput as q, LoadedResourceTreeBuildResult as r, ResourceIdentity as s, LoadResourceTreeOptions as t, ResourceNode as u, ResourceValueList as v, CodePackageBinding as w, loadResourceTree as x, ResourceValueMap as y, buildResourceDependencySnapshot as z };
+export { buildResourceDependencySnapshot as A, ResourceTombstone as B, BuildResourceDependencySnapshotInput as C, ResourceDependencySnapshot as D, ResourceDependencyEdge as E, EffectiveResourceEntry as F, composeLayeredResourceRegistry as H, EffectiveResourceRegistry as I, ResourceLayerDescriptor as L, sha256Digest as M, ComposeLayeredResourceRegistryInput as N, ResourceDigestContribution as O, EffectiveKindDefinition as P, ResourceLayerInput as R, validateResourceTree as S, ResourceContentIdentity as T, Sha256Digest as U, ResourceTombstoneOrigin as V, ResourceValue as _, ResourceDescriptor as a, SourceShape as b, ResourceKindContract as c, ResourceRecord as d, ResourceRegistry as f, ResourceValidationError as g, ResourceTreeBuildResult as h, RegisteredKindDefinition as i, createResourceContentIdentity as j, SnapshotResource as k, ResourceMetadata as l, ResourceTree as m, LoadedResourceTree as n, ResourceDiagnostic as o, ResourceScalar as p, LoadedResourceTreeBuildResult as r, ResourceIdentity as s, LoadResourceTreeOptions as t, ResourceNode as u, ResourceValueList as v, CreateResourceContentIdentityInput as w, loadResourceTree as x, ResourceValueMap as y, ResourceOrigin as z };

package/dist/{index-DkqggaxV.d.ts → index-CF4nEkOi.d.ts}

@@ -1,4 +1,4 @@
-import { a as ResourceDescriptor } from "./index-CEJBgfBZ.js";
+import { a as ResourceDescriptor } from "./index-CDIT65pI.js";
 //#region ../resource-projection/src/index.d.ts
 interface ResourceRegistry {
   readonly byKind: ReadonlyMap<string, readonly ResourceDescriptor[]>;

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 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 admitCodePackages, B as createResourceContentIdentity, C as CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, D as LoadCodePackageModuleInput, E as CodePackageLoadError, F as ResourceDependencyEdge, G as EffectiveResourceRegistry, H as ComposeLayeredResourceRegistryInput, I as ResourceDependencySnapshot, J as ResourceOrigin, K as ResourceLayerDescriptor, L as ResourceDigestContribution, M as BuildResourceDependencySnapshotInput, N as CreateResourceContentIdentityInput, O as LoadedCodePackageModule, P as ResourceContentIdentity, Q as Sha256Digest, R as SnapshotResource, S as validateResourceTree, T as CodePackageExportContract, U as EffectiveKindDefinition, V as sha256Digest, W as EffectiveResourceEntry, X as ResourceTombstoneOrigin, Y as ResourceTombstone, Z as composeLayeredResourceRegistry, _ 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 loadCodePackageModule, k as admitCodePackageExports, l as ResourceMetadata, m as ResourceTree, n as LoadedResourceTree, o as ResourceDiagnostic, p as ResourceScalar, q as ResourceLayerInput, r as LoadedResourceTreeBuildResult, s as ResourceIdentity, t as LoadResourceTreeOptions, u as ResourceNode, v as ResourceValueList, w as CodePackageBinding, x as loadResourceTree, y as ResourceValueMap, z as buildResourceDependencySnapshot } from "./index-CEJBgfBZ.js";
-import { i as ResourceCompositionError, n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./resource-core-zEONBZ_o.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 { 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 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;
 declare function loadHalfcodeResourceDslSystemSkillPlan(): Promise<SkillCapsuleDistributionPlan>;
 //#endregion
-export { type ApplicationAssembly, type ApplicationScope, ApplySkillCapsuleDistributionOptions, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, type AuthoringModuleDescriptor, BuildResourceDependencySnapshotInput, type BusinessObjectResource, type BusinessObjectSopResource, CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, type CodeBinding, type CodePackageBinding, type CodePackageExportContract, CodePackageLoadError, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, ComposeLayeredResourceRegistryInput, type ContractedCallableResource, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, type ExecuteObjectOperationRequest, type JsonObject, type JsonPrimitive, type JsonValue, type LoadApplicationAssemblyOptions, type LoadCodePackageModuleInput, LoadResourceTreeOptions, type LoadedCodePackageModule, LoadedResourceTree, LoadedResourceTreeBuildResult, type ObjectInvocation, type ObjectInvocationMode, type ObjectOperationBehavior, type ObjectOperationCall, type ObjectOperationCatalog, type ObjectOperationConfig, ObjectOperationContractError, type ObjectOperationDefinition, type ObjectOperationEffect, type ObjectOperationHandler, type ObjectOperationOwnerKind, type ObjectOperationTargetDeclaration, type ObjectTargetKindDefinition, type ObjectTargetRef, type ObjectTargets, type PageObjectResource, PlanSkillCapsuleDistributionInput, PlannedSkillCapsule, PlannedSkillFile, RegisteredKindDefinition, type ResolveApplicationAssemblyOptions, ResolveEffectiveResourceContentIdentitiesInput, type ResolvedAssemblyPortBinding, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, type ResourceInclude, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMetadata, ResourceNode, ResourceOrigin, ResourceRecord, ResourceRegistry, ResourceScalar, type ResourceSource, ResourceTombstone, ResourceTombstoneOrigin, ResourceTree, ResourceTreeBuildResult, ResourceValidationError, ResourceValue, ResourceValueList, ResourceValueMap, type Sha256Digest, SkillCapsuleApplyStep, SkillCapsuleContentDigest, type SkillCapsuleDependency, SkillCapsuleDistributionError, SkillCapsuleDistributionPlan, SkillCapsuleDistributionReceipt, SkillCapsuleIdentity, SkillCapsulePlan, SkillCapsuleProvenanceManifest, type SkillCapsuleResource, SkillDescriptor, SkillReference, SnapshotResource, SourceShape, type TextMaterial, type TextResource, admitCodePackageExports, admitCodePackages, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, loadCodePackageModule, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, planSkillCapsuleDistribution, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree };
+export { type ApplicationAssembly, type ApplicationScope, ApplySkillCapsuleDistributionOptions, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, type AuthoringModuleDescriptor, BuildResourceDependencySnapshotInput, type BusinessObjectResource, type BusinessObjectSopResource, type CodeBinding, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, ComposeLayeredResourceRegistryInput, type ContractedCallableResource, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, type ExecuteObjectOperationRequest, type JsonObject, type JsonPrimitive, type JsonValue, type LoadApplicationAssemblyOptions, LoadResourceTreeOptions, LoadedResourceTree, LoadedResourceTreeBuildResult, type ObjectInvocation, type ObjectInvocationMode, type ObjectOperationBehavior, type ObjectOperationCall, type ObjectOperationCatalog, type ObjectOperationConfig, ObjectOperationContractError, type ObjectOperationDefinition, type ObjectOperationEffect, type ObjectOperationHandler, type ObjectOperationOwnerKind, type ObjectOperationTargetDeclaration, type ObjectTargetKindDefinition, type ObjectTargetRef, type ObjectTargets, type PageObjectResource, PlanSkillCapsuleDistributionInput, PlannedSkillCapsule, PlannedSkillFile, ReadResourceMaterialInput, RegisteredKindDefinition, type ResolveApplicationAssemblyOptions, ResolveEffectiveResourceContentIdentitiesInput, type ResolvedAssemblyPortBinding, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, type ResourceInclude, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMaterial, ResourceMaterialError, ResourceMetadata, ResourceNode, ResourceOrigin, ResourceRecord, ResourceRegistry, ResourceScalar, type ResourceSource, ResourceTombstone, ResourceTombstoneOrigin, ResourceTree, ResourceTreeBuildResult, ResourceValidationError, ResourceValue, ResourceValueList, ResourceValueMap, type Sha256Digest, SkillCapsuleApplyStep, SkillCapsuleContentDigest, type SkillCapsuleDependency, SkillCapsuleDistributionError, SkillCapsuleDistributionPlan, SkillCapsuleDistributionReceipt, SkillCapsuleIdentity, SkillCapsulePlan, SkillCapsuleProvenanceManifest, type SkillCapsuleResource, SkillDescriptor, SkillReference, SnapshotResource, SourceShape, type TextMaterial, type TextResource, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, planSkillCapsuleDistribution, readResourceMaterial, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree };

package/dist/index.js

@@ -1,8 +1,9 @@
-import { _ as ResourceCompositionError, a as CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, c as admitCodePackages, d as buildResourceDependencySnapshot, f as createResourceContentIdentity, l as loadCodePackageModule, n as loadResourceTree, o as CodePackageLoadError, p as sha256Digest, r as validateResourceTree, s as admitCodePackageExports, t as ResourceValidationError } from "./src-88_zDKZE.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-D2au7Wcj.js";
+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 { composeLayeredResourceRegistry, resolveEffectiveResourceContentIdentities } 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-BxyKIkBg.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
 function loadHalfcodeResourceDslSystemSkillModule() {
@@ -20,4 +21,4 @@ async function loadHalfcodeResourceDslSystemSkillPlan() {
 	return bundled.default;
 }
 //#endregion
-export { CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, CodePackageLoadError, ObjectOperationContractError, ResourceCompositionError, ResourceValidationError, SkillCapsuleDistributionError, admitCodePackageExports, admitCodePackages, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, loadCodePackageModule, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, planSkillCapsuleDistribution, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree };
+export { ObjectOperationContractError, ResourceCompositionError, ResourceMaterialError, ResourceValidationError, SkillCapsuleDistributionError, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, planSkillCapsuleDistribution, readResourceMaterial, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree };

package/dist/kind-definition.d.ts

@@ -1,4 +1,4 @@
-import { a as ResourceDescriptor, c as ResourceKindContract } from "./index-CEJBgfBZ.js";
+import { a as ResourceDescriptor, c as ResourceKindContract } from "./index-CDIT65pI.js";
 //#region ../kind-definition/src/index.d.ts
 interface KindDefinition extends ResourceDescriptor, ResourceKindContract {
   kind: "KindDefinition";

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 admitCodePackages, B as createResourceContentIdentity, C as CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, D as LoadCodePackageModuleInput, E as CodePackageLoadError, F as ResourceDependencyEdge, G as EffectiveResourceRegistry, H as ComposeLayeredResourceRegistryInput, I as ResourceDependencySnapshot, J as ResourceOrigin, K as ResourceLayerDescriptor, L as ResourceDigestContribution, M as BuildResourceDependencySnapshotInput, N as CreateResourceContentIdentityInput, O as LoadedCodePackageModule, P as ResourceContentIdentity, Q as Sha256Digest, R as SnapshotResource, S as validateResourceTree, T as CodePackageExportContract, U as EffectiveKindDefinition, V as sha256Digest, W as EffectiveResourceEntry, X as ResourceTombstoneOrigin, Y as ResourceTombstone, Z as composeLayeredResourceRegistry, _ 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 loadCodePackageModule, k as admitCodePackageExports, l as ResourceMetadata, m as ResourceTree, n as LoadedResourceTree, o as ResourceDiagnostic, p as ResourceScalar, q as ResourceLayerInput, r as LoadedResourceTreeBuildResult, s as ResourceIdentity, t as LoadResourceTreeOptions, u as ResourceNode, v as ResourceValueList, w as CodePackageBinding, x as loadResourceTree, y as ResourceValueMap, z as buildResourceDependencySnapshot } from "./index-CEJBgfBZ.js";
-import { i as ResourceCompositionError, n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./resource-core-zEONBZ_o.js";
-export { BuildResourceDependencySnapshotInput, CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, type CodePackageBinding, type CodePackageExportContract, CodePackageLoadError, ComposeLayeredResourceRegistryInput, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, type LoadCodePackageModuleInput, LoadResourceTreeOptions, type LoadedCodePackageModule, LoadedResourceTree, LoadedResourceTreeBuildResult, RegisteredKindDefinition, ResolveEffectiveResourceContentIdentitiesInput, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMetadata, ResourceNode, ResourceOrigin, ResourceRecord, ResourceRegistry, ResourceScalar, ResourceTombstone, ResourceTombstoneOrigin, ResourceTree, ResourceTreeBuildResult, ResourceValidationError, ResourceValue, ResourceValueList, ResourceValueMap, type Sha256Digest, SnapshotResource, SourceShape, admitCodePackageExports, admitCodePackages, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadCodePackageModule, loadResourceTree, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };
+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 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 };