holarchy-eidolon-adapter 0.1.1 → 0.2.1

package/dist/HolonExecutionBindingProjection.js

@@ -0,0 +1,289 @@
+import { HOLON_EXECUTION_BINDING_KIND, HOLON_EXECUTION_BINDING_KIND_DEFINITION_BYTES, HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN, parseHolonExecutionBindingBytes, validateHolonExecutionBindingGraph, } from "./HolonExecutionBinding.js";
+import { HOLON_EFFECTIVE_SNAPSHOT_KIND, HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_BYTES, HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_FQN, parseHolonEffectiveSnapshotBytes, parseHolonEffectiveSnapshotIssuanceReceiptBytes, } from "holarchy-core-contract";
+import { buildResourceDependencySnapshot, sha256Digest, } from "halfcode-compiler.xnl/resource-core";
+import { HolarchyEidolonAdapterError as EidolonResourceRegistryError } from "./HolarchyEidolonAdapterError.js";
+const authenticProjections = new WeakSet();
+const authenticFreezeReceipts = new WeakSet();
+export async function projectHolonExecutionBindings(input) {
+    const resources = [...(input.registry.byKind.get(HOLON_EXECUTION_BINDING_KIND) ?? [])]
+        .sort((left, right) => compareUtf16(left.resourceId, right.resourceId));
+    if (resources.length === 0)
+        return Object.freeze([]);
+    assertCanonicalKindDefinition(input, {
+        resourceKind: HOLON_EXECUTION_BINDING_KIND,
+        fqn: HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN,
+        bytes: HOLON_EXECUTION_BINDING_KIND_DEFINITION_BYTES,
+        code: "EIDOLON_HOLON_BINDING_KIND_DEFINITION_MISMATCH",
+    });
+    assertCanonicalKindDefinition(input, {
+        resourceKind: HOLON_EFFECTIVE_SNAPSHOT_KIND,
+        fqn: HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_FQN,
+        bytes: HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_BYTES,
+        code: "EIDOLON_HOLON_SNAPSHOT_KIND_DEFINITION_MISMATCH",
+    });
+    const decoded = resources.map((resource) => {
+        const bindingBytes = canonicalBase64Property(resource, "bindingBytesBase64");
+        const binding = parseHolonExecutionBindingBytes(bindingBytes);
+        if (binding.bindingRef !== resourceRef(resource.resourceId)) {
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_IDENTITY_MISMATCH", `HolonExecutionBinding '${resource.resourceId}' bytes select '${binding.bindingRef}'.`);
+        }
+        return Object.freeze({ resource, binding, bindingBytes });
+    });
+    const bindingGraph = validateHolonExecutionBindingGraph(decoded.map(({ binding }) => binding));
+    const decodedByRef = new Map(decoded.map((entry) => [entry.binding.bindingRef, entry]));
+    const projections = [];
+    for (const binding of bindingGraph) {
+        const decodedBinding = decodedByRef.get(binding.bindingRef);
+        if (!decodedBinding)
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_GRAPH_INTERNAL", `HolonExecutionBinding '${binding.bindingRef}' disappeared during projection.`);
+        const snapshotId = resourceId(binding.snapshotRef);
+        const snapshotResource = exactResource(input.registry, snapshotId);
+        if (snapshotResource.kind !== HOLON_EFFECTIVE_SNAPSHOT_KIND) {
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_SNAPSHOT_KIND_MISMATCH", `Resource '${snapshotId}' must be a canonical ${HOLON_EFFECTIVE_SNAPSHOT_KIND} Resource.`);
+        }
+        const snapshotBytes = canonicalBase64Property(snapshotResource, "snapshotBytesBase64");
+        const snapshot = await parseHolonEffectiveSnapshotBytes(snapshotBytes);
+        const receiptBytes = canonicalBase64Property(snapshotResource, "issuanceReceiptBytesBase64");
+        const receipt = parseHolonEffectiveSnapshotIssuanceReceiptBytes(receiptBytes, snapshot);
+        assertTargetExists(binding, snapshot);
+        const closureResourceIds = resolveBindingClosureResourceIds(binding, decodedByRef, input.registry);
+        for (const resourceId of closureResourceIds)
+            requiredIdentity(input.contentIdentities, resourceId);
+        requiredIdentity(input.contentIdentities, snapshotResource.resourceId);
+        const projection = Object.freeze({
+            schemaVersion: "eidolon.holon-execution-binding-projection/v1",
+            resource: decodedBinding.resource,
+            binding,
+            snapshotResource,
+            snapshot,
+            receipt,
+            bindingBytesDigest: sha256Digest(decodedBinding.bindingBytes),
+            receiptBytesDigest: sha256Digest(receiptBytes),
+            closureResourceIds,
+            registryRevision: input.registryRevision,
+        });
+        authenticProjections.add(projection);
+        projections.push(projection);
+    }
+    return Object.freeze(projections);
+}
+export function freezeHolonExecutionBinding(input) {
+    if (!authenticProjections.has(input.projection)) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_PROJECTION_UNTRUSTED", "Binding freeze requires the exact projection produced by the shared registry.");
+    }
+    const closure = Object.freeze(input.projection.closureResourceIds.map((resourceId) => {
+        const resource = exactResource(input.registry, resourceId);
+        const identity = requiredIdentity(input.contentIdentities, resourceId);
+        return Object.freeze({
+            resourceId,
+            kind: resource.kind,
+            authorityDigest: exactSha256(identity.authorityDigest, `${resourceId}.authorityDigest`),
+            contentDigest: exactSha256(identity.contentDigest, `${resourceId}.contentDigest`),
+        });
+    }));
+    const agentProofs = Object.freeze(agentRefs(input.projection.binding, new Map((input.registry.byKind.get(HOLON_EXECUTION_BINDING_KIND) ?? []).map((resource) => {
+        const projected = resourceRef(resource.resourceId);
+        return [projected, projected === input.projection.binding.bindingRef
+                ? input.projection.binding
+                : parseHolonExecutionBindingBytes(canonicalBase64Property(resource, "bindingBytesBase64"))];
+    }))).map((agentDefinitionRef) => {
+        const agentId = resourceId(agentDefinitionRef);
+        const agent = input.agentResources.agentDefinitions.find((candidate) => candidate.resource.resourceId === agentId);
+        if (!agent)
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_AGENT_PROJECTION_MISSING", `AIAgentDefinition '${agentDefinitionRef}' has no authentic shared-registry projection.`);
+        const roots = agentClosureResourceIds(agent);
+        const dependencySnapshot = buildResourceDependencySnapshot({
+            registry: input.registry,
+            roots,
+            edges: input.agentResources.dependencyEdges,
+            contentIdentities: input.contentIdentities,
+        });
+        return Object.freeze({
+            agentDefinitionRef,
+            agentContentDigest: requiredIdentity(input.contentIdentities, agentId).contentDigest,
+            closureResourceIds: Object.freeze(dependencySnapshot.closure.map(({ resourceId }) => resourceId)),
+            snapshotRevision: dependencySnapshot.snapshotRevision,
+        });
+    }));
+    const semanticFingerprint = sha256Digest(JSON.stringify({
+        schemaVersion: "eidolon.holon-execution-binding-freeze-semantic/v1",
+        bindingRef: input.projection.binding.bindingRef,
+        snapshotRef: input.projection.binding.snapshotRef,
+        snapshotTreeDigest: input.projection.snapshot.treeDigest,
+        snapshotReceiptDigest: input.projection.receiptBytesDigest,
+        bindingBytesDigest: input.projection.bindingBytesDigest,
+        registryRevision: input.registryRevision,
+        closure,
+        agentProofs,
+    }));
+    const receipt = Object.freeze({
+        schemaVersion: "eidolon.holon-execution-binding-freeze/v1",
+        bindingRef: input.projection.binding.bindingRef,
+        snapshotRef: input.projection.binding.snapshotRef,
+        snapshotTreeDigest: input.projection.snapshot.treeDigest,
+        snapshotReceiptDigest: input.projection.receiptBytesDigest,
+        bindingBytesDigest: input.projection.bindingBytesDigest,
+        registryRevision: input.registryRevision,
+        closure,
+        agentProofs,
+        semanticFingerprint,
+    });
+    authenticFreezeReceipts.add(receipt);
+    return receipt;
+}
+export function assertHolonExecutionBindingFreezeReceipt(value) {
+    if (!authenticFreezeReceipts.has(value)) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_FREEZE_RECEIPT_UNTRUSTED", "Holon binding dispatch requires the authentic receipt produced by the shared registry freeze boundary.");
+    }
+    return value;
+}
+function agentRefs(root, byRef) {
+    const refs = new Set();
+    const visited = new Set();
+    const visit = (binding) => {
+        if (visited.has(binding.bindingRef))
+            return;
+        visited.add(binding.bindingRef);
+        if (binding.adapter.kind === "ai-agent")
+            refs.add(binding.adapter.agentDefinitionRef);
+        if (binding.adapter.kind === "hybrid") {
+            for (const candidateRef of binding.adapter.candidateBindingRefs) {
+                const candidate = byRef.get(candidateRef);
+                if (!candidate)
+                    throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_CANDIDATE_MISSING", `Hybrid candidate '${candidateRef}' disappeared before freeze.`);
+                visit(candidate);
+            }
+        }
+    };
+    visit(root);
+    return Object.freeze([...refs].sort(compareUtf16));
+}
+function agentClosureResourceIds(agent) {
+    const ids = new Set([agent.resource.resourceId]);
+    for (const message of agent.messages) {
+        ids.add(message.prompt.resource.resourceId);
+        if (message.schema)
+            ids.add(message.schema.resource.resourceId);
+    }
+    if (agent.inputSchema)
+        ids.add(agent.inputSchema.resource.resourceId);
+    if (agent.outputSchema)
+        ids.add(agent.outputSchema.resource.resourceId);
+    if (agent.effectPolicy)
+        ids.add(agent.effectPolicy.resource.resourceId);
+    for (const tool of agent.tools)
+        ids.add(tool.resource.resourceId);
+    for (const port of agent.materialPorts)
+        ids.add(port.resource.resourceId);
+    return Object.freeze([...ids].sort(compareUtf16));
+}
+function assertCanonicalKindDefinition(input, expected) {
+    const kindDefinition = input.registry.kindDefinitions.get(expected.resourceKind)?.definition;
+    if (!kindDefinition || kindDefinition.resourceId !== expected.fqn) {
+        throw new EidolonResourceRegistryError(expected.code, `Kind '${expected.resourceKind}' must be registered by canonical KindDefinition '${expected.fqn}'.`);
+    }
+    const expectedDigest = sha256Digest(Uint8Array.from(expected.bytes));
+    if (input.kindDefinitionAuthorityDigests.get(expected.resourceKind) !== expectedDigest) {
+        throw new EidolonResourceRegistryError(expected.code, `KindDefinition '${expected.fqn}' bytes do not match the canonical owner bytes.`);
+    }
+}
+function canonicalBase64Property(resource, property) {
+    const value = resource.node.properties[property];
+    if (typeof value !== "string" || value.length === 0 || value !== value.trim()) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_RESOURCE_BYTES_MISSING", `Resource '${resource.resourceId}' requires exact '${property}' base64 bytes.`);
+    }
+    let bytes;
+    try {
+        bytes = Uint8Array.from(Buffer.from(value, "base64"));
+    }
+    catch {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_RESOURCE_BYTES_INVALID", `Resource '${resource.resourceId}' '${property}' is not valid base64.`);
+    }
+    if (bytes.byteLength === 0 || Buffer.from(bytes).toString("base64") !== value) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_RESOURCE_BYTES_INVALID", `Resource '${resource.resourceId}' '${property}' is not canonical base64.`);
+    }
+    return bytes;
+}
+function assertTargetExists(binding, snapshot) {
+    const expectedKind = binding.target.kind === "member" ? "Member" : "Role";
+    const targetRef = binding.target.kind === "member" ? binding.target.memberRef : binding.target.roleRef;
+    if (!snapshot.records.some((record) => record.kind === expectedKind && record.id === targetRef)) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_TARGET_MISSING", `${expectedKind} '${targetRef}' is not present in frozen snapshot '${snapshot.snapshotId}'.`);
+    }
+}
+function resolveBindingClosureResourceIds(root, bindings, registry) {
+    const selected = new Set();
+    const visited = new Set();
+    const add = (ref, expectedKind) => {
+        const id = resourceId(ref);
+        const resource = exactResource(registry, id);
+        if (expectedKind && resource.kind !== expectedKind) {
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_RESOURCE_KIND_MISMATCH", `Resource '${id}' must have kind '${expectedKind}', got '${resource.kind}'.`);
+        }
+        selected.add(id);
+    };
+    const visit = (binding) => {
+        if (visited.has(binding.bindingRef))
+            return;
+        visited.add(binding.bindingRef);
+        add(binding.bindingRef, HOLON_EXECUTION_BINDING_KIND);
+        add(binding.snapshotRef, HOLON_EFFECTIVE_SNAPSHOT_KIND);
+        add(binding.policy.taskProfileRef);
+        for (const ref of binding.policy.capabilityRefs)
+            add(ref);
+        for (const ref of binding.policy.toolRefs)
+            add(ref);
+        for (const ref of binding.policy.materialRefs)
+            add(ref);
+        if (binding.adapter.kind === "ai-agent") {
+            add(binding.adapter.agentDefinitionRef, "AIAgentDefinition");
+            add(binding.adapter.runtimeProfileRef);
+        }
+        else if (binding.adapter.kind === "human-endpoint") {
+            add(binding.adapter.humanEndpointRef);
+            add(binding.adapter.inboxProfileRef);
+        }
+        else if (binding.adapter.kind === "service") {
+            add(binding.adapter.serviceAdapterRef);
+            add(binding.adapter.runtimeProfileRef);
+        }
+        else {
+            add(binding.adapter.policyRef);
+            for (const candidateRef of binding.adapter.candidateBindingRefs) {
+                const candidate = bindings.get(candidateRef);
+                if (!candidate)
+                    throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_CANDIDATE_MISSING", `Hybrid candidate '${candidateRef}' is not present in the admitted registry.`);
+                visit(candidate.binding);
+            }
+        }
+    };
+    visit(root);
+    return Object.freeze([...selected].sort(compareUtf16));
+}
+function exactResource(registry, resourceId) {
+    const resource = registry.byId.get(resourceId)?.resource;
+    if (!resource) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_RESOURCE_MISSING", `Resource '${resourceId}' is not present in the admitted registry.`);
+    }
+    return resource;
+}
+function requiredIdentity(identities, resourceId) {
+    const identity = identities.get(resourceId);
+    if (!identity)
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_CONTENT_IDENTITY_MISSING", `Resource '${resourceId}' has no exact content identity.`);
+    return identity;
+}
+function resourceId(ref) {
+    return ref.slice("resource://".length);
+}
+function resourceRef(resourceId) {
+    return `resource://${resourceId}`;
+}
+function compareUtf16(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function exactSha256(value, path) {
+    if (!/^sha256:[0-9a-f]{64}$/.test(value))
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_DIGEST_INVALID", `Expected one canonical SHA-256 digest at '${path}'.`);
+    return value;
+}

package/dist/WorkbenchProtocol.d.ts

@@ -0,0 +1,12 @@
+/** A path selects a local owner operation, never a network destination. */
+export type OrganizationWorkbenchRequest = {
+    method: "GET" | "POST";
+    path: string;
+    body?: Record<string, unknown>;
+};
+export type OrganizationWorkbenchReply = {
+    status: number;
+    body: unknown;
+};
+export declare function parseOrganizationWorkbenchRequest(value: unknown): OrganizationWorkbenchRequest;
+export declare function parseOrganizationWorkbenchReply(value: unknown): OrganizationWorkbenchReply;

package/dist/WorkbenchProtocol.js

@@ -0,0 +1,102 @@
+function invalid() {
+    throw Object.assign(new Error("Invalid organization workbench request"), {
+        code: "invalid_schema",
+    });
+}
+function jsonValue(value, depth = 0) {
+    if (depth > 64)
+        invalid();
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number" && Number.isFinite(value))
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            jsonValue(item, depth + 1);
+        return;
+    }
+    if (value &&
+        typeof value === "object" &&
+        Object.getPrototypeOf(value) === Object.prototype) {
+        for (const [key, item] of Object.entries(value)) {
+            if (["__proto__", "constructor", "prototype"].includes(key))
+                invalid();
+            jsonValue(item, depth + 1);
+        }
+        return;
+    }
+    invalid();
+}
+export function parseOrganizationWorkbenchRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        invalid();
+    const row = value;
+    if (Object.keys(row).some((key) => !["method", "path", "body"].includes(key)) ||
+        !["GET", "POST"].includes(String(row.method)) ||
+        typeof row.path !== "string" ||
+        row.path.length > 4096 ||
+        !row.path.startsWith("/api/") ||
+        /[\\\u0000-\u001f]/.test(row.path))
+        invalid();
+    const url = new URL(row.path, "http://workbench.local");
+    if (url.origin !== "http://workbench.local" ||
+        url.hash ||
+        url.pathname !== row.path.split("?")[0])
+        invalid();
+    const parts = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
+    if (parts.some((part) => !part || part === "." || part === ".." || part.includes("/")))
+        invalid();
+    if (row.method === "POST") {
+        if (parts.length !== 4 ||
+            parts[0] !== "api" ||
+            parts[1] !== "connections" ||
+            parts[3] !== "invoke" ||
+            [...url.searchParams].length ||
+            !row.body ||
+            typeof row.body !== "object" ||
+            Array.isArray(row.body))
+            invalid();
+    }
+    else {
+        if (row.body !== undefined)
+            invalid();
+        const top = parts.length === 2 && ["health", "connections"].includes(parts[1]);
+        const leaf = parts[1] === "connections" &&
+            parts.length >= 4 &&
+            parts.length <= 6 &&
+            [
+                "state",
+                "history",
+                "xnl",
+                "operations",
+                "issuances",
+                "projection",
+                "objects",
+                "result",
+            ].includes(parts[3]);
+        if (!top && !leaf)
+            invalid();
+        for (const [key] of url.searchParams)
+            if (!["effectiveDate", "observation"].includes(key))
+                invalid();
+    }
+    jsonValue(value);
+    if (new TextEncoder().encode(JSON.stringify(value)).length > 2 * 1024 * 1024)
+        invalid();
+    return value;
+}
+export function parseOrganizationWorkbenchReply(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        invalid();
+    const row = value;
+    if (Object.keys(row).some((key) => !["status", "body"].includes(key)) ||
+        !Number.isInteger(row.status) ||
+        Number(row.status) < 200 ||
+        Number(row.status) > 599 ||
+        !Object.hasOwn(row, "body"))
+        invalid();
+    jsonValue(row.body);
+    if (new TextEncoder().encode(JSON.stringify(value)).length > 16 * 1024 * 1024)
+        invalid();
+    return value;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./HolarchyEidolonAdapterError.js";
+export * from "./HolonDeploymentDefinition.js";
+export * from "./HolonDeploymentRuntime.js";
+export * from "./HolonExecutionBinding.js";
+export * from "./HolonExecutionBindingProjection.js";
+export { parseOrganizationWorkbenchRequest, parseOrganizationWorkbenchReply } from './WorkbenchProtocol.js';
+export type { OrganizationWorkbenchRequest, OrganizationWorkbenchReply } from './WorkbenchProtocol.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./HolarchyEidolonAdapterError.js";
+export * from "./HolonDeploymentDefinition.js";
+export * from "./HolonDeploymentRuntime.js";
+export * from "./HolonExecutionBinding.js";
+export * from "./HolonExecutionBindingProjection.js";
+export { parseOrganizationWorkbenchRequest, parseOrganizationWorkbenchReply } from './WorkbenchProtocol.js';

package/package.json

@@ -1,34 +1,57 @@
 {
   "name": "holarchy-eidolon-adapter",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "private": false,
   "description": "Eidolon ResourcePackage adapter for frozen Holarchy organization snapshots and execution bindings.",
   "type": "module",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "exports": {
-    ".": "./src/index.ts",
-    "./HolonDeploymentDefinition": "./src/HolonDeploymentDefinition.ts",
-    "./HolonDeploymentRuntime": "./src/HolonDeploymentRuntime.ts",
-    "./HolonExecutionBinding": "./src/HolonExecutionBinding.ts",
-    "./HolonExecutionBindingProjection": "./src/HolonExecutionBindingProjection.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./HolonDeploymentDefinition": {
+      "types": "./dist/HolonDeploymentDefinition.d.ts",
+      "import": "./dist/HolonDeploymentDefinition.js"
+    },
+    "./HolonDeploymentRuntime": {
+      "types": "./dist/HolonDeploymentRuntime.d.ts",
+      "import": "./dist/HolonDeploymentRuntime.js"
+    },
+    "./HolonExecutionBinding": {
+      "types": "./dist/HolonExecutionBinding.d.ts",
+      "import": "./dist/HolonExecutionBinding.js"
+    },
+    "./HolonExecutionBindingProjection": {
+      "types": "./dist/HolonExecutionBindingProjection.d.ts",
+      "import": "./dist/HolonExecutionBindingProjection.js"
+    },
+    "./WorkbenchProtocol": {
+      "types": "./dist/WorkbenchProtocol.d.ts",
+      "import": "./dist/WorkbenchProtocol.js"
+    }
   },
   "files": [
-    "src"
+    "dist",
+    "README.md"
   ],
   "scripts": {
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "bun test"
+    "test": "bun test",
+    "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "ai-workflow-contract": "0.1.8",
+    "ai-workflow-contract": "0.2.1",
     "depa-actor": "0.2.2",
-    "halfcode-compiler.xnl": "0.2.2",
-    "holarchy-core-contract": "0.1.1"
+    "halfcode-compiler.xnl": "0.3.2",
+    "holarchy-core-contract": "0.3.0"
   },
   "devDependencies": {
-    "typescript": "^5.4.0"
+    "typescript": "^5.4.0",
+    "@types/node": "^22.0.0"
   },
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "types": "./dist/index.d.ts"
 }

package/src/HolarchyEidolonAdapterError.ts

@@ -1,9 +0,0 @@
-export class HolarchyEidolonAdapterError extends Error {
-  constructor(
-    readonly code: string,
-    message: string,
-  ) {
-    super(`${code}: ${message}`)
-    this.name = "HolarchyEidolonAdapterError"
-  }
-}