halfcode-compiler.xnl 0.3.0 → 0.3.1

package/dist/application-assembly.d.ts

@@ -1,2 +1,3 @@
+import { a as CodeExecutionEnvironment, c as FrozenCodeDependency, d as validateCodeClosure, i as CodeClosureError, l as FrozenCodeModule, n as CaptureCodeClosureInput, o as FrozenCodeAsset, r as CodeClosureCaptureRuntime, s as FrozenCodeClosure, t as CODE_CLOSURE_COMPILER_IDENTITY, u as captureCodeClosure } from "./code-execution-closure-CXORuheJ.js";
 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-DEikbOFh.js";
-export { type ApplicationAssembly, type ApplicationScope, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, type AuthoringModuleDescriptor, type BusinessObjectResource, type BusinessObjectSopResource, type CodeBinding, type ContractedCallableResource, type ExecuteObjectOperationRequest, type JsonObject, type JsonPrimitive, type JsonValue, type LoadApplicationAssemblyOptions, 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, type ResolveApplicationAssemblyOptions, type ResolvedAssemblyPortBinding, type ResourceInclude, type ResourceSource, type SkillCapsuleDependency, type SkillCapsuleResource, type TextMaterial, type TextResource, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };
+export { type ApplicationAssembly, type ApplicationScope, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, type AuthoringModuleDescriptor, type BusinessObjectResource, type BusinessObjectSopResource, CODE_CLOSURE_COMPILER_IDENTITY, type CaptureCodeClosureInput, type CodeBinding, type CodeClosureCaptureRuntime, CodeClosureError, type CodeExecutionEnvironment, type ContractedCallableResource, type ExecuteObjectOperationRequest, type FrozenCodeAsset, type FrozenCodeClosure, type FrozenCodeDependency, type FrozenCodeModule, type JsonObject, type JsonPrimitive, type JsonValue, type LoadApplicationAssemblyOptions, 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, type ResolveApplicationAssemblyOptions, type ResolvedAssemblyPortBinding, type ResourceInclude, type ResourceSource, type SkillCapsuleDependency, type SkillCapsuleResource, type TextMaterial, type TextResource, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, captureCodeClosure, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn, validateCodeClosure };

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-B0Hja_dk.js";
-export { ObjectOperationContractError, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };
+import { a as assertObjectOperationCatalog, c as resolveApplicationAssembly, d as CodeClosureError, f as captureCodeClosure, i as assertObjectOperationCall, l as resourceRefToFqn, n as applicationAssemblyPackage, o as assertObjectOperationDefinition, p as validateCodeClosure, r as assertExecuteObjectOperationRequest, s as loadApplicationAssembly, t as ObjectOperationContractError, u as CODE_CLOSURE_COMPILER_IDENTITY } from "./src-BX7wrSq1.js";
+export { CODE_CLOSURE_COMPILER_IDENTITY, CodeClosureError, ObjectOperationContractError, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, captureCodeClosure, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn, validateCodeClosure };

package/dist/authoring-runtime.d.ts

@@ -1,5 +1,7 @@
-import { $ as RESOURCE_ENVELOPE_VERSION, Dt as EffectiveResourceRegistry, i as AuthoredResourceTree, o as KindSpecRevisionDescriptor, tt as SpecVersion } from "./index-DboIOEr8.js";
-import { n as ResourceLayerContentIdentityInput } from "./effective-content-identities-drMRhYE2.js";
+import { $ as RESOURCE_ENVELOPE_VERSION, gt as EffectiveResourceRegistry, i as AuthoredResourceTree, o as KindSpecRevisionDescriptor, tt as SpecVersion } from "./index-By8x4reS.js";
+import { n as ResourceLayerContentIdentityInput } from "./effective-content-identities-Cf0ygCXk.js";
+import { a as CodeExecutionEnvironment, s as FrozenCodeClosure } from "./code-execution-closure-CXORuheJ.js";
+import { l as CodeBinding } from "./index-DEikbOFh.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";
 //#region ../runtime-authoring/src/resource-authoring.d.ts
 declare const RESOURCE_AUTHORING_SCHEMA_VERSION: "halfcode.resource-authoring/v1";
@@ -165,4 +167,19 @@ declare function deriveResourceAuthoringRegistryRevision(input: ResourceAuthorin
 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 };
+//#region ../runtime-authoring/src/code-execution.d.ts
+interface CodeClosureExecutionRuntime {
+  readonly environment: CodeExecutionEnvironment;
+  /** Explicit host exports for the exact identities declared in environment. */
+  readonly ambientModules?: Readonly<Record<string, unknown>>;
+}
+interface RestoredCodeClosure {
+  readonly binding: CodeBinding;
+  readonly closureDigest: string;
+  readonly exports: Readonly<Record<string, unknown>>;
+}
+/** Each restore owns a fresh module table; this is not an untrusted-code sandbox. */
+declare function restoreCodeClosure(runtime: CodeClosureExecutionRuntime, input: FrozenCodeClosure, expectedDigest: string): RestoredCodeClosure;
+declare function bindCodeClosure(runtime: CodeClosureExecutionRuntime, closure: FrozenCodeClosure, expectedDigest: string): (...args: unknown[]) => unknown;
+//#endregion
+export { ApplyResourceAuthoringConfig, AuthoringBindings, AuthoringRuntime, CodeClosureExecutionRuntime, 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, RestoredCodeClosure, RuntimeEffects, applyResourceAuthoring, bindCodeClosure, createAuthoringBindings, currentRuntime, deriveResourceAuthoringRegistryRevision, invokeEffect, logger, planResourceAuthoring, restoreCodeClosure, runWithRuntime, runtimeAuthoringPackage };

package/dist/authoring-runtime.js

@@ -1,2 +1,2 @@
-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-hrUy4DJ9.js";
-export { RESOURCE_AUTHORING_SCHEMA_VERSION, ResourceAuthoringError, applyResourceAuthoring, createAuthoringBindings, currentRuntime, deriveResourceAuthoringRegistryRevision, invokeEffect, logger, planResourceAuthoring, runWithRuntime, runtimeAuthoringPackage };
+import { a as runWithRuntime, c as restoreCodeClosure, d as applyResourceAuthoring, f as deriveResourceAuthoringRegistryRevision, i as logger, l as RESOURCE_AUTHORING_SCHEMA_VERSION, n as currentRuntime, o as runtimeAuthoringPackage, p as planResourceAuthoring, r as invokeEffect, s as bindCodeClosure, t as createAuthoringBindings, u as ResourceAuthoringError } from "./src-MPJZB76z.js";
+export { RESOURCE_AUTHORING_SCHEMA_VERSION, ResourceAuthoringError, applyResourceAuthoring, bindCodeClosure, createAuthoringBindings, currentRuntime, deriveResourceAuthoringRegistryRevision, invokeEffect, logger, planResourceAuthoring, restoreCodeClosure, runWithRuntime, runtimeAuthoringPackage };

package/dist/code-execution-closure-CXORuheJ.d.ts

@@ -0,0 +1,59 @@
+import { a as ResourcePackageReadPort } from "./resource-package-read-port-BLBb4cz5.js";
+import { l as CodeBinding } from "./index-DEikbOFh.js";
+//#region ../application-assembly/src/code-execution-closure.d.ts
+/** The complete emit profile is versioned; changing it invalidates old closures. */
+declare const CODE_CLOSURE_COMPILER_IDENTITY = "typescript@5.9.3/commonjs-es2022-interop/closure-v2";
+interface CodeExecutionEnvironment {
+  readonly hostIdentity: string;
+  readonly ambient: Readonly<Record<string, string>>;
+}
+interface CodeClosureCaptureRuntime {
+  readonly source: ResourcePackageReadPort;
+}
+interface CaptureCodeClosureInput {
+  readonly binding: CodeBinding;
+  readonly sourceRoot: string;
+  readonly entryPath: string;
+  /** Paths relative to sourceRoot; imports of non-code files require a declaration. */
+  readonly assets?: Readonly<Record<string, "text" | "json">>;
+  readonly environment: CodeExecutionEnvironment;
+}
+interface FrozenCodeDependency {
+  readonly specifier: string;
+  readonly kind: "module" | "asset" | "ambient";
+  readonly target: string;
+}
+interface FrozenCodeModule {
+  readonly path: string;
+  readonly source: string;
+  readonly sourceDigest: string;
+  readonly code: string;
+  readonly codeDigest: string;
+  readonly dependencies: readonly FrozenCodeDependency[];
+}
+interface FrozenCodeAsset {
+  readonly path: string;
+  readonly format: "text" | "json";
+  readonly content: string;
+  readonly contentDigest: string;
+}
+/** Immutable recovery material. Its digest must be pinned by the admitting owner. */
+interface FrozenCodeClosure {
+  readonly format: "halfcode-code-closure/v1";
+  readonly compilerIdentity: string;
+  readonly binding: CodeBinding;
+  readonly entryPath: string;
+  readonly environment: CodeExecutionEnvironment;
+  readonly modules: readonly FrozenCodeModule[];
+  readonly assets: readonly FrozenCodeAsset[];
+  readonly digest: string;
+}
+declare class CodeClosureError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+declare function captureCodeClosure(runtime: CodeClosureCaptureRuntime, input: CaptureCodeClosureInput): Promise<FrozenCodeClosure>;
+/** Pure validation: no source reader, live imports, or module execution. */
+declare function validateCodeClosure(closure: FrozenCodeClosure, environment: CodeExecutionEnvironment, expectedDigest: string): void;
+//#endregion
+export { CodeExecutionEnvironment as a, FrozenCodeDependency as c, validateCodeClosure as d, CodeClosureError as i, FrozenCodeModule as l, CaptureCodeClosureInput as n, FrozenCodeAsset as o, CodeClosureCaptureRuntime as r, FrozenCodeClosure as s, CODE_CLOSURE_COMPILER_IDENTITY as t, captureCodeClosure as u };

package/dist/{effective-content-identities-drMRhYE2.d.ts → effective-content-identities-Cf0ygCXk.d.ts}

@@ -1,4 +1,4 @@
-import { Dt as EffectiveResourceRegistry, gt as ResourceContentIdentity, i as AuthoredResourceTree, yt as ResourceDigestContribution } from "./index-DboIOEr8.js";
+import { at as ResourceContentIdentity, ct as ResourceDigestContribution, gt as EffectiveResourceRegistry, i as AuthoredResourceTree } from "./index-By8x4reS.js";
 //#region ../resource-core/src/effective-content-identities.d.ts
 interface ResourceLayerContentIdentityInput {
   readonly id: string;

package/dist/{index-CR7wJSSX.d.ts → index-B9Pp3Zgj.d.ts}

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

package/dist/{index-DboIOEr8.d.ts → index-By8x4reS.d.ts}

@@ -1,3 +1,4 @@
+import { o as ResourcePackageReadPortOptions } from "./resource-package-read-port-BLBb4cz5.js";
 //#region ../resource-core/src/canonical.d.ts
 type Sha256Digest = `sha256:${string}`;
 declare function compareCodeUnits(left: string, right: string): number;
@@ -106,38 +107,6 @@ declare function sha256Digest(value: string | Uint8Array): Sha256Digest;
 declare function createResourceContentIdentity(input: CreateResourceContentIdentityInput): ResourceContentIdentity;
 declare function buildResourceDependencySnapshot(input: BuildResourceDependencySnapshotInput): ResourceDependencySnapshot;
 //#endregion
-//#region ../resource-core/src/resource-package-read-port.d.ts
-type ResourcePackageAwaitable<T> = T | PromiseLike<T>;
-type ResourcePackageEntryKind = "file" | "directory" | "symlink" | "other";
-interface ResourcePackageEntry {
-  readonly kind: ResourcePackageEntryKind;
-}
-interface ResourcePackageDirectoryEntry extends ResourcePackageEntry {
-  readonly name: string;
-}
-/**
- * Storage-neutral source effect for one already-materialized ResourcePackage
- * file view. Paths are canonical POSIX absolute coordinates scoped to the
- * provider; they are never semantic resource provenance.
- */
-interface ResourcePackageReadPort {
-  stat(sourcePath: string): ResourcePackageAwaitable<ResourcePackageEntry | undefined>;
-  readDirectory(sourcePath: string): ResourcePackageAwaitable<readonly ResourcePackageDirectoryEntry[] | undefined>;
-  readBytes(sourcePath: string): ResourcePackageAwaitable<Uint8Array | undefined>;
-}
-interface ResourcePackageReadPortOptions {
-  readonly port: ResourcePackageReadPort;
-  readonly rootPath?: string;
-  readonly manifestPath?: string;
-}
-declare class ResourcePackageSourcePathError extends TypeError {
-  constructor(message: string);
-}
-declare function canonicalResourcePackageSourcePath(input: string): string;
-declare function joinResourcePackageSourcePath(base: string, ...segments: readonly string[]): string;
-declare function dirnameResourcePackageSourcePath(sourcePath: string): string;
-declare function relativeResourcePackageSourcePath(rootPath: string, sourcePath: string): string | undefined;
-//#endregion
 //#region ../resource-core/src/resource-version-contracts.d.ts
 declare const RESOURCE_ENVELOPE_VERSION: "halfcode.resource-envelope/v1";
 declare const CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS: Readonly<{
@@ -471,4 +440,4 @@ declare function validateResourceTree(options: LoadResourceTreeOptions): Promise
 declare function loadResourceTreeFromReadPort(options: ResourcePackageReadPortOptions): Promise<AuthoredResourceTree>;
 declare function validateResourceTreeFromReadPort(options: ResourcePackageReadPortOptions): Promise<ResourceDiagnostic[]>;
 //#endregion
-export { RESOURCE_ENVELOPE_VERSION as $, validateResourceTreeFromReadPort as A, ResourceOrigin as At, KindSpecRevision as B, ResourceValue as C, sha256Digest as Ct, loadResourceTree as D, EffectiveResourceRegistry as Dt, SourceShape as E, EffectiveResourceEntry as Et, KindContractLockReader as F, canonicalJson as Ft, ReaderProfile as G, KindWriterRegistration as H, KindReaderRegistration as I, compareCodeUnits as It, ResourceResolutionReceipt as J, ReaderTarget as K, KindSemanticContract as L, digestCanonical as Lt, JsonSchema as M, ResourceTombstoneOrigin as Mt, JsonSchemaValidator as N, composeLayeredResourceRegistry as Nt, loadResourceTreeFromReadPort as O, ResourceLayerDescriptor as Ot, KindContractLock as P, Sha256Digest as Pt, RESOURCE_ENVELOPE_FINGERPRINT as Q, KindSourceContract as R, ResourceValidationError as S, createResourceContentIdentity as St, ResourceValueMap as T, EffectiveKindDefinition as Tt, PortableSpec as U, KindSubjectOwner as V, PortableValue as W, CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS as X, SpecResolutionDefinition as Y, RESOURCE_ENVELOPE_CONTRACT as Z, ResourceRecord as _, ResourceDependencyEdge as _t, AuthoredResourceTreeBuildResult as a, ResourcePackageEntry as at, ResourceTree as b, SnapshotResource as bt, RegisteredKindDefinition as c, ResourcePackageReadPortOptions as ct, ResolvedResourceTree as d, dirnameResourcePackageSourcePath as dt, ResourceMetadata as et, ResourceDescriptor as f, joinResourcePackageSourcePath as ft, ResourceNode as g, ResourceContentIdentity as gt, ResourceKindContract as h, CreateResourceContentIdentityInput as ht, AuthoredResourceTree as i, ResourcePackageDirectoryEntry as it, CompatibilityPolicy as j, ResourceTombstone as jt, validateResourceTree as k, ResourceLayerInput as kt, ResolvedResourceRecord as l, ResourcePackageSourcePathError as lt, ResourceIdentity as m, BuildResourceDependencySnapshotInput as mt, AuthoredResourceRegistry as n, isSpecVersion as nt, KindSpecRevisionDescriptor as o, ResourcePackageEntryKind as ot, ResourceDiagnostic as p, relativeResourcePackageSourcePath as pt, ResolvedSpec as q, AuthoredResourceSpec as r, ResourcePackageAwaitable as rt, LoadResourceTreeOptions as s, ResourcePackageReadPort as st, AuthoredResourceRecord as t, SpecVersion as tt, ResolvedResourceRegistry as u, canonicalResourcePackageSourcePath as ut, ResourceRegistry as v, ResourceDependencySnapshot as vt, ResourceValueList as w, ComposeLayeredResourceRegistryInput as wt, ResourceTreeBuildResult as x, buildResourceDependencySnapshot as xt, ResourceScalar as y, ResourceDigestContribution as yt, KindSourceShape as z };
+export { RESOURCE_ENVELOPE_VERSION as $, validateResourceTreeFromReadPort as A, KindSpecRevision as B, ResourceValue as C, Sha256Digest as Ct, loadResourceTree as D, SourceShape as E, digestCanonical as Et, KindContractLockReader as F, ReaderProfile as G, KindWriterRegistration as H, KindReaderRegistration as I, ResourceResolutionReceipt as J, ReaderTarget as K, KindSemanticContract as L, JsonSchema as M, JsonSchemaValidator as N, loadResourceTreeFromReadPort as O, KindContractLock as P, RESOURCE_ENVELOPE_FINGERPRINT as Q, KindSourceContract as R, ResourceValidationError as S, composeLayeredResourceRegistry as St, ResourceValueMap as T, compareCodeUnits as Tt, PortableSpec as U, KindSubjectOwner as V, PortableValue as W, CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS as X, SpecResolutionDefinition as Y, RESOURCE_ENVELOPE_CONTRACT as Z, ResourceRecord as _, ResourceLayerDescriptor as _t, AuthoredResourceTreeBuildResult as a, ResourceContentIdentity as at, ResourceTree as b, ResourceTombstone as bt, RegisteredKindDefinition as c, ResourceDigestContribution as ct, ResolvedResourceTree as d, createResourceContentIdentity as dt, ResourceMetadata as et, ResourceDescriptor as f, sha256Digest as ft, ResourceNode as g, EffectiveResourceRegistry as gt, ResourceKindContract as h, EffectiveResourceEntry as ht, AuthoredResourceTree as i, CreateResourceContentIdentityInput as it, CompatibilityPolicy as j, validateResourceTree as k, ResolvedResourceRecord as l, SnapshotResource as lt, ResourceIdentity as m, EffectiveKindDefinition as mt, AuthoredResourceRegistry as n, isSpecVersion as nt, KindSpecRevisionDescriptor as o, ResourceDependencyEdge as ot, ResourceDiagnostic as p, ComposeLayeredResourceRegistryInput as pt, ResolvedSpec as q, AuthoredResourceSpec as r, BuildResourceDependencySnapshotInput as rt, LoadResourceTreeOptions as s, ResourceDependencySnapshot as st, AuthoredResourceRecord as t, SpecVersion as tt, ResolvedResourceRegistry as u, buildResourceDependencySnapshot as ut, ResourceRegistry as v, ResourceLayerInput as vt, ResourceValueList as w, canonicalJson as wt, ResourceTreeBuildResult as x, ResourceTombstoneOrigin as xt, ResourceScalar as y, ResourceOrigin as yt, KindSourceShape as z };

package/dist/{index-DI3WtuXq.d.ts → index-Csi_AIoU.d.ts}

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

package/dist/index.d.ts

@@ -1,11 +1,13 @@
+import { $ as RESOURCE_ENVELOPE_VERSION, A as validateResourceTreeFromReadPort, B as KindSpecRevision, C as ResourceValue, Ct as Sha256Digest, D as loadResourceTree, E as SourceShape, Et as digestCanonical, F as KindContractLockReader, G as ReaderProfile, H as KindWriterRegistration, I as KindReaderRegistration, J as ResourceResolutionReceipt, K as ReaderTarget, L as KindSemanticContract, M as JsonSchema, N as JsonSchemaValidator, O as loadResourceTreeFromReadPort, P as KindContractLock, Q as RESOURCE_ENVELOPE_FINGERPRINT, R as KindSourceContract, S as ResourceValidationError, St as composeLayeredResourceRegistry, T as ResourceValueMap, Tt as compareCodeUnits, U as PortableSpec, V as KindSubjectOwner, W as PortableValue, X as CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, Y as SpecResolutionDefinition, Z as RESOURCE_ENVELOPE_CONTRACT, _ as ResourceRecord, _t as ResourceLayerDescriptor, a as AuthoredResourceTreeBuildResult, at as ResourceContentIdentity, b as ResourceTree, bt as ResourceTombstone, c as RegisteredKindDefinition, ct as ResourceDigestContribution, d as ResolvedResourceTree, dt as createResourceContentIdentity, et as ResourceMetadata, f as ResourceDescriptor, ft as sha256Digest, g as ResourceNode, gt as EffectiveResourceRegistry, h as ResourceKindContract, ht as EffectiveResourceEntry, i as AuthoredResourceTree, it as CreateResourceContentIdentityInput, j as CompatibilityPolicy, k as validateResourceTree, l as ResolvedResourceRecord, lt as SnapshotResource, m as ResourceIdentity, mt as EffectiveKindDefinition, n as AuthoredResourceRegistry, nt as isSpecVersion, o as KindSpecRevisionDescriptor, ot as ResourceDependencyEdge, p as ResourceDiagnostic, pt as ComposeLayeredResourceRegistryInput, q as ResolvedSpec, r as AuthoredResourceSpec, rt as BuildResourceDependencySnapshotInput, s as LoadResourceTreeOptions, st as ResourceDependencySnapshot, t as AuthoredResourceRecord, tt as SpecVersion, u as ResolvedResourceRegistry, ut as buildResourceDependencySnapshot, v as ResourceRegistry, vt as ResourceLayerInput, w as ResourceValueList, wt as canonicalJson, x as ResourceTreeBuildResult, xt as ResourceTombstoneOrigin, y as ResourceScalar, yt as ResourceOrigin, z as KindSourceShape } from "./index-By8x4reS.js";
+import { a as ResourcePackageReadPort, c as canonicalResourcePackageSourcePath, d as relativeResourcePackageSourcePath, i as ResourcePackageEntryKind, l as dirnameResourcePackageSourcePath, n as ResourcePackageDirectoryEntry, o as ResourcePackageReadPortOptions, r as ResourcePackageEntry, s as ResourcePackageSourcePathError, t as ResourcePackageAwaitable, u as joinResourcePackageSourcePath } from "./resource-package-read-port-BLBb4cz5.js";
+import { a as ReadResourceMaterialInput, c as readResourceMaterial, i as createDirectoryResourcePackageReadPort, l as ResourceCompositionError, n as ResourceMetadataDecodeResult, o as ResourceMaterial, r as decodeResourceMetadata, s as ResourceMaterialError, t as ResourceMetadataDecodeInput } from "./resource-core-CoTu6FNS.js";
+import { n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./effective-content-identities-Cf0ygCXk.js";
+import { a as CodeExecutionEnvironment, c as FrozenCodeDependency, d as validateCodeClosure, i as CodeClosureError, l as FrozenCodeModule, n as CaptureCodeClosureInput, o as FrozenCodeAsset, r as CodeClosureCaptureRuntime, s as FrozenCodeClosure, t as CODE_CLOSURE_COMPILER_IDENTITY, u as captureCodeClosure } from "./code-execution-closure-CXORuheJ.js";
 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-DEikbOFh.js";
-import { $ as RESOURCE_ENVELOPE_VERSION, A as validateResourceTreeFromReadPort, At as ResourceOrigin, B as KindSpecRevision, C as ResourceValue, Ct as sha256Digest, D as loadResourceTree, Dt as EffectiveResourceRegistry, E as SourceShape, Et as EffectiveResourceEntry, F as KindContractLockReader, Ft as canonicalJson, G as ReaderProfile, H as KindWriterRegistration, I as KindReaderRegistration, It as compareCodeUnits, J as ResourceResolutionReceipt, K as ReaderTarget, L as KindSemanticContract, Lt as digestCanonical, M as JsonSchema, Mt as ResourceTombstoneOrigin, N as JsonSchemaValidator, Nt as composeLayeredResourceRegistry, O as loadResourceTreeFromReadPort, Ot as ResourceLayerDescriptor, P as KindContractLock, Pt as Sha256Digest, Q as RESOURCE_ENVELOPE_FINGERPRINT, R as KindSourceContract, S as ResourceValidationError, St as createResourceContentIdentity, T as ResourceValueMap, Tt as EffectiveKindDefinition, U as PortableSpec, V as KindSubjectOwner, W as PortableValue, X as CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, Y as SpecResolutionDefinition, Z as RESOURCE_ENVELOPE_CONTRACT, _ as ResourceRecord, _t as ResourceDependencyEdge, a as AuthoredResourceTreeBuildResult, at as ResourcePackageEntry, b as ResourceTree, bt as SnapshotResource, c as RegisteredKindDefinition, ct as ResourcePackageReadPortOptions, d as ResolvedResourceTree, dt as dirnameResourcePackageSourcePath, et as ResourceMetadata, f as ResourceDescriptor, ft as joinResourcePackageSourcePath, g as ResourceNode, gt as ResourceContentIdentity, h as ResourceKindContract, ht as CreateResourceContentIdentityInput, i as AuthoredResourceTree, it as ResourcePackageDirectoryEntry, j as CompatibilityPolicy, jt as ResourceTombstone, k as validateResourceTree, kt as ResourceLayerInput, l as ResolvedResourceRecord, lt as ResourcePackageSourcePathError, m as ResourceIdentity, mt as BuildResourceDependencySnapshotInput, n as AuthoredResourceRegistry, nt as isSpecVersion, o as KindSpecRevisionDescriptor, ot as ResourcePackageEntryKind, p as ResourceDiagnostic, pt as relativeResourcePackageSourcePath, q as ResolvedSpec, r as AuthoredResourceSpec, rt as ResourcePackageAwaitable, s as LoadResourceTreeOptions, st as ResourcePackageReadPort, t as AuthoredResourceRecord, tt as SpecVersion, u as ResolvedResourceRegistry, ut as canonicalResourcePackageSourcePath, v as ResourceRegistry, vt as ResourceDependencySnapshot, w as ResourceValueList, wt as ComposeLayeredResourceRegistryInput, x as ResourceTreeBuildResult, xt as buildResourceDependencySnapshot, y as ResourceScalar, yt as ResourceDigestContribution, z as KindSourceShape } from "./index-DboIOEr8.js";
-import { a as ReadResourceMaterialInput, c as readResourceMaterial, i as createDirectoryResourcePackageReadPort, l as ResourceCompositionError, n as ResourceMetadataDecodeResult, o as ResourceMaterial, r as decodeResourceMetadata, s as ResourceMaterialError, t as ResourceMetadataDecodeInput } from "./resource-core-Brj8naBr.js";
-import { n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./effective-content-identities-drMRhYE2.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-CR7wJSSX.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-B9Pp3Zgj.js";
 import { CORE_KIND_READER_REGISTRATIONS, CORE_KIND_SPEC_REVISIONS, CORE_KIND_SUBJECT_OWNERS, CORE_RESOURCE_CONTRACT_REGISTRATIONS, KIND_DEFINITION_KIND_OWNER, KIND_DEFINITION_KIND_READER_REGISTRATION_V1, KIND_DEFINITION_KIND_SPEC_REVISION_V1, KIND_DEFINITION_SPEC_SCHEMA_V1, KindContractRegistry, KindDefinition, KindReaderRegistry, KindWriterRegistry, RESOURCE_PACKAGE_KIND_OWNER, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_SPEC_SCHEMA_V1, ResolveResourceTreeInput, ResourceSourceMigrationDefinition, ResourceSourceMigrationRegistry, SpecResolutionRegistry, createKindContractLock, createKindSpecRevision, createKindSubjectOwner, createReaderProfile, exactSpecVersion, kindDefinitionPackage, resolveResourceTree, resolveSpec } from "./kind-definition.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, AuthoredResourceRecord, AuthoredResourceRegistry, AuthoredResourceSpec, AuthoredResourceTree, AuthoredResourceTreeBuildResult, type AuthoringModuleDescriptor, BuildResourceDependencySnapshotInput, type BusinessObjectResource, type BusinessObjectSopResource, CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, CORE_KIND_READER_REGISTRATIONS, CORE_KIND_SPEC_REVISIONS, CORE_KIND_SUBJECT_OWNERS, CORE_RESOURCE_CONTRACT_REGISTRATIONS, type CodeBinding, CompatibilityPolicy, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, ComposeLayeredResourceRegistryInput, type ContractedCallableResource, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, type ExecuteObjectOperationRequest, type JsonObject, type JsonPrimitive, JsonSchema, JsonSchemaValidator, type JsonValue, KIND_DEFINITION_KIND_OWNER, KIND_DEFINITION_KIND_READER_REGISTRATION_V1, KIND_DEFINITION_KIND_SPEC_REVISION_V1, KIND_DEFINITION_SPEC_SCHEMA_V1, KindContractLock, KindContractLockReader, KindContractRegistry, KindDefinition, KindReaderRegistration, KindReaderRegistry, KindSemanticContract, KindSourceContract, KindSourceShape, KindSpecRevision, KindSpecRevisionDescriptor, KindSubjectOwner, KindWriterRegistration, KindWriterRegistry, type LoadApplicationAssemblyOptions, LoadResourceTreeOptions, 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, PortableSpec, PortableValue, RESOURCE_ENVELOPE_CONTRACT, RESOURCE_ENVELOPE_FINGERPRINT, RESOURCE_ENVELOPE_VERSION, RESOURCE_PACKAGE_KIND_OWNER, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_SPEC_SCHEMA_V1, ReadResourceMaterialInput, ReaderProfile, ReaderTarget, RegisteredKindDefinition, type ResolveApplicationAssemblyOptions, ResolveEffectiveResourceContentIdentitiesInput, ResolveResourceTreeInput, type ResolvedAssemblyPortBinding, ResolvedResourceRecord, ResolvedResourceRegistry, ResolvedResourceTree, ResolvedSpec, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, type ResourceInclude, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMaterial, ResourceMaterialError, ResourceMetadata, ResourceMetadataDecodeInput, ResourceMetadataDecodeResult, ResourceNode, ResourceOrigin, ResourcePackageAwaitable, ResourcePackageDirectoryEntry, ResourcePackageEntry, ResourcePackageEntryKind, ResourcePackageReadPort, ResourcePackageReadPortOptions, ResourcePackageSourcePathError, ResourceRecord, ResourceRegistry, ResourceResolutionReceipt, ResourceScalar, type ResourceSource, ResourceSourceMigrationDefinition, ResourceSourceMigrationRegistry, 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, SpecResolutionDefinition, SpecResolutionRegistry, SpecVersion, type TextMaterial, type TextResource, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, canonicalJson, canonicalResourcePackageSourcePath, compareCodeUnits, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createDirectoryResourcePackageReadPort, createKindContractLock, createKindSpecRevision, createKindSubjectOwner, createReaderProfile, createResourceContentIdentity, decodeResourceMetadata, digestCanonical, dirnameResourcePackageSourcePath, exactSpecVersion, isSpecVersion, joinResourcePackageSourcePath, kindDefinitionPackage, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, loadResourceTreeFromReadPort, planSkillCapsuleDistribution, readResourceMaterial, relativeResourcePackageSourcePath, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resolveResourceTree, resolveSpec, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree, validateResourceTreeFromReadPort };
+export { type ApplicationAssembly, type ApplicationScope, ApplySkillCapsuleDistributionOptions, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, AuthoredResourceRecord, AuthoredResourceRegistry, AuthoredResourceSpec, AuthoredResourceTree, AuthoredResourceTreeBuildResult, type AuthoringModuleDescriptor, BuildResourceDependencySnapshotInput, type BusinessObjectResource, type BusinessObjectSopResource, CODE_CLOSURE_COMPILER_IDENTITY, CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, CORE_KIND_READER_REGISTRATIONS, CORE_KIND_SPEC_REVISIONS, CORE_KIND_SUBJECT_OWNERS, CORE_RESOURCE_CONTRACT_REGISTRATIONS, type CaptureCodeClosureInput, type CodeBinding, type CodeClosureCaptureRuntime, CodeClosureError, type CodeExecutionEnvironment, CompatibilityPolicy, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, ComposeLayeredResourceRegistryInput, type ContractedCallableResource, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, type ExecuteObjectOperationRequest, type FrozenCodeAsset, type FrozenCodeClosure, type FrozenCodeDependency, type FrozenCodeModule, type JsonObject, type JsonPrimitive, JsonSchema, JsonSchemaValidator, type JsonValue, KIND_DEFINITION_KIND_OWNER, KIND_DEFINITION_KIND_READER_REGISTRATION_V1, KIND_DEFINITION_KIND_SPEC_REVISION_V1, KIND_DEFINITION_SPEC_SCHEMA_V1, KindContractLock, KindContractLockReader, KindContractRegistry, KindDefinition, KindReaderRegistration, KindReaderRegistry, KindSemanticContract, KindSourceContract, KindSourceShape, KindSpecRevision, KindSpecRevisionDescriptor, KindSubjectOwner, KindWriterRegistration, KindWriterRegistry, type LoadApplicationAssemblyOptions, LoadResourceTreeOptions, 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, PortableSpec, PortableValue, RESOURCE_ENVELOPE_CONTRACT, RESOURCE_ENVELOPE_FINGERPRINT, RESOURCE_ENVELOPE_VERSION, RESOURCE_PACKAGE_KIND_OWNER, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_SPEC_SCHEMA_V1, ReadResourceMaterialInput, ReaderProfile, ReaderTarget, RegisteredKindDefinition, type ResolveApplicationAssemblyOptions, ResolveEffectiveResourceContentIdentitiesInput, ResolveResourceTreeInput, type ResolvedAssemblyPortBinding, ResolvedResourceRecord, ResolvedResourceRegistry, ResolvedResourceTree, ResolvedSpec, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, type ResourceInclude, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMaterial, ResourceMaterialError, ResourceMetadata, ResourceMetadataDecodeInput, ResourceMetadataDecodeResult, ResourceNode, ResourceOrigin, ResourcePackageAwaitable, ResourcePackageDirectoryEntry, ResourcePackageEntry, ResourcePackageEntryKind, ResourcePackageReadPort, ResourcePackageReadPortOptions, ResourcePackageSourcePathError, ResourceRecord, ResourceRegistry, ResourceResolutionReceipt, ResourceScalar, type ResourceSource, ResourceSourceMigrationDefinition, ResourceSourceMigrationRegistry, 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, SpecResolutionDefinition, SpecResolutionRegistry, SpecVersion, type TextMaterial, type TextResource, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, canonicalJson, canonicalResourcePackageSourcePath, captureCodeClosure, compareCodeUnits, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createDirectoryResourcePackageReadPort, createKindContractLock, createKindSpecRevision, createKindSubjectOwner, createReaderProfile, createResourceContentIdentity, decodeResourceMetadata, digestCanonical, dirnameResourcePackageSourcePath, exactSpecVersion, isSpecVersion, joinResourcePackageSourcePath, kindDefinitionPackage, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, loadResourceTreeFromReadPort, planSkillCapsuleDistribution, readResourceMaterial, relativeResourcePackageSourcePath, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resolveResourceTree, resolveSpec, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateCodeClosure, validateResourceTree, validateResourceTreeFromReadPort };

package/dist/index.js

@@ -1,10 +1,10 @@
 import { C as digestCanonical, D as dirnameResourcePackageSourcePath, E as canonicalResourcePackageSourcePath, O as joinResourcePackageSourcePath, S as compareCodeUnits, T as ResourcePackageSourcePathError, a as validateResourceTreeFromReadPort, b as ResourceCompositionError, c as RESOURCE_ENVELOPE_CONTRACT, d as isSpecVersion, g as sha256Digest, h as createResourceContentIdentity, i as validateResourceTree, k as relativeResourcePackageSourcePath, l as RESOURCE_ENVELOPE_FINGERPRINT, m as buildResourceDependencySnapshot, n as loadResourceTree, o as decodeResourceMetadata, r as loadResourceTreeFromReadPort, s as CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, t as ResourceValidationError, u as RESOURCE_ENVELOPE_VERSION, w as createDirectoryResourcePackageReadPort, x as canonicalJson } from "./src-jggOQtq3.js";
 import { t as resolveEffectiveResourceContentIdentities } from "./effective-content-identities-CV6XFBZy.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-B0Hja_dk.js";
+import { a as assertObjectOperationCatalog, c as resolveApplicationAssembly, d as CodeClosureError, f as captureCodeClosure, i as assertObjectOperationCall, l as resourceRefToFqn, n as applicationAssemblyPackage, o as assertObjectOperationDefinition, p as validateCodeClosure, r as assertExecuteObjectOperationRequest, s as loadApplicationAssembly, t as ObjectOperationContractError, u as CODE_CLOSURE_COMPILER_IDENTITY } from "./src-BX7wrSq1.js";
 import "./application-assembly.js";
 import { ResourceMaterialError, composeLayeredResourceRegistry, readResourceMaterial } from "./resource-core.js";
 import { CORE_KIND_READER_REGISTRATIONS, CORE_KIND_SPEC_REVISIONS, CORE_KIND_SUBJECT_OWNERS, CORE_RESOURCE_CONTRACT_REGISTRATIONS, KIND_DEFINITION_KIND_OWNER, KIND_DEFINITION_KIND_READER_REGISTRATION_V1, KIND_DEFINITION_KIND_SPEC_REVISION_V1, KIND_DEFINITION_SPEC_SCHEMA_V1, KindContractRegistry, KindReaderRegistry, KindWriterRegistry, RESOURCE_PACKAGE_KIND_OWNER, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_SPEC_SCHEMA_V1, ResourceSourceMigrationRegistry, SpecResolutionRegistry, createKindContractLock, createKindSpecRevision, createKindSubjectOwner, createReaderProfile, exactSpecVersion, kindDefinitionPackage, resolveResourceTree, resolveSpec } from "./kind-definition.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-DLJUCH0M.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-QI7NRyC8.js";
 import { fileURLToPath } from "node:url";
 //#region src/bundled-system-skills.ts
 function loadHalfcodeResourceDslSystemSkillModule() {
@@ -22,4 +22,4 @@ async function loadHalfcodeResourceDslSystemSkillPlan() {
 	return bundled.default;
 }
 //#endregion
-export { CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, CORE_KIND_READER_REGISTRATIONS, CORE_KIND_SPEC_REVISIONS, CORE_KIND_SUBJECT_OWNERS, CORE_RESOURCE_CONTRACT_REGISTRATIONS, KIND_DEFINITION_KIND_OWNER, KIND_DEFINITION_KIND_READER_REGISTRATION_V1, KIND_DEFINITION_KIND_SPEC_REVISION_V1, KIND_DEFINITION_SPEC_SCHEMA_V1, KindContractRegistry, KindReaderRegistry, KindWriterRegistry, ObjectOperationContractError, RESOURCE_ENVELOPE_CONTRACT, RESOURCE_ENVELOPE_FINGERPRINT, RESOURCE_ENVELOPE_VERSION, RESOURCE_PACKAGE_KIND_OWNER, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_SPEC_SCHEMA_V1, ResourceCompositionError, ResourceMaterialError, ResourcePackageSourcePathError, ResourceSourceMigrationRegistry, ResourceValidationError, SkillCapsuleDistributionError, SpecResolutionRegistry, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, canonicalJson, canonicalResourcePackageSourcePath, compareCodeUnits, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createDirectoryResourcePackageReadPort, createKindContractLock, createKindSpecRevision, createKindSubjectOwner, createReaderProfile, createResourceContentIdentity, decodeResourceMetadata, digestCanonical, dirnameResourcePackageSourcePath, exactSpecVersion, isSpecVersion, joinResourcePackageSourcePath, kindDefinitionPackage, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, loadResourceTreeFromReadPort, planSkillCapsuleDistribution, readResourceMaterial, relativeResourcePackageSourcePath, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resolveResourceTree, resolveSpec, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree, validateResourceTreeFromReadPort };
+export { CODE_CLOSURE_COMPILER_IDENTITY, CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, CORE_KIND_READER_REGISTRATIONS, CORE_KIND_SPEC_REVISIONS, CORE_KIND_SUBJECT_OWNERS, CORE_RESOURCE_CONTRACT_REGISTRATIONS, CodeClosureError, KIND_DEFINITION_KIND_OWNER, KIND_DEFINITION_KIND_READER_REGISTRATION_V1, KIND_DEFINITION_KIND_SPEC_REVISION_V1, KIND_DEFINITION_SPEC_SCHEMA_V1, KindContractRegistry, KindReaderRegistry, KindWriterRegistry, ObjectOperationContractError, RESOURCE_ENVELOPE_CONTRACT, RESOURCE_ENVELOPE_FINGERPRINT, RESOURCE_ENVELOPE_VERSION, RESOURCE_PACKAGE_KIND_OWNER, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_SPEC_SCHEMA_V1, ResourceCompositionError, ResourceMaterialError, ResourcePackageSourcePathError, ResourceSourceMigrationRegistry, ResourceValidationError, SkillCapsuleDistributionError, SpecResolutionRegistry, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, canonicalJson, canonicalResourcePackageSourcePath, captureCodeClosure, compareCodeUnits, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createDirectoryResourcePackageReadPort, createKindContractLock, createKindSpecRevision, createKindSubjectOwner, createReaderProfile, createResourceContentIdentity, decodeResourceMetadata, digestCanonical, dirnameResourcePackageSourcePath, exactSpecVersion, isSpecVersion, joinResourcePackageSourcePath, kindDefinitionPackage, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillModule, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, loadResourceTreeFromReadPort, planSkillCapsuleDistribution, readResourceMaterial, relativeResourcePackageSourcePath, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resolveResourceTree, resolveSpec, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateCodeClosure, validateResourceTree, validateResourceTreeFromReadPort };

package/dist/kind-definition.d.ts

@@ -1,4 +1,4 @@
-import { B as KindSpecRevision, F as KindContractLockReader, G as ReaderProfile, H as KindWriterRegistration, I as KindReaderRegistration, J as ResourceResolutionReceipt, K as ReaderTarget, L as KindSemanticContract, M as JsonSchema, N as JsonSchemaValidator, P as KindContractLock, Pt as Sha256Digest, R as KindSourceContract, U as PortableSpec, V as KindSubjectOwner, W as PortableValue, Y as SpecResolutionDefinition, d as ResolvedResourceTree, f as ResourceDescriptor, h as ResourceKindContract, i as AuthoredResourceTree, j as CompatibilityPolicy, q as ResolvedSpec, tt as SpecVersion, z as KindSourceShape } from "./index-DboIOEr8.js";
+import { B as KindSpecRevision, Ct as Sha256Digest, F as KindContractLockReader, G as ReaderProfile, H as KindWriterRegistration, I as KindReaderRegistration, J as ResourceResolutionReceipt, K as ReaderTarget, L as KindSemanticContract, M as JsonSchema, N as JsonSchemaValidator, P as KindContractLock, R as KindSourceContract, U as PortableSpec, V as KindSubjectOwner, W as PortableValue, Y as SpecResolutionDefinition, d as ResolvedResourceTree, f as ResourceDescriptor, h as ResourceKindContract, i as AuthoredResourceTree, j as CompatibilityPolicy, q as ResolvedSpec, tt as SpecVersion, z as KindSourceShape } from "./index-By8x4reS.js";
 //#region ../kind-definition/src/versioned-contracts.d.ts
 declare class KindContractRegistry {
   private readonly ownersByKind;

package/dist/{resource-core-Brj8naBr.d.ts → resource-core-CoTu6FNS.d.ts}

@@ -1,4 +1,5 @@
-import { et as ResourceMetadata, i as AuthoredResourceTree, p as ResourceDiagnostic, st as ResourcePackageReadPort, yt as ResourceDigestContribution } from "./index-DboIOEr8.js";
+import { ct as ResourceDigestContribution, et as ResourceMetadata, i as AuthoredResourceTree, p as ResourceDiagnostic } from "./index-By8x4reS.js";
+import { a as ResourcePackageReadPort } from "./resource-package-read-port-BLBb4cz5.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,4 +1,5 @@
-import { $ as RESOURCE_ENVELOPE_VERSION, A as validateResourceTreeFromReadPort, At as ResourceOrigin, B as KindSpecRevision, C as ResourceValue, Ct as sha256Digest, D as loadResourceTree, Dt as EffectiveResourceRegistry, E as SourceShape, Et as EffectiveResourceEntry, F as KindContractLockReader, Ft as canonicalJson, G as ReaderProfile, H as KindWriterRegistration, I as KindReaderRegistration, It as compareCodeUnits, J as ResourceResolutionReceipt, K as ReaderTarget, L as KindSemanticContract, Lt as digestCanonical, M as JsonSchema, Mt as ResourceTombstoneOrigin, N as JsonSchemaValidator, Nt as composeLayeredResourceRegistry, O as loadResourceTreeFromReadPort, Ot as ResourceLayerDescriptor, P as KindContractLock, Pt as Sha256Digest, Q as RESOURCE_ENVELOPE_FINGERPRINT, R as KindSourceContract, S as ResourceValidationError, St as createResourceContentIdentity, T as ResourceValueMap, Tt as EffectiveKindDefinition, U as PortableSpec, V as KindSubjectOwner, W as PortableValue, X as CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, Y as SpecResolutionDefinition, Z as RESOURCE_ENVELOPE_CONTRACT, _ as ResourceRecord, _t as ResourceDependencyEdge, a as AuthoredResourceTreeBuildResult, at as ResourcePackageEntry, b as ResourceTree, bt as SnapshotResource, c as RegisteredKindDefinition, ct as ResourcePackageReadPortOptions, d as ResolvedResourceTree, dt as dirnameResourcePackageSourcePath, et as ResourceMetadata, f as ResourceDescriptor, ft as joinResourcePackageSourcePath, g as ResourceNode, gt as ResourceContentIdentity, h as ResourceKindContract, ht as CreateResourceContentIdentityInput, i as AuthoredResourceTree, it as ResourcePackageDirectoryEntry, j as CompatibilityPolicy, jt as ResourceTombstone, k as validateResourceTree, kt as ResourceLayerInput, l as ResolvedResourceRecord, lt as ResourcePackageSourcePathError, m as ResourceIdentity, mt as BuildResourceDependencySnapshotInput, n as AuthoredResourceRegistry, nt as isSpecVersion, o as KindSpecRevisionDescriptor, ot as ResourcePackageEntryKind, p as ResourceDiagnostic, pt as relativeResourcePackageSourcePath, q as ResolvedSpec, r as AuthoredResourceSpec, rt as ResourcePackageAwaitable, s as LoadResourceTreeOptions, st as ResourcePackageReadPort, t as AuthoredResourceRecord, tt as SpecVersion, u as ResolvedResourceRegistry, ut as canonicalResourcePackageSourcePath, v as ResourceRegistry, vt as ResourceDependencySnapshot, w as ResourceValueList, wt as ComposeLayeredResourceRegistryInput, x as ResourceTreeBuildResult, xt as buildResourceDependencySnapshot, y as ResourceScalar, yt as ResourceDigestContribution, z as KindSourceShape } from "./index-DboIOEr8.js";
-import { a as ReadResourceMaterialInput, c as readResourceMaterial, i as createDirectoryResourcePackageReadPort, l as ResourceCompositionError, n as ResourceMetadataDecodeResult, o as ResourceMaterial, r as decodeResourceMetadata, s as ResourceMaterialError, t as ResourceMetadataDecodeInput } from "./resource-core-Brj8naBr.js";
-import { n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./effective-content-identities-drMRhYE2.js";
+import { $ as RESOURCE_ENVELOPE_VERSION, A as validateResourceTreeFromReadPort, B as KindSpecRevision, C as ResourceValue, Ct as Sha256Digest, D as loadResourceTree, E as SourceShape, Et as digestCanonical, F as KindContractLockReader, G as ReaderProfile, H as KindWriterRegistration, I as KindReaderRegistration, J as ResourceResolutionReceipt, K as ReaderTarget, L as KindSemanticContract, M as JsonSchema, N as JsonSchemaValidator, O as loadResourceTreeFromReadPort, P as KindContractLock, Q as RESOURCE_ENVELOPE_FINGERPRINT, R as KindSourceContract, S as ResourceValidationError, St as composeLayeredResourceRegistry, T as ResourceValueMap, Tt as compareCodeUnits, U as PortableSpec, V as KindSubjectOwner, W as PortableValue, X as CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, Y as SpecResolutionDefinition, Z as RESOURCE_ENVELOPE_CONTRACT, _ as ResourceRecord, _t as ResourceLayerDescriptor, a as AuthoredResourceTreeBuildResult, at as ResourceContentIdentity, b as ResourceTree, bt as ResourceTombstone, c as RegisteredKindDefinition, ct as ResourceDigestContribution, d as ResolvedResourceTree, dt as createResourceContentIdentity, et as ResourceMetadata, f as ResourceDescriptor, ft as sha256Digest, g as ResourceNode, gt as EffectiveResourceRegistry, h as ResourceKindContract, ht as EffectiveResourceEntry, i as AuthoredResourceTree, it as CreateResourceContentIdentityInput, j as CompatibilityPolicy, k as validateResourceTree, l as ResolvedResourceRecord, lt as SnapshotResource, m as ResourceIdentity, mt as EffectiveKindDefinition, n as AuthoredResourceRegistry, nt as isSpecVersion, o as KindSpecRevisionDescriptor, ot as ResourceDependencyEdge, p as ResourceDiagnostic, pt as ComposeLayeredResourceRegistryInput, q as ResolvedSpec, r as AuthoredResourceSpec, rt as BuildResourceDependencySnapshotInput, s as LoadResourceTreeOptions, st as ResourceDependencySnapshot, t as AuthoredResourceRecord, tt as SpecVersion, u as ResolvedResourceRegistry, ut as buildResourceDependencySnapshot, v as ResourceRegistry, vt as ResourceLayerInput, w as ResourceValueList, wt as canonicalJson, x as ResourceTreeBuildResult, xt as ResourceTombstoneOrigin, y as ResourceScalar, yt as ResourceOrigin, z as KindSourceShape } from "./index-By8x4reS.js";
+import { a as ResourcePackageReadPort, c as canonicalResourcePackageSourcePath, d as relativeResourcePackageSourcePath, i as ResourcePackageEntryKind, l as dirnameResourcePackageSourcePath, n as ResourcePackageDirectoryEntry, o as ResourcePackageReadPortOptions, r as ResourcePackageEntry, s as ResourcePackageSourcePathError, t as ResourcePackageAwaitable, u as joinResourcePackageSourcePath } from "./resource-package-read-port-BLBb4cz5.js";
+import { a as ReadResourceMaterialInput, c as readResourceMaterial, i as createDirectoryResourcePackageReadPort, l as ResourceCompositionError, n as ResourceMetadataDecodeResult, o as ResourceMaterial, r as decodeResourceMetadata, s as ResourceMaterialError, t as ResourceMetadataDecodeInput } from "./resource-core-CoTu6FNS.js";
+import { n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./effective-content-identities-Cf0ygCXk.js";
 export { AuthoredResourceRecord, AuthoredResourceRegistry, AuthoredResourceSpec, AuthoredResourceTree, AuthoredResourceTreeBuildResult, BuildResourceDependencySnapshotInput, CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, CompatibilityPolicy, ComposeLayeredResourceRegistryInput, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, JsonSchema, JsonSchemaValidator, KindContractLock, KindContractLockReader, KindReaderRegistration, KindSemanticContract, KindSourceContract, KindSourceShape, KindSpecRevision, KindSpecRevisionDescriptor, KindSubjectOwner, KindWriterRegistration, LoadResourceTreeOptions, PortableSpec, PortableValue, RESOURCE_ENVELOPE_CONTRACT, RESOURCE_ENVELOPE_FINGERPRINT, RESOURCE_ENVELOPE_VERSION, ReadResourceMaterialInput, ReaderProfile, ReaderTarget, RegisteredKindDefinition, ResolveEffectiveResourceContentIdentitiesInput, ResolvedResourceRecord, ResolvedResourceRegistry, ResolvedResourceTree, ResolvedSpec, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMaterial, ResourceMaterialError, ResourceMetadata, ResourceMetadataDecodeInput, ResourceMetadataDecodeResult, ResourceNode, ResourceOrigin, ResourcePackageAwaitable, ResourcePackageDirectoryEntry, ResourcePackageEntry, ResourcePackageEntryKind, ResourcePackageReadPort, ResourcePackageReadPortOptions, ResourcePackageSourcePathError, ResourceRecord, ResourceRegistry, ResourceResolutionReceipt, ResourceScalar, ResourceTombstone, ResourceTombstoneOrigin, ResourceTree, ResourceTreeBuildResult, ResourceValidationError, ResourceValue, ResourceValueList, ResourceValueMap, type Sha256Digest, SnapshotResource, SourceShape, SpecResolutionDefinition, SpecVersion, buildResourceDependencySnapshot, canonicalJson, canonicalResourcePackageSourcePath, compareCodeUnits, composeLayeredResourceRegistry, createDirectoryResourcePackageReadPort, createResourceContentIdentity, decodeResourceMetadata, digestCanonical, dirnameResourcePackageSourcePath, isSpecVersion, joinResourcePackageSourcePath, loadResourceTree, loadResourceTreeFromReadPort, readResourceMaterial, relativeResourcePackageSourcePath, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree, validateResourceTreeFromReadPort };

package/dist/resource-package-read-port-BLBb4cz5.d.ts

@@ -0,0 +1,33 @@
+//#region ../resource-core/src/resource-package-read-port.d.ts
+type ResourcePackageAwaitable<T> = T | PromiseLike<T>;
+type ResourcePackageEntryKind = "file" | "directory" | "symlink" | "other";
+interface ResourcePackageEntry {
+  readonly kind: ResourcePackageEntryKind;
+}
+interface ResourcePackageDirectoryEntry extends ResourcePackageEntry {
+  readonly name: string;
+}
+/**
+ * Storage-neutral source effect for one already-materialized ResourcePackage
+ * file view. Paths are canonical POSIX absolute coordinates scoped to the
+ * provider; they are never semantic resource provenance.
+ */
+interface ResourcePackageReadPort {
+  stat(sourcePath: string): ResourcePackageAwaitable<ResourcePackageEntry | undefined>;
+  readDirectory(sourcePath: string): ResourcePackageAwaitable<readonly ResourcePackageDirectoryEntry[] | undefined>;
+  readBytes(sourcePath: string): ResourcePackageAwaitable<Uint8Array | undefined>;
+}
+interface ResourcePackageReadPortOptions {
+  readonly port: ResourcePackageReadPort;
+  readonly rootPath?: string;
+  readonly manifestPath?: string;
+}
+declare class ResourcePackageSourcePathError extends TypeError {
+  constructor(message: string);
+}
+declare function canonicalResourcePackageSourcePath(input: string): string;
+declare function joinResourcePackageSourcePath(base: string, ...segments: readonly string[]): string;
+declare function dirnameResourcePackageSourcePath(sourcePath: string): string;
+declare function relativeResourcePackageSourcePath(rootPath: string, sourcePath: string): string | undefined;
+//#endregion
+export { ResourcePackageReadPort as a, canonicalResourcePackageSourcePath as c, relativeResourcePackageSourcePath as d, ResourcePackageEntryKind as i, dirnameResourcePackageSourcePath as l, ResourcePackageDirectoryEntry as n, ResourcePackageReadPortOptions as o, ResourcePackageEntry as r, ResourcePackageSourcePathError as s, ResourcePackageAwaitable as t, joinResourcePackageSourcePath as u };

package/dist/resource-projection.d.ts

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

package/dist/skill-capsule.d.ts

@@ -1,3 +1,3 @@
 import { I as SkillCapsuleDependency } from "./index-DEikbOFh.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-CR7wJSSX.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-B9Pp3Zgj.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-DLJUCH0M.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-QI7NRyC8.js";
 export { SkillCapsuleDistributionError, applySkillCapsuleDistributionPlan, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, planSkillCapsuleDistribution, skillCapsuleDistributionProjection };

package/dist/{src-B0Hja_dk.js → src-BX7wrSq1.js}

@@ -1,7 +1,9 @@
-import { n as loadResourceTree } from "./src-jggOQtq3.js";
+import { E as canonicalResourcePackageSourcePath, n as loadResourceTree } from "./src-jggOQtq3.js";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { parse } from "yaml";
+import { createHash } from "node:crypto";
+import ts from "typescript";
 //#region ../application-assembly/src/internal-bindings.ts
 const bindingsByDefinition = /* @__PURE__ */ new WeakMap();
 const compilationsByAssembly = /* @__PURE__ */ new WeakMap();
@@ -24,6 +26,328 @@ function resolveObjectOperationCompilation(assembly, operationRef) {
 	return compilation;
 }
 //#endregion
+//#region ../application-assembly/src/code-execution-closure.ts
+/** The complete emit profile is versioned; changing it invalidates old closures. */
+const CODE_CLOSURE_COMPILER_IDENTITY = "typescript@5.9.3/commonjs-es2022-interop/closure-v2";
+var CodeClosureError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(`${code}: ${message}`);
+		this.code = code;
+		this.name = "CodeClosureError";
+	}
+};
+function fail$1(code, message) {
+	throw new CodeClosureError(code, message);
+}
+/** Reject active objects before reading values or invoking JSON serialization. */
+function assertJsonData(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return;
+	if (typeof value !== "object") fail$1("invalid-closure-data", "Expected closed JSON data");
+	if (ancestors.has(value)) fail$1("invalid-closure-data", "Cyclic closure data is unsupported");
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== (Array.isArray(value) ? Array.prototype : Object.prototype) && prototype !== null) fail$1("invalid-closure-data", "Exotic closure objects are unsupported");
+	ancestors.add(value);
+	for (const key of Reflect.ownKeys(value)) {
+		if (Array.isArray(value) && key === "length") continue;
+		const property = Object.getOwnPropertyDescriptor(value, key);
+		if (typeof key !== "string" || !property.enumerable || !("value" in property)) fail$1("invalid-closure-data", "Accessors and non-JSON properties are unsupported");
+		if (Array.isArray(value) && (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length)) fail$1("invalid-closure-data", "Array properties must be indexes");
+		assertJsonData(property.value, ancestors);
+	}
+	if (Array.isArray(value) && Object.keys(value).length !== value.length) fail$1("invalid-closure-data", "Sparse arrays are unsupported");
+	ancestors.delete(value);
+}
+function comparePaths(a, b) {
+	if (a < b) return -1;
+	return a > b ? 1 : 0;
+}
+function stable(value) {
+	if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stable(value[key])}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function digest(value) {
+	return createHash("sha256").update(stable(value)).digest("hex");
+}
+function contentDigest(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function freeze(value) {
+	if (value && typeof value === "object") {
+		for (const child of Object.values(value)) freeze(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+function relativePath(path) {
+	if (!path || path.startsWith("/") || path.includes("\\") || path.includes("\0") || path.includes("?") || path.includes("#") || path.split("/").some((part) => !part || part === "." || part === "..")) fail$1("invalid-path", `Noncanonical closure path: ${path}`);
+	return path;
+}
+function localTarget(from, specifier) {
+	if (!specifier.startsWith("./") && !specifier.startsWith("../")) fail$1("outside-source-root", `Unsupported local path ${specifier}`);
+	if (/[\\\0?#]/.test(specifier)) fail$1("invalid-path", `Unsupported module specifier ${specifier}`);
+	const parts = from.split("/").slice(0, -1);
+	for (const part of specifier.split("/")) {
+		if (part === ".") continue;
+		if (part === "..") {
+			if (!parts.length) fail$1("outside-source-root", `${from} imports outside source root: ${specifier}`);
+			parts.pop();
+		} else {
+			if (!part) fail$1("invalid-path", specifier);
+			parts.push(part);
+		}
+	}
+	return relativePath(parts.join("/"));
+}
+const codeExtension = /\.(?:[cm]?[jt]s)$/;
+function candidates(target) {
+	if (codeExtension.test(target)) {
+		const substituted = target.replace(/\.js$/, ".ts").replace(/\.mjs$/, ".mts").replace(/\.cjs$/, ".cts");
+		return [.../* @__PURE__ */ new Set([substituted, target])];
+	}
+	if (/\.[^/]+$/.test(target)) return [target];
+	return [target, ...[
+		".ts",
+		".js",
+		".mts",
+		".mjs",
+		".cts",
+		".cjs",
+		"/index.ts",
+		"/index.js"
+	].map((extension) => target + extension)];
+}
+function checkEnvironment(environment) {
+	assertJsonData(environment);
+	if (!environment || typeof environment.hostIdentity !== "string" || !environment.hostIdentity || !environment.ambient || Array.isArray(environment.ambient) || typeof environment.ambient !== "object") fail$1("invalid-environment", "Expected host identity and ambient identities");
+	for (const [specifier, identity] of Object.entries(environment.ambient)) if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || /[\\\0]/.test(specifier) || typeof identity !== "string" || !identity) fail$1("invalid-environment", `Invalid ambient identity: ${specifier}`);
+}
+function bindingEntry(binding) {
+	if (!binding || typeof binding.packageName !== "string" || !binding.packageName || typeof binding.exportName !== "string" || !binding.exportName || typeof binding.module !== "string" || !binding.module.startsWith("./")) fail$1("invalid-binding", "Closure binding requires a package-owned ./ module and export");
+	const entry = relativePath(binding.module.slice(2));
+	if (binding.moduleSpecifier !== `${binding.packageName}/${entry}`) fail$1("invalid-binding", "CodeBinding moduleSpecifier does not match package/module");
+	return entry;
+}
+function compile(path, source) {
+	if (ts.version !== "5.9.3") fail$1("compiler-mismatch", `Expected TypeScript 5.9.3; found ${ts.version}`);
+	const tree = ts.createSourceFile(path, source, ts.ScriptTarget.ES2022, true, /\.[cm]?js$/.test(path) ? ts.ScriptKind.JS : ts.ScriptKind.TS);
+	const specifiers = /* @__PURE__ */ new Set();
+	const walk = (node, functionDepth) => {
+		if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) fail$1("unsupported-dynamic-import", `${path}: dynamic import cannot be frozen`);
+		if (ts.isIdentifier(node) && node.text === "require") fail$1("unsupported-require", `${path}: require and aliases are unsupported; use static imports`);
+		if (ts.isImportEqualsDeclaration(node)) fail$1("unsupported-require", `${path}: import-equals is unsupported`);
+		if (ts.isMetaProperty(node) && node.keywordToken === ts.SyntaxKind.ImportKeyword) fail$1("unsupported-import-meta", `${path}: import.meta is unsupported`);
+		if (!functionDepth && (ts.isAwaitExpression(node) || ts.isForOfStatement(node) && node.awaitModifier)) fail$1("unsupported-top-level-await", `${path}: top-level await is unsupported`);
+		if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier) {
+			if (ts.isImportDeclaration(node) && node.importClause) {
+				const clause = node.importClause;
+				if (clause.isTypeOnly || !clause.name && clause.namedBindings && ts.isNamedImports(clause.namedBindings) && clause.namedBindings.elements.length > 0 && clause.namedBindings.elements.every((element) => element.isTypeOnly)) return;
+			}
+			if (ts.isExportDeclaration(node) && (node.isTypeOnly || node.exportClause && ts.isNamedExports(node.exportClause) && node.exportClause.elements.length > 0 && node.exportClause.elements.every((element) => element.isTypeOnly))) return;
+			if (!ts.isStringLiteral(node.moduleSpecifier)) fail$1("unsupported-import", `${path}: module specifier must be a string literal`);
+			if (node.attributes) fail$1("unsupported-import-attributes", `${path}: use declared closure assets without import attributes`);
+			specifiers.add(node.moduleSpecifier.text);
+		}
+		ts.forEachChild(node, (child) => walk(child, functionDepth + (ts.isFunctionLike(node) ? 1 : 0)));
+	};
+	walk(tree, 0);
+	const emitPath = path.replace(/\.mts$/, ".ts").replace(/\.mjs$/, ".js");
+	const emitted = ts.transpileModule(source, {
+		fileName: emitPath,
+		reportDiagnostics: true,
+		compilerOptions: {
+			target: ts.ScriptTarget.ES2022,
+			module: ts.ModuleKind.CommonJS,
+			esModuleInterop: true,
+			sourceMap: false,
+			inlineSourceMap: false,
+			removeComments: false
+		}
+	});
+	const errors = emitted.diagnostics?.filter((item) => item.category === ts.DiagnosticCategory.Error) ?? [];
+	if (errors.length) fail$1("invalid-source", `${path}: ${errors.map((item) => ts.flattenDiagnosticMessageText(item.messageText, " ")).join("; ")}`);
+	return {
+		code: emitted.outputText,
+		specifiers: [...specifiers].sort()
+	};
+}
+async function captureCodeClosure(runtime, input) {
+	checkEnvironment(input.environment);
+	const root = canonicalResourcePackageSourcePath(input.sourceRoot);
+	const sourcePath = canonicalResourcePackageSourcePath(input.entryPath);
+	const bindingPath = bindingEntry(input.binding);
+	const absolute = (path) => root === "/" ? `/${path}` : `${root}/${path}`;
+	const entryPath = candidates(bindingPath).find((candidate) => absolute(candidate) === sourcePath);
+	if (!entryPath) fail$1("invalid-binding", "entryPath must resolve CodeBinding.module within sourceRoot");
+	const declarations = { ...input.assets };
+	for (const [path, format] of Object.entries(declarations)) {
+		relativePath(path);
+		if (format !== "text" && format !== "json") fail$1("invalid-asset", `Unsupported asset format: ${format}`);
+		if (codeExtension.test(path)) fail$1("invalid-asset", `Code cannot be declared as an asset: ${path}`);
+	}
+	const modules = /* @__PURE__ */ new Map();
+	const assets = /* @__PURE__ */ new Map();
+	const hasFile = async (path) => {
+		const segments = absolute(path).slice(1).split("/");
+		for (let i = 1; i <= segments.length; i++) {
+			const prefix = `/${segments.slice(0, i).join("/")}`;
+			const info = await runtime.source.stat(prefix);
+			if (info?.kind === "symlink") fail$1("symlink-source", `Symlink source is unsupported: ${prefix}`);
+			if (i === segments.length) return info?.kind === "file";
+		}
+		return false;
+	};
+	const read = async (path) => {
+		if (!await hasFile(path)) fail$1("missing-source", `Missing source file: ${path}`);
+		const bytes = await runtime.source.readBytes(absolute(path));
+		if (!bytes) fail$1("missing-source", `Unreadable source file: ${path}`);
+		try {
+			return new TextDecoder("utf-8", {
+				fatal: true,
+				ignoreBOM: true
+			}).decode(bytes);
+		} catch {
+			return fail$1("invalid-source", `Expected UTF-8: ${path}`);
+		}
+	};
+	const visit = async (path) => {
+		if (modules.has(path)) return;
+		if (!codeExtension.test(path) || /\.d\.[cm]?ts$/.test(path)) fail$1("unsupported-module", `Expected executable TS/JS module: ${path}`);
+		const source = await read(path);
+		const result = compile(path, source);
+		const dependencies = [];
+		modules.set(path, {
+			path,
+			source,
+			sourceDigest: contentDigest(source),
+			code: result.code,
+			codeDigest: contentDigest(result.code),
+			dependencies
+		});
+		for (const specifier of result.specifiers) if (specifier.startsWith(".")) {
+			const target = localTarget(path, specifier);
+			if (Object.hasOwn(declarations, target)) dependencies.push({
+				specifier,
+				kind: "asset",
+				target
+			});
+			else {
+				if (!codeExtension.test(target) && /\.[^/]+$/.test(target)) fail$1("undeclared-asset", `${path}: asset must be declared: ${specifier}`);
+				let resolved;
+				for (const candidate of candidates(target)) if (await hasFile(candidate)) {
+					resolved = candidate;
+					break;
+				}
+				if (!resolved) fail$1("missing-module", `${path}: cannot freeze ${specifier}`);
+				dependencies.push({
+					specifier,
+					kind: "module",
+					target: resolved
+				});
+				await visit(resolved);
+			}
+		} else {
+			if (specifier.startsWith("/") || specifier.startsWith("file:") || specifier.includes("\\")) fail$1("outside-source-root", `${path}: ${specifier}`);
+			if (!Object.hasOwn(input.environment.ambient, specifier)) fail$1("undeclared-ambient", `${path}: ambient dependency not declared: ${specifier}`);
+			dependencies.push({
+				specifier,
+				kind: "ambient",
+				target: specifier
+			});
+		}
+	};
+	await visit(entryPath);
+	for (const [path, format] of Object.entries(declarations).sort(([a], [b]) => comparePaths(a, b))) {
+		const content = await read(path);
+		if (format === "json") try {
+			JSON.parse(content);
+		} catch {
+			fail$1("invalid-asset", `Invalid JSON asset: ${path}`);
+		}
+		assets.set(path, {
+			path,
+			format,
+			content,
+			contentDigest: contentDigest(content)
+		});
+	}
+	const payload = {
+		format: "halfcode-code-closure/v1",
+		compilerIdentity: CODE_CLOSURE_COMPILER_IDENTITY,
+		binding: { ...input.binding },
+		entryPath,
+		environment: {
+			hostIdentity: input.environment.hostIdentity,
+			ambient: { ...input.environment.ambient }
+		},
+		modules: [...modules.values()].sort((a, b) => comparePaths(a.path, b.path)),
+		assets: [...assets.values()]
+	};
+	const closure = {
+		...payload,
+		digest: digest(payload)
+	};
+	validateCodeClosure(closure, input.environment, closure.digest);
+	return freeze(closure);
+}
+/** Pure validation: no source reader, live imports, or module execution. */
+function validateCodeClosure(closure, environment, expectedDigest) {
+	if (typeof expectedDigest !== "string" || !/^[a-f0-9]{64}$/.test(expectedDigest)) fail$1("invalid-digest", "A trusted expected digest is required");
+	assertJsonData(closure);
+	if (!closure || typeof closure !== "object" || closure.digest !== expectedDigest) fail$1("digest-mismatch", "Closure differs from the trusted expected digest");
+	const { digest: actualDigest, ...payload } = closure;
+	if (digest(payload) !== actualDigest) fail$1("digest-mismatch", "Closure contents do not match digest");
+	if (closure.format !== "halfcode-code-closure/v1") fail$1("unsupported-format", "Unsupported code closure format");
+	if (closure.compilerIdentity !== "typescript@5.9.3/commonjs-es2022-interop/closure-v2" || ts.version !== "5.9.3") fail$1("compiler-mismatch", "Closure compiler identity mismatch");
+	checkEnvironment(environment);
+	checkEnvironment(closure.environment);
+	if (stable(environment) !== stable(closure.environment)) fail$1("environment-mismatch", "Execution environment identity mismatch");
+	if (!candidates(bindingEntry(closure.binding)).includes(closure.entryPath)) fail$1("invalid-binding", "Closure entry does not match binding");
+	if (!Array.isArray(closure.modules) || !Array.isArray(closure.assets)) fail$1("invalid-closure", "Expected modules and assets");
+	const modules = /* @__PURE__ */ new Map();
+	const assets = /* @__PURE__ */ new Map();
+	for (const module of closure.modules) {
+		relativePath(module.path);
+		if (!codeExtension.test(module.path) || /\.d\.[cm]?ts$/.test(module.path) || modules.has(module.path) || typeof module.source !== "string" || typeof module.code !== "string" || !Array.isArray(module.dependencies)) fail$1("invalid-module", `Invalid module: ${module.path}`);
+		if (module.sourceDigest !== contentDigest(module.source) || module.codeDigest !== contentDigest(module.code)) fail$1("file-digest-mismatch", `Module content digest mismatch: ${module.path}`);
+		modules.set(module.path, module);
+	}
+	for (const asset of closure.assets) {
+		relativePath(asset.path);
+		if (assets.has(asset.path) || modules.has(asset.path) || codeExtension.test(asset.path) || typeof asset.content !== "string" || !["text", "json"].includes(asset.format)) fail$1("invalid-asset", `Invalid asset: ${asset.path}`);
+		if (asset.contentDigest !== contentDigest(asset.content)) fail$1("file-digest-mismatch", `Asset content digest mismatch: ${asset.path}`);
+		if (asset.format === "json") try {
+			JSON.parse(asset.content);
+		} catch {
+			fail$1("invalid-asset", `Invalid JSON asset: ${asset.path}`);
+		}
+		assets.set(asset.path, asset);
+	}
+	if (!modules.has(closure.entryPath)) fail$1("missing-entry", "Closure entry module is absent");
+	for (const module of modules.values()) {
+		const compiled = compile(module.path, module.source);
+		if (compiled.code !== module.code) fail$1("invalid-emit", `Compiled code differs from frozen source: ${module.path}`);
+		if (stable(compiled.specifiers) !== stable(module.dependencies.map((edge) => edge.specifier).sort())) fail$1("invalid-edge", `Dependency set differs from source: ${module.path}`);
+		for (const edge of module.dependencies) {
+			if (edge.specifier.startsWith(".")) {
+				const target = localTarget(module.path, edge.specifier);
+				if (edge.kind === "asset" && edge.target === target && assets.has(edge.target)) continue;
+				if (edge.kind === "module" && candidates(target).includes(edge.target) && modules.has(edge.target)) continue;
+			} else if (edge.kind === "ambient" && edge.target === edge.specifier && Object.hasOwn(environment.ambient, edge.target) && !edge.target.startsWith("/") && !edge.target.startsWith("file:")) continue;
+			fail$1("invalid-edge", `Invalid dependency target: ${module.path} -> ${edge.specifier}`);
+		}
+	}
+	const reachable = /* @__PURE__ */ new Set();
+	const visit = (path) => {
+		if (reachable.has(path)) return;
+		reachable.add(path);
+		for (const edge of modules.get(path).dependencies) if (edge.kind === "module") visit(edge.target);
+	};
+	visit(closure.entryPath);
+	if (reachable.size !== modules.size) fail$1("invalid-closure", "Closure contains unreachable modules");
+}
+//#endregion
 //#region ../application-assembly/src/index.ts
 var ObjectOperationContractError = class extends TypeError {
 	code;
@@ -642,4 +966,4 @@ const applicationAssemblyPackage = {
 	owns: "resource registry facts normalized for target-neutral compiler projections"
 };
 //#endregion
-export { assertObjectOperationCatalog as a, resolveApplicationAssembly as c, assertObjectOperationCall as i, resourceRefToFqn as l, applicationAssemblyPackage as n, assertObjectOperationDefinition as o, assertExecuteObjectOperationRequest as r, loadApplicationAssembly as s, ObjectOperationContractError as t, resolveObjectOperationCompilation as u };
+export { assertObjectOperationCatalog as a, resolveApplicationAssembly as c, CodeClosureError as d, captureCodeClosure as f, assertObjectOperationCall as i, resourceRefToFqn as l, resolveObjectOperationCompilation as m, applicationAssemblyPackage as n, assertObjectOperationDefinition as o, validateCodeClosure as p, assertExecuteObjectOperationRequest as r, loadApplicationAssembly as s, ObjectOperationContractError as t, CODE_CLOSURE_COMPILER_IDENTITY as u };

package/dist/{src-hrUy4DJ9.js → src-MPJZB76z.js}

@@ -1,5 +1,6 @@
 import { d as isSpecVersion, u as RESOURCE_ENVELOPE_VERSION } from "./src-jggOQtq3.js";
 import { t as resolveEffectiveResourceContentIdentities } from "./effective-content-identities-CV6XFBZy.js";
+import { d as CodeClosureError, p as validateCodeClosure } from "./src-BX7wrSq1.js";
 import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region ../runtime-authoring/src/resource-authoring.ts
@@ -600,6 +601,55 @@ function fail(code, message) {
 	throw new ResourceAuthoringError(code, message);
 }
 //#endregion
+//#region ../runtime-authoring/src/code-execution.ts
+/** Each restore owns a fresh module table; this is not an untrusted-code sandbox. */
+function restoreCodeClosure(runtime, input, expectedDigest) {
+	validateCodeClosure(input, runtime.environment, expectedDigest);
+	const closure = JSON.parse(JSON.stringify(input));
+	const ambient = /* @__PURE__ */ new Map();
+	for (const name of Object.keys(closure.environment.ambient)) {
+		if (!runtime.ambientModules || !Object.hasOwn(runtime.ambientModules, name)) throw new CodeClosureError("missing-ambient", `Missing explicit ambient exports: ${name}`);
+		ambient.set(name, runtime.ambientModules[name]);
+	}
+	const modules = new Map(closure.modules.map((module) => [module.path, module]));
+	const assets = new Map(closure.assets.map((asset) => [asset.path, asset.format === "json" ? JSON.parse(asset.content) : asset.content]));
+	const table = /* @__PURE__ */ new Map();
+	const load = (path) => {
+		const cached = table.get(path);
+		if (cached) return cached.exports;
+		const source = modules.get(path);
+		if (!source) throw new CodeClosureError("missing-module", `Frozen module absent: ${path}`);
+		const module = { exports: {} };
+		table.set(path, module);
+		const edges = new Map(source.dependencies.map((edge) => [edge.specifier, edge]));
+		const requireFrozen = (specifier) => {
+			const edge = edges.get(specifier);
+			if (!edge) throw new CodeClosureError("undeclared-dependency", `No frozen edge for ${path}: ${specifier}`);
+			if (edge.kind === "module") return load(edge.target);
+			if (edge.kind === "asset") return assets.get(edge.target);
+			return ambient.get(edge.target);
+		};
+		try {
+			new Function("require", "module", "exports", source.code)(requireFrozen, module, module.exports);
+			return module.exports;
+		} catch (error) {
+			table.delete(path);
+			throw error;
+		}
+	};
+	return Object.freeze({
+		binding: Object.freeze(closure.binding),
+		closureDigest: closure.digest,
+		exports: load(closure.entryPath)
+	});
+}
+function bindCodeClosure(runtime, closure, expectedDigest) {
+	const restored = restoreCodeClosure(runtime, closure, expectedDigest);
+	const callable = restored.exports[restored.binding.exportName];
+	if (typeof callable !== "function") throw new CodeClosureError("missing-export", `CodeBinding export is not callable: ${restored.binding.exportName}`);
+	return (...args) => Reflect.apply(callable, void 0, args);
+}
+//#endregion
 //#region ../runtime-authoring/src/index.ts
 const runtimeScope = new AsyncLocalStorage();
 function runWithRuntime(runtime, callback) {
@@ -637,4 +687,4 @@ const runtimeAuthoringPackage = {
 	owns: "target-neutral deterministic-code runtime and effect boundary"
 };
 //#endregion
-export { runWithRuntime as a, ResourceAuthoringError as c, planResourceAuthoring as d, logger as i, applyResourceAuthoring as l, currentRuntime as n, runtimeAuthoringPackage as o, invokeEffect as r, RESOURCE_AUTHORING_SCHEMA_VERSION as s, createAuthoringBindings as t, deriveResourceAuthoringRegistryRevision as u };
+export { runWithRuntime as a, restoreCodeClosure as c, applyResourceAuthoring as d, deriveResourceAuthoringRegistryRevision as f, logger as i, RESOURCE_AUTHORING_SCHEMA_VERSION as l, currentRuntime as n, runtimeAuthoringPackage as o, planResourceAuthoring as p, invokeEffect as r, bindCodeClosure as s, createAuthoringBindings as t, ResourceAuthoringError as u };

package/dist/{src-DLJUCH0M.js → src-QI7NRyC8.js}

@@ -1,4 +1,4 @@
-import { l as resourceRefToFqn, u as resolveObjectOperationCompilation } from "./src-B0Hja_dk.js";
+import { l as resourceRefToFqn, m as resolveObjectOperationCompilation } from "./src-BX7wrSq1.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/testing.js

@@ -1,4 +1,4 @@
-import { a as runWithRuntime } from "./src-hrUy4DJ9.js";
+import { a as runWithRuntime } from "./src-MPJZB76z.js";
 //#region ../runtime-mock/src/index.ts
 function createMockRuntime(options = {}) {
 	const effectCalls = [];

package/package.json

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