gdc-sdk-front-ts 0.6.2 → 0.6.6

package/dist/gdc-common-utils-ts/src/utils/didcomm-submit.js

@@ -0,0 +1,81 @@
+import { resolveDidcommSubmissionPlan } from './didcomm-submit-policy';
+function getHeaderValue(headers, name) {
+    if (!headers || typeof headers.get !== 'function') {
+        return undefined;
+    }
+    const value = headers.get(name);
+    return value == null ? undefined : value;
+}
+async function parseBody(response) {
+    if (typeof response.text === 'function') {
+        const raw = await response.text();
+        if (!raw)
+            return undefined;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return undefined;
+}
+/**
+ * Submits a DIDComm payload using either plaintext or encrypted transport,
+ * depending on the resolved submission policy.
+ *
+ * @param input.mode Communication mode that drives plain vs encrypted submission.
+ * @param input.url Target endpoint URL.
+ * @param input.payload DIDComm payload body to submit.
+ * @param input.defaultHeaders Optional extra request headers.
+ * @param input.bearerToken Optional bearer token.
+ * @param input.recipientEncryptionJwk Recipient public key for encrypted mode.
+ * @param input.fetcher Runtime fetch-like implementation.
+ * @param input.signCompactJws Callback used to sign plaintext claims before encryption.
+ * @param input.encryptCompactJwe Callback used to encrypt the signed JWS.
+ */
+export async function submitDidcomm(input) {
+    const plan = resolveDidcommSubmissionPlan(input.mode, {
+        hasRecipientEncryptionJwk: !!input.recipientEncryptionJwk,
+    });
+    const headers = {
+        ...(input.defaultHeaders ?? {}),
+        Accept: 'application/json, application/didcomm-plaintext+json, */*',
+    };
+    let body;
+    let contentType;
+    if (plan.submitKind === 'plain') {
+        contentType = 'application/didcomm-plaintext+json';
+        body = JSON.stringify(input.payload);
+    }
+    else {
+        if (!input.signCompactJws) {
+            throw new Error('Encrypted DIDComm submission requires signCompactJws callback.');
+        }
+        if (!input.encryptCompactJwe) {
+            throw new Error('Encrypted DIDComm submission requires encryptCompactJwe callback.');
+        }
+        if (!input.recipientEncryptionJwk) {
+            throw new Error('Encrypted DIDComm submission requires recipientEncryptionJwk.');
+        }
+        const compactJws = await input.signCompactJws(input.payload);
+        body = await input.encryptCompactJwe(compactJws, input.recipientEncryptionJwk);
+        contentType = 'application/didcomm-encrypted+json';
+    }
+    headers['Content-Type'] = contentType;
+    if (input.bearerToken) {
+        headers.Authorization = `Bearer ${input.bearerToken}`;
+    }
+    const response = await input.fetcher(input.url, {
+        method: 'POST',
+        headers,
+        body,
+    });
+    return {
+        status: response.status,
+        location: getHeaderValue(response.headers, 'location'),
+        body: await parseBody(response),
+        submitKind: plan.submitKind,
+        contentType,
+    };
+}

package/dist/gdc-common-utils-ts/src/utils/didcomm.d.ts

@@ -0,0 +1,60 @@
+import { DidCommPayload, DidCommAttachment } from '../models/comm';
+export { DidCommAttachment } from '../models/comm';
+/**
+ * Creates a DIDComm message instance.
+ */
+export declare class DidCommMessage implements DidCommPayload {
+    id: string;
+    type: string;
+    from?: string;
+    to?: string[];
+    thid?: string;
+    pthid?: string;
+    created_time?: number;
+    expires_time?: number;
+    body: {
+        [key: string]: any;
+    };
+    attachments?: DidCommAttachment[];
+    /**
+     * Creates an empty DIDComm message with generated `id`, empty `type`,
+     * and empty `body`.
+     */
+    constructor();
+}
+/**
+ * Prepares a DIDComm request message.
+ *
+ * @param type DIDComm message type.
+ * @param body DIDComm body payload.
+ * @param attachments Optional DIDComm attachments.
+ */
+export declare function prepareDidCommRequest(type: string, body?: any, attachments?: DidCommAttachment[]): DidCommMessage;
+/**
+ * Includes VP token in DIDComm message body.
+ *
+ * @param message DIDComm message to mutate.
+ * @param vpToken VP token string to place under `body.vp_token`.
+ */
+export declare function includeVpTokenInMessage(message: DidCommMessage, vpToken: string): void;
+/**
+ * Includes file bytes as base64 attachment in DIDComm message.
+ *
+ * @param message DIDComm message to mutate.
+ * @param fileBytes Raw file bytes.
+ * @param mediaType Attachment media type.
+ * @param id Attachment identifier.
+ */
+export declare function includeFileInMessage(message: DidCommMessage, fileBytes: Uint8Array, mediaType: string, id: string): void;
+/**
+ * Gets THID from DIDComm message.
+ *
+ * @param message DIDComm message.
+ */
+export declare function getThidFromMessage(message: DidCommMessage): string;
+/**
+ * Gets data results from polling response body.
+ *
+ * @param response DIDComm response carrying `body.data`.
+ */
+export declare function getDataResults(response: DidCommMessage): any[];

package/dist/gdc-common-utils-ts/src/utils/didcomm.js

@@ -0,0 +1,78 @@
+/**
+ * Generates a random ID for DIDComm messages.
+ */
+function generateId() {
+    return Math.random().toString(36).substr(2, 9);
+}
+/**
+ * Creates a DIDComm message instance.
+ */
+export class DidCommMessage {
+    /**
+     * Creates an empty DIDComm message with generated `id`, empty `type`,
+     * and empty `body`.
+     */
+    constructor() {
+        this.id = generateId();
+        this.type = '';
+        this.body = {};
+    }
+}
+/**
+ * Prepares a DIDComm request message.
+ *
+ * @param type DIDComm message type.
+ * @param body DIDComm body payload.
+ * @param attachments Optional DIDComm attachments.
+ */
+export function prepareDidCommRequest(type, body = {}, attachments = []) {
+    const message = new DidCommMessage();
+    message.type = type;
+    message.body = body;
+    message.attachments = attachments;
+    message.thid = message.id; // Set thid to id for new threads
+    return message;
+}
+/**
+ * Includes VP token in DIDComm message body.
+ *
+ * @param message DIDComm message to mutate.
+ * @param vpToken VP token string to place under `body.vp_token`.
+ */
+export function includeVpTokenInMessage(message, vpToken) {
+    message.body.vp_token = vpToken;
+}
+/**
+ * Includes file bytes as base64 attachment in DIDComm message.
+ *
+ * @param message DIDComm message to mutate.
+ * @param fileBytes Raw file bytes.
+ * @param mediaType Attachment media type.
+ * @param id Attachment identifier.
+ */
+export function includeFileInMessage(message, fileBytes, mediaType, id) {
+    const base64 = Buffer.from(fileBytes).toString('base64');
+    if (!message.attachments)
+        message.attachments = [];
+    message.attachments.push({
+        id,
+        media_type: mediaType,
+        data: { base64 }
+    });
+}
+/**
+ * Gets THID from DIDComm message.
+ *
+ * @param message DIDComm message.
+ */
+export function getThidFromMessage(message) {
+    return message.thid || message.id;
+}
+/**
+ * Gets data results from polling response body.
+ *
+ * @param response DIDComm response carrying `body.data`.
+ */
+export function getDataResults(response) {
+    return response.body?.data || [];
+}

package/dist/gdc-common-utils-ts/src/utils/discovery-normalization.d.ts

@@ -0,0 +1,28 @@
+import { DidResolutionResult } from '../models/did';
+/**
+ * Canonical runtime-neutral discovery result used by SDK and GW code after
+ * normalizing metadata from ICA, node operators, or provider catalogs.
+ */
+export type NormalizedDiscoveryMetadata = DidResolutionResult & {
+    /** Origin of the normalized metadata payload. */
+    source: 'ica' | 'node-operator' | 'service-provider';
+};
+/**
+ * Normalizes ICA discovery metadata into the shared DID/discovery result shape.
+ *
+ * The input can be partial. When no DID Document is supplied, a minimal synthetic
+ * one is created from `did`/`issuer` so downstream code still has a stable carrier.
+ */
+export declare function normalizeIcaDiscoveryMetadata(metadata: Record<string, unknown>): NormalizedDiscoveryMetadata;
+/**
+ * Normalizes node-operator discovery metadata into the shared DID/discovery result shape.
+ */
+export declare function normalizeNodeOperatorDiscoveryMetadata(metadata: Record<string, unknown>): NormalizedDiscoveryMetadata;
+/**
+ * Normalizes a service-provider or DCAT-style entry into the shared DID/discovery result shape.
+ *
+ * This helper extracts well-known operational URLs such as the DID Document URL,
+ * JWKS URL, and SMART token endpoint from `service[]` instead of rebuilding them
+ * from public aliases or assumed base URLs.
+ */
+export declare function normalizeServiceProviderEntry(entry: Record<string, unknown>): NormalizedDiscoveryMetadata;

package/dist/gdc-common-utils-ts/src/utils/discovery-normalization.js

@@ -0,0 +1,64 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { getDidDocumentEndpoint, getJwksServiceEndpoint, getSmartTokenEndpoint, toDidResolutionResult } from './did-resolution';
+function ensureDidDocument(metadata, fallbackDid) {
+    const didDocument = metadata.didDocument;
+    if (didDocument?.id) {
+        return didDocument;
+    }
+    return {
+        '@context': 'https://www.w3.org/ns/did/v1',
+        id: String(metadata.did || metadata.issuer || metadata.providerDid || fallbackDid || '').trim(),
+        service: [],
+    };
+}
+function attachMetadata(result, metadata) {
+    return {
+        ...result,
+        issuer: typeof metadata.issuer === 'string' ? metadata.issuer : result.issuer,
+        jwksUri: typeof metadata.jwks_uri === 'string' ? metadata.jwks_uri : result.jwksUri,
+        metadata,
+    };
+}
+/**
+ * Normalizes ICA discovery metadata into the shared DID/discovery result shape.
+ *
+ * The input can be partial. When no DID Document is supplied, a minimal synthetic
+ * one is created from `did`/`issuer` so downstream code still has a stable carrier.
+ */
+export function normalizeIcaDiscoveryMetadata(metadata) {
+    const didDocument = ensureDidDocument(metadata, metadata.issuer);
+    return {
+        ...attachMetadata(toDidResolutionResult(didDocument), metadata),
+        source: 'ica',
+    };
+}
+/**
+ * Normalizes node-operator discovery metadata into the shared DID/discovery result shape.
+ */
+export function normalizeNodeOperatorDiscoveryMetadata(metadata) {
+    const didDocument = ensureDidDocument(metadata, metadata.operatorDid);
+    return {
+        ...attachMetadata(toDidResolutionResult(didDocument), metadata),
+        source: 'node-operator',
+    };
+}
+/**
+ * Normalizes a service-provider or DCAT-style entry into the shared DID/discovery result shape.
+ *
+ * This helper extracts well-known operational URLs such as the DID Document URL,
+ * JWKS URL, and SMART token endpoint from `service[]` instead of rebuilding them
+ * from public aliases or assumed base URLs.
+ */
+export function normalizeServiceProviderEntry(entry) {
+    const didDocument = ensureDidDocument(entry, entry.providerDid);
+    const result = attachMetadata(toDidResolutionResult(didDocument), entry);
+    const jwks = entry.jwks;
+    return {
+        ...result,
+        jwks,
+        didDocumentUrl: getDidDocumentEndpoint(didDocument),
+        jwksUri: result.jwksUri || getJwksServiceEndpoint(didDocument),
+        smartTokenEndpoint: getSmartTokenEndpoint(didDocument),
+        source: 'service-provider',
+    };
+}

package/dist/gdc-common-utils-ts/src/utils/fhir-cid.d.ts

@@ -0,0 +1,60 @@
+export type FhirCanonicalizationOptions = {
+    /**
+     * Removes `meta.versionId` from canonical input to avoid self-referential hashes.
+     * Default: true.
+     */
+    stripMetaVersionId?: boolean;
+    /**
+     * Removes top-level narrative `text` if present.
+     * Default: false.
+     */
+    stripNarrativeText?: boolean;
+    /**
+     * Removes nested `id` fields in backbone elements (resource root `id` is preserved).
+     * Default: false.
+     */
+    stripNestedElementIds?: boolean;
+};
+export type FhirCidBuildOptions = {
+    canonicalization?: FhirCanonicalizationOptions;
+    /**
+     * CID multicodec for canonical FHIR JSON payloads.
+     * `0x0129` is DAG-JSON.
+     */
+    multicodecCode?: number;
+};
+export type FhirCidResult = {
+    cid: string;
+    versionId: string;
+    canonicalJson: string;
+    digestHex: string;
+};
+export type ClaimsCidResult = {
+    cid: string;
+    canonicalJson: string;
+    digestHex: string;
+};
+export type FhirCidVersionMapping = {
+    resourceType?: string;
+    resourceId?: string;
+    fullUrl?: string;
+    cid: string;
+    versionId: string;
+};
+export declare function canonicalizeFhirResource(resource: Record<string, unknown>, options?: FhirCanonicalizationOptions): string;
+export declare function buildCidV1FromCanonicalJson(canonicalJson: string, multicodecCode?: number): FhirCidResult;
+export declare function canonicalizeClaimsForCid(claims: Record<string, unknown>): string;
+export declare function claimsToCid(claims: Record<string, unknown>): ClaimsCidResult;
+export declare function assignCidToClaimsId(claims: Record<string, unknown>): {
+    claims: Record<string, unknown>;
+    cid: string;
+};
+export declare function fhirResourceToCid(resource: Record<string, unknown>, options?: FhirCidBuildOptions): FhirCidResult;
+export declare function assignCidToFhirResourceVersionId(resource: Record<string, unknown>, options?: FhirCidBuildOptions): {
+    resource: Record<string, unknown>;
+    mapping: FhirCidVersionMapping;
+};
+export declare function assignCidToFhirBundleEntries(bundle: Record<string, unknown>, options?: FhirCidBuildOptions): {
+    bundle: Record<string, unknown>;
+    mappings: FhirCidVersionMapping[];
+};

package/dist/gdc-common-utils-ts/src/utils/fhir-cid.js

@@ -0,0 +1,152 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { sha256 } from '@noble/hashes/sha2.js';
+import { utf8ToBytes } from '@noble/hashes/utils.js';
+import { encodeMultibase58btc } from './multibase58.js';
+const DEFAULT_MULTICODEC_DAG_JSON = 0x0129;
+const MULTIHASH_SHA2_256_CODE = 0x12;
+const MULTIHASH_SHA2_256_LEN = 32;
+const CID_V1 = 0x01;
+function toHex(bytes) {
+    return Buffer.from(bytes).toString('hex');
+}
+function encodeVarint(value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`Invalid varint value: ${value}`);
+    }
+    const out = [];
+    let n = value >>> 0;
+    while (n >= 0x80) {
+        out.push((n & 0x7f) | 0x80);
+        n >>>= 7;
+    }
+    out.push(n);
+    return Uint8Array.from(out);
+}
+function concatBytes(...parts) {
+    const total = parts.reduce((acc, part) => acc + part.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+function canonicalizeValue(value, options, depth) {
+    if (Array.isArray(value)) {
+        // FHIR array order can be significant; preserve order, canonicalize each element.
+        return value.map((entry) => canonicalizeValue(entry, options, depth + 1));
+    }
+    if (value && typeof value === 'object') {
+        const asRecord = value;
+        const keys = Object.keys(asRecord).sort();
+        const out = {};
+        for (const key of keys) {
+            if (options.stripNarrativeText && depth === 0 && key === 'text') {
+                continue;
+            }
+            if (options.stripNestedElementIds && depth > 0 && key === 'id') {
+                continue;
+            }
+            let next = asRecord[key];
+            if (next === undefined)
+                continue;
+            if (options.stripMetaVersionId && key === 'meta' && next && typeof next === 'object' && !Array.isArray(next)) {
+                const metaRecord = { ...next };
+                delete metaRecord.versionId;
+                next = metaRecord;
+            }
+            out[key] = canonicalizeValue(next, options, depth + 1);
+        }
+        return out;
+    }
+    return value;
+}
+export function canonicalizeFhirResource(resource, options = {}) {
+    const normalizedOptions = {
+        stripMetaVersionId: options.stripMetaVersionId ?? true,
+        stripNarrativeText: options.stripNarrativeText ?? false,
+        stripNestedElementIds: options.stripNestedElementIds ?? false,
+    };
+    const normalized = canonicalizeValue(resource, normalizedOptions, 0);
+    return JSON.stringify(normalized);
+}
+export function buildCidV1FromCanonicalJson(canonicalJson, multicodecCode = DEFAULT_MULTICODEC_DAG_JSON) {
+    const digest = sha256(utf8ToBytes(canonicalJson));
+    const multihash = concatBytes(Uint8Array.from([MULTIHASH_SHA2_256_CODE, MULTIHASH_SHA2_256_LEN]), digest);
+    const cidBytes = concatBytes(encodeVarint(CID_V1), encodeVarint(multicodecCode), multihash);
+    const cid = encodeMultibase58btc(cidBytes);
+    return {
+        cid,
+        versionId: cid,
+        canonicalJson,
+        digestHex: toHex(digest),
+    };
+}
+export function canonicalizeClaimsForCid(claims) {
+    const stripped = { ...(claims || {}) };
+    delete stripped['@context'];
+    delete stripped['@type'];
+    delete stripped['@id'];
+    const normalized = canonicalizeValue(stripped, {
+        stripMetaVersionId: false,
+        stripNarrativeText: false,
+        stripNestedElementIds: false,
+    }, 0);
+    return JSON.stringify(normalized);
+}
+export function claimsToCid(claims) {
+    const canonicalJson = canonicalizeClaimsForCid(claims);
+    const cidData = buildCidV1FromCanonicalJson(canonicalJson, DEFAULT_MULTICODEC_DAG_JSON);
+    return {
+        cid: cidData.cid,
+        canonicalJson,
+        digestHex: cidData.digestHex,
+    };
+}
+export function assignCidToClaimsId(claims) {
+    const out = JSON.parse(JSON.stringify(claims || {}));
+    const { cid } = claimsToCid(out);
+    out['@id'] = cid;
+    return {
+        claims: out,
+        cid,
+    };
+}
+export function fhirResourceToCid(resource, options = {}) {
+    const canonicalJson = canonicalizeFhirResource(resource, options.canonicalization);
+    return buildCidV1FromCanonicalJson(canonicalJson, options.multicodecCode ?? DEFAULT_MULTICODEC_DAG_JSON);
+}
+export function assignCidToFhirResourceVersionId(resource, options = {}) {
+    const cid = fhirResourceToCid(resource, options);
+    const out = JSON.parse(JSON.stringify(resource));
+    const meta = (out.meta && typeof out.meta === 'object' && !Array.isArray(out.meta))
+        ? { ...out.meta }
+        : {};
+    meta.versionId = cid.versionId;
+    out.meta = meta;
+    return {
+        resource: out,
+        mapping: {
+            resourceType: String(out.resourceType || ''),
+            resourceId: out.id ? String(out.id) : undefined,
+            cid: cid.cid,
+            versionId: cid.versionId,
+        },
+    };
+}
+export function assignCidToFhirBundleEntries(bundle, options = {}) {
+    const out = JSON.parse(JSON.stringify(bundle));
+    const entries = Array.isArray(out.entry) ? out.entry : [];
+    const mappings = [];
+    for (const entry of entries) {
+        const resource = entry?.resource;
+        if (!resource || typeof resource !== 'object' || Array.isArray(resource))
+            continue;
+        const assigned = assignCidToFhirResourceVersionId(resource, options);
+        entry.resource = assigned.resource;
+        assigned.mapping.fullUrl = entry.fullUrl ? String(entry.fullUrl) : undefined;
+        mappings.push(assigned.mapping);
+    }
+    return { bundle: out, mappings };
+}

package/dist/gdc-common-utils-ts/src/utils/fhir-validator.d.ts

@@ -0,0 +1,61 @@
+export type FhirVersion = 'r4' | 'r5' | string;
+export type FhirValidationIssue = {
+    severity: 'error' | 'warning';
+    code: string;
+    diagnostics: string;
+    expression?: string;
+};
+export type FhirValidationResult = {
+    ok: boolean;
+    issues: FhirValidationIssue[];
+};
+export type FhirValidatorAdapter = {
+    /**
+     * Stable adapter id for observability/configuration.
+     * Example: `basic`, `hl7-official-cli`, `hapi`.
+     */
+    id: string;
+    /**
+     * Returns true when this adapter can validate the requested FHIR version.
+     */
+    supports(version: FhirVersion): boolean;
+    /**
+     * Validates one resource and returns OperationOutcome-like issues.
+     */
+    validate(resource: Record<string, unknown>, version: FhirVersion): Promise<FhirValidationResult> | FhirValidationResult;
+};
+/**
+ * Registers a custom FHIR validator adapter.
+ * Adapters are checked in registration order.
+ *
+ * @param adapter Validator adapter to register.
+ */
+export declare function registerFhirValidatorAdapter(adapter: FhirValidatorAdapter): void;
+/**
+ * Clears all registered adapters.
+ * Intended for tests or explicit runtime reconfiguration.
+ */
+export declare function clearFhirValidatorAdapters(): void;
+/**
+ * Returns currently registered adapters (read-only copy).
+ */
+export declare function listFhirValidatorAdapters(): FhirValidatorAdapter[];
+/**
+ * Validates a FHIR resource using the first registered adapter that supports the requested version.
+ * Falls back to built-in structural validation when no adapter matches.
+ *
+ * This utility is intentionally adapter-based so SDK/GW can share one validation entrypoint while
+ * keeping the formal validator implementation pluggable per deployment.
+ * @param resource FHIR resource candidate.
+ * @param version Requested FHIR version, defaults to `r4`.
+ */
+export declare function validateFhirResource(resource: Record<string, unknown>, version?: FhirVersion): Promise<FhirValidationResult>;
+/**
+ * Minimal built-in structural validation.
+ * This does not replace a formal HL7 profile validator; it provides a safe baseline
+ * and deterministic checks for common gateway constraints.
+ *
+ * @param resource FHIR resource candidate.
+ * @param _version Requested FHIR version, defaults to `r4`.
+ */
+export declare function validateFhirResourceBasic(resource: Record<string, unknown>, _version?: FhirVersion): FhirValidationResult;

package/dist/gdc-common-utils-ts/src/utils/fhir-validator.js

@@ -0,0 +1,91 @@
+const validators = [];
+/**
+ * Registers a custom FHIR validator adapter.
+ * Adapters are checked in registration order.
+ *
+ * @param adapter Validator adapter to register.
+ */
+export function registerFhirValidatorAdapter(adapter) {
+    validators.push(adapter);
+}
+/**
+ * Clears all registered adapters.
+ * Intended for tests or explicit runtime reconfiguration.
+ */
+export function clearFhirValidatorAdapters() {
+    validators.length = 0;
+}
+/**
+ * Returns currently registered adapters (read-only copy).
+ */
+export function listFhirValidatorAdapters() {
+    return [...validators];
+}
+/**
+ * Validates a FHIR resource using the first registered adapter that supports the requested version.
+ * Falls back to built-in structural validation when no adapter matches.
+ *
+ * This utility is intentionally adapter-based so SDK/GW can share one validation entrypoint while
+ * keeping the formal validator implementation pluggable per deployment.
+ * @param resource FHIR resource candidate.
+ * @param version Requested FHIR version, defaults to `r4`.
+ */
+export async function validateFhirResource(resource, version = 'r4') {
+    const adapter = validators.find((item) => item.supports(version));
+    if (adapter)
+        return adapter.validate(resource, version);
+    return validateFhirResourceBasic(resource, version);
+}
+/**
+ * Minimal built-in structural validation.
+ * This does not replace a formal HL7 profile validator; it provides a safe baseline
+ * and deterministic checks for common gateway constraints.
+ *
+ * @param resource FHIR resource candidate.
+ * @param _version Requested FHIR version, defaults to `r4`.
+ */
+export function validateFhirResourceBasic(resource, _version = 'r4') {
+    const issues = [];
+    const resourceType = String(resource?.resourceType || '').trim();
+    if (!resourceType) {
+        issues.push({
+            severity: 'error',
+            code: 'required',
+            diagnostics: 'Missing required field: resourceType.',
+            expression: 'resourceType',
+        });
+    }
+    if (resourceType === 'Communication') {
+        const status = String(resource?.status || '').trim();
+        if (!status) {
+            issues.push({
+                severity: 'error',
+                code: 'required',
+                diagnostics: 'Communication.status is required.',
+                expression: 'Communication.status',
+            });
+        }
+        const payload = resource?.payload;
+        if (Array.isArray(payload) && payload.length > 1) {
+            issues.push({
+                severity: 'warning',
+                code: 'business-rule',
+                diagnostics: 'Gateway convention recommends one payload per Communication.',
+                expression: 'Communication.payload',
+            });
+        }
+        const note = resource?.note;
+        if (Array.isArray(note) && note.length > 1) {
+            issues.push({
+                severity: 'warning',
+                code: 'business-rule',
+                diagnostics: 'Gateway convention recommends one note per Communication.',
+                expression: 'Communication.note',
+            });
+        }
+    }
+    return {
+        ok: issues.every((issue) => issue.severity !== 'error'),
+        issues,
+    };
+}