@ovok/native 0.4.6 → 0.4.8

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/custom/custom.device.d.ts

@@ -23,6 +23,16 @@ export declare class CustomDevice extends BTManagedDevice<CustomDeviceId> {
     private readonly definition;
     private readonly validators;
     constructor(device: Device, params: CreateDeviceParams<CustomDeviceId>, definition: CustomDeviceDefinition);
+    /**
+     * Gives a Lepu declaration its frame reader and its command sequence.
+     *
+     * Both or neither: the reader finds frame edges the family's own way, and the gate is
+     * what decides anything may be sent at all. A declaration that had the reader without the
+     * gate would poll hardware it had not identified, which is the case the gate exists for.
+     */
+    private declareLepuProtocol;
+    private onIdentified;
+    private onIdentityRefused;
     protected validatePackage: (pkg: string[], uuid: string) => boolean;
     /**
      * Every declared "result" frame arrives here, whether or not the device streamed first.
@@ -35,9 +45,29 @@ export declare class CustomDevice extends BTManagedDevice<CustomDeviceId> {
      * readings themselves are reported from handleDependentResult, so there is nothing to do.
      */
     protected handleSuccessResult(): void | boolean;
+    /**
+     * Reports what the frame carried, which may be more than one reading.
+     *
+     * A device handing over its stored history answers one request with every record it
+     * holds, back to back. Those were taken at different times and are separate readings, so
+     * each record is decoded and reported on its own. A trailing part-record is ignored: half
+     * a record is not a reading.
+     */
+    private reportFrame;
+    /**
+     * Reports every reading the frame carried.
+     *
+     * One frame is often one reading, but a multi-parameter monitor sends a heart rate, an
+     * oxygen saturation and a temperature together. Those are separate measurements, so they
+     * are reported separately rather than merged into one object whose properties came from
+     * different instruments.
+     *
+     * A reading that fails its checks is discarded on its own. A temperature the device could
+     * not take is no reason to withhold the heart rate in the same frame.
+     */
     private report;
-    private reject;
-    private fail;
+    private discard;
+    private reportMeasurement;
 }
 export {};
 //# sourceMappingURL=custom.device.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/custom/custom.device.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"custom.device.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/custom/custom.device.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,4BAA4B,EAAE,MAAM,gDAAgD,CAAC;AAC9F,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,KAAK,mBAAmB,GAAG,yBAAyB,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC;AAKvE;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,eAAe,CAAC,cAAc,CAAC;IAC/D,SAAS,CAAC,YAAY,EAAE,QAAQ,EAAE,CAAC;IACnC,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;IACnC,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAEnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiD;gBAG1E,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,kBAAkB,CAAC,cAAc,CAAC,EAC1C,UAAU,EAAE,sBAAsB;IAapC,SAAS,CAAC,eAAe,GAAI,KAAK,MAAM,EAAE,EAAE,MAAM,MAAM,KAAG,OAAO,CAQhE;IAEF;;;;OAIG;IACH,SAAS,CAAC,qBAAqB,GAC7B,MAAM,4BAA4B,CAAC,mBAAmB,CAAC,KACtD,4BAA4B,CAAC,mBAAmB,CAAC,CAWlD;IAEF;;;OAGG;IACH,SAAS,CAAC,mBAAmB,IAAI,IAAI,GAAG,OAAO;IAI/C,OAAO,CAAC,MAAM;IAgCd,OAAO,CAAC,MAAM;IAsBd,OAAO,CAAC,IAAI;CAOb"}
+{"version":3,"file":"custom.device.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/custom/custom.device.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,4BAA4B,EAAE,MAAM,gDAAgD,CAAC;AAC9F,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAIlF,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAOvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AASvD,KAAK,mBAAmB,GAAG,yBAAyB,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC;AAGvE;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,eAAe,CAAC,cAAc,CAAC;IAC/D,SAAS,CAAC,YAAY,EAAE,QAAQ,EAAE,CAAC;IACnC,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;IACnC,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAEnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiD;gBAG1E,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,kBAAkB,CAAC,cAAc,CAAC,EAC1C,UAAU,EAAE,sBAAsB;IAmBpC;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,YAAY,CACwB;IAE5C,OAAO,CAAC,iBAAiB,CAMvB;IAEF,SAAS,CAAC,eAAe,GAAI,KAAK,MAAM,EAAE,EAAE,MAAM,MAAM,KAAG,OAAO,CAQhE;IAEF;;;;OAIG;IACH,SAAS,CAAC,qBAAqB,GAC7B,MAAM,4BAA4B,CAAC,mBAAmB,CAAC,KACtD,4BAA4B,CAAC,mBAAmB,CAAC,CAWlD;IAEF;;;OAGG;IACH,SAAS,CAAC,mBAAmB,IAAI,IAAI,GAAG,OAAO;IAI/C;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;IAyBnB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,MAAM;IAcd,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,iBAAiB;CAiC1B"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/frame-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frame-parser.d.ts","sourceRoot":"","sources":["../../../../../../../../src/modules/bt-management/services/devices/frame-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAC;AAC3F,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAK9D;;;;;;;GAOG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,WAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE,cAAc,CAAC,aAAa,CAAC;IAEjE,KAAK,CACV,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EAAE,GACd,4BAA4B,CAAC,CAAC,CAAC,GAAG,SAAS;IA8B9C,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,aAAa;CAMtB"}
+{"version":3,"file":"frame-parser.d.ts","sourceRoot":"","sources":["../../../../../../../../src/modules/bt-management/services/devices/frame-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAC;AAC3F,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAK9D;;;;;;;GAOG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,WAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE,cAAc,CAAC,aAAa,CAAC;IAEjE,KAAK,CACV,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EAAE,GACd,4BAA4B,CAAC,CAAC,CAAC,GAAG,SAAS;IA+B9C,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,aAAa;CAMtB"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.command-builder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Builds the commands a Lepu device accepts.
+ *
+ * Layout: `start | cmd | ~cmd | type | seq | lenLow lenHigh | payload | crc8`, the same frame
+ * the device answers with. The type byte is 0x00 on a request, and the checksum covers every
+ * byte before it.
+ *
+ * The sequence number is write-only bookkeeping: it wraps at 254 and nothing in the response
+ * path reads it back, so it cannot correlate a reply to its request. Correlation is by opcode,
+ * and the protocol relies on at most one command being outstanding - which is the constraint
+ * any sequencer built on this has to respect.
+ *
+ * The counter makes a builder stateful, so each connection needs its own. One builder shared
+ * across devices would interleave their sequence numbers, which is a defect the vendor's own
+ * global counter has and this avoids by construction.
+ */
+export declare class LepuCommandBuilder {
+    private readonly startByte;
+    private sequenceNumber;
+    constructor(startByte?: string);
+    build(command: number, payload?: readonly number[]): string[];
+    private advanceSequence;
+}
+//# sourceMappingURL=lepu.command-builder.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.command-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.command-builder.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.command-builder.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,kBAAkB;IAGV,OAAO,CAAC,QAAQ,CAAC,SAAS;IAF7C,OAAO,CAAC,cAAc,CAAK;gBAES,SAAS,GAAE,MAAa;IAErD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,EAAE;IAkBxE,OAAO,CAAC,eAAe;CAIxB"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.commands.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The commands every Lepu device understands.
+ *
+ * These are the generic opcodes, shared across the whole family. Device-specific opcodes live
+ * below 0x40 and belong with their driver, because the same number means different things on
+ * different hardware - 0x08 polls realtime data on a BP2 and starts a measurement on others.
+ * That collision is why this module holds only the opcodes that are genuinely common, and why
+ * a driver must never assume a low opcode is safe to send to an unidentified device.
+ */
+export declare const LepuCommand: {
+    /** Link keepalive and round-trip test. Inert. */
+    readonly ECHO: 224;
+    /**
+     * Device information, including the model string.
+     *
+     * Inert and identical family-wide, which makes it the one command safe to send before a
+     * device has been identified - and therefore the way to confirm what something is before
+     * addressing it with an opcode that means something else on the wrong hardware.
+     */
+    readonly GET_INFO: 225;
+    readonly GET_BATTERY: 228;
+    /** Enumerate the records stored on the device. */
+    readonly GET_FILE_LIST: 241;
+    /** Begin a read: a 20-byte payload of file name plus a 32-bit offset. */
+    readonly READ_FILE_START: 242;
+    /** Fetch the next chunk of the file being read. */
+    readonly READ_FILE_DATA: 243;
+    /** End the read and release the device's file handle. */
+    readonly READ_FILE_END: 244;
+};
+export type LepuCommandValue = (typeof LepuCommand)[keyof typeof LepuCommand];
+//# sourceMappingURL=lepu.commands.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.commands.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;IACtB,iDAAiD;;IAGjD;;;;;;OAMG;;;IAKH,kDAAkD;;IAGlD,yEAAyE;;IAGzE,mDAAmD;;IAGnD,yDAAyD;;CAEjD,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.device-info.d.ts

@@ -0,0 +1,27 @@
+/** What a Lepu device says it is, in answer to `GET_INFO`. */
+interface LepuDeviceInfo {
+    /** The model, as a number. What a driver checks before addressing the hardware. */
+    deviceType: number;
+    /** The largest payload the device will accept, which bounds a file read's chunks. */
+    protocolMaxLength: number;
+    branchCode: string;
+    serialNumber: string;
+}
+/**
+ * Reads the reply to `GET_INFO`, or nothing if the frame is not one.
+ *
+ * The command byte is checked rather than assumed, because this is the answer a driver
+ * decides its identity on: parsing some other frame as device info would produce a model
+ * number out of whatever bytes happened to sit at offset 20, and the gate would then pass
+ * on a coincidence.
+ *
+ * A frame too short to hold the layout is refused for the same reason, as is one whose
+ * response type is anything but success: an error reply carries a reason where the device
+ * information would be, and reading it as a model number would identify the hardware from
+ * an error code. The vendor's own struct is at least 56 bytes; anything shorter than the
+ * serial length field cannot be read without inventing the parts that are missing.
+ */
+declare const parseLepuDeviceInfo: (frame: readonly string[]) => LepuDeviceInfo | undefined;
+export { parseLepuDeviceInfo };
+export type { LepuDeviceInfo };
+//# sourceMappingURL=lepu.device-info.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.device-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.device-info.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.device-info.ts"],"names":[],"mappings":"AAmDA,8DAA8D;AAC9D,UAAU,cAAc;IAEtB,mFAAmF;IACnF,UAAU,EAAE,MAAM,CAAC;IAEnB,qFAAqF;IACrF,iBAAiB,EAAE,MAAM,CAAC;IAE1B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,mBAAmB,GACvB,OAAO,SAAS,MAAM,EAAE,KACvB,cAAc,GAAG,SA0BnB,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAC/B,YAAY,EAAE,cAAc,EAAE,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.device-names.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The names the Lepu/Viatom family advertises, as its own SDK matches them.
+ *
+ * Taken from the vendor's `getDeviceModel`, a 732-line cascade of substring checks that is
+ * the whole of how that SDK decides which product it is talking to. The order there matters,
+ * because 27 of these names are a prefix of another - `BP2` of `BP2A`, `BP2T`, `BP2W` and
+ * three more - so a check that ran in the wrong order would bind a BP2W as a BP2 and poll it
+ * with an opcode written for different hardware.
+ *
+ * It is that function's vocabulary, not a catalogue of everything the vendor sells: a few
+ * products - the ER3 and the M12 among them - are identified elsewhere in that app and never
+ * reach this list. `lepuNameMatch` accepts a name that is absent, and derives no exclusions
+ * for it, which is correct exactly when no name here extends it.
+ *
+ * They are held here as a flat vocabulary rather than an ordered cascade, because
+ * `lepuNameMatch` derives the exclusions from the list itself. Adding a name automatically
+ * narrows every name it extends, which an ordered list would leave to whoever inserted it.
+ */
+export declare const LEPU_DEVICE_NAMES: readonly string[];
+//# sourceMappingURL=lepu.device-names.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.device-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.device-names.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.device-names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAsM9C,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.file-names.d.ts

@@ -0,0 +1,14 @@
+/** Names are a fixed sixteen bytes, zero padded, in both the listing and the request. */
+declare const NAME_BYTES = 16;
+/**
+ * A file name as the device expects it: sixteen bytes, zero padded, truncated.
+ *
+ * The truncation is the device's, not ours - it copies at most sixteen bytes and pads the
+ * rest - so two names that agree in their first sixteen bytes are the same file as far as
+ * the protocol is concerned.
+ */
+declare const lepuNameBytes: (name: string) => number[];
+/** The names in a file listing: a count, then that many fixed-width padded names. */
+declare const lepuNamesFrom: (payload: readonly string[]) => string[];
+export { lepuNameBytes, lepuNamesFrom, NAME_BYTES };
+//# sourceMappingURL=lepu.file-names.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.file-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.file-names.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.file-names.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,QAAA,MAAM,UAAU,KAAK,CAAC;AAItB;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MAAM,EAGzC,CAAC;AAEJ,qFAAqF;AACrF,QAAA,MAAM,aAAa,GAAI,SAAS,SAAS,MAAM,EAAE,KAAG,MAAM,EAczD,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.file-transfer.d.ts

@@ -0,0 +1,75 @@
+import { CommandSequencer } from "../../../types/command-sequencer";
+import { DeviceCommand } from "../../../types/device-command";
+import { LepuCommandBuilder } from "./lepu.command-builder";
+interface LepuFile {
+    name: string;
+    content: readonly string[];
+}
+interface LepuFileTransferParams {
+    /** The characteristic commands are written to. */
+    write: Omit<DeviceCommand, "frame">;
+    /** Builds this connection's frames. One per connection: it carries a sequence number. */
+    builder: LepuCommandBuilder;
+    maxFileBytes?: number;
+    /** Called once per file, and only after its length was confirmed exactly. */
+    onFile: (file: LepuFile) => void;
+    /** Called with why a transfer stopped. Required, so a failed read cannot pass unseen. */
+    onError: (reason: string) => void;
+    /** Called as each chunk lands, for a long file with a person waiting on it. */
+    onProgress?: (progress: {
+        name: string;
+        receivedBytes: number;
+        totalBytes: number;
+    }) => void;
+}
+/**
+ * Downloads the records a Lepu device has stored.
+ *
+ * Every opcode this uses is generic and inert - list, open, read, close - so unlike a
+ * realtime poll it is safe on hardware whose model is not known. That is what makes it the
+ * one thing the whole family can be asked for without identifying it first.
+ *
+ * The exchange is self-clocking and has no windowing: each reply decides the next request,
+ * and the device chooses how much to send, so the offset advances by what actually arrived
+ * rather than by an assumed chunk size. There is no retry in the protocol either - a single
+ * dropped reply stalls the transfer with nothing to resume it - which is what the data
+ * processor's stuck-data timeout is the watchdog for.
+ *
+ * A short read is an error, not a truncated success: the device is asked to close the file
+ * and the reading is discarded, because half an ECG that looks like a whole one is worse
+ * than none.
+ */
+export declare class LepuFileTransfer implements CommandSequencer {
+    private readonly params;
+    private files;
+    private fileIndex;
+    private name;
+    private totalBytes;
+    private content;
+    private isSessionOpen;
+    private isDone;
+    constructor(params: LepuFileTransferParams);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: (frame: readonly string[]) => readonly DeviceCommand[] | undefined;
+    private openNextFile;
+    /** The reply to opening a file states its whole length, which bounds everything after. */
+    private openedFile;
+    /**
+     * A reply with no bytes in it ends the transfer rather than asking again from the same
+     * offset, which is a request the device would answer the same way for as long as the link
+     * stayed up.
+     */
+    private appendChunk;
+    private closedFile;
+    private closeFile;
+    /**
+     * Stops, and releases the device's file handle if one is open.
+     *
+     * The device holds that handle from the moment a file is opened until it is closed, so
+     * walking away from a failed read can leave it open until the device times out or resets.
+     */
+    private fail;
+    private commandFor;
+}
+export {};
+//# sourceMappingURL=lepu.file-transfer.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.file-transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.file-transfer.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.file-transfer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAI9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAsB5D,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,UAAU,sBAAsB;IAE9B,kDAAkD;IAClD,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAEpC,yFAAyF;IACzF,OAAO,EAAE,kBAAkB,CAAC;IAE5B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,6EAA6E;IAC7E,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IAEjC,yFAAyF;IACzF,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAElC,+EAA+E;IAC/E,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,EAAE,MAAM,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC;KACpB,KAAK,IAAI,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAiB,YAAW,gBAAgB;IASpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAR1C,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,MAAM,CAAS;gBAEa,MAAM,EAAE,sBAAsB;IAE3D,eAAe,QAAO,SAAS,aAAa,EAAE,CAEnD;IAEK,WAAW,GAChB,OAAO,SAAS,MAAM,EAAE,KACvB,SAAS,aAAa,EAAE,GAAG,SAAS,CA2BrC;IAEF,OAAO,CAAC,YAAY,CAmBlB;IAEF,0FAA0F;IAC1F,OAAO,CAAC,UAAU,CAqBhB;IAEF;;;;OAIG;IACH,OAAO,CAAC,WAAW,CA2BjB;IAEF,OAAO,CAAC,UAAU,CAgBhB;IAEF,OAAO,CAAC,SAAS,CAEf;IAEF;;;;;OAKG;IACH,OAAO,CAAC,IAAI,CAWV;IAEF,OAAO,CAAC,UAAU,CAMf;CACJ"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.frame-reader.d.ts

@@ -0,0 +1,28 @@
+import { FrameReadResult } from "../../../types/frame-read-result";
+import { FrameReader } from "../../../types/frame-reader";
+/**
+ * Reads the frame every Lepu device shares.
+ *
+ * Layout: `start | cmd | ~cmd | type | seq | lenLow lenHigh | payload | crc8`, where the
+ * checksum covers every byte before it. The complement of the command byte only narrows the
+ * search for a start; the checksum is what actually decides a frame is trustworthy.
+ *
+ * The start byte is the only part that varies across the family. Most devices use `a5`, a
+ * smaller group uses `55`, and a few accept either and settle on one at runtime - so it is a
+ * list rather than a single value. Everything else is identical on every device speaking this
+ * protocol, which is why it is worth having once rather than once per device.
+ */
+export declare class LepuFrameReader implements FrameReader {
+    private readonly startBytes;
+    constructor(startBytes: readonly string[]);
+    readFrame(buffer: readonly string[]): FrameReadResult;
+    private isFrameStart;
+    private findFrameStart;
+    /**
+     * Bytes that cannot begin a frame start, and are therefore safe to drop when no start was
+     * found. The trailing bytes are kept because a start pattern may still be arriving.
+     */
+    private droppableLeadingBytes;
+    private hasValidChecksum;
+}
+//# sourceMappingURL=lepu.frame-reader.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.frame-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.frame-reader.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.frame-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAe1D;;;;;;;;;;;GAWG;AACH,qBAAa,eAAgB,YAAW,WAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,SAAS,MAAM,EAAE;IAE1D,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe;IAiC5D,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,cAAc;IAYtB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,gBAAgB;CAMzB"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.frame.d.ts

@@ -0,0 +1,12 @@
+/** The opcode a frame answers, which is what correlates a reply to its request. */
+declare const lepuCommandOf: (frame: readonly string[]) => number;
+/**
+ * The bytes a frame carries, from its own declared length.
+ *
+ * Declared rather than derived from what arrived: the frame reader has already checked that
+ * the buffer holds the whole frame, so the length field is the payload's end, and trusting
+ * the array instead would fold the checksum byte into the data.
+ */
+declare const lepuPayloadOf: (frame: readonly string[]) => string[];
+export { lepuCommandOf, lepuPayloadOf };
+//# sourceMappingURL=lepu.frame.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.frame.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.frame.ts"],"names":[],"mappings":"AAOA,mFAAmF;AACnF,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MACV,CAAC;AAEzC;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MAAM,EAIvD,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.identity-gate.d.ts

@@ -0,0 +1,81 @@
+import { CommandSequencer } from "../../../types/command-sequencer";
+import { DeviceCommand } from "../../../types/device-command";
+import { LepuCommandBuilder } from "./lepu.command-builder";
+import { LepuDeviceInfo } from "./lepu.device-info";
+interface LepuIdentityGateParams {
+    /** The characteristic this device's commands are written to. */
+    write: Omit<DeviceCommand, "frame">;
+    /** Builds this connection's frames. One per connection: it carries a sequence number. */
+    builder: LepuCommandBuilder;
+    /** The models this driver was written for. */
+    expectedDeviceTypes: readonly number[];
+    /**
+     * The opcode to poll with, once the device has proved it is one of them.
+     *
+     * Optional, and its absence is a working mode rather than a gap: the gate asks what the
+     * device is, reports it, and sends nothing else. That is how a model number is learned
+     * in the first place - every one of them lives on the hardware and nowhere else, because
+     * the vendor's own SDK never checks the field and so never had to write the values down.
+     */
+    pollCommand?: number;
+    /** Called with what the device said it was, whether or not it was expected. */
+    onIdentified?: (info: LepuDeviceInfo) => void;
+    /**
+     * Called with why the device was refused. Required, so a refusal cannot pass unseen.
+     *
+     * The reason is built here rather than by the caller, because the gate is the only place
+     * that knows which of the several ways it can go wrong actually happened.
+     */
+    onRefused: (reason: string) => void;
+}
+/**
+ * Asks a Lepu device what it is before sending it anything that acts.
+ *
+ * The family shares one frame format, one checksum and one opcode space, but not one
+ * meaning: `0x08` polls realtime data on a BP2, starts a blood-pressure measurement on an
+ * AirBp and starts an ECG on a Lepod. A frame built for the wrong device is therefore
+ * perfectly well-formed - the CRC is computed the same way on every one of them - so
+ * nothing in the protocol catches a driver bound to the wrong hardware. What comes back is
+ * a cuff inflating on someone's arm because a name matched during a scan.
+ *
+ * `GET_INFO` is the one command that cannot cause that: it is generic, inert, and answered
+ * identically family-wide. So it goes first, and everything else waits on its reply.
+ *
+ * A declaration that names the models it was written for is refused permanently when the
+ * device answers with a different one. A declaration that names none is identified by the
+ * advertised name it already matched, which is the basis the vendor's own SDK binds every
+ * one of its products on; it is asked what it is anyway, and the answer reported, because
+ * that is the only place these model numbers exist - the vendor never reads the field back,
+ * so there is no table of them to copy.
+ *
+ * A reply that never arrives leaves the gate closed and nothing sent, which the data
+ * processor's stuck-data timeout reports and disconnects on. That is the watchdog for this
+ * too - the protocol has no retry of its own, so a dropped reply is recovered by
+ * reconnecting rather than by asking again.
+ */
+export declare class LepuIdentityGate implements CommandSequencer {
+    private readonly params;
+    private isIdentified;
+    private isRefused;
+    constructor(params: LepuIdentityGateParams);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: (frame: readonly string[]) => readonly DeviceCommand[] | undefined;
+    /**
+     * Decides on the reply to `GET_INFO`.
+     *
+     * A frame that is not that reply leaves the gate as it was rather than provoking another
+     * command, because the only command outstanding is the one still being waited on.
+     *
+     * A reply that is that command but carries an error type is refused rather than parsed.
+     * The payload of an error is the reason for it, so reading a model number out of it would
+     * identify the hardware from an error code.
+     */
+    private admit;
+    /** Closes the gate for good. There is no state a refused device can be talked back from. */
+    private refuse;
+    /** Nothing, for a declaration that asks what the device is and stops there. */
+    private poll;
+    private commandFor;
+}
+export {};
+//# sourceMappingURL=lepu.identity-gate.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.identity-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.identity-gate.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.identity-gate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAG9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,EAAE,cAAc,EAAuB,MAAM,oBAAoB,CAAC;AAMzE,UAAU,sBAAsB;IAE9B,gEAAgE;IAChE,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAEpC,yFAAyF;IACzF,OAAO,EAAE,kBAAkB,CAAC;IAE5B,8CAA8C;IAC9C,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAEvC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,+EAA+E;IAC/E,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IAE9C;;;;;OAKG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,gBAAiB,YAAW,gBAAgB;IAIpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAH1C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAS;gBAEU,MAAM,EAAE,sBAAsB;IAE3D,eAAe,QAAO,SAAS,aAAa,EAAE,CAEnD;IAEK,WAAW,GAChB,OAAO,SAAS,MAAM,EAAE,KACvB,SAAS,aAAa,EAAE,GAAG,SAAS,CAUrC;IAEF;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK,CAsCX;IAEF,4FAA4F;IAC5F,OAAO,CAAC,MAAM,CAKZ;IAEF,+EAA+E;IAC/E,OAAO,CAAC,IAAI,CAGqC;IAEjD,OAAO,CAAC,UAAU,CAGf;CACJ"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.name-match.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Builds a matcher for one advertised name that cannot also match a longer one.
+ *
+ * The vendor tests these names with a substring check in a hand-ordered cascade, so `BP2`
+ * only fails to match a BP2W because `BP2W` happens to be checked first. Order is a fragile
+ * place to keep a safety property: it lives in whoever wrote the list, is invisible at the
+ * point of use, and an insertion in the wrong place silently binds the wrong driver.
+ *
+ * Here the exclusions are derived instead. Every name in the vocabulary that extends this
+ * one becomes a negative lookahead, so the matcher is correct wherever it is used and in
+ * whatever order it is tried.
+ *
+ * The match is deliberately open at the end, because these devices advertise a serial after
+ * the model - `BP2 1234` - and the serial's shape varies across the family.
+ */
+export declare const lepuNameMatch: (name: string, vocabulary?: readonly string[]) => RegExp;
+//# sourceMappingURL=lepu.name-match.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.name-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.name-match.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.name-match.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,EACZ,aAAY,SAAS,MAAM,EAAsB,KAChD,MASF,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.response-type.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What a Lepu device says about the request it just answered.
+ *
+ * Only `SUCCESS` means the payload holds what was asked for. Every other value is an error
+ * whose payload is not the requested data, so a reply has to be checked before it is
+ * decoded - otherwise a refusal is read as a reading, out of whatever bytes happen to
+ * follow the header.
+ */
+declare const LepuResponseType: {
+    /** A request, phone to device. Never seen on a reply. */
+    readonly REQUEST: 0;
+    readonly SUCCESS: 1;
+    /** The device rejected our checksum. */
+    readonly CRC_ERROR: 2;
+    readonly FILE_NOT_FOUND: 224;
+    readonly FILE_READ_FAILED: 225;
+    readonly FILE_WRITE_FAILED: 226;
+    readonly PARAMETER_ILLEGAL: 241;
+    readonly PERMISSION_DENIED: 242;
+    readonly DECRYPT_FAILED: 243;
+    /** Mid-measurement or otherwise occupied. Worth backing off rather than giving up. */
+    readonly DEVICE_BUSY: 251;
+    readonly COMMAND_FORMAT_ERROR: 252;
+    /** The opcode is unknown to this firmware, which is how a feature is detected. */
+    readonly COMMAND_NOT_SUPPORTED: 253;
+    readonly ERROR: 255;
+};
+declare const lepuResponseType: (frame: readonly string[]) => number;
+declare const isLepuSuccess: (frame: readonly string[]) => boolean;
+/** Why a device refused, in words, for an error a person will read. */
+declare const describeLepuResponseType: (frame: readonly string[]) => string;
+export { describeLepuResponseType, isLepuSuccess, LepuResponseType, lepuResponseType, };
+//# sourceMappingURL=lepu.response-type.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.response-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.response-type.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.response-type.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,QAAA,MAAM,gBAAgB;IACpB,yDAAyD;;;IAKzD,wCAAwC;;;;;;;;IAUxC,sFAAsF;;;IAKtF,kFAAkF;;;CAI1E,CAAC;AAiBX,QAAA,MAAM,gBAAgB,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MACP,CAAC;AAE/C,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,OACI,CAAC;AAEvD,uEAAuE;AACvE,QAAA,MAAM,wBAAwB,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MAM5D,CAAC;AAEF,OAAO,EACL,wBAAwB,EACxB,aAAa,EACb,gBAAgB,EAChB,gBAAgB,GACjB,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.transports.d.ts

@@ -0,0 +1,85 @@
+import { CustomCaseSpec } from "../../../types/custom-case-spec";
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+/**
+ * The characteristics each group of products exposes, read from the vendor's own managers.
+ *
+ * `standard` and `aw1` match the vendor's published SDK reference exactly, and `standard`
+ * also matches the SDK's existing BP2 driver, which has run against hardware on precisely
+ * these UUIDs. `ding` and `aiTele` were read from an OEM build and the vendor documents no
+ * product on them, so they are the two entries here that nothing independent confirms.
+ */
+declare const lepuTransports: {
+    readonly standard: {
+        readonly serviceUuid: "14839ac4-7d7e-415c-9a42-167340cf2339";
+        readonly notifyUuid: "0734594a-a8e7-4b1a-a6b1-cd5243059a57";
+        readonly writeUuid: "8b00ace7-eb0b-49b0-bbe9-9aee0a26e1a3";
+        readonly preferredMtu: 247;
+    };
+    /** The same characteristics on a link that will not grow past the minimum. */
+    readonly standardSmallMtu: {
+        readonly serviceUuid: "14839ac4-7d7e-415c-9a42-167340cf2339";
+        readonly notifyUuid: "0734594a-a8e7-4b1a-a6b1-cd5243059a57";
+        readonly writeUuid: "8b00ace7-eb0b-49b0-bbe9-9aee0a26e1a3";
+        readonly preferredMtu: 23;
+    };
+    readonly aw1: {
+        readonly serviceUuid: "e8fb0001-a14b-98f9-831b-4e2941d01248";
+        readonly notifyUuid: "e8fb0003-a14b-98f9-831b-4e2941d01248";
+        readonly writeUuid: "e8fb0002-a14b-98f9-831b-4e2941d01248";
+        readonly preferredMtu: 247;
+    };
+    readonly ding: {
+        readonly serviceUuid: "0000fe60-0000-1000-8000-00805f9b34fb";
+        readonly notifyUuid: "0000fe62-0000-1000-8000-00805f9b34fb";
+        readonly writeUuid: "0000fe61-0000-1000-8000-00805f9b34fb";
+        readonly preferredMtu: 247;
+    };
+    readonly aiTele: {
+        readonly serviceUuid: "00002760-08c2-11e1-9073-0e8ac72e5450";
+        readonly notifyUuid: "00002760-08c2-11e1-9073-0e8ac72e5402";
+        readonly writeUuid: "00002760-08c2-11e1-9073-0e8ac72e5401";
+        readonly preferredMtu: 247;
+    };
+};
+type LepuTransportName = keyof typeof lepuTransports;
+interface LepuDeviceParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /** The name the hardware advertises. */
+    nameMatch: string | RegExp;
+    /** Which characteristics the product exposes. Nearly all of them are "standard". */
+    transport?: LepuTransportName;
+    /**
+     * The models this declaration was written for, as the device reports them.
+     *
+     * Required to poll, and only ever learned from hardware: declare the device without a
+     * `pollCommand` first, connect, and read the model it reports.
+     */
+    expectedDeviceTypes?: number[];
+    /**
+     * The opcode to poll with once the device has proved it is one of those models.
+     *
+     * Leave it out and the device identifies itself and nothing more. That is the safe first
+     * connection to hardware nobody has identified, because the low opcodes in this family
+     * act - one inflates a cuff, another starts an ECG - and mean different things on
+     * different products.
+     */
+    pollCommand?: number;
+    /**
+     * Shortest frame any declared case may be read from. The seven-byte header and the
+     * trailing checksum are part of it, so a one-byte payload is nine.
+     */
+    minLengthBytes: number;
+    /**
+     * Byte offsets that pick the case. The command byte at index 1 is the usual choice, and
+     * products that answer one command with several shapes add the byte that distinguishes
+     * them.
+     */
+    caseSelectorBytes?: number[];
+    cases: CustomCaseSpec[];
+    stuckDataTimeoutMs?: number;
+}
+declare const lepuDevice: (params: LepuDeviceParams) => CustomDeviceDefinition;
+export { lepuDevice, lepuTransports };
+export type { LepuDeviceParams, LepuTransportName };
+//# sourceMappingURL=lepu.transports.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/lepu/lepu.transports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.transports.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.transports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAyEjF;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc;;;;;;;IAQlB,8EAA8E;;;;;;;;;;;;;;;;;;;;;;;;;CA4B9B,CAAC;AAEnD,KAAK,iBAAiB,GAAG,MAAM,OAAO,cAAc,CAAC;AAErD,UAAU,gBAAgB;IAExB,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX,wCAAwC;IACxC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAE3B,oFAAoF;IACpF,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAE9B;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE/B;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE7B,KAAK,EAAE,cAAc,EAAE,CAAC;IAExB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAID,QAAA,MAAM,UAAU,GAAI,QAAQ,gBAAgB,KAAG,sBAiC9C,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AACtC,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/polling-command-sequencer.d.ts

@@ -0,0 +1,27 @@
+import { CommandSequencer } from "../../types/command-sequencer";
+import { DeviceCommand } from "../../types/device-command";
+import { IMedicalDevice } from "../../types/i-medical-device";
+/**
+ * Sends the same commands on connect and after every frame.
+ *
+ * This is what the SDK did before a device could express anything else, and it remains
+ * right for the devices that only ever ask one question: a poll goes out, a reading comes
+ * back, and the answer is another poll. Keeping it as a named policy rather than as
+ * behaviour built into the transport is what lets a device replace it without every other
+ * device changing.
+ */
+declare class PollingCommandSequencer implements CommandSequencer {
+    private readonly commands;
+    constructor(commands: readonly DeviceCommand[]);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: () => readonly DeviceCommand[];
+}
+/**
+ * Builds the polling policy a device's declared services already describe.
+ *
+ * A service without a write characteristic contributes nothing, so a listen-only device
+ * gets an empty policy and is never written to.
+ */
+declare const pollingSequencerFor: (services: IMedicalDevice["mainService"]) => PollingCommandSequencer;
+export { PollingCommandSequencer, pollingSequencerFor };
+//# sourceMappingURL=polling-command-sequencer.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/polling-command-sequencer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polling-command-sequencer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/modules/bt-management/services/devices/polling-command-sequencer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAG9D;;;;;;;;GAQG;AACH,cAAM,uBAAwB,YAAW,gBAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,SAAS,aAAa,EAAE;IAE/D,eAAe,QAAO,SAAS,aAAa,EAAE,CAAkB;IAEhE,WAAW,QAAO,SAAS,aAAa,EAAE,CAAkB;CACpE;AAED;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,GACvB,UAAU,cAAc,CAAC,aAAa,CAAC,KACtC,uBAaA,CAAC;AAEJ,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,CAAC"}