@ovok/core 0.2.59 → 0.2.62

package/README.md

@@ -13,6 +13,7 @@ Core TypeScript SDK for healthcare applications. Provides authentication, AI-FHI
 - 💬 Chat AI integration
 - 🤖 Bot execution framework
 - 📋 Questionnaire responses
+- 📥 Opt-in durable offline measurement queue with idempotent retries
 
 ## Installation
 
@@ -38,3 +39,31 @@ const client = new OvokClient({
 ## Documentation
 
 Full documentation and examples available at **[sdk.ovok.com](https://sdk.ovok.com/)**
+
+## Offline measurements
+
+Pass a durable Medplum storage adapter and opt in to queue measurements while offline:
+
+```typescript
+const client = new OvokClient({
+  storage,
+  offlineQueue: { enabled: true },
+  // other Medplum configuration
+});
+
+const result = await client.saveMeasurement({
+  patientId: "patient-id",
+  measurement: {
+    measurementTypeKey: MeasurementTypeKey.temperature,
+    bodyTemp: 36.5,
+  },
+});
+
+// result.status is "saved" or "queued".
+// Call this from the host app's connectivity and app-resume listeners.
+await client.flushOfflineMeasurementQueue();
+```
+
+Queued observations are persisted in `storage`, retried with exponential backoff, and sent as
+conditional creates using a stable identifier. A retry after a process death therefore cannot
+create a second copy of the same observation. The queue is opt-in and requires durable storage.

package/dist/client/observation/methods/generateObservationBodiesByMeasurement.js

@@ -12,14 +12,31 @@ const getPatientReference = async (client, patientId) => {
     return (0, core_1.getReferenceString)(profile);
 };
 async function generateObservationBodiesByMeasurement(params) {
+    var _a;
     const { device, measurement } = params;
     const measurementTypeKey = measurement.measurementTypeKey;
     const patientReference = await getPatientReference(this, params.patientId);
     const observationService = creator_1.ObservationServiceCreator.getInstance().getService(measurementTypeKey);
+    const deviceObject = (0, getDeviceObject_1.getDeviceObject)(device);
+    const observationFragments = (_a = observationService.generateObservationFragments) === null || _a === void 0 ? void 0 : _a.call(observationService, measurement);
+    if (observationFragments) {
+        return observationFragments
+            .map((fragment) => ({
+            resourceType: "Observation",
+            status: "registered",
+            subject: {
+                reference: patientReference,
+            },
+            device: deviceObject,
+            ...fragment.value,
+            code: fragment.code,
+            ...(fragment.additionalProperties || {}),
+        }))
+            .filter(hasObservationValue);
+    }
     const observationCodes = observationService.getObservationCodes();
     const values = observationService.generateValues(measurement);
     const additionalProperties = observationService.getAdditionalProperties(measurement);
-    const deviceObject = (0, getDeviceObject_1.getDeviceObject)(device);
     const observationBodies = observationCodes.map((code, index) => ({
         resourceType: "Observation",
         status: "registered",
@@ -31,10 +48,11 @@ async function generateObservationBodiesByMeasurement(params) {
         code,
         ...(additionalProperties[index] || {}),
     }));
-    return observationBodies.filter((observation) => {
-        var _a, _b, _c, _d, _e;
-        return ((_a = observation.valueQuantity) === null || _a === void 0 ? void 0 : _a.value) ||
-            ((_b = observation.valueSampledData) === null || _b === void 0 ? void 0 : _b.data) ||
-            ((_e = (_d = (_c = observation.valueCodeableConcept) === null || _c === void 0 ? void 0 : _c.coding) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.code);
-    });
+    return observationBodies.filter(hasObservationValue);
 }
+const hasObservationValue = (observation) => {
+    var _a, _b, _c, _d, _e;
+    return ((_a = observation.valueQuantity) === null || _a === void 0 ? void 0 : _a.value) !== undefined ||
+        Boolean((_b = observation.valueSampledData) === null || _b === void 0 ? void 0 : _b.data) ||
+        Boolean((_e = (_d = (_c = observation.valueCodeableConcept) === null || _c === void 0 ? void 0 : _c.coding) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.code);
+};

package/dist/client/observation/services/ecg-observation-fragments.d.ts

@@ -0,0 +1,4 @@
+import { CodeableConcept } from "@medplum/fhirtypes";
+import { EcgMeasurement } from "../../../types";
+import { ObservationFragment } from "../types/generate-observation-body/ObservationFragment";
+export declare const generateEcgObservationFragments: (measurement: EcgMeasurement, observationCodes: CodeableConcept[]) => ObservationFragment[];

package/dist/client/observation/services/ecg-observation-fragments.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEcgObservationFragments = void 0;
+const MAX_SEGMENT_DURATION_SECONDS = 5 * 60;
+const generateEcgObservationFragments = (measurement, observationCodes) => {
+    const fragments = [];
+    const diagramPoints = measurement.diagramPoints;
+    const recordedAt = isValidDate(measurement.recordedAt)
+        ? measurement.recordedAt
+        : new Date();
+    const duration = typeof measurement.duration === "number" &&
+        Number.isFinite(measurement.duration) &&
+        measurement.duration > 0
+        ? measurement.duration
+        : undefined;
+    if (diagramPoints === null || diagramPoints === void 0 ? void 0 : diagramPoints.length) {
+        const maxSamples = duration
+            ? Math.max(1, Math.floor((MAX_SEGMENT_DURATION_SECONDS * diagramPoints.length) / duration))
+            : diagramPoints.length;
+        const recordingId = `ecg-${recordedAt.getTime()}-${diagramPoints.length}`;
+        const ecgCode = observationCodes[0];
+        for (let startIndex = 0, segmentIndex = 0; startIndex < diagramPoints.length; startIndex += maxSamples, segmentIndex++) {
+            const segment = diagramPoints.slice(startIndex, startIndex + maxSamples);
+            const segmentDuration = duration
+                ? (duration * segment.length) / diagramPoints.length
+                : segment.length / 1000;
+            const segmentStart = new Date(recordedAt.getTime() +
+                (duration
+                    ? (duration * startIndex * 1000) / diagramPoints.length
+                    : startIndex));
+            const segmentEnd = new Date(segmentStart.getTime() + segmentDuration * 1000);
+            const firstId = recordingId;
+            fragments.push({
+                code: ecgCode,
+                value: {
+                    valueSampledData: {
+                        origin: { value: 0, unit: "mV" },
+                        period: duration
+                            ? (duration * 1000) / diagramPoints.length
+                            : 1,
+                        dimensions: 1,
+                        data: segment.map((sample) => Number(sample.toFixed(3))).join(" "),
+                    },
+                },
+                additionalProperties: {
+                    id: segmentIndex === 0 ? firstId : `${recordingId}-${segmentIndex}`,
+                    effectivePeriod: {
+                        start: segmentStart.toISOString(),
+                        end: segmentEnd.toISOString(),
+                    },
+                    hasMember: segmentIndex === 0
+                        ? []
+                        : [{ reference: `Observation/${firstId}` }],
+                    ...(segmentIndex === 0 && measurement.diagnosticResult
+                        ? { interpretation: [{ text: measurement.diagnosticResult }] }
+                        : {}),
+                    ...(segmentIndex === 0 && duration !== undefined
+                        ? { component: [durationComponent(duration)] }
+                        : {}),
+                },
+            });
+        }
+    }
+    if (typeof measurement.heartRate === "number") {
+        fragments.push({
+            code: observationCodes[1],
+            value: {
+                valueQuantity: {
+                    value: Number(measurement.heartRate.toFixed(0)),
+                    unit: "bpm",
+                    code: "8867-4",
+                    system: "http://loinc.org",
+                },
+            },
+            additionalProperties: {
+                effectiveDateTime: recordedAt.toISOString(),
+            },
+        });
+    }
+    return fragments;
+};
+exports.generateEcgObservationFragments = generateEcgObservationFragments;
+const durationComponent = (duration) => ({
+    code: {
+        text: "measurement-duration",
+        coding: [{ code: "measurement-duration" }],
+    },
+    id: "measurement-duration",
+    valueQuantity: {
+        value: duration,
+        unit: "s",
+        code: "s",
+        system: "http://unitsofmeasure.org",
+    },
+});
+const isValidDate = (value) => value instanceof Date && !Number.isNaN(value.getTime());

package/dist/client/observation/services/ecg.d.ts

@@ -1,5 +1,6 @@
 import { Observation } from "@medplum/fhirtypes";
 import { EcgMeasurement, Measurement, MeasurementTypeKey } from "../../../types";
+import { ObservationFragment } from "../types/generate-observation-body/ObservationFragment";
 import { ObservationValue } from "../types/generate-observation-body/ObservationValue";
 import { ObservationMetadata } from "../types/service/ObservationMetadata";
 import { BaseObservationService } from "./base-observation-service";
@@ -8,6 +9,8 @@ export declare class EcgService extends BaseObservationService<EcgMeasurement> {
     protected measurementTypeName: string;
     protected observationMetadata: ObservationMetadata<EcgMeasurement>[];
     generateValues(measurement: Measurement): ObservationValue[];
+    /** Expand long recordings into bounded, timestamped observations. */
+    generateObservationFragments(measurement: Measurement): ObservationFragment[];
     getAdditionalProperties(measurement: Measurement): Partial<Observation>[];
     getMeasurementDisplay(measurement: Measurement): string;
     getObservationDisplay(observations: Observation[]): string | undefined;

package/dist/client/observation/services/ecg.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EcgService = void 0;
 const types_1 = require("../../../types");
 const base_observation_service_1 = require("./base-observation-service");
+const ecg_observation_fragments_1 = require("./ecg-observation-fragments");
 class EcgService extends base_observation_service_1.BaseObservationService {
     constructor() {
         super(...arguments);
@@ -59,6 +60,11 @@ class EcgService extends base_observation_service_1.BaseObservationService {
         }
         return values;
     }
+    /** Expand long recordings into bounded, timestamped observations. */
+    generateObservationFragments(measurement) {
+        const castedMeasurement = this.getCastedMeasurement(measurement);
+        return (0, ecg_observation_fragments_1.generateEcgObservationFragments)(castedMeasurement, this.getObservationCodes());
+    }
     getAdditionalProperties(measurement) {
         const castedMeasurement = this.getCastedMeasurement(measurement);
         const additionalProperties = [

package/dist/client/observation/services/uric-acid-service.d.ts

@@ -1,6 +1,7 @@
 import { Observation } from "@medplum/fhirtypes";
 import { Measurement, MeasurementTypeKey, Sample, UrineAnalyzeMeasurement } from "../../../types";
 import { RecordResult, RecordType } from "../types/generate-measurement/HealthConnectTypes";
+import { ObservationFragment } from "../types/generate-observation-body/ObservationFragment";
 import { ObservationValue } from "../types/generate-observation-body/ObservationValue";
 import { ObservationMetadata } from "../types/service/ObservationMetadata";
 import { BaseObservationService } from "./base-observation-service";
@@ -11,6 +12,13 @@ export declare class UricAcidService extends BaseObservationService<UrineAnalyze
     protected observationMetadata: ObservationMetadata<UrineAnalyzeMeasurement>[];
     generateValues(measurement: Measurement): ObservationValue[];
     getAdditionalProperties(measurement: Measurement): Partial<Observation>[];
+    /**
+     * A strip contains independent analyte readings. Emit each measured value
+     * as its own Observation so zero is retained and decimal values never pass
+     * through the integer-only component representation used by the legacy
+     * panel implementation.
+     */
+    generateObservationFragments(measurement: Measurement): ObservationFragment[];
     getMeasurementDisplay(measurement: Measurement): string;
     getObservationDisplay(observations: Observation[]): string | undefined;
     convertSamplesToMeasurement(_samples: Sample[]): UrineAnalyzeMeasurement;

package/dist/client/observation/services/uric-acid-service.js

@@ -36,7 +36,9 @@ class UricAcidService extends base_observation_service_1.BaseObservationService
     getAdditionalProperties(measurement) {
         const castedMeasurement = this.getCastedMeasurement(measurement);
         const components = Object.entries(castedMeasurement)
-            .filter(([key]) => key !== "measurementTypeKey" && key !== "urineValues")
+            .filter(([key]) => key !== "measurementTypeKey" &&
+            key !== "urineValues" &&
+            key !== "recordedAt")
             .map(([key, value]) => this.getComponent(key, value));
         return [
             {
@@ -45,6 +47,50 @@ class UricAcidService extends base_observation_service_1.BaseObservationService
             },
         ];
     }
+    /**
+     * A strip contains independent analyte readings. Emit each measured value
+     * as its own Observation so zero is retained and decimal values never pass
+     * through the integer-only component representation used by the legacy
+     * panel implementation.
+     */
+    generateObservationFragments(measurement) {
+        const castedMeasurement = this.getCastedMeasurement(measurement);
+        const effectiveDateTime = castedMeasurement.recordedAt instanceof Date &&
+            !Number.isNaN(castedMeasurement.recordedAt.getTime())
+            ? castedMeasurement.recordedAt.toISOString()
+            : new Date().toISOString();
+        return types_1.URINE_ANALYTE_DEFINITIONS.flatMap((analyte) => {
+            const value = castedMeasurement[analyte.key];
+            if (value === undefined || value === null || !Number.isFinite(value)) {
+                return [];
+            }
+            return [
+                {
+                    code: {
+                        coding: [
+                            {
+                                code: analyte.code,
+                                display: analyte.display,
+                                system: "http://loinc.org",
+                            },
+                        ],
+                        text: analyte.display,
+                    },
+                    value: {
+                        valueQuantity: {
+                            value,
+                            unit: "1",
+                            code: "1",
+                            system: "http://unitsofmeasure.org",
+                        },
+                    },
+                    additionalProperties: {
+                        effectiveDateTime,
+                    },
+                },
+            ];
+        });
+    }
     getMeasurementDisplay(measurement) {
         const castedMeasurement = this.getCastedMeasurement(measurement);
         const problemCount = this.countProblems(castedMeasurement);

package/dist/client/observation/types/IObservationService.d.ts

@@ -1,10 +1,12 @@
 import { CodeableConcept, Observation } from "@medplum/fhirtypes";
 import { RecordResult, RecordType } from "./generate-measurement/HealthConnectTypes";
 import { Sample } from "./generate-measurement/Sample";
+import { ObservationFragment } from "./generate-observation-body/ObservationFragment";
 import { ObservationValue } from "./generate-observation-body/ObservationValue";
 import { Measurement } from "./measurement/Measurement";
 export interface IObservationService {
     generateValues: (measurement: Measurement) => ObservationValue[];
+    generateObservationFragments?: (measurement: Measurement) => ObservationFragment[];
     getObservationCodes: () => CodeableConcept[];
     getAdditionalProperties: (measurement: Measurement) => Partial<Observation>[];
     getUnits: () => string[];

package/dist/client/observation/types/UrineAnalytes.d.ts

@@ -0,0 +1,12 @@
+export type UrineAnalyteKey = "uro" | "bil" | "ket" | "glu" | "pro" | "ph" | "bld" | "nit" | "leu" | "sg" | "vc";
+export type UrineAnalyteDefinition = {
+    key: UrineAnalyteKey;
+    code: string;
+    display: string;
+};
+/**
+ * LOINC mappings for the eleven values returned by Contec's BC401 strip.
+ * These are exported so Native declarations and consuming apps can describe
+ * the same analytes without maintaining a second, drifting table.
+ */
+export declare const URINE_ANALYTE_DEFINITIONS: readonly UrineAnalyteDefinition[];

package/dist/client/observation/types/UrineAnalytes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URINE_ANALYTE_DEFINITIONS = void 0;
+/**
+ * LOINC mappings for the eleven values returned by Contec's BC401 strip.
+ * These are exported so Native declarations and consuming apps can describe
+ * the same analytes without maintaining a second, drifting table.
+ */
+exports.URINE_ANALYTE_DEFINITIONS = [
+    { key: "uro", code: "50563-6", display: "Urobilinogen" },
+    { key: "bld", code: "50559-4", display: "Hemoglobin" },
+    { key: "bil", code: "53327-3", display: "Bilirubin" },
+    { key: "ket", code: "50557-8", display: "Ketones" },
+    { key: "glu", code: "53328-1", display: "Glucose" },
+    { key: "pro", code: "50561-0", display: "Protein" },
+    { key: "ph", code: "50560-2", display: "Urine pH" },
+    { key: "nit", code: "50558-6", display: "Nitrite" },
+    { key: "leu", code: "60026-2", display: "Leukocyte esterase" },
+    { key: "sg", code: "53326-5", display: "Specific gravity" },
+    { key: "vc", code: "5768-7", display: "Ascorbate (vitamin C)" },
+];

package/dist/client/observation/types/generate-observation-body/ObservationFragment.d.ts

@@ -0,0 +1,12 @@
+import { CodeableConcept, Observation } from "@medplum/fhirtypes";
+import { ObservationValue } from "./ObservationValue";
+/**
+ * A service-specific observation that is expanded by the common observation
+ * body generator. This is used when one measurement has to produce more than
+ * one FHIR Observation, such as a long ECG or a urine strip's analytes.
+ */
+export type ObservationFragment = {
+    code: CodeableConcept;
+    value?: ObservationValue;
+    additionalProperties?: Partial<Observation>;
+};

package/dist/client/observation/types/generate-observation-body/ObservationFragment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/observation/types/measurement/EcgMeasurement.d.ts

@@ -10,4 +10,6 @@ export type EcgMeasurement = Measurement & {
      * Duration of the ECG in seconds
      */
     duration?: number;
+    /** Time at which the device started recording the ECG. */
+    recordedAt?: Date;
 };

package/dist/client/observation/types/measurement/UrineAnalyzeMeasurement.d.ts

@@ -13,6 +13,8 @@ export type UrineAnalyzeMeasurement = Measurement & {
     sg?: number;
     vc?: number;
     urineValues: UrineAnalysisValue[];
+    /** Time at which the analyzer recorded the strip. */
+    recordedAt?: Date;
 };
 type UrineAnalysisValue = {
     code: CodeableConcept;

package/dist/client/offline/index.d.ts

@@ -0,0 +1 @@
+export * from "./offline-measurement-queue";

package/dist/client/offline/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./offline-measurement-queue"), exports);

package/dist/client/offline/offline-measurement-queue.d.ts

@@ -0,0 +1,44 @@
+import { IClientStorage } from "@medplum/core";
+import { Bundle, BundleEntry, Observation } from "@medplum/fhirtypes";
+declare const DEFAULT_STORAGE_KEY = "@ovok/core/offline-measurements";
+declare const IDENTIFIER_SYSTEM = "https://api.ovok.com/fhir/StructureDefinition/offline-measurement-id";
+export type OfflineMeasurementQueueOptions = {
+    enabled?: boolean;
+    storageKey?: string;
+    maxRetries?: number;
+    retryBackoffMs?: number;
+    maxRetryBackoffMs?: number;
+};
+export type OfflineMeasurementFlushOptions = {
+    includeExhausted?: boolean;
+    resetExhausted?: boolean;
+};
+export type OfflineMeasurementFlushResult = {
+    attempted: number;
+    saved: number;
+    queued: number;
+    exhausted: number;
+    responses: Record<string, Bundle>;
+};
+type MeasurementTransport = (bundle: Bundle) => Promise<Bundle>;
+declare const entryForObservation: (observation: Observation) => BundleEntry<Observation>;
+export declare class OfflineMeasurementQueue {
+    private readonly storage;
+    private readonly transport;
+    private readonly storageKey;
+    private readonly maxRetries;
+    private readonly retryBackoffMs;
+    private readonly maxRetryBackoffMs;
+    private operation;
+    constructor(storage: IClientStorage, transport: MeasurementTransport, options?: OfflineMeasurementQueueOptions);
+    enqueueAndFlush: (observations: Observation[]) => Promise<{
+        id: string;
+        flush: OfflineMeasurementFlushResult;
+    }>;
+    flush: (options?: OfflineMeasurementFlushOptions) => Promise<OfflineMeasurementFlushResult>;
+    private runExclusive;
+    private readQueue;
+    private writeQueue;
+    private flushQueue;
+}
+export { DEFAULT_STORAGE_KEY as DEFAULT_OFFLINE_MEASUREMENT_QUEUE_KEY, IDENTIFIER_SYSTEM as OFFLINE_MEASUREMENT_IDENTIFIER_SYSTEM, entryForObservation, };

package/dist/client/offline/offline-measurement-queue.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entryForObservation = exports.OFFLINE_MEASUREMENT_IDENTIFIER_SYSTEM = exports.DEFAULT_OFFLINE_MEASUREMENT_QUEUE_KEY = exports.OfflineMeasurementQueue = void 0;
+const DEFAULT_STORAGE_KEY = "@ovok/core/offline-measurements";
+exports.DEFAULT_OFFLINE_MEASUREMENT_QUEUE_KEY = DEFAULT_STORAGE_KEY;
+const DEFAULT_MAX_RETRIES = 8;
+const DEFAULT_RETRY_BACKOFF_MS = 5000;
+const DEFAULT_MAX_RETRY_BACKOFF_MS = 60 * 60 * 1000;
+const IDENTIFIER_SYSTEM = "https://api.ovok.com/fhir/StructureDefinition/offline-measurement-id";
+exports.OFFLINE_MEASUREMENT_IDENTIFIER_SYSTEM = IDENTIFIER_SYSTEM;
+const canonicalize = (value) => {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, nested]) => [key, canonicalize(nested)]));
+    }
+    return value;
+};
+const hash = (value) => {
+    let first = 0x811c9dc5;
+    let second = 0x01000193;
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        first ^= code;
+        first = Math.imul(first, 0x01000193);
+        second ^= code + index;
+        second = Math.imul(second, 0x811c9dc5);
+    }
+    return `${(first >>> 0).toString(16).padStart(8, "0")}${(second >>> 0)
+        .toString(16)
+        .padStart(8, "0")}`;
+};
+const stableMeasurementId = (observation) => hash(JSON.stringify(canonicalize(observation)));
+const entryForObservation = (observation) => {
+    var _a;
+    const id = stableMeasurementId(observation);
+    const identifier = {
+        system: IDENTIFIER_SYSTEM,
+        value: id,
+    };
+    return {
+        fullUrl: `urn:uuid:${id}`,
+        request: {
+            method: "POST",
+            url: "Observation",
+            ifNoneExist: `identifier=${IDENTIFIER_SYSTEM}|${id}`,
+        },
+        resource: {
+            ...observation,
+            identifier: [...((_a = observation.identifier) !== null && _a !== void 0 ? _a : []), identifier],
+        },
+    };
+};
+exports.entryForObservation = entryForObservation;
+const isFailedResponse = (bundle) => {
+    var _a, _b;
+    return (_b = (_a = bundle.entry) === null || _a === void 0 ? void 0 : _a.some((entry) => {
+        var _a, _b;
+        const status = (_b = (_a = entry.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : "";
+        return status.startsWith("4") || status.startsWith("5");
+    })) !== null && _b !== void 0 ? _b : false;
+};
+class OfflineMeasurementQueue {
+    constructor(storage, transport, options = {}) {
+        var _a, _b, _c, _d;
+        this.storage = storage;
+        this.transport = transport;
+        this.operation = Promise.resolve();
+        this.enqueueAndFlush = (observations) => this.runExclusive(async () => {
+            var _a, _b;
+            await ((_b = (_a = this.storage).getInitPromise) === null || _b === void 0 ? void 0 : _b.call(_a));
+            const queue = this.readQueue();
+            const entries = observations.map(entryForObservation);
+            const id = hash(JSON.stringify(canonicalize(entries)));
+            if (!queue.some((item) => item.id === id)) {
+                queue.push({
+                    id,
+                    queuedAt: new Date().toISOString(),
+                    attempt: 0,
+                    nextAttemptAt: 0,
+                    entries,
+                });
+                this.writeQueue(queue);
+            }
+            return { id, flush: await this.flushQueue(queue) };
+        });
+        this.flush = (options = {}) => this.runExclusive(async () => {
+            var _a, _b;
+            await ((_b = (_a = this.storage).getInitPromise) === null || _b === void 0 ? void 0 : _b.call(_a));
+            return this.flushQueue(this.readQueue(), options);
+        });
+        this.runExclusive = (operation) => {
+            const next = this.operation.then(operation, operation);
+            this.operation = next.catch(() => undefined);
+            return next;
+        };
+        this.readQueue = () => {
+            const stored = this.storage.getObject(this.storageKey);
+            if (stored === undefined) {
+                return [];
+            }
+            if (!Array.isArray(stored)) {
+                throw new Error("Offline measurement queue is not an array.");
+            }
+            return stored;
+        };
+        this.writeQueue = (queue) => {
+            this.storage.setObject(this.storageKey, queue);
+        };
+        this.flushQueue = async (queue, options = {}) => {
+            const result = {
+                attempted: 0,
+                saved: 0,
+                queued: 0,
+                exhausted: 0,
+                responses: {},
+            };
+            const now = Date.now();
+            let changed = false;
+            for (const item of [...queue]) {
+                if (item.exhausted && options.resetExhausted) {
+                    item.attempt = 0;
+                    item.exhausted = false;
+                    item.nextAttemptAt = 0;
+                    changed = true;
+                }
+                if ((item.exhausted && !options.includeExhausted) ||
+                    item.nextAttemptAt > now) {
+                    if (item.exhausted) {
+                        result.exhausted++;
+                    }
+                    else {
+                        result.queued++;
+                    }
+                    continue;
+                }
+                result.attempted++;
+                const attempt = item.attempt + 1;
+                try {
+                    const response = await this.transport({
+                        resourceType: "Bundle",
+                        type: "transaction",
+                        entry: item.entries,
+                    });
+                    if (isFailedResponse(response)) {
+                        throw response;
+                    }
+                    queue.splice(queue.indexOf(item), 1);
+                    result.saved++;
+                    result.responses[item.id] = response;
+                    changed = true;
+                }
+                catch (_a) {
+                    item.attempt = attempt;
+                    item.exhausted = attempt >= this.maxRetries;
+                    item.nextAttemptAt = item.exhausted
+                        ? Number.MAX_SAFE_INTEGER
+                        : Date.now() +
+                            Math.min(this.maxRetryBackoffMs, this.retryBackoffMs * 2 ** (attempt - 1));
+                    changed = true;
+                    if (item.exhausted) {
+                        result.exhausted++;
+                    }
+                    else {
+                        result.queued++;
+                    }
+                }
+            }
+            if (changed) {
+                this.writeQueue(queue);
+            }
+            return result;
+        };
+        this.storageKey = (_a = options.storageKey) !== null && _a !== void 0 ? _a : DEFAULT_STORAGE_KEY;
+        this.maxRetries = Math.max(1, (_b = options.maxRetries) !== null && _b !== void 0 ? _b : DEFAULT_MAX_RETRIES);
+        this.retryBackoffMs = Math.max(1, (_c = options.retryBackoffMs) !== null && _c !== void 0 ? _c : DEFAULT_RETRY_BACKOFF_MS);
+        this.maxRetryBackoffMs = Math.max(this.retryBackoffMs, (_d = options.maxRetryBackoffMs) !== null && _d !== void 0 ? _d : DEFAULT_MAX_RETRY_BACKOFF_MS);
+    }
+}
+exports.OfflineMeasurementQueue = OfflineMeasurementQueue;

package/dist/client/ovok-client.d.ts

@@ -1,20 +1,41 @@
 import { IClientStorage, MedplumClient, MedplumClientOptions, SubscriptionManager } from "@medplum/core";
+import { Bundle, Observation } from "@medplum/fhirtypes";
 import * as aiFhirMethods from "./ai-fhir/methods";
 import * as authMethods from "./auth/methods";
 import * as botMethods from "./bot/methods";
 import * as aiMethods from "./chat/ai/methods";
 import * as observationMethods from "./observation/methods";
+import { GenerateObservationBodyParams } from "./observation/types/generate-observation-body/GenerateObservationBodyParams";
+import { OfflineMeasurementFlushOptions, OfflineMeasurementFlushResult, OfflineMeasurementQueueOptions } from "./offline";
 import * as questionnaireResponseMethods from "./questionnaire-response/methods";
+export type SaveObservationsResult = {
+    status: "saved";
+    response: Bundle;
+} | {
+    status: "queued";
+    queueId: string;
+};
 export declare class OvokClient extends MedplumClient {
     protected socialLoginClientId: string;
     clientStorage: IClientStorage | undefined;
+    private readonly offlineQueueOptions;
+    private offlineMeasurementQueue;
     /**
      * @param config - The configuration for the client.
      * @param config.socialLoginClientId - The social login client id to use for the client.
      */
     constructor(config: MedplumClientOptions & {
         socialLoginClientId?: string;
+        offlineQueue?: OfflineMeasurementQueueOptions;
     });
+    /** Saves a measurement immediately, or durably queues it when the opt-in queue is enabled. */
+    saveMeasurement(params: GenerateObservationBodyParams): Promise<SaveObservationsResult>;
+    /** Saves observations with conditional creates so a retry cannot create a duplicate. */
+    saveObservations(observations: Observation[]): Promise<SaveObservationsResult>;
+    /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
+    flushOfflineMeasurementQueue(options?: OfflineMeasurementFlushOptions): Promise<OfflineMeasurementFlushResult>;
+    private getOfflineMeasurementQueue;
+    private executeConditionalObservationCreates;
     private bindMethods;
     /**
      * Gets the `SubscriptionManager` for WebSocket subscriptions.

package/dist/client/ovok-client.js

@@ -41,6 +41,7 @@ const authMethods = __importStar(require("./auth/methods"));
 const botMethods = __importStar(require("./bot/methods"));
 const aiMethods = __importStar(require("./chat/ai/methods"));
 const observationMethods = __importStar(require("./observation/methods"));
+const offline_1 = require("./offline");
 const questionnaireResponseMethods = __importStar(require("./questionnaire-response/methods"));
 class OvokClient extends core_1.MedplumClient {
     /**
@@ -48,7 +49,7 @@ class OvokClient extends core_1.MedplumClient {
      * @param config.socialLoginClientId - The social login client id to use for the client.
      */
     constructor(config) {
-        var _a;
+        var _a, _b;
         super(config);
         this.socialLoginClientId = "";
         this.socialLoginClientId = (_a = config.socialLoginClientId) !== null && _a !== void 0 ? _a : "";
@@ -59,6 +60,67 @@ class OvokClient extends core_1.MedplumClient {
         this.bindMethods(aiFhirMethods);
         this.bindMethods(botMethods);
         this.clientStorage = config.storage;
+        this.offlineQueueOptions = (_b = config.offlineQueue) !== null && _b !== void 0 ? _b : {};
+    }
+    /** Saves a measurement immediately, or durably queues it when the opt-in queue is enabled. */
+    async saveMeasurement(params) {
+        const observations = await this.generateObservationBodiesByMeasurement(params);
+        return this.saveObservations(observations);
+    }
+    /** Saves observations with conditional creates so a retry cannot create a duplicate. */
+    async saveObservations(observations) {
+        const queue = this.getOfflineMeasurementQueue();
+        if (queue) {
+            const { id, flush } = await queue.enqueueAndFlush(observations);
+            const response = flush.responses[id];
+            return response
+                ? { status: "saved", response }
+                : { status: "queued", queueId: id };
+        }
+        const response = await this.executeConditionalObservationCreates(observations);
+        return { status: "saved", response };
+    }
+    /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
+    async flushOfflineMeasurementQueue(options = {}) {
+        const queue = this.getOfflineMeasurementQueue();
+        if (!queue) {
+            return {
+                attempted: 0,
+                saved: 0,
+                queued: 0,
+                exhausted: 0,
+                responses: {},
+            };
+        }
+        return queue.flush(options);
+    }
+    getOfflineMeasurementQueue() {
+        var _a;
+        if (this.offlineQueueOptions.enabled !== true) {
+            return undefined;
+        }
+        if (!this.clientStorage) {
+            throw new Error("Offline measurement queue requires a durable client storage adapter.");
+        }
+        (_a = this.offlineMeasurementQueue) !== null && _a !== void 0 ? _a : (this.offlineMeasurementQueue = new offline_1.OfflineMeasurementQueue(this.clientStorage, (bundle) => this.executeBatch(bundle), this.offlineQueueOptions));
+        return this.offlineMeasurementQueue;
+    }
+    async executeConditionalObservationCreates(observations) {
+        var _a;
+        const entries = observations.map(offline_1.entryForObservation);
+        const bundle = await this.executeBatch({
+            resourceType: "Bundle",
+            type: "transaction",
+            entry: entries,
+        });
+        if ((_a = bundle.entry) === null || _a === void 0 ? void 0 : _a.some((entry) => {
+            var _a, _b;
+            const status = (_b = (_a = entry.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : "";
+            return status.startsWith("4") || status.startsWith("5");
+        })) {
+            throw bundle;
+        }
+        return bundle;
     }
     bindMethods(methods) {
         for (const [name, method] of Object.entries(methods)) {

package/dist/conformance/capability-requirements.js

@@ -48,7 +48,7 @@ exports.OVOK_CORE_REQUIREMENTS = {
     description: "The FHIR surface a server must provide for the @ovok/core client library's own methods to function.",
     software: {
         name: "@ovok/core",
-        version: "0.2.58",
+        version: "0.2.61",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/index.d.ts

@@ -923,6 +923,8 @@ declare const Medplum: {
 };
 export { Medplum };
 export { OvokClient } from "./client/ovok-client";
+export type { SaveObservationsResult } from "./client/ovok-client";
+export * from "./client/offline";
 export * from "./hooks";
 export * from "./utils";
 export * from "./client/observation/services";

package/dist/index.js

@@ -44,6 +44,7 @@ const { MedplumClient, ...Medplum } = MedplumCore;
 exports.Medplum = Medplum;
 var ovok_client_1 = require("./client/ovok-client");
 Object.defineProperty(exports, "OvokClient", { enumerable: true, get: function () { return ovok_client_1.OvokClient; } });
+__exportStar(require("./client/offline"), exports);
 __exportStar(require("./hooks"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./client/observation/services"), exports);

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@ export * from "../client/auth/types/RequestDeleteUserBody";
 export * from "../client/auth/types/ResetPasswordBody";
 export * from "../client/observation/types/MeasurementTypeKey";
 export * from "../client/observation/types/ObservationCode";
+export * from "../client/observation/types/UrineAnalytes";
 export * from "../client/observation/types/measurement";
 export * from "../client/observation/types/generate-measurement/Sample";
 export * from "../client/observation/types/GetLatestObservationsByCodeParams";

package/dist/types/index.js

@@ -24,6 +24,7 @@ __exportStar(require("../client/auth/types/ResetPasswordBody"), exports);
 // Measurement types
 __exportStar(require("../client/observation/types/MeasurementTypeKey"), exports);
 __exportStar(require("../client/observation/types/ObservationCode"), exports);
+__exportStar(require("../client/observation/types/UrineAnalytes"), exports);
 __exportStar(require("../client/observation/types/measurement"), exports);
 __exportStar(require("../client/observation/types/generate-measurement/Sample"), exports);
 // Observation types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ovok/core",
-  "version": "0.2.59",
+  "version": "0.2.62",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",