gdc-common-utils-ts 2.0.17 → 2.1.0

package/dist/models/inter-tenant-access-contract.js

@@ -0,0 +1,78 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+/**
+ * Canonical flat claim keys used when a frontend captures an inter-tenant
+ * access contract form and sends it to a backend before the final FHIR
+ * `Contract` resource is assembled.
+ *
+ * Notes:
+ * - these keys are claims-first transport helpers, not the legal source of
+ *   truth
+ * - the canonical legal payload is the FHIR `Contract` placed in
+ *   `credentialSubject` of the emitted VC
+ * - custom flat keys are used only where base FHIR does not define a simple
+ *   one-claim scalar path suitable for UI transport
+ */
+export var ClaimInterTenantAccessContract;
+(function (ClaimInterTenantAccessContract) {
+    /** Stable business identifier of the agreement/contract. */
+    ClaimInterTenantAccessContract["identifier"] = "Contract.identifier";
+    /** FHIR Contract lifecycle status, for example `executed` or `amended`. */
+    ClaimInterTenantAccessContract["status"] = "Contract.status";
+    /** When the agreement was formally issued. */
+    ClaimInterTenantAccessContract["issued"] = "Contract.issued";
+    /** Agreement validity start date/time. */
+    ClaimInterTenantAccessContract["appliesStart"] = "Contract.applies-start";
+    /** Agreement validity end date/time. */
+    ClaimInterTenantAccessContract["appliesEnd"] = "Contract.applies-end";
+    /**
+     * Provider organization DID.
+     *
+     * Meaning for programmers:
+     * - this is the tenant that owns/exposes the protected data
+     * - in the current example this is `did:web:api.acme.org`
+     */
+    ClaimInterTenantAccessContract["providerOrganization"] = "Contract.provider-organization";
+    /**
+     * Consumer organization DID.
+     *
+     * Meaning for programmers:
+     * - this is the foreign tenant requesting access under the agreement
+     * - in the current example this is `did:web:api.lab.org`
+     */
+    ClaimInterTenantAccessContract["consumerOrganization"] = "Contract.consumer-organization";
+    /**
+     * DID of the controller who signed on behalf of the provider organization.
+     */
+    ClaimInterTenantAccessContract["providerController"] = "Contract.provider-controller";
+    /**
+     * DID of the controller who signed on behalf of the consumer organization.
+     */
+    ClaimInterTenantAccessContract["consumerController"] = "Contract.consumer-controller";
+    /**
+     * Allowed operational capability, expressed with the same vocabulary used by
+     * GW service capabilities and SMART-like root scopes.
+     *
+     * Example:
+     * - `organization/Composition.rs`
+     */
+    ClaimInterTenantAccessContract["capability"] = "Contract.security-label";
+    /**
+     * Allowed business/legal purpose for the access.
+     *
+     * Example:
+     * - `RESEARCH`
+     */
+    ClaimInterTenantAccessContract["purpose"] = "Contract.term-type";
+    /**
+     * External instantiated artifact for the agreement, typically the signed PDF
+     * or CID/URL of the contract itself plus direct contractual annexes.
+     *
+     * Canonical FHIR field:
+     * - `Contract.instantiatesUri`
+     *
+     * Flat claim rule in this stack:
+     * - use FHIR-style `instantiates-uri` in claims, then map it to
+     *   `instantiatesUri` in the actual FHIR resource object
+     */
+    ClaimInterTenantAccessContract["instantiatesUri"] = "Contract.instantiates-uri";
+})(ClaimInterTenantAccessContract || (ClaimInterTenantAccessContract = {}));

package/dist/models/interoperable-claims/diagnostic-report-claims.d.ts

@@ -91,6 +91,5 @@ export declare const DiagnosticReportSearchParamToClaimKey: Record<DiagnosticRep
  *
  * Keep `DiagnosticReport` paused at the typing/mapping layer until:
  * 1. `claims-helpers-diagnostic-report.ts` exists
- * 2. `CommunicationAttachedBundleSession.upsertActiveDiagnosticReportEntry(...)` exists
- * 3. GW Core readers/tests consume the same shared claim keys
+ * 2. GW Core readers/tests consume the same shared claim keys
  */

package/dist/models/interoperable-claims/diagnostic-report-claims.js

@@ -100,6 +100,5 @@ export const DiagnosticReportSearchParamToClaimKey = {
  *
  * Keep `DiagnosticReport` paused at the typing/mapping layer until:
  * 1. `claims-helpers-diagnostic-report.ts` exists
- * 2. `CommunicationAttachedBundleSession.upsertActiveDiagnosticReportEntry(...)` exists
- * 3. GW Core readers/tests consume the same shared claim keys
+ * 2. GW Core readers/tests consume the same shared claim keys
  */

package/dist/models/profile-manager.d.ts

@@ -0,0 +1,85 @@
+import type { WalletMessagePriority, WalletQueuedMessage } from './wallet';
+/**
+ * Minimal local profile descriptor for memory-backed wallet/runtime tests.
+ *
+ * This stays intentionally below actor-specific SDK facades.
+ */
+export type ProfileManagerMemProfile = Readonly<{
+    profileId: string;
+    displayName?: string;
+    did: string;
+}>;
+/**
+ * Result returned by one backend message transport after submitting one local
+ * queued message envelope.
+ */
+export type BackendMessageTransportSubmitResult = Readonly<{
+    accepted: boolean;
+    retryable?: boolean;
+    errorMessage?: string;
+    responseEnvelope?: string;
+    locationUrl?: string;
+}>;
+/**
+ * Result returned by one backend message poll operation after a previous
+ * transport submit accepted the request asynchronously.
+ */
+export type BackendMessageTransportPollResult = Readonly<{
+    pending: boolean;
+    completed?: boolean;
+    retryable?: boolean;
+    errorMessage?: string;
+    responseEnvelope?: string;
+}>;
+/**
+ * Pluggable submit-only transport used by the low-level backend message manager.
+ */
+export type BackendMessageTransport = Readonly<{
+    submit(input: Readonly<{
+        message: WalletQueuedMessage;
+        envelope: string;
+    }>): Promise<BackendMessageTransportSubmitResult>;
+    poll?(input: Readonly<{
+        message: ProfileOutboxMessageRecord;
+    }>): Promise<BackendMessageTransportPollResult>;
+}>;
+/**
+ * One decoded inbound response associated with one DIDComm thread.
+ */
+export type BackendMessageResponseRecord = Readonly<{
+    thid: string;
+    receivedAt: string;
+    content: Record<string, unknown>;
+    meta: Record<string, unknown>;
+}>;
+/**
+ * Immutable historical record written after one profile message is submitted.
+ *
+ * It complements the mutable queue state by preserving:
+ * - the final submitted envelope
+ * - the last known queue status at submission time
+ * - the optional decoded response thread reference
+ */
+export type ProfileOutboxMessageRecord = Readonly<{
+    id: string;
+    thid?: string;
+    messageType?: string;
+    priority: string;
+    status: string;
+    transportStatus?: 'submitted' | 'completed' | 'failed';
+    recordedAt: string;
+    payload: Record<string, unknown>;
+    envelope: string;
+    responseThid?: string;
+    locationUrl?: string;
+    pollCount?: number;
+}>;
+/**
+ * Input used by `BackendMessageManagerMem` and `ProfileManagerMem` to queue one
+ * outbound business payload.
+ */
+export type QueueProfileMessageInput = Readonly<{
+    payload: Record<string, unknown>;
+    priority?: WalletMessagePriority;
+    recipientEncryptionJwk: Record<string, unknown>;
+}>;

package/dist/models/profile-manager.js

@@ -0,0 +1,2 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+export {};

package/dist/models/wallet.d.ts

@@ -0,0 +1,59 @@
+import type { JWK } from './jwk';
+/**
+ * Canonical priority levels for wallet-managed outbound messages.
+ *
+ * Ordering rule:
+ * - `emergency` is always processed before all other priorities
+ * - for the same priority level, insertion order must be preserved
+ */
+export declare const WalletMessagePriorities: Readonly<{
+    readonly Emergency: "emergency";
+    readonly High: "high";
+    readonly Normal: "normal";
+    readonly Low: "low";
+}>;
+export type WalletMessagePriority = typeof WalletMessagePriorities[keyof typeof WalletMessagePriorities];
+/**
+ * Lifecycle states for one local wallet queue/outbox message.
+ */
+export declare const WalletQueueStatuses: Readonly<{
+    readonly Pending: "pending";
+    readonly Delivered: "delivered";
+    readonly Failed: "failed";
+}>;
+export type WalletQueueStatus = typeof WalletQueueStatuses[keyof typeof WalletQueueStatuses];
+/**
+ * One message tracked by the local wallet queue or outbox.
+ */
+export type WalletQueuedMessage = Readonly<{
+    id: string;
+    createdAt: string;
+    priority: WalletMessagePriority;
+    status: WalletQueueStatus;
+    sequence: number;
+    payload: Record<string, unknown>;
+    thid?: string;
+    messageType?: string;
+    deliveredAt?: string;
+    errorMessage?: string;
+}>;
+/**
+ * Input accepted by wallet-local queue implementations when creating one
+ * queued outbound message.
+ */
+export type WalletEnqueueMessageInput = Readonly<{
+    payload: Record<string, unknown>;
+    priority?: WalletMessagePriority;
+    thid?: string;
+    messageType?: string;
+    id?: string;
+    createdAt?: string;
+}>;
+/**
+ * Public summary of one wallet-managed entity key set.
+ */
+export type WalletManagedEntityDescriptor = Readonly<{
+    entityId: string;
+    signingJwk: JWK;
+    encryptionJwk: JWK;
+}>;

package/dist/models/wallet.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+/**
+ * Canonical priority levels for wallet-managed outbound messages.
+ *
+ * Ordering rule:
+ * - `emergency` is always processed before all other priorities
+ * - for the same priority level, insertion order must be preserved
+ */
+export const WalletMessagePriorities = Object.freeze({
+    Emergency: 'emergency',
+    High: 'high',
+    Normal: 'normal',
+    Low: 'low',
+});
+/**
+ * Lifecycle states for one local wallet queue/outbox message.
+ */
+export const WalletQueueStatuses = Object.freeze({
+    Pending: 'pending',
+    Delivered: 'delivered',
+    Failed: 'failed',
+});

package/dist/utils/backend-message-manager-mem.d.ts

@@ -0,0 +1,67 @@
+import type { IWallet } from '../interfaces/IWallet';
+import type { IProfileOutboxRepository } from '../interfaces/IProfileOutboxRepository';
+import type { BackendMessageResponseRecord, BackendMessageTransport, ProfileOutboxMessageRecord, QueueProfileMessageInput } from '../models/profile-manager';
+import { type WalletQueuedMessage } from '../models/wallet';
+export type BackendMessageManagerMemOptions = Readonly<{
+    wallet: IWallet;
+    entityId: string;
+    transport: BackendMessageTransport;
+    outboxRepository: IProfileOutboxRepository;
+}>;
+/**
+ * Memory-backed backend message manager that:
+ * - queues outbound payloads through `WalletMem`
+ * - packs the next pending message as DIDComm-like JWS+JWE
+ * - submits it through an injected transport
+ * - unwraps the response and indexes it by `thid`
+ *
+ * This is the lowest reusable BFF/proxy slice before actor-specific SDK
+ * facades appear.
+ */
+export declare class BackendMessageManagerMem {
+    private readonly wallet;
+    private readonly entityId;
+    private readonly transport;
+    private readonly outboxRepository;
+    private readonly responsesByThread;
+    constructor(options: BackendMessageManagerMemOptions);
+    /**
+     * Queues one outbound business payload for later submission.
+     */
+    queueMessage(input: QueueProfileMessageInput): Promise<WalletQueuedMessage>;
+    /**
+     * Returns queued messages in current priority/FIFO processing order.
+     */
+    listQueuedMessages(): Promise<WalletQueuedMessage[]>;
+    /**
+     * Submits the next pending message through the injected transport and stores
+     * the decoded response by `thid` when one response envelope is returned.
+     */
+    submitNextPendingMessage(recipientEncryptionJwk: Record<string, unknown>): Promise<{
+        message: WalletQueuedMessage;
+        response?: BackendMessageResponseRecord;
+        pending?: boolean;
+    }>;
+    /**
+     * Returns the latest decoded response for one DIDComm thread.
+     */
+    getResponseByThreadId(thid: string): BackendMessageResponseRecord | undefined;
+    /**
+     * Lists submitted message history records preserved by the outbox repository.
+     */
+    listOutboxHistory(): Promise<ProfileOutboxMessageRecord[]>;
+    /**
+     * Polls one previously submitted asynchronous message by id.
+     */
+    pollSubmittedMessage(messageId: string): Promise<{
+        pending: boolean;
+        response?: BackendMessageResponseRecord;
+        record: ProfileOutboxMessageRecord;
+    }>;
+    /**
+     * Reads one decoded response by thread id, first from memory and then from the repository.
+     */
+    readResponseByThreadId(thid: string): Promise<BackendMessageResponseRecord | undefined>;
+    private persistMessageRecord;
+    private requireOutboxRecord;
+}

package/dist/utils/backend-message-manager-mem.js

@@ -0,0 +1,227 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { WalletQueueStatuses } from '../models/wallet.js';
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Memory-backed backend message manager that:
+ * - queues outbound payloads through `WalletMem`
+ * - packs the next pending message as DIDComm-like JWS+JWE
+ * - submits it through an injected transport
+ * - unwraps the response and indexes it by `thid`
+ *
+ * This is the lowest reusable BFF/proxy slice before actor-specific SDK
+ * facades appear.
+ */
+export class BackendMessageManagerMem {
+    wallet;
+    entityId;
+    transport;
+    outboxRepository;
+    responsesByThread = new Map();
+    constructor(options) {
+        this.wallet = options.wallet;
+        this.entityId = String(options.entityId || '').trim();
+        this.transport = options.transport;
+        this.outboxRepository = options.outboxRepository;
+    }
+    /**
+     * Queues one outbound business payload for later submission.
+     */
+    async queueMessage(input) {
+        if (!this.wallet.enqueueMessage) {
+            throw new Error('BackendMessageManagerMem requires wallet.enqueueMessage().');
+        }
+        const thid = typeof input.payload['thid'] === 'string' ? String(input.payload['thid']) : undefined;
+        const messageType = typeof input.payload['type'] === 'string' ? String(input.payload['type']) : undefined;
+        return this.wallet.enqueueMessage({
+            payload: input.payload,
+            priority: input.priority,
+            thid,
+            messageType,
+        });
+    }
+    /**
+     * Returns queued messages in current priority/FIFO processing order.
+     */
+    async listQueuedMessages() {
+        if (!this.wallet.listMessages) {
+            throw new Error('BackendMessageManagerMem requires wallet.listMessages().');
+        }
+        return this.wallet.listMessages();
+    }
+    /**
+     * Submits the next pending message through the injected transport and stores
+     * the decoded response by `thid` when one response envelope is returned.
+     */
+    async submitNextPendingMessage(recipientEncryptionJwk) {
+        if (!this.wallet.peekNextMessage) {
+            throw new Error('BackendMessageManagerMem requires wallet.peekNextMessage().');
+        }
+        if (!this.wallet.pack) {
+            throw new Error('BackendMessageManagerMem requires wallet.pack().');
+        }
+        if (!this.wallet.markMessageDelivered || !this.wallet.markMessageFailed) {
+            throw new Error('BackendMessageManagerMem requires wallet.markMessageDelivered() and wallet.markMessageFailed().');
+        }
+        const next = await this.wallet.peekNextMessage();
+        if (!next || next.status !== WalletQueueStatuses.Pending) {
+            throw new Error('BackendMessageManagerMem found no pending queued message.');
+        }
+        const envelope = await this.wallet.pack(next.payload, recipientEncryptionJwk, this.entityId);
+        const transportResult = await this.transport.submit({
+            message: next,
+            envelope,
+        });
+        if (!transportResult.accepted) {
+            const failed = await this.wallet.markMessageFailed(next.id, String(transportResult.errorMessage || 'transport rejected queued message'));
+            await this.persistMessageRecord(failed, envelope, undefined, {
+                transportStatus: 'failed',
+            });
+            return { message: failed };
+        }
+        const delivered = await this.wallet.markMessageDelivered(next.id);
+        if (!transportResult.responseEnvelope) {
+            await this.persistMessageRecord(delivered, envelope, undefined, {
+                transportStatus: 'submitted',
+                locationUrl: transportResult.locationUrl,
+                pollCount: 0,
+            });
+            return { message: delivered, pending: true };
+        }
+        if (!this.wallet.unpack) {
+            throw new Error('BackendMessageManagerMem requires wallet.unpack() to decode response envelopes.');
+        }
+        const unpacked = await this.wallet.unpack(transportResult.responseEnvelope, this.entityId);
+        const responseContent = clone(unpacked.content);
+        const thid = String(responseContent['thid'] || delivered.thid || delivered.id).trim();
+        const response = {
+            thid,
+            receivedAt: new Date().toISOString(),
+            content: responseContent,
+            meta: clone(unpacked.meta),
+        };
+        this.responsesByThread.set(thid, response);
+        await this.outboxRepository.putResponse(response);
+        await this.persistMessageRecord(delivered, envelope, response.thid, {
+            transportStatus: 'completed',
+        });
+        return {
+            message: delivered,
+            response,
+        };
+    }
+    /**
+     * Returns the latest decoded response for one DIDComm thread.
+     */
+    getResponseByThreadId(thid) {
+        const normalizedThreadId = String(thid || '').trim();
+        const stored = this.responsesByThread.get(normalizedThreadId);
+        return stored ? clone(stored) : undefined;
+    }
+    /**
+     * Lists submitted message history records preserved by the outbox repository.
+     */
+    async listOutboxHistory() {
+        return this.outboxRepository.listMessages();
+    }
+    /**
+     * Polls one previously submitted asynchronous message by id.
+     */
+    async pollSubmittedMessage(messageId) {
+        if (!this.transport.poll) {
+            throw new Error('BackendMessageManagerMem requires transport.poll() for asynchronous polling.');
+        }
+        const currentRecord = await this.requireOutboxRecord(messageId);
+        const pollResult = await this.transport.poll({
+            message: currentRecord,
+        });
+        if (pollResult.pending) {
+            const pendingRecord = await this.outboxRepository.putMessage({
+                ...currentRecord,
+                transportStatus: 'submitted',
+                pollCount: (currentRecord.pollCount || 0) + 1,
+                recordedAt: new Date().toISOString(),
+            });
+            return {
+                pending: true,
+                record: pendingRecord,
+            };
+        }
+        if (!pollResult.completed || !pollResult.responseEnvelope) {
+            const failedRecord = await this.outboxRepository.putMessage({
+                ...currentRecord,
+                transportStatus: pollResult.retryable ? 'submitted' : 'failed',
+                pollCount: (currentRecord.pollCount || 0) + 1,
+                recordedAt: new Date().toISOString(),
+            });
+            return {
+                pending: Boolean(pollResult.retryable),
+                record: failedRecord,
+            };
+        }
+        if (!this.wallet.unpack) {
+            throw new Error('BackendMessageManagerMem requires wallet.unpack() to decode polled response envelopes.');
+        }
+        const unpacked = await this.wallet.unpack(pollResult.responseEnvelope, this.entityId);
+        const responseContent = clone(unpacked.content);
+        const thid = String(responseContent['thid'] || currentRecord.thid || currentRecord.id).trim();
+        const response = {
+            thid,
+            receivedAt: new Date().toISOString(),
+            content: responseContent,
+            meta: clone(unpacked.meta),
+        };
+        this.responsesByThread.set(thid, response);
+        await this.outboxRepository.putResponse(response);
+        const completedRecord = await this.outboxRepository.putMessage({
+            ...currentRecord,
+            transportStatus: 'completed',
+            responseThid: response.thid,
+            pollCount: (currentRecord.pollCount || 0) + 1,
+            recordedAt: new Date().toISOString(),
+        });
+        return {
+            pending: false,
+            response,
+            record: completedRecord,
+        };
+    }
+    /**
+     * Reads one decoded response by thread id, first from memory and then from the repository.
+     */
+    async readResponseByThreadId(thid) {
+        const inMemory = this.getResponseByThreadId(thid);
+        if (inMemory)
+            return inMemory;
+        const stored = await this.outboxRepository.getLatestResponseByThreadId(thid);
+        if (stored) {
+            this.responsesByThread.set(String(stored.thid || '').trim(), clone(stored));
+        }
+        return stored;
+    }
+    async persistMessageRecord(message, envelope, responseThid, options = {}) {
+        await this.outboxRepository.putMessage({
+            id: message.id,
+            thid: message.thid,
+            messageType: message.messageType,
+            priority: message.priority,
+            status: message.status,
+            transportStatus: options.transportStatus,
+            recordedAt: new Date().toISOString(),
+            payload: clone(message.payload),
+            envelope,
+            ...(responseThid ? { responseThid } : {}),
+            ...(options.locationUrl ? { locationUrl: options.locationUrl } : {}),
+            ...(typeof options.pollCount === 'number' ? { pollCount: options.pollCount } : {}),
+        });
+    }
+    async requireOutboxRecord(messageId) {
+        const normalizedMessageId = String(messageId || '').trim();
+        const stored = await this.outboxRepository.getMessage(normalizedMessageId);
+        if (!stored) {
+            throw new Error(`BackendMessageManagerMem outbox record not found: ${normalizedMessageId}`);
+        }
+        return stored;
+    }
+}

package/dist/utils/bundle-didcomm-payload.d.ts

@@ -0,0 +1,29 @@
+import type { IDecodedDidcommPayload } from '../models/confidential-message';
+export declare const BundleDidcommEntryTypes: Readonly<{
+    readonly Batch: "Bundle-batch-request-v1.0";
+    readonly Document: "Bundle-document-request-v1.0";
+}>;
+/**
+ * Input contract for wrapping one bundle-like resource as one low-level
+ * DIDComm-style batch payload.
+ */
+export type BuildDidcommPayloadFromBundleInput = Readonly<{
+    bundle: Record<string, unknown>;
+    iss: string;
+    aud: string;
+    jti: string;
+    thid: string;
+    entryType?: string;
+}>;
+/**
+ * Builds one low-level DIDComm-style payload carrying one direct `Bundle`
+ * resource in `body.data[0].resource`.
+ *
+ * This path is meant for operational bundles such as employee/search/purge
+ * flows that travel as a bundle itself, not nested inside a `Communication`.
+ */
+export declare function buildDidcommPayloadFromBundle(input: BuildDidcommPayloadFromBundleInput): IDecodedDidcommPayload;
+/**
+ * Reads the first `Bundle` resource carried under `body.data[0].resource`.
+ */
+export declare function getFirstBundleResourceFromDidcommPayload(payload: IDecodedDidcommPayload): Record<string, unknown>;

package/dist/utils/bundle-didcomm-payload.js

@@ -0,0 +1,48 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+export const BundleDidcommEntryTypes = Object.freeze({
+    Batch: 'Bundle-batch-request-v1.0',
+    Document: 'Bundle-document-request-v1.0',
+});
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Builds one low-level DIDComm-style payload carrying one direct `Bundle`
+ * resource in `body.data[0].resource`.
+ *
+ * This path is meant for operational bundles such as employee/search/purge
+ * flows that travel as a bundle itself, not nested inside a `Communication`.
+ */
+export function buildDidcommPayloadFromBundle(input) {
+    return {
+        iss: String(input.iss || '').trim(),
+        aud: String(input.aud || '').trim(),
+        jti: String(input.jti || '').trim(),
+        thid: String(input.thid || '').trim(),
+        type: String(input.entryType || BundleDidcommEntryTypes.Batch).trim(),
+        body: {
+            data: [
+                {
+                    id: String(input.jti || '').trim(),
+                    type: String(input.entryType || BundleDidcommEntryTypes.Batch).trim(),
+                    resource: clone(input.bundle),
+                },
+            ],
+        },
+    };
+}
+/**
+ * Reads the first `Bundle` resource carried under `body.data[0].resource`.
+ */
+export function getFirstBundleResourceFromDidcommPayload(payload) {
+    const first = Array.isArray(payload?.body?.data)
+        ? payload.body.data[0]
+        : undefined;
+    const resource = first?.resource && typeof first.resource === 'object'
+        ? clone(first.resource)
+        : {};
+    if (String(resource['resourceType'] || '').trim() !== 'Bundle') {
+        throw new Error('getFirstBundleResourceFromDidcommPayload requires body.data[0].resource.resourceType = Bundle.');
+    }
+    return resource;
+}