gdc-sdk-front-ts 2.2.1 → 2.3.1

package/dist/ProfileManager.js

@@ -199,15 +199,18 @@ export class ProfileManager {
                 return this.individual.service.upsertRelatedPersonAndPoll(input.relatedPersonPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken);
             },
             ingestCommunicationAndUpdateIndex: (ctx, input) => {
+                const communicationInput = input.communicationJob || input.communicationPayload;
+                if (!communicationInput)
+                    throw new Error('Clinical ingestion requires communicationJob.');
                 if (this.professional?.physician) {
-                    return this.professional.physician.ingestCommunicationAndUpdateIndex(input.communicationPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
+                    return this.professional.physician.ingestCommunicationAndUpdateIndex(communicationInput, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
                 }
                 if (this.professional?.paramedic) {
-                    return this.professional.paramedic.ingestCommunicationAndUpdateIndex(input.communicationPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
+                    return this.professional.paramedic.ingestCommunicationAndUpdateIndex(communicationInput, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
                 }
                 if (!this.individual?.service)
                     throw new Error('individual.service is not available for this profile.');
-                return this.individual.service.ingestCommunicationAndUpdateIndex(input.communicationPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
+                return this.individual.service.ingestCommunicationAndUpdateIndex(communicationInput, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
             },
             generateDigitalTwinFromSubjectData: (ctx, input) => {
                 if (!this.individual?.service)

package/dist/front-clinical-runtime-client.d.ts

@@ -0,0 +1,69 @@
+import { type RenderedTransportRequest, type CommunicationClinicalFormatRenderers, type SecureDidcommTransportAdapter, type SubmitAndPollResult, type TransportProfile } from 'gdc-sdk-core-ts';
+import type { FrontClinicalBundleSearchInput, FrontCommunicationIngestionInput, FrontRouteContext, FrontRuntimeClient } from './orchestration/client-port.js';
+export type FrontClinicalCarrierResponse = Readonly<{
+    status: number;
+    body: unknown;
+    location?: string;
+    retryAfterMs?: number;
+}>;
+/**
+ * Carrier-neutral request. HTTP, an offline sync queue, Bluetooth or another
+ * local link receives the same already-rendered protected message.
+ */
+export type FrontClinicalCarrierRequest = Readonly<{
+    phase: 'submit' | 'poll';
+    path: string;
+    authorization: string;
+    message: RenderedTransportRequest;
+}>;
+export type FrontClinicalCarrier = Readonly<{
+    /** Deliver an already-rendered message without decrypting or rebuilding it. */
+    send(request: FrontClinicalCarrierRequest): Promise<FrontClinicalCarrierResponse>;
+}>;
+export type FrontClinicalRuntimeClientOptions = Readonly<{
+    carrier: FrontClinicalCarrier;
+    transportProfile?: TransportProfile;
+    secureTransportAdapter?: SecureDidcommTransportAdapter;
+    /** Product-supplied projections not owned by the generic frontend runtime. */
+    communicationFormatRenderers?: CommunicationClinicalFormatRenderers;
+    accessToken?: string;
+    pollIntervalMs?: number;
+    pollTimeoutMs?: number;
+}>;
+/**
+ * Direct browser/mobile implementation of the canonical Node clinical surface.
+ *
+ * The client owns message rendering, SMART bearer use, thread correlation and
+ * polling. The carrier owns delivery only. An offline-first carrier persists
+ * `request.message` byte-for-byte with its `thid`; a Bluetooth carrier relays
+ * that persisted JWE without seeing FHIR or wallet keys.
+ *
+ * A native confidential app must inject an unlocked wallet-backed
+ * `secureTransportAdapter`. It should protect that wallet with the same
+ * PIN-plus-device envelope described by the Node profile contract, replacing
+ * Cloud KMS with Keychain/Keystore rather than weakening the KDF.
+ */
+export declare class FrontClinicalRuntimeClient implements FrontRuntimeClient {
+    private readonly options;
+    private readonly profile;
+    constructor(options: FrontClinicalRuntimeClientOptions);
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    searchClinicalBundle(ctx: FrontRouteContext, input: FrontClinicalBundleSearchInput): Promise<SubmitAndPollResult & {
+        thid: string;
+    }>;
+    getLatestIps(ctx: FrontRouteContext, subject: string): Promise<SubmitAndPollResult & {
+        thid: string;
+    }>;
+    private sendAndPoll;
+}
+/**
+ * Create the online HTTP carrier.
+ *
+ * Expo should inject a durable outbox carrier instead. That carrier may choose
+ * HTTP or Bluetooth at delivery time, but must preserve the rendered content
+ * type, exact form-encoded JWE and thread id.
+ */
+export declare function createFetchFrontClinicalCarrier(input: Readonly<{
+    baseUrl: string;
+    fetchImpl?: typeof fetch;
+}>): FrontClinicalCarrier;

package/dist/front-clinical-runtime-client.js

@@ -0,0 +1,214 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { TransportProfiles, decodeTransportResponse, renderCommunicationOutboxRequest, renderGatewayMessageRequest, renderTransportPollRequest, } from 'gdc-sdk-core-ts';
+/**
+ * Direct browser/mobile implementation of the canonical Node clinical surface.
+ *
+ * The client owns message rendering, SMART bearer use, thread correlation and
+ * polling. The carrier owns delivery only. An offline-first carrier persists
+ * `request.message` byte-for-byte with its `thid`; a Bluetooth carrier relays
+ * that persisted JWE without seeing FHIR or wallet keys.
+ *
+ * A native confidential app must inject an unlocked wallet-backed
+ * `secureTransportAdapter`. It should protect that wallet with the same
+ * PIN-plus-device envelope described by the Node profile contract, replacing
+ * Cloud KMS with Keychain/Keystore rather than weakening the KDF.
+ */
+export class FrontClinicalRuntimeClient {
+    constructor(options) {
+        this.options = options;
+        this.profile = options.transportProfile || TransportProfiles.DidcommPlainJson;
+    }
+    async ingestCommunicationAndUpdateIndex(ctx, input) {
+        if (!input.communicationJob) {
+            throw new Error('Direct clinical ingestion requires communicationJob.');
+        }
+        const route = requireDirectRoute(ctx);
+        const format = normalizeFormat(input.clinicalFormat || input.pathFormatSegment);
+        const profile = input.transportProfile || this.profile;
+        const submit = await renderCommunicationOutboxRequest(input.communicationJob, profile, this.options.secureTransportAdapter, {
+            clinicalFormat: input.clinicalFormat || input.pathFormatSegment || 'api',
+            formatRenderers: this.options.communicationFormatRenderers,
+        });
+        return this.sendAndPoll(ctx, resourcePath(route, format, 'Communication', '_batch'), resourcePath(route, format, 'Communication', '_batch-response'), submit, profile, input.pollOptions);
+    }
+    async searchClinicalBundle(ctx, input) {
+        const route = requireDirectRoute(ctx);
+        const profile = input.transportProfile || this.profile;
+        const thid = input.requestThid || `bundle-search-${runtimeUuid()}`;
+        const message = await renderGatewayMessageRequest({
+            thid,
+            body: {
+                resourceType: 'Bundle',
+                type: 'batch',
+                entry: [{ request: { method: 'GET', url: buildBundleSearchQuery(input) } }],
+            },
+        }, profile, this.options.secureTransportAdapter);
+        const result = await this.sendAndPoll(ctx, resourcePath(route, 'org.hl7.fhir.r4', 'Bundle', '_search'), resourcePath(route, 'org.hl7.fhir.r4', 'Bundle', '_search-response'), message, profile, input.pollOptions);
+        return { thid, ...result };
+    }
+    getLatestIps(ctx, subject) {
+        return this.searchClinicalBundle(ctx, {
+            subject,
+            section: 'LOINC|60591-5',
+            includedTypes: ['Composition', 'DocumentReference'],
+        });
+    }
+    async sendAndPoll(ctx, submitPath, pollPath, submitMessage, profile, pollOptions) {
+        const authorization = requireSmartBearer(ctx, this.options.accessToken);
+        const submitted = await this.options.carrier.send({
+            phase: 'submit',
+            path: submitPath,
+            authorization,
+            message: submitMessage,
+        });
+        const submit = { status: submitted.status, location: submitted.location, body: submitted.body };
+        if (submitted.status !== 202) {
+            const body = await decodeTransportResponse(submitted.body, profile, this.options.secureTransportAdapter);
+            return { submit, poll: { status: submitted.status, body, attempts: 1 } };
+        }
+        const started = Date.now();
+        const timeoutMs = pollOptions?.timeoutMs ?? this.options.pollTimeoutMs ?? 30000;
+        const intervalMs = pollOptions?.intervalMs ?? this.options.pollIntervalMs ?? 500;
+        let attempts = 0;
+        while (Date.now() - started <= timeoutMs) {
+            attempts += 1;
+            const pollMessage = await renderTransportPollRequest(submitMessage.thid, profile, this.options.secureTransportAdapter);
+            const response = await this.options.carrier.send({
+                phase: 'poll',
+                path: pollPath,
+                authorization,
+                message: pollMessage,
+            });
+            if (response.status !== 202) {
+                return {
+                    submit,
+                    poll: {
+                        status: response.status,
+                        body: await decodeTransportResponse(response.body, profile, this.options.secureTransportAdapter),
+                        attempts,
+                    },
+                };
+            }
+            await delay(response.retryAfterMs ?? intervalMs);
+        }
+        throw new Error(`Clinical transport polling timed out for thread '${submitMessage.thid}'.`);
+    }
+}
+/**
+ * Create the online HTTP carrier.
+ *
+ * Expo should inject a durable outbox carrier instead. That carrier may choose
+ * HTTP or Bluetooth at delivery time, but must preserve the rendered content
+ * type, exact form-encoded JWE and thread id.
+ */
+export function createFetchFrontClinicalCarrier(input) {
+    const baseUrl = input.baseUrl.replace(/\/$/, '');
+    const fetchImpl = input.fetchImpl || fetch;
+    return {
+        async send(request) {
+            const response = await fetchImpl(`${baseUrl}${request.path}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: request.authorization,
+                    'Content-Type': request.message.contentType,
+                    Accept: request.message.accept,
+                },
+                body: typeof request.message.body === 'string'
+                    ? request.message.body
+                    : JSON.stringify(request.message.body),
+            });
+            const text = await response.text();
+            return {
+                status: response.status,
+                body: parseCarrierBody(text),
+                location: response.headers.get('location') || undefined,
+                retryAfterMs: parseRetryAfter(response.headers.get('retry-after')),
+            };
+        },
+    };
+}
+function requireDirectRoute(ctx) {
+    const tenantId = String(ctx.tenantId || '').trim();
+    const jurisdiction = String(ctx.jurisdiction || '').trim();
+    const sector = String(ctx.sector || '').trim();
+    if (!tenantId || !jurisdiction || !sector) {
+        throw new Error('Direct frontend clinical transport requires tenantId, jurisdiction and sector.');
+    }
+    return { tenantId, jurisdiction, sector };
+}
+function requireSmartBearer(ctx, fallback) {
+    const token = String(ctx.accessToken || fallback || '').trim();
+    if (!token)
+        throw new Error('Direct frontend clinical transport requires a SMART access token.');
+    return `Bearer ${token}`;
+}
+function resourcePath(route, format, resourceType, action) {
+    return `/${encodeURIComponent(route.tenantId)}/cds-${encodeURIComponent(route.jurisdiction)}/v1/${encodeURIComponent(route.sector)}/individual/${encodeURIComponent(format)}/${encodeURIComponent(resourceType)}/${encodeURIComponent(action)}`;
+}
+function normalizeFormat(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (!normalized || normalized === 'api' || normalized === 'org.hl7.fhir.api')
+        return 'org.hl7.fhir.api';
+    if (normalized === 'r4' || normalized === 'fhir.r4' || normalized === 'org.hl7.fhir.r4')
+        return 'org.hl7.fhir.r4';
+    if (/^org\.hl7\.fhir\.[a-z0-9.-]+$/.test(normalized))
+        return normalized;
+    throw new Error(`Unsupported Communication clinical format '${String(value || '')}'.`);
+}
+function buildBundleSearchQuery(input) {
+    const params = new URLSearchParams();
+    params.set('type', 'document');
+    params.set('subject', input.subject);
+    setCsv(params, 'composition.section', input.section);
+    setCsv(params, '_type', input.includedTypes);
+    if (input.date?.start)
+        params.set('start', input.date.start);
+    if (input.date?.end)
+        params.set('end', input.date.end);
+    setCsv(params, 'code', input.code);
+    setCsv(params, 'category', input.category);
+    setCsv(params, 'author', input.author);
+    if (input.thid)
+        params.set('thid', input.thid);
+    if (input.pthid)
+        params.set('pthid', input.pthid);
+    if (input.channelId)
+        params.set('channelId', input.channelId);
+    if (input.partOf)
+        params.set('part-of', input.partOf);
+    for (const [key, value] of Object.entries(input.extraSearchParams || {})) {
+        if (value !== undefined && value !== null && String(value).trim())
+            params.set(key, String(value));
+    }
+    return `Bundle?${params.toString()}`;
+}
+function setCsv(params, key, value) {
+    const normalized = (Array.isArray(value) ? value : value ? [value] : [])
+        .map((item) => String(item).trim())
+        .filter(Boolean)
+        .join(',');
+    if (normalized)
+        params.set(key, normalized);
+}
+function parseCarrierBody(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseRetryAfter(value) {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    return Number.isFinite(seconds) ? seconds * 1000 : undefined;
+}
+function runtimeUuid() {
+    return globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from './ClientSDK.js';
 export * from './frontend-profile-runtime.js';
 export * from './frontend-profile-workspace.js';
 export * from './individual-controller-frontend-runtime.js';
+export * from './front-clinical-runtime-client.js';
 export * from './discovery/index.js';
 export * from './orchestration/client-port.js';
 export * from './orchestration/host-onboarding-sdk.js';

package/dist/index.js

@@ -16,6 +16,7 @@ export * from './ClientSDK.js';
 export * from './frontend-profile-runtime.js';
 export * from './frontend-profile-workspace.js';
 export * from './individual-controller-frontend-runtime.js';
+export * from './front-clinical-runtime-client.js';
 export * from './discovery/index.js';
 export * from './orchestration/client-port.js';
 export * from './orchestration/host-onboarding-sdk.js';

package/dist/orchestration/client-port.d.ts

@@ -3,10 +3,16 @@ import type { LicenseListSearchState } from 'gdc-common-utils-ts/utils/license-l
 import type { LicenseOfferSearchState, LicenseOrderSearchState } from 'gdc-common-utils-ts/utils/license-commercial-search';
 import type { IndividualOrganizationLifecycleEditor } from 'gdc-common-utils-ts/utils/individual-organization-lifecycle';
 import type { IndividualOnboardingDraftInput, IndividualOnboardingDraftResult } from 'gdc-common-utils-ts/models/individual-onboarding';
-import type { BundleSearchQuery, CommunicationInput, EmployeeSearchValue, HostLifecycleInput, HostRouteContext, HostedTenantLifecycleInput, OrganizationDidBindingInput, LegalOrganizationOrderInput, PollOptions, SmartTokenRequestContract, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
+import type { BundleSearchQuery, CommMsgExtendedCommunicationOutboxJob, CommunicationOutboxJob, CommunicationInput, EmployeeSearchValue, HostLifecycleInput, HostRouteContext, HostedTenantLifecycleInput, OrganizationDidBindingInput, LegalOrganizationOrderInput, PollOptions, SmartTokenRequestContract, SubmitAndPollResult, SubmitPayload, TransportProfile } from 'gdc-sdk-core-ts';
 export type FrontRouteContext = {
     providerDid: string;
     idToken: string;
+    /** Direct-to-GW runtimes use the SMART access token, never the login token. */
+    accessToken?: string;
+    /** Direct mobile/browser runtimes require explicit GW routing. */
+    tenantId?: string;
+    jurisdiction?: string;
+    sector?: string;
     requiredScope?: string;
     format?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api';
 };
@@ -118,11 +124,23 @@ export type FrontRelatedPersonUpsertInput = {
     relatedPersonPayload: object;
 };
 export type FrontCommunicationIngestionInput = {
-    communicationPayload: CommunicationInput & Record<string, unknown>;
+    /** Preferred claims-first job created by `createCommunicationOutboxJobFromCommMsgExtendedDraft(...)`. */
+    communicationJob?: CommunicationOutboxJob | CommMsgExtendedCommunicationOutboxJob;
+    /** Compatibility escape hatch for an already-rendered channel payload. */
+    communicationPayload?: CommunicationInput & Record<string, unknown>;
+    /** Claims-first representation rendered before transport. */
+    clinicalFormat?: string;
+    /** @deprecated Use `clinicalFormat`. */
     pathFormatSegment?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api';
+    transportProfile?: TransportProfile;
+    pollOptions?: PollOptions;
 };
-export type FrontClinicalBundleSearchInput = BundleSearchQuery & {
+export type FrontClinicalBundleSearchInput = Omit<BundleSearchQuery, 'section' | 'searchParams'> & {
+    section?: string | string[];
+    extraSearchParams?: BundleSearchQuery['searchParams'];
     requestThid?: string;
+    transportProfile?: TransportProfile;
+    pollOptions?: PollOptions;
 };
 export type FrontGrantProfessionalAccessInput = {
     subjectDid?: string;

package/dist/orchestration/individual-member-sdk.d.ts

@@ -1,8 +1,18 @@
 import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
-import { type FrontRelatedPersonUpsertInput, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+import { type FrontClinicalBundleSearchInput, type FrontCommunicationIngestionInput, type FrontRelatedPersonUpsertInput, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
 export declare class IndividualMemberSdk {
     private readonly client;
     constructor(client: FrontRuntimeClient);
     upsertRelatedPersonAndPoll(ctx: FrontRouteContext, input: FrontRelatedPersonUpsertInput): Promise<SubmitAndPollResult>;
     requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+    /** Delegates a permitted member write to the same canonical clinical outbox. */
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    /** Reads clinical documents under the member's accepted consent and SMART scopes. */
+    searchClinicalBundle(ctx: FrontRouteContext, input: FrontClinicalBundleSearchInput): Promise<{
+        thid: string;
+    }>;
+    /** Reads the latest IPS permitted for this member and subject. */
+    getLatestIps(ctx: FrontRouteContext, subject: string): Promise<{
+        thid: string;
+    }>;
 }

package/dist/orchestration/individual-member-sdk.js

@@ -10,4 +10,16 @@ export class IndividualMemberSdk {
     requestSmartToken(input) {
         return requireClientMethod(this.client, 'requestSmartToken')(input);
     }
+    /** Delegates a permitted member write to the same canonical clinical outbox. */
+    ingestCommunicationAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
+    }
+    /** Reads clinical documents under the member's accepted consent and SMART scopes. */
+    searchClinicalBundle(ctx, input) {
+        return requireClientMethod(this.client, 'searchClinicalBundle')(ctx, input);
+    }
+    /** Reads the latest IPS permitted for this member and subject. */
+    getLatestIps(ctx, subject) {
+        return requireClientMethod(this.client, 'getLatestIps')(ctx, subject);
+    }
 }

package/dist/orchestration/professional-sdk.d.ts

@@ -1,6 +1,6 @@
 import { type ProfessionalEmployeeCredentialInput, type ProfessionalSmartVpPayloadInput } from 'gdc-common-utils-ts';
 import type { PollOptions, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
-import { type FrontCommunicationIngestionInput, type FrontGrantProfessionalAccessInput, type FrontGrantProfessionalAccessResult, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+import { type FrontClinicalBundleSearchInput, type FrontCommunicationIngestionInput, type FrontGrantProfessionalAccessInput, type FrontGrantProfessionalAccessResult, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
 export declare class ProfessionalSdk {
     private readonly client;
     constructor(client: FrontRuntimeClient);
@@ -31,5 +31,11 @@ export declare class ProfessionalSdk {
     }>): string;
     ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
     grantProfessionalAccess(ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput): Promise<FrontGrantProfessionalAccessResult>;
+    searchClinicalBundle(ctx: FrontRouteContext, input: FrontClinicalBundleSearchInput): Promise<{
+        thid: string;
+    }>;
+    getLatestIps(ctx: FrontRouteContext, subject: string): Promise<{
+        thid: string;
+    }>;
     submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
 }

package/dist/orchestration/professional-sdk.js

@@ -42,6 +42,12 @@ export class ProfessionalSdk {
     grantProfessionalAccess(ctx, input) {
         return requireClientMethod(this.client, 'grantProfessionalAccess')(ctx, input);
     }
+    searchClinicalBundle(ctx, input) {
+        return requireClientMethod(this.client, 'searchClinicalBundle')(ctx, input);
+    }
+    getLatestIps(ctx, subject) {
+        return requireClientMethod(this.client, 'getLatestIps')(ctx, subject);
+    }
     submitAndPoll(submitPath, pollPath, payload, pollOptions) {
         return requireClientMethod(this.client, 'submitAndPoll')(submitPath, pollPath, payload, pollOptions);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-front-ts",
-  "version": "2.2.1",
+  "version": "2.3.1",
   "description": "Next-generation frontend runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -17,8 +17,8 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.28.4",
-    "gdc-common-utils-ts": "^2.2.2",
-    "gdc-sdk-core-ts": "~2.2.1"
+    "gdc-common-utils-ts": "^2.3.1",
+    "gdc-sdk-core-ts": "~2.3.1"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",

package/dist/discovery/HttpDataspaceDiscoveryClient.d.ts

@@ -1,34 +0,0 @@
-import type { DataspaceDiscoveryClient } from './DataspaceDiscoveryClient.js';
-import type { ListPublishedProvidersInput, ListPublishedProvidersResult } from './types.js';
-type DiscoveryFetchResponse = Readonly<{
-    ok: boolean;
-    status: number;
-    json(): Promise<unknown>;
-}>;
-export type FrontendDiscoveryFetch = (input: string, init?: Readonly<{
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-}>) => Promise<DiscoveryFetchResponse>;
-export type HttpDataspaceDiscoveryClientOptions = Readonly<{
-    baseUrl: string;
-    fetcher?: FrontendDiscoveryFetch;
-    endpointPath?: string;
-    headers?: Record<string, string>;
-}>;
-/**
- * HTTP/BFF-first frontend discovery client.
- */
-export declare class HttpDataspaceDiscoveryClient implements DataspaceDiscoveryClient {
-    private readonly baseUrl;
-    private readonly fetcher;
-    private readonly endpointPath;
-    private readonly headers;
-    constructor(options: HttpDataspaceDiscoveryClientOptions);
-    /**
-     * Calls the configured backend/BFF endpoint and maps normalized discovery
-     * DTOs into UI-facing cards.
-     */
-    listPublishedProviders(input: ListPublishedProvidersInput): Promise<ListPublishedProvidersResult>;
-}
-export {};

package/dist/discovery/HttpDataspaceDiscoveryClient.js

@@ -1,47 +0,0 @@
-// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { mapHostingOperatorRecordToCard, mapPublishedProviderRecordToCard } from './mappers.js';
-function defaultFetch(input, init) {
-    return fetch(input, init);
-}
-/**
- * HTTP/BFF-first frontend discovery client.
- */
-export class HttpDataspaceDiscoveryClient {
-    constructor(options) {
-        this.baseUrl = new URL(options.baseUrl.endsWith('/') ? options.baseUrl : `${options.baseUrl}/`);
-        this.fetcher = options.fetcher || defaultFetch;
-        this.endpointPath = options.endpointPath || '/api/dataspace-discovery/providers';
-        this.headers = { ...(options.headers || {}) };
-    }
-    /**
-     * Calls the configured backend/BFF endpoint and maps normalized discovery
-     * DTOs into UI-facing cards.
-     */
-    async listPublishedProviders(input) {
-        const response = await this.fetcher(new URL(this.endpointPath.replace(/^\//, ''), this.baseUrl).href, {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                ...this.headers,
-            },
-            body: JSON.stringify(input),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to load dataspace discovery results (${response.status}).`);
-        }
-        const body = await response.json();
-        const providers = Array.isArray(body.providers)
-            ? body.providers.map((record) => mapPublishedProviderRecordToCard(record))
-            : [];
-        const hostingOperators = Array.isArray(body.hostingOperators)
-            ? body.hostingOperators.map((entry) => mapHostingOperatorRecordToCard(entry.record, {
-                catalogUrl: entry.catalogUrl,
-                title: entry.title,
-            }))
-            : [];
-        return {
-            providers,
-            ...(hostingOperators.length ? { hostingOperators } : {}),
-        };
-    }
-}

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

@@ -1,27 +0,0 @@
-import { ProtectedDataAES } from './models/aes';
-/**
- * Manages AES-GCM encryption and decryption using Node's native crypto module.
- * This class handles the core cryptography and the base64url serialization required for JWE.
- */
-export declare class AesManager {
-    private readonly ALGORITHM;
-    private readonly KEY_SIZE;
-    private readonly IV_GENERATION_SIZE;
-    private readonly TAG_SIZE_BYTES;
-    /**
-     * Encrypts a plaintext string and returns the components as base64url strings.
-     * @param plaintext The stringified data to encrypt (e.g. a stringified object or ASCII string from raw bytes)
-     * @param cekBytes The 32-byte Content Encryption Key.
-     * @param aad The Additional Authenticated Data string for integrity protection.
-     * @returns A promise resolving to the JWE-compatible encrypted components.
-     */
-    encrypt(plaintext: string, cekBytes: Uint8Array, aad: string): Promise<ProtectedDataAES>;
-    /**
-     * Decrypts JWE-compatible encrypted components back to a plaintext string.
-     * @param encryptedData The object containing the base64url-encoded ciphertext, iv, and tag.
-     * @param cekBytes The 32-byte Content Encryption Key.
-     * @param aad The Additional Authenticated Data for integrity verification.
-     * @returns A promise resolving to the decrypted plaintext string.
-     */
-    decrypt(encryptedData: ProtectedDataAES, cekBytes: Uint8Array, aad: string): Promise<string>;
-}

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

@@ -1,64 +0,0 @@
-// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
-// File: crypto-ts/AesManager.ts
-import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
-import { Content } from './utils/content';
-/**
- * Manages AES-GCM encryption and decryption using Node's native crypto module.
- * This class handles the core cryptography and the base64url serialization required for JWE.
- */
-export class AesManager {
-    constructor() {
-        this.ALGORITHM = 'aes-256-gcm';
-        this.KEY_SIZE = 32; // 256-bit key
-        this.IV_GENERATION_SIZE = 12; // 96-bit IV, recommended by NIST for GCM
-        this.TAG_SIZE_BYTES = 16; // 128-bit authentication tag
-    }
-    /**
-     * Encrypts a plaintext string and returns the components as base64url strings.
-     * @param plaintext The stringified data to encrypt (e.g. a stringified object or ASCII string from raw bytes)
-     * @param cekBytes The 32-byte Content Encryption Key.
-     * @param aad The Additional Authenticated Data string for integrity protection.
-     * @returns A promise resolving to the JWE-compatible encrypted components.
-     */
-    async encrypt(plaintext, cekBytes, aad) {
-        if (cekBytes.length !== this.KEY_SIZE) {
-            throw new Error(`Invalid key length: a ${this.KEY_SIZE}-byte key is required.`);
-        }
-        const iv = randomBytes(this.IV_GENERATION_SIZE);
-        const aadBytes = Content.stringToBytesUTF8(aad);
-        const cipher = createCipheriv(this.ALGORITHM, cekBytes, iv, {
-            authTagLength: this.TAG_SIZE_BYTES
-        });
-        cipher.setAAD(aadBytes);
-        const ciphertext = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
-        const tag = cipher.getAuthTag();
-        return {
-            ciphertext: Content.bytesToRawBase64UrlSafe(ciphertext),
-            iv: Content.bytesToRawBase64UrlSafe(iv),
-            tag: Content.bytesToRawBase64UrlSafe(tag),
-        };
-    }
-    /**
-     * Decrypts JWE-compatible encrypted components back to a plaintext string.
-     * @param encryptedData The object containing the base64url-encoded ciphertext, iv, and tag.
-     * @param cekBytes The 32-byte Content Encryption Key.
-     * @param aad The Additional Authenticated Data for integrity verification.
-     * @returns A promise resolving to the decrypted plaintext string.
-     */
-    async decrypt(encryptedData, cekBytes, aad) {
-        if (cekBytes.length !== this.KEY_SIZE) {
-            throw new Error(`Invalid key length: a ${this.KEY_SIZE}-byte key is required.`);
-        }
-        const ciphertextBytes = Content.base64ToBytes(encryptedData.ciphertext);
-        const tagBytes = Content.base64ToBytes(encryptedData.tag);
-        const ivBytes = Content.base64ToBytes(encryptedData.iv);
-        const aadBytes = Content.stringToBytesUTF8(aad);
-        const decipher = createDecipheriv(this.ALGORITHM, cekBytes, ivBytes, {
-            authTagLength: this.TAG_SIZE_BYTES
-        });
-        decipher.setAuthTag(tagBytes);
-        decipher.setAAD(aadBytes);
-        const decryptedBytes = Buffer.concat([decipher.update(ciphertextBytes), decipher.final()]);
-        return Content.bytesToStringUTF8(decryptedBytes);
-    }
-}