halfcode-compiler.xnl 0.2.9 → 0.3.1

package/dist/resource-core-CoTu6FNS.d.ts

@@ -0,0 +1,48 @@
+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[];
+  constructor(diagnostics: readonly ResourceDiagnostic[]);
+}
+//#endregion
+//#region ../resource-core/src/resource-material.d.ts
+interface ReadResourceMaterialInput {
+  readonly tree: AuthoredResourceTree;
+  readonly rootDir: string;
+  readonly resourceId: string;
+  readonly uri: string;
+}
+interface ResourceMaterial {
+  readonly resourceId: string;
+  readonly uri: string;
+  readonly sourceUri: string;
+  readonly digest: string;
+  readonly contribution: ResourceDigestContribution;
+  bytes(): Uint8Array;
+}
+declare class ResourceMaterialError extends Error {
+  readonly diagnostics: readonly ResourceDiagnostic[];
+  constructor(diagnostics: readonly ResourceDiagnostic[]);
+}
+declare function readResourceMaterial(input: ReadResourceMaterialInput): Promise<ResourceMaterial>;
+//#endregion
+//#region ../resource-core/src/directory-resource-package-read-port.d.ts
+declare function createDirectoryResourcePackageReadPort(rootDir: string): Promise<ResourcePackageReadPort>;
+//#endregion
+//#region ../resource-core/src/resource-envelope.d.ts
+interface ResourceMetadataDecodeInput {
+  readonly fields: Readonly<Record<string, unknown>>;
+  readonly removedFieldContainers?: readonly Readonly<Record<string, unknown>>[];
+  readonly lifecycle?: unknown;
+  readonly location: string;
+  readonly source: "XNL" | "Markdown";
+}
+type ResourceMetadataDecodeResult = Readonly<{
+  metadata: ResourceMetadata;
+}> | Readonly<{
+  diagnostic: ResourceDiagnostic;
+}>;
+declare function decodeResourceMetadata(input: ResourceMetadataDecodeInput): ResourceMetadataDecodeResult;
+//#endregion
+export { ReadResourceMaterialInput as a, readResourceMaterial as c, createDirectoryResourcePackageReadPort as i, ResourceCompositionError as l, ResourceMetadataDecodeResult as n, ResourceMaterial as o, decodeResourceMetadata as r, ResourceMaterialError as s, ResourceMetadataDecodeInput as t };

package/dist/resource-core.d.ts

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

@@ -1,5 +1,5 @@
-import { a as isLoadedResourceTreeAuthentic, c as sha256Digest, d as markEffectiveRegistryAuthentic, f as ResourceCompositionError, i as readonlyMap, m as digestCanonical, n as loadResourceTree, o as buildResourceDependencySnapshot, p as compareCodeUnits, r as validateResourceTree, s as createResourceContentIdentity, t as ResourceValidationError } from "./src-D3qSzGFn.js";
-import { t as resolveEffectiveResourceContentIdentities } from "./effective-content-identities-DV5fTr5Q.js";
+import { 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, f as readonlyMap, 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, p as isAuthoredResourceTreeAuthentic, r as loadResourceTreeFromReadPort, s as CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, t as ResourceValidationError, u as RESOURCE_ENVELOPE_VERSION, w as createDirectoryResourcePackageReadPort, x as canonicalJson, y as markEffectiveRegistryAuthentic } from "./src-jggOQtq3.js";
+import { t as resolveEffectiveResourceContentIdentities } from "./effective-content-identities-CV6XFBZy.js";
 import { lstat, readFile, realpath } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 //#region ../resource-core/src/layered-registry.ts
@@ -236,9 +236,9 @@ function cloneResourceRecord(resource) {
 }
 function cloneResourceMetadata(metadata) {
 	return Object.freeze({
-		apiVersion: metadata.apiVersion,
-		...metadata.lifecycle === void 0 ? {} : { lifecycle: metadata.lifecycle },
-		...metadata.version === void 0 ? {} : { version: metadata.version }
+		envelopeVersion: metadata.envelopeVersion,
+		specVersion: metadata.specVersion,
+		...metadata.lifecycle === void 0 ? {} : { lifecycle: metadata.lifecycle }
 	});
 }
 function cloneResourceValue(value) {
@@ -252,10 +252,17 @@ function cloneRegisteredKindDefinition(definition) {
 	return Object.freeze({
 		resourceId: definition.resourceId,
 		resourceKind: definition.resourceKind,
+		subjectFqn: definition.subjectFqn,
 		sourceShapes: Object.freeze([...definition.sourceShapes].sort(compareCodeUnits)),
 		requiredFiles: Object.freeze([...definition.requiredFiles].sort(compareCodeUnits)),
-		currentApiVersion: definition.currentApiVersion,
-		supportedApiVersions: Object.freeze([...definition.supportedApiVersions].sort(compareCodeUnits)),
+		specRevisions: Object.freeze(definition.specRevisions.map((revision) => Object.freeze({
+			specVersion: revision.specVersion,
+			schemaRef: revision.schemaRef,
+			schemaFingerprint: revision.schemaFingerprint,
+			contractFingerprint: revision.contractFingerprint,
+			semanticContract: Object.freeze({ ...revision.semanticContract }),
+			stability: revision.stability
+		})).sort((left, right) => left.specVersion - right.specVersion)),
 		documentCardinality: definition.documentCardinality,
 		documentUri: definition.documentUri
 	});
@@ -263,10 +270,17 @@ function cloneRegisteredKindDefinition(definition) {
 function normalizedKindContract(definition) {
 	return {
 		resourceKind: definition.resourceKind,
+		subjectFqn: definition.subjectFqn,
 		sourceShapes: [...definition.sourceShapes].sort(compareCodeUnits),
 		requiredFiles: [...definition.requiredFiles].sort(compareCodeUnits),
-		currentApiVersion: definition.currentApiVersion,
-		supportedApiVersions: [...definition.supportedApiVersions].sort(compareCodeUnits),
+		specRevisions: definition.specRevisions.map((revision) => ({
+			specVersion: revision.specVersion,
+			schemaRef: revision.schemaRef,
+			schemaFingerprint: revision.schemaFingerprint,
+			contractFingerprint: revision.contractFingerprint,
+			semanticContract: revision.semanticContract,
+			stability: revision.stability
+		})),
 		documentCardinality: definition.documentCardinality
 	};
 }
@@ -326,7 +340,7 @@ var ResourceMaterialError = class extends Error {
 	}
 };
 async function readResourceMaterial(input) {
-	if (!isLoadedResourceTreeAuthentic(input.tree)) throw materialError("RESOURCE_MATERIAL_TREE_UNTRUSTED", input.resourceId, "Resource materials require an authentic LoadedResourceTree.");
+	if (!isAuthoredResourceTreeAuthentic(input.tree)) throw materialError("RESOURCE_MATERIAL_TREE_UNTRUSTED", input.resourceId, "Resource materials require an authentic AuthoredResourceTree.");
 	const record = findResource(input.tree, input.resourceId);
 	const identity = input.tree.contentIdentities.get(input.resourceId);
 	if (!record || record.sourceShape !== "directory" || !identity) throw materialError("RESOURCE_MATERIAL_RESOURCE_INVALID", input.resourceId, `Resource '${input.resourceId}' is not an authentic directory resource.`);
@@ -400,4 +414,4 @@ function materialError(code, resourceId, message) {
 	})]);
 }
 //#endregion
-export { ResourceCompositionError, ResourceMaterialError, ResourceValidationError, buildResourceDependencySnapshot, composeLayeredResourceRegistry, createResourceContentIdentity, loadResourceTree, readResourceMaterial, resolveEffectiveResourceContentIdentities, sha256Digest, validateResourceTree };
+export { CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS, RESOURCE_ENVELOPE_CONTRACT, RESOURCE_ENVELOPE_FINGERPRINT, RESOURCE_ENVELOPE_VERSION, ResourceCompositionError, ResourceMaterialError, ResourcePackageSourcePathError, ResourceValidationError, 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-CF4nEkOi.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-Cqh9pEBa.js";
-import { S as skillCapsuleDistributionProjection, _ as applySkillCapsuleDistributionPlan, a as PlannedSkillCapsule, b as compilerSkillPackage, c as SkillCapsuleContentDigest, d as SkillCapsuleDistributionReceipt, f as SkillCapsuleIdentity, g as SkillReference, h as SkillDescriptor, i as PlanSkillCapsuleDistributionInput, l as SkillCapsuleDistributionError, m as SkillCapsuleProvenanceManifest, n as CompileResourceSkillCapsuleInput, o as PlannedSkillFile, p as SkillCapsulePlan, r as CompileSkillCapsuleInput, s as SkillCapsuleApplyStep, t as ApplySkillCapsuleDistributionOptions, u as SkillCapsuleDistributionPlan, v as compileResourceSkillCapsule, x as planSkillCapsuleDistribution, y as compileSkillCapsule } from "./index-B515mMkO.js";
+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-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-CaQ25rMj.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-3pnDAjBD.js → src-BX7wrSq1.js}

@@ -1,7 +1,9 @@
-import { n as loadResourceTree } from "./src-D3qSzGFn.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;
@@ -388,14 +712,11 @@ async function readTextResource(module, record, kind) {
 async function readSkillCapsule(module, record) {
 	const metadataMaterial = await readRequiredMaterial(module, record, "SkillMetadata");
 	const template = await readRequiredMaterial(module, record, "Template");
-	const version = record.metadata.version;
-	const apiVersion = record.metadata.apiVersion;
-	if (!apiVersion) throw new Error(`SKILL_CAPSULE_API_VERSION_MISSING: ${record.logicalPath} is missing XNL metadata apiVersion`);
-	if (!version) throw new Error(`SKILL_CAPSULE_VERSION_MISSING: ${record.logicalPath} is missing XNL metadata version`);
 	const parsedMetadata = parse(metadataMaterial.content);
 	if (!parsedMetadata || typeof parsedMetadata !== "object" || Array.isArray(parsedMetadata)) throw new Error(`SKILL_CAPSULE_METADATA_INVALID: ${record.logicalPath} Skill metadata must be a YAML object`);
 	const yamlVersion = parsedMetadata.version;
-	if (yamlVersion !== void 0 && yamlVersion !== version) throw new Error(`SKILL_CAPSULE_VERSION_CONFLICT: ${requiredFqn(record)} YAML version ${JSON.stringify(yamlVersion)} does not match XNL version ${version}`);
+	if (typeof yamlVersion !== "string" || !yamlVersion.trim()) throw new Error(`SKILL_CAPSULE_VERSION_MISSING: ${record.logicalPath} Skill metadata must declare a non-empty version`);
+	const version = yamlVersion.trim();
 	const hasXnlName = Object.prototype.hasOwnProperty.call(record.node.properties, "name");
 	const xnlName = stringResourceValue(record.node.properties.name);
 	if (hasXnlName && !xnlName) throw new Error(`SKILL_CAPSULE_NAME_INVALID: ${requiredFqn(record)} XNL name must be a non-empty string`);
@@ -404,7 +725,8 @@ async function readSkillCapsule(module, record) {
 		kind: "SkillCapsule",
 		fqn: requiredFqn(record),
 		...xnlName ? { name: xnlName } : {},
-		apiVersion,
+		envelopeVersion: record.metadata.envelopeVersion,
+		specVersion: record.metadata.specVersion,
 		version,
 		description: requiredDescription(record),
 		metadata: {
@@ -644,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 };