gdc-sdk-node-ts 0.9.1 → 2.0.2

package/dist/backend-profile-runtime.js

@@ -0,0 +1,436 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ActorKinds } from 'gdc-common-utils-ts/constants/actor-session';
+import { ProfileAppTypes } from 'gdc-common-utils-ts/constants';
+import { JobStatus } from 'gdc-common-utils-ts/models/confidential-job';
+import { buildActorSessionDescriptorForActorKind, expandActorSessionDescriptorToFacades, prepareLoadedActorProfile, prepareLoadProfile, } from 'gdc-sdk-core-ts';
+import { createActorSessionsFromFacades } from './gdc-session-bridge.js';
+export const BackendSubjectIndexReadModes = Object.freeze({
+    LatestIps: 'latest-ips',
+    ClinicalBundle: 'clinical-bundle',
+});
+/**
+ * Default backend-generic runtime implementation backed by injected adapters.
+ *
+ * This class is the first concrete v2 slice intended for backend consumers that
+ * need one reusable actor-aware profile runtime after authentication.
+ */
+export class BackendProfileRuntime {
+    constructor(adapters, options = {}) {
+        this.adapters = adapters;
+        this.options = options;
+    }
+    async loadProfile(input) {
+        const loadedProfile = await this.adapters.loadProfile(input);
+        return {
+            ...loadedProfile,
+            actorSessions: createActorSessionsFromFacades(loadedProfile.facades, this.options.facadeClient),
+        };
+    }
+    async closeProfile(_profileKey) { }
+    async registerTrustedDevice(input) {
+        return this.adapters.registerTrustedDevice(input);
+    }
+    async connectToSubjectIndex(input) {
+        return this.adapters.connectToSubjectIndex(input);
+    }
+    async getSubjectIndexComposition(input) {
+        return this.adapters.getSubjectIndexComposition(input);
+    }
+}
+/**
+ * Current concrete backend profile runtime over one injected runtime client.
+ *
+ * This is the pragmatic v2 bridge for backend consumers that already possess
+ * an authenticated `RuntimeClient` and need `loadProfile(...)` to materialize
+ * actor facades immediately against the current GW CORE contract.
+ */
+export class DirectBackendProfileRuntime {
+    constructor(options) {
+        this.loadedProfiles = new Map();
+        this.options = options;
+    }
+    async loadProfile(input) {
+        const normalized = prepareLoadProfile(input);
+        const profileId = String(normalized.profileId
+            || normalized.profileDid
+            || normalized.subjectDid
+            || normalized.providerDid).trim();
+        const resolvedAppType = normalized.appType || ProfileAppTypes.Family;
+        const descriptor = {
+            profileId,
+            actorKind: normalized.actorKind,
+            actorRole: normalized.actorRole,
+            providerDid: normalized.providerDid,
+            runtimeClass: normalized.runtimeClass,
+            profileDid: normalized.profileDid,
+            subjectDid: normalized.subjectDid,
+            email: normalized.email,
+            phone: normalized.phone,
+            deviceDid: normalized.deviceDid,
+            appType: resolvedAppType,
+        };
+        const session = buildActorSessionDescriptorForActorKind({
+            actorKind: normalized.actorKind,
+            appType: resolvedAppType,
+            profileId: descriptor.profileId,
+            profileDid: descriptor.profileDid,
+            role: descriptor.actorRole,
+        });
+        const facades = expandActorSessionDescriptorToFacades(session);
+        const jobManager = this.options.createJobManager
+            ? this.options.createJobManager(descriptor, normalized)
+            : createJobManagerInMemory(descriptor);
+        const loadedProfile = prepareLoadedActorProfile({
+            descriptor,
+            session,
+            facades,
+            jobManager,
+        });
+        const backendProfile = {
+            ...loadedProfile,
+            actorSessions: createActorSessionsFromFacades(loadedProfile.facades, this.options.facadeClient),
+        };
+        this.rememberLoadedProfile(backendProfile);
+        return backendProfile;
+    }
+    async closeProfile(profileKey) {
+        const profile = this.resolveLoadedProfile(profileKey);
+        profile.jobManager.shutdown();
+        this.forgetLoadedProfile(profile);
+    }
+    async registerTrustedDevice(input) {
+        if (this.options.registerTrustedDevice) {
+            return this.options.registerTrustedDevice(input);
+        }
+        return {
+            trustedDeviceId: input.deviceDid,
+            status: 'already-trusted',
+        };
+    }
+    async connectToSubjectIndex(input) {
+        if (this.options.connectToSubjectIndex) {
+            return this.options.connectToSubjectIndex(input);
+        }
+        return {
+            subjectId: input.subjectId,
+            userId: input.userId,
+            userRoleCode: input.userRoleCode,
+            status: 'already-connected',
+        };
+    }
+    async getSubjectIndexComposition(input) {
+        if (this.options.getSubjectIndexComposition) {
+            return this.options.getSubjectIndexComposition(input);
+        }
+        const routeContext = this.options.defaultRouteContext;
+        if (!routeContext) {
+            throw new Error('DirectBackendProfileRuntime requires defaultRouteContext to read subject index data.');
+        }
+        const profile = this.resolveLoadedProfile(input.userId);
+        if (profile.descriptor.actorKind !== ActorKinds.IndividualController) {
+            throw new Error(`DirectBackendProfileRuntime currently resolves subject index reads through IndividualController only, not '${profile.descriptor.actorKind}'.`);
+        }
+        const sdk = requireBackendIndividualControllerSdk(profile);
+        if (this.options.subjectIndexReadMode === BackendSubjectIndexReadModes.ClinicalBundle) {
+            const searchResult = await sdk.searchClinicalBundle(routeContext, {
+                subject: input.subjectId,
+            });
+            return {
+                subjectId: input.subjectId,
+                userId: input.userId,
+                userRoleCode: input.userRoleCode,
+                composition: searchResult.poll.body,
+            };
+        }
+        const latestIps = await sdk.getLatestIps(routeContext, {
+            subject: input.subjectId,
+        });
+        return {
+            subjectId: input.subjectId,
+            userId: input.userId,
+            userRoleCode: input.userRoleCode,
+            composition: latestIps.poll.body,
+        };
+    }
+    rememberLoadedProfile(profile) {
+        const keys = new Set([
+            profile.descriptor.profileId,
+            String(profile.descriptor.profileDid || '').trim(),
+            String(profile.descriptor.subjectDid || '').trim(),
+            String(profile.descriptor.email || '').trim(),
+            String(profile.descriptor.phone || '').trim(),
+        ].filter(Boolean));
+        for (const key of keys) {
+            this.loadedProfiles.set(key, profile);
+        }
+    }
+    forgetLoadedProfile(profile) {
+        const keys = new Set([
+            profile.descriptor.profileId,
+            String(profile.descriptor.profileDid || '').trim(),
+            String(profile.descriptor.subjectDid || '').trim(),
+            String(profile.descriptor.email || '').trim(),
+            String(profile.descriptor.phone || '').trim(),
+        ].filter(Boolean));
+        for (const key of keys) {
+            this.loadedProfiles.delete(key);
+        }
+    }
+    resolveLoadedProfile(userId) {
+        const normalizedUserId = String(userId || '').trim();
+        const direct = this.loadedProfiles.get(normalizedUserId);
+        if (direct) {
+            return direct;
+        }
+        throw new Error(`DirectBackendProfileRuntime has not loaded one backend profile for '${normalizedUserId}'.`);
+    }
+}
+/**
+ * Minimal in-memory `JobManager` for backend runtimes that do not need durable
+ * persistence during one live session.
+ */
+export function createJobManagerInMemory(descriptor) {
+    let isInitialized = false;
+    let sequence = 0;
+    const jobs = new Map();
+    let listener;
+    function notify() {
+        listener?.();
+    }
+    function nextSequence() {
+        sequence += 1;
+        return sequence;
+    }
+    function inferFormType(content) {
+        const first = Array.isArray(content?.body?.data) ? content.body.data[0] : undefined;
+        return String(first?.type || content?.type || '').trim();
+    }
+    function cloneJob(job) {
+        return {
+            ...job,
+            indexed: job.indexed ? structuredClone(job.indexed) : job.indexed,
+            content: job.content ? structuredClone(job.content) : job.content,
+            jwe: job.jwe ? structuredClone(job.jwe) : job.jwe,
+        };
+    }
+    function matchesQuery(job, query) {
+        const conditions = Array.isArray(query.where) ? query.where : [];
+        return conditions.every((condition) => {
+            const currentValue = job[condition.attribute];
+            if ('equals' in condition) {
+                return currentValue === condition.equals;
+            }
+            if ('in' in condition) {
+                return Array.isArray(condition.in) && condition.in.includes(currentValue);
+            }
+            return true;
+        });
+    }
+    return {
+        descriptor: { ...descriptor },
+        get isInitialized() {
+            return isInitialized;
+        },
+        async initialize() {
+            isInitialized = true;
+        },
+        shutdown() {
+            isInitialized = false;
+            jobs.clear();
+        },
+        setListener(nextListener) {
+            listener = nextListener;
+        },
+        async createJob(content, selector) {
+            const now = Date.now();
+            const job = {
+                id: createRuntimeUuid(),
+                thid: String(content?.thid || '').trim() || undefined,
+                status: JobStatus.DRAFT,
+                sequence: nextSequence(),
+                createdAtTimestamp: now,
+                content: structuredClone(content),
+                ...selector,
+            };
+            jobs.set(job.id, job);
+            notify();
+            return cloneJob(job);
+        },
+        async findDraftJobByFormType(formType) {
+            const normalizedFormType = String(formType || '').trim();
+            for (const job of jobs.values()) {
+                if (job.status !== JobStatus.DRAFT)
+                    continue;
+                if (inferFormType(job.content) === normalizedFormType) {
+                    return cloneJob(job);
+                }
+            }
+            return null;
+        },
+        async createOrUpdateDraftJob(content, selector) {
+            const formType = inferFormType(content);
+            const existing = formType ? await this.findDraftJobByFormType(formType) : null;
+            if (!existing) {
+                return this.createJob(content, selector);
+            }
+            const current = jobs.get(existing.id);
+            if (!current) {
+                return this.createJob(content, selector);
+            }
+            const updated = {
+                ...current,
+                ...selector,
+                thid: String(content?.thid || '').trim() || current.thid,
+                content: structuredClone(content),
+                previousSequence: current.sequence,
+                sequence: nextSequence(),
+            };
+            jobs.set(updated.id, updated);
+            notify();
+            return cloneJob(updated);
+        },
+        async sync() { },
+        async queryJobs(query) {
+            const filtered = [...jobs.values()].filter(job => matchesQuery(job, query));
+            if (query.orderBy) {
+                const { attribute, direction } = query.orderBy;
+                filtered.sort((left, right) => {
+                    const a = left[attribute];
+                    const b = right[attribute];
+                    if (a === b)
+                        return 0;
+                    const cmp = a > b ? 1 : -1;
+                    return direction === 'desc' ? -cmp : cmp;
+                });
+            }
+            const offset = Math.max(0, Number(query.offset || 0));
+            const limit = query.limit == null ? filtered.length : Math.max(0, Number(query.limit));
+            return filtered.slice(offset, offset + limit).map(cloneJob);
+        },
+        async submitJob(job) {
+            const current = jobs.get(job.id);
+            if (!current) {
+                throw new Error(`JobManager in-memory store cannot submit unknown job '${job.id}'.`);
+            }
+            jobs.set(job.id, {
+                ...current,
+                status: JobStatus.SENT,
+                previousSequence: current.sequence,
+                sequence: nextSequence(),
+            });
+            notify();
+        },
+        async sealJobWithToken(job) {
+            return job;
+        },
+        async getJobResponseByThid(thid) {
+            for (const job of jobs.values()) {
+                if (job.thid === thid && job.responseMessageId) {
+                    return {
+                        id: job.responseMessageId,
+                        thid,
+                    };
+                }
+            }
+            return null;
+        },
+        generateId() {
+            return createRuntimeUuid();
+        },
+    };
+}
+/**
+ * Requires one backend profile-runtime method from one runtime client.
+ */
+export function requireBackendProfileRuntimeMethod(client, method) {
+    const candidate = client[method];
+    if (typeof candidate !== 'function') {
+        throw new Error(`BackendProfileRuntimeClient does not implement '${String(method)}'.`);
+    }
+    return candidate.bind(client);
+}
+/**
+ * Canonical backend helper for loading one actor profile after authentication.
+ */
+export async function loadBackendProfile(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'loadProfile')(input);
+}
+/**
+ * Canonical backend helper for closing one loaded actor profile and clearing
+ * runtime-owned in-memory state.
+ */
+export async function closeBackendProfile(client, profileKey) {
+    return requireBackendProfileRuntimeMethod(client, 'closeProfile')(profileKey);
+}
+/**
+ * Canonical backend helper for registering one trusted device/runtime context.
+ */
+export async function registerBackendTrustedDevice(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'registerTrustedDevice')(input);
+}
+/**
+ * Canonical backend helper for connecting one actor profile to one subject
+ * index after the profile is already loaded.
+ */
+export async function connectBackendToSubjectIndex(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'connectToSubjectIndex')(input);
+}
+/**
+ * Canonical backend helper for reading one subject index composition after the
+ * relationship is already established.
+ */
+export async function getBackendSubjectIndexComposition(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'getSubjectIndexComposition')(input);
+}
+/**
+ * Returns one materialized backend actor session by actor kind.
+ *
+ * Backend callers should use this instead of scanning `actorSessions` manually.
+ */
+export function requireBackendActorSession(profile, actorKind) {
+    const session = profile.actorSessions.find(candidate => candidate.actorKind === actorKind);
+    if (!session) {
+        throw new Error(`Loaded backend profile does not expose actor kind '${actorKind}'.`);
+    }
+    return session;
+}
+/**
+ * Returns the individual-controller session from one loaded backend profile.
+ *
+ * This helper is the first concrete bridge from the generic backend runtime to
+ * the current individual bootstrap/index use case.
+ */
+export function requireBackendIndividualControllerSession(profile) {
+    return requireBackendActorSession(profile, ActorKinds.IndividualController);
+}
+/**
+ * Materializes the individual-controller facade directly from one loaded
+ * backend profile.
+ */
+export function requireBackendIndividualControllerSdk(profile) {
+    return requireBackendIndividualControllerSession(profile).asIndividualController();
+}
+/**
+ * Loads one backend profile and resolves the individual-controller session in
+ * one step.
+ *
+ * This is the first pragmatic use-case helper on top of the generic backend
+ * profile runtime, because the current stable CORE bootstrap baseline starts
+ * from the individual-controller flow.
+ */
+export async function loadBackendIndividualControllerProfile(client, input) {
+    const profile = await loadBackendProfile(client, input);
+    const session = requireBackendIndividualControllerSession(profile);
+    return {
+        profile,
+        session,
+        sdk: session.asIndividualController(),
+    };
+}
+function createRuntimeUuid() {
+    const fromCrypto = globalThis.crypto?.randomUUID?.();
+    if (fromCrypto) {
+        return fromCrypto;
+    }
+    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

package/dist/consent-claim-helpers.d.ts

@@ -1,4 +1,5 @@
 /**
  * Node runtime re-export of canonical consent claim helpers.
  */
-export { addActorIdentifierList, addActorRoleList, addActors, addCategories, addCategoryList, addClaimValues, addPurposeList, addPurposes, addRoles, addSections, getActorIdentifierList, getActorRoleList, getActors, getCategories, getCategoryList, getClaimValues, getConsentDate, getConsentIdentifier, getConsentPeriodEnd, getConsentPeriodStart, getPurposeList, getPurposes, getRoles, getSections, setActorIdentifierList, setActorRoleList, setActors, setCategories, setCategoryList, setClaimValues, setConsentDate, setConsentIdentifier, setConsentPeriodEnd, setConsentPeriodStart, setPurposeList, setPurposes, setRoles, setSections, type ConsentInteroperableClaims, } from 'gdc-sdk-core-ts';
+export { addActorIdentifierList, addActorRoleList, addActors, addCategories, addCategoryList, addClaimValues, addPurposeList, addPurposes, addRoles, addSections, getActorIdentifierList, getActorRoleList, getActors, getCategories, getCategoryList, getClaimValues, getConsentDate, getConsentIdentifier, getConsentPeriodEnd, getConsentPeriodStart, getPurposeList, getPurposes, getRoles, getSections, setActorIdentifierList, setActorRoleList, setActors, setCategories, setCategoryList, setClaimValues, setConsentDate, setConsentIdentifier, setConsentPeriodEnd, setConsentPeriodStart, setPurposeList, setPurposes, setRoles, setSections, } from 'gdc-sdk-core-ts';
+export type { ConsentInteroperableClaims, } from 'gdc-sdk-core-ts';

package/dist/constants/lifecycle.d.ts

@@ -31,6 +31,7 @@ export declare const GwCoreLifecycleRequestType: Readonly<{
     readonly IndividualOrganizationRegistration: "SubjectOrg-registration-form-v1.0";
     readonly IndividualOrganizationDisable: "Family-disable-request-v1.0";
     readonly IndividualOrganizationPurge: "Family-purge-request-v1.0";
+    readonly IndividualMemberPurge: "RelatedPerson-purge-request-v1.0";
 }>;
 /**
  * Named TODO ids kept close to the current lifecycle implementation so the

package/dist/constants/lifecycle.js

@@ -1,4 +1,5 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { LifecycleRequestType } from 'gdc-common-utils-ts';
 /**
  * GW CORE lifecycle route/action tokens used by the Node runtime SDK.
  *
@@ -32,6 +33,7 @@ export const GwCoreLifecycleRequestType = Object.freeze({
     IndividualOrganizationRegistration: 'SubjectOrg-registration-form-v1.0',
     IndividualOrganizationDisable: 'Family-disable-request-v1.0',
     IndividualOrganizationPurge: 'Family-purge-request-v1.0',
+    IndividualMemberPurge: LifecycleRequestType.RelatedPersonPurge,
 });
 /**
  * Named TODO ids kept close to the current lifecycle implementation so the

package/dist/gdc-session-bridge.js

@@ -3,14 +3,18 @@ import { ActorCapabilities } from 'gdc-common-utils-ts/constants/actor-session';
 import { expandActorSessionDescriptorToFacades, filterCapabilitiesForActor, } from 'gdc-sdk-core-ts';
 import { ActorSession, NodeActorSession } from './session.js';
 const capabilityMap = {
-    [ActorCapabilities.HostActivateOrganization]: ActorCapabilities.HostActivateOrganization,
-    [ActorCapabilities.HostConfirmOrder]: ActorCapabilities.HostConfirmOrder,
+    [ActorCapabilities.HostingActivateOrganization]: ActorCapabilities.HostingActivateOrganization,
+    [ActorCapabilities.HostingConfirmOrder]: ActorCapabilities.HostingConfirmOrder,
+    [ActorCapabilities.HostingDisableHost]: ActorCapabilities.HostingDisableHost,
+    [ActorCapabilities.HostingPurgeHost]: ActorCapabilities.HostingPurgeHost,
     [ActorCapabilities.OrganizationCreateEmployee]: ActorCapabilities.OrganizationCreateEmployee,
     [ActorCapabilities.OrganizationActivateDevice]: ActorCapabilities.OrganizationActivateDevice,
     [ActorCapabilities.OrganizationIssueActivationCode]: ActorCapabilities.OrganizationIssueActivationCode,
     [ActorCapabilities.OrganizationRequestSmartToken]: ActorCapabilities.OrganizationRequestSmartToken,
     [ActorCapabilities.OrganizationDisableEmployee]: ActorCapabilities.OrganizationDisableEmployee,
     [ActorCapabilities.OrganizationPurgeEmployee]: ActorCapabilities.OrganizationPurgeEmployee,
+    [ActorCapabilities.OrganizationDisableTenant]: ActorCapabilities.OrganizationDisableTenant,
+    [ActorCapabilities.OrganizationPurgeTenant]: ActorCapabilities.OrganizationPurgeTenant,
     [ActorCapabilities.IndividualBootstrap]: ActorCapabilities.IndividualBootstrap,
     [ActorCapabilities.IndividualDisable]: ActorCapabilities.IndividualDisable,
     [ActorCapabilities.IndividualPurge]: ActorCapabilities.IndividualPurge,

package/dist/host-onboarding.d.ts

@@ -1,42 +1,9 @@
-import type { PollOptions, SubmitAndPollResult } from './orchestration/client-port.js';
 /**
- * Current host-registry route context for existing host endpoints.
+ * Compatibility re-export.
  *
- * This is a routing object for host registry calls. It is not the same thing as
- * a host discovery descriptor.
+ * The canonical host/hosting facade contract now lives in `gdc-sdk-core-ts` so
+ * browser and Node runtimes can share the same orchestration surface. This
+ * file stays as a stable import path for existing Node consumers.
  */
-export type HostRouteContext = {
-    jurisdiction: string;
-    hostNetwork?: string;
-    /** @deprecated Use `hostNetwork`. */
-    sector?: string;
-    controllerDid?: string;
-    hostDid?: string;
-};
-/**
- * Input for legal-organization order confirmation in the host registry.
- */
-export type LegalOrganizationOrderInput = {
-    offerId: string;
-    jurisdiction?: string;
-    hostNetwork?: string;
-    /** @deprecated Use `hostNetwork`. */
-    sector?: string;
-    dataType?: string;
-    additionalClaims?: Record<string, unknown>;
-    timeoutSeconds?: number;
-    intervalSeconds?: number;
-};
-type ConfirmLegalOrganizationOrderDeps = {
-    input: LegalOrganizationOrderInput;
-    hostCtx: HostRouteContext;
-    defaultTimeoutMs?: number;
-    defaultIntervalMs?: number;
-    hostRegistryOrderBatchPath: (ctx: HostRouteContext) => string;
-    hostRegistryOrderPollPath: (ctx: HostRouteContext) => string;
-    submitAndPoll: (submitPath: string, pollPath: string, payload: {
-        thid?: string;
-    } & Record<string, unknown>, options?: PollOptions) => Promise<SubmitAndPollResult>;
-};
-export declare function confirmLegalOrganizationOrderWithDeps(deps: ConfirmLegalOrganizationOrderDeps): Promise<SubmitAndPollResult>;
-export {};
+export { confirmLegalOrganizationOrderWithDeps, HostLifecycleRequestType, HostedTenantLifecycleRequestType, submitHostedTenantLifecycleWithDeps, } from 'gdc-sdk-core-ts';
+export type { HostingControllerFacade, HostLifecycleInput, HostRouteContext, HostedTenantLifecycleInput, LegalOrganizationOrderInput, } from 'gdc-sdk-core-ts';

package/dist/host-onboarding.js

@@ -1,39 +1,9 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { resolvePollOptionsFromSeconds } from './poll-options.js';
-export async function confirmLegalOrganizationOrderWithDeps(deps) {
-    const offerId = String(deps.input.offerId || '').trim();
-    if (!offerId) {
-        throw new Error('confirmLegalOrganizationOrder requires offerId.');
-    }
-    const claims = {
-        '@context': 'org.schema',
-        'Order.acceptedOffer.identifier': offerId,
-        ...(deps.input.additionalClaims || {}),
-    };
-    const payload = {
-        jti: `jti-${createRuntimeUuid()}`,
-        iss: String(deps.hostCtx.controllerDid || '').trim() || undefined,
-        aud: String(deps.hostCtx.hostDid || '').trim() || undefined,
-        type: 'application/didcomm-plain+json',
-        thid: `order-${createRuntimeUuid()}`,
-        body: {
-            data: [{
-                    type: deps.input.dataType || 'Organization-order-request-v1.0',
-                    meta: { claims },
-                    resource: { meta: { claims } },
-                }],
-        },
-    };
-    const pollOptions = resolvePollOptionsFromSeconds(deps.input.timeoutSeconds, deps.input.intervalSeconds, {
-        timeoutMs: deps.defaultTimeoutMs,
-        intervalMs: deps.defaultIntervalMs,
-    });
-    return deps.submitAndPoll(deps.hostRegistryOrderBatchPath(deps.hostCtx), deps.hostRegistryOrderPollPath(deps.hostCtx), payload, pollOptions);
-}
-function createRuntimeUuid() {
-    const fromCrypto = globalThis.crypto?.randomUUID?.();
-    if (fromCrypto) {
-        return fromCrypto;
-    }
-    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-}
+/**
+ * Compatibility re-export.
+ *
+ * The canonical host/hosting facade contract now lives in `gdc-sdk-core-ts` so
+ * browser and Node runtimes can share the same orchestration surface. This
+ * file stays as a stable import path for existing Node consumers.
+ */
+export { confirmLegalOrganizationOrderWithDeps, HostLifecycleRequestType, HostedTenantLifecycleRequestType, submitHostedTenantLifecycleWithDeps, } from 'gdc-sdk-core-ts';

package/dist/index.d.ts

@@ -2,13 +2,18 @@ export * from 'gdc-sdk-core-ts';
 export * from './runtime-contracts.js';
 export * from './identity-bootstrap.js';
 export * from './async-polling.js';
+export * from './backend-profile-runtime.js';
+export * from './individual-controller-backend-runtime.js';
 export * from './poll-options.js';
 export * from './host-onboarding.js';
 export * from './individual-start.js';
 export * from './individual-onboarding.js';
 export * from './device-activation.js';
 export * from './smart-token.js';
+export * from './order-offer-summary.js';
+export * from './organization-license-order.js';
 export * from './resource-operations.js';
+export * from './constants/lifecycle.js';
 export * from './consent-claim-helpers.js';
 export * from './session.js';
 export * from './node-runtime-client.js';

package/dist/index.js

@@ -3,13 +3,18 @@ export * from 'gdc-sdk-core-ts';
 export * from './runtime-contracts.js';
 export * from './identity-bootstrap.js';
 export * from './async-polling.js';
+export * from './backend-profile-runtime.js';
+export * from './individual-controller-backend-runtime.js';
 export * from './poll-options.js';
 export * from './host-onboarding.js';
 export * from './individual-start.js';
 export * from './individual-onboarding.js';
 export * from './device-activation.js';
 export * from './smart-token.js';
+export * from './order-offer-summary.js';
+export * from './organization-license-order.js';
 export * from './resource-operations.js';
+export * from './constants/lifecycle.js';
 export * from './consent-claim-helpers.js';
 export * from './session.js';
 export * from './node-runtime-client.js';

package/dist/individual-controller-backend-runtime.d.ts

@@ -0,0 +1,46 @@
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import type { IndividualOrganizationConfirmOrderInput, RouteContext } from './individual-onboarding.js';
+import type { IndividualOrganizationBootstrapInput, IndividualOrganizationStartResult } from './individual-start.js';
+import type { ClinicalBundleSearchInput } from './resource-operations.js';
+import { type BackendIndividualControllerProfile, type BackendProfileRuntimeClient } from './backend-profile-runtime.js';
+import type { ProfileLoadRequest } from 'gdc-sdk-core-ts';
+/**
+ * Backend use-case facade for the current individual-controller baseline.
+ *
+ * This class does not redefine the generic backend profile runtime. It wraps
+ * that runtime with the current stable CORE-facing actions that backend
+ * consumers need first:
+ *
+ * - load an individual-controller profile
+ * - start individual registration/bootstrap
+ * - confirm the returned order/offer
+ * - search the subject clinical index
+ * - request the latest IPS-oriented bundle
+ */
+export declare class IndividualControllerBackendRuntime {
+    private readonly profileRuntime;
+    constructor(profileRuntime: BackendProfileRuntimeClient);
+    /**
+     * Loads one individual-controller backend profile and materializes its actor
+     * facade in one step.
+     */
+    loadProfile(input: ProfileLoadRequest): Promise<BackendIndividualControllerProfile>;
+    /**
+     * Starts the current CORE individual/family bootstrap flow.
+     */
+    startIndividualOrganization(profile: BackendIndividualControllerProfile, input: IndividualOrganizationBootstrapInput): Promise<IndividualOrganizationStartResult>;
+    /**
+     * Confirms the order returned by the individual bootstrap flow.
+     */
+    confirmIndividualOrganizationOrder(profile: BackendIndividualControllerProfile, input: IndividualOrganizationConfirmOrderInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches the current subject clinical bundle index through the loaded
+     * individual-controller facade.
+     */
+    searchClinicalBundle(profile: BackendIndividualControllerProfile, ctx: RouteContext, input: ClinicalBundleSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Reads the latest IPS-oriented bundle through the loaded
+     * individual-controller facade.
+     */
+    getLatestIps(profile: BackendIndividualControllerProfile, ctx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes'>): Promise<SubmitAndPollResult>;
+}