halfcode-compiler.xnl 0.2.0 → 0.2.2

package/README.md

@@ -16,4 +16,43 @@ import {
 } from "halfcode-compiler.xnl"
 ```
 
+Multi-capsule distribution is an additive plan/apply surface. Planning resolves exact sibling dependencies, captures every output as canonical immutable `contentBase64`, preflights the complete closure, and does not mutate the target. `PlannedSkillFile.content` remains a compatibility byte view, but every read returns a defensive copy; projection, validation, and apply use the canonical string authority. Applying rejects empty or disconnected closures before any live mutation and consumes only that plan plus a caller-selected output root:
+
+```ts
+import {
+  applySkillCapsuleDistributionPlan,
+  planSkillCapsuleDistribution,
+  type SkillCapsuleDependency,
+  type SkillCapsuleDistributionPlan,
+} from "halfcode-compiler.xnl"
+
+const plan: SkillCapsuleDistributionPlan = await planSkillCapsuleDistribution({
+  assembly,
+  rootSkillFqns: ["example.resource_lifecycle.skill.devops"],
+})
+
+await applySkillCapsuleDistributionPlan(plan, { outputRoot })
+```
+
+Each capsule identity includes the XNL `apiVersion` and `version`. The planner generates exactly one `references/.halfcode/provenance.json` per capsule with the source identity, `halfcode.skill-distribution/v1` generator and every payload file digest. The applier reconstructs and validates this manifest before any target mutation.
+
+The legacy `compileSkillCapsule` and `compileResourceSkillCapsule` APIs remain available from both the package root and `halfcode-compiler.xnl/skill-capsule`. The subpath also exports the new plan/apply APIs and `SkillCapsuleDependency` type.
+
 Lower-level APIs are available through explicit subpaths such as `halfcode-compiler.xnl/resource-core` and `halfcode-compiler.xnl/authoring-runtime`.
+
+The resource-core subpath preserves the single-package loader and adds deterministic, read-only composition APIs:
+
+```ts
+import {
+  loadResourceTree,
+  composeLayeredResourceRegistry,
+  resolveEffectiveResourceContentIdentities,
+  buildResourceDependencySnapshot,
+} from "halfcode-compiler.xnl/resource-core"
+```
+
+`loadResourceTree()` returns an additive `LoadedResourceTree` whose content identities come from the same raw-byte read used for fatal UTF-8 decoding and XNL parsing. `resolveEffectiveResourceContentIdentities()` accepts only the canonical registry and exact loaded layers, selects each effective authority identity, and merges only explicit Kind-owned digest contributions.
+
+Layer order, tombstones, dependency edges, and digest contributions are explicit caller-owned facts. Resource core does not assign semantics to layer names, infer dependencies from arbitrary strings, or own host installation paths. Structural `ResourceTree` values remain valid for generic layer composition; the new identity projector requires authentic loaded trees.
+
+`EffectiveResourceRegistry.compositionRevision` binds ordered identity/presence/layer/shadow/tombstone, selected KindDefinition authority identity/contract, and canonical logical-origin facts, but deliberately excludes descriptor/node/metadata bytes; its `revision` field remains an exact compatibility alias. Snapshot construction accepts only the immutable registry returned by the canonical composer, copies/freeze its own origin facts, and rejects inconsistent structural projections. `ResourceDependencySnapshot.registryRevision` additionally binds the revalidated content digests of every effective resource, while `snapshotRevision` binds the selected roots, reachable closure, and participating typed edges. Duplicate contribution keys fail closed, and all canonical ordering uses fixed UTF-16 code-unit order rather than locale-dependent sorting.

package/dist/application-assembly.d.ts

@@ -1,2 +1,2 @@
-import { A as ObjectTargets, B as assertExecuteObjectOperationRequest, C as ObjectOperationDefinition, D as ObjectOperationTargetDeclaration, E as ObjectOperationOwnerKind, F as ResourceSource, G as resolveApplicationAssembly, H as assertObjectOperationCatalog, I as SkillCapsuleResource, K as resourceRefToFqn, L as TextMaterial, M as ResolveApplicationAssemblyOptions, N as ResolvedAssemblyPortBinding, O as ObjectTargetKindDefinition, P as ResourceInclude, R as TextResource, S as ObjectOperationContractError, T as ObjectOperationHandler, U as assertObjectOperationDefinition, V as assertObjectOperationCall, W as loadApplicationAssembly, _ 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, 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 applicationAssemblyPackage } from "./index-FdimP_SL.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 SkillCapsuleResource, type TextMaterial, type TextResource, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };
+import { A as ObjectTargets, B as applicationAssemblyPackage, C as ObjectOperationDefinition, D as ObjectOperationTargetDeclaration, E as ObjectOperationOwnerKind, F as ResourceSource, G as loadApplicationAssembly, H as assertObjectOperationCall, I as SkillCapsuleDependency, K as resolveApplicationAssembly, L as SkillCapsuleResource, M as ResolveApplicationAssemblyOptions, N as ResolvedAssemblyPortBinding, O as ObjectTargetKindDefinition, P as ResourceInclude, R as TextMaterial, S as ObjectOperationContractError, T as ObjectOperationHandler, U as assertObjectOperationCatalog, V as assertExecuteObjectOperationRequest, W as assertObjectOperationDefinition, _ as ObjectInvocationMode, a as AssemblyResource, b as ObjectOperationCatalog, c as BusinessObjectSopResource, d as ExecuteObjectOperationRequest, f as JsonObject, g as ObjectInvocation, h as LoadApplicationAssemblyOptions, i as AssemblyPortBinding, j as PageObjectResource, k as ObjectTargetRef, l as CodeBinding, m as JsonValue, n as ApplicationScope, o as AuthoringModuleDescriptor, p as JsonPrimitive, q as resourceRefToFqn, r as AssemblyPort, s as BusinessObjectResource, t as ApplicationAssembly, u as ContractedCallableResource, v as ObjectOperationBehavior, w as ObjectOperationEffect, x as ObjectOperationConfig, y as ObjectOperationCall, z as TextResource } from "./index-Cqh9pEBa.js";
+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 };

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-DJr-I4Kc.js";
+import { a as assertObjectOperationCatalog, c as resolveApplicationAssembly, i as assertObjectOperationCall, l as resourceRefToFqn, n as applicationAssemblyPackage, o as assertObjectOperationDefinition, r as assertExecuteObjectOperationRequest, s as loadApplicationAssembly, t as ObjectOperationContractError } from "./src-DRIws6tY.js";
 export { ObjectOperationContractError, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };

package/dist/index-96qHPZj2.d.ts

@@ -0,0 +1,126 @@
+import { t as ApplicationAssembly } from "./index-Cqh9pEBa.js";
+import { t as ResourceRegistry } from "./index-D2mpux6L.js";
+//#region ../compiler-skill/src/index.d.ts
+interface SkillDescriptor {
+  name: string;
+  description: string;
+  instructions?: string;
+}
+interface SkillReference {
+  path: string;
+  content: string;
+}
+interface CompileSkillCapsuleInput {
+  skill: SkillDescriptor;
+  registry?: ResourceRegistry;
+  references?: readonly SkillReference[];
+  outputDir: string;
+}
+interface SkillCapsulePlan {
+  skillName: string;
+  outputRoot: string;
+  files: readonly string[];
+}
+interface CompileResourceSkillCapsuleInput {
+  assembly: ApplicationAssembly;
+  skillFqn: string;
+  outputDir: string;
+  schemas?: ReadonlyMap<string, unknown> | Record<string, unknown>;
+}
+interface SkillCapsuleIdentity {
+  readonly fqn: string;
+  readonly name: string;
+  readonly apiVersion: string;
+  readonly version: string;
+}
+type SkillCapsuleContentDigest = `sha256:${string}`;
+interface SkillCapsuleProvenanceManifest {
+  readonly format: "halfcode.skill-provenance/v1";
+  readonly generatedBy: "halfcode.skill-distribution/v1";
+  readonly source: {
+    readonly fqn: string;
+    readonly apiVersion: string;
+    readonly version: string;
+  };
+  readonly payloadFiles: readonly {
+    readonly path: string;
+    readonly contentDigest: SkillCapsuleContentDigest;
+  }[];
+}
+interface PlannedSkillFile {
+  readonly skillFqn: string;
+  readonly skillApiVersion: string;
+  readonly skillVersion: string;
+  readonly capsuleRelativePath: string;
+  readonly targetRelativePath: string;
+  /** Canonical, serializable content authority. */
+  readonly contentBase64: string;
+  /** Compatibility byte snapshot. Every read returns a defensive copy. */
+  readonly content: Uint8Array;
+  readonly contentDigest: SkillCapsuleContentDigest;
+}
+interface PlannedSkillCapsule {
+  readonly identity: SkillCapsuleIdentity;
+  readonly dependencies: readonly SkillCapsuleIdentity[];
+  readonly files: readonly PlannedSkillFile[];
+  readonly capsuleDigest: string;
+}
+interface SkillCapsuleDistributionPlan {
+  readonly format: "halfcode.skill-distribution/v1";
+  readonly roots: readonly SkillCapsuleIdentity[];
+  readonly topology: readonly string[];
+  readonly capsules: readonly PlannedSkillCapsule[];
+  readonly files: readonly PlannedSkillFile[];
+  readonly closureDigest: string;
+}
+interface PlanSkillCapsuleDistributionInput {
+  readonly assembly: ApplicationAssembly;
+  readonly rootSkillFqns: readonly string[];
+  readonly schemas?: ReadonlyMap<string, unknown> | Record<string, unknown>;
+}
+type SkillCapsuleApplyStep = "after-stage" | "after-readback" | "after-backup" | "before-live-rename";
+interface ApplySkillCapsuleDistributionOptions {
+  readonly outputRoot: string;
+  readonly onStep?: (step: SkillCapsuleApplyStep) => void | Promise<void>;
+}
+interface SkillCapsuleDistributionReceipt {
+  readonly outputRoot: string;
+  readonly closureDigest: string;
+  readonly installedSkills: readonly SkillCapsuleIdentity[];
+  readonly files: readonly string[];
+}
+declare class SkillCapsuleDistributionError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+declare function compileSkillCapsule(input: CompileSkillCapsuleInput): Promise<SkillCapsulePlan>;
+declare function compileResourceSkillCapsule(input: CompileResourceSkillCapsuleInput): Promise<SkillCapsulePlan>;
+declare function planSkillCapsuleDistribution(input: PlanSkillCapsuleDistributionInput): Promise<SkillCapsuleDistributionPlan>;
+declare function skillCapsuleDistributionProjection(plan: SkillCapsuleDistributionPlan): {
+  format: "halfcode.skill-distribution/v1";
+  roots: readonly SkillCapsuleIdentity[];
+  topology: readonly string[];
+  capsules: {
+    identity: SkillCapsuleIdentity;
+    dependencies: readonly SkillCapsuleIdentity[];
+    files: {
+      contentBase64: string;
+      skillFqn: string;
+      skillApiVersion: string;
+      skillVersion: string;
+      capsuleRelativePath: string;
+      targetRelativePath: string;
+      contentDigest: `sha256:${string}`;
+    }[];
+    capsuleDigest: string;
+  }[];
+  closureDigest: string;
+};
+declare function applySkillCapsuleDistributionPlan(plan: SkillCapsuleDistributionPlan, options: ApplySkillCapsuleDistributionOptions): Promise<SkillCapsuleDistributionReceipt>;
+declare const compilerSkillPackage: {
+  readonly role: "framework";
+  readonly area: "compiler-skill";
+  readonly owns: "standard Skill capsule projection";
+};
+//#endregion
+export { skillCapsuleDistributionProjection as S, applySkillCapsuleDistributionPlan as _, PlannedSkillCapsule as a, compilerSkillPackage as b, SkillCapsuleContentDigest as c, SkillCapsuleDistributionReceipt as d, SkillCapsuleIdentity as f, SkillReference as g, SkillDescriptor as h, PlanSkillCapsuleDistributionInput as i, SkillCapsuleDistributionError as l, SkillCapsuleProvenanceManifest as m, CompileResourceSkillCapsuleInput as n, PlannedSkillFile as o, SkillCapsulePlan as p, CompileSkillCapsuleInput as r, SkillCapsuleApplyStep as s, ApplySkillCapsuleDistributionOptions as t, SkillCapsuleDistributionPlan as u, compileResourceSkillCapsule as v, planSkillCapsuleDistribution as x, compileSkillCapsule as y };

package/dist/{index-FdimP_SL.d.ts → index-Cqh9pEBa.d.ts}

@@ -169,13 +169,22 @@ interface TextResource {
 interface SkillCapsuleResource {
   kind: "SkillCapsule";
   fqn: string;
+  name?: string;
+  apiVersion: string;
+  version: string;
   description: string;
   metadata: Record<string, unknown>;
   template: TextMaterial;
   resourceMappings?: TextMaterial;
   includes: readonly ResourceInclude[];
+  dependencies: readonly SkillCapsuleDependency[];
   source: ResourceSource;
 }
+interface SkillCapsuleDependency {
+  ref: string;
+  fqn: string;
+  version: string;
+}
 interface PageObjectResource {
   kind: "PageObject";
   fqn: string;
@@ -233,4 +242,4 @@ declare const applicationAssemblyPackage: {
   readonly owns: "resource registry facts normalized for target-neutral compiler projections";
 };
 //#endregion
-export { ObjectTargets as A, assertExecuteObjectOperationRequest as B, ObjectOperationDefinition as C, ObjectOperationTargetDeclaration as D, ObjectOperationOwnerKind as E, ResourceSource as F, resolveApplicationAssembly as G, assertObjectOperationCatalog as H, SkillCapsuleResource as I, resourceRefToFqn as K, TextMaterial as L, ResolveApplicationAssemblyOptions as M, ResolvedAssemblyPortBinding as N, ObjectTargetKindDefinition as O, ResourceInclude as P, TextResource as R, ObjectOperationContractError as S, ObjectOperationHandler as T, assertObjectOperationDefinition as U, assertObjectOperationCall as V, loadApplicationAssembly as W, ObjectInvocationMode as _, AssemblyResource as a, ObjectOperationCatalog as b, BusinessObjectSopResource as c, ExecuteObjectOperationRequest as d, JsonObject as f, ObjectInvocation as g, LoadApplicationAssemblyOptions as h, AssemblyPortBinding as i, PageObjectResource as j, ObjectTargetRef as k, CodeBinding as l, JsonValue as m, ApplicationScope as n, AuthoringModuleDescriptor as o, JsonPrimitive as p, AssemblyPort as r, BusinessObjectResource as s, ApplicationAssembly as t, ContractedCallableResource as u, ObjectOperationBehavior as v, ObjectOperationEffect as w, ObjectOperationConfig as x, ObjectOperationCall as y, applicationAssemblyPackage as z };
+export { ObjectTargets as A, applicationAssemblyPackage as B, ObjectOperationDefinition as C, ObjectOperationTargetDeclaration as D, ObjectOperationOwnerKind as E, ResourceSource as F, loadApplicationAssembly as G, assertObjectOperationCall as H, SkillCapsuleDependency as I, resolveApplicationAssembly as K, SkillCapsuleResource as L, ResolveApplicationAssemblyOptions as M, ResolvedAssemblyPortBinding as N, ObjectTargetKindDefinition as O, ResourceInclude as P, TextMaterial as R, ObjectOperationContractError as S, ObjectOperationHandler as T, assertObjectOperationCatalog as U, assertExecuteObjectOperationRequest as V, assertObjectOperationDefinition as W, ObjectInvocationMode as _, AssemblyResource as a, ObjectOperationCatalog as b, BusinessObjectSopResource as c, ExecuteObjectOperationRequest as d, JsonObject as f, ObjectInvocation as g, LoadApplicationAssemblyOptions as h, AssemblyPortBinding as i, PageObjectResource as j, ObjectTargetRef as k, CodeBinding as l, JsonValue as m, ApplicationScope as n, AuthoringModuleDescriptor as o, JsonPrimitive as p, resourceRefToFqn as q, AssemblyPort as r, BusinessObjectResource as s, ApplicationAssembly as t, ContractedCallableResource as u, ObjectOperationBehavior as v, ObjectOperationEffect as w, ObjectOperationConfig as x, ObjectOperationCall as y, TextResource as z };

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

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

package/dist/index-DdRHFKSQ.d.ts

@@ -0,0 +1,192 @@
+//#region ../resource-core/src/canonical.d.ts
+type Sha256Digest = `sha256:${string}`;
+//#endregion
+//#region ../resource-core/src/layered-registry.d.ts
+interface ResourceTombstone {
+  readonly resourceId: string;
+  readonly expectedKind?: string;
+  readonly reason?: string;
+}
+interface ResourceLayerInput {
+  readonly id: string;
+  readonly tree: ResourceTree;
+  readonly tombstones?: readonly ResourceTombstone[];
+}
+interface ResourceLayerDescriptor {
+  readonly id: string;
+  readonly index: number;
+  readonly packageId: string;
+}
+interface ResourceOrigin {
+  readonly layerId: string;
+  readonly layerIndex: number;
+  readonly packageId: string;
+  readonly documentUri: string;
+  readonly logicalPath?: string;
+}
+interface ResourceTombstoneOrigin extends ResourceTombstone {
+  readonly layerId: string;
+  readonly layerIndex: number;
+  readonly packageId: string;
+}
+interface EffectiveResourceEntry {
+  readonly resourceId: string;
+  readonly kind: string;
+  readonly resource?: ResourceRecord;
+  readonly effectiveLayerId?: string;
+  readonly effectiveOrigin?: ResourceOrigin;
+  readonly shadowed: readonly ResourceOrigin[];
+  readonly tombstone?: ResourceTombstoneOrigin;
+  readonly tombstones: readonly ResourceTombstoneOrigin[];
+}
+interface EffectiveKindDefinition {
+  readonly definition: RegisteredKindDefinition;
+  readonly origins: readonly ResourceOrigin[];
+}
+interface EffectiveResourceRegistry {
+  readonly byId: ReadonlyMap<string, EffectiveResourceEntry>;
+  readonly byKind: ReadonlyMap<string, readonly ResourceRecord[]>;
+  readonly kindDefinitions: ReadonlyMap<string, EffectiveKindDefinition>;
+  readonly layers: readonly ResourceLayerDescriptor[];
+  readonly compositionRevision: string;
+  /** Compatibility alias for compositionRevision. */
+  readonly revision: string;
+}
+interface ComposeLayeredResourceRegistryInput {
+  readonly layers: readonly ResourceLayerInput[];
+}
+declare function composeLayeredResourceRegistry(input: ComposeLayeredResourceRegistryInput): EffectiveResourceRegistry;
+//#endregion
+//#region ../resource-core/src/dependency-snapshot.d.ts
+interface ResourceDigestContribution {
+  readonly key: string;
+  readonly digest: string;
+  readonly sourceUri?: string;
+}
+interface CreateResourceContentIdentityInput {
+  readonly resourceId: string;
+  readonly authorityDigest: string;
+  readonly contributions?: readonly ResourceDigestContribution[];
+}
+interface ResourceContentIdentity {
+  readonly resourceId: string;
+  readonly authorityDigest: string;
+  readonly contributions: readonly ResourceDigestContribution[];
+  readonly contentDigest: Sha256Digest;
+}
+interface ResourceDependencyEdge {
+  readonly fromResourceId: string;
+  readonly toResourceId: string;
+  readonly relation: string;
+  readonly declaredBy: string;
+}
+interface SnapshotResource {
+  readonly resourceId: string;
+  readonly kind: string;
+  readonly contentDigest: string;
+  readonly origin: ResourceOrigin;
+}
+interface ResourceDependencySnapshot {
+  readonly roots: readonly string[];
+  readonly closure: readonly SnapshotResource[];
+  readonly edges: readonly ResourceDependencyEdge[];
+  readonly registryRevision: string;
+  readonly snapshotRevision: Sha256Digest;
+}
+interface BuildResourceDependencySnapshotInput {
+  readonly registry: EffectiveResourceRegistry;
+  readonly roots: readonly string[];
+  readonly edges: readonly ResourceDependencyEdge[];
+  readonly contentIdentities: ReadonlyMap<string, ResourceContentIdentity>;
+}
+declare function sha256Digest(value: string | Uint8Array): Sha256Digest;
+declare function createResourceContentIdentity(input: CreateResourceContentIdentityInput): ResourceContentIdentity;
+declare function buildResourceDependencySnapshot(input: BuildResourceDependencySnapshotInput): ResourceDependencySnapshot;
+//#endregion
+//#region ../resource-core/src/index.d.ts
+type SourceShape = "single-file" | "directory" | "manifest";
+interface ResourceIdentity {
+  kind: string;
+  fqn?: string;
+  name?: string;
+}
+interface ResourceDescriptor extends ResourceIdentity {
+  description?: string;
+}
+interface ResourceMetadata {
+  apiVersion: string;
+  lifecycle?: string;
+  version?: string;
+}
+type ResourceScalar = string | number | boolean | null;
+interface ResourceValueList extends ReadonlyArray<ResourceValue> {}
+interface ResourceValueMap extends Readonly<Record<string, ResourceValue>> {}
+type ResourceValue = ResourceScalar | ResourceNode | ResourceValueList | ResourceValueMap;
+interface ResourceNode {
+  readonly tag: string;
+  readonly resourceId?: string;
+  readonly metadata: Readonly<Record<string, ResourceValue>>;
+  readonly properties: Readonly<Record<string, ResourceValue>>;
+  readonly body: readonly ResourceValue[];
+  readonly subdomains: Readonly<Record<string, ResourceNode>>;
+  readonly text?: string;
+}
+interface ResourceRecord extends ResourceDescriptor {
+  resourceId: string;
+  metadata: ResourceMetadata;
+  sourceShape: SourceShape;
+  logicalPath: string;
+  documentUri: string;
+  format: "xnl";
+  node: ResourceNode;
+}
+interface ResourceKindContract {
+  resourceKind: string;
+  sourceShapes: readonly SourceShape[];
+  currentApiVersion: string;
+  supportedApiVersions: readonly string[];
+  documentCardinality?: "one" | "many";
+}
+interface RegisteredKindDefinition extends ResourceKindContract {
+  resourceId: string;
+  requiredFiles: readonly string[];
+  documentCardinality: "one" | "many";
+  documentUri: string;
+}
+interface ResourceRegistry {
+  readonly byKind: ReadonlyMap<string, readonly ResourceRecord[]>;
+  readonly kindDefinitions: ReadonlyMap<string, RegisteredKindDefinition>;
+}
+interface ResourceTree {
+  manifest: ResourceRecord;
+  registry: ResourceRegistry;
+  diagnostics: readonly ResourceDiagnostic[];
+}
+interface LoadedResourceTree extends ResourceTree {
+  readonly contentIdentities: ReadonlyMap<string, ResourceContentIdentity>;
+}
+interface ResourceDiagnostic {
+  code: string;
+  location: string;
+  message: string;
+  hint?: string;
+}
+interface LoadResourceTreeOptions {
+  rootDir: string;
+  manifestPath?: string;
+}
+interface ResourceTreeBuildResult {
+  diagnostics: ResourceDiagnostic[];
+  tree?: ResourceTree;
+}
+interface LoadedResourceTreeBuildResult extends ResourceTreeBuildResult {
+  tree?: LoadedResourceTree;
+}
+declare class ResourceValidationError extends Error {
+  readonly diagnostics: readonly ResourceDiagnostic[];
+  constructor(diagnostics: readonly ResourceDiagnostic[]);
+}
+declare function loadResourceTree(options: LoadResourceTreeOptions): Promise<LoadedResourceTree>;
+declare function validateResourceTree(options: LoadResourceTreeOptions): Promise<ResourceDiagnostic[]>;
+//#endregion
+export { buildResourceDependencySnapshot as A, ResourceTombstone as B, BuildResourceDependencySnapshotInput as C, ResourceDependencySnapshot as D, ResourceDependencyEdge as E, EffectiveResourceEntry as F, composeLayeredResourceRegistry as H, EffectiveResourceRegistry as I, ResourceLayerDescriptor as L, sha256Digest as M, ComposeLayeredResourceRegistryInput as N, ResourceDigestContribution as O, EffectiveKindDefinition as P, ResourceLayerInput as R, validateResourceTree as S, ResourceContentIdentity as T, Sha256Digest as U, ResourceTombstoneOrigin as V, ResourceValue as _, ResourceDescriptor as a, SourceShape as b, ResourceKindContract as c, ResourceRecord as d, ResourceRegistry as f, ResourceValidationError as g, ResourceTreeBuildResult as h, RegisteredKindDefinition as i, createResourceContentIdentity as j, SnapshotResource as k, ResourceMetadata as l, ResourceTree as m, LoadedResourceTree as n, ResourceDiagnostic as o, ResourceScalar as p, LoadedResourceTreeBuildResult as r, ResourceIdentity as s, LoadResourceTreeOptions as t, ResourceNode as u, ResourceValueList as v, CreateResourceContentIdentityInput as w, loadResourceTree as x, ResourceValueMap as y, ResourceOrigin as z };

package/dist/index.d.ts

@@ -1,3 +1,8 @@
-import { A as ObjectTargets, B as assertExecuteObjectOperationRequest, C as ObjectOperationDefinition, D as ObjectOperationTargetDeclaration, E as ObjectOperationOwnerKind, F as ResourceSource, G as resolveApplicationAssembly, H as assertObjectOperationCatalog, I as SkillCapsuleResource, K as resourceRefToFqn, L as TextMaterial, M as ResolveApplicationAssemblyOptions, N as ResolvedAssemblyPortBinding, O as ObjectTargetKindDefinition, P as ResourceInclude, R as TextResource, S as ObjectOperationContractError, T as ObjectOperationHandler, U as assertObjectOperationDefinition, V as assertObjectOperationCall, W as loadApplicationAssembly, _ 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, 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 applicationAssemblyPackage } from "./index-FdimP_SL.js";
-import { a as SkillReference, c as compilerSkillPackage, i as SkillDescriptor, n as CompileSkillCapsuleInput, o as compileResourceSkillCapsule, r as SkillCapsulePlan, s as compileSkillCapsule, t as CompileResourceSkillCapsuleInput } from "./index-wU-iKJnW.js";
-export { type ApplicationAssembly, type ApplicationScope, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, type AuthoringModuleDescriptor, type BusinessObjectResource, type BusinessObjectSopResource, type CodeBinding, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, 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, SkillCapsulePlan, type SkillCapsuleResource, SkillDescriptor, SkillReference, type TextMaterial, type TextResource, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };
+import { A as ObjectTargets, B as applicationAssemblyPackage, C as ObjectOperationDefinition, D as ObjectOperationTargetDeclaration, E as ObjectOperationOwnerKind, F as ResourceSource, G as loadApplicationAssembly, H as assertObjectOperationCall, I as SkillCapsuleDependency, K as resolveApplicationAssembly, L as SkillCapsuleResource, M as ResolveApplicationAssemblyOptions, N as ResolvedAssemblyPortBinding, O as ObjectTargetKindDefinition, P as ResourceInclude, R as TextMaterial, S as ObjectOperationContractError, T as ObjectOperationHandler, U as assertObjectOperationCatalog, V as assertExecuteObjectOperationRequest, W as assertObjectOperationDefinition, _ as ObjectInvocationMode, a as AssemblyResource, b as ObjectOperationCatalog, c as BusinessObjectSopResource, d as ExecuteObjectOperationRequest, f as JsonObject, g as ObjectInvocation, h as LoadApplicationAssemblyOptions, i as AssemblyPortBinding, j as PageObjectResource, k as ObjectTargetRef, l as CodeBinding, m as JsonValue, n as ApplicationScope, o as AuthoringModuleDescriptor, p as JsonPrimitive, q as resourceRefToFqn, r as AssemblyPort, s as BusinessObjectResource, t as ApplicationAssembly, u as ContractedCallableResource, v as ObjectOperationBehavior, w as ObjectOperationEffect, x as ObjectOperationConfig, y as ObjectOperationCall, z as TextResource } from "./index-Cqh9pEBa.js";
+import { A as buildResourceDependencySnapshot, B as ResourceTombstone, C as BuildResourceDependencySnapshotInput, D as ResourceDependencySnapshot, E as ResourceDependencyEdge, F as EffectiveResourceEntry, H as composeLayeredResourceRegistry, I as EffectiveResourceRegistry, L as ResourceLayerDescriptor, M as sha256Digest, N as ComposeLayeredResourceRegistryInput, O as ResourceDigestContribution, P as EffectiveKindDefinition, R as ResourceLayerInput, S as validateResourceTree, T as ResourceContentIdentity, U as Sha256Digest, V as ResourceTombstoneOrigin, _ as ResourceValue, a as ResourceDescriptor, b as SourceShape, c as ResourceKindContract, d as ResourceRecord, f as ResourceRegistry, g as ResourceValidationError, h as ResourceTreeBuildResult, i as RegisteredKindDefinition, j as createResourceContentIdentity, k as SnapshotResource, l as ResourceMetadata, m as ResourceTree, n as LoadedResourceTree, o as ResourceDiagnostic, p as ResourceScalar, r as LoadedResourceTreeBuildResult, s as ResourceIdentity, t as LoadResourceTreeOptions, u as ResourceNode, v as ResourceValueList, w as CreateResourceContentIdentityInput, x as loadResourceTree, y as ResourceValueMap, z as ResourceOrigin } from "./index-DdRHFKSQ.js";
+import { i as ResourceCompositionError, n as ResourceLayerContentIdentityInput, r as resolveEffectiveResourceContentIdentities, t as ResolveEffectiveResourceContentIdentitiesInput } from "./resource-core-Byhqyadq.js";
+import { S as skillCapsuleDistributionProjection, _ as applySkillCapsuleDistributionPlan, a as PlannedSkillCapsule, b as compilerSkillPackage, c as SkillCapsuleContentDigest, d as SkillCapsuleDistributionReceipt, f as SkillCapsuleIdentity, g as SkillReference, h as SkillDescriptor, i as PlanSkillCapsuleDistributionInput, l as SkillCapsuleDistributionError, m as SkillCapsuleProvenanceManifest, n as CompileResourceSkillCapsuleInput, o as PlannedSkillFile, p as SkillCapsulePlan, r as CompileSkillCapsuleInput, s as SkillCapsuleApplyStep, t as ApplySkillCapsuleDistributionOptions, u as SkillCapsuleDistributionPlan, v as compileResourceSkillCapsule, x as planSkillCapsuleDistribution, y as compileSkillCapsule } from "./index-96qHPZj2.js";
+//#region src/bundled-system-skills.d.ts
+declare function loadHalfcodeResourceDslSystemSkillPlan(): Promise<SkillCapsuleDistributionPlan>;
+//#endregion
+export { type ApplicationAssembly, type ApplicationScope, ApplySkillCapsuleDistributionOptions, type AssemblyPort, type AssemblyPortBinding, type AssemblyResource, type AuthoringModuleDescriptor, BuildResourceDependencySnapshotInput, type BusinessObjectResource, type BusinessObjectSopResource, type CodeBinding, CompileResourceSkillCapsuleInput, CompileSkillCapsuleInput, ComposeLayeredResourceRegistryInput, type ContractedCallableResource, CreateResourceContentIdentityInput, EffectiveKindDefinition, EffectiveResourceEntry, EffectiveResourceRegistry, type ExecuteObjectOperationRequest, type JsonObject, type JsonPrimitive, type JsonValue, type LoadApplicationAssemblyOptions, LoadResourceTreeOptions, LoadedResourceTree, LoadedResourceTreeBuildResult, type ObjectInvocation, type ObjectInvocationMode, type ObjectOperationBehavior, type ObjectOperationCall, type ObjectOperationCatalog, type ObjectOperationConfig, ObjectOperationContractError, type ObjectOperationDefinition, type ObjectOperationEffect, type ObjectOperationHandler, type ObjectOperationOwnerKind, type ObjectOperationTargetDeclaration, type ObjectTargetKindDefinition, type ObjectTargetRef, type ObjectTargets, type PageObjectResource, PlanSkillCapsuleDistributionInput, PlannedSkillCapsule, PlannedSkillFile, RegisteredKindDefinition, type ResolveApplicationAssemblyOptions, ResolveEffectiveResourceContentIdentitiesInput, type ResolvedAssemblyPortBinding, ResourceCompositionError, ResourceContentIdentity, ResourceDependencyEdge, ResourceDependencySnapshot, ResourceDescriptor, ResourceDiagnostic, ResourceDigestContribution, ResourceIdentity, type ResourceInclude, ResourceKindContract, ResourceLayerContentIdentityInput, ResourceLayerDescriptor, ResourceLayerInput, ResourceMetadata, ResourceNode, ResourceOrigin, ResourceRecord, ResourceRegistry, ResourceScalar, type ResourceSource, ResourceTombstone, ResourceTombstoneOrigin, ResourceTree, ResourceTreeBuildResult, ResourceValidationError, ResourceValue, ResourceValueList, ResourceValueMap, type Sha256Digest, SkillCapsuleApplyStep, SkillCapsuleContentDigest, type SkillCapsuleDependency, SkillCapsuleDistributionError, SkillCapsuleDistributionPlan, SkillCapsuleDistributionReceipt, SkillCapsuleIdentity, SkillCapsulePlan, SkillCapsuleProvenanceManifest, type SkillCapsuleResource, SkillDescriptor, SkillReference, SnapshotResource, SourceShape, type TextMaterial, type TextResource, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, planSkillCapsuleDistribution, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree };

package/dist/index.js

@@ -1,4 +1,13 @@
-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-DJr-I4Kc.js";
+import { c as sha256Digest, f as ResourceCompositionError, n as loadResourceTree, o as buildResourceDependencySnapshot, r as validateResourceTree, s as createResourceContentIdentity, t as ResourceValidationError } from "./src-DCRih45n.js";
+import { a as assertObjectOperationCatalog, c as resolveApplicationAssembly, i as assertObjectOperationCall, l as resourceRefToFqn, n as applicationAssemblyPackage, o as assertObjectOperationDefinition, r as assertExecuteObjectOperationRequest, s as loadApplicationAssembly, t as ObjectOperationContractError } from "./src-DRIws6tY.js";
 import "./application-assembly.js";
-import { n as compileSkillCapsule, r as compilerSkillPackage, t as compileResourceSkillCapsule } from "./src-B36aAZZE.js";
-export { ObjectOperationContractError, applicationAssemblyPackage, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, loadApplicationAssembly, resolveApplicationAssembly, resourceRefToFqn };
+import { composeLayeredResourceRegistry, resolveEffectiveResourceContentIdentities } from "./resource-core.js";
+import { a as compilerSkillPackage, i as compileSkillCapsule, n as applySkillCapsuleDistributionPlan, o as planSkillCapsuleDistribution, r as compileResourceSkillCapsule, s as skillCapsuleDistributionProjection, t as SkillCapsuleDistributionError } from "./src-D1Bmq7Lo.js";
+//#region src/bundled-system-skills.ts
+async function loadHalfcodeResourceDslSystemSkillPlan() {
+	const bundled = await import(new URL("./system-skills/sys-halfcode-resource-dsl.plan.js", import.meta.url).href);
+	if (!bundled.default) throw new Error("HALFCODE_RESOURCE_DSL_SKILL_PLAN_MISSING: bundled plan has no default export");
+	return bundled.default;
+}
+//#endregion
+export { ObjectOperationContractError, ResourceCompositionError, ResourceValidationError, SkillCapsuleDistributionError, applicationAssemblyPackage, applySkillCapsuleDistributionPlan, assertExecuteObjectOperationRequest, assertObjectOperationCall, assertObjectOperationCatalog, assertObjectOperationDefinition, buildResourceDependencySnapshot, compileResourceSkillCapsule, compileSkillCapsule, compilerSkillPackage, composeLayeredResourceRegistry, createResourceContentIdentity, loadApplicationAssembly, loadHalfcodeResourceDslSystemSkillPlan, loadResourceTree, planSkillCapsuleDistribution, resolveApplicationAssembly, resolveEffectiveResourceContentIdentities, resourceRefToFqn, sha256Digest, skillCapsuleDistributionProjection, validateResourceTree };

package/dist/kind-definition.d.ts

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

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

@@ -0,0 +1,20 @@
+import { I as EffectiveResourceRegistry, O as ResourceDigestContribution, T as ResourceContentIdentity, n as LoadedResourceTree, o as ResourceDiagnostic } from "./index-DdRHFKSQ.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/effective-content-identities.d.ts
+interface ResourceLayerContentIdentityInput {
+  readonly id: string;
+  readonly tree: LoadedResourceTree;
+}
+interface ResolveEffectiveResourceContentIdentitiesInput {
+  readonly registry: EffectiveResourceRegistry;
+  readonly layers: readonly ResourceLayerContentIdentityInput[];
+  readonly contributions?: ReadonlyMap<string, readonly ResourceDigestContribution[]>;
+}
+declare function resolveEffectiveResourceContentIdentities(input: ResolveEffectiveResourceContentIdentitiesInput): ReadonlyMap<string, ResourceContentIdentity>;
+//#endregion
+export { ResourceCompositionError as i, ResourceLayerContentIdentityInput as n, resolveEffectiveResourceContentIdentities as r, ResolveEffectiveResourceContentIdentitiesInput as t };

package/dist/resource-core.d.ts

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