holarchy-eidolon-adapter 0.2.0 → 0.2.2

package/dist/HolonExecutionBinding.d.ts

@@ -0,0 +1,90 @@
+import { type JsonSchema, type KindReaderRegistration, type KindSemanticContract } from "halfcode-compiler.xnl/resource-core";
+export declare const HOLON_EXECUTION_BINDING_KIND: "HolonExecutionBinding";
+export declare const HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN: "Eidolon.AI.KindDefinition.HolonExecutionBinding";
+export declare const HOLON_EXECUTION_BINDING_API_VERSION: "eidolon.ai/v1";
+export declare const HOLON_EXECUTION_BINDING_KIND_DEFINITION_SPEC_VERSION: 1;
+export declare const HOLON_EXECUTION_BINDING_KIND_OWNER_PACKAGE_ID: "holarchy-eidolon-adapter";
+export declare const HOLON_EXECUTION_BINDING_KIND_OWNER_PACKAGE_FINGERPRINT: `sha256:${string}`;
+export declare const HOLON_EXECUTION_BINDING_KIND_OWNER: import("halfcode-compiler.xnl/resource-core").KindSubjectOwner;
+export declare const HOLON_EXECUTION_BINDING_SPEC_SCHEMA_V1: JsonSchema;
+export declare const HOLON_EXECUTION_BINDING_SEMANTIC_CONTRACT_V1: KindSemanticContract;
+export declare const HOLON_EXECUTION_BINDING_KIND_SPEC_REVISION_V1: import("halfcode-compiler.xnl/resource-core").KindSpecRevision;
+export declare const HOLON_EXECUTION_BINDING_KIND_DEFINITION_SOURCE: string;
+export declare const HOLON_EXECUTION_BINDING_KIND_DEFINITION_BYTES: Readonly<Uint8Array>;
+export declare const HOLON_MEMBER_EXECUTION_ADAPTER_KINDS: readonly ["ai-agent", "human-endpoint", "service", "hybrid"];
+export type HolonExecutionResourceRef = `resource://${string}`;
+export type HolonExecutionTarget = Readonly<{
+    readonly kind: "member";
+    readonly memberRef: string;
+}> | Readonly<{
+    readonly kind: "role";
+    readonly roleRef: string;
+}>;
+export type HolonMemberExecutionAdapter = Readonly<{
+    readonly kind: "ai-agent";
+    readonly agentDefinitionRef: HolonExecutionResourceRef;
+    readonly runtimeProfileRef: HolonExecutionResourceRef;
+}> | Readonly<{
+    readonly kind: "human-endpoint";
+    readonly humanEndpointRef: HolonExecutionResourceRef;
+    readonly inboxProfileRef: HolonExecutionResourceRef;
+}> | Readonly<{
+    readonly kind: "service";
+    readonly serviceAdapterRef: HolonExecutionResourceRef;
+    readonly runtimeProfileRef: HolonExecutionResourceRef;
+}> | Readonly<{
+    readonly kind: "hybrid";
+    readonly policyRef: HolonExecutionResourceRef;
+    readonly candidateBindingRefs: readonly [HolonExecutionResourceRef, ...HolonExecutionResourceRef[]];
+}>;
+export type HolonExecutionRuntimeIntent = Readonly<{
+    readonly mode: "shared-member-runtime";
+}> | Readonly<{
+    readonly mode: "isolated-task-runtime";
+}>;
+export interface HolonExecutionPolicyV1 {
+    readonly version: "1";
+    readonly runtime: HolonExecutionRuntimeIntent;
+    readonly taskProfileRef: HolonExecutionResourceRef;
+    readonly capabilityRefs: readonly HolonExecutionResourceRef[];
+    readonly toolRefs: readonly HolonExecutionResourceRef[];
+    readonly materialRefs: readonly HolonExecutionResourceRef[];
+}
+export interface HolonExecutionBinding {
+    readonly apiVersion: typeof HOLON_EXECUTION_BINDING_API_VERSION;
+    readonly kind: typeof HOLON_EXECUTION_BINDING_KIND;
+    readonly bindingRef: HolonExecutionResourceRef;
+    readonly snapshotRef: HolonExecutionResourceRef;
+    readonly target: HolonExecutionTarget;
+    readonly adapter: HolonMemberExecutionAdapter;
+    readonly policy: HolonExecutionPolicyV1;
+}
+export interface HolonExecutionInvocation {
+    readonly apiVersion: typeof HOLON_EXECUTION_BINDING_API_VERSION;
+    readonly kind: "HolonExecutionInvocation";
+    readonly taskSpaceRef: string;
+    readonly taskRef: string;
+    readonly claimRef: string;
+    readonly invocationRef: string;
+    readonly targetBindingRef: HolonExecutionResourceRef;
+    readonly input: ClosedValue;
+    readonly materialRefs: readonly HolonExecutionResourceRef[];
+    readonly resultContractRef: HolonExecutionResourceRef;
+}
+interface ClosedArray extends ReadonlyArray<ClosedValue> {
+}
+interface ClosedRecord {
+    readonly [key: string]: ClosedValue;
+}
+export type ClosedValue = null | string | number | boolean | ClosedArray | ClosedRecord;
+export declare class HolonExecutionBindingContractError extends Error {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+export declare function normalizeHolonExecutionBinding(value: unknown): HolonExecutionBinding;
+export declare function canonicalHolonExecutionBindingBytes(value: unknown): Uint8Array;
+export declare function parseHolonExecutionBindingBytes(bytes: Uint8Array): HolonExecutionBinding;
+export declare const HOLON_EXECUTION_BINDING_KIND_READER_REGISTRATION_V1: KindReaderRegistration<HolonExecutionBinding>;
+export declare function validateHolonExecutionBindingGraph(values: readonly HolonExecutionBinding[]): readonly HolonExecutionBinding[];
+export declare function normalizeHolonExecutionInvocation(value: unknown): HolonExecutionInvocation;
+export {};

package/dist/HolonExecutionBinding.js

@@ -0,0 +1,453 @@
+import { decodeCanonicalBase64 } from './canonicalBase64.js';
+import { digestCanonical, } from "halfcode-compiler.xnl/resource-core";
+import { createKindSpecRevision, createKindSubjectOwner, } from "halfcode-compiler.xnl/kind-definition";
+export const HOLON_EXECUTION_BINDING_KIND = "HolonExecutionBinding";
+export const HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN = "Eidolon.AI.KindDefinition.HolonExecutionBinding";
+export const HOLON_EXECUTION_BINDING_API_VERSION = "eidolon.ai/v1";
+export const HOLON_EXECUTION_BINDING_KIND_DEFINITION_SPEC_VERSION = 1;
+export const HOLON_EXECUTION_BINDING_KIND_OWNER_PACKAGE_ID = "holarchy-eidolon-adapter";
+export const HOLON_EXECUTION_BINDING_KIND_OWNER_PACKAGE_FINGERPRINT = digestCanonical(Object.freeze({
+    authority: "holarchy-eidolon-adapter/holon-execution-binding-kind/v1",
+    ownerPackageId: HOLON_EXECUTION_BINDING_KIND_OWNER_PACKAGE_ID,
+    subjects: Object.freeze([HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN]),
+    semanticContractVersion: HOLON_EXECUTION_BINDING_API_VERSION,
+}));
+export const HOLON_EXECUTION_BINDING_KIND_OWNER = createKindSubjectOwner({
+    kind: HOLON_EXECUTION_BINDING_KIND,
+    subjectFqn: HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN,
+    ownerPackageId: HOLON_EXECUTION_BINDING_KIND_OWNER_PACKAGE_ID,
+    ownerPackageFingerprint: HOLON_EXECUTION_BINDING_KIND_OWNER_PACKAGE_FINGERPRINT,
+    sourceShapes: Object.freeze(["single-file"]),
+    documentCardinality: "one",
+});
+export const HOLON_EXECUTION_BINDING_SPEC_SCHEMA_V1 = Object.freeze({
+    type: "object",
+    required: Object.freeze(["properties", "body", "subdomains"]),
+    properties: Object.freeze({
+        properties: Object.freeze({
+            type: "object",
+            required: Object.freeze(["bindingBytesBase64"]),
+            properties: Object.freeze({
+                bindingBytesBase64: Object.freeze({ type: "string", minLength: 1 }),
+            }),
+            additionalProperties: false,
+        }),
+        body: Object.freeze({ type: "array", maxItems: 0 }),
+        subdomains: Object.freeze({ type: "object", maxProperties: 0 }),
+    }),
+    additionalProperties: false,
+});
+export const HOLON_EXECUTION_BINDING_SEMANTIC_CONTRACT_V1 = Object.freeze({
+    semanticValidatorFingerprint: digestCanonical(Object.freeze({
+        authority: "holarchy-eidolon-adapter/holon-execution-binding-kind/v1",
+        role: "canonical-binding-and-graph-validation",
+        apiVersion: HOLON_EXECUTION_BINDING_API_VERSION,
+        validators: Object.freeze([
+            "parseHolonExecutionBindingBytes",
+            "validateHolonExecutionBindingGraph",
+        ]),
+    })),
+    referenceProjectionFingerprint: digestCanonical(Object.freeze({
+        authority: "holarchy-eidolon-adapter/holon-execution-binding-kind/v1",
+        role: "closed-execution-binding-reference-projection",
+        fields: Object.freeze([
+            "snapshotRef",
+            "adapter",
+            "policy.taskProfileRef",
+            "policy.capabilityRefs",
+            "policy.toolRefs",
+            "policy.materialRefs",
+        ]),
+    })),
+    compilerInputFingerprint: digestCanonical(Object.freeze({
+        authority: "holarchy-eidolon-adapter/holon-execution-binding-kind/v1",
+        role: "authored-resource-to-canonical-binding-input",
+        fields: Object.freeze(["properties.bindingBytesBase64"]),
+        encoding: "canonical-base64",
+    })),
+});
+export const HOLON_EXECUTION_BINDING_KIND_SPEC_REVISION_V1 = createKindSpecRevision({
+    kind: HOLON_EXECUTION_BINDING_KIND_OWNER.kind,
+    subjectFqn: HOLON_EXECUTION_BINDING_KIND_OWNER.subjectFqn,
+    specVersion: HOLON_EXECUTION_BINDING_KIND_DEFINITION_SPEC_VERSION,
+    specSchema: HOLON_EXECUTION_BINDING_SPEC_SCHEMA_V1,
+    semanticContract: HOLON_EXECUTION_BINDING_SEMANTIC_CONTRACT_V1,
+    sourceContractFingerprint: HOLON_EXECUTION_BINDING_KIND_OWNER.sourceContract.sourceContractFingerprint,
+    stability: "stable",
+});
+function renderHolonExecutionBindingKindDefinition() {
+    const owner = HOLON_EXECUTION_BINDING_KIND_OWNER;
+    const revision = HOLON_EXECUTION_BINDING_KIND_SPEC_REVISION_V1;
+    return [
+        `<KindDefinition #${HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN} envelopeVersion="halfcode.resource-envelope/v1" specVersion=1 {`,
+        '  lifecycle = "Stable"',
+        `  resourceKind = "${owner.kind}"`,
+        `  subjectFqn = "${owner.subjectFqn}"`,
+        '  sourceShapes = ["single-file"]',
+        `  documentCardinality = "${owner.sourceContract.documentCardinality}"`,
+        '  description = "Maps one frozen Holon Member or Role identity to an exact Eidolon execution adapter closure."',
+        '} (',
+        '  <SpecRevisions [',
+        `    <SpecRevision #v${revision.specVersion} {`,
+        `      specVersion = ${revision.specVersion}`,
+        '      schemaRef = "vfs://./spec-v1.schema.json"',
+        `      schemaFingerprint = "${revision.schemaFingerprint}"`,
+        `      contractFingerprint = "${revision.contractFingerprint}"`,
+        `      semanticValidatorFingerprint = "${revision.semanticContract.semanticValidatorFingerprint}"`,
+        `      referenceProjectionFingerprint = "${revision.semanticContract.referenceProjectionFingerprint}"`,
+        `      compilerInputFingerprint = "${revision.semanticContract.compilerInputFingerprint}"`,
+        `      stability = "${revision.stability}"`,
+        '    }>',
+        '  ]>',
+        ')>',
+        '',
+    ].join("\n");
+}
+export const HOLON_EXECUTION_BINDING_KIND_DEFINITION_SOURCE = renderHolonExecutionBindingKindDefinition();
+export const HOLON_EXECUTION_BINDING_KIND_DEFINITION_BYTES = new TextEncoder().encode(HOLON_EXECUTION_BINDING_KIND_DEFINITION_SOURCE);
+export const HOLON_MEMBER_EXECUTION_ADAPTER_KINDS = Object.freeze([
+    "ai-agent",
+    "human-endpoint",
+    "service",
+    "hybrid",
+]);
+export class HolonExecutionBindingContractError extends Error {
+    path;
+    constructor(path, message) {
+        super(`${path}: ${message}`);
+        this.path = path;
+        this.name = "HolonExecutionBindingContractError";
+    }
+}
+const invalid = (path, message) => {
+    throw new HolonExecutionBindingContractError(path, message);
+};
+const compareUtf16CodeUnits = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+function closedObject(value, path) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return invalid(path, "Expected a plain object");
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        return invalid(path, "Expected a plain object");
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Reflect.ownKeys(descriptors);
+    if (keys.some((key) => typeof key !== "string")) {
+        return invalid(path, "Symbol properties are not allowed");
+    }
+    const result = Object.create(null);
+    for (const key of keys.sort(compareUtf16CodeUnits)) {
+        const descriptor = descriptors[key];
+        if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true) {
+            return invalid(`${path}.${key}`, "Expected one enumerable own-data property");
+        }
+        result[key] = descriptor.value;
+    }
+    return result;
+}
+function exactKeys(value, expected, path) {
+    const expectedSet = new Set(expected);
+    const extra = Object.keys(value).find((key) => !expectedSet.has(key));
+    if (extra !== undefined)
+        invalid(`${path}.${extra}`, "Unsupported field");
+    const missing = expected.find((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    if (missing !== undefined)
+        invalid(`${path}.${missing}`, "Required field is missing");
+}
+function exactString(value, path) {
+    if (typeof value !== "string" || value.length === 0 || value !== value.trim()) {
+        return invalid(path, "Expected an exact non-empty string");
+    }
+    return value;
+}
+function exactLiteral(value, expected, path) {
+    if (value !== expected)
+        invalid(path, `Expected '${expected}'`);
+    return expected;
+}
+function resourceRef(value, path) {
+    const exact = exactString(value, path);
+    const prefix = "resource://";
+    if (!exact.startsWith(prefix))
+        invalid(path, "Expected an exact resource:// reference");
+    const identity = exact.slice(prefix.length);
+    if (!identity || identity.includes("://"))
+        invalid(path, "Expected one exact Resource identity");
+    return exact;
+}
+function denseArray(value, path) {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
+        return invalid(path, "Expected a plain dense array");
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true) {
+            return invalid(`${path}[${index}]`, "Expected a dense enumerable own-data entry");
+        }
+    }
+    for (const key of Reflect.ownKeys(descriptors)) {
+        if (key === "length")
+            continue;
+        if (typeof key !== "string" || !/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length) {
+            return invalid(path, "Symbol and extra array properties are not allowed");
+        }
+    }
+    return value;
+}
+function resourceRefs(value, path, options = {}) {
+    const refs = denseArray(value, path).map((entry, index) => resourceRef(entry, `${path}[${index}]`));
+    if (options.nonEmpty && refs.length === 0)
+        invalid(path, "Expected at least one Resource reference");
+    if (new Set(refs).size !== refs.length)
+        invalid(path, "Resource reference list contains a duplicate");
+    if (options.sort)
+        refs.sort(compareUtf16CodeUnits);
+    return Object.freeze(refs);
+}
+function target(value) {
+    const record = closedObject(value, "$.target");
+    const kind = exactString(record.kind, "$.target.kind");
+    if (kind === "member") {
+        exactKeys(record, ["kind", "memberRef"], "$.target");
+        return Object.freeze({ kind, memberRef: exactString(record.memberRef, "$.target.memberRef") });
+    }
+    if (kind === "role") {
+        exactKeys(record, ["kind", "roleRef"], "$.target");
+        return Object.freeze({ kind, roleRef: exactString(record.roleRef, "$.target.roleRef") });
+    }
+    return invalid("$.target.kind", "Expected 'member' or 'role'");
+}
+function adapter(value) {
+    const record = closedObject(value, "$.adapter");
+    const kind = exactString(record.kind, "$.adapter.kind");
+    if (kind === "ai-agent") {
+        exactKeys(record, ["kind", "agentDefinitionRef", "runtimeProfileRef"], "$.adapter");
+        return Object.freeze({
+            kind,
+            agentDefinitionRef: resourceRef(record.agentDefinitionRef, "$.adapter.agentDefinitionRef"),
+            runtimeProfileRef: resourceRef(record.runtimeProfileRef, "$.adapter.runtimeProfileRef"),
+        });
+    }
+    if (kind === "human-endpoint") {
+        exactKeys(record, ["kind", "humanEndpointRef", "inboxProfileRef"], "$.adapter");
+        return Object.freeze({
+            kind,
+            humanEndpointRef: resourceRef(record.humanEndpointRef, "$.adapter.humanEndpointRef"),
+            inboxProfileRef: resourceRef(record.inboxProfileRef, "$.adapter.inboxProfileRef"),
+        });
+    }
+    if (kind === "service") {
+        exactKeys(record, ["kind", "serviceAdapterRef", "runtimeProfileRef"], "$.adapter");
+        return Object.freeze({
+            kind,
+            serviceAdapterRef: resourceRef(record.serviceAdapterRef, "$.adapter.serviceAdapterRef"),
+            runtimeProfileRef: resourceRef(record.runtimeProfileRef, "$.adapter.runtimeProfileRef"),
+        });
+    }
+    if (kind === "hybrid") {
+        exactKeys(record, ["kind", "policyRef", "candidateBindingRefs"], "$.adapter");
+        const refs = resourceRefs(record.candidateBindingRefs, "$.adapter.candidateBindingRefs", { nonEmpty: true });
+        return Object.freeze({
+            kind,
+            policyRef: resourceRef(record.policyRef, "$.adapter.policyRef"),
+            candidateBindingRefs: refs,
+        });
+    }
+    return invalid("$.adapter.kind", "Expected one closed execution adapter kind");
+}
+function policy(value) {
+    const record = closedObject(value, "$.policy");
+    exactKeys(record, [
+        "version",
+        "runtime",
+        "taskProfileRef",
+        "capabilityRefs",
+        "toolRefs",
+        "materialRefs",
+    ], "$.policy");
+    exactLiteral(record.version, "1", "$.policy.version");
+    const runtime = closedObject(record.runtime, "$.policy.runtime");
+    exactKeys(runtime, ["mode"], "$.policy.runtime");
+    const mode = exactString(runtime.mode, "$.policy.runtime.mode");
+    if (mode !== "shared-member-runtime" && mode !== "isolated-task-runtime") {
+        invalid("$.policy.runtime.mode", "Expected one closed runtime intent");
+    }
+    const normalizedMode = mode;
+    return Object.freeze({
+        version: "1",
+        runtime: Object.freeze({ mode: normalizedMode }),
+        taskProfileRef: resourceRef(record.taskProfileRef, "$.policy.taskProfileRef"),
+        capabilityRefs: resourceRefs(record.capabilityRefs, "$.policy.capabilityRefs", { sort: true }),
+        toolRefs: resourceRefs(record.toolRefs, "$.policy.toolRefs", { sort: true }),
+        materialRefs: resourceRefs(record.materialRefs, "$.policy.materialRefs", { sort: true }),
+    });
+}
+export function normalizeHolonExecutionBinding(value) {
+    const record = closedObject(value, "$");
+    exactKeys(record, [
+        "apiVersion",
+        "kind",
+        "bindingRef",
+        "snapshotRef",
+        "target",
+        "adapter",
+        "policy",
+    ], "$");
+    return Object.freeze({
+        apiVersion: exactLiteral(record.apiVersion, HOLON_EXECUTION_BINDING_API_VERSION, "$.apiVersion"),
+        kind: exactLiteral(record.kind, HOLON_EXECUTION_BINDING_KIND, "$.kind"),
+        bindingRef: resourceRef(record.bindingRef, "$.bindingRef"),
+        snapshotRef: resourceRef(record.snapshotRef, "$.snapshotRef"),
+        target: target(record.target),
+        adapter: adapter(record.adapter),
+        policy: policy(record.policy),
+    });
+}
+function sameBytes(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        if (left[index] !== right[index])
+            return false;
+    }
+    return true;
+}
+export function canonicalHolonExecutionBindingBytes(value) {
+    return new TextEncoder().encode(JSON.stringify(normalizeHolonExecutionBinding(value)));
+}
+export function parseHolonExecutionBindingBytes(bytes) {
+    let decoded;
+    try {
+        decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        return invalid("$bytes", "Binding bytes are not valid UTF-8");
+    }
+    let value;
+    try {
+        value = JSON.parse(decoded);
+    }
+    catch {
+        return invalid("$bytes", "Binding bytes are not valid JSON");
+    }
+    const binding = normalizeHolonExecutionBinding(value);
+    if (!sameBytes(bytes, canonicalHolonExecutionBindingBytes(binding))) {
+        return invalid("$bytes", "Binding bytes are not canonical");
+    }
+    return binding;
+}
+function canonicalBase64SpecBytes(spec, property) {
+    const properties = closedObject(spec.properties, "$.properties");
+    exactKeys(properties, [property], "$.properties");
+    const value = exactString(properties[property], `$.properties.${property}`);
+    let bytes;
+    try {
+        bytes = decodeCanonicalBase64(value);
+    }
+    catch {
+        return invalid(`$.properties.${property}`, "Expected canonical base64");
+    }
+    return bytes;
+}
+export const HOLON_EXECUTION_BINDING_KIND_READER_REGISTRATION_V1 = Object.freeze({
+    readerId: "holarchy-eidolon-adapter.holon-execution-binding.v1",
+    subjectFqn: HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN,
+    readerSpecVersion: HOLON_EXECUTION_BINDING_KIND_DEFINITION_SPEC_VERSION,
+    contractFingerprint: HOLON_EXECUTION_BINDING_KIND_SPEC_REVISION_V1.contractFingerprint,
+    readerImplementationFingerprint: digestCanonical(Object.freeze({
+        authority: "holarchy-eidolon-adapter/holon-execution-binding-reader/v1",
+        implementation: Object.freeze([
+            "canonicalBase64SpecBytes",
+            "parseHolonExecutionBindingBytes",
+        ]),
+    })),
+    compatibilityPolicy: "exact",
+    read: (spec) => parseHolonExecutionBindingBytes(canonicalBase64SpecBytes(spec, "bindingBytesBase64")),
+});
+export function validateHolonExecutionBindingGraph(values) {
+    const bindings = values.map(normalizeHolonExecutionBinding);
+    const byRef = new Map();
+    for (const binding of bindings) {
+        if (byRef.has(binding.bindingRef)) {
+            invalid("$.bindings", `Duplicate binding identity '${binding.bindingRef}'`);
+        }
+        byRef.set(binding.bindingRef, binding);
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (bindingRef) => {
+        if (visited.has(bindingRef))
+            return;
+        if (visiting.has(bindingRef))
+            invalid("$.bindings", `Hybrid binding cycle includes '${bindingRef}'`);
+        const binding = byRef.get(bindingRef)
+            ?? invalid("$.bindings", `Hybrid candidate '${bindingRef}' is unresolved`);
+        visiting.add(bindingRef);
+        if (binding.adapter.kind === "hybrid") {
+            for (const candidateRef of binding.adapter.candidateBindingRefs)
+                visit(candidateRef);
+        }
+        visiting.delete(bindingRef);
+        visited.add(bindingRef);
+    };
+    for (const binding of bindings)
+        visit(binding.bindingRef);
+    return Object.freeze(bindings);
+}
+function cloneClosedValue(value, path, active = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            invalid(path, "Expected a finite number");
+        return value;
+    }
+    if (typeof value !== "object")
+        return invalid(path, "Expected JSON-compatible plain data");
+    if (active.has(value))
+        return invalid(path, "Cycles are not allowed");
+    active.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return Object.freeze(denseArray(value, path).map((entry, index) => cloneClosedValue(entry, `${path}[${index}]`, active)));
+        }
+        const record = closedObject(value, path);
+        const output = Object.create(null);
+        for (const key of Object.keys(record).sort(compareUtf16CodeUnits)) {
+            output[key] = cloneClosedValue(record[key], `${path}.${key}`, active);
+        }
+        return Object.freeze(output);
+    }
+    finally {
+        active.delete(value);
+    }
+}
+export function normalizeHolonExecutionInvocation(value) {
+    const record = closedObject(value, "$");
+    exactKeys(record, [
+        "apiVersion",
+        "kind",
+        "taskSpaceRef",
+        "taskRef",
+        "claimRef",
+        "invocationRef",
+        "targetBindingRef",
+        "input",
+        "materialRefs",
+        "resultContractRef",
+    ], "$");
+    return Object.freeze({
+        apiVersion: exactLiteral(record.apiVersion, HOLON_EXECUTION_BINDING_API_VERSION, "$.apiVersion"),
+        kind: exactLiteral(record.kind, "HolonExecutionInvocation", "$.kind"),
+        taskSpaceRef: exactString(record.taskSpaceRef, "$.taskSpaceRef"),
+        taskRef: exactString(record.taskRef, "$.taskRef"),
+        claimRef: exactString(record.claimRef, "$.claimRef"),
+        invocationRef: exactString(record.invocationRef, "$.invocationRef"),
+        targetBindingRef: resourceRef(record.targetBindingRef, "$.targetBindingRef"),
+        input: cloneClosedValue(record.input, "$.input"),
+        materialRefs: resourceRefs(record.materialRefs, "$.materialRefs", { sort: true }),
+        resultContractRef: resourceRef(record.resultContractRef, "$.resultContractRef"),
+    });
+}

package/dist/HolonExecutionBindingProjection.d.ts

@@ -0,0 +1,57 @@
+import { type HolonExecutionBinding, type HolonExecutionResourceRef } from "./HolonExecutionBinding.js";
+import { type HolonEffectiveSnapshot, type HolonEffectiveSnapshotIssuanceReceipt } from "holarchy-core-contract";
+import { type EffectiveResourceRegistry, type ResourceContentIdentity, type ResourceRecord } from "halfcode-compiler.xnl/resource-core";
+import type { AIWorkflowAgentResourceProjection } from "ai-workflow-contract";
+export interface EidolonHolonExecutionBindingProjection {
+    readonly schemaVersion: "eidolon.holon-execution-binding-projection/v1";
+    readonly resource: ResourceRecord;
+    readonly binding: HolonExecutionBinding;
+    readonly snapshotResource: ResourceRecord;
+    readonly snapshot: HolonEffectiveSnapshot;
+    readonly snapshotBytes: Uint8Array;
+    readonly receiptBytes: Uint8Array;
+    readonly receipt: HolonEffectiveSnapshotIssuanceReceipt;
+    readonly bindingBytesDigest: `sha256:${string}`;
+    readonly receiptBytesDigest: `sha256:${string}`;
+    readonly closureResourceIds: readonly string[];
+    readonly registryRevision: string;
+}
+export interface EidolonHolonExecutionAgentProof {
+    readonly agentDefinitionRef: HolonExecutionResourceRef;
+    readonly agentContentDigest: `sha256:${string}`;
+    readonly closureResourceIds: readonly string[];
+    readonly snapshotRevision: `sha256:${string}`;
+}
+export interface EidolonHolonExecutionBindingFreezeReceipt {
+    readonly schemaVersion: "eidolon.holon-execution-binding-freeze/v1";
+    readonly bindingRef: HolonExecutionResourceRef;
+    readonly snapshotRef: HolonExecutionResourceRef;
+    readonly snapshotTreeDigest: `sha256:${string}`;
+    readonly snapshotReceiptDigest: `sha256:${string}`;
+    readonly bindingBytesDigest: `sha256:${string}`;
+    readonly registryRevision: string;
+    readonly closure: readonly Readonly<{
+        readonly resourceId: string;
+        readonly kind: string;
+        readonly authorityDigest: `sha256:${string}`;
+        readonly contentDigest: `sha256:${string}`;
+    }>[];
+    readonly agentProofs: readonly EidolonHolonExecutionAgentProof[];
+    readonly semanticFingerprint: `sha256:${string}`;
+}
+export interface HolonExecutionBindingProjectionInput {
+    readonly registry: EffectiveResourceRegistry;
+    readonly contentIdentities: ReadonlyMap<string, ResourceContentIdentity>;
+    readonly kindDefinitionAuthorityDigests: ReadonlyMap<string, `sha256:${string}`>;
+    readonly registryRevision: string;
+}
+export interface HolonExecutionBindingFreezeInput {
+    readonly registry: EffectiveResourceRegistry;
+    readonly contentIdentities: ReadonlyMap<string, ResourceContentIdentity>;
+    readonly registryRevision: string;
+    readonly projection: EidolonHolonExecutionBindingProjection;
+    readonly agentResources: AIWorkflowAgentResourceProjection;
+}
+export declare function projectHolonExecutionBindings(input: HolonExecutionBindingProjectionInput): Promise<readonly EidolonHolonExecutionBindingProjection[]>;
+export declare function freezeHolonExecutionBinding(input: HolonExecutionBindingFreezeInput): EidolonHolonExecutionBindingFreezeReceipt;
+export declare function assertHolonExecutionBindingFreezeReceipt(value: EidolonHolonExecutionBindingFreezeReceipt): EidolonHolonExecutionBindingFreezeReceipt;