gdc-common-utils-ts 2.3.0 → 2.3.2

package/dist/utils/bundle-editor-core.js

@@ -77,6 +77,52 @@ export class BundleEditor {
     getBundleType() {
         return this.bundleType;
     }
+    /**
+     * Replaces staged entries with one previously materialized JSON-API-like
+     * Bundle snapshot so a later UI session can reopen, edit or append entries.
+     *
+     * This is an in-memory authoring operation only. It does not imply that the
+     * supplied Bundle came from authoritative GW readback and it performs no
+     * Communication wrapping, submission or polling.
+     */
+    setBundle(bundle) {
+        if (!bundle || bundle.resourceType !== ResourceTypesFhirR4.Bundle || !Array.isArray(bundle.data)) {
+            throw new TypeError('BundleEditor.setBundle requires a Bundle with data[].');
+        }
+        if (!Object.values(BundleTypes).includes(bundle.type)) {
+            throw new TypeError(`BundleEditor.setBundle does not support Bundle.type: ${String(bundle.type || '')}`);
+        }
+        const operation = this.requireBundleOperation();
+        const nextEntries = bundle.data.map((source, index) => {
+            const resource = source?.resource;
+            const resourceType = normalizeOptionalIdentifier(resource?.resourceType);
+            if (!resource || !resourceType) {
+                throw new TypeError(`BundleEditor.setBundle requires data[${index}].resource.resourceType.`);
+            }
+            if (bundle.type !== BundleTypes.document
+                && this.allowedResourceType
+                && resourceType !== this.allowedResourceType) {
+                throw new Error(`BundleEditor cannot mix resource types in ${bundle.type} mode: ${this.allowedResourceType} vs ${resourceType}`);
+            }
+            const cloned = cloneEntry(source);
+            return {
+                type: normalizeOptionalIdentifier(cloned.type) || inferGenericEntryType(resourceType, operation),
+                request: cloned.request || { method: resolveRequestMethodForOperation(operation) },
+                ...(cloned.fullUrl ? { fullUrl: cloned.fullUrl } : {}),
+                resource: {
+                    ...cloned.resource,
+                    resourceType,
+                    meta: {
+                        ...(cloned.resource?.meta || {}),
+                        claims: { ...(cloned.resource?.meta?.claims || {}) },
+                    },
+                },
+            };
+        });
+        this.bundleType = bundle.type;
+        this.entries.splice(0, this.entries.length, ...nextEntries);
+        return this;
+    }
     setCompositionIdentifier(identifier) {
         return this.setCompositionScalarClaim(CompositionClaim.Identifier, identifier);
     }

package/dist/utils/bundle-editor.d.ts

@@ -19,3 +19,5 @@ export * from './immunization-entry-editor';
 export * from './procedure-entry-editor';
 export * from './diagnostic-report-entry-editor';
 export * from './employee-entry-editor';
+export * from './consent-entry-editor';
+export * from './related-person-entry-editor';

package/dist/utils/bundle-editor.js

@@ -19,3 +19,5 @@ export * from './immunization-entry-editor.js';
 export * from './procedure-entry-editor.js';
 export * from './diagnostic-report-entry-editor.js';
 export * from './employee-entry-editor.js';
+export * from './consent-entry-editor.js';
+export * from './related-person-entry-editor.js';

package/dist/utils/bundle-entry-editor.d.ts

@@ -17,6 +17,8 @@ import type { MedicationStatementEntryEditor } from './medication-statement-entr
 import type { ObservationEntryEditor } from './observation-entry-editor';
 import type { ProcedureEntryEditor } from './procedure-entry-editor';
 import type { VitalSignEntryEditor } from './vital-sign-entry-editor';
+import type { ConsentEntryEditor } from './consent-entry-editor';
+import type { RelatedPersonEntryEditor } from './related-person-entry-editor';
 import { type EmployeeClaims } from './employee';
 export declare class BundleEntryEditor {
     protected readonly bundleEditor: BundleEditor;
@@ -31,6 +33,10 @@ export declare class BundleEntryEditor {
     asResourceType<T extends AllowedResourceType>(resourceType: T): ResourceTypeEntryEditor<T>;
     /** Opens the current entry as one employee-specific resource editor. */
     asEmployee(): EmployeeEntryEditor;
+    /** Opens the current entry as one Consent permission editor. */
+    asConsent(): ConsentEntryEditor;
+    /** Opens the current entry as one RelatedPerson/contact editor. */
+    asRelatedPerson(): RelatedPersonEntryEditor;
     /** Opens the current entry as one vital-sign-specific Observation editor. */
     asVitalSign(): VitalSignEntryEditor;
     /** Opens the current entry as one general Observation editor. */

package/dist/utils/bundle-entry-editor.js

@@ -27,6 +27,10 @@ export class BundleEntryEditor {
         switch (normalized) {
             case BundleEditableResourceTypes.employee:
                 return this.asEmployee();
+            case BundleEditableResourceTypes.consent:
+                return this.asConsent();
+            case BundleEditableResourceTypes.relatedPerson:
+                return this.asRelatedPerson();
             case BundleEditableResourceTypes.vitalSign:
                 return this.asVitalSign();
             case BundleEditableResourceTypes.observation:
@@ -71,6 +75,22 @@ export class BundleEntryEditor {
         }
         return createRegisteredBundleEntryEditor(BundleEditableResourceTypes.employee, this.bundleEditor, this.entryIndex);
     }
+    /** Opens the current entry as one Consent permission editor. */
+    asConsent() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Consent) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Consent: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return createRegisteredBundleEntryEditor(BundleEditableResourceTypes.consent, this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one RelatedPerson/contact editor. */
+    asRelatedPerson() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.RelatedPerson) {
+            throw new Error(`BundleEntryEditor cannot open this entry as RelatedPerson: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return createRegisteredBundleEntryEditor(BundleEditableResourceTypes.relatedPerson, this.bundleEditor, this.entryIndex);
+    }
     /** Opens the current entry as one vital-sign-specific Observation editor. */
     asVitalSign() {
         const entry = this.getMutableEntry();

package/dist/utils/communication-consent-access-editor.d.ts

@@ -1,6 +1,6 @@
 import { type HealthcareActorRoleDescriptor, type HealthcareSectionDescriptor } from '../constants/healthcare';
 import type { DataspaceSector } from '../constants/sectors';
-import type { CommunicationAttachedBundleSessionOptions, ConsentEditorClassifiedActors, ConsentEditorClassifiedPurpose, ConsentEditorClassifiedRoles, ConsentEditorClassifiedTarget, ConsentViewModel } from '../models/communication-attached-bundle-session';
+import type { ActiveEntrySelection, CommunicationAttachedBundleSessionOptions, ConsentEditorClassifiedActors, ConsentEditorClassifiedPurpose, ConsentEditorClassifiedRoles, ConsentEditorClassifiedTarget, ConsentViewModel, UpsertClaimsResourceEntryInput } from '../models/communication-attached-bundle-session';
 import type { ConsentDuplicateRuleConflict } from './consent-duplicate-rules';
 import { CommunicationAttachedBundleSession } from './communication-attached-bundle-session';
 /**
@@ -15,6 +15,19 @@ import { CommunicationAttachedBundleSession } from './communication-attached-bun
  * by the existing access-rule contract.
  */
 export declare class ConsentAccessEditor extends CommunicationAttachedBundleSession {
+    /**
+     * Adds one authored Consent to the in-memory permission Bundle and selects it.
+     *
+     * Prefer this semantic name in app code and tutorials. Saving, attaching the
+     * completed Bundle to a Communication and transporting it are later steps.
+     */
+    addConsent(input: UpsertClaimsResourceEntryInput<Record<string, unknown>>): this;
+    /** Reopens one Consent already present in the in-memory permission Bundle. */
+    openConsent(selection: ActiveEntrySelection): this;
+    /** Saves the active Consent and closes its editing selection. */
+    saveConsent(): this;
+    /** @deprecated Internal compatibility plumbing. Use `addConsent(...)`. */
+    upsertActiveConsentEntry(input: UpsertClaimsResourceEntryInput<Record<string, unknown>>): this;
     /** Returns duplicate atomic consent-rule conflicts across the current bundle. */
     getConsentRuleDuplicateConflicts(): ConsentDuplicateRuleConflict[];
     /** Returns duplicate atomic consent-rule conflicts affecting the active Consent entry. */

package/dist/utils/communication-consent-access-editor.js

@@ -18,6 +18,33 @@ import { asTrimmedString, buildClassifiedConsentTarget, buildConsentViewModel, b
  * by the existing access-rule contract.
  */
 export class ConsentAccessEditor extends CommunicationAttachedBundleSession {
+    /**
+     * Adds one authored Consent to the in-memory permission Bundle and selects it.
+     *
+     * Prefer this semantic name in app code and tutorials. Saving, attaching the
+     * completed Bundle to a Communication and transporting it are later steps.
+     */
+    addConsent(input) {
+        return super.upsertActiveConsentEntry(input);
+    }
+    /** Reopens one Consent already present in the in-memory permission Bundle. */
+    openConsent(selection) {
+        this.selectActiveEntry(selection);
+        const resourceType = this.getActiveEntry()?.resource?.resourceType;
+        if (resourceType !== ResourceTypesFhirR4.Consent) {
+            this.clearActiveEntry();
+            throw new Error(`ConsentAccessEditor cannot open resource type: ${String(resourceType || '')}`);
+        }
+        return this;
+    }
+    /** Saves the active Consent and closes its editing selection. */
+    saveConsent() {
+        return this.saveAndReleaseActiveEntry();
+    }
+    /** @deprecated Internal compatibility plumbing. Use `addConsent(...)`. */
+    upsertActiveConsentEntry(input) {
+        return this.addConsent(input);
+    }
     /** Returns duplicate atomic consent-rule conflicts across the current bundle. */
     getConsentRuleDuplicateConflicts() {
         return detectDuplicateConsentRuleConflicts(this.getBundleInMemory().data);

package/dist/utils/consent-entry-editor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - This file owns only the typed editor for one staged Consent entry.
+ */
+import { type ConsentDecision } from '../models/consent-rule';
+import { BundleEntryEditor } from './bundle-entry-editor';
+/**
+ * Typed editor for one Consent permission staged inside a Bundle.
+ *
+ * It edits semantic permission data only. It does not create a Communication,
+ * choose a clinical projection, pack DIDComm, authorize, submit or poll.
+ */
+export declare class ConsentEntryEditor extends BundleEntryEditor {
+    setIdentifier(value?: string | null): this;
+    getIdentifier(): string | undefined;
+    ensureIdentifier(): string;
+    setSubject(value?: string | null): this;
+    getSubject(): string | undefined;
+    setDecision(value?: ConsentDecision | null): this;
+    getDecision(): string | undefined;
+    setActorIdentifierList(values: readonly string[]): this;
+    getActorIdentifierList(): string[];
+    setActorRoleList(values: readonly string[]): this;
+    getActorRoleList(): string[];
+    setPurposeList(values: readonly string[]): this;
+    getPurposeList(): string[];
+    setSectionList(values: readonly string[]): this;
+    getSectionList(): string[];
+    setResourceTypeList(values: readonly string[]): this;
+    getResourceTypeList(): string[];
+    setDate(value?: string | null): this;
+    getDate(): string | undefined;
+    setPeriodStart(value?: string | null): this;
+    getPeriodStart(): string | undefined;
+    setPeriodEnd(value?: string | null): this;
+    getPeriodEnd(): string | undefined;
+    private setOptionalText;
+    private getOptionalText;
+    private setList;
+    private getList;
+}

package/dist/utils/consent-entry-editor.js

@@ -0,0 +1,80 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - This file owns only the typed editor for one staged Consent entry.
+ */
+import { ClaimConsent } from '../models/consent-rule.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { BundleEntryEditor } from './bundle-entry-editor.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+function normalizeText(value) {
+    const normalized = String(value || '').trim();
+    return normalized || undefined;
+}
+function normalizeList(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+/**
+ * Typed editor for one Consent permission staged inside a Bundle.
+ *
+ * It edits semantic permission data only. It does not create a Communication,
+ * choose a clinical projection, pack DIDComm, authorize, submit or poll.
+ */
+export class ConsentEntryEditor extends BundleEntryEditor {
+    setIdentifier(value) {
+        const normalized = normalizeText(value);
+        if (!normalized) {
+            this.removeClaim(ClaimConsent.identifier).setResourceId().setFullUrl();
+            return this;
+        }
+        return this.setClaim(ClaimConsent.identifier, normalized)
+            .setResourceId(normalized)
+            .setFullUrl(normalized);
+    }
+    getIdentifier() {
+        return normalizeText(String(this.getClaim(ClaimConsent.identifier) || this.getResourceId() || this.getFullUrl() || ''));
+    }
+    ensureIdentifier() {
+        const identifier = this.getIdentifier();
+        if (!identifier)
+            throw new Error('Consent entry requires a generated resource id or explicit identifier.');
+        this.setIdentifier(identifier);
+        return identifier;
+    }
+    setSubject(value) { return this.setOptionalText(ClaimConsent.subject, value); }
+    getSubject() { return this.getOptionalText(ClaimConsent.subject); }
+    setDecision(value) { return this.setOptionalText(ClaimConsent.decision, value); }
+    getDecision() { return this.getOptionalText(ClaimConsent.decision); }
+    setActorIdentifierList(values) { return this.setList(ClaimConsent.actorIdentifier, values); }
+    getActorIdentifierList() { return this.getList(ClaimConsent.actorIdentifier); }
+    setActorRoleList(values) { return this.setList(ClaimConsent.actorRole, values); }
+    getActorRoleList() { return this.getList(ClaimConsent.actorRole); }
+    setPurposeList(values) { return this.setList(ClaimConsent.purpose, values); }
+    getPurposeList() { return this.getList(ClaimConsent.purpose); }
+    setSectionList(values) { return this.setList(ClaimConsent.action, values); }
+    getSectionList() { return this.getList(ClaimConsent.action); }
+    setResourceTypeList(values) { return this.setList(ClaimConsent.resourceType, values); }
+    getResourceTypeList() { return this.getList(ClaimConsent.resourceType); }
+    setDate(value) { return this.setOptionalText(ClaimConsent.date, value); }
+    getDate() { return this.getOptionalText(ClaimConsent.date); }
+    setPeriodStart(value) { return this.setOptionalText(ClaimConsent.periodStart, value); }
+    getPeriodStart() { return this.getOptionalText(ClaimConsent.periodStart); }
+    setPeriodEnd(value) { return this.setOptionalText(ClaimConsent.periodEnd, value); }
+    getPeriodEnd() { return this.getOptionalText(ClaimConsent.periodEnd); }
+    setOptionalText(key, value) {
+        const normalized = normalizeText(value);
+        return normalized ? this.setClaim(key, normalized) : this.removeClaim(key);
+    }
+    getOptionalText(key) {
+        return normalizeText(String(this.getClaim(key) || ''));
+    }
+    setList(key, values) {
+        const normalized = normalizeList(values);
+        return normalized.length ? this.setClaim(key, normalized.join(',')) : this.removeClaim(key);
+    }
+    getList(key) {
+        const value = this.getClaim(key);
+        return normalizeList(Array.isArray(value) ? value.map(String) : String(value || '').split(','));
+    }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.consent, ConsentEntryEditor);

package/dist/utils/did.d.ts

@@ -71,7 +71,7 @@ export declare function extractTenantIdFromHostedDidWeb(did: string): string | u
  * Builds the canonical hosted provider DID root used by hosted tenant services.
  *
  * Canonical form:
- * `did:web:<host.domain>:<sector>;organization:taxid:<provider-tax-id>`
+ * `did:web:<host.domain>:<sector>:organization:taxid:<provider-tax-id>`
  *
  * This is the provider-scoped DID root under which hosted individual and member
  * identities are published. Downstream individual DIDs extend this root with
@@ -167,7 +167,7 @@ export declare function buildProfessionalDidWeb(input: {
  *
  * Canonical supported forms:
  * - hosted:
- *   `did:web:<host.domain>:<sector>;organization:taxid:<provider-tax-id>:individual:multibase:<individualId>`
+ *   `did:web:<host.domain>:<sector>:organization:taxid:<provider-tax-id>:individual:multibase:<individualId>`
  * - external/provider-domain:
  *   `did:web:<sector.provider.domain>:individual:multibase:<individualId>`
  *

package/dist/utils/did.js

@@ -137,7 +137,7 @@ export function extractTenantIdFromHostedDidWeb(did) {
  * Builds the canonical hosted provider DID root used by hosted tenant services.
  *
  * Canonical form:
- * `did:web:<host.domain>:<sector>;organization:taxid:<provider-tax-id>`
+ * `did:web:<host.domain>:<sector>:organization:taxid:<provider-tax-id>`
  *
  * This is the provider-scoped DID root under which hosted individual and member
  * identities are published. Downstream individual DIDs extend this root with
@@ -153,7 +153,7 @@ export function buildHostedProviderDidWeb(input) {
         throw new Error('buildHostedProviderDidWeb requires sector.');
     if (!providerTaxId)
         throw new Error('buildHostedProviderDidWeb requires providerTaxId.');
-    return `did:web:${hostDomain}:${sector};organization:taxid:${providerTaxId}`;
+    return `did:web:${hostDomain}:${sector}:organization:taxid:${providerTaxId}`;
 }
 /**
  * Builds the canonical public provider DID root used by an external provider domain.
@@ -269,7 +269,7 @@ export function buildProfessionalDidWeb(input) {
  *
  * Canonical supported forms:
  * - hosted:
- *   `did:web:<host.domain>:<sector>;organization:taxid:<provider-tax-id>:individual:multibase:<individualId>`
+ *   `did:web:<host.domain>:<sector>:organization:taxid:<provider-tax-id>:individual:multibase:<individualId>`
  * - external/provider-domain:
  *   `did:web:<sector.provider.domain>:individual:multibase:<individualId>`
  *

package/dist/utils/index.d.ts

@@ -59,6 +59,7 @@ export * from './clinical-resource-view';
 export * from './fhir-validator';
 export * from './family-registration-test-data';
 export * from './individual-form-pdf';
+export * from './individual-identifier';
 export * from './individual-smart';
 export * from './individual-organization-claims';
 export * from './inter-tenant-access-contract';

package/dist/utils/index.js

@@ -59,6 +59,7 @@ export * from './clinical-resource-view.js';
 export * from './fhir-validator.js';
 export * from './family-registration-test-data.js';
 export * from './individual-form-pdf.js';
+export * from './individual-identifier.js';
 export * from './individual-smart.js';
 export * from './individual-organization-claims.js';
 export * from './inter-tenant-access-contract.js';

package/dist/utils/individual-identifier.d.ts

@@ -0,0 +1,14 @@
+import { type Hl7V20203IdentifierCode, type IdKindValue } from '../constants/identity-identifiers.js';
+export type IndividualIdentifierInput = Readonly<{
+    type: Hl7V20203IdentifierCode | IdKindValue | string;
+    jurisdiction: string;
+    value: string;
+}>;
+/** Resolves a supported short or reverse-DNS HL7 identifier type to one canonical type. */
+export declare function normalizeIndividualIdentifierType(type: IndividualIdentifierInput['type']): IdKindValue;
+/** Builds the sole canonical input hashed for an external individual identifier alias. */
+export declare function buildIndividualIdentifierToken(input: IndividualIdentifierInput): string;
+/** Returns the deterministic CIDv1/SHA3-384 alias stored in `Organization.sameAs`. */
+export declare function buildIndividualIdentifierCid(input: IndividualIdentifierInput): string;
+/** Returns the SHA3-384 multihash URN used as a ledger lookup asset id. */
+export declare function buildIndividualIdentifierLedgerAssetId(input: IndividualIdentifierInput): string;

package/dist/utils/individual-identifier.js

@@ -0,0 +1,39 @@
+import { HL7_V2_0203_REVERSE_DNS_PREFIX, HL7_V2_0203_REVERSE_DNS_TYPES, } from '../constants/identity-identifiers.js';
+import { buildRawCidV1FromUtf8String } from './multiformat-profile.js';
+import { encodeMultibaseSha3 } from './multibasehash.js';
+import { UrnPrefixes } from '../constants/urn.js';
+const LEGACY_HL7_V2_0203_REVERSE_DNS_PREFIX = 'org.hl7.terminology.codesystem.v2-0203';
+const ISO_3166_JURISDICTION_PATTERN = /^[A-Z]{2}(?:-[A-Z0-9]{1,3})?$/;
+/** Resolves a supported short or reverse-DNS HL7 identifier type to one canonical type. */
+export function normalizeIndividualIdentifierType(type) {
+    const candidate = String(type).trim();
+    const shortCode = candidate.startsWith(`${HL7_V2_0203_REVERSE_DNS_PREFIX}.`)
+        ? candidate.slice(HL7_V2_0203_REVERSE_DNS_PREFIX.length + 1)
+        : candidate.startsWith(`${LEGACY_HL7_V2_0203_REVERSE_DNS_PREFIX}.`)
+            ? candidate.slice(LEGACY_HL7_V2_0203_REVERSE_DNS_PREFIX.length + 1)
+            : candidate;
+    const canonical = HL7_V2_0203_REVERSE_DNS_TYPES[shortCode];
+    if (!canonical)
+        throw new Error(`Unsupported individual identifier type: ${candidate}`);
+    return canonical;
+}
+/** Builds the sole canonical input hashed for an external individual identifier alias. */
+export function buildIndividualIdentifierToken(input) {
+    const type = normalizeIndividualIdentifierType(input.type);
+    const jurisdiction = input.jurisdiction.trim().toUpperCase();
+    const value = input.value.trim().normalize('NFKC').toUpperCase();
+    if (!ISO_3166_JURISDICTION_PATTERN.test(jurisdiction)) {
+        throw new Error(`Invalid ISO 3166 jurisdiction: ${input.jurisdiction}`);
+    }
+    if (!value)
+        throw new Error('Individual identifier value is required');
+    return `${type}|${jurisdiction}|${value}`;
+}
+/** Returns the deterministic CIDv1/SHA3-384 alias stored in `Organization.sameAs`. */
+export function buildIndividualIdentifierCid(input) {
+    return buildRawCidV1FromUtf8String(buildIndividualIdentifierToken(input));
+}
+/** Returns the SHA3-384 multihash URN used as a ledger lookup asset id. */
+export function buildIndividualIdentifierLedgerAssetId(input) {
+    return `${UrnPrefixes.Multibase}${encodeMultibaseSha3(buildIndividualIdentifierToken(input))}`;
+}

package/dist/utils/multibasehash.d.ts

@@ -1,8 +1,22 @@
+export type Sha3DigestBits = 224 | 256 | 384 | 512;
 /**
- * Encodes input into multibase(base58btc(multihash(sha384))).
- * - Multihash prefix: 0x15 0x30
- *   - 0x15: code for SHA-384
- *   - 0x30: length of SHA-384 = 48 bytes
- * - Multibase prefix: 'z'
+ * Encodes bytes as `multibase(base58btc(multihash(SHA3-n)))`.
+ *
+ * Contract:
+ * - input strings are hashed as their exact UTF-8 bytes; callers own any
+ *   higher-level identifier or JSON canonicalization
+ * - SHA3-384 is the default profile
+ * - the multihash stores the canonical SHA3 multicodec code and digest length
+ * - the returned `z...` value is a multibase string, not a CID
+ *
+ * Use a CID builder when identifying a content-addressed record. Use this
+ * helper when the multihash itself is the stable identifier or index key.
+ */
+export declare function encodeMultibaseSha3(input: string | Uint8Array, digestBits?: Sha3DigestBits): string;
+/**
+ * @deprecated Use `encodeMultibaseSha3(input)` or pass `384` explicitly.
+ *
+ * This compatibility name now follows its historically intended multihash
+ * profile: SHA3-384, not SHA-2 SHA-384 with a mismatched SHA3 prefix.
  */
 export declare function encodeMultibaseSha384(input: string | Uint8Array): string;

package/dist/utils/multibasehash.js

@@ -1,23 +1,48 @@
 // Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
 // Use explicit .js subpaths to satisfy package exports in Metro/Node ESM.
-import { sha384 } from '@noble/hashes/sha2.js';
+import { sha3_224, sha3_256, sha3_384, sha3_512 } from '@noble/hashes/sha3.js';
 import { utf8ToBytes } from '@noble/hashes/utils.js';
 import baseX from 'base-x';
 const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 const base58btc = baseX(BASE58_ALPHABET);
+const SHA3_PROFILES = Object.freeze({
+    224: Object.freeze({ code: 0x17, digestLengthBytes: 28, digest: sha3_224 }),
+    256: Object.freeze({ code: 0x16, digestLengthBytes: 32, digest: sha3_256 }),
+    384: Object.freeze({ code: 0x15, digestLengthBytes: 48, digest: sha3_384 }),
+    512: Object.freeze({ code: 0x14, digestLengthBytes: 64, digest: sha3_512 }),
+});
 /**
- * Encodes input into multibase(base58btc(multihash(sha384))).
- * - Multihash prefix: 0x15 0x30
- *   - 0x15: code for SHA-384
- *   - 0x30: length of SHA-384 = 48 bytes
- * - Multibase prefix: 'z'
+ * Encodes bytes as `multibase(base58btc(multihash(SHA3-n)))`.
+ *
+ * Contract:
+ * - input strings are hashed as their exact UTF-8 bytes; callers own any
+ *   higher-level identifier or JSON canonicalization
+ * - SHA3-384 is the default profile
+ * - the multihash stores the canonical SHA3 multicodec code and digest length
+ * - the returned `z...` value is a multibase string, not a CID
+ *
+ * Use a CID builder when identifying a content-addressed record. Use this
+ * helper when the multihash itself is the stable identifier or index key.
  */
-export function encodeMultibaseSha384(input) {
+export function encodeMultibaseSha3(input, digestBits = 384) {
+    const profile = SHA3_PROFILES[digestBits];
+    if (!profile) {
+        throw new Error(`Unsupported SHA3 digest size: ${String(digestBits)}`);
+    }
     const bytes = typeof input === 'string' ? utf8ToBytes(input) : input;
-    const hashBytes = sha384(bytes);
+    const hashBytes = profile.digest(bytes);
     const multihashBytes = new Uint8Array(2 + hashBytes.length);
-    multihashBytes[0] = 0x15; // SHA-384 code
-    multihashBytes[1] = 0x30; // length = 48
+    multihashBytes[0] = profile.code;
+    multihashBytes[1] = profile.digestLengthBytes;
     multihashBytes.set(hashBytes, 2);
     return 'z' + base58btc.encode(multihashBytes);
 }
+/**
+ * @deprecated Use `encodeMultibaseSha3(input)` or pass `384` explicitly.
+ *
+ * This compatibility name now follows its historically intended multihash
+ * profile: SHA3-384, not SHA-2 SHA-384 with a mismatched SHA3 prefix.
+ */
+export function encodeMultibaseSha384(input) {
+    return encodeMultibaseSha3(input, 384);
+}

package/dist/utils/multiformat-profile.d.ts

@@ -38,9 +38,11 @@ export declare const SHA3_256_MULTIHASH_PROFILE: MultihashProfile;
  */
 export declare const SHA3_384_MULTIHASH_PROFILE: MultihashProfile;
 /**
- * Builds a `CIDv1` over a UTF-8 string using the provided multihash profile.
+ * Builds a `CIDv1` over a UTF-8 string using SHA3-384 by default.
  *
  * This helper intentionally does not canonicalize the input string for you.
  * Callers must pass the final canonical logical identifier they want to anchor.
+ * A caller may supply another explicit multihash profile when an established
+ * external contract requires it.
  */
-export declare function buildRawCidV1FromUtf8String(value: string, profile: MultihashProfile): string;
+export declare function buildRawCidV1FromUtf8String(value: string, profile?: MultihashProfile): string;

package/dist/utils/multiformat-profile.js

@@ -19,7 +19,7 @@ export const MULTICODEC_RAW_CODE = 0x55;
  */
 export const SHA3_256_MULTIHASH_PROFILE = Object.freeze({
     algorithm: 'sha3-256',
-    code: 0x14,
+    code: 0x16,
     digestLengthBytes: 32,
     digest: sha3_256,
 });
@@ -36,12 +36,14 @@ export const SHA3_384_MULTIHASH_PROFILE = Object.freeze({
     digest: sha3_384,
 });
 /**
- * Builds a `CIDv1` over a UTF-8 string using the provided multihash profile.
+ * Builds a `CIDv1` over a UTF-8 string using SHA3-384 by default.
  *
  * This helper intentionally does not canonicalize the input string for you.
  * Callers must pass the final canonical logical identifier they want to anchor.
+ * A caller may supply another explicit multihash profile when an established
+ * external contract requires it.
  */
-export function buildRawCidV1FromUtf8String(value, profile) {
+export function buildRawCidV1FromUtf8String(value, profile = SHA3_384_MULTIHASH_PROFILE) {
     const digest = profile.digest(utf8ToBytes(String(value || '')));
     const multihash = concatBytes(Uint8Array.from([profile.code, profile.digestLengthBytes]), digest);
     const cidBytes = concatBytes(encodeVarint(MULTIFORMAT_CID_V1_CODE), encodeVarint(MULTICODEC_RAW_CODE), multihash);

package/dist/utils/related-person-entry-editor.d.ts

@@ -0,0 +1,32 @@
+import { BundleEntryEditor } from './bundle-entry-editor';
+/**
+ * Typed editor for one RelatedPerson/contact staged inside a Bundle.
+ *
+ * Relationship authoring is separate from access authorization. This editor
+ * does not grant Consent, build a Communication, submit or poll.
+ */
+export declare class RelatedPersonEntryEditor extends BundleEntryEditor {
+    setIdentifier(value?: string | null): this;
+    getIdentifier(): string | undefined;
+    ensureIdentifier(): string;
+    setActive(value?: boolean | null): this;
+    getActive(): boolean | undefined;
+    setSubject(value?: string | null): this;
+    getSubject(): string | undefined;
+    setRelationship(value?: string | null): this;
+    getRelationship(): string | undefined;
+    setRoleList(values: readonly string[]): this;
+    getRoleList(): string[];
+    setName(value?: string | null): this;
+    getName(): string | undefined;
+    setTelecom(value?: string | null): this;
+    getTelecom(): string | undefined;
+    setRelatedEntityType(value?: string | null): this;
+    getRelatedEntityType(): string | undefined;
+    setActorIdentifierList(values: readonly string[]): this;
+    getActorIdentifierList(): string[];
+    private setOptionalText;
+    private getOptionalText;
+    private setList;
+    private getList;
+}