gdc-common-utils-ts 2.0.18 → 2.2.2

package/dist/models/interoperable-claims/condition-claims.d.ts

@@ -6,9 +6,20 @@ export declare const ConditionClaim: {
     readonly VerificationStatus: "Condition.verification-status";
     readonly Category: "Condition.category";
     readonly Code: "Condition.code";
+    /**
+     * Canonical CSV/list of related contained resource references or identifiers.
+     */
+    readonly ContainedReferenceList: "Condition.contained-reference-list";
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
+    readonly ContainedResourceList: "Condition.contained-resource-list";
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
     readonly ContainedDocuments: "Condition.contained-documents";
     /**
-     * @deprecated Use `ContainedDocuments`.
+     * @deprecated Use `ContainedReferenceList`.
      */
     readonly AttachmentContentIds: "Condition.attachment-content-ids";
     readonly Severity: "Condition.severity";

package/dist/models/interoperable-claims/condition-claims.js

@@ -8,9 +8,20 @@ export const ConditionClaim = {
     VerificationStatus: 'Condition.verification-status',
     Category: 'Condition.category',
     Code: 'Condition.code',
+    /**
+     * Canonical CSV/list of related contained resource references or identifiers.
+     */
+    ContainedReferenceList: 'Condition.contained-reference-list',
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
+    ContainedResourceList: 'Condition.contained-resource-list',
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
     ContainedDocuments: 'Condition.contained-documents',
     /**
-     * @deprecated Use `ContainedDocuments`.
+     * @deprecated Use `ContainedReferenceList`.
      */
     AttachmentContentIds: 'Condition.attachment-content-ids',
     Severity: 'Condition.severity',

package/dist/models/interoperable-claims/diagnostic-report-claims.d.ts

@@ -17,6 +17,17 @@ export declare const DiagnosticReportClaim: {
     readonly PresentedFormContentType: "DiagnosticReport.presented-form-contenttype";
     readonly PresentedFormData: "DiagnosticReport.presented-form-data";
     readonly PresentedFormUrl: "DiagnosticReport.presented-form-url";
+    /**
+     * Canonical CSV/list of related contained resource references or identifiers.
+     */
+    readonly ContainedReferenceList: "DiagnosticReport.contained-reference-list";
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
+    readonly ContainedResourceList: "DiagnosticReport.contained-resource-list";
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
     readonly ContainedDocuments: "DiagnosticReport.contained-documents";
 };
 /**
@@ -31,7 +42,7 @@ export declare const DiagnosticReportClaim: {
  *   - `get/set/add/removeDiagnosticReportResultList`
  *   - `get/set/add/removeDiagnosticReportPerformerList`
  *   - `get/set/add/removeDiagnosticReportSpecimenList`
- *   - `get/set/add/removeDiagnosticReportContainedDocuments`
+ *   - `get/set/add/removeDiagnosticReportContainedResourceReferences`
  *   - `get/setDiagnosticReportPresentedFormContentType`
  *   - `get/setDiagnosticReportPresentedFormData`
  *   - `get/setDiagnosticReportPresentedFormUrl`
@@ -87,10 +98,9 @@ export declare const DiagnosticReportSearchParamToClaimKey: Record<DiagnosticRep
  *
  * Do not invent camelCase names. Prefer official FHIR search parameter names
  * or explicit attachment aliases such as `presented-form-*` and
- * `contained-documents`.
+ * `contained-reference-list`.
  *
  * Keep `DiagnosticReport` paused at the typing/mapping layer until:
  * 1. `claims-helpers-diagnostic-report.ts` exists
- * 2. `CommunicationAttachedBundleSession.upsertActiveDiagnosticReportEntry(...)` exists
- * 3. GW Core readers/tests consume the same shared claim keys
+ * 2. GW Core readers/tests consume the same shared claim keys
  */

package/dist/models/interoperable-claims/diagnostic-report-claims.js

@@ -18,6 +18,17 @@ export const DiagnosticReportClaim = {
     PresentedFormContentType: 'DiagnosticReport.presented-form-contenttype',
     PresentedFormData: 'DiagnosticReport.presented-form-data',
     PresentedFormUrl: 'DiagnosticReport.presented-form-url',
+    /**
+     * Canonical CSV/list of related contained resource references or identifiers.
+     */
+    ContainedReferenceList: 'DiagnosticReport.contained-reference-list',
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
+    ContainedResourceList: 'DiagnosticReport.contained-resource-list',
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
     ContainedDocuments: 'DiagnosticReport.contained-documents',
 };
 export const DiagnosticReportClaimSpecs = [
@@ -96,10 +107,9 @@ export const DiagnosticReportSearchParamToClaimKey = {
  *
  * Do not invent camelCase names. Prefer official FHIR search parameter names
  * or explicit attachment aliases such as `presented-form-*` and
- * `contained-documents`.
+ * `contained-reference-list`.
  *
  * Keep `DiagnosticReport` paused at the typing/mapping layer until:
  * 1. `claims-helpers-diagnostic-report.ts` exists
- * 2. `CommunicationAttachedBundleSession.upsertActiveDiagnosticReportEntry(...)` exists
- * 3. GW Core readers/tests consume the same shared claim keys
+ * 2. GW Core readers/tests consume the same shared claim keys
  */

package/dist/models/interoperable-claims/document-reference-claims.d.ts

@@ -22,6 +22,7 @@ export declare const DocumentReferenceClaim: {
     readonly Relation: "DocumentReference.relation";
     readonly Subject: "DocumentReference.subject";
     readonly Type: "DocumentReference.type";
+    readonly UserSelected: "DocumentReference.user-selected";
 };
 export type DocumentReferenceClaimKey = typeof DocumentReferenceClaim[keyof typeof DocumentReferenceClaim];
 /**

package/dist/models/interoperable-claims/document-reference-claims.js

@@ -24,6 +24,7 @@ export const DocumentReferenceClaim = {
     Relation: 'DocumentReference.relation',
     Subject: 'DocumentReference.subject',
     Type: 'DocumentReference.type',
+    UserSelected: 'DocumentReference.user-selected',
 };
 /**
  * Human-readable reference for UI/docs generators.
@@ -52,6 +53,7 @@ export const DocumentReferenceClaimSpecs = [
     { key: DocumentReferenceClaim.Relation, meaning: 'Relation type to related document.', example: 'appends' },
     { key: DocumentReferenceClaim.Subject, meaning: 'URN for the section in the individual index.', example: 'urn:uhix:section:vitals' },
     { key: DocumentReferenceClaim.Type, meaning: 'Lower-level, sector-specific type.', example: 'http://hl7.org/fhir/ValueSet/c80-doc-typecodes|34133-9' },
+    { key: DocumentReferenceClaim.UserSelected, meaning: 'Custom provenance flag telling whether the document was explicitly created or selected by the end user/controller.', example: 'true' },
 ];
 /**
  * Optional mapping helper when converting claims-first payloads to strict FHIR JSON.
@@ -86,4 +88,5 @@ export const DocumentReferenceClaimToFhirPath = {
     [DocumentReferenceClaim.Relation]: 'DocumentReference.relatesTo.code',
     [DocumentReferenceClaim.Subject]: 'DocumentReference.subject.reference',
     [DocumentReferenceClaim.Type]: 'DocumentReference.type.coding',
+    [DocumentReferenceClaim.UserSelected]: 'DocumentReference.user-selected',
 };

package/dist/models/interoperable-claims/medication-statement-claims.d.ts

@@ -14,6 +14,7 @@ export declare const MedicationStatementClaim: {
     readonly PartOf: "MedicationStatement.part-of";
     readonly Source: "MedicationStatement.source";
     readonly MedicationText: "MedicationStatement.medication-text";
+    readonly UserSelected: "MedicationStatement.user-selected";
     /**
      * Free-text clinical note.
      *
@@ -27,6 +28,22 @@ export declare const MedicationStatementClaim: {
      * `TimingPeriodUnit`, and `DosagePatientInstructionText`.
      */
     readonly Note: "MedicationStatement.note";
+    /**
+     * Canonical CSV/list of related contained resource references or identifiers.
+     *
+     * Values may be:
+     * - `urn:uuid:*`
+     * - `ResourceType/urn:uuid:*`
+     * - another canonical local resource reference used inside the same bundle
+     */
+    readonly ContainedReferenceList: "MedicationStatement.contained-reference-list";
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
+    readonly ContainedResourceList: "MedicationStatement.contained-resource-list";
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
     readonly ContainedDocuments: "MedicationStatement.contained-documents";
     /**
      * @deprecated Use `ContainedDocuments`.

package/dist/models/interoperable-claims/medication-statement-claims.js

@@ -16,6 +16,7 @@ export const MedicationStatementClaim = {
     PartOf: 'MedicationStatement.part-of',
     Source: 'MedicationStatement.source',
     MedicationText: 'MedicationStatement.medication-text',
+    UserSelected: 'MedicationStatement.user-selected',
     /**
      * Free-text clinical note.
      *
@@ -29,6 +30,22 @@ export const MedicationStatementClaim = {
      * `TimingPeriodUnit`, and `DosagePatientInstructionText`.
      */
     Note: 'MedicationStatement.note',
+    /**
+     * Canonical CSV/list of related contained resource references or identifiers.
+     *
+     * Values may be:
+     * - `urn:uuid:*`
+     * - `ResourceType/urn:uuid:*`
+     * - another canonical local resource reference used inside the same bundle
+     */
+    ContainedReferenceList: 'MedicationStatement.contained-reference-list',
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
+    ContainedResourceList: 'MedicationStatement.contained-resource-list',
+    /**
+     * @deprecated Use `ContainedReferenceList`.
+     */
     ContainedDocuments: 'MedicationStatement.contained-documents',
     /**
      * @deprecated Use `ContainedDocuments`.

package/dist/models/profile-manager.d.ts

@@ -0,0 +1,85 @@
+import type { WalletMessagePriority, WalletQueuedMessage } from './wallet';
+/**
+ * Minimal local profile descriptor for memory-backed wallet/runtime tests.
+ *
+ * This stays intentionally below actor-specific SDK facades.
+ */
+export type ProfileManagerMemProfile = Readonly<{
+    profileId: string;
+    displayName?: string;
+    did: string;
+}>;
+/**
+ * Result returned by one backend message transport after submitting one local
+ * queued message envelope.
+ */
+export type BackendMessageTransportSubmitResult = Readonly<{
+    accepted: boolean;
+    retryable?: boolean;
+    errorMessage?: string;
+    responseEnvelope?: string;
+    locationUrl?: string;
+}>;
+/**
+ * Result returned by one backend message poll operation after a previous
+ * transport submit accepted the request asynchronously.
+ */
+export type BackendMessageTransportPollResult = Readonly<{
+    pending: boolean;
+    completed?: boolean;
+    retryable?: boolean;
+    errorMessage?: string;
+    responseEnvelope?: string;
+}>;
+/**
+ * Pluggable submit-only transport used by the low-level backend message manager.
+ */
+export type BackendMessageTransport = Readonly<{
+    submit(input: Readonly<{
+        message: WalletQueuedMessage;
+        envelope: string;
+    }>): Promise<BackendMessageTransportSubmitResult>;
+    poll?(input: Readonly<{
+        message: ProfileOutboxMessageRecord;
+    }>): Promise<BackendMessageTransportPollResult>;
+}>;
+/**
+ * One decoded inbound response associated with one DIDComm thread.
+ */
+export type BackendMessageResponseRecord = Readonly<{
+    thid: string;
+    receivedAt: string;
+    content: Record<string, unknown>;
+    meta: Record<string, unknown>;
+}>;
+/**
+ * Immutable historical record written after one profile message is submitted.
+ *
+ * It complements the mutable queue state by preserving:
+ * - the final submitted envelope
+ * - the last known queue status at submission time
+ * - the optional decoded response thread reference
+ */
+export type ProfileOutboxMessageRecord = Readonly<{
+    id: string;
+    thid?: string;
+    messageType?: string;
+    priority: string;
+    status: string;
+    transportStatus?: 'submitted' | 'completed' | 'failed';
+    recordedAt: string;
+    payload: Record<string, unknown>;
+    envelope: string;
+    responseThid?: string;
+    locationUrl?: string;
+    pollCount?: number;
+}>;
+/**
+ * Input used by `BackendMessageManagerMem` and `ProfileManagerMem` to queue one
+ * outbound business payload.
+ */
+export type QueueProfileMessageInput = Readonly<{
+    payload: Record<string, unknown>;
+    priority?: WalletMessagePriority;
+    recipientEncryptionJwk: Record<string, unknown>;
+}>;

package/dist/models/profile-manager.js

@@ -0,0 +1,2 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+export {};

package/dist/models/wallet.d.ts

@@ -0,0 +1,59 @@
+import type { JWK } from './jwk';
+/**
+ * Canonical priority levels for wallet-managed outbound messages.
+ *
+ * Ordering rule:
+ * - `emergency` is always processed before all other priorities
+ * - for the same priority level, insertion order must be preserved
+ */
+export declare const WalletMessagePriorities: Readonly<{
+    readonly Emergency: "emergency";
+    readonly High: "high";
+    readonly Normal: "normal";
+    readonly Low: "low";
+}>;
+export type WalletMessagePriority = typeof WalletMessagePriorities[keyof typeof WalletMessagePriorities];
+/**
+ * Lifecycle states for one local wallet queue/outbox message.
+ */
+export declare const WalletQueueStatuses: Readonly<{
+    readonly Pending: "pending";
+    readonly Delivered: "delivered";
+    readonly Failed: "failed";
+}>;
+export type WalletQueueStatus = typeof WalletQueueStatuses[keyof typeof WalletQueueStatuses];
+/**
+ * One message tracked by the local wallet queue or outbox.
+ */
+export type WalletQueuedMessage = Readonly<{
+    id: string;
+    createdAt: string;
+    priority: WalletMessagePriority;
+    status: WalletQueueStatus;
+    sequence: number;
+    payload: Record<string, unknown>;
+    thid?: string;
+    messageType?: string;
+    deliveredAt?: string;
+    errorMessage?: string;
+}>;
+/**
+ * Input accepted by wallet-local queue implementations when creating one
+ * queued outbound message.
+ */
+export type WalletEnqueueMessageInput = Readonly<{
+    payload: Record<string, unknown>;
+    priority?: WalletMessagePriority;
+    thid?: string;
+    messageType?: string;
+    id?: string;
+    createdAt?: string;
+}>;
+/**
+ * Public summary of one wallet-managed entity key set.
+ */
+export type WalletManagedEntityDescriptor = Readonly<{
+    entityId: string;
+    signingJwk: JWK;
+    encryptionJwk: JWK;
+}>;

package/dist/models/wallet.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+/**
+ * Canonical priority levels for wallet-managed outbound messages.
+ *
+ * Ordering rule:
+ * - `emergency` is always processed before all other priorities
+ * - for the same priority level, insertion order must be preserved
+ */
+export const WalletMessagePriorities = Object.freeze({
+    Emergency: 'emergency',
+    High: 'high',
+    Normal: 'normal',
+    Low: 'low',
+});
+/**
+ * Lifecycle states for one local wallet queue/outbox message.
+ */
+export const WalletQueueStatuses = Object.freeze({
+    Pending: 'pending',
+    Delivered: 'delivered',
+    Failed: 'failed',
+});

package/dist/utils/allergy-intolerance-entry-editor.d.ts

@@ -0,0 +1,51 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged AllergyIntolerance resource entry.
+ *
+ * Use this from frontend/BFF bundle-authoring flows when the caller needs one
+ * allergy row with canonical claims-first accessors.
+ */
+export declare class AllergyIntoleranceEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical allergy identifier. */
+    setIdentifier(identifier?: string | null): this;
+    /** Reads the canonical allergy identifier. */
+    getIdentifier(): string | undefined;
+    /** Ensures the allergy entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier(): string;
+    /** Writes the subject/patient reference for the allergy entry. */
+    setSubject(subject?: string | null): this;
+    /** Reads the subject/patient reference for the allergy entry. */
+    getSubject(): string | undefined;
+    /** Writes the coded allergy substance. */
+    setCode(code?: string | null): this;
+    /** Reads the coded allergy substance. */
+    getCode(): string | undefined;
+    /** Writes the clinical status. */
+    setClinicalStatus(status?: string | null): this;
+    /** Reads the clinical status. */
+    getClinicalStatus(): string | undefined;
+    /** Writes the verification status. */
+    setVerificationStatus(status?: string | null): this;
+    /** Reads the verification status. */
+    getVerificationStatus(): string | undefined;
+    /** Writes the allergy category. */
+    setCategory(category?: string | null): this;
+    /** Reads the allergy category. */
+    getCategory(): string | undefined;
+    /** Writes the allergy criticality. */
+    setCriticality(criticality?: string | null): this;
+    /** Reads the allergy criticality. */
+    getCriticality(): string | undefined;
+    /** Writes the onset date/time. */
+    setOnsetDateTime(value?: string | null): this;
+    /** Reads the onset date/time. */
+    getOnsetDateTime(): string | undefined;
+    /** Writes the recorder reference. */
+    setRecorder(reference?: string | null): this;
+    /** Reads the recorder reference. */
+    getRecorder(): string | undefined;
+    /** Writes the linked contained-document identifier list. */
+    setContainedDocumentIdentifierList(identifiers: readonly string[]): this;
+    /** Reads the linked contained-document identifier list. */
+    getContainedDocumentIdentifierList(): string[];
+}

package/dist/utils/allergy-intolerance-entry-editor.js

@@ -0,0 +1,55 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor.js';
+import { AllergyIntoleranceClaim } from '../models/interoperable-claims/allergy-intolerance-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged AllergyIntolerance resource entry.
+ *
+ * Use this from frontend/BFF bundle-authoring flows when the caller needs one
+ * allergy row with canonical claims-first accessors.
+ */
+export class AllergyIntoleranceEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical allergy identifier. */
+    setIdentifier(identifier) { return this.setIdentifierValue(AllergyIntoleranceClaim.Identifier, identifier); }
+    /** Reads the canonical allergy identifier. */
+    getIdentifier() { return this.getIdentifierValue(AllergyIntoleranceClaim.Identifier); }
+    /** Ensures the allergy entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier() { return this.ensureIdentifierValue(AllergyIntoleranceClaim.Identifier); }
+    /** Writes the subject/patient reference for the allergy entry. */
+    setSubject(subject) { return this.setSubjectClaims(AllergyIntoleranceClaim.Subject, AllergyIntoleranceClaim.Patient, subject); }
+    /** Reads the subject/patient reference for the allergy entry. */
+    getSubject() { return this.getSubjectClaims(AllergyIntoleranceClaim.Subject, AllergyIntoleranceClaim.Patient); }
+    /** Writes the coded allergy substance. */
+    setCode(code) { return this.setScalarClaim(AllergyIntoleranceClaim.Code, code); }
+    /** Reads the coded allergy substance. */
+    getCode() { return this.getScalarClaim(AllergyIntoleranceClaim.Code); }
+    /** Writes the clinical status. */
+    setClinicalStatus(status) { return this.setScalarClaim(AllergyIntoleranceClaim.ClinicalStatus, status); }
+    /** Reads the clinical status. */
+    getClinicalStatus() { return this.getScalarClaim(AllergyIntoleranceClaim.ClinicalStatus); }
+    /** Writes the verification status. */
+    setVerificationStatus(status) { return this.setScalarClaim(AllergyIntoleranceClaim.VerificationStatus, status); }
+    /** Reads the verification status. */
+    getVerificationStatus() { return this.getScalarClaim(AllergyIntoleranceClaim.VerificationStatus); }
+    /** Writes the allergy category. */
+    setCategory(category) { return this.setScalarClaim(AllergyIntoleranceClaim.Category, category); }
+    /** Reads the allergy category. */
+    getCategory() { return this.getScalarClaim(AllergyIntoleranceClaim.Category); }
+    /** Writes the allergy criticality. */
+    setCriticality(criticality) { return this.setScalarClaim(AllergyIntoleranceClaim.Criticality, criticality); }
+    /** Reads the allergy criticality. */
+    getCriticality() { return this.getScalarClaim(AllergyIntoleranceClaim.Criticality); }
+    /** Writes the onset date/time. */
+    setOnsetDateTime(value) { return this.setScalarClaim(AllergyIntoleranceClaim.OnsetDateTime, value); }
+    /** Reads the onset date/time. */
+    getOnsetDateTime() { return this.getScalarClaim(AllergyIntoleranceClaim.OnsetDateTime); }
+    /** Writes the recorder reference. */
+    setRecorder(reference) { return this.setScalarClaim(AllergyIntoleranceClaim.Recorder, reference); }
+    /** Reads the recorder reference. */
+    getRecorder() { return this.getScalarClaim(AllergyIntoleranceClaim.Recorder); }
+    /** Writes the linked contained-document identifier list. */
+    setContainedDocumentIdentifierList(identifiers) { return this.setCsvClaimList(AllergyIntoleranceClaim.ContainedDocuments, identifiers); }
+    /** Reads the linked contained-document identifier list. */
+    getContainedDocumentIdentifierList() { return this.getCsvClaimList(AllergyIntoleranceClaim.ContainedDocuments); }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.allergyIntolerance, AllergyIntoleranceEntryEditor);

package/dist/utils/authority-resolution.d.ts

@@ -0,0 +1,37 @@
+import type { AuthorityCatalogRecord, AuthorityResolution, AuthorityResolutionInput } from '../models/authority-resolution';
+/**
+ * Builds one authority/root `did:web` from a bare host authority or URL.
+ *
+ * Examples:
+ * - `https://gw.example.org` -> `did:web:gw.example.org`
+ * - `localhost:3300` -> `did:web:localhost%3A3300`
+ */
+export declare function buildAuthorityDidWeb(input: {
+    authority: string;
+}): string;
+/**
+ * Normalizes one authority base URL from either an explicit URL or one
+ * authority/root `did:web`.
+ */
+export declare function resolveAuthorityBaseUrl(input: {
+    authorityBaseUrl?: string;
+    authorityDidWeb?: string;
+}): string | undefined;
+/**
+ * Builds one compatibility authority resolution when the caller only knows:
+ * - tenant context
+ * - one base URL or one root authority `did:web`
+ *
+ * This helper intentionally keeps the current hosted-DID fallback in one place
+ * so app code does not have to hand-invent `did:web` strings.
+ */
+export declare function buildLegacyAuthorityResolution(input: AuthorityResolutionInput & Readonly<{
+    tenantId: string;
+    jurisdiction: string;
+    sector: string;
+}>): AuthorityResolution;
+/**
+ * Converts one resolution into a catalog-style record so runtimes can preload
+ * legacy fallback data into a shared resolver cache.
+ */
+export declare function authorityResolutionToCatalogRecord(resolution: AuthorityResolution): AuthorityCatalogRecord;

package/dist/utils/authority-resolution.js

@@ -0,0 +1,112 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { buildOrganizationDidWeb, getBaseUrlFromDidWeb } from './did.js';
+function normalizeString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function encodeDidWebAuthority(authority) {
+    return authority.replace(/:/g, '%3A').toLowerCase();
+}
+function normalizeAuthorityHost(value) {
+    const raw = normalizeString(value).replace(/\/+$/, '');
+    if (!raw)
+        return '';
+    if (/^https?:\/\//i.test(raw)) {
+        try {
+            return new URL(raw).host;
+        }
+        catch {
+            return raw.replace(/^https?:\/\//i, '');
+        }
+    }
+    return raw;
+}
+function protocolForAuthority(authority) {
+    const normalized = authority.trim().toLowerCase();
+    return normalized.startsWith('localhost')
+        || normalized.startsWith('127.0.0.1')
+        || normalized.startsWith('[::1]')
+        ? 'http'
+        : 'https';
+}
+function inferMatchedBy(input) {
+    if (normalizeString(input.subjectDid))
+        return 'subject-did';
+    if (normalizeString(input.subjectSameAs))
+        return 'subject-same-as';
+    if (normalizeString(input.authorityDidWeb))
+        return 'authority-did';
+    if (normalizeString(input.authorityBaseUrl))
+        return 'authority-base-url';
+    return 'tenant-context';
+}
+/**
+ * Builds one authority/root `did:web` from a bare host authority or URL.
+ *
+ * Examples:
+ * - `https://gw.example.org` -> `did:web:gw.example.org`
+ * - `localhost:3300` -> `did:web:localhost%3A3300`
+ */
+export function buildAuthorityDidWeb(input) {
+    const authority = normalizeAuthorityHost(input.authority);
+    if (!authority)
+        throw new Error('buildAuthorityDidWeb requires authority.');
+    return `did:web:${encodeDidWebAuthority(authority)}`;
+}
+/**
+ * Normalizes one authority base URL from either an explicit URL or one
+ * authority/root `did:web`.
+ */
+export function resolveAuthorityBaseUrl(input) {
+    const direct = normalizeString(input.authorityBaseUrl);
+    if (direct) {
+        const host = normalizeAuthorityHost(direct);
+        return host ? `${protocolForAuthority(host)}://${host}/` : undefined;
+    }
+    const did = normalizeString(input.authorityDidWeb);
+    if (!did)
+        return undefined;
+    return getBaseUrlFromDidWeb(did);
+}
+/**
+ * Builds one compatibility authority resolution when the caller only knows:
+ * - tenant context
+ * - one base URL or one root authority `did:web`
+ *
+ * This helper intentionally keeps the current hosted-DID fallback in one place
+ * so app code does not have to hand-invent `did:web` strings.
+ */
+export function buildLegacyAuthorityResolution(input) {
+    const authorityDidWeb = normalizeString(input.authorityDidWeb)
+        || buildAuthorityDidWeb({ authority: normalizeString(input.authorityBaseUrl) });
+    const authorityBaseUrl = resolveAuthorityBaseUrl({
+        authorityBaseUrl: input.authorityBaseUrl,
+        authorityDidWeb,
+    });
+    const tenantDidWeb = buildOrganizationDidWeb({
+        hostDidWeb: authorityDidWeb,
+        tenantId: input.tenantId,
+        jurisdiction: input.jurisdiction,
+        version: normalizeString(input.version) || 'v1',
+        sector: input.sector,
+    });
+    return {
+        authorityDidWeb,
+        authorityBaseUrl,
+        tenantDidWeb,
+        metadataUrl: normalizeString(input.metadataUrl) || undefined,
+        source: 'legacy',
+        matchedBy: inferMatchedBy(input),
+    };
+}
+/**
+ * Converts one resolution into a catalog-style record so runtimes can preload
+ * legacy fallback data into a shared resolver cache.
+ */
+export function authorityResolutionToCatalogRecord(resolution) {
+    return {
+        authorityDidWeb: resolution.authorityDidWeb,
+        authorityBaseUrl: resolution.authorityBaseUrl,
+        tenantDidWeb: resolution.tenantDidWeb,
+        metadataUrl: resolution.metadataUrl,
+    };
+}