halfcode-compiler.xnl 0.2.3 → 0.2.5

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-DRIws6tY.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-BxwHmx6r.js";
 export { ObjectOperationContractError, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };

package/dist/{index-96qHPZj2.d.ts → index-D7UtYNm7.d.ts}

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

package/dist/{index-DdRHFKSQ.d.ts → index-DihSfO7X.d.ts}

@@ -103,8 +103,38 @@ 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";
+type SourceShape = "single-file" | "directory" | "manifest" | "code-package";
 interface ResourceIdentity {
   kind: string;
   fqn?: string;
@@ -164,6 +194,7 @@ interface ResourceTree {
 }
 interface LoadedResourceTree extends ResourceTree {
   readonly contentIdentities: ReadonlyMap<string, ResourceContentIdentity>;
+  readonly codePackageBindings: ReadonlyMap<string, CodePackageBinding>;
 }
 interface ResourceDiagnostic {
   code: string;
@@ -189,4 +220,4 @@ declare class ResourceValidationError extends Error {
 declare function loadResourceTree(options: LoadResourceTreeOptions): Promise<LoadedResourceTree>;
 declare function validateResourceTree(options: LoadResourceTreeOptions): Promise<ResourceDiagnostic[]>;
 //#endregion
-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 };
+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 };

package/dist/{index-D2mpux6L.d.ts → index-DjvNDidT.d.ts}

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

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 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-DdRHFKSQ.js";
-import { i as ResourceCompositionError, n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./resource-core-Byhqyadq.js";
-import { S as skillCapsuleDistributionProjection, _ as applySkillCapsuleDistributionPlan, a as PlannedSkillCapsule, b as compilerSkillPackage, c as SkillCapsuleContentDigest, d as SkillCapsuleDistributionReceipt, f as SkillCapsuleIdentity, g as SkillReference, h as SkillDescriptor, i as PlanSkillCapsuleDistributionInput, l as SkillCapsuleDistributionError, m as SkillCapsuleProvenanceManifest, n as CompileResourceSkillCapsuleInput, o as PlannedSkillFile, p as SkillCapsulePlan, r as CompileSkillCapsuleInput, s as SkillCapsuleApplyStep, t as ApplySkillCapsuleDistributionOptions, u as SkillCapsuleDistributionPlan, v as compileResourceSkillCapsule, x as planSkillCapsuleDistribution, y as compileSkillCapsule } from "./index-96qHPZj2.js";
+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-DihSfO7X.js";
+import { i as ResourceCompositionError, n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./resource-core-UAvFx3m-.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-D7UtYNm7.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, 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, 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, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, 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, 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 };

package/dist/index.js

@@ -1,8 +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-DCRih45n.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-DRIws6tY.js";
+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-BGFskWEk.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-BxwHmx6r.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-D1Bmq7Lo.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-BJ5cQQ7P.js";
 import { fileURLToPath } from "node:url";
 //#region src/bundled-system-skills.ts
 function loadHalfcodeResourceDslSystemSkillModule() {
@@ -20,4 +20,4 @@ async function loadHalfcodeResourceDslSystemSkillPlan() {
 	return bundled.default;
 }
 //#endregion
-export { ObjectOperationContractError, ResourceCompositionError, ResourceValidationError, SkillCapsuleDistributionError, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, planSkillCapsuleDistribution, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree };
+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 };

package/dist/kind-definition.d.ts

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

package/dist/{resource-core-Byhqyadq.d.ts → resource-core-UAvFx3m-.d.ts}

@@ -1,4 +1,4 @@
-import { I as EffectiveResourceRegistry, O as ResourceDigestContribution, T as ResourceContentIdentity, n as LoadedResourceTree, o as ResourceDiagnostic } from "./index-DdRHFKSQ.js";
+import { G as EffectiveResourceRegistry, L as ResourceDigestContribution, P as ResourceContentIdentity, n as LoadedResourceTree, o as ResourceDiagnostic } from "./index-DihSfO7X.js";
 //#region ../resource-core/src/composition-error.d.ts
 declare class ResourceCompositionError extends Error {
   readonly diagnostics: readonly ResourceDiagnostic[];

package/dist/resource-core.d.ts

@@ -1,3 +1,3 @@
-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-DdRHFKSQ.js";
-import { i as ResourceCompositionError, n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./resource-core-Byhqyadq.js";
-export { BuildResourceDependencySnapshotInput, ComposeLayeredResourceRegistryInput, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, LoadResourceTreeOptions, 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, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadResourceTree, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };
+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-DihSfO7X.js";
+import { i as ResourceCompositionError, n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./resource-core-UAvFx3m-.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 };

package/dist/resource-core.js

@@ -1,4 +1,4 @@
-import { a as isLoadedResourceTreeAuthentic, c as sha256Digest, d as markEffectiveRegistryAuthentic, f as ResourceCompositionError, i as readonlyMap, l as effectiveRegistryLayerBindings, m as digestCanonical, n as loadResourceTree, o as buildResourceDependencySnapshot, p as compareCodeUnits, r as validateResourceTree, s as createResourceContentIdentity, t as ResourceValidationError, u as isEffectiveRegistryAuthentic } from "./src-DCRih45n.js";
+import { _ as ResourceCompositionError, a as CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, c as admitCodePackages, d as buildResourceDependencySnapshot, f as createResourceContentIdentity, g as markEffectiveRegistryAuthentic, h as isEffectiveRegistryAuthentic, i as readonlyMap, l as loadCodePackageModule, m as effectiveRegistryLayerBindings, n as loadResourceTree, o as CodePackageLoadError, p as sha256Digest, r as validateResourceTree, s as admitCodePackageExports, t as ResourceValidationError, u as isLoadedResourceTreeAuthentic, v as compareCodeUnits, y as digestCanonical } from "./src-BGFskWEk.js";
 //#region ../resource-core/src/layered-registry.ts
 function composeLayeredResourceRegistry(input) {
 	const diagnostics = [];
@@ -368,7 +368,7 @@ function resolveEffectiveResourceContentIdentities(input) {
 			const identity = createResourceContentIdentity({
 				resourceId: entry.resourceId,
 				authorityDigest: authorityIdentity.authorityDigest,
-				contributions: input.contributions?.get(entry.resourceId) ?? []
+				contributions: [...authorityIdentity.contributions, ...input.contributions?.get(entry.resourceId) ?? []]
 			});
 			output.push([entry.resourceId, identity]);
 		} catch (error) {
@@ -391,7 +391,7 @@ function validateLoadedIdentityCoverage(tree, layerId, diagnostics) {
 		const normalized = createResourceContentIdentity({
 			resourceId: identity.resourceId,
 			authorityDigest: identity.authorityDigest,
-			contributions: []
+			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.`));
 	}
@@ -429,4 +429,4 @@ function contentLocation(resourceId) {
 	return `content:${resourceId || "unnamed"}`;
 }
 //#endregion
-export { ResourceCompositionError, ResourceValidationError, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadResourceTree, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };
+export { CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY, CodePackageLoadError, ResourceCompositionError, ResourceValidationError, admitCodePackageExports, admitCodePackages, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadCodePackageModule, loadResourceTree, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };

package/dist/resource-projection.d.ts

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

package/dist/skill-capsule.d.ts

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

package/dist/skill-capsule.js

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

package/dist/{src-DCRih45n.js → src-BGFskWEk.js}

@@ -1,7 +1,9 @@
 import { n as wordToString, t as parseXnl } from "./dist-Bkv7YeVi.js";
-import { readFile, readdir, realpath, stat } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { mkdtemp, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
 //#region ../resource-core/src/canonical.ts
 function compareCodeUnits(left, right) {
 	if (left < right) return -1;
@@ -72,17 +74,17 @@ function createResourceContentIdentity(input) {
 		strictCanonicalInput: false,
 		validateClaimedDigest: false
 	});
-	if (diagnostics.length > 0 || !identity) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
+	if (diagnostics.length > 0 || !identity) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
 	return identity;
 }
 function buildResourceDependencySnapshot(input) {
 	const diagnostics = [];
-	if (!isEffectiveRegistryAuthentic(input.registry) || input.registry.revision !== input.registry.compositionRevision) throw new ResourceCompositionError(Object.freeze([diagnostic("RESOURCE_EFFECTIVE_REGISTRY_UNTRUSTED", "effective-registry:revision", "Dependency snapshots require an authentic immutable registry returned by composeLayeredResourceRegistry().")]));
+	if (!isEffectiveRegistryAuthentic(input.registry) || input.registry.revision !== input.registry.compositionRevision) throw new ResourceCompositionError(Object.freeze([diagnostic$1("RESOURCE_EFFECTIVE_REGISTRY_UNTRUSTED", "effective-registry:revision", "Dependency snapshots require an authentic immutable registry returned by composeLayeredResourceRegistry().")]));
 	const roots = validateRoots(input.roots, input.registry, diagnostics);
 	const edges = validateEdges(input.edges, input.registry, diagnostics);
 	validateContentIdentityIndex(input.contentIdentities, diagnostics);
 	const validatedIdentities = validateEffectiveContentIdentities(input.registry, input.contentIdentities, diagnostics);
-	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
 	const registryRevision = digestCanonical({
 		compositionRevision: input.registry.compositionRevision,
 		resources: [...validatedIdentities.values()].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)).map((identity) => ({
@@ -106,7 +108,7 @@ function buildResourceDependencySnapshot(input) {
 		if (visiting.has(resourceId)) {
 			const cycleStart = path.indexOf(resourceId);
 			const cycle = [...path.slice(cycleStart), resourceId];
-			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_CYCLE", dependencyLocation(resourceId), `Resource dependency cycle detected: ${cycle.join(" -> ")}.`));
+			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_CYCLE", dependencyLocation(resourceId), `Resource dependency cycle detected: ${cycle.join(" -> ")}.`));
 			return;
 		}
 		if (visited.has(resourceId)) return;
@@ -122,7 +124,7 @@ function buildResourceDependencySnapshot(input) {
 		visited.add(resourceId);
 	};
 	for (const root of roots) visit(root);
-	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
 	const closure = Object.freeze([...reachable].sort(compareCodeUnits).map((resourceId) => {
 		const entry = input.registry.byId.get(resourceId);
 		const identity = validatedIdentities.get(resourceId);
@@ -160,19 +162,19 @@ function validateRoots(inputRoots, registry, diagnostics) {
 	for (const value of inputRoots) {
 		const resourceId = value.trim();
 		if (resourceId.length === 0) {
-			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOT_EMPTY", "dependency-root:unnamed", "Dependency snapshot roots must be non-empty resource ids."));
+			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOT_EMPTY", "dependency-root:unnamed", "Dependency snapshot roots must be non-empty resource ids."));
 			continue;
 		}
 		if (seen.has(resourceId)) {
-			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOT_DUPLICATE", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is declared more than once.`));
+			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOT_DUPLICATE", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is declared more than once.`));
 			continue;
 		}
 		seen.add(resourceId);
 		roots.push(resourceId);
 		const entry = registry.byId.get(resourceId);
-		if (!entry || !entry.resource) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOT_MISSING", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is not an effective resource.`));
+		if (!entry || !entry.resource) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOT_MISSING", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is not an effective resource.`));
 	}
-	if (roots.length === 0 && diagnostics.length === 0) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOTS_EMPTY", "dependency-root:none", "Dependency snapshot requires at least one explicit root."));
+	if (roots.length === 0 && diagnostics.length === 0) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOTS_EMPTY", "dependency-root:none", "Dependency snapshot requires at least one explicit root."));
 	return roots;
 }
 function validateEdges(inputEdges, registry, diagnostics) {
@@ -185,13 +187,13 @@ function validateEdges(inputEdges, registry, diagnostics) {
 			declaredBy: inputEdge.declaredBy.trim()
 		});
 		if (!edge.fromResourceId || !edge.toResourceId || !edge.relation || !edge.declaredBy) {
-			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_EDGE_INVALID", `dependency-edge:${index}`, "Dependency edges require non-empty fromResourceId, toResourceId, relation, and declaredBy fields."));
+			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_EDGE_INVALID", `dependency-edge:${index}`, "Dependency edges require non-empty fromResourceId, toResourceId, relation, and declaredBy fields."));
 			return;
 		}
 		const source = registry.byId.get(edge.fromResourceId);
 		const target = registry.byId.get(edge.toResourceId);
-		if (!source?.resource) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_SOURCE_MISSING", dependencyLocation(edge.fromResourceId), `Dependency edge source '${edge.fromResourceId}' is not an effective resource.`));
-		if (!target?.resource) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_TARGET_MISSING", dependencyLocation(edge.toResourceId), `Dependency edge target '${edge.toResourceId}' is not an effective resource.`));
+		if (!source?.resource) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_SOURCE_MISSING", dependencyLocation(edge.fromResourceId), `Dependency edge source '${edge.fromResourceId}' is not an effective resource.`));
+		if (!target?.resource) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_TARGET_MISSING", dependencyLocation(edge.toResourceId), `Dependency edge target '${edge.toResourceId}' is not an effective resource.`));
 		values.set(edgeKey(edge), edge);
 	});
 	return [...values.values()].sort(compareEdges);
@@ -199,41 +201,41 @@ function validateEdges(inputEdges, registry, diagnostics) {
 function normalizeContentIdentity(input, diagnostics, options) {
 	const initialDiagnosticCount = diagnostics.length;
 	if (!isRecord(input)) {
-		diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_INVALID", contentLocation(""), "Resource content identity must be an object fact."));
+		diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_INVALID", contentLocation(""), "Resource content identity must be an object fact."));
 		return;
 	}
 	const rawResourceId = input.resourceId;
 	const resourceId = typeof rawResourceId === "string" ? rawResourceId.trim() : "";
-	if (resourceId.length === 0) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_ID_EMPTY", contentLocation(""), "Resource content identity requires a non-empty resource id."));
-	else if (options.strictCanonicalInput && rawResourceId !== resourceId) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_NON_CANONICAL", contentLocation(resourceId), `Resource content identity '${resourceId}' must use its canonical id without surrounding whitespace.`));
+	if (resourceId.length === 0) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_ID_EMPTY", contentLocation(""), "Resource content identity requires a non-empty resource id."));
+	else if (options.strictCanonicalInput && rawResourceId !== resourceId) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_NON_CANONICAL", contentLocation(resourceId), `Resource content identity '${resourceId}' must use its canonical id without surrounding whitespace.`));
 	const authorityDigest = typeof input.authorityDigest === "string" ? input.authorityDigest : "";
-	if (!isSha256Digest(authorityDigest)) diagnostics.push(diagnostic("RESOURCE_CONTENT_AUTHORITY_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has an invalid authority digest.`));
+	if (!isSha256Digest(authorityDigest)) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_AUTHORITY_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has an invalid authority digest.`));
 	const rawContributions = input.contributions;
 	let contributionFacts = [];
 	if (rawContributions === void 0 && !options.requireContributions) contributionFacts = [];
-	else if (!Array.isArray(rawContributions)) diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTIONS_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' must provide an explicit digest contribution array.`));
+	else if (!Array.isArray(rawContributions)) diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTIONS_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' must provide an explicit digest contribution array.`));
 	else contributionFacts = rawContributions;
 	const contributions = /* @__PURE__ */ new Map();
 	for (const fact of contributionFacts) {
 		if (!isRecord(fact)) {
-			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a non-object digest contribution.`));
+			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a non-object digest contribution.`));
 			continue;
 		}
 		const rawKey = fact.key;
 		const key = typeof rawKey === "string" ? rawKey.trim() : "";
 		if (key.length === 0) {
-			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_KEY_EMPTY", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a digest contribution with an empty key.`));
+			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_KEY_EMPTY", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a digest contribution with an empty key.`));
 			continue;
 		}
-		if (options.strictCanonicalInput && rawKey !== key) diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_NON_CANONICAL", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' must use its canonical key.`));
+		if (options.strictCanonicalInput && rawKey !== key) diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_NON_CANONICAL", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' must use its canonical key.`));
 		const digest = typeof fact.digest === "string" ? fact.digest : "";
 		if (!isSha256Digest(digest)) {
-			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is invalid.`));
+			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is invalid.`));
 			continue;
 		}
 		const sourceUri = fact.sourceUri;
 		if (sourceUri !== void 0 && typeof sourceUri !== "string") {
-			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_SOURCE_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' has an invalid source URI.`));
+			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_SOURCE_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' has an invalid source URI.`));
 			continue;
 		}
 		const contribution = Object.freeze({
@@ -244,7 +246,7 @@ function normalizeContentIdentity(input, diagnostics, options) {
 		const current = contributions.get(key);
 		if (current) {
 			const conflicting = current.digest !== digest;
-			diagnostics.push(diagnostic(conflicting ? "RESOURCE_DIGEST_CONTRIBUTION_CONFLICT" : "RESOURCE_DIGEST_CONTRIBUTION_DUPLICATE", contentLocation(resourceId, key), conflicting ? `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' has conflicting digests.` : `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is declared more than once.`));
+			diagnostics.push(diagnostic$1(conflicting ? "RESOURCE_DIGEST_CONTRIBUTION_CONFLICT" : "RESOURCE_DIGEST_CONTRIBUTION_DUPLICATE", contentLocation(resourceId, key), conflicting ? `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' has conflicting digests.` : `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is declared more than once.`));
 			continue;
 		}
 		contributions.set(key, contribution);
@@ -262,11 +264,11 @@ function normalizeContentIdentity(input, diagnostics, options) {
 	if (options.validateClaimedDigest) {
 		const claimedDigest = input.contentDigest;
 		if (typeof claimedDigest !== "string" || !isSha256Digest(claimedDigest)) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId}' has an invalid claimed content digest.`));
+			diagnostics.push(diagnostic$1("RESOURCE_CONTENT_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId}' has an invalid claimed content digest.`));
 			return;
 		}
 		if (claimedDigest !== contentDigest) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_DIGEST_MISMATCH", contentLocation(resourceId), `Resource '${resourceId}' claimed a content digest that does not match its explicit authority and contributions.`));
+			diagnostics.push(diagnostic$1("RESOURCE_CONTENT_DIGEST_MISMATCH", contentLocation(resourceId), `Resource '${resourceId}' claimed a content digest that does not match its explicit authority and contributions.`));
 			return;
 		}
 	}
@@ -283,7 +285,7 @@ function validateEffectiveContentIdentities(registry, identities, diagnostics) {
 	for (const entry of effectiveEntries) {
 		const input = identities.get(entry.resourceId);
 		if (input === void 0) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_MISSING", dependencyLocation(entry.resourceId), `Effective resource '${entry.resourceId}' has no explicit content identity.`));
+			diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_MISSING", dependencyLocation(entry.resourceId), `Effective resource '${entry.resourceId}' has no explicit content identity.`));
 			continue;
 		}
 		const identity = normalizeContentIdentity(input, diagnostics, {
@@ -298,7 +300,7 @@ function validateEffectiveContentIdentities(registry, identities, diagnostics) {
 function validateContentIdentityIndex(identities, diagnostics) {
 	for (const [key, identity] of [...identities.entries()].sort(([left], [right]) => compareCodeUnits(left, right))) {
 		const identityResourceId = isRecord(identity) && typeof identity.resourceId === "string" ? identity.resourceId : void 0;
-		if (key !== identityResourceId) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_KEY_MISMATCH", dependencyLocation(key), `Content identity index key '${key}' does not match identity '${identityResourceId ?? "invalid"}'.`));
+		if (key !== identityResourceId) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_KEY_MISMATCH", dependencyLocation(key), `Content identity index key '${key}' does not match identity '${identityResourceId ?? "invalid"}'.`));
 	}
 }
 function isSha256Digest(value) {
@@ -344,10 +346,10 @@ function cloneOrigin(origin) {
 		...origin.logicalPath === void 0 ? {} : { logicalPath: origin.logicalPath }
 	});
 }
-function stableDiagnostics(diagnostics) {
+function stableDiagnostics$1(diagnostics) {
 	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
 }
-function diagnostic(code, location, message) {
+function diagnostic$1(code, location, message) {
 	return Object.freeze({
 		code,
 		location,
@@ -371,6 +373,217 @@ function isLoadedResourceTreeAuthentic(tree) {
 	return authenticLoadedResourceTrees.has(tree);
 }
 //#endregion
+//#region ../resource-core/src/code-package.ts
+const CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY = "code-binding:module";
+/** @internal Node effect implementation bound by the public facade. */
+const nodeCodePackageRuntime = Object.freeze({
+	realpath,
+	readFile,
+	stat,
+	prepareModuleSource: async ({ bytes }) => {
+		const directory = await mkdtemp(join(tmpdir(), "halfcode-code-package-module-"));
+		const sourcePath = join(directory, "entry.mjs");
+		try {
+			await writeFile(sourcePath, bytes, { flag: "wx" });
+		} catch (error) {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			}).catch(() => void 0);
+			throw error;
+		}
+		return Object.freeze({
+			url: pathToFileURL(sourcePath).href,
+			dispose: async () => rm(directory, {
+				recursive: true,
+				force: true
+			})
+		});
+	},
+	importModule: async (url) => import(url)
+});
+var CodePackageLoadError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(`CodePackage loading failed with ${diagnostics.length} diagnostic(s)`);
+		this.name = "CodePackageLoadError";
+		this.diagnostics = Object.freeze([...diagnostics]);
+	}
+};
+/** @internal Used by the canonical XNL loader before it brands the completed tree. */
+function normalizeCodePackageBinding(record) {
+	const diagnostics = [];
+	if (record.sourceShape !== "code-package") {
+		diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_SHAPE_INVALID", record.documentUri, `Resource '${record.resourceId}' does not use the code-package source shape.`));
+		return { diagnostics };
+	}
+	const node = record.node.subdomains.CodeBinding;
+	if (!node || node.tag !== "CodeBinding") {
+		diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_BINDING_MISSING", record.documentUri, `CodePackage resource '${record.resourceId}' requires one CodeBinding.`));
+		return { diagnostics };
+	}
+	if (node.properties.package !== void 0) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_BINDING_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' must bind a package-local module, not an external package.`));
+	const rawModule = stringValue(node.properties.module);
+	const moduleUri = rawModule === void 0 ? void 0 : normalizeModuleUri(rawModule);
+	if (!moduleUri) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_MODULE_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' requires a canonical package-local .js or .mjs module URI.`));
+	const rawExport = node.properties.export;
+	const exportName = stringValue(rawExport);
+	if (rawExport !== void 0 && (!exportName || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName))) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_EXPORT_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' has an invalid named export binding.`));
+	if (diagnostics.length > 0 || !moduleUri) return { diagnostics: stableDiagnostics(diagnostics) };
+	return {
+		binding: Object.freeze({
+			resourceId: record.resourceId,
+			moduleUri,
+			...exportName ? { exportName } : {}
+		}),
+		diagnostics: Object.freeze([])
+	};
+}
+/** @internal Resolves and reads the exact entry bytes under the descriptor directory. */
+async function readCodePackageEntry(runtime, rootDir, record, binding) {
+	const diagnostics = [];
+	const realRoot = await runtime.realpath(resolve(rootDir)).catch(() => void 0);
+	if (!realRoot) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ROOT_MISSING", record.documentUri, `The resource root for '${record.resourceId}' is missing or unreadable.`)] };
+	if (!isSafeLogicalPath(record.logicalPath)) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_PROVENANCE_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' has unsafe logical provenance.`)] };
+	const descriptorPath = resolve(realRoot, record.logicalPath);
+	const descriptorDirectory = await runtime.realpath(dirname(descriptorPath)).catch(() => void 0);
+	if (!descriptorDirectory || !isWithin(realRoot, descriptorDirectory)) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_CONTAINMENT", record.documentUri, `CodePackage resource '${record.resourceId}' resolves outside the resource root.`)] };
+	const localPath = moduleLocalPath(binding.moduleUri);
+	if (!localPath) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_MODULE_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' has an invalid module URI.`)] };
+	const entryPath = await runtime.realpath(resolve(descriptorDirectory, ...localPath.split("/"))).catch(() => void 0);
+	if (!entryPath) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_MISSING", `${record.documentUri}#CodeBinding`, `CodePackage entry is missing for '${record.resourceId}'.`)] };
+	if (!isWithin(descriptorDirectory, entryPath) || entryPath === descriptorDirectory) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_CONTAINMENT", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' resolves outside its package directory.`));
+	if (!(await runtime.stat(entryPath).catch(() => void 0))?.isFile()) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_INVALID", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' must be a regular file.`));
+	if (diagnostics.length > 0) return { diagnostics: stableDiagnostics(diagnostics) };
+	const bytes = await runtime.readFile(entryPath).catch(() => void 0);
+	if (!bytes) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_MISSING", `${record.documentUri}#CodeBinding`, `CodePackage entry is unreadable for '${record.resourceId}'.`)] };
+	const resourceDirectory = posix.dirname(record.logicalPath);
+	return {
+		entryPath,
+		bytes,
+		sourceUri: `vfs://@/${resourceDirectory === "." ? localPath : `${resourceDirectory}/${localPath}`}`,
+		diagnostics: Object.freeze([])
+	};
+}
+async function loadCodePackageModule(input) {
+	return loadCodePackageModuleWithRuntime(nodeCodePackageRuntime, input);
+}
+/** @internal Pure orchestration over an injected effect runtime; hidden by the package facade. */
+async function loadCodePackageModuleWithRuntime(runtime, input) {
+	if (!isLoadedResourceTreeAuthentic(input.tree)) throw loadError("RESOURCE_CODE_PACKAGE_TREE_UNTRUSTED", `code-package:${input.resourceId}`, "CodePackage modules require an authentic LoadedResourceTree.");
+	const record = findResource(input.tree, input.resourceId);
+	const binding = input.tree.codePackageBindings.get(input.resourceId);
+	const identity = input.tree.contentIdentities.get(input.resourceId);
+	if (!record || record.sourceShape !== "code-package" || !binding || !identity) throw loadError("RESOURCE_CODE_PACKAGE_RESOURCE_INVALID", `code-package:${input.resourceId}`, `Resource '${input.resourceId}' is not a loaded CodePackage.`);
+	const entry = await readCodePackageEntry(runtime, input.rootDir, record, binding);
+	if (entry.diagnostics.length > 0 || !entry.entryPath || !entry.bytes) throw new CodePackageLoadError(entry.diagnostics);
+	const contribution = identity.contributions.find((item) => item.key === CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY);
+	if (!contribution || contribution.digest !== sha256Digest(entry.bytes) || contribution.sourceUri !== entry.sourceUri) throw loadError("RESOURCE_CODE_PACKAGE_REVISION_STALE", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' changed after its ResourceTree was loaded.`);
+	let preparedSource;
+	try {
+		preparedSource = await runtime.prepareModuleSource({
+			bytes: entry.bytes,
+			revision: identity.contentDigest
+		});
+	} catch {
+		throw loadError("RESOURCE_CODE_PACKAGE_IMPORT_PREPARE_FAILED", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' could not be prepared for import.`);
+	}
+	let moduleNamespace;
+	let importFailed = false;
+	try {
+		moduleNamespace = await runtime.importModule(preparedSource.url);
+	} catch {
+		importFailed = true;
+		moduleNamespace = Object.freeze({});
+	}
+	const cleanupFailed = await preparedSource.dispose().then(() => false, () => true);
+	if (importFailed) throw loadError("RESOURCE_CODE_PACKAGE_IMPORT_FAILED", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' could not be imported.`);
+	if (cleanupFailed) throw loadError("RESOURCE_CODE_PACKAGE_IMPORT_CLEANUP_FAILED", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' could not be cleaned up after import.`);
+	if (binding.exportName && !(binding.exportName in moduleNamespace)) throw loadError("RESOURCE_CODE_PACKAGE_EXPORT_MISSING", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' does not export '${binding.exportName}'.`);
+	const currentBytes = await runtime.readFile(entry.entryPath).catch(() => void 0);
+	if (!currentBytes || sha256Digest(currentBytes) !== contribution.digest) throw loadError("RESOURCE_CODE_PACKAGE_REVISION_STALE", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' changed while it was being imported.`);
+	const frozenNamespace = Object.freeze(Object.fromEntries(Object.keys(moduleNamespace).sort(compareCodeUnits).map((name) => [name, moduleNamespace[name]])));
+	return Object.freeze({
+		resourceId: record.resourceId,
+		binding,
+		revision: identity.contentDigest,
+		moduleNamespace: frozenNamespace
+	});
+}
+function admitCodePackageExports(loaded, contract) {
+	return admitCandidates([{
+		loaded,
+		contract
+	}]);
+}
+function admitCodePackages(loaded, contract) {
+	return admitCandidates(loaded.map((item) => ({
+		loaded: item,
+		contract
+	})));
+}
+function admitCandidates(packages) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const { loaded, contract } of packages) {
+		const names = loaded.binding.exportName ? [loaded.binding.exportName] : Object.keys(loaded.moduleNamespace).sort(compareCodeUnits);
+		for (const name of names) {
+			const exported = loaded.moduleNamespace[name];
+			const candidates = Array.isArray(exported) ? exported : [exported];
+			for (const candidate of candidates) {
+				if (!contract.isDefinition(candidate)) continue;
+				const identity = contract.identityOf(candidate).trim();
+				if (!identity) throw new TypeError(`CodePackage definition from '${loaded.resourceId}' has an empty identity`);
+				if (definitions.has(identity)) throw new TypeError(`Duplicate CodePackage definition identity '${identity}'`);
+				definitions.set(identity, candidate);
+			}
+		}
+	}
+	return Object.freeze([...definitions.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([, definition]) => definition));
+}
+function normalizeModuleUri(value) {
+	const prefix = "vfs://./";
+	if (!value.startsWith(prefix) || value !== value.trim() || value.includes("%") || value.includes("\\") || value.includes("?") || value.includes("#")) return void 0;
+	const localPath = value.slice(8);
+	if (!localPath || isAbsolute(localPath) || posix.isAbsolute(localPath)) return void 0;
+	const parts = localPath.split("/");
+	if (parts.some((part) => !part || part === "." || part === "..")) return void 0;
+	const extension = extname(localPath).toLowerCase();
+	if (extension !== ".js" && extension !== ".mjs") return void 0;
+	return `${prefix}${parts.join("/")}`;
+}
+function moduleLocalPath(moduleUri) {
+	return normalizeModuleUri(moduleUri)?.slice(8);
+}
+function findResource(tree, resourceId) {
+	for (const records of tree.registry.byKind.values()) {
+		const record = records.find((item) => item.resourceId === resourceId);
+		if (record) return record;
+	}
+}
+function isSafeLogicalPath(value) {
+	return Boolean(value) && !isAbsolute(value) && !value.includes("\\") && !value.split("/").some((part) => !part || part === "." || part === "..");
+}
+function isWithin(boundary, candidate) {
+	const path = relative(boundary, candidate);
+	return path === "" || !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path);
+}
+function stringValue(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function loadError(code, location, message) {
+	return new CodePackageLoadError([diagnostic(code, location, message)]);
+}
+function stableDiagnostics(diagnostics) {
+	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
+}
+function diagnostic(code, location, message) {
+	return Object.freeze({
+		code,
+		location,
+		message
+	});
+}
+//#endregion
 //#region ../resource-core/src/readonly-map.ts
 function readonlyMap(entries) {
 	const values = new Map(entries);
@@ -413,7 +626,9 @@ async function buildXnlResourceTree(options) {
 		resources: [],
 		seenIdentities: /* @__PURE__ */ new Map(),
 		authorityFiles: /* @__PURE__ */ new Map(),
-		recordAuthorityDigests: /* @__PURE__ */ new WeakMap()
+		recordAuthorityDigests: /* @__PURE__ */ new WeakMap(),
+		recordContributions: /* @__PURE__ */ new WeakMap(),
+		codePackageBindings: /* @__PURE__ */ new Map()
 	};
 	const manifest = await loadManifest(resolve(context.rootDir, options.manifestPath), "manifest", context, true);
 	if (!manifest || context.diagnostics.length > 0) return { diagnostics: context.diagnostics };
@@ -426,6 +641,7 @@ async function buildXnlResourceTree(options) {
 	const frozenByKind = readonlyMap([...byKind.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([kind, records]) => [kind, Object.freeze([...records].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)))]));
 	const frozenKindDefinitions = readonlyMap([...context.kindDefinitions.entries()].sort(([left], [right]) => compareCodeUnits(left, right)));
 	const contentIdentities = readonlyMap(context.resources.map((resource) => [resource.resourceId, loadedContentIdentity(resource, context)]).sort(([left], [right]) => compareCodeUnits(left, right)));
+	const codePackageBindings = readonlyMap([...context.codePackageBindings.entries()].sort(([left], [right]) => compareCodeUnits(left, right)));
 	return {
 		diagnostics: [],
 		tree: markLoadedResourceTreeAuthentic(Object.freeze({
@@ -435,7 +651,8 @@ async function buildXnlResourceTree(options) {
 				kindDefinitions: frozenKindDefinitions
 			}),
 			diagnostics: Object.freeze([]),
-			contentIdentities
+			contentIdentities,
+			codePackageBindings
 		}))
 	};
 }
@@ -524,6 +741,7 @@ async function loadCatalog(catalog, manifestDir, context) {
 			}
 			validateResourceApiVersion(record, definition, context.diagnostics);
 			await validateRequiredFiles(dirname(file), record, definition, context.diagnostics);
+			if (catalog.shape === "code-package" && !await prepareCodePackageRecord(record, context)) continue;
 			validateIdentity(record, context);
 			context.resources.push(record);
 		}
@@ -559,7 +777,7 @@ async function catalogFiles(catalog, manifestDir, context) {
 		context.diagnostics.push({
 			code: "RESOURCE_CATALOG_ENTRY_INVALID",
 			location: catalog.location,
-			message: "Directory and manifest catalogs require a plain XNL entry filename."
+			message: "Directory, manifest and code-package catalogs require a plain XNL entry filename."
 		});
 		return [];
 	}
@@ -640,8 +858,25 @@ function loadedContentIdentity(resource, context) {
 	if (!authorityDigest) throw new Error(`Loader authority digest is missing for ${resource.resourceId}`);
 	return createResourceContentIdentity({
 		resourceId: resource.resourceId,
-		authorityDigest
+		authorityDigest,
+		contributions: context.recordContributions.get(resource) ?? []
+	});
+}
+async function prepareCodePackageRecord(record, context) {
+	const normalized = normalizeCodePackageBinding(record);
+	context.diagnostics.push(...normalized.diagnostics);
+	if (!normalized.binding) return false;
+	const entry = await readCodePackageEntry(nodeCodePackageRuntime, context.rootDir, record, normalized.binding);
+	context.diagnostics.push(...entry.diagnostics);
+	if (!entry.bytes || !entry.sourceUri) return false;
+	const contribution = Object.freeze({
+		key: CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY,
+		digest: sha256Digest(entry.bytes),
+		sourceUri: entry.sourceUri
 	});
+	context.recordContributions.set(record, Object.freeze([contribution]));
+	context.codePackageBindings.set(record.resourceId, normalized.binding);
+	return true;
 }
 function resourceRecordFromRoot(root, filePath, sourceShape, context) {
 	const documentUri = documentUriFor(context.rootDir, filePath);
@@ -877,7 +1112,7 @@ function kindMismatch(actual, expected, location) {
 	};
 }
 function isXnlShape(value) {
-	return value === "single-file" || value === "directory" || value === "manifest";
+	return value === "single-file" || value === "directory" || value === "manifest" || value === "code-package";
 }
 function isDocumentCardinality(value) {
 	return value === "one" || value === "many";
@@ -944,4 +1179,4 @@ function unsupportedAuthorityDiagnostic(options) {
 	};
 }
 //#endregion
-export { isLoadedResourceTreeAuthentic as a, sha256Digest as c, markEffectiveRegistryAuthentic as d, ResourceCompositionError as f, readonlyMap as i, effectiveRegistryLayerBindings as l, digestCanonical as m, loadResourceTree as n, buildResourceDependencySnapshot as o, compareCodeUnits as p, validateResourceTree as r, createResourceContentIdentity as s, ResourceValidationError as t, isEffectiveRegistryAuthentic as u };
+export { ResourceCompositionError as _, CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY as a, admitCodePackages as c, buildResourceDependencySnapshot as d, createResourceContentIdentity as f, markEffectiveRegistryAuthentic as g, isEffectiveRegistryAuthentic as h, readonlyMap as i, loadCodePackageModule as l, effectiveRegistryLayerBindings as m, loadResourceTree as n, CodePackageLoadError as o, sha256Digest as p, validateResourceTree as r, admitCodePackageExports as s, ResourceValidationError as t, isLoadedResourceTreeAuthentic as u, compareCodeUnits as v, digestCanonical as y };

package/dist/{src-D1Bmq7Lo.js → src-BJ5cQQ7P.js}

@@ -1,4 +1,4 @@
-import { l as resourceRefToFqn, u as resolveObjectOperationCompilation } from "./src-DRIws6tY.js";
+import { l as resourceRefToFqn, u as resolveObjectOperationCompilation } from "./src-BxwHmx6r.js";
 import { c as unsafeUnicodeCodeUnitIssue, i as planResourceMappings, o as safePathLexicalIssue, r as parseResourceMappings, t as ResourceMappingPathError } from "./src-25wZPUyX.js";
 import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, posix, resolve } from "node:path";

package/dist/{src-DRIws6tY.js → src-BxwHmx6r.js}

@@ -1,4 +1,4 @@
-import { n as loadResourceTree } from "./src-DCRih45n.js";
+import { n as loadResourceTree } from "./src-BGFskWEk.js";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { parse } from "yaml";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halfcode-compiler.xnl",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Compile XNL-described applications into runtime-ready skill capsules.",
   "type": "module",
   "private": false,