@opalesce/core 0.0.0 → 0.1.0

package/dist/interaction/build.js

@@ -0,0 +1,315 @@
+import { InteractionContractError } from "./errors.js";
+import { createSchemaRegistry } from "./schema.js";
+function parserObject(model) {
+    const value = model.json();
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Collect every authored JSON pointer whose value is a `$ref`, using RFC 6901
+// escaping so keys align with parser model pointers. This is provenance only;
+// no parse, resolve, or fetch happens here.
+function collectAuthoredReferences(data) {
+    const index = new Map();
+    const visit = (value, pointer) => {
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => visit(item, `${pointer}/${index}`));
+            return;
+        }
+        if (!isRecord(value)) {
+            return;
+        }
+        const reference = value.$ref;
+        if (typeof reference === "string" && reference.length > 0) {
+            index.set(pointer === "" ? "/" : pointer, reference);
+        }
+        for (const [key, child] of Object.entries(value)) {
+            const escapedKey = key.replaceAll("~", "~0").replaceAll("/", "~1");
+            visit(child, `${pointer === "" ? "" : pointer}/${escapedKey}`);
+        }
+    };
+    visit(data, "");
+    return index;
+}
+function requireVersion(version) {
+    switch (version) {
+        case "2.6.0":
+        case "3.0.0":
+        case "3.1.0":
+            return version;
+        default:
+            throw new InteractionContractError("INTERACTION_VERSION_UNSUPPORTED", `AsyncAPI ${version} is not supported by the interaction contract.`, { pointer: "/asyncapi", details: { version } });
+    }
+}
+function requireName(value, kind, pointer) {
+    if (value !== undefined && value.length > 0) {
+        return value;
+    }
+    throw new InteractionContractError("INTERACTION_IDENTITY_MISSING", `The ${kind} at ${pointer} has no stable identity.`, { pointer, details: { kind } });
+}
+function normalizeAction(action, pointer) {
+    switch (action) {
+        case "publish":
+        case "send":
+            return "send";
+        case "receive":
+        case "subscribe":
+            return "receive";
+        default: {
+            const exhaustive = action;
+            throw new InteractionContractError("INTERACTION_IDENTITY_MISSING", `The operation at ${pointer} has an unsupported action.`, { pointer, details: { action: exhaustive } });
+        }
+    }
+}
+function uniqueSorted(values) {
+    return Object.freeze([...new Set(values)].sort((left, right) => left.localeCompare(right)));
+}
+function messageBaseName(message, pointer) {
+    const id = message.id();
+    if (typeof id === "string" && id.length > 0) {
+        return id;
+    }
+    const name = message.name();
+    if (name !== undefined && name.length > 0) {
+        return name;
+    }
+    return pointer;
+}
+function registerMessage(registry, message, identity, name, asyncapiVersion, createSchemaRole, ownerIdentity) {
+    const existing = registry.messages.get(identity);
+    if (existing !== undefined) {
+        return existing.identity;
+    }
+    const pointer = message.meta("pointer");
+    const payload = message.payload();
+    const headers = message.headers();
+    const description = message.description();
+    const contract = Object.freeze({
+        identity,
+        kind: "message",
+        name,
+        pointer,
+        asyncapiVersion,
+        ...(ownerIdentity === undefined ? {} : { ownerIdentity }),
+        ...(description === undefined ? {} : { description }),
+        ...(payload === undefined ? {} : { payload: createSchemaRole(payload) }),
+        ...(headers === undefined ? {} : { headers: createSchemaRole(headers) }),
+    });
+    registry.messages.set(identity, contract);
+    registry.identityByPointer.set(pointer, identity);
+    const object = parserObject(message);
+    if (object !== undefined) {
+        registry.identityByObject.set(object, identity);
+    }
+    return identity;
+}
+function existingMessageIdentity(registry, message) {
+    const object = parserObject(message);
+    if (object !== undefined) {
+        const identity = registry.identityByObject.get(object);
+        if (identity !== undefined) {
+            return identity;
+        }
+    }
+    return registry.identityByPointer.get(message.meta("pointer"));
+}
+function channelIdentity(channel) {
+    const pointer = channel.meta("pointer");
+    return `channel:${requireName(channel.id(), "channel", pointer)}`;
+}
+function authoredOperationId(operation) {
+    const value = operation.json();
+    if (typeof value === "object" &&
+        value !== null &&
+        "operationId" in value &&
+        typeof value.operationId === "string" &&
+        value.operationId.length > 0) {
+        return value.operationId;
+    }
+    return undefined;
+}
+function operationIdentityAndName(operation, operationChannelIdentity, asyncapiVersion) {
+    const pointer = operation.meta("pointer");
+    // AsyncAPI 2.6 without an authored operationId falls back to the parser action
+    // value such as "publish" or "subscribe", which collides across channels. Derive
+    // a collision-free identity from the exact channel identity plus authored role.
+    if (asyncapiVersion === "2.6.0" && authoredOperationId(operation) === undefined) {
+        const channel = operation.channels().all()[0];
+        if (channel !== undefined) {
+            const role = operation.action();
+            return {
+                identity: `operation:${operationChannelIdentity}:${role}`,
+                name: `${requireName(channel.id(), "operation channel", pointer)}-${role}`,
+            };
+        }
+    }
+    const name = operationName(operation);
+    return { identity: `operation:${name}`, name };
+}
+function operationName(operation) {
+    const id = operation.id();
+    if (typeof id === "string" && id.length > 0) {
+        return id;
+    }
+    const pointer = operation.meta("pointer");
+    return requireName(undefined, "operation", pointer);
+}
+function authoredSourceData(document, source) {
+    if (source !== undefined) {
+        return source.data;
+    }
+    const metadata = document.meta("asyncapi");
+    const input = metadata?.input;
+    return isRecord(input) || Array.isArray(input) ? input : undefined;
+}
+export function buildInteractionContract(document, source) {
+    const asyncapiVersion = requireVersion(document.version());
+    const authoredData = authoredSourceData(document, source);
+    const authoredReferences = collectAuthoredReferences(authoredData);
+    const schemaRegistry = createSchemaRegistry(document.components().schemas().all(), asyncapiVersion, authoredReferences);
+    const messageRegistry = {
+        messages: new Map(),
+        identityByObject: new WeakMap(),
+        identityByPointer: new Map(),
+    };
+    for (const message of document.components().messages().all()) {
+        const pointer = message.meta("pointer");
+        const name = requireName(message.id(), "component message", pointer);
+        registerMessage(messageRegistry, message, `message:component:${name}`, name, asyncapiVersion, schemaRegistry.createRole, undefined);
+    }
+    const channelIdentityByObject = new WeakMap();
+    const channelIdentityById = new Map();
+    const channels = [];
+    for (const channel of document.channels().all()) {
+        const identity = channelIdentity(channel);
+        const name = requireName(channel.id(), "channel", channel.meta("pointer"));
+        const object = parserObject(channel);
+        if (object !== undefined) {
+            channelIdentityByObject.set(object, identity);
+        }
+        channelIdentityById.set(name, identity);
+        const messageIdentities = channel
+            .messages()
+            .all()
+            .map((message) => {
+            const existing = existingMessageIdentity(messageRegistry, message);
+            if (existing !== undefined) {
+                return existing;
+            }
+            const pointer = message.meta("pointer");
+            return registerMessage(messageRegistry, message, `message:${identity}:${pointer}`, messageBaseName(message, pointer), asyncapiVersion, schemaRegistry.createRole, identity);
+        });
+        const parameters = channel
+            .parameters()
+            .all()
+            .map((parameter) => {
+            const schema = parameter.schema();
+            const description = parameter.description();
+            const location = parameter.location();
+            return Object.freeze({
+                name: requireName(parameter.id(), "channel parameter", parameter.meta("pointer")),
+                pointer: parameter.meta("pointer"),
+                ...(description === undefined ? {} : { description }),
+                ...(location === undefined ? {} : { location }),
+                ...(schema === undefined ? {} : { schema: schemaRegistry.createRole(schema) }),
+            });
+        });
+        const address = channel.address();
+        const description = channel.description();
+        channels.push(Object.freeze({
+            identity,
+            kind: "channel",
+            name,
+            pointer: channel.meta("pointer"),
+            asyncapiVersion,
+            ...(address === undefined ? {} : { address }),
+            ...(description === undefined ? {} : { description }),
+            parameters: Object.freeze([...parameters].sort((left, right) => left.name.localeCompare(right.name))),
+            messageIdentities: uniqueSorted(messageIdentities),
+        }));
+    }
+    const resolveChannelIdentity = (channel) => {
+        const object = parserObject(channel);
+        if (object !== undefined) {
+            const byObject = channelIdentityByObject.get(object);
+            if (byObject !== undefined) {
+                return byObject;
+            }
+        }
+        const byId = channelIdentityById.get(channel.id());
+        if (byId !== undefined) {
+            return byId;
+        }
+        throw new InteractionContractError("INTERACTION_REFERENCE_UNSUPPORTED", `The channel reference at ${channel.meta("pointer")} has no stable target.`, { pointer: channel.meta("pointer"), details: { referenceKind: "channel" } });
+    };
+    const resolveMessageIdentity = (message, ownerIdentity) => {
+        const existing = existingMessageIdentity(messageRegistry, message);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const pointer = message.meta("pointer");
+        return registerMessage(messageRegistry, message, `message:${ownerIdentity}:${pointer}`, messageBaseName(message, pointer), asyncapiVersion, schemaRegistry.createRole, ownerIdentity);
+    };
+    const operations = [];
+    const replies = [];
+    for (const operation of document.operations().all()) {
+        const pointer = operation.meta("pointer");
+        const channel = operation.channels().all()[0];
+        if (channel === undefined) {
+            throw new InteractionContractError("INTERACTION_REFERENCE_UNSUPPORTED", `The operation at ${pointer} has no resolved channel.`, { pointer, details: { referenceKind: "channel" } });
+        }
+        const operationChannelIdentity = resolveChannelIdentity(channel);
+        const { identity, name } = operationIdentityAndName(operation, operationChannelIdentity, asyncapiVersion);
+        const messageIdentities = uniqueSorted(operation
+            .messages()
+            .all()
+            .map((message) => resolveMessageIdentity(message, operationChannelIdentity)));
+        const reply = operation.reply();
+        let replyIdentity;
+        if (reply !== undefined) {
+            replyIdentity = `reply:${identity}`;
+            const replyChannel = reply.channel();
+            const resolvedReplyChannelIdentity = replyChannel === undefined ? undefined : resolveChannelIdentity(replyChannel);
+            const explicitMessages = reply.messages().all();
+            const effectiveMessages = explicitMessages.length > 0
+                ? explicitMessages
+                : (replyChannel?.messages().all() ?? explicitMessages);
+            replies.push(Object.freeze({
+                identity: replyIdentity,
+                kind: "reply",
+                name: `${name}-reply`,
+                pointer: reply.meta("pointer"),
+                asyncapiVersion,
+                operationIdentity: identity,
+                ...(resolvedReplyChannelIdentity === undefined
+                    ? {}
+                    : { channelIdentity: resolvedReplyChannelIdentity }),
+                messageIdentities: uniqueSorted(effectiveMessages.map((message) => resolveMessageIdentity(message, replyIdentity ?? identity))),
+            }));
+        }
+        const description = operation.description();
+        const summary = operation.summary();
+        operations.push(Object.freeze({
+            identity,
+            kind: "operation",
+            name,
+            pointer,
+            asyncapiVersion,
+            action: normalizeAction(operation.action(), pointer),
+            channelIdentity: operationChannelIdentity,
+            messageIdentities,
+            ...(replyIdentity === undefined ? {} : { replyIdentity }),
+            ...(description === undefined ? {} : { description }),
+            ...(summary === undefined ? {} : { summary }),
+        }));
+    }
+    return Object.freeze({
+        asyncapiVersion,
+        schemas: schemaRegistry.roots,
+        messages: Object.freeze([...messageRegistry.messages.values()].sort((left, right) => left.identity.localeCompare(right.identity))),
+        channels: Object.freeze(channels.sort((left, right) => left.identity.localeCompare(right.identity))),
+        operations: Object.freeze(operations.sort((left, right) => left.identity.localeCompare(right.identity))),
+        replies: Object.freeze(replies.sort((left, right) => left.identity.localeCompare(right.identity))),
+    });
+}

package/dist/interaction/errors.d.ts

@@ -0,0 +1,12 @@
+export type InteractionContractErrorCode = "INTERACTION_IDENTITY_MISSING" | "INTERACTION_REFERENCE_UNSUPPORTED" | "INTERACTION_VERSION_UNSUPPORTED";
+export interface InteractionContractErrorOptions {
+    readonly pointer: string;
+    readonly details?: Readonly<Record<string, string>>;
+}
+export declare class InteractionContractError extends Error {
+    readonly code: InteractionContractErrorCode;
+    readonly pointer: string;
+    readonly details: Readonly<Record<string, string>>;
+    constructor(code: InteractionContractErrorCode, message: string, options: InteractionContractErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/interaction/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/interaction/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GACpC,8BAA8B,GAC9B,mCAAmC,GACnC,iCAAiC,CAAC;AAEtC,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACrD;AAED,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;gBAGjD,IAAI,EAAE,4BAA4B,EAClC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,+BAA+B;CAQ3C"}

package/dist/interaction/errors.js

@@ -0,0 +1,12 @@
+export class InteractionContractError extends Error {
+    code;
+    pointer;
+    details;
+    constructor(code, message, options) {
+        super(message);
+        this.name = "InteractionContractError";
+        this.code = code;
+        this.pointer = options.pointer;
+        this.details = Object.freeze({ ...options.details });
+    }
+}

package/dist/interaction/schema.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaInterface } from "@asyncapi/parser";
+import type { InteractionAsyncAPIVersion, SchemaContract, SchemaRoleContract } from "./types.js";
+export interface SchemaRegistry {
+    readonly roots: readonly SchemaContract[];
+    createRole(schema: SchemaInterface): SchemaRoleContract;
+}
+export type AuthoredReferenceIndex = ReadonlyMap<string, string>;
+export declare function createSchemaRegistry(schemas: readonly SchemaInterface[], asyncapiVersion: InteractionAsyncAPIVersion, authoredReferences?: AuthoredReferenceIndex): SchemaRegistry;
+//# sourceMappingURL=schema.d.ts.map

package/dist/interaction/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/interaction/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EACV,0BAA0B,EAC1B,cAAc,EAEd,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAOpB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,kBAAkB,CAAC;CACzD;AAED,MAAM,MAAM,sBAAsB,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AA6FjE,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,eAAe,EAAE,0BAA0B,EAC3C,kBAAkB,GAAE,sBAAkC,GACrD,cAAc,CA2HhB"}

package/dist/interaction/schema.js

@@ -0,0 +1,178 @@
+import { InteractionContractError } from "./errors.js";
+function isExternalReference(reference) {
+    return !reference.startsWith("#");
+}
+function parserObject(schema) {
+    const value = schema.json();
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+function effectiveSchemaFormat(schema) {
+    const value = schema.json();
+    if (typeof value === "object" &&
+        value !== null &&
+        "schemaFormat" in value &&
+        typeof value.schemaFormat === "string") {
+        return value.schemaFormat;
+    }
+    return schema.schemaFormat();
+}
+function schemaChildren(schema) {
+    const children = [];
+    const append = (candidate) => {
+        if (candidate !== undefined) {
+            children.push(candidate);
+        }
+    };
+    const appendMany = (candidates) => {
+        if (candidates !== undefined) {
+            children.push(...candidates);
+        }
+    };
+    appendMany(schema.allOf());
+    appendMany(schema.anyOf());
+    appendMany(schema.oneOf());
+    append(schema.not());
+    append(schema.if());
+    append(schema.then());
+    append(schema.else());
+    append(schema.contains());
+    append(schema.propertyNames());
+    const items = schema.items();
+    if (Array.isArray(items)) {
+        appendMany(items);
+    }
+    else {
+        append(items);
+    }
+    const additionalItems = schema.additionalItems();
+    if (typeof additionalItems !== "boolean") {
+        append(additionalItems);
+    }
+    const additionalProperties = schema.additionalProperties();
+    if (typeof additionalProperties !== "boolean") {
+        append(additionalProperties);
+    }
+    const propertyGroups = [schema.properties(), schema.patternProperties(), schema.definitions()];
+    for (const group of propertyGroups) {
+        if (group !== undefined) {
+            children.push(...Object.values(group));
+        }
+    }
+    const dependencies = schema.dependencies();
+    if (dependencies !== undefined) {
+        for (const dependency of Object.values(dependencies)) {
+            if (!Array.isArray(dependency)) {
+                children.push(dependency);
+            }
+        }
+    }
+    return children;
+}
+function sortDependencies(dependencies) {
+    return Object.freeze([...dependencies.values()]
+        .sort((left, right) => left.targetIdentity.localeCompare(right.targetIdentity))
+        .map((dependency) => Object.freeze(dependency)));
+}
+export function createSchemaRegistry(schemas, asyncapiVersion, authoredReferences = new Map()) {
+    const identityByObject = new WeakMap();
+    const identityBySchemaId = new Map();
+    for (const schema of schemas) {
+        const name = schema.id();
+        const identity = `schema:component:${name}`;
+        const entry = Object.freeze({ identity, pointer: schema.meta("pointer") });
+        const object = parserObject(schema);
+        if (object !== undefined) {
+            identityByObject.set(object, entry);
+        }
+        identityBySchemaId.set(name, entry);
+    }
+    const findComponent = (schema) => {
+        const object = parserObject(schema);
+        if (object !== undefined) {
+            const byObject = identityByObject.get(object);
+            if (byObject !== undefined) {
+                return byObject;
+            }
+        }
+        return identityBySchemaId.get(schema.id());
+    };
+    // #17: fail closed when authored provenance proves this schema role originated
+    // from an external $ref and the resolved model maps to no stable component or
+    // owner-scoped local identity. Uses the already-retained pointer/URI only.
+    const assertProvenance = (schema, pointer) => {
+        const authoredReference = authoredReferences.get(pointer);
+        if (authoredReference === undefined || !isExternalReference(authoredReference)) {
+            return;
+        }
+        const target = findComponent(schema);
+        if (target === undefined) {
+            throw new InteractionContractError("INTERACTION_REFERENCE_UNSUPPORTED", `The schema reference at ${pointer} resolves to an unrepresentable external target.`, { pointer, details: { referenceKind: "schema", reference: authoredReference } });
+        }
+    };
+    const collectDependencies = (root) => {
+        const dependencies = new Map();
+        const visitedObjects = new WeakSet();
+        const visitedSchemas = new WeakSet();
+        const visit = (schema) => {
+            const object = parserObject(schema);
+            if (object === undefined) {
+                if (visitedSchemas.has(schema)) {
+                    return;
+                }
+                visitedSchemas.add(schema);
+            }
+            else {
+                if (visitedObjects.has(object)) {
+                    const target = findComponent(schema);
+                    if (target !== undefined && !dependencies.has(target.identity)) {
+                        dependencies.set(target.identity, Object.freeze({
+                            targetIdentity: target.identity,
+                            pointer: schema.meta("pointer"),
+                        }));
+                    }
+                    return;
+                }
+                visitedObjects.add(object);
+            }
+            for (const child of schemaChildren(schema)) {
+                const target = findComponent(child);
+                if (target !== undefined && !dependencies.has(target.identity)) {
+                    dependencies.set(target.identity, Object.freeze({
+                        targetIdentity: target.identity,
+                        pointer: child.meta("pointer"),
+                    }));
+                }
+                visit(child);
+            }
+        };
+        visit(root);
+        return sortDependencies(dependencies);
+    };
+    const createRole = (schema) => {
+        const pointer = schema.meta("pointer");
+        assertProvenance(schema, pointer);
+        return Object.freeze({
+            pointer,
+            schemaFormat: effectiveSchemaFormat(schema),
+            schema,
+            dependencies: collectDependencies(schema),
+        });
+    };
+    const roots = Object.freeze([...schemas]
+        .map((schema) => {
+        const name = schema.id();
+        const role = createRole(schema);
+        return Object.freeze({
+            identity: `schema:component:${name}`,
+            kind: "schema",
+            name,
+            pointer: role.pointer,
+            asyncapiVersion,
+            schemaFormat: role.schemaFormat,
+            schema: role.schema,
+            dependencies: role.dependencies,
+        });
+    })
+        .sort((left, right) => left.identity.localeCompare(right.identity)));
+    return Object.freeze({ roots, createRole });
+}

package/dist/interaction/types.d.ts

@@ -0,0 +1,69 @@
+import type { SchemaInterface } from "@asyncapi/parser";
+export type InteractionAsyncAPIVersion = "2.6.0" | "3.0.0" | "3.1.0";
+export type InteractionAction = "send" | "receive";
+export type InteractionRootKind = "schema" | "message" | "channel" | "operation" | "reply";
+export interface InteractionRootMetadata {
+    readonly identity: string;
+    readonly kind: InteractionRootKind;
+    readonly name: string;
+    readonly pointer: string;
+    readonly asyncapiVersion: InteractionAsyncAPIVersion;
+}
+export interface SchemaDependencyContract {
+    readonly targetIdentity: string;
+    readonly pointer: string;
+}
+export interface SchemaRoleContract {
+    readonly pointer: string;
+    readonly schemaFormat: string;
+    readonly schema: SchemaInterface;
+    readonly dependencies: readonly SchemaDependencyContract[];
+}
+export interface SchemaContract extends InteractionRootMetadata, SchemaRoleContract {
+    readonly kind: "schema";
+}
+export interface MessageContract extends InteractionRootMetadata {
+    readonly kind: "message";
+    readonly ownerIdentity?: string;
+    readonly description?: string;
+    readonly payload?: SchemaRoleContract;
+    readonly headers?: SchemaRoleContract;
+}
+export interface ChannelParameterContract {
+    readonly name: string;
+    readonly pointer: string;
+    readonly description?: string;
+    readonly location?: string;
+    readonly schema?: SchemaRoleContract;
+}
+export interface ChannelContract extends InteractionRootMetadata {
+    readonly kind: "channel";
+    readonly address?: string | null;
+    readonly description?: string;
+    readonly parameters: readonly ChannelParameterContract[];
+    readonly messageIdentities: readonly string[];
+}
+export interface ReplyContract extends InteractionRootMetadata {
+    readonly kind: "reply";
+    readonly operationIdentity: string;
+    readonly channelIdentity?: string;
+    readonly messageIdentities: readonly string[];
+}
+export interface OperationContract extends InteractionRootMetadata {
+    readonly kind: "operation";
+    readonly action: InteractionAction;
+    readonly description?: string;
+    readonly summary?: string;
+    readonly channelIdentity: string;
+    readonly messageIdentities: readonly string[];
+    readonly replyIdentity?: string;
+}
+export interface InteractionContract {
+    readonly asyncapiVersion: InteractionAsyncAPIVersion;
+    readonly schemas: readonly SchemaContract[];
+    readonly messages: readonly MessageContract[];
+    readonly channels: readonly ChannelContract[];
+    readonly operations: readonly OperationContract[];
+    readonly replies: readonly ReplyContract[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/interaction/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/interaction/types.ts"],"names":[],"mappings":"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"}

package/dist/interaction/types.js

@@ -0,0 +1 @@
+export {};

package/dist/orchestrator/artifacts.d.ts

@@ -2,7 +2,7 @@ import type { GeneratedArtifact } from "./types.js";
 export declare class ArtifactStore {
     private readonly artifacts;
     private readonly paths;
-    emit(artifact: GeneratedArtifact): void;
+    add(artifact: GeneratedArtifact): void;
     snapshot(): readonly GeneratedArtifact[];
 }
 //# sourceMappingURL=artifacts.d.ts.map

package/dist/orchestrator/artifacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/orchestrator/artifacts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAkBpD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IACrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAE3C,IAAI,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAkBvC,QAAQ,IAAI,SAAS,iBAAiB,EAAE;CAGzC"}
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/orchestrator/artifacts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAkBpD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IACrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAE3C,GAAG,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAkBtC,QAAQ,IAAI,SAAS,iBAAiB,EAAE;CAGzC"}

package/dist/orchestrator/artifacts.js

@@ -14,7 +14,7 @@ function isCanonicalArtifactPath(path) {
 export class ArtifactStore {
     artifacts = [];
     paths = new Set();
-    emit(artifact) {
+    add(artifact) {
         if (!isCanonicalArtifactPath(artifact.path)) {
             throw new ArtifactError("invalid-path", artifact.path);
         }

package/dist/orchestrator/errors.d.ts

@@ -1,18 +1,3 @@
-import type { PluginExecutionPhase } from "./types.js";
-export type PluginConfigurationErrorCode = "empty-name" | "duplicate-name" | "missing-dependency" | "dependency-cycle";
-export declare class PluginConfigurationError extends Error {
-    readonly name = "PluginConfigurationError";
-    readonly code: PluginConfigurationErrorCode;
-    readonly pluginNames: readonly string[];
-    constructor(code: PluginConfigurationErrorCode, message: string, pluginNames?: readonly string[]);
-}
-export type ServiceRegistryErrorCode = "duplicate-service" | "missing-service";
-export declare class ServiceRegistryError extends Error {
-    readonly name = "ServiceRegistryError";
-    readonly code: ServiceRegistryErrorCode;
-    readonly serviceName: string;
-    constructor(code: ServiceRegistryErrorCode, serviceName: string);
-}
 export type ArtifactErrorCode = "invalid-path" | "path-collision";
 export declare class ArtifactError extends Error {
     readonly name = "ArtifactError";
@@ -23,7 +8,6 @@ export declare class ArtifactError extends Error {
 export declare class PluginExecutionError extends Error {
     readonly name = "PluginExecutionError";
     readonly pluginName: string;
-    readonly phase: PluginExecutionPhase;
-    constructor(pluginName: string, phase: PluginExecutionPhase, cause: unknown);
+    constructor(pluginName: string, cause: unknown);
 }
 //# sourceMappingURL=errors.d.ts.map