gdc-sdk-node-ts 2.1.4 → 2.3.0

package/dist/professional-backend-runtime.js

@@ -38,4 +38,11 @@ export class ProfessionalBackendRuntime {
     getLatestIps(profile, ctx, input) {
         return profile.sdk.getLatestIps(ctx, input);
     }
+    /**
+     * Registers one FHIR resource or raw artifact on blockchain before it is
+     * attached to a communication.
+     */
+    registerBlockchainArtifactAndUpdateIndex(profile, ctx, input) {
+        return profile.sdk.registerBlockchainArtifactAndUpdateIndex(ctx, input);
+    }
 }

package/dist/profile-workspace.d.ts

@@ -1,4 +1,5 @@
 import { CommunicationAttachedBundleSession, IndividualBundleVault, buildVitalSignObservationClaims, createSummaryOperationRequestParameters, createSummaryOperationRequestParametersResource, summarizeClinicalBundle, toClinicalResourceExpandedViews, type BuildVitalSignObservationClaimsInput } from 'gdc-common-utils-ts';
+import type { BundleEntry, BundleJsonApi } from 'gdc-common-utils-ts/models/bundle';
 import type { BackendOrganizationControllerProfile, BackendProfessionalProfile } from './backend-profile-runtime.js';
 export type IpsRequestDraft = Readonly<{
     subjectId: string;
@@ -29,6 +30,17 @@ declare class ProfessionalSubjectIpsWorkspace {
     processResponseBundleIps(body: unknown): ProcessedClinicalBundleResponse;
     rememberResponseBundleIps(body: unknown): Promise<IndividualBundleVault>;
     addVitalSign(input: BuildVitalSignObservationClaimsInput): Promise<IndividualBundleVault>;
+    buildVitalSignBatchCommunicationFromSearchResponse(searchResponse: unknown, selectedResourceIds?: readonly string[]): import("./resource-operations.js").CommunicationIngestionInput;
+    buildBlockchainArtifactBundleFromSearchResponse(searchResponse: unknown, selectedResourceIds?: readonly string[]): Readonly<{
+        availableResourceIds: readonly string[];
+        anchoredResourceIds: readonly string[];
+        unanchoredResourceIds: readonly string[];
+        selectedResourceIds: readonly string[];
+        missingResourceIds: readonly string[];
+        returnedCount: number;
+        totalCount: number;
+        bundle: BundleJsonApi<BundleEntry>;
+    }>;
     get cache(): IndividualBundleVault;
 }
 declare class ProfessionalSubjectWorkspace {

package/dist/profile-workspace.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { CommunicationAttachedBundleSession, IndividualBundleVault, VaultMemRepository, buildVitalSignObservationClaims, createConsentAccessEditor, createInvoiceBundleEditor, createSummaryOperationRequestParameters, createSummaryOperationRequestParametersResource, createSummaryOperationRequestReferencePath, readEmployeeSearchResults, summarizeClinicalBundle, summarizeLicenseListRecords, toClinicalResourceExpandedViews, } from 'gdc-common-utils-ts';
+import { buildBlockchainArtifactBundleFromSearchResponse, buildVitalSignBatchCommunicationFromSearchResponse } from './resource-operations.js';
 function normalizeSectionList(sectionList) {
     return Array.from(new Set((sectionList || []).map((item) => String(item || '').trim()).filter(Boolean)));
 }
@@ -69,6 +70,20 @@ class ProfessionalSubjectIpsWorkspace {
         await this.bundleVault.upsertVitalSign(input);
         return this.bundleVault;
     }
+    buildVitalSignBatchCommunicationFromSearchResponse(searchResponse, selectedResourceIds) {
+        return buildVitalSignBatchCommunicationFromSearchResponse({
+            subject: this.subjectId,
+            searchResponse,
+            selectedResourceIds,
+        });
+    }
+    buildBlockchainArtifactBundleFromSearchResponse(searchResponse, selectedResourceIds) {
+        return buildBlockchainArtifactBundleFromSearchResponse({
+            subject: this.subjectId,
+            searchResponse,
+            selectedResourceIds,
+        });
+    }
     get cache() {
         return this.bundleVault;
     }

package/dist/resource-operations.d.ts

@@ -1,6 +1,8 @@
+import type { DeviceAppType } from 'gdc-common-utils-ts/constants/device';
 import type { LicenseOfferSearchState, LicenseOrderSearchState } from 'gdc-common-utils-ts/utils/license-commercial-search';
 import type { LicenseListSearchState } from 'gdc-common-utils-ts/utils/license-list-search';
-import type { BundleSearchQuery, CommunicationInput, DateRange, EmployeeSearchValue, IndividualOrganizationLifecycleInput } from 'gdc-sdk-core-ts';
+import type { BundleSearchQuery, CommMsgExtendedCommunicationOutboxJob, CommunicationOutboxJob, CommunicationInput, DateRange, EmployeeSearchValue, IndividualOrganizationLifecycleInput, TransportProfile } from 'gdc-sdk-core-ts';
+import type { BundleEntry, BundleJsonApi } from 'gdc-common-utils-ts/models/bundle';
 import type { SubmitAndPollResult } from './orchestration/client-port.js';
 import type { RouteContext } from './individual-onboarding.js';
 export type OrganizationEmployeeCreationInput = {
@@ -84,6 +86,52 @@ export type LicenseListRuntimeSearchInput = {
         intervalMs?: number;
     };
 };
+/**
+ * Reserves one individual-organization seat for an existing RelatedPerson.
+ *
+ * Only FHIR v3 RoleCode members belong here. ISCO professionals receive
+ * Consent/Communication access but keep using the license paid by their
+ * professional organization.
+ */
+export type IndividualMemberLicenseInvitationInput = {
+    ownerOrganizationId: string;
+    /** Exact card/subject DID granted after the invitation is accepted. */
+    subjectDid: string;
+    relatedPersonId: string;
+    invitationId: string;
+    role: string;
+    email?: string;
+    telephone?: string;
+    type?: DeviceAppType;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+/** Adds zero-cost member seats to one individual organization. */
+export type IndividualMemberLicenseAddInput = {
+    ownerOrganizationId: string;
+    quantity: number;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+/** Input shared by invitation acceptance, deactivation and release. */
+export type IndividualMemberLicenseTransitionInput = {
+    /** Required for controller deactivation/release; acceptance resolves by code. */
+    ownerOrganizationId?: string;
+    activationCode: string;
+    subjectId?: string;
+    verifiedActorIdentifier?: string;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
 /**
  * Runtime search/list input for commercial offer read-models exposed through
  * actor facades.
@@ -143,6 +191,13 @@ export type IpsOrFhirImportInput = {
     };
 };
 export type RelatedPersonUpsertInput = {
+    /**
+     * Canonical RelatedPerson bundle. Keep kinship/legal relationship in
+     * `RelatedPerson.relationship`; the optional GDC `RelatedPerson.role`
+     * extension may carry comma-separated functions such as
+     * `CAREGIVER,ECON,DEPEN,BILL`.
+     * Access decisions such as PERMITTED do not belong in either claim.
+     */
     relatedPersonPayload: {
         thid?: string;
     } & Record<string, unknown>;
@@ -152,7 +207,22 @@ export type RelatedPersonUpsertInput = {
     };
 };
 export type CommunicationIngestionInput = {
-    communicationPayload: CommunicationInput & Record<string, unknown>;
+    /**
+     * Preferred claims-first job created by
+     * `createCommunicationOutboxJobFromCommMsgExtendedDraft(...)`. Legacy
+     * `createOutboxJobFromDraft(...)` jobs remain accepted temporarily.
+     */
+    communicationJob?: CommunicationOutboxJob | CommMsgExtendedCommunicationOutboxJob;
+    /**
+     * Compatibility input for callers that already own one GW envelope.
+     * New application code should pass `communicationJob` instead.
+     */
+    communicationPayload?: CommunicationInput & Record<string, unknown>;
+    /** Overrides the client default only for this clinical submission. */
+    transportProfile?: TransportProfile;
+    /** Clinical representation rendered from canonical claims: built-in `api`/`r4` or an extension format. */
+    clinicalFormat?: string;
+    /** @deprecated Use `clinicalFormat`. This value selects representation and route, not transport. */
     pathFormatSegment?: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4' | 'api' | 'r4' | 'fhir.r4';
     autoConvertClaimsToFhirR4?: boolean;
     pollOptions?: {
@@ -160,6 +230,53 @@ export type CommunicationIngestionInput = {
         intervalMs?: number;
     };
 };
+export type BlockchainArtifactRegistrationInput = {
+    subject: string;
+    resource?: Record<string, unknown>;
+    contentDataBase64?: string;
+    contentType?: string;
+    identifier?: string;
+    title?: string;
+    description?: string;
+    date?: string;
+    location?: string;
+    language?: string;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+export type BlockchainArtifactSearchSelectionInput = Readonly<{
+    subject: string;
+    searchResponse: unknown;
+    selectedResourceIds?: readonly string[];
+}>;
+export type BlockchainArtifactSearchSelectionResult = Readonly<{
+    availableResourceIds: readonly string[];
+    anchoredResourceIds: readonly string[];
+    unanchoredResourceIds: readonly string[];
+    selectedResourceIds: readonly string[];
+    missingResourceIds: readonly string[];
+    returnedCount: number;
+    totalCount: number;
+    bundle: BundleJsonApi<BundleEntry>;
+}>;
+export type VitalSignBatchCommunicationFromSearchResponseInput = Readonly<{
+    subject: string;
+    searchResponse: unknown;
+    selectedResourceIds?: readonly string[];
+    sender?: string;
+    recipient?: string | string[];
+    sent?: string;
+    status?: string;
+    noteText?: string;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+}>;
 /**
  * Runtime participant query for `Communication/_search`.
  *
@@ -202,6 +319,8 @@ export type ClinicalBundleSearchInput = Omit<BundleSearchQuery, 'section' | 'sea
         timeoutMs?: number;
         intervalMs?: number;
     };
+    /** Overrides the client default for this subject-scoped clinical read. */
+    transportProfile?: TransportProfile;
 };
 export type ConsentActorTargetInput = string | string[] | {
     identifier?: string;
@@ -433,6 +552,40 @@ export declare function searchIndividualLicensesWithDeps(routeCtx: RouteContext,
  * search route without mandatory filters.
  */
 export declare function listIndividualLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput | undefined, deps: Parameters<typeof searchIndividualLicensesWithDeps>[2]): Promise<SubmitAndPollResult>;
+type IndividualLicenseMutationDeps = {
+    individualLicenseActionPath: (ctx: RouteContext, action: string) => string;
+    individualLicenseActionPollPath: (ctx: RouteContext, action: string) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+};
+/**
+ * Reserves one available household/member seat for a selected contact.
+ *
+ * Ordered application flow:
+ * 1. Create/select RelatedPerson.
+ * 2. Author Consent rules.
+ * 3. Call this operation only for a FHIR v3 RoleCode member.
+ * 4. Put the returned activation code in the invitation Communication.
+ */
+export declare function issueIndividualMemberLicenseWithDeps(routeCtx: RouteContext, input: IndividualMemberLicenseInvitationInput, deps: IndividualLicenseMutationDeps): Promise<SubmitAndPollResult>;
+/**
+ * Adds free seats without creating contacts, permissions or invitations.
+ * Price zero is explicit so GW never routes this MVP operation through a
+ * payment-proof branch.
+ */
+export declare function addFreeIndividualMemberLicensesWithDeps(routeCtx: RouteContext, input: IndividualMemberLicenseAddInput, deps: IndividualLicenseMutationDeps): Promise<SubmitAndPollResult>;
+/**
+ * Accepts, deactivates or releases one member seat.
+ *
+ * `_accept` needs the Firebase/BFF verified recipient plus the authenticated
+ * subject id. `_release` remains backend-guarded and cannot free an active
+ * member directly.
+ */
+export declare function transitionIndividualMemberLicenseWithDeps(routeCtx: RouteContext, action: '_accept' | '_deactivate' | '_release', input: IndividualMemberLicenseTransitionInput, deps: IndividualLicenseMutationDeps): Promise<SubmitAndPollResult>;
 export declare function searchIndividualLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput, deps: {
     individualLicenseOfferSearchPath: (ctx: RouteContext) => string;
     individualLicenseOfferSearchPollPath: (ctx: RouteContext) => string;
@@ -502,8 +655,8 @@ export declare function upsertRelatedPersonAndPollWithDeps(routeCtx: RouteContex
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
 export declare function ingestCommunicationAndUpdateIndexWithDeps(routeCtx: RouteContext, input: CommunicationIngestionInput, deps: {
-    individualCommunicationBatchPath: (ctx: RouteContext, pathFormatSegment: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4') => string;
-    individualCommunicationPollPath: (ctx: RouteContext, pathFormatSegment: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4') => string;
+    individualCommunicationBatchPath: (ctx: RouteContext, pathFormatSegment: string) => string;
+    individualCommunicationPollPath: (ctx: RouteContext, pathFormatSegment: string) => string;
     transformPayloadForFhirR4?: (payload: Record<string, unknown>, enabled: boolean) => Record<string, unknown>;
     submitAndPoll: (submitPath: string, pollPath: string, payload: {
         thid?: string;
@@ -532,11 +685,37 @@ export declare function searchClinicalBundleWithDeps(routeCtx: RouteContext, inp
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+/**
+ * Builds one Communication-ready ingestion payload from a paginated search
+ * response that already selected the day batches to be anchored.
+ *
+ * The search response is normalized into a `Bundle.type=batch` attachment,
+ * and the resulting `Communication` is ready for `ingestCommunication...`.
+ */
+export declare function buildVitalSignBatchCommunicationFromSearchResponse(input: VitalSignBatchCommunicationFromSearchResponseInput): CommunicationIngestionInput;
+/**
+ * Builds one blockchain-ready batch bundle from a paginated search response.
+ *
+ * The helper keeps the original search result as the source of truth and only
+ * projects the selected `resource.id` values into a `Bundle.type=batch`
+ * payload for subsequent communication/registration.
+ */
+export declare function buildBlockchainArtifactBundleFromSearchResponse(input: BlockchainArtifactSearchSelectionInput): BlockchainArtifactSearchSelectionResult;
 export declare function searchLatestIpsWithDeps(routeCtx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes' | 'section'> & {
     section?: string | string[];
 }, deps: {
     searchClinicalBundle: (routeCtx: RouteContext, input: ClinicalBundleSearchInput) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+export declare function registerBlockchainArtifactAndUpdateIndexWithDeps(routeCtx: RouteContext, input: BlockchainArtifactRegistrationInput, deps: {
+    individualDocumentReferenceBatchPath: (ctx: RouteContext) => string;
+    individualDocumentReferencePollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
 export declare function grantProfessionalAccessWithDeps(routeCtx: RouteContext, input: GrantProfessionalAccessInput, deps: {
     buildConsentClaimsWithCid: (input: GrantProfessionalAccessInput, options?: {
         consentIdentifierFactory: () => string;
@@ -577,3 +756,5 @@ export declare function generateDigitalTwinFromSubjectDataWithDeps(routeCtx: Rou
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+export declare function normalizeCommunicationPathFormatSegment(raw?: string): string;
+export {};

package/dist/resource-operations.js

@@ -2,7 +2,8 @@
 import { HealthcareBasicSections, ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants';
 import { Format } from 'gdc-common-utils-ts/constants/Schemas';
 import { RelatedPersonClaim } from 'gdc-common-utils-ts/models/interoperable-claims/related-person-claims';
-import { buildCommunicationParticipantSearchBundle, createInteroperableResourceOperationEditor, IndividualOrganizationLifecycleEditor, LicenseOfferSearchEditor, LicenseOrderSearchEditor, InteroperableLifecycleStatuses, LicenseListSearchEditor, } from 'gdc-common-utils-ts';
+import { buildCommunicationParticipantSearchBundle, buildBlockchainArtifactDocumentReference, BundleQuery, createInteroperableResourceOperationEditor, IndividualOrganizationLifecycleEditor, LicenseOfferSearchEditor, LicenseOrderSearchEditor, InteroperableLifecycleStatuses, LicenseListSearchEditor, buildLicenseIssueEntry, buildLicensePurchaseEntry, } from 'gdc-common-utils-ts';
+import { addFhirResourceToCommunication, createCommunicationResource, } from 'gdc-sdk-core-ts';
 import { GwCoreLifecycleRequestMethod, GwCoreLifecycleRequestType, GwCoreLifecycleTodo, } from './constants/lifecycle.js';
 import { buildEmployeeBatchEntry, buildEmployeeSearchBundle, ConsentClaims, } from 'gdc-sdk-core-ts';
 export async function createOrganizationEmployeeWithDeps(routeCtx, input, options, deps) {
@@ -168,6 +169,81 @@ export async function searchIndividualLicensesWithDeps(routeCtx, input, deps) {
 export async function listIndividualLicensesWithDeps(routeCtx, input, deps) {
     return searchIndividualLicensesWithDeps(routeCtx, input || {}, deps);
 }
+/**
+ * Reserves one available household/member seat for a selected contact.
+ *
+ * Ordered application flow:
+ * 1. Create/select RelatedPerson.
+ * 2. Author Consent rules.
+ * 3. Call this operation only for a FHIR v3 RoleCode member.
+ * 4. Put the returned activation code in the invitation Communication.
+ */
+export async function issueIndividualMemberLicenseWithDeps(routeCtx, input, deps) {
+    const entry = buildLicenseIssueEntry({
+        email: input.email,
+        telephone: input.telephone,
+        role: input.role,
+        userClass: 'individual',
+        type: input.type || 'web',
+        ownerOrganizationId: input.ownerOrganizationId,
+        relatedPersonId: input.relatedPersonId,
+        invitationId: input.invitationId,
+    });
+    entry.meta.subjectDid = input.subjectDid;
+    return deps.submitAndPoll(deps.individualLicenseActionPath(routeCtx, '_issue'), deps.individualLicenseActionPollPath(routeCtx, '_issue'), {
+        thid: input.requestThid || `individual-license-issue-${createRuntimeUuid()}`,
+        body: { resourceType: 'Bundle', type: 'batch', data: [entry] },
+    }, input.pollOptions);
+}
+/**
+ * Adds free seats without creating contacts, permissions or invitations.
+ * Price zero is explicit so GW never routes this MVP operation through a
+ * payment-proof branch.
+ */
+export async function addFreeIndividualMemberLicensesWithDeps(routeCtx, input, deps) {
+    const entry = buildLicensePurchaseEntry({
+        quantity: input.quantity,
+        userClass: 'individual',
+        type: 'web',
+        price: 0,
+        priceCurrency: 'EUR',
+        ownerOrganizationId: input.ownerOrganizationId,
+    });
+    return deps.submitAndPoll(deps.individualLicenseActionPath(routeCtx, '_add'), deps.individualLicenseActionPollPath(routeCtx, '_add'), {
+        thid: input.requestThid || `individual-license-add-${createRuntimeUuid()}`,
+        body: { resourceType: 'Bundle', type: 'batch', data: [entry] },
+    }, input.pollOptions);
+}
+/**
+ * Accepts, deactivates or releases one member seat.
+ *
+ * `_accept` needs the Firebase/BFF verified recipient plus the authenticated
+ * subject id. `_release` remains backend-guarded and cannot free an active
+ * member directly.
+ */
+export async function transitionIndividualMemberLicenseWithDeps(routeCtx, action, input, deps) {
+    return deps.submitAndPoll(deps.individualLicenseActionPath(routeCtx, action), deps.individualLicenseActionPollPath(routeCtx, action), {
+        thid: input.requestThid || `individual-license-${action.slice(1)}-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [{
+                    id: input.activationCode,
+                    type: `IndividualMemberLicense${action}`,
+                    meta: {
+                        ...(input.ownerOrganizationId ? { ownerOrganizationId: input.ownerOrganizationId } : {}),
+                        ...(input.subjectId ? { subjectId: input.subjectId } : {}),
+                        ...(input.verifiedActorIdentifier ? { verifiedActorIdentifier: input.verifiedActorIdentifier } : {}),
+                        claims: {
+                            '@context': 'org.schema',
+                            'org.schema.IndividualProduct.serialNumber': input.activationCode,
+                        },
+                    },
+                    request: { method: 'POST' },
+                }],
+        },
+    }, input.pollOptions);
+}
 export async function searchIndividualLicenseOffersWithDeps(routeCtx, input, deps) {
     return deps.submitAndPoll(deps.individualLicenseOfferSearchPath(routeCtx), deps.individualLicenseOfferSearchPollPath(routeCtx), {
         thid: input.requestThid || `individual-license-offer-search-${createRuntimeUuid()}`,
@@ -280,6 +356,9 @@ export async function upsertRelatedPersonAndPollWithDeps(routeCtx, input, deps)
     return deps.submitAndPoll(deps.individualRelatedPersonBatchPath(routeCtx), deps.individualRelatedPersonPollPath(routeCtx), payload, input.pollOptions);
 }
 export async function ingestCommunicationAndUpdateIndexWithDeps(routeCtx, input, deps) {
+    if (!input.communicationPayload) {
+        throw new Error('Legacy communication ingestion requires communicationPayload.');
+    }
     const payload = {
         thid: input.communicationPayload.thid || `communication-${createRuntimeUuid()}`,
         ...input.communicationPayload,
@@ -323,6 +402,117 @@ export async function searchClinicalBundleWithDeps(routeCtx, input, deps) {
     };
     return deps.submitAndPoll(deps.bundleSearchPath(routeCtx), deps.bundleSearchPollPath(routeCtx), payload, input.pollOptions);
 }
+/**
+ * Builds one Communication-ready ingestion payload from a paginated search
+ * response that already selected the day batches to be anchored.
+ *
+ * The search response is normalized into a `Bundle.type=batch` attachment,
+ * and the resulting `Communication` is ready for `ingestCommunication...`.
+ */
+export function buildVitalSignBatchCommunicationFromSearchResponse(input) {
+    const selection = buildBlockchainArtifactBundleFromSearchResponse({
+        subject: input.subject,
+        searchResponse: input.searchResponse,
+        selectedResourceIds: input.selectedResourceIds,
+    });
+    const communication = addFhirResourceToCommunication(createCommunicationResource({
+        subject: input.subject,
+        sender: input.sender,
+        recipient: input.recipient,
+        sent: input.sent,
+        status: input.status || 'completed',
+        noteText: input.noteText || `Selected ${selection.selectedResourceIds.length} vital-sign batch item(s) for blockchain anchoring.`,
+        claims: {
+            'Communication.vital-sign-batch-selection.subject': input.subject,
+            'Communication.vital-sign-batch-selection.selected-count': selection.selectedResourceIds.length,
+            'Communication.vital-sign-batch-selection.unanchored-count': selection.unanchoredResourceIds.length,
+            'Communication.vital-sign-batch-selection.selected-ids': selection.selectedResourceIds.join(','),
+            'Communication.vital-sign-batch-selection.missing-ids': selection.missingResourceIds.join(','),
+        },
+    }), selection.bundle, {
+        attachmentContentType: 'application/fhir+json',
+        attachmentTitle: 'vital-sign-batch-selection.json',
+    });
+    return {
+        communicationPayload: communication,
+        pathFormatSegment: 'org.hl7.fhir.r4',
+        pollOptions: input.pollOptions,
+        autoConvertClaimsToFhirR4: false,
+    };
+}
+/**
+ * Builds one blockchain-ready batch bundle from a paginated search response.
+ *
+ * The helper keeps the original search result as the source of truth and only
+ * projects the selected `resource.id` values into a `Bundle.type=batch`
+ * payload for subsequent communication/registration.
+ */
+export function buildBlockchainArtifactBundleFromSearchResponse(input) {
+    const bundle = normalizeBundleLike(input.searchResponse);
+    const query = new BundleQuery(bundle);
+    const availableResourceIds = query.getResourceIds();
+    const availableEntries = query.getResourceEntriesByIds(availableResourceIds);
+    const anchoredResourceIds = availableEntries
+        .filter((entry) => hasAuditTxId(entry))
+        .map((entry, index) => resolveBundleEntryStableId(entry, index));
+    const unanchoredResourceIds = availableResourceIds.filter((resourceId) => !anchoredResourceIds.includes(resourceId));
+    const requestedResourceIds = normalizeIdList(input.selectedResourceIds);
+    const selectedResourceIds = requestedResourceIds.length > 0
+        ? requestedResourceIds.filter((resourceId) => availableResourceIds.includes(resourceId))
+        : unanchoredResourceIds;
+    const missingResourceIds = requestedResourceIds.filter((resourceId) => !availableResourceIds.includes(resourceId));
+    if (requestedResourceIds.length > 0 && selectedResourceIds.length === 0) {
+        throw new Error('buildBlockchainArtifactBundleFromSearchResponse could not match any selected resource ids.');
+    }
+    const selectedEntries = query.getResourceEntriesByIds(selectedResourceIds);
+    const artifactEntries = selectedEntries.map((entry, index) => {
+        const resource = entry.resource && typeof entry.resource === 'object' ? entry.resource : undefined;
+        if (!resource) {
+            throw new Error(`buildBlockchainArtifactBundleFromSearchResponse requires resource data for selected entry at index ${index}.`);
+        }
+        const logicalIdentifier = asTrimmedString(resource.id || entry.id || entry.fullUrl || selectedResourceIds[index]);
+        const artifact = buildBlockchainArtifactDocumentReference({
+            subject: input.subject,
+            resource,
+            identifier: logicalIdentifier || undefined,
+            title: `${asTrimmedString(resource.resourceType) || 'resource'}.json`,
+        });
+        return {
+            type: 'DocumentReference',
+            meta: { claims: artifact.documentReference.meta?.claims || {} },
+            resource: artifact.documentReference,
+            request: {
+                method: 'POST',
+                url: 'individual/org.hl7.fhir.r4/DocumentReference/_batch',
+            },
+        };
+    });
+    return {
+        availableResourceIds,
+        anchoredResourceIds,
+        unanchoredResourceIds,
+        selectedResourceIds,
+        missingResourceIds,
+        returnedCount: query.getResourceIds().length,
+        totalCount: typeof bundle.total === 'number'
+            ? Number(bundle.total)
+            : query.getResourceIds().length,
+        bundle: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            meta: {
+                claims: {
+                    'BlockchainArtifactSelection.subject': input.subject,
+                    'BlockchainArtifactSelection.availableCount': availableResourceIds.length,
+                    'BlockchainArtifactSelection.selectedCount': selectedResourceIds.length,
+                    'BlockchainArtifactSelection.missingCount': missingResourceIds.length,
+                    'BlockchainArtifactSelection.selectedResourceIds': selectedResourceIds.join(','),
+                },
+            },
+            data: artifactEntries,
+        },
+    };
+}
 export async function searchLatestIpsWithDeps(routeCtx, input, deps) {
     return deps.searchClinicalBundle(routeCtx, {
         ...input,
@@ -330,6 +520,78 @@ export async function searchLatestIpsWithDeps(routeCtx, input, deps) {
         includedTypes: ['Composition', 'DocumentReference'],
     });
 }
+export async function registerBlockchainArtifactAndUpdateIndexWithDeps(routeCtx, input, deps) {
+    const artifact = buildBlockchainArtifactDocumentReference({
+        subject: input.subject,
+        resource: input.resource,
+        contentDataBase64: input.contentDataBase64,
+        contentType: input.contentType,
+        identifier: input.identifier,
+        title: input.title,
+        description: input.description,
+        date: input.date,
+        location: input.location,
+        language: input.language,
+    });
+    const payload = {
+        thid: input.requestThid || `blockchain-artifact-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [{
+                    type: 'DocumentReference',
+                    meta: { claims: artifact.documentReference.meta?.claims || {} },
+                    resource: artifact.documentReference,
+                    request: {
+                        method: 'POST',
+                        url: 'individual/org.hl7.fhir.r4/DocumentReference/_batch',
+                    },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.individualDocumentReferenceBatchPath(routeCtx), deps.individualDocumentReferencePollPath(routeCtx), payload, input.pollOptions);
+}
+function normalizeBundleLike(value) {
+    const root = value && typeof value === 'object' ? value : {};
+    const body = root.body && typeof root.body === 'object' ? root.body : root;
+    const resourceType = asTrimmedString(body.resourceType) || 'Bundle';
+    const type = asTrimmedString(body.type) || 'batch';
+    const data = Array.isArray(body.data)
+        ? body.data
+        : (Array.isArray(body.entry) ? body.entry : []);
+    return {
+        ...(typeof body.id === 'string' ? { id: asTrimmedString(body.id) || undefined } : {}),
+        resourceType: resourceType,
+        type,
+        total: typeof body.total === 'number' ? body.total : undefined,
+        meta: body.meta && typeof body.meta === 'object' ? body.meta : undefined,
+        data: data,
+    };
+}
+function normalizeIdList(value) {
+    return [...(value || [])]
+        .map((item) => asTrimmedString(item))
+        .filter(Boolean);
+}
+function asTrimmedString(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    return String(value).trim();
+}
+function resolveBundleEntryStableId(entry, index) {
+    const resource = entry.resource && typeof entry.resource === 'object' ? entry.resource : {};
+    return asTrimmedString(resource.id || entry.id || entry.fullUrl || `entry-${index}`);
+}
+function hasAuditTxId(entry) {
+    const entryAudit = entry && typeof entry === 'object' ? entry.audit : undefined;
+    const entryMeta = entry && typeof entry === 'object' ? entry.meta : undefined;
+    const resource = entry.resource && typeof entry.resource === 'object' ? entry.resource : {};
+    const resourceMeta = resource.meta && typeof resource.meta === 'object' ? resource.meta : {};
+    const audit = [entryAudit, entryMeta && typeof entryMeta === 'object' ? entryMeta.audit : undefined, resourceMeta.audit]
+        .find((candidate) => candidate && typeof candidate === 'object');
+    return Boolean(asTrimmedString(audit?.txId));
+}
 export async function grantProfessionalAccessWithDeps(routeCtx, input, deps) {
     const built = deps.buildConsentClaimsWithCid({
         subjectDid: input.subjectDid,
@@ -404,13 +666,15 @@ export async function generateDigitalTwinFromSubjectDataWithDeps(routeCtx, input
         : deps.digitalTwinCompositionR4PollPath(routeCtx);
     return deps.submitAndPoll(submitPath, pollPath, payload, input.pollOptions);
 }
-function normalizeCommunicationPathFormatSegment(raw) {
+export function normalizeCommunicationPathFormatSegment(raw) {
     const value = String(raw || '').trim().toLowerCase();
     if (!value || value === 'api' || value === 'org.hl7.fhir.api')
         return 'org.hl7.fhir.api';
     if (value === 'r4' || value === 'fhir.r4' || value === 'org.hl7.fhir.r4')
         return 'org.hl7.fhir.r4';
-    return 'org.hl7.fhir.api';
+    if (/^org\.hl7\.fhir\.[a-z0-9.-]+$/.test(value))
+        return value;
+    throw new Error(`Unsupported Communication clinical format '${String(raw || '')}'.`);
 }
 function createRuntimeUuid() {
     const fromCrypto = globalThis.crypto?.randomUUID?.();

package/dist/runtime-client-paths.d.ts

@@ -52,6 +52,10 @@ export declare class RuntimeClientPaths {
     individualFamilyOrganizationPurgePollPath(ctx?: RouteContext): string;
     individualLicenseSearchPath(ctx?: RouteContext): string;
     individualLicenseSearchPollPath(ctx?: RouteContext): string;
+    /** Builds one individual-member license mutation path. */
+    individualLicenseActionPath(ctx: RouteContext | undefined, action: string): string;
+    /** Builds the poll path paired with one individual-member license mutation. */
+    individualLicenseActionPollPath(ctx: RouteContext | undefined, action: string): string;
     individualLicenseOfferSearchPath(ctx?: RouteContext): string;
     individualLicenseOfferSearchPollPath(ctx?: RouteContext): string;
     individualLicenseOrderSearchPath(ctx?: RouteContext): string;
@@ -64,10 +68,12 @@ export declare class RuntimeClientPaths {
     individualRelatedPersonPurgePollPath(ctx?: RouteContext): string;
     individualConsentR4BatchPath(ctx: RouteContext): string;
     individualConsentR4PollPath(ctx: RouteContext): string;
-    individualCommunicationBatchPath(ctx: RouteContext, format: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4'): string;
-    individualCommunicationPollPath(ctx: RouteContext, format: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4'): string;
+    individualCommunicationBatchPath(ctx: RouteContext, format: string): string;
+    individualCommunicationPollPath(ctx: RouteContext, format: string): string;
     individualCommunicationSearchPath(ctx: RouteContext): string;
     individualCommunicationSearchPollPath(ctx: RouteContext): string;
+    individualDocumentReferenceBatchPath(ctx: RouteContext): string;
+    individualDocumentReferencePollPath(ctx: RouteContext): string;
     individualBundleSearchPath(ctx: RouteContext): string;
     individualBundleSearchPollPath(ctx: RouteContext): string;
     identityTokenExchangePath(ctx: RouteContext): string;