@credo-ts/askar-to-drizzle-storage-migration 0.6.0-alpha-20251010154241 → 0.6.0-alpha-20251010164336

package/build/packages/didcomm/src/DidCommEvents.js

@@ -0,0 +1,11 @@
+
+//#region ../didcomm/src/DidCommEvents.ts
+let DidCommEventTypes = /* @__PURE__ */ function(DidCommEventTypes$1) {
+	DidCommEventTypes$1["DidCommMessageReceived"] = "DidCommMessageReceived";
+	DidCommEventTypes$1["DidCommMessageProcessed"] = "DidCommMessageProcessed";
+	DidCommEventTypes$1["DidCommMessageSent"] = "DidCommMessageSent";
+	return DidCommEventTypes$1;
+}({});
+
+//#endregion
+exports.DidCommEventTypes = DidCommEventTypes;

package/build/packages/didcomm/src/DidCommEvents.mjs

@@ -0,0 +1,11 @@
+//#region ../didcomm/src/DidCommEvents.ts
+let DidCommEventTypes = /* @__PURE__ */ function(DidCommEventTypes$1) {
+	DidCommEventTypes$1["DidCommMessageReceived"] = "DidCommMessageReceived";
+	DidCommEventTypes$1["DidCommMessageProcessed"] = "DidCommMessageProcessed";
+	DidCommEventTypes$1["DidCommMessageSent"] = "DidCommMessageSent";
+	return DidCommEventTypes$1;
+}({});
+
+//#endregion
+export { DidCommEventTypes };
+//# sourceMappingURL=DidCommEvents.mjs.map

package/build/packages/didcomm/src/DidCommEvents.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DidCommEvents.mjs","names":[],"sources":["../../../../../didcomm/src/DidCommEvents.ts"],"sourcesContent":["import type { BaseEvent } from '@credo-ts/core'\nimport type { DidCommMessage } from './DidCommMessage'\nimport type { DidCommTransportSession } from './DidCommTransportService'\nimport type { DidCommOutboundMessageContext, OutboundMessageSendStatus } from './models'\nimport type { DidCommConnectionRecord } from './modules/connections/repository'\nimport type { DidCommEncryptedMessage } from './types'\n\nexport enum DidCommEventTypes {\n  DidCommMessageReceived = 'DidCommMessageReceived',\n  DidCommMessageProcessed = 'DidCommMessageProcessed',\n  DidCommMessageSent = 'DidCommMessageSent',\n}\n\nexport interface DidCommMessageReceivedEvent extends BaseEvent {\n  type: typeof DidCommEventTypes.DidCommMessageReceived\n  payload: {\n    message: unknown\n    connection?: DidCommConnectionRecord\n    contextCorrelationId?: string\n    receivedAt?: Date\n    session?: DidCommTransportSession\n  }\n}\n\nexport interface DidCommMessageProcessedEvent extends BaseEvent {\n  type: typeof DidCommEventTypes.DidCommMessageProcessed\n  payload: {\n    message: DidCommMessage\n    connection?: DidCommConnectionRecord\n    receivedAt?: Date\n    encryptedMessage?: DidCommEncryptedMessage\n  }\n}\n\nexport interface DidCommMessageSentEvent extends BaseEvent {\n  type: typeof DidCommEventTypes.DidCommMessageSent\n  payload: {\n    message: DidCommOutboundMessageContext\n    status: OutboundMessageSendStatus\n  }\n}\n"],"mappings":";AAOA,IAAY,kEAAL;AACL;AACA;AACA"}

package/build/packages/didcomm/src/DidCommFeatureRegistry.js

@@ -0,0 +1,53 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_decorate = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.js');
+let __credo_ts_core = require("@credo-ts/core");
+__credo_ts_core = require_rolldown_runtime.__toESM(__credo_ts_core);
+
+//#region ../didcomm/src/DidCommFeatureRegistry.ts
+let DidCommFeatureRegistry = class DidCommFeatureRegistry$1 {
+	constructor() {
+		this.features = [];
+	}
+	/**
+	* Register a single or set of Features on the registry
+	*
+	* @param features set of {Feature} objects or any inherited class
+	*/
+	register(...features) {
+		for (const feature of features) {
+			const index = this.features.findIndex((item) => item.type === feature.type && item.id === feature.id);
+			if (index > -1) this.features[index] = this.features[index].combine(feature);
+			else this.features.push(feature);
+		}
+	}
+	/**
+	* Perform a set of queries in the registry, supporting wildcards (*) as
+	* expressed in Aries RFC 0557.
+	*
+	* @see https://github.com/hyperledger/aries-rfcs/blob/560ffd23361f16a01e34ccb7dcc908ec28c5ddb1/features/0557-discover-features-v2/README.md
+	*
+	* @param queries set of {FeatureQuery} objects to query features
+	* @returns array containing all matching features (can be empty)
+	*/
+	query(...queries) {
+		const output = [];
+		for (const query of queries) {
+			const items = this.features.filter((item) => item.type === query.featureType);
+			if (query.match === "*") output.push(...items);
+			else if (query.match.endsWith("*")) {
+				const match = query.match.slice(0, -1);
+				output.push(...items.filter((m) => m.id.startsWith(match)));
+			} else output.push(...items.filter((m) => m.id === query.match));
+		}
+		return output;
+	}
+};
+DidCommFeatureRegistry = require_decorate.__decorate([(0, __credo_ts_core.injectable)()], DidCommFeatureRegistry);
+
+//#endregion
+Object.defineProperty(exports, 'DidCommFeatureRegistry', {
+  enumerable: true,
+  get: function () {
+    return DidCommFeatureRegistry;
+  }
+});

package/build/packages/didcomm/src/DidCommFeatureRegistry.mjs

@@ -0,0 +1,47 @@
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.mjs";
+import { injectable } from "@credo-ts/core";
+
+//#region ../didcomm/src/DidCommFeatureRegistry.ts
+let DidCommFeatureRegistry = class DidCommFeatureRegistry$1 {
+	constructor() {
+		this.features = [];
+	}
+	/**
+	* Register a single or set of Features on the registry
+	*
+	* @param features set of {Feature} objects or any inherited class
+	*/
+	register(...features) {
+		for (const feature of features) {
+			const index = this.features.findIndex((item) => item.type === feature.type && item.id === feature.id);
+			if (index > -1) this.features[index] = this.features[index].combine(feature);
+			else this.features.push(feature);
+		}
+	}
+	/**
+	* Perform a set of queries in the registry, supporting wildcards (*) as
+	* expressed in Aries RFC 0557.
+	*
+	* @see https://github.com/hyperledger/aries-rfcs/blob/560ffd23361f16a01e34ccb7dcc908ec28c5ddb1/features/0557-discover-features-v2/README.md
+	*
+	* @param queries set of {FeatureQuery} objects to query features
+	* @returns array containing all matching features (can be empty)
+	*/
+	query(...queries) {
+		const output = [];
+		for (const query of queries) {
+			const items = this.features.filter((item) => item.type === query.featureType);
+			if (query.match === "*") output.push(...items);
+			else if (query.match.endsWith("*")) {
+				const match = query.match.slice(0, -1);
+				output.push(...items.filter((m) => m.id.startsWith(match)));
+			} else output.push(...items.filter((m) => m.id === query.match));
+		}
+		return output;
+	}
+};
+DidCommFeatureRegistry = __decorate([injectable()], DidCommFeatureRegistry);
+
+//#endregion
+export { DidCommFeatureRegistry };
+//# sourceMappingURL=DidCommFeatureRegistry.mjs.map

package/build/packages/didcomm/src/DidCommFeatureRegistry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DidCommFeatureRegistry.mjs","names":["DidCommFeatureRegistry"],"sources":["../../../../../didcomm/src/DidCommFeatureRegistry.ts"],"sourcesContent":["import type { DidCommFeature, DidCommFeatureQuery } from './models'\n\nimport { injectable } from '@credo-ts/core'\n\n@injectable()\nexport class DidCommFeatureRegistry {\n  private features: DidCommFeature[] = []\n\n  /**\n   * Register a single or set of Features on the registry\n   *\n   * @param features set of {Feature} objects or any inherited class\n   */\n  public register(...features: DidCommFeature[]) {\n    for (const feature of features) {\n      const index = this.features.findIndex((item) => item.type === feature.type && item.id === feature.id)\n\n      if (index > -1) {\n        this.features[index] = this.features[index].combine(feature)\n      } else {\n        this.features.push(feature)\n      }\n    }\n  }\n\n  /**\n   * Perform a set of queries in the registry, supporting wildcards (*) as\n   * expressed in Aries RFC 0557.\n   *\n   * @see https://github.com/hyperledger/aries-rfcs/blob/560ffd23361f16a01e34ccb7dcc908ec28c5ddb1/features/0557-discover-features-v2/README.md\n   *\n   * @param queries set of {FeatureQuery} objects to query features\n   * @returns array containing all matching features (can be empty)\n   */\n  public query(...queries: DidCommFeatureQuery[]) {\n    const output = []\n    for (const query of queries) {\n      const items = this.features.filter((item) => item.type === query.featureType)\n      // An * will return all features of a given type (e.g. all protocols, all goal codes, all AIP configs)\n      if (query.match === '*') {\n        output.push(...items)\n        // An string ending with * will return a family of features of a certain type\n        // (e.g. all versions of a given protocol, all subsets of an AIP, etc.)\n      } else if (query.match.endsWith('*')) {\n        const match = query.match.slice(0, -1)\n        output.push(...items.filter((m) => m.id.startsWith(match)))\n        // Exact matching (single feature)\n      } else {\n        output.push(...items.filter((m) => m.id === query.match))\n      }\n    }\n    return output\n  }\n}\n"],"mappings":";;;;AAKO,mCAAMA,yBAAuB;;OAC1B,WAA6B,EAAE;;;;;;;CAOvC,AAAO,SAAS,GAAG,UAA4B;AAC7C,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,QAAQ,KAAK,SAAS,WAAW,SAAS,KAAK,SAAS,QAAQ,QAAQ,KAAK,OAAO,QAAQ,GAAG;AAErG,OAAI,QAAQ,GACV,MAAK,SAAS,SAAS,KAAK,SAAS,OAAO,QAAQ,QAAQ;OAE5D,MAAK,SAAS,KAAK,QAAQ;;;;;;;;;;;;CAcjC,AAAO,MAAM,GAAG,SAAgC;EAC9C,MAAM,SAAS,EAAE;AACjB,OAAK,MAAM,SAAS,SAAS;GAC3B,MAAM,QAAQ,KAAK,SAAS,QAAQ,SAAS,KAAK,SAAS,MAAM,YAAY;AAE7E,OAAI,MAAM,UAAU,IAClB,QAAO,KAAK,GAAG,MAAM;YAGZ,MAAM,MAAM,SAAS,IAAI,EAAE;IACpC,MAAM,QAAQ,MAAM,MAAM,MAAM,GAAG,GAAG;AACtC,WAAO,KAAK,GAAG,MAAM,QAAQ,MAAM,EAAE,GAAG,WAAW,MAAM,CAAC,CAAC;SAG3D,QAAO,KAAK,GAAG,MAAM,QAAQ,MAAM,EAAE,OAAO,MAAM,MAAM,CAAC;;AAG7D,SAAO;;;qCA/CV,YAAY"}

package/build/packages/didcomm/src/DidCommMessage.js

@@ -0,0 +1,39 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_index = require('../../../node_modules/.pnpm/class-transformer@0.5.1/node_modules/class-transformer/cjs/index.js');
+const require_decorateMetadata = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorateMetadata.js');
+const require_decorate = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.js');
+const require_BaseDidCommMessage = require('./BaseDidCommMessage.js');
+const require_AckDecoratorExtension = require('./decorators/ack/AckDecoratorExtension.js');
+const require_AttachmentExtension = require('./decorators/attachment/AttachmentExtension.js');
+const require_L10nDecoratorExtension = require('./decorators/l10n/L10nDecoratorExtension.js');
+const require_ServiceDecoratorExtension = require('./decorators/service/ServiceDecoratorExtension.js');
+const require_ThreadDecoratorExtension = require('./decorators/thread/ThreadDecoratorExtension.js');
+const require_TimingDecoratorExtension = require('./decorators/timing/TimingDecoratorExtension.js');
+const require_TransportDecoratorExtension = require('./decorators/transport/TransportDecoratorExtension.js');
+const require_messageType = require('./util/messageType.js');
+let __credo_ts_core = require("@credo-ts/core");
+__credo_ts_core = require_rolldown_runtime.__toESM(__credo_ts_core);
+
+//#region ../didcomm/src/DidCommMessage.ts
+var import_cjs = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_index.require_cjs());
+const Decorated = require_ThreadDecoratorExtension.ThreadDecorated(require_L10nDecoratorExtension.L10nDecorated(require_TransportDecoratorExtension.TransportDecorated(require_TimingDecoratorExtension.TimingDecorated(require_AckDecoratorExtension.AckDecorated(require_AttachmentExtension.AttachmentDecorated(require_ServiceDecoratorExtension.ServiceDecorated(require_BaseDidCommMessage.BaseDidCommMessage)))))));
+var DidCommMessage = class extends Decorated {
+	constructor(..._args) {
+		super(..._args);
+		this.allowDidSovPrefix = false;
+		this.allowQueueTransport = true;
+	}
+	toJSON({ useDidSovPrefixWhereAllowed } = {}) {
+		const json = __credo_ts_core.JsonTransformer.toJSON(this);
+		if (this.allowDidSovPrefix && useDidSovPrefixWhereAllowed) require_messageType.replaceNewDidCommPrefixWithLegacyDidSovOnMessage(json);
+		return json;
+	}
+	is(Class) {
+		return this.type === Class.type.messageTypeUri;
+	}
+};
+require_decorate.__decorate([(0, import_cjs.Exclude)(), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], DidCommMessage.prototype, "allowDidSovPrefix", void 0);
+require_decorate.__decorate([(0, import_cjs.Exclude)(), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], DidCommMessage.prototype, "allowQueueTransport", void 0);
+
+//#endregion
+exports.DidCommMessage = DidCommMessage;

package/build/packages/didcomm/src/DidCommMessage.mjs

@@ -0,0 +1,37 @@
+import { __decorateMetadata } from "../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.mjs";
+import { BaseDidCommMessage } from "./BaseDidCommMessage.mjs";
+import { AckDecorated } from "./decorators/ack/AckDecoratorExtension.mjs";
+import { AttachmentDecorated } from "./decorators/attachment/AttachmentExtension.mjs";
+import { L10nDecorated } from "./decorators/l10n/L10nDecoratorExtension.mjs";
+import { ServiceDecorated } from "./decorators/service/ServiceDecoratorExtension.mjs";
+import { ThreadDecorated } from "./decorators/thread/ThreadDecoratorExtension.mjs";
+import { TimingDecorated } from "./decorators/timing/TimingDecoratorExtension.mjs";
+import { TransportDecorated } from "./decorators/transport/TransportDecoratorExtension.mjs";
+import { replaceNewDidCommPrefixWithLegacyDidSovOnMessage } from "./util/messageType.mjs";
+import { JsonTransformer } from "@credo-ts/core";
+import { Exclude } from "class-transformer";
+
+//#region ../didcomm/src/DidCommMessage.ts
+const Decorated = ThreadDecorated(L10nDecorated(TransportDecorated(TimingDecorated(AckDecorated(AttachmentDecorated(ServiceDecorated(BaseDidCommMessage)))))));
+var DidCommMessage = class extends Decorated {
+	constructor(..._args) {
+		super(..._args);
+		this.allowDidSovPrefix = false;
+		this.allowQueueTransport = true;
+	}
+	toJSON({ useDidSovPrefixWhereAllowed } = {}) {
+		const json = JsonTransformer.toJSON(this);
+		if (this.allowDidSovPrefix && useDidSovPrefixWhereAllowed) replaceNewDidCommPrefixWithLegacyDidSovOnMessage(json);
+		return json;
+	}
+	is(Class) {
+		return this.type === Class.type.messageTypeUri;
+	}
+};
+__decorate([Exclude(), __decorateMetadata("design:type", Boolean)], DidCommMessage.prototype, "allowDidSovPrefix", void 0);
+__decorate([Exclude(), __decorateMetadata("design:type", Boolean)], DidCommMessage.prototype, "allowQueueTransport", void 0);
+
+//#endregion
+export { DidCommMessage };
+//# sourceMappingURL=DidCommMessage.mjs.map

package/build/packages/didcomm/src/DidCommMessage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DidCommMessage.mjs","names":[],"sources":["../../../../../didcomm/src/DidCommMessage.ts"],"sourcesContent":["import type { Constructor } from '@credo-ts/core'\nimport type { DidCommPlaintextMessage } from './types'\nimport type { ParsedMessageType } from './util/messageType'\n\nimport { JsonTransformer } from '@credo-ts/core'\nimport { Exclude } from 'class-transformer'\n\nimport { BaseDidCommMessage } from './BaseDidCommMessage'\nimport { AckDecorated } from './decorators/ack/AckDecoratorExtension'\nimport { AttachmentDecorated } from './decorators/attachment/AttachmentExtension'\nimport { L10nDecorated } from './decorators/l10n/L10nDecoratorExtension'\nimport { ServiceDecorated } from './decorators/service/ServiceDecoratorExtension'\nimport { ThreadDecorated } from './decorators/thread/ThreadDecoratorExtension'\nimport { TimingDecorated } from './decorators/timing/TimingDecoratorExtension'\nimport { TransportDecorated } from './decorators/transport/TransportDecoratorExtension'\nimport { replaceNewDidCommPrefixWithLegacyDidSovOnMessage } from './util/messageType'\n\nexport type ConstructableAgentMessage = Constructor<DidCommMessage> & { type: ParsedMessageType }\n\nconst Decorated = ThreadDecorated(\n  L10nDecorated(\n    TransportDecorated(TimingDecorated(AckDecorated(AttachmentDecorated(ServiceDecorated(BaseDidCommMessage)))))\n  )\n)\n\nexport class DidCommMessage extends Decorated {\n  /**\n   * Whether the protocol RFC was initially written using the legacy did:prefix instead of the\n   * new https://didcomm.org message type prefix.\n   *\n   * @see https://github.com/hyperledger/aries-rfcs/blob/main/features/0348-transition-msg-type-to-https/README.md\n   */\n  @Exclude()\n  public readonly allowDidSovPrefix: boolean = false\n\n  /**\n   * Whether to use Queue Transport in case the recipient of this message does not have a reliable\n   * endpoint available\n   *\n   * @see https://github.com/decentralized-identity/didcomm-messaging/blob/main/extensions/return_route/main.md#queue-transport\n   */\n  @Exclude()\n  public readonly allowQueueTransport: boolean = true\n\n  public toJSON({\n    useDidSovPrefixWhereAllowed,\n  }: { useDidSovPrefixWhereAllowed?: boolean } = {}): DidCommPlaintextMessage {\n    const json = JsonTransformer.toJSON(this)\n\n    // If we have `useDidSovPrefixWhereAllowed` enabled, we want to replace the new https://didcomm.org prefix with the legacy did:sov prefix.\n    // However, we only do this if the protocol RFC was initially written with the did:sov message type prefix\n    // See https://github.com/hyperledger/aries-rfcs/blob/main/features/0348-transition-msg-type-to-https/README.md\n    if (this.allowDidSovPrefix && useDidSovPrefixWhereAllowed) {\n      replaceNewDidCommPrefixWithLegacyDidSovOnMessage(json)\n    }\n\n    return json as DidCommPlaintextMessage\n  }\n\n  public is<C extends typeof DidCommMessage>(Class: C): this is InstanceType<C> {\n    return this.type === Class.type.messageTypeUri\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,MAAM,YAAY,gBAChB,cACE,mBAAmB,gBAAgB,aAAa,oBAAoB,iBAAiB,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAC7G,CACF;AAED,IAAa,iBAAb,cAAoC,UAAU;;;OAQ5B,oBAA6B;OAS7B,sBAA+B;;CAE/C,AAAO,OAAO,EACZ,gCAC6C,EAAE,EAA2B;EAC1E,MAAM,OAAO,gBAAgB,OAAO,KAAK;AAKzC,MAAI,KAAK,qBAAqB,4BAC5B,kDAAiD,KAAK;AAGxD,SAAO;;CAGT,AAAO,GAAoC,OAAmC;AAC5E,SAAO,KAAK,SAAS,MAAM,KAAK;;;YA5BjC,SAAS;YAST,SAAS"}

package/build/packages/didcomm/src/DidCommMessageHandlerRegistry.js

@@ -0,0 +1,71 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_decorate = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.js');
+const require_messageType = require('./util/messageType.js');
+let __credo_ts_core = require("@credo-ts/core");
+__credo_ts_core = require_rolldown_runtime.__toESM(__credo_ts_core);
+
+//#region ../didcomm/src/DidCommMessageHandlerRegistry.ts
+let DidCommMessageHandlerRegistry = class DidCommMessageHandlerRegistry$1 {
+	constructor() {
+		this.messageHandlers = [];
+		this.messageHandlerMiddlewares = [];
+	}
+	registerMessageHandler(messageHandler) {
+		this.messageHandlers.push(messageHandler);
+	}
+	registerMessageHandlers(messageHandlers) {
+		for (const messageHandler of messageHandlers) this.registerMessageHandler(messageHandler);
+	}
+	registerMessageHandlerMiddleware(messageHandlerMiddleware) {
+		this.messageHandlerMiddlewares.push(messageHandlerMiddleware);
+	}
+	get fallbackMessageHandler() {
+		return this._fallbackMessageHandler;
+	}
+	/**
+	* Sets the fallback message handler, the message handler that will be called if no handler
+	* is registered for an incoming message type.
+	*/
+	setFallbackMessageHandler(fallbackMessageHandler) {
+		this._fallbackMessageHandler = fallbackMessageHandler;
+	}
+	getHandlerForMessageType(messageType) {
+		const incomingMessageType = require_messageType.parseMessageType(messageType);
+		for (const handler of this.messageHandlers) for (const MessageClass of handler.supportedMessages) if (require_messageType.canHandleMessageType(MessageClass, incomingMessageType)) return handler;
+	}
+	getMessageClassForMessageType(messageType) {
+		const incomingMessageType = require_messageType.parseMessageType(messageType);
+		for (const handler of this.messageHandlers) for (const MessageClass of handler.supportedMessages) if (require_messageType.canHandleMessageType(MessageClass, incomingMessageType)) return MessageClass;
+	}
+	/**
+	* Returns array of message types that dispatcher is able to handle.
+	* Message type format is MTURI specified at https://github.com/hyperledger/aries-rfcs/blob/main/concepts/0003-protocols/README.md#mturi.
+	*/
+	get supportedMessageTypes() {
+		return this.messageHandlers.reduce((all, cur) => [...all, ...cur.supportedMessages], []).map((m) => m.type);
+	}
+	/**
+	* Returns array of protocol IDs that dispatcher is able to handle.
+	* Protocol ID format is PIURI specified at https://github.com/hyperledger/aries-rfcs/blob/main/concepts/0003-protocols/README.md#piuri.
+	*/
+	get supportedProtocolUris() {
+		const seenProtocolUris = /* @__PURE__ */ new Set();
+		return this.supportedMessageTypes.filter((m) => {
+			const has = seenProtocolUris.has(m.protocolUri);
+			seenProtocolUris.add(m.protocolUri);
+			return !has;
+		}).map(({ messageName, messageTypeUri,...parsedProtocolUri }) => parsedProtocolUri);
+	}
+	filterSupportedProtocolsByProtocolUris(parsedProtocolUris) {
+		return this.supportedProtocolUris.filter((supportedProtocol) => parsedProtocolUris.some((p) => require_messageType.supportsIncomingDidCommProtocolUri(supportedProtocol, p)));
+	}
+};
+DidCommMessageHandlerRegistry = require_decorate.__decorate([(0, __credo_ts_core.injectable)()], DidCommMessageHandlerRegistry);
+
+//#endregion
+Object.defineProperty(exports, 'DidCommMessageHandlerRegistry', {
+  enumerable: true,
+  get: function () {
+    return DidCommMessageHandlerRegistry;
+  }
+});

package/build/packages/didcomm/src/DidCommMessageHandlerRegistry.mjs

@@ -0,0 +1,65 @@
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.mjs";
+import { canHandleMessageType, parseMessageType, supportsIncomingDidCommProtocolUri } from "./util/messageType.mjs";
+import { injectable } from "@credo-ts/core";
+
+//#region ../didcomm/src/DidCommMessageHandlerRegistry.ts
+let DidCommMessageHandlerRegistry = class DidCommMessageHandlerRegistry$1 {
+	constructor() {
+		this.messageHandlers = [];
+		this.messageHandlerMiddlewares = [];
+	}
+	registerMessageHandler(messageHandler) {
+		this.messageHandlers.push(messageHandler);
+	}
+	registerMessageHandlers(messageHandlers) {
+		for (const messageHandler of messageHandlers) this.registerMessageHandler(messageHandler);
+	}
+	registerMessageHandlerMiddleware(messageHandlerMiddleware) {
+		this.messageHandlerMiddlewares.push(messageHandlerMiddleware);
+	}
+	get fallbackMessageHandler() {
+		return this._fallbackMessageHandler;
+	}
+	/**
+	* Sets the fallback message handler, the message handler that will be called if no handler
+	* is registered for an incoming message type.
+	*/
+	setFallbackMessageHandler(fallbackMessageHandler) {
+		this._fallbackMessageHandler = fallbackMessageHandler;
+	}
+	getHandlerForMessageType(messageType) {
+		const incomingMessageType = parseMessageType(messageType);
+		for (const handler of this.messageHandlers) for (const MessageClass of handler.supportedMessages) if (canHandleMessageType(MessageClass, incomingMessageType)) return handler;
+	}
+	getMessageClassForMessageType(messageType) {
+		const incomingMessageType = parseMessageType(messageType);
+		for (const handler of this.messageHandlers) for (const MessageClass of handler.supportedMessages) if (canHandleMessageType(MessageClass, incomingMessageType)) return MessageClass;
+	}
+	/**
+	* Returns array of message types that dispatcher is able to handle.
+	* Message type format is MTURI specified at https://github.com/hyperledger/aries-rfcs/blob/main/concepts/0003-protocols/README.md#mturi.
+	*/
+	get supportedMessageTypes() {
+		return this.messageHandlers.reduce((all, cur) => [...all, ...cur.supportedMessages], []).map((m) => m.type);
+	}
+	/**
+	* Returns array of protocol IDs that dispatcher is able to handle.
+	* Protocol ID format is PIURI specified at https://github.com/hyperledger/aries-rfcs/blob/main/concepts/0003-protocols/README.md#piuri.
+	*/
+	get supportedProtocolUris() {
+		const seenProtocolUris = /* @__PURE__ */ new Set();
+		return this.supportedMessageTypes.filter((m) => {
+			const has = seenProtocolUris.has(m.protocolUri);
+			seenProtocolUris.add(m.protocolUri);
+			return !has;
+		}).map(({ messageName, messageTypeUri,...parsedProtocolUri }) => parsedProtocolUri);
+	}
+	filterSupportedProtocolsByProtocolUris(parsedProtocolUris) {
+		return this.supportedProtocolUris.filter((supportedProtocol) => parsedProtocolUris.some((p) => supportsIncomingDidCommProtocolUri(supportedProtocol, p)));
+	}
+};
+DidCommMessageHandlerRegistry = __decorate([injectable()], DidCommMessageHandlerRegistry);
+
+//#endregion
+export { DidCommMessageHandlerRegistry };
+//# sourceMappingURL=DidCommMessageHandlerRegistry.mjs.map

package/build/packages/didcomm/src/DidCommMessageHandlerRegistry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DidCommMessageHandlerRegistry.mjs","names":["DidCommMessageHandlerRegistry"],"sources":["../../../../../didcomm/src/DidCommMessageHandlerRegistry.ts"],"sourcesContent":["import type { DidCommMessage } from './DidCommMessage'\nimport type { DidCommMessageHandler } from './handlers/DidCommMessageHandler'\nimport type { DidCommMessageHandlerMiddleware } from './handlers/DidCommMessageHandlerMiddleware'\nimport type { ParsedDidCommProtocolUri } from './util/messageType'\n\nimport { injectable } from '@credo-ts/core'\n\nimport { canHandleMessageType, parseMessageType, supportsIncomingDidCommProtocolUri } from './util/messageType'\n\n@injectable()\nexport class DidCommMessageHandlerRegistry {\n  private messageHandlers: DidCommMessageHandler[] = []\n  public readonly messageHandlerMiddlewares: DidCommMessageHandlerMiddleware[] = []\n  private _fallbackMessageHandler?: DidCommMessageHandler['handle']\n\n  public registerMessageHandler(messageHandler: DidCommMessageHandler) {\n    this.messageHandlers.push(messageHandler)\n  }\n\n  public registerMessageHandlers(messageHandlers: DidCommMessageHandler[]) {\n    for (const messageHandler of messageHandlers) {\n      this.registerMessageHandler(messageHandler)\n    }\n  }\n\n  public registerMessageHandlerMiddleware(messageHandlerMiddleware: DidCommMessageHandlerMiddleware) {\n    this.messageHandlerMiddlewares.push(messageHandlerMiddleware)\n  }\n\n  public get fallbackMessageHandler() {\n    return this._fallbackMessageHandler\n  }\n\n  /**\n   * Sets the fallback message handler, the message handler that will be called if no handler\n   * is registered for an incoming message type.\n   */\n  public setFallbackMessageHandler(fallbackMessageHandler: DidCommMessageHandler['handle']) {\n    this._fallbackMessageHandler = fallbackMessageHandler\n  }\n\n  public getHandlerForMessageType(messageType: string): DidCommMessageHandler | undefined {\n    const incomingMessageType = parseMessageType(messageType)\n\n    for (const handler of this.messageHandlers) {\n      for (const MessageClass of handler.supportedMessages) {\n        if (canHandleMessageType(MessageClass, incomingMessageType)) return handler\n      }\n    }\n  }\n\n  public getMessageClassForMessageType(messageType: string): typeof DidCommMessage | undefined {\n    const incomingMessageType = parseMessageType(messageType)\n\n    for (const handler of this.messageHandlers) {\n      for (const MessageClass of handler.supportedMessages) {\n        if (canHandleMessageType(MessageClass, incomingMessageType)) return MessageClass\n      }\n    }\n  }\n\n  /**\n   * Returns array of message types that dispatcher is able to handle.\n   * Message type format is MTURI specified at https://github.com/hyperledger/aries-rfcs/blob/main/concepts/0003-protocols/README.md#mturi.\n   */\n  public get supportedMessageTypes() {\n    return (\n      this.messageHandlers\n        // biome-ignore lint/performance/noAccumulatingSpread: <explanation>\n        .reduce<(typeof DidCommMessage)[]>((all, cur) => [...all, ...cur.supportedMessages], [])\n        .map((m) => m.type)\n    )\n  }\n\n  /**\n   * Returns array of protocol IDs that dispatcher is able to handle.\n   * Protocol ID format is PIURI specified at https://github.com/hyperledger/aries-rfcs/blob/main/concepts/0003-protocols/README.md#piuri.\n   */\n  public get supportedProtocolUris() {\n    const seenProtocolUris = new Set<string>()\n\n    const protocolUris: ParsedDidCommProtocolUri[] = this.supportedMessageTypes\n      .filter((m) => {\n        const has = seenProtocolUris.has(m.protocolUri)\n        seenProtocolUris.add(m.protocolUri)\n        return !has\n      })\n      .map(({ messageName, messageTypeUri, ...parsedProtocolUri }) => parsedProtocolUri)\n\n    return protocolUris\n  }\n\n  public filterSupportedProtocolsByProtocolUris(parsedProtocolUris: ParsedDidCommProtocolUri[]) {\n    return this.supportedProtocolUris.filter((supportedProtocol) =>\n      parsedProtocolUris.some((p) => supportsIncomingDidCommProtocolUri(supportedProtocol, p))\n    )\n  }\n}\n"],"mappings":";;;;;AAUO,0CAAMA,gCAA8B;;OACjC,kBAA2C,EAAE;OACrC,4BAA+D,EAAE;;CAGjF,AAAO,uBAAuB,gBAAuC;AACnE,OAAK,gBAAgB,KAAK,eAAe;;CAG3C,AAAO,wBAAwB,iBAA0C;AACvE,OAAK,MAAM,kBAAkB,gBAC3B,MAAK,uBAAuB,eAAe;;CAI/C,AAAO,iCAAiC,0BAA2D;AACjG,OAAK,0BAA0B,KAAK,yBAAyB;;CAG/D,IAAW,yBAAyB;AAClC,SAAO,KAAK;;;;;;CAOd,AAAO,0BAA0B,wBAAyD;AACxF,OAAK,0BAA0B;;CAGjC,AAAO,yBAAyB,aAAwD;EACtF,MAAM,sBAAsB,iBAAiB,YAAY;AAEzD,OAAK,MAAM,WAAW,KAAK,gBACzB,MAAK,MAAM,gBAAgB,QAAQ,kBACjC,KAAI,qBAAqB,cAAc,oBAAoB,CAAE,QAAO;;CAK1E,AAAO,8BAA8B,aAAwD;EAC3F,MAAM,sBAAsB,iBAAiB,YAAY;AAEzD,OAAK,MAAM,WAAW,KAAK,gBACzB,MAAK,MAAM,gBAAgB,QAAQ,kBACjC,KAAI,qBAAqB,cAAc,oBAAoB,CAAE,QAAO;;;;;;CAS1E,IAAW,wBAAwB;AACjC,SACE,KAAK,gBAEF,QAAmC,KAAK,QAAQ,CAAC,GAAG,KAAK,GAAG,IAAI,kBAAkB,EAAE,EAAE,CAAC,CACvF,KAAK,MAAM,EAAE,KAAK;;;;;;CAQzB,IAAW,wBAAwB;EACjC,MAAM,mCAAmB,IAAI,KAAa;AAU1C,SARiD,KAAK,sBACnD,QAAQ,MAAM;GACb,MAAM,MAAM,iBAAiB,IAAI,EAAE,YAAY;AAC/C,oBAAiB,IAAI,EAAE,YAAY;AACnC,UAAO,CAAC;IACR,CACD,KAAK,EAAE,aAAa,eAAgB,GAAG,wBAAwB,kBAAkB;;CAKtF,AAAO,uCAAuC,oBAAgD;AAC5F,SAAO,KAAK,sBAAsB,QAAQ,sBACxC,mBAAmB,MAAM,MAAM,mCAAmC,mBAAmB,EAAE,CAAC,CACzF;;;4CAtFJ,YAAY"}

package/build/packages/didcomm/src/DidCommMessageReceiver.js

@@ -0,0 +1,208 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_decorateMetadata = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorateMetadata.js');
+const require_decorate = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.js');
+const require_messageType = require('./util/messageType.js');
+const require_DidCommMessage = require('./DidCommMessage.js');
+const require_DidCommProblemReportMessage = require('./messages/problem-reports/DidCommProblemReportMessage.js');
+const require_DidCommProblemReportError = require('./errors/problem-reports/DidCommProblemReportError.js');
+require('./errors/index.js');
+require('./messages/index.js');
+const require_DidCommProblemReportReason = require('./models/problem-reports/DidCommProblemReportReason.js');
+const require_DidCommInboundMessageContext = require('./models/DidCommInboundMessageContext.js');
+const require_DidCommOutboundMessageContext = require('./models/DidCommOutboundMessageContext.js');
+require('./models/index.js');
+const require_JWE = require('./util/JWE.js');
+const require_DidCommTransportService = require('./DidCommTransportService.js');
+const require_decorateParam = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorateParam.js');
+const require_DidCommConnectionService = require('./modules/connections/services/DidCommConnectionService.js');
+const require_DidCommEnvelopeService = require('./DidCommEnvelopeService.js');
+const require_DidCommMessageSender = require('./DidCommMessageSender.js');
+require('./modules/connections/services/index.js');
+const require_DidCommMessageHandlerRegistry = require('./DidCommMessageHandlerRegistry.js');
+const require_DidCommDispatcher = require('./DidCommDispatcher.js');
+let __credo_ts_core = require("@credo-ts/core");
+__credo_ts_core = require_rolldown_runtime.__toESM(__credo_ts_core);
+
+//#region ../didcomm/src/DidCommMessageReceiver.ts
+var _ref, _ref2, _ref3, _ref4, _ref5, _ref6;
+let DidCommMessageReceiver = class DidCommMessageReceiver$1 {
+	constructor(envelopeService, transportService, messageSender, connectionService, dispatcher, messageHandlerRegistry, agentContextProvider, logger) {
+		this._inboundTransports = [];
+		this.envelopeService = envelopeService;
+		this.transportService = transportService;
+		this.messageSender = messageSender;
+		this.connectionService = connectionService;
+		this.dispatcher = dispatcher;
+		this.messageHandlerRegistry = messageHandlerRegistry;
+		this.agentContextProvider = agentContextProvider;
+		this.logger = logger;
+		this._inboundTransports = [];
+	}
+	get inboundTransports() {
+		return this._inboundTransports;
+	}
+	registerInboundTransport(inboundTransport) {
+		this._inboundTransports.push(inboundTransport);
+	}
+	async unregisterInboundTransport(inboundTransport) {
+		this._inboundTransports = this._inboundTransports.filter((transport) => transport !== inboundTransport);
+		await inboundTransport.stop();
+	}
+	/**
+	* Receive and handle an inbound DIDComm message. It will determine the agent context, decrypt the message, transform it
+	* to it's corresponding message class and finally dispatch it to the dispatcher.
+	*
+	* @param inboundMessage the message to receive and handle
+	*/
+	async receiveMessage(inboundMessage, { session, connection, contextCorrelationId, receivedAt } = {}) {
+		this.logger.debug("Agent received message");
+		const agentContext = await this.agentContextProvider.getContextForInboundMessage(inboundMessage, { contextCorrelationId });
+		try {
+			if (this.isEncryptedMessage(inboundMessage)) await this.receiveEncryptedMessage(agentContext, inboundMessage, session, receivedAt);
+			else if (this.isPlaintextMessage(inboundMessage)) await this.receivePlaintextMessage(agentContext, inboundMessage, connection, receivedAt);
+			else throw new __credo_ts_core.CredoError("Unable to parse incoming message: unrecognized format");
+		} finally {
+			await agentContext.endSession();
+		}
+	}
+	async receivePlaintextMessage(agentContext, plaintextMessage, connection, receivedAt) {
+		const messageContext = new require_DidCommInboundMessageContext.DidCommInboundMessageContext(await this.transformAndValidate(agentContext, plaintextMessage), {
+			connection,
+			agentContext,
+			receivedAt
+		});
+		await this.dispatcher.dispatch(messageContext);
+	}
+	async receiveEncryptedMessage(agentContext, encryptedMessage, session, receivedAt) {
+		const decryptedMessage = await this.decryptMessage(agentContext, encryptedMessage);
+		const { plaintextMessage, senderKey, recipientKey } = decryptedMessage;
+		this.logger.info(`Received message with type '${plaintextMessage["@type"]}', recipient key ${recipientKey?.fingerprint} and sender key ${senderKey?.fingerprint}`, plaintextMessage);
+		const connection = await this.findConnectionByMessageKeys(agentContext, decryptedMessage);
+		const message = await this.transformAndValidate(agentContext, plaintextMessage, connection);
+		const messageContext = new require_DidCommInboundMessageContext.DidCommInboundMessageContext(message, {
+			connection: connection?.isReady ? connection : void 0,
+			senderKey,
+			recipientKey,
+			agentContext,
+			receivedAt,
+			encryptedMessage
+		});
+		if (senderKey && recipientKey && message.hasAnyReturnRoute() && session) {
+			this.logger.debug(`Storing session for inbound message '${message.id}'`);
+			session.keys = {
+				recipientKeys: [senderKey],
+				routingKeys: [],
+				senderKey: recipientKey
+			};
+			session.inboundMessage = message;
+			session.connectionId = connection?.id;
+			messageContext.sessionId = session.id;
+			this.transportService.saveSession(session);
+		} else if (session) await session.close();
+		await this.dispatcher.dispatch(messageContext);
+	}
+	/**
+	* Decrypt a message using the envelope service.
+	*
+	* @param message the received inbound message to decrypt
+	*/
+	async decryptMessage(agentContext, message) {
+		try {
+			return await this.envelopeService.unpackMessage(agentContext, message);
+		} catch (error) {
+			this.logger.error("Error while decrypting message", {
+				error,
+				encryptedMessage: message,
+				errorMessage: error instanceof Error ? error.message : error
+			});
+			throw error;
+		}
+	}
+	isPlaintextMessage(message) {
+		if (typeof message !== "object" || message == null) return false;
+		return "@type" in message;
+	}
+	isEncryptedMessage(message) {
+		return require_JWE.isValidJweStructure(message);
+	}
+	async transformAndValidate(agentContext, plaintextMessage, connection) {
+		let message;
+		try {
+			message = await this.transformMessage(plaintextMessage);
+		} catch (error) {
+			if (connection) await this.sendProblemReportMessage(agentContext, error.message, connection, plaintextMessage);
+			throw error;
+		}
+		return message;
+	}
+	async findConnectionByMessageKeys(agentContext, { recipientKey, senderKey }) {
+		if (!recipientKey || !senderKey) return null;
+		return this.connectionService.findByKeys(agentContext, {
+			senderKey,
+			recipientKey
+		});
+	}
+	/**
+	* Transform an plaintext DIDComm message into it's corresponding message class. Will look at all message types in the registered handlers.
+	*
+	* @param message the plaintext message for which to transform the message in to a class instance
+	*/
+	async transformMessage(message) {
+		require_messageType.replaceLegacyDidSovPrefixOnMessage(message);
+		const messageType = message["@type"];
+		const MessageClass = this.messageHandlerRegistry.getMessageClassForMessageType(messageType) ?? require_DidCommMessage.DidCommMessage;
+		let messageTransformed;
+		try {
+			messageTransformed = __credo_ts_core.JsonTransformer.fromJSON(message, MessageClass);
+		} catch (error) {
+			this.logger.error(`Error validating message ${message["@type"]}`, {
+				errors: error,
+				message: JSON.stringify(message)
+			});
+			throw new require_DidCommProblemReportError.DidCommProblemReportError(`Error validating message ${message["@type"]}`, { problemCode: require_DidCommProblemReportReason.DidCommProblemReportReason.MessageParseFailure });
+		}
+		return messageTransformed;
+	}
+	/**
+	* Send the problem report message (https://didcomm.org/notification/1.0/problem-report) to the recipient.
+	* @param message error message to send
+	* @param connection connection to send the message to
+	* @param plaintextMessage received inbound message
+	*/
+	async sendProblemReportMessage(agentContext, message, connection, plaintextMessage) {
+		if (require_messageType.canHandleMessageType(require_DidCommProblemReportMessage.DidCommProblemReportMessage, require_messageType.parseMessageType(plaintextMessage["@type"]))) throw new __credo_ts_core.CredoError(`Not sending problem report in response to problem report: ${message}`);
+		const problemReportMessage = new require_DidCommProblemReportMessage.DidCommProblemReportMessage({ description: {
+			en: message,
+			code: require_DidCommProblemReportReason.DidCommProblemReportReason.MessageParseFailure
+		} });
+		problemReportMessage.setThread({ parentThreadId: plaintextMessage["@id"] });
+		const outboundMessageContext = new require_DidCommOutboundMessageContext.DidCommOutboundMessageContext(problemReportMessage, {
+			agentContext,
+			connection
+		});
+		if (outboundMessageContext) await this.messageSender.sendMessage(outboundMessageContext);
+	}
+};
+DidCommMessageReceiver = require_decorate.__decorate([
+	(0, __credo_ts_core.injectable)(),
+	require_decorateParam.__decorateParam(6, (0, __credo_ts_core.inject)(__credo_ts_core.InjectionSymbols.AgentContextProvider)),
+	require_decorateParam.__decorateParam(7, (0, __credo_ts_core.inject)(__credo_ts_core.InjectionSymbols.Logger)),
+	require_decorateMetadata.__decorateMetadata("design:paramtypes", [
+		typeof (_ref = typeof require_DidCommEnvelopeService.DidCommEnvelopeService !== "undefined" && require_DidCommEnvelopeService.DidCommEnvelopeService) === "function" ? _ref : Object,
+		typeof (_ref2 = typeof require_DidCommTransportService.DidCommTransportService !== "undefined" && require_DidCommTransportService.DidCommTransportService) === "function" ? _ref2 : Object,
+		typeof (_ref3 = typeof require_DidCommMessageSender.DidCommMessageSender !== "undefined" && require_DidCommMessageSender.DidCommMessageSender) === "function" ? _ref3 : Object,
+		typeof (_ref4 = typeof require_DidCommConnectionService.DidCommConnectionService !== "undefined" && require_DidCommConnectionService.DidCommConnectionService) === "function" ? _ref4 : Object,
+		typeof (_ref5 = typeof require_DidCommDispatcher.DidCommDispatcher !== "undefined" && require_DidCommDispatcher.DidCommDispatcher) === "function" ? _ref5 : Object,
+		typeof (_ref6 = typeof require_DidCommMessageHandlerRegistry.DidCommMessageHandlerRegistry !== "undefined" && require_DidCommMessageHandlerRegistry.DidCommMessageHandlerRegistry) === "function" ? _ref6 : Object,
+		Object,
+		Object
+	])
+], DidCommMessageReceiver);
+
+//#endregion
+Object.defineProperty(exports, 'DidCommMessageReceiver', {
+  enumerable: true,
+  get: function () {
+    return DidCommMessageReceiver;
+  }
+});