gdc-common-utils-ts 2.0.6 → 2.0.7

package/README.md

@@ -138,6 +138,8 @@ read first:
 
 - [`docs/101-COMMUNICATION_LAYERING.md`](docs/101-COMMUNICATION_LAYERING.md)
 - [`docs/101-BUNDLE_EDITOR_READER.md`](docs/101-BUNDLE_EDITOR_READER.md)
+- [`docs/101-CLINICAL-IPS.md`](docs/101-CLINICAL-IPS.md)
+- [`docs/REFERENCE-CLINICAL-IPS-API.md`](docs/REFERENCE-CLINICAL-IPS-API.md)
 - [`docs/101-CONSENT_PERMISSION_TEMPLATES.md`](docs/101-CONSENT_PERMISSION_TEMPLATES.md)
 
 ## Install
@@ -270,6 +272,12 @@ import { JweObject, JwtCompactParts } from 'gdc-common-utils-ts/models';
     planning
 - [docs/101-IPS_BUNDLE.md](docs/101-IPS_BUNDLE.md)
   - canonical 101 for requesting IPS, editing IPS-style bundles in `Communication.content-attachment-data`, and reading resources by section
+- [docs/101-CLINICAL-IPS.md](docs/101-CLINICAL-IPS.md)
+  - shortest high-level onboarding for `ipsBundleReader`, section summaries,
+    family queries, and UI-ready narrative helpers
+- [docs/REFERENCE-CLINICAL-IPS-API.md](docs/REFERENCE-CLINICAL-IPS-API.md)
+  - canonical claim/method matrix with `TODO` coverage for missing typed
+    `get...` / `set...` helpers
 
 ## Dataspace Protocol And Discovery
 

package/dist/constants/clinical-statuses.d.ts

@@ -0,0 +1,83 @@
+export declare const AllergyIntoleranceClinicalStatuses: Readonly<{
+    readonly Active: "active";
+    readonly Inactive: "inactive";
+    readonly Resolved: "resolved";
+}>;
+export type AllergyIntoleranceClinicalStatus = typeof AllergyIntoleranceClinicalStatuses[keyof typeof AllergyIntoleranceClinicalStatuses];
+export declare const AllergyIntoleranceVerificationStatuses: Readonly<{
+    readonly Unconfirmed: "unconfirmed";
+    readonly Confirmed: "confirmed";
+    readonly Refuted: "refuted";
+    readonly EnteredInError: "entered-in-error";
+}>;
+export type AllergyIntoleranceVerificationStatus = typeof AllergyIntoleranceVerificationStatuses[keyof typeof AllergyIntoleranceVerificationStatuses];
+export declare const ConditionClinicalStatuses: Readonly<{
+    readonly Active: "active";
+    readonly Recurrence: "recurrence";
+    readonly Relapse: "relapse";
+    readonly Inactive: "inactive";
+    readonly Remission: "remission";
+    readonly Resolved: "resolved";
+}>;
+export type ConditionClinicalStatus = typeof ConditionClinicalStatuses[keyof typeof ConditionClinicalStatuses];
+export declare const ConditionVerificationStatuses: Readonly<{
+    readonly Unconfirmed: "unconfirmed";
+    readonly Provisional: "provisional";
+    readonly Differential: "differential";
+    readonly Confirmed: "confirmed";
+    readonly Refuted: "refuted";
+    readonly EnteredInError: "entered-in-error";
+}>;
+export type ConditionVerificationStatus = typeof ConditionVerificationStatuses[keyof typeof ConditionVerificationStatuses];
+export declare const MedicationStatementStatuses: Readonly<{
+    readonly Active: "active";
+    readonly Completed: "completed";
+    readonly EnteredInError: "entered-in-error";
+    readonly Intended: "intended";
+    readonly Stopped: "stopped";
+    readonly OnHold: "on-hold";
+    readonly Unknown: "unknown";
+    readonly NotTaken: "not-taken";
+}>;
+export type MedicationStatementStatus = typeof MedicationStatementStatuses[keyof typeof MedicationStatementStatuses];
+export declare const ImmunizationStatuses: Readonly<{
+    readonly Completed: "completed";
+    readonly EnteredInError: "entered-in-error";
+    readonly NotDone: "not-done";
+}>;
+export type ImmunizationStatus = typeof ImmunizationStatuses[keyof typeof ImmunizationStatuses];
+export declare const ProcedureStatuses: Readonly<{
+    readonly Preparation: "preparation";
+    readonly InProgress: "in-progress";
+    readonly NotDone: "not-done";
+    readonly OnHold: "on-hold";
+    readonly Stopped: "stopped";
+    readonly Completed: "completed";
+    readonly EnteredInError: "entered-in-error";
+    readonly Unknown: "unknown";
+}>;
+export type ProcedureStatus = typeof ProcedureStatuses[keyof typeof ProcedureStatuses];
+export declare const DiagnosticReportStatuses: Readonly<{
+    readonly Registered: "registered";
+    readonly Partial: "partial";
+    readonly Preliminary: "preliminary";
+    readonly Final: "final";
+    readonly Amended: "amended";
+    readonly Corrected: "corrected";
+    readonly Appended: "appended";
+    readonly Cancelled: "cancelled";
+    readonly EnteredInError: "entered-in-error";
+    readonly Unknown: "unknown";
+}>;
+export type DiagnosticReportStatus = typeof DiagnosticReportStatuses[keyof typeof DiagnosticReportStatuses];
+export declare const ObservationStatuses: Readonly<{
+    readonly Registered: "registered";
+    readonly Preliminary: "preliminary";
+    readonly Final: "final";
+    readonly Amended: "amended";
+    readonly Corrected: "corrected";
+    readonly Cancelled: "cancelled";
+    readonly EnteredInError: "entered-in-error";
+    readonly Unknown: "unknown";
+}>;
+export type ObservationStatus = typeof ObservationStatuses[keyof typeof ObservationStatuses];

package/dist/constants/clinical-statuses.js

@@ -0,0 +1,74 @@
+export const AllergyIntoleranceClinicalStatuses = Object.freeze({
+    Active: 'active',
+    Inactive: 'inactive',
+    Resolved: 'resolved',
+});
+export const AllergyIntoleranceVerificationStatuses = Object.freeze({
+    Unconfirmed: 'unconfirmed',
+    Confirmed: 'confirmed',
+    Refuted: 'refuted',
+    EnteredInError: 'entered-in-error',
+});
+export const ConditionClinicalStatuses = Object.freeze({
+    Active: 'active',
+    Recurrence: 'recurrence',
+    Relapse: 'relapse',
+    Inactive: 'inactive',
+    Remission: 'remission',
+    Resolved: 'resolved',
+});
+export const ConditionVerificationStatuses = Object.freeze({
+    Unconfirmed: 'unconfirmed',
+    Provisional: 'provisional',
+    Differential: 'differential',
+    Confirmed: 'confirmed',
+    Refuted: 'refuted',
+    EnteredInError: 'entered-in-error',
+});
+export const MedicationStatementStatuses = Object.freeze({
+    Active: 'active',
+    Completed: 'completed',
+    EnteredInError: 'entered-in-error',
+    Intended: 'intended',
+    Stopped: 'stopped',
+    OnHold: 'on-hold',
+    Unknown: 'unknown',
+    NotTaken: 'not-taken',
+});
+export const ImmunizationStatuses = Object.freeze({
+    Completed: 'completed',
+    EnteredInError: 'entered-in-error',
+    NotDone: 'not-done',
+});
+export const ProcedureStatuses = Object.freeze({
+    Preparation: 'preparation',
+    InProgress: 'in-progress',
+    NotDone: 'not-done',
+    OnHold: 'on-hold',
+    Stopped: 'stopped',
+    Completed: 'completed',
+    EnteredInError: 'entered-in-error',
+    Unknown: 'unknown',
+});
+export const DiagnosticReportStatuses = Object.freeze({
+    Registered: 'registered',
+    Partial: 'partial',
+    Preliminary: 'preliminary',
+    Final: 'final',
+    Amended: 'amended',
+    Corrected: 'corrected',
+    Appended: 'appended',
+    Cancelled: 'cancelled',
+    EnteredInError: 'entered-in-error',
+    Unknown: 'unknown',
+});
+export const ObservationStatuses = Object.freeze({
+    Registered: 'registered',
+    Preliminary: 'preliminary',
+    Final: 'final',
+    Amended: 'amended',
+    Corrected: 'corrected',
+    Cancelled: 'cancelled',
+    EnteredInError: 'entered-in-error',
+    Unknown: 'unknown',
+});

package/dist/constants/index.d.ts

@@ -1,5 +1,6 @@
 export * from './actor-session';
 export * from './communication';
+export * from './clinical-statuses';
 export * from './cryptography';
 export * from './data-capabilities';
 export * from './dataspace-discovery';

package/dist/constants/index.js

@@ -1,5 +1,6 @@
 export * from './actor-session.js';
 export * from './communication.js';
+export * from './clinical-statuses.js';
 export * from './cryptography.js';
 export * from './data-capabilities.js';
 export * from './dataspace-discovery.js';

package/dist/examples/ips-bundle.js

@@ -56,6 +56,7 @@ export function buildIpsClinicalHistoryBundleExample() {
             '@context': 'org.hl7.fhir.api',
             [MedicationStatementClaim.Identifier]: EXAMPLE_MEDICATION_STATEMENT_IDENTIFIER,
             [MedicationStatementClaim.Subject]: EXAMPLE_SUBJECT_DID,
+            [MedicationStatementClaim.Category]: HealthcareBasicSections.HistoryOfMedicationUse.attributeValue,
             [MedicationStatementClaim.Status]: EXAMPLE_MEDICATION_STATEMENT_STATUS,
             [MedicationStatementClaim.MedicationText]: EXAMPLE_MEDICATION_STATEMENT_TEXT,
             [MedicationStatementClaim.Effective]: '2026-05-05',

package/dist/storage/IVaultRepository.js

@@ -1,10 +1,10 @@
 // Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
 // File: src/storage/IVaultRepository.ts
 // ---------------------------------------------------------------------------
-// Base contract — used by all channels (voice, chat, mobile)
+// Base contract — used by all channels (chat, mobile, web, backend)
 //
 // Each vault instance is scoped to a single actor/session context
-// (e.g. callSid for voice, userId for text channels).
+// (e.g. one transient session id or one user id).
 //
 // collectionName → logical bucket within the vault (e.g. 'tokens', 'session')
 // containerId    → unique record id within the bucket

package/dist/storage/VaultMemRepository.d.ts

@@ -5,7 +5,7 @@ import { IVaultRepository, VaultQuery } from './IVaultRepository';
  *
  * Intended for:
  * - Unit/integration tests across all packages
- * - Short-lived runtime contexts (voice calls, transient sessions)
+ * - Short-lived runtime contexts (transient sessions)
  *
  * Each instance is independent — instantiate one per actor/session context
  * (e.g. one per CallSid in uhc-unid-chat-node) and discard on cleanup.

package/dist/storage/VaultMemRepository.js

@@ -6,7 +6,7 @@ import { IVaultRepository } from './IVaultRepository.js';
  *
  * Intended for:
  * - Unit/integration tests across all packages
- * - Short-lived runtime contexts (voice calls, transient sessions)
+ * - Short-lived runtime contexts (transient sessions)
  *
  * Each instance is independent — instantiate one per actor/session context
  * (e.g. one per CallSid in uhc-unid-chat-node) and discard on cleanup.

package/dist/utils/clinical-resource-view.d.ts

@@ -29,6 +29,28 @@ export type ClinicalResourceExpandedView = Readonly<{
     xhtml?: string;
     notes: string[];
 }>;
+export type ClinicalResourceLike = Readonly<{
+    resourceType?: string;
+    text?: {
+        div?: unknown;
+    };
+    meta?: {
+        claims?: Record<string, unknown>;
+    };
+    note?: unknown;
+    code?: unknown;
+    valueQuantity?: unknown;
+    [key: string]: unknown;
+}>;
+export type LocalTextAndIntDisplay = Readonly<{
+    localText?: string;
+    internationalDisplay?: string;
+    combined?: string;
+}>;
+export type NarrativeResult = Readonly<{
+    xhtml?: string;
+    source: 'resource.text.div' | 'derived-from-claims' | 'missing';
+}>;
 export type ClinicalResourceEntryLike = Readonly<{
     fullUrl?: string;
     type?: string;
@@ -65,3 +87,18 @@ export declare function toClinicalResourceExpandedView(entry: ClinicalResourceEn
  * Maps all entries from a Bundle into expanded views.
  */
 export declare function toClinicalResourceExpandedViews(bundle: ClinicalResourceBundleLike): ClinicalResourceExpandedView[];
+/**
+ * Returns the most useful local text plus international display pair that can
+ * be inferred from one FHIR-like resource and its `meta.claims`.
+ */
+export declare function getLocalTextAndIntDisplay(resource: ClinicalResourceLike): LocalTextAndIntDisplay;
+/**
+ * Returns XHTML narrative for one FHIR-like resource, preferring
+ * `resource.text.div` and otherwise deriving a deterministic fallback from
+ * canonical `meta.claims`.
+ */
+export declare function getXhtmlOrDerived(resource: ClinicalResourceLike): string | undefined;
+/**
+ * Returns XHTML plus the source used to obtain it.
+ */
+export declare function getNarrative(resource: ClinicalResourceLike): NarrativeResult;

package/dist/utils/clinical-resource-view.js

@@ -4,7 +4,9 @@ import { ClaimConsent } from '../models/consent-rule.js';
 import { AllergyIntoleranceClaim, AllergyIntoleranceClaimsFhirApi, } from '../models/interoperable-claims/allergy-intolerance-claims.js';
 import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
 import { ConditionClaim, ConditionClaimsFhirApi, } from '../models/interoperable-claims/condition-claims.js';
-import { MedicationStatementClaim, MedicationStatementClaimsFhirApi, } from '../models/interoperable-claims/medication-statement-claims.js';
+import { ImmunizationClaim } from '../models/interoperable-claims/immunization-claims.js';
+import { MedicationStatementClaim, MedicationStatementClaimsFhirApi, MedicationStatementClaimsFhirApiExtended, } from '../models/interoperable-claims/medication-statement-claims.js';
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
 const CONSENT_ACTOR_REFERENCE_CLAIM = 'Consent.actor-reference';
 const GENERIC_CREATOR_CLAIM_SUFFIX = '.creator';
 const GENERIC_PERFORMER_CLAIM_SUFFIX = '.performer';
@@ -70,6 +72,73 @@ export function toClinicalResourceExpandedView(entry) {
 export function toClinicalResourceExpandedViews(bundle) {
     return readBundleEntries(bundle).map((entry) => toClinicalResourceExpandedView(entry));
 }
+/**
+ * Returns the most useful local text plus international display pair that can
+ * be inferred from one FHIR-like resource and its `meta.claims`.
+ */
+export function getLocalTextAndIntDisplay(resource) {
+    const claims = asRecord(resource?.meta?.claims);
+    const resourceType = resolveResourceType({ resource }, claims);
+    const localText = firstDefinedText([
+        resolveResourceCodeText(resource),
+        findBySuffix(claims, '.code-text'),
+        findBySuffix(claims, '.medication-text'),
+        findBySuffix(claims, '.vaccine-code-text'),
+        findBySuffix(claims, '.value-concept-text'),
+    ]) || resolveTitle(resourceType, claims);
+    const internationalDisplay = firstDefinedText([
+        resolveResourceCodeDisplay(resource),
+        findBySuffix(claims, '.code-display'),
+        findBySuffix(claims, '.vaccine-code-display'),
+        findBySuffix(claims, '.value-concept-display'),
+    ]);
+    const combined = buildCombinedLabel(localText, internationalDisplay);
+    return {
+        ...(localText ? { localText } : {}),
+        ...(internationalDisplay ? { internationalDisplay } : {}),
+        ...(combined ? { combined } : {}),
+    };
+}
+/**
+ * Returns XHTML narrative for one FHIR-like resource, preferring
+ * `resource.text.div` and otherwise deriving a deterministic fallback from
+ * canonical `meta.claims`.
+ */
+export function getXhtmlOrDerived(resource) {
+    return getNarrative(resource).xhtml;
+}
+/**
+ * Returns XHTML plus the source used to obtain it.
+ */
+export function getNarrative(resource) {
+    const fromFhirNarrative = trimValue(asRecord(resource?.text).div);
+    if (fromFhirNarrative) {
+        return {
+            xhtml: fromFhirNarrative,
+            source: 'resource.text.div',
+        };
+    }
+    const claims = asRecord(resource?.meta?.claims);
+    const fromSpecificClaim = findBySuffix(claims, '.xhtml')
+        || findBySuffix(claims, '.text-div');
+    if (fromSpecificClaim) {
+        return {
+            xhtml: fromSpecificClaim,
+            source: 'derived-from-claims',
+        };
+    }
+    const resourceType = resolveResourceType({ resource }, claims);
+    const lines = buildNarrativeLines(resourceType, claims, resource);
+    if (lines.length === 0) {
+        return {
+            source: 'missing',
+        };
+    }
+    return {
+        xhtml: `<div xmlns="http://www.w3.org/1999/xhtml">${lines.map((line) => `<p>${escapeHtml(line)}</p>`).join('')}</div>`,
+        source: 'derived-from-claims',
+    };
+}
 function readClaims(entry) {
     const resourceClaims = asRecord(entry?.resource?.meta?.claims);
     const legacyClaims = asRecord(entry?.meta?.claims);
@@ -284,13 +353,16 @@ function resolveActors(resourceType, claims) {
     return out;
 }
 function resolveXhtml(entry, claims) {
-    const fromFhirNarrative = trimValue(asRecord(entry?.resource?.text).div);
-    if (fromFhirNarrative) {
-        return fromFhirNarrative;
-    }
-    const fromSpecificClaim = findBySuffix(claims, '.xhtml')
-        || findBySuffix(claims, '.text-div');
-    return fromSpecificClaim || undefined;
+    if (!entry?.resource) {
+        return undefined;
+    }
+    const mergedResource = {
+        ...entry.resource,
+        meta: {
+            claims,
+        },
+    };
+    return getXhtmlOrDerived(mergedResource);
 }
 function resolveNotes(entry, resourceType, claims) {
     const notesFromResource = readFhirNoteArray(entry);
@@ -379,6 +451,211 @@ function findBySuffix(claims, keySuffix) {
     }
     return undefined;
 }
+function resolveResourceCodeText(resource) {
+    return trimValue(asRecord(resource?.code).text) || undefined;
+}
+function resolveResourceCodeDisplay(resource) {
+    const coding = asArray(asRecord(resource?.code).coding);
+    for (const item of coding) {
+        const display = trimValue(asRecord(item).display);
+        if (display) {
+            return display;
+        }
+    }
+    return undefined;
+}
+function firstDefinedText(values) {
+    for (const value of values) {
+        const normalized = trimValue(value);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
+function buildCombinedLabel(localText, internationalDisplay) {
+    const local = trimValue(localText);
+    const intl = trimValue(internationalDisplay);
+    if (local && intl && local !== intl) {
+        return `${local} (${intl})`;
+    }
+    return local || intl || undefined;
+}
+function buildNarrativeLines(resourceType, claims, resource) {
+    const lines = [];
+    const label = getLocalTextAndIntDisplay(resource).combined || resolveTitle(resourceType, claims) || resourceType;
+    if (label) {
+        lines.push(label);
+    }
+    const date = resolveDate(resourceType, claims);
+    if (date) {
+        lines.push(`Date: ${date}`);
+    }
+    const periodStart = resolvePeriodStart(resourceType, claims);
+    const periodEnd = resolvePeriodEnd(resourceType, claims);
+    if (periodStart) {
+        lines.push(`Start: ${periodStart}`);
+        if (periodEnd) {
+            lines.push(`End: ${periodEnd}`);
+        }
+    }
+    appendFamilySpecificNarrativeLines(lines, resourceType, claims, resource);
+    return uniqueTokens(lines);
+}
+function appendFamilySpecificNarrativeLines(lines, resourceType, claims, resource) {
+    if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
+        pushLine(lines, 'Clinical status', firstClaimValue(claims, [
+            AllergyIntoleranceClaim.ClinicalStatus,
+            AllergyIntoleranceClaimsFhirApi.ClinicalStatus,
+        ]));
+        pushLine(lines, 'Verification status', firstClaimValue(claims, [
+            AllergyIntoleranceClaim.VerificationStatus,
+            AllergyIntoleranceClaimsFhirApi.VerificationStatus,
+        ]));
+        pushLine(lines, 'Criticality', firstClaimValue(claims, [
+            AllergyIntoleranceClaim.Criticality,
+            AllergyIntoleranceClaimsFhirApi.Criticality,
+        ]));
+        pushLine(lines, 'Category', firstClaimCsvValue(claims, [
+            AllergyIntoleranceClaim.Category,
+            AllergyIntoleranceClaimsFhirApi.Category,
+        ]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.Condition) {
+        pushLine(lines, 'Clinical status', firstClaimValue(claims, [
+            ConditionClaim.ClinicalStatus,
+            ConditionClaimsFhirApi.ClinicalStatus,
+        ]));
+        pushLine(lines, 'Verification status', firstClaimValue(claims, [
+            ConditionClaim.VerificationStatus,
+            ConditionClaimsFhirApi.VerificationStatus,
+        ]));
+        pushLine(lines, 'Severity', firstClaimValue(claims, [
+            ConditionClaim.Severity,
+            ConditionClaimsFhirApi.Severity,
+        ]));
+        pushLine(lines, 'Category', firstClaimCsvValue(claims, [
+            ConditionClaim.Category,
+            ConditionClaimsFhirApi.Category,
+        ]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
+        pushLine(lines, 'Status', firstClaimValue(claims, [
+            MedicationStatementClaim.Status,
+            MedicationStatementClaimsFhirApi.Status,
+        ]));
+        pushLine(lines, 'Dose', buildQuantityLabel(firstDefinedText([
+            normalizeNumericValue(claims[MedicationStatementClaimsFhirApiExtended.DoseQuantityValue]),
+            normalizeNumericValue(claims['MedicationStatement.dose-quantity-value']),
+        ]), firstDefinedText([
+            trimValue(claims[MedicationStatementClaimsFhirApiExtended.DoseQuantityUnit]),
+            trimValue(claims['MedicationStatement.dose-quantity-unit']),
+        ])));
+        pushLine(lines, 'Timing', buildMedicationTimingLabel(claims));
+        pushLine(lines, 'Note', firstClaimValue(claims, [MedicationStatementClaim.Note]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.Immunization) {
+        pushLine(lines, 'Status', trimValue(claims[ImmunizationClaim.Status]));
+        pushLine(lines, 'Vaccine', firstDefinedText([
+            findBySuffix(claims, '.vaccine-code-text'),
+            findBySuffix(claims, '.vaccine-code-display'),
+            trimValue(claims[ImmunizationClaim.VaccineCode]),
+        ]));
+        pushLine(lines, 'Performer', trimValue(claims[ImmunizationClaim.Performer]));
+        pushLine(lines, 'Note', trimValue(claims[ImmunizationClaim.Note]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.Observation) {
+        appendObservationNarrativeLines(lines, claims, resource);
+    }
+}
+function appendObservationNarrativeLines(lines, claims, resource) {
+    const codeValue = firstDefinedText([
+        trimValue(claims[ObservationClaim.CodeValue]),
+        splitTokenCode(claims[ObservationClaim.Code]),
+    ]);
+    const systolic = normalizeNumericValue(claims[ObservationClaim.BloodPressureSystolicNumber]);
+    const diastolic = normalizeNumericValue(claims[ObservationClaim.BloodPressureDiastolicNumber]);
+    const unit = firstDefinedText([
+        trimValue(claims[ObservationClaim.ValueQuantityUnit]),
+        resolveObservationUnitFromResource(resource),
+    ]);
+    if (codeValue === '85354-9' || systolic || diastolic) {
+        if (systolic) {
+            pushLine(lines, 'Systolic', buildQuantityLabel(systolic, unit));
+        }
+        if (diastolic) {
+            pushLine(lines, 'Diastolic', buildQuantityLabel(diastolic, unit));
+        }
+        return;
+    }
+    const numericValue = normalizeNumericValue(claims[ObservationClaim.ValueQuantityNumber]);
+    if (numericValue || unit) {
+        pushLine(lines, 'Value', buildQuantityLabel(numericValue, unit));
+    }
+    pushLine(lines, 'Note', trimValue(claims[ObservationClaim.Note]));
+}
+function buildMedicationTimingLabel(claims) {
+    const frequency = firstDefinedText([
+        normalizeNumericValue(claims[MedicationStatementClaimsFhirApiExtended.TimingFrequency]),
+        normalizeNumericValue(claims['MedicationStatement.timing-frequency']),
+    ]);
+    const period = firstDefinedText([
+        normalizeNumericValue(claims[MedicationStatementClaimsFhirApiExtended.TimingPeriod]),
+        normalizeNumericValue(claims['MedicationStatement.timing-period']),
+    ]);
+    const unit = firstDefinedText([
+        trimValue(claims[MedicationStatementClaimsFhirApiExtended.TimingPeriodUnit]),
+        trimValue(claims['MedicationStatement.timing-period-unit']),
+    ]);
+    if (!frequency && !period && !unit) {
+        return undefined;
+    }
+    return [frequency ? `${frequency}x` : undefined, period ? `every ${period}` : undefined, unit].filter(Boolean).join(' ');
+}
+function buildQuantityLabel(value, unit) {
+    const normalizedValue = trimValue(value);
+    const normalizedUnit = trimValue(unit);
+    if (normalizedValue && normalizedUnit) {
+        return `${normalizedValue} ${normalizedUnit}`;
+    }
+    return normalizedValue || normalizedUnit || undefined;
+}
+function resolveObservationUnitFromResource(resource) {
+    const valueQuantity = asRecord(resource?.valueQuantity);
+    return trimValue(valueQuantity.unit) || trimValue(valueQuantity.code) || undefined;
+}
+function normalizeNumericValue(value) {
+    const normalized = trimValue(value);
+    return normalized || undefined;
+}
+function splitTokenCode(value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return undefined;
+    }
+    if (!normalized.includes('|')) {
+        return normalized;
+    }
+    const parts = normalized.split('|');
+    return trimValue(parts[parts.length - 1]) || undefined;
+}
+function pushLine(lines, label, value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return;
+    }
+    lines.push(`${label}: ${normalized}`);
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
+}
 function pushActor(out, actor) {
     const identifier = trimValue(actor.identifier);
     if (!identifier) {
@@ -414,3 +691,6 @@ function asRecord(value) {
     }
     return value;
 }
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}

package/dist/utils/legal-organization-onboarding.d.ts

@@ -90,7 +90,7 @@ export declare const LEGAL_ORGANIZATION_ONBOARDING_JSON_SCHEMA: {
  *   canonical `identifier.value`
  *
  * The result shape is intentionally assistant-friendly:
- * - `missingClaims` tells UI/voice flows what is still required
+ * - `missingClaims` tells UI/application flows what is still required
  * - `normalizedClaims` shows the post-derivation claim set
  * - `derived` explains which values were filled automatically
  */

package/dist/utils/legal-organization-onboarding.js

@@ -67,7 +67,7 @@ function normalizeOptionalString(value) {
  *   canonical `identifier.value`
  *
  * The result shape is intentionally assistant-friendly:
- * - `missingClaims` tells UI/voice flows what is still required
+ * - `missingClaims` tells UI/application flows what is still required
  * - `normalizedClaims` shows the post-derivation claim set
  * - `derived` explains which values were filled automatically
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "publishConfig": {
     "access": "public"
   },