halfcode-compiler.xnl 0.2.8 → 0.3.0

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

@@ -0,0 +1,47 @@
+import { et as ResourceMetadata, i as AuthoredResourceTree, p as ResourceDiagnostic, st as ResourcePackageReadPort, yt as ResourceDigestContribution } from "./index-DboIOEr8.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,3 +1,4 @@
-import { A as buildResourceDependencySnapshot, B as ResourceTombstone, C as BuildResourceDependencySnapshotInput, D as ResourceDependencySnapshot, E as ResourceDependencyEdge, F as EffectiveResourceEntry, H as composeLayeredResourceRegistry, I as EffectiveResourceRegistry, L as ResourceLayerDescriptor, M as sha256Digest, N as ComposeLayeredResourceRegistryInput, O as ResourceDigestContribution, P as EffectiveKindDefinition, R as ResourceLayerInput, S as validateResourceTree, T as ResourceContentIdentity, U as Sha256Digest, V as ResourceTombstoneOrigin, _ as ResourceValue, a as ResourceDescriptor, b as SourceShape, c as ResourceKindContract, d as ResourceRecord, f as ResourceRegistry, g as ResourceValidationError, h as ResourceTreeBuildResult, i as RegisteredKindDefinition, j as createResourceContentIdentity, k as SnapshotResource, l as ResourceMetadata, m as ResourceTree, n as LoadedResourceTree, o as ResourceDiagnostic, p as ResourceScalar, r as LoadedResourceTreeBuildResult, s as ResourceIdentity, t as LoadResourceTreeOptions, u as ResourceNode, v as ResourceValueList, w as CreateResourceContentIdentityInput, x as loadResourceTree, y as ResourceValueMap, z as ResourceOrigin } from "./index-CDIT65pI.js";
-import { a as ResolveEffectiveResourceContentIdentitiesInput, c as ResourceCompositionError, i as readResourceMaterial, n as ResourceMaterial, o as ResourceLayerContentIdentityInput, r as ResourceMaterialError, s as resolveEffectiveResourceContentIdentities, t as ReadResourceMaterialInput } from "./resource-core-C8IonwKw.js";
-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, 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";
+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,4 +1,5 @@
-import { a as isLoadedResourceTreeAuthentic, c as sha256Digest, d as markEffectiveRegistryAuthentic, f as ResourceCompositionError, i as readonlyMap, l as effectiveRegistryLayerBindings, m as digestCanonical, n as loadResourceTree, o as buildResourceDependencySnapshot, p as compareCodeUnits, r as validateResourceTree, s as createResourceContentIdentity, t as ResourceValidationError, u as isEffectiveRegistryAuthentic } from "./src-D3qSzGFn.js";
+import { 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
@@ -12,11 +13,11 @@ function composeLayeredResourceRegistry(input) {
 		const layerId = layer.id.trim();
 		const packageId = layer.tree.manifest.resourceId;
 		if (layerId.length === 0) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_ID_EMPTY", layerLocation$1(layerIndex), "Resource layer id must be a non-empty explicit value."));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_ID_EMPTY", layerLocation(layerIndex), "Resource layer id must be a non-empty explicit value."));
 			return;
 		}
 		if (layerIds.has(layerId)) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_ID_DUPLICATE", layerLocation$1(layerIndex, layerId), `Resource layer id '${layerId}' is declared more than once.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_ID_DUPLICATE", layerLocation(layerIndex, layerId), `Resource layer id '${layerId}' is declared more than once.`));
 			return;
 		}
 		layerIds.add(layerId);
@@ -29,7 +30,7 @@ function composeLayeredResourceRegistry(input) {
 		mergeResources(layer.tree, layerId, layerIndex, packageId, entries, diagnostics);
 		applyTombstones(layer, layerId, layerIndex, packageId, entries, diagnostics);
 	});
-	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
 	const frozenEntries = [...entries.values()].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)).map((entry) => freezeEntry(entry));
 	const byId = readonlyMap(frozenEntries.map((entry) => [entry.resourceId, entry]));
 	const byKindValues = /* @__PURE__ */ new Map();
@@ -75,7 +76,7 @@ function composeLayeredResourceRegistry(input) {
 function mergeKindDefinitions(tree, layerId, layerIndex, packageId, definitions, diagnostics) {
 	for (const [kind, inputDefinition] of [...tree.registry.kindDefinitions.entries()].sort(([left], [right]) => compareCodeUnits(left, right))) {
 		if (!isCanonicalVfsDocumentUri(inputDefinition.documentUri)) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation$1(layerIndex, layerId, kind), `Resource kind '${kind}' must use canonical VFS document provenance.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation(layerIndex, layerId, kind), `Resource kind '${kind}' must use canonical VFS document provenance.`));
 			continue;
 		}
 		const definition = cloneRegisteredKindDefinition(inputDefinition);
@@ -89,7 +90,7 @@ function mergeKindDefinitions(tree, layerId, layerIndex, packageId, definitions,
 			continue;
 		}
 		if (JSON.stringify(normalizedKindContract(current.definition)) !== JSON.stringify(normalizedKindContract(definition))) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_KIND_DEFINITION_CONFLICT", layerLocation$1(layerIndex, layerId, kind), `Resource kind '${kind}' has incompatible KindDefinition contracts across layers.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_KIND_DEFINITION_CONFLICT", layerLocation(layerIndex, layerId, kind), `Resource kind '${kind}' has incompatible KindDefinition contracts across layers.`));
 			continue;
 		}
 		current.origins.push(origin);
@@ -100,12 +101,12 @@ function mergeResources(tree, layerId, layerIndex, packageId, entries, diagnosti
 	const seenInLayer = /* @__PURE__ */ new Set();
 	for (const resource of records) {
 		if (seenInLayer.has(resource.resourceId)) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_RESOURCE_DUPLICATE", layerLocation$1(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' occurs more than once in layer '${layerId}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_RESOURCE_DUPLICATE", layerLocation(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' occurs more than once in layer '${layerId}'.`));
 			continue;
 		}
 		seenInLayer.add(resource.resourceId);
 		if (!isSafeLogicalPath(resource.logicalPath) || resource.documentUri !== `vfs://@/${resource.logicalPath}`) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation$1(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' must use matching canonical VFS documentUri and safe logicalPath provenance.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_PROVENANCE_INVALID", layerLocation(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' must use matching canonical VFS documentUri and safe logicalPath provenance.`));
 			continue;
 		}
 		const immutableResource = cloneResourceRecord(resource);
@@ -124,7 +125,7 @@ function mergeResources(tree, layerId, layerIndex, packageId, entries, diagnosti
 			continue;
 		}
 		if (current.kind !== resource.kind) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_IDENTITY_KIND_CONFLICT", layerLocation$1(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' changes kind from '${current.kind}' to '${resource.kind}' across layers.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_IDENTITY_KIND_CONFLICT", layerLocation(layerIndex, layerId, resource.resourceId), `Resource '${resource.resourceId}' changes kind from '${current.kind}' to '${resource.kind}' across layers.`));
 			continue;
 		}
 		if (current.effectiveOrigin) current.shadowed.push(current.effectiveOrigin);
@@ -140,25 +141,25 @@ function applyTombstones(layer, layerId, layerIndex, packageId, entries, diagnos
 	for (const tombstone of tombstones) {
 		const resourceId = tombstone.resourceId.trim();
 		if (resourceId.length === 0) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_ID_EMPTY", layerLocation$1(layerIndex, layerId), "Resource tombstone target must be a non-empty resource id."));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_ID_EMPTY", layerLocation(layerIndex, layerId), "Resource tombstone target must be a non-empty resource id."));
 			continue;
 		}
 		if (seen.has(resourceId)) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_DUPLICATE", layerLocation$1(layerIndex, layerId, resourceId), `Resource '${resourceId}' has more than one tombstone in layer '${layerId}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_DUPLICATE", layerLocation(layerIndex, layerId, resourceId), `Resource '${resourceId}' has more than one tombstone in layer '${layerId}'.`));
 			continue;
 		}
 		seen.add(resourceId);
 		const current = entries.get(resourceId);
 		if (!current) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_TARGET_MISSING", layerLocation$1(layerIndex, layerId, resourceId), `Tombstone target '${resourceId}' does not exist in a lower or current layer.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_TARGET_MISSING", layerLocation(layerIndex, layerId, resourceId), `Tombstone target '${resourceId}' does not exist in a lower or current layer.`));
 			continue;
 		}
 		if (current.effectiveLayerId === layerId) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_RESOURCE_CONFLICT", layerLocation$1(layerIndex, layerId, resourceId), `Resource '${resourceId}' cannot be both effective and tombstoned in layer '${layerId}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_RESOURCE_CONFLICT", layerLocation(layerIndex, layerId, resourceId), `Resource '${resourceId}' cannot be both effective and tombstoned in layer '${layerId}'.`));
 			continue;
 		}
 		if (tombstone.expectedKind !== void 0 && tombstone.expectedKind !== current.kind) {
-			diagnostics.push(diagnostic$1("RESOURCE_LAYER_TOMBSTONE_KIND_MISMATCH", layerLocation$1(layerIndex, layerId, resourceId), `Tombstone for '${resourceId}' expects kind '${tombstone.expectedKind}', but the target kind is '${current.kind}'.`));
+			diagnostics.push(diagnostic("RESOURCE_LAYER_TOMBSTONE_KIND_MISMATCH", layerLocation(layerIndex, layerId, resourceId), `Tombstone for '${resourceId}' expects kind '${tombstone.expectedKind}', but the target kind is '${current.kind}'.`));
 			continue;
 		}
 		const origin = Object.freeze({
@@ -235,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) {
@@ -251,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
 	});
@@ -262,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
 	};
 }
@@ -301,122 +316,9 @@ function compareOrigins(left, right) {
 function compareTombstones(left, right) {
 	return left.layerIndex - right.layerIndex || compareCodeUnits(left.resourceId, right.resourceId);
 }
-function stableDiagnostics$1(diagnostics) {
-	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
-}
-function diagnostic$1(code, location, message) {
-	return Object.freeze({
-		code,
-		location,
-		message
-	});
-}
-function layerLocation$1(index, layerId, subject) {
-	return `layer:${index}:${layerId ?? "unnamed"}${subject === void 0 ? "" : `:${subject}`}`;
-}
-//#endregion
-//#region ../resource-core/src/effective-content-identities.ts
-function resolveEffectiveResourceContentIdentities(input) {
-	const diagnostics = [];
-	if (!isEffectiveRegistryAuthentic(input.registry)) throw compositionError(diagnostic("RESOURCE_CONTENT_IDENTITY_REGISTRY_UNTRUSTED", "content-projector:registry", "Effective content identities require an authentic registry returned by composeLayeredResourceRegistry()."));
-	const bindings = effectiveRegistryLayerBindings(input.registry) ?? [];
-	if (input.layers.length !== input.registry.layers.length || bindings.length !== input.registry.layers.length) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_COUNT_MISMATCH", "content-projector:layers", "Effective content identity layers must exactly match the composed registry layers."));
-	const loadedById = /* @__PURE__ */ new Map();
-	for (let index = 0; index < input.registry.layers.length; index += 1) {
-		const descriptor = input.registry.layers[index];
-		const layer = input.layers[index];
-		const binding = bindings[index];
-		if (!layer) continue;
-		if (!isLoadedResourceTreeAuthentic(layer.tree)) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_UNTRUSTED", layerLocation(index, layer.id), `Layer '${layer.id}' must use an authentic LoadedResourceTree returned by loadResourceTree().`));
-			continue;
-		}
-		if (layer.id !== descriptor.id || binding?.id !== descriptor.id) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_ID_MISMATCH", layerLocation(index, layer.id), `Layer at index ${index} must retain exact id '${descriptor.id}'.`));
-			continue;
-		}
-		if (descriptor.index !== index) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_INDEX_MISMATCH", layerLocation(index, layer.id), `Layer '${layer.id}' has inconsistent registry index ${descriptor.index}.`));
-			continue;
-		}
-		if (layer.tree.manifest.resourceId !== descriptor.packageId) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_PACKAGE_MISMATCH", layerLocation(index, layer.id), `Layer '${layer.id}' must retain package '${descriptor.packageId}'.`));
-			continue;
-		}
-		if (binding?.tree !== layer.tree) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_LAYER_BINDING_MISMATCH", layerLocation(index, layer.id), `Layer '${layer.id}' must use the exact loaded tree composed into the registry.`));
-			continue;
-		}
-		validateLoadedIdentityCoverage(layer.tree, layer.id, diagnostics);
-		loadedById.set(layer.id, layer.tree);
-	}
-	const effectiveEntries = [...input.registry.byId.values()].filter((entry) => entry.resource !== void 0).sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId));
-	const effectiveIds = new Set(effectiveEntries.map((entry) => entry.resourceId));
-	for (const resourceId of input.contributions?.keys() ?? []) if (!effectiveIds.has(resourceId)) diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_OWNER_UNKNOWN", contentLocation(resourceId), `Digest contributions target unknown effective resource '${resourceId}'.`));
-	const output = [];
-	for (const entry of effectiveEntries) {
-		const tree = entry.effectiveLayerId === void 0 ? void 0 : loadedById.get(entry.effectiveLayerId);
-		if (!tree || !entry.effectiveOrigin) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_EFFECTIVE_ORIGIN_MISSING", contentLocation(entry.resourceId), `Effective resource '${entry.resourceId}' has no exact loaded layer origin.`));
-			continue;
-		}
-		validateEffectiveOrigin(entry, input.registry, tree, diagnostics);
-		const authorityIdentity = tree.contentIdentities.get(entry.resourceId);
-		if (!authorityIdentity) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_MISSING", contentLocation(entry.resourceId), `Effective resource '${entry.resourceId}' is missing its loader authority identity.`));
-			continue;
-		}
-		try {
-			const identity = createResourceContentIdentity({
-				resourceId: entry.resourceId,
-				authorityDigest: authorityIdentity.authorityDigest,
-				contributions: [...authorityIdentity.contributions, ...input.contributions?.get(entry.resourceId) ?? []]
-			});
-			output.push([entry.resourceId, identity]);
-		} catch (error) {
-			if (error instanceof ResourceCompositionError) diagnostics.push(...error.diagnostics);
-			else throw error;
-		}
-	}
-	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
-	return readonlyMap(output.sort(([left], [right]) => compareCodeUnits(left, right)));
-}
-function validateLoadedIdentityCoverage(tree, layerId, diagnostics) {
-	const resources = [...tree.registry.byKind.values()].flatMap((records) => [...records]).sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId));
-	const resourcesById = new Map(resources.map((resource) => [resource.resourceId, resource]));
-	for (const resource of resources) {
-		const identity = tree.contentIdentities.get(resource.resourceId);
-		if (!identity) {
-			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_MISSING", layerLocation(void 0, layerId, resource.resourceId), `Loaded resource '${resource.resourceId}' has no authority identity.`));
-			continue;
-		}
-		const normalized = createResourceContentIdentity({
-			resourceId: identity.resourceId,
-			authorityDigest: identity.authorityDigest,
-			contributions: identity.contributions
-		});
-		if (identity.resourceId !== resource.resourceId || identity.contentDigest !== normalized.contentDigest) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_INVALID", layerLocation(void 0, layerId, resource.resourceId), `Loaded resource '${resource.resourceId}' has an inconsistent authority identity.`));
-	}
-	for (const resourceId of tree.contentIdentities.keys()) if (!resourcesById.has(resourceId)) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_EXTRA", layerLocation(void 0, layerId, resourceId), `Loaded tree contains an extra authority identity '${resourceId}'.`));
-}
-function validateEffectiveOrigin(entry, registry, tree, diagnostics) {
-	const origin = entry.effectiveOrigin;
-	const descriptor = registry.layers[origin.layerIndex];
-	const loadedRecord = findResource$1(tree, entry.resourceId);
-	if (!descriptor || descriptor.id !== origin.layerId || descriptor.packageId !== origin.packageId || tree.manifest.resourceId !== origin.packageId || !loadedRecord || loadedRecord.documentUri !== origin.documentUri || loadedRecord.logicalPath !== origin.logicalPath) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_EFFECTIVE_ORIGIN_MISMATCH", contentLocation(entry.resourceId), `Effective resource '${entry.resourceId}' does not match its exact layer/package/origin facts.`));
-}
-function findResource$1(tree, resourceId) {
-	for (const records of tree.registry.byKind.values()) {
-		const resource = records.find((record) => record.resourceId === resourceId);
-		if (resource) return resource;
-	}
-}
 function stableDiagnostics(diagnostics) {
 	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
 }
-function compositionError(diagnosticValue) {
-	return new ResourceCompositionError(Object.freeze([diagnosticValue]));
-}
 function diagnostic(code, location, message) {
 	return Object.freeze({
 		code,
@@ -424,11 +326,8 @@ function diagnostic(code, location, message) {
 		message
 	});
 }
-function layerLocation(index, layerId, resourceId) {
-	return `content-layer:${index ?? "unknown"}:${layerId}${resourceId === void 0 ? "" : `:${resourceId}`}`;
-}
-function contentLocation(resourceId) {
-	return `content:${resourceId || "unnamed"}`;
+function layerLocation(index, layerId, subject) {
+	return `layer:${index}:${layerId ?? "unnamed"}${subject === void 0 ? "" : `:${subject}`}`;
 }
 //#endregion
 //#region ../resource-core/src/resource-material.ts
@@ -441,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.`);
@@ -515,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-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-DI3WtuXq.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-CR7wJSSX.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-DLJUCH0M.js";
 export { SkillCapsuleDistributionError, applySkillCapsuleDistributionPlan, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, planSkillCapsuleDistribution, skillCapsuleDistributionProjection };

package/dist/{src-3pnDAjBD.js → src-B0Hja_dk.js}

@@ -1,4 +1,4 @@
-import { n as loadResourceTree } from "./src-D3qSzGFn.js";
+import { n as loadResourceTree } from "./src-jggOQtq3.js";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { parse } from "yaml";
@@ -388,14 +388,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 +401,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: {

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

@@ -1,4 +1,4 @@
-import { l as resourceRefToFqn, u as resolveObjectOperationCompilation } from "./src-3pnDAjBD.js";
+import { l as resourceRefToFqn, u as resolveObjectOperationCompilation } from "./src-B0Hja_dk.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";
@@ -70,7 +70,8 @@ async function planSkillCapsuleDistribution(input) {
 			const targetRelativePath = posix.join(identity.name, file.targetRelativePath);
 			return plannedSkillFile({
 				skillFqn: identity.fqn,
-				skillApiVersion: identity.apiVersion,
+				skillEnvelopeVersion: identity.envelopeVersion,
+				skillSpecVersion: identity.specVersion,
 				skillVersion: identity.version,
 				capsuleRelativePath: file.targetRelativePath,
 				targetRelativePath
@@ -294,7 +295,8 @@ function skillIdentity(skill) {
 	return Object.freeze({
 		fqn: skill.fqn,
 		name: skillOutputName(skill),
-		apiVersion: skill.apiVersion,
+		envelopeVersion: skill.envelopeVersion,
+		specVersion: skill.specVersion,
 		version: skill.version
 	});
 }
@@ -338,7 +340,7 @@ function assertValidDistributionPlan(plan) {
 	const capsuleByFqn = /* @__PURE__ */ new Map();
 	for (const capsule of plan.capsules) {
 		validateSkillOutputName(capsule.identity.name);
-		if (!capsule.identity.fqn.trim() || !capsule.identity.apiVersion.trim() || !capsule.identity.version.trim()) failDistribution("SKILL_PLAN_IDENTITY_INVALID", "planned Skill identity requires non-empty FQN, apiVersion and version");
+		if (!capsule.identity.fqn.trim() || !capsule.identity.envelopeVersion.trim() || !Number.isSafeInteger(capsule.identity.specVersion) || capsule.identity.specVersion <= 0 || !capsule.identity.version.trim()) failDistribution("SKILL_PLAN_IDENTITY_INVALID", "planned Skill identity requires non-empty FQN/envelopeVersion/version and a positive specVersion");
 		if (capsuleByFqn.has(capsule.identity.fqn)) failDistribution("SKILL_PLAN_CAPSULE_DUPLICATE", `duplicate planned capsule ${capsule.identity.fqn}`);
 		capsuleByFqn.set(capsule.identity.fqn, capsule);
 		for (const file of capsule.files) {
@@ -348,7 +350,7 @@ function assertValidDistributionPlan(plan) {
 		assertCanonicalSkillEntry(capsule);
 		for (const file of capsule.files) {
 			assertValidPlannedFile(file);
-			if (file.skillFqn !== capsule.identity.fqn || file.skillApiVersion !== capsule.identity.apiVersion || file.skillVersion !== capsule.identity.version) failDistribution("SKILL_PLAN_FILE_OWNER_INVALID", `file ${file.targetRelativePath} has the wrong Skill owner`);
+			if (file.skillFqn !== capsule.identity.fqn || file.skillEnvelopeVersion !== capsule.identity.envelopeVersion || file.skillSpecVersion !== capsule.identity.specVersion || file.skillVersion !== capsule.identity.version) failDistribution("SKILL_PLAN_FILE_OWNER_INVALID", `file ${file.targetRelativePath} has the wrong Skill owner`);
 			if (file.targetRelativePath !== posix.join(capsule.identity.name, file.capsuleRelativePath)) failDistribution("SKILL_PLAN_TARGET_INVALID", `file ${file.targetRelativePath} is outside Skill output ${capsule.identity.name}`);
 		}
 		assertCanonicalSkillProvenance(capsule);
@@ -448,7 +450,8 @@ function bytesEqual(left, right) {
 function fileDigestProjection(file) {
 	return {
 		skillFqn: file.skillFqn,
-		skillApiVersion: file.skillApiVersion,
+		skillEnvelopeVersion: file.skillEnvelopeVersion,
+		skillSpecVersion: file.skillSpecVersion,
 		skillVersion: file.skillVersion,
 		capsuleRelativePath: file.capsuleRelativePath,
 		targetRelativePath: file.targetRelativePath,
@@ -476,7 +479,8 @@ function canonicalSkillProvenanceBytes(identity, payloadFiles) {
 		generatedBy: "halfcode.skill-distribution/v1",
 		source: {
 			fqn: identity.fqn,
-			apiVersion: identity.apiVersion,
+			envelopeVersion: identity.envelopeVersion,
+			specVersion: identity.specVersion,
 			version: identity.version
 		},
 		payloadFiles: payloadFiles.map((file) => ({