@ovok/native 0.4.6 → 0.4.8

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.file-transfer.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LepuFileTransfer = void 0;
+var _le32FromHex = require("../../../utils/le-32-from-hex.js");
+var _le32ToBytes = require("../../../utils/le-32-to-bytes.js");
+var _lepuCommands = require("./lepu.commands.js");
+var _lepuFileNames = require("./lepu.file-names.js");
+var _lepuFrame = require("./lepu.frame.js");
+var _lepuResponseType = require("./lepu.response-type.js");
+const FILE_SIZE_OFFSET = 0;
+
+/**
+ * A hex-byte array costs far more memory than the file it describes, so the cap sits well
+ * below what a device could offer. A stored ECG is tens of kilobytes; a length near this one
+ * is a length to refuse rather than try to hold on a low-memory tablet.
+ */
+const MAX_FILE_BYTES = 262_144;
+const TRANSFER_COMMANDS = [_lepuCommands.LepuCommand.GET_FILE_LIST, _lepuCommands.LepuCommand.READ_FILE_START, _lepuCommands.LepuCommand.READ_FILE_DATA, _lepuCommands.LepuCommand.READ_FILE_END];
+/**
+ * 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.
+ */
+class LepuFileTransfer {
+  files = [];
+  fileIndex = 0;
+  name = "";
+  totalBytes = 0;
+  content = [];
+  isSessionOpen = false;
+  isDone = false;
+  constructor(params) {
+    this.params = params;
+  }
+  initialCommands = () => [this.commandFor(_lepuCommands.LepuCommand.GET_FILE_LIST)];
+  nextCommand = frame => {
+    const command = (0, _lepuFrame.lepuCommandOf)(frame);
+    if (this.isDone || !TRANSFER_COMMANDS.includes(command)) {
+      return undefined;
+    }
+    if (!(0, _lepuResponseType.isLepuSuccess)(frame)) {
+      return this.fail(`the device refused it: ${(0, _lepuResponseType.describeLepuResponseType)(frame)}`);
+    }
+    if (command === _lepuCommands.LepuCommand.GET_FILE_LIST) {
+      this.files = (0, _lepuFileNames.lepuNamesFrom)((0, _lepuFrame.lepuPayloadOf)(frame));
+      this.fileIndex = 0;
+      return this.openNextFile();
+    }
+    if (command === _lepuCommands.LepuCommand.READ_FILE_START) {
+      return this.openedFile((0, _lepuFrame.lepuPayloadOf)(frame));
+    }
+    if (command === _lepuCommands.LepuCommand.READ_FILE_DATA) {
+      return this.appendChunk((0, _lepuFrame.lepuPayloadOf)(frame));
+    }
+    return this.closedFile();
+  };
+  openNextFile = () => {
+    const name = this.files[this.fileIndex];
+    if (name === undefined) {
+      this.isDone = true;
+      return undefined;
+    }
+    this.name = name;
+    this.totalBytes = 0;
+    this.content = [];
+    return [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_START, [...(0, _lepuFileNames.lepuNameBytes)(name), ...(0, _le32ToBytes.le32ToBytes)(0)])];
+  };
+
+  /** The reply to opening a file states its whole length, which bounds everything after. */
+  openedFile = payload => {
+    this.isSessionOpen = true;
+    this.totalBytes = (0, _le32FromHex.le32FromHex)([...payload], FILE_SIZE_OFFSET);
+    const limit = this.params.maxFileBytes ?? MAX_FILE_BYTES;
+    if (this.totalBytes > limit) {
+      return this.fail(`"${this.name}" is ${this.totalBytes} bytes, more than the ${limit} this transfer will hold`);
+    }
+    if (this.totalBytes === 0) {
+      return this.closeFile();
+    }
+    return [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_DATA, (0, _le32ToBytes.le32ToBytes)(0))];
+  };
+
+  /**
+   * 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.
+   */
+  appendChunk = payload => {
+    if (payload.length === 0) {
+      return this.fail(`"${this.name}" stopped sending at ${this.content.length} of ${this.totalBytes} bytes`);
+    }
+    this.content.push(...payload);
+    this.params.onProgress?.({
+      name: this.name,
+      receivedBytes: this.content.length,
+      totalBytes: this.totalBytes
+    });
+    if (this.content.length >= this.totalBytes) {
+      return this.closeFile();
+    }
+    return [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_DATA, (0, _le32ToBytes.le32ToBytes)(this.content.length))];
+  };
+  closedFile = () => {
+    this.isSessionOpen = false;
+    if (this.totalBytes > 0 && this.content.length !== this.totalBytes) {
+      return this.fail(`"${this.name}" ended at ${this.content.length} of ${this.totalBytes} bytes`);
+    }
+    if (this.totalBytes > 0) {
+      this.params.onFile({
+        name: this.name,
+        content: this.content
+      });
+    }
+    this.fileIndex++;
+    return this.openNextFile();
+  };
+  closeFile = () => [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_END)];
+
+  /**
+   * 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.
+   */
+  fail = reason => {
+    this.params.onError(reason);
+    this.isDone = true;
+    if (!this.isSessionOpen) {
+      return undefined;
+    }
+    this.isSessionOpen = false;
+    return this.closeFile();
+  };
+  commandFor = (command, payload = []) => ({
+    ...this.params.write,
+    frame: this.params.builder.build(command, payload)
+  });
+}
+exports.LepuFileTransfer = LepuFileTransfer;
+//# sourceMappingURL=lepu.file-transfer.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.file-transfer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_le32FromHex","require","_le32ToBytes","_lepuCommands","_lepuFileNames","_lepuFrame","_lepuResponseType","FILE_SIZE_OFFSET","MAX_FILE_BYTES","TRANSFER_COMMANDS","LepuCommand","GET_FILE_LIST","READ_FILE_START","READ_FILE_DATA","READ_FILE_END","LepuFileTransfer","files","fileIndex","name","totalBytes","content","isSessionOpen","isDone","constructor","params","initialCommands","commandFor","nextCommand","frame","command","lepuCommandOf","includes","undefined","isLepuSuccess","fail","describeLepuResponseType","lepuNamesFrom","lepuPayloadOf","openNextFile","openedFile","appendChunk","closedFile","lepuNameBytes","le32ToBytes","payload","le32FromHex","limit","maxFileBytes","closeFile","length","push","onProgress","receivedBytes","onFile","reason","onError","write","builder","build","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.file-transfer.ts"],"mappings":";;;;;;AAEA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAGA,IAAAE,aAAA,GAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,iBAAA,GAAAL,OAAA;AAEA,MAAMM,gBAAgB,GAAG,CAAC;;AAE1B;AACA;AACA;AACA;AACA;AACA,MAAMC,cAAc,GAAG,OAAO;AAE9B,MAAMC,iBAAoC,GAAG,CAC3CC,yBAAW,CAACC,aAAa,EACzBD,yBAAW,CAACE,eAAe,EAC3BF,yBAAW,CAACG,cAAc,EAC1BH,yBAAW,CAACI,aAAa,CAC1B;AA+BD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,gBAAgB,CAA6B;EAChDC,KAAK,GAAa,EAAE;EACpBC,SAAS,GAAG,CAAC;EACbC,IAAI,GAAG,EAAE;EACTC,UAAU,GAAG,CAAC;EACdC,OAAO,GAAa,EAAE;EACtBC,aAAa,GAAG,KAAK;EACrBC,MAAM,GAAG,KAAK;EAEfC,WAAWA,CAAkBC,MAA8B,EAAE;IAAA,KAAhCA,MAA8B,GAA9BA,MAA8B;EAAG;EAE9DC,eAAe,GAAGA,CAAA,KAAgC,CACvD,IAAI,CAACC,UAAU,CAAChB,yBAAW,CAACC,aAAa,CAAC,CAC3C;EAEMgB,WAAW,GAChBC,KAAwB,IACiB;IACzC,MAAMC,OAAO,GAAG,IAAAC,wBAAa,EAACF,KAAK,CAAC;IAEpC,IAAI,IAAI,CAACN,MAAM,IAAI,CAACb,iBAAiB,CAACsB,QAAQ,CAACF,OAAO,CAAC,EAAE;MACvD,OAAOG,SAAS;IAClB;IAEA,IAAI,CAAC,IAAAC,+BAAa,EAACL,KAAK,CAAC,EAAE;MACzB,OAAO,IAAI,CAACM,IAAI,CAAC,0BAA0B,IAAAC,0CAAwB,EAACP,KAAK,CAAC,EAAE,CAAC;IAC/E;IAEA,IAAIC,OAAO,KAAKnB,yBAAW,CAACC,aAAa,EAAE;MACzC,IAAI,CAACK,KAAK,GAAG,IAAAoB,4BAAa,EAAC,IAAAC,wBAAa,EAACT,KAAK,CAAC,CAAC;MAChD,IAAI,CAACX,SAAS,GAAG,CAAC;MAElB,OAAO,IAAI,CAACqB,YAAY,CAAC,CAAC;IAC5B;IAEA,IAAIT,OAAO,KAAKnB,yBAAW,CAACE,eAAe,EAAE;MAC3C,OAAO,IAAI,CAAC2B,UAAU,CAAC,IAAAF,wBAAa,EAACT,KAAK,CAAC,CAAC;IAC9C;IAEA,IAAIC,OAAO,KAAKnB,yBAAW,CAACG,cAAc,EAAE;MAC1C,OAAO,IAAI,CAAC2B,WAAW,CAAC,IAAAH,wBAAa,EAACT,KAAK,CAAC,CAAC;IAC/C;IAEA,OAAO,IAAI,CAACa,UAAU,CAAC,CAAC;EAC1B,CAAC;EAEOH,YAAY,GAAGA,CAAA,KAA4C;IACjE,MAAMpB,IAAI,GAAG,IAAI,CAACF,KAAK,CAAC,IAAI,CAACC,SAAS,CAAC;IAEvC,IAAIC,IAAI,KAAKc,SAAS,EAAE;MACtB,IAAI,CAACV,MAAM,GAAG,IAAI;MAElB,OAAOU,SAAS;IAClB;IAEA,IAAI,CAACd,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACC,UAAU,GAAG,CAAC;IACnB,IAAI,CAACC,OAAO,GAAG,EAAE;IAEjB,OAAO,CACL,IAAI,CAACM,UAAU,CAAChB,yBAAW,CAACE,eAAe,EAAE,CAC3C,GAAG,IAAA8B,4BAAa,EAACxB,IAAI,CAAC,EACtB,GAAG,IAAAyB,wBAAW,EAAC,CAAC,CAAC,CAClB,CAAC,CACH;EACH,CAAC;;EAED;EACQJ,UAAU,GAChBK,OAA0B,IACe;IACzC,IAAI,CAACvB,aAAa,GAAG,IAAI;IACzB,IAAI,CAACF,UAAU,GAAG,IAAA0B,wBAAW,EAAC,CAAC,GAAGD,OAAO,CAAC,EAAErC,gBAAgB,CAAC;IAE7D,MAAMuC,KAAK,GAAG,IAAI,CAACtB,MAAM,CAACuB,YAAY,IAAIvC,cAAc;IAExD,IAAI,IAAI,CAACW,UAAU,GAAG2B,KAAK,EAAE;MAC3B,OAAO,IAAI,CAACZ,IAAI,CACd,IAAI,IAAI,CAAChB,IAAI,QAAQ,IAAI,CAACC,UAAU,yBAAyB2B,KAAK,0BACpE,CAAC;IACH;IAEA,IAAI,IAAI,CAAC3B,UAAU,KAAK,CAAC,EAAE;MACzB,OAAO,IAAI,CAAC6B,SAAS,CAAC,CAAC;IACzB;IAEA,OAAO,CACL,IAAI,CAACtB,UAAU,CAAChB,yBAAW,CAACG,cAAc,EAAE,IAAA8B,wBAAW,EAAC,CAAC,CAAC,CAAC,CAC5D;EACH,CAAC;;EAED;AACF;AACA;AACA;AACA;EACUH,WAAW,GACjBI,OAA0B,IACe;IACzC,IAAIA,OAAO,CAACK,MAAM,KAAK,CAAC,EAAE;MACxB,OAAO,IAAI,CAACf,IAAI,CACd,IAAI,IAAI,CAAChB,IAAI,wBAAwB,IAAI,CAACE,OAAO,CAAC6B,MAAM,OAAO,IAAI,CAAC9B,UAAU,QAChF,CAAC;IACH;IAEA,IAAI,CAACC,OAAO,CAAC8B,IAAI,CAAC,GAAGN,OAAO,CAAC;IAE7B,IAAI,CAACpB,MAAM,CAAC2B,UAAU,GAAG;MACvBjC,IAAI,EAAE,IAAI,CAACA,IAAI;MACfkC,aAAa,EAAE,IAAI,CAAChC,OAAO,CAAC6B,MAAM;MAClC9B,UAAU,EAAE,IAAI,CAACA;IACnB,CAAC,CAAC;IAEF,IAAI,IAAI,CAACC,OAAO,CAAC6B,MAAM,IAAI,IAAI,CAAC9B,UAAU,EAAE;MAC1C,OAAO,IAAI,CAAC6B,SAAS,CAAC,CAAC;IACzB;IAEA,OAAO,CACL,IAAI,CAACtB,UAAU,CACbhB,yBAAW,CAACG,cAAc,EAC1B,IAAA8B,wBAAW,EAAC,IAAI,CAACvB,OAAO,CAAC6B,MAAM,CACjC,CAAC,CACF;EACH,CAAC;EAEOR,UAAU,GAAGA,CAAA,KAA4C;IAC/D,IAAI,CAACpB,aAAa,GAAG,KAAK;IAE1B,IAAI,IAAI,CAACF,UAAU,GAAG,CAAC,IAAI,IAAI,CAACC,OAAO,CAAC6B,MAAM,KAAK,IAAI,CAAC9B,UAAU,EAAE;MAClE,OAAO,IAAI,CAACe,IAAI,CACd,IAAI,IAAI,CAAChB,IAAI,cAAc,IAAI,CAACE,OAAO,CAAC6B,MAAM,OAAO,IAAI,CAAC9B,UAAU,QACtE,CAAC;IACH;IAEA,IAAI,IAAI,CAACA,UAAU,GAAG,CAAC,EAAE;MACvB,IAAI,CAACK,MAAM,CAAC6B,MAAM,CAAC;QAAEnC,IAAI,EAAE,IAAI,CAACA,IAAI;QAAEE,OAAO,EAAE,IAAI,CAACA;MAAQ,CAAC,CAAC;IAChE;IAEA,IAAI,CAACH,SAAS,EAAE;IAEhB,OAAO,IAAI,CAACqB,YAAY,CAAC,CAAC;EAC5B,CAAC;EAEOU,SAAS,GAAGA,CAAA,KAAgC,CAClD,IAAI,CAACtB,UAAU,CAAChB,yBAAW,CAACI,aAAa,CAAC,CAC3C;;EAED;AACF;AACA;AACA;AACA;AACA;EACUoB,IAAI,GAAIoB,MAAc,IAA2C;IACvE,IAAI,CAAC9B,MAAM,CAAC+B,OAAO,CAACD,MAAM,CAAC;IAC3B,IAAI,CAAChC,MAAM,GAAG,IAAI;IAElB,IAAI,CAAC,IAAI,CAACD,aAAa,EAAE;MACvB,OAAOW,SAAS;IAClB;IAEA,IAAI,CAACX,aAAa,GAAG,KAAK;IAE1B,OAAO,IAAI,CAAC2B,SAAS,CAAC,CAAC;EACzB,CAAC;EAEOtB,UAAU,GAAGA,CACnBG,OAAe,EACfe,OAA0B,GAAG,EAAE,MACZ;IACnB,GAAG,IAAI,CAACpB,MAAM,CAACgC,KAAK;IACpB5B,KAAK,EAAE,IAAI,CAACJ,MAAM,CAACiC,OAAO,CAACC,KAAK,CAAC7B,OAAO,EAAEe,OAAO;EACnD,CAAC,CAAC;AACJ;AAACe,OAAA,CAAA5C,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame-reader.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LepuFrameReader = void 0;
+var _frameReadStatus = require("../../../types/frame-read-status.js");
+var _calculateCrc = require("../../../utils/calculate-crc-8.js");
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+var _le16FromHex = require("../../../utils/le-16-from-hex.js");
+const COMMAND_INDEX = 1;
+const COMMAND_COMPLEMENT_INDEX = 2;
+const PAYLOAD_LENGTH_INDEX = 5;
+const HEADER_BYTES = 7;
+const CHECKSUM_BYTES = 1;
+const BYTE_MASK = 0xff;
+
+/** Start byte, command and its complement: the shortest run that can identify a start. */
+const START_PATTERN_BYTES = 3;
+
+/**
+ * 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.
+ */
+class LepuFrameReader {
+  constructor(startBytes) {
+    this.startBytes = startBytes;
+  }
+  readFrame(buffer) {
+    const start = this.findFrameStart(buffer);
+    if (start === -1) {
+      return {
+        status: _frameReadStatus.FrameReadStatus.INCOMPLETE,
+        consumedBytes: this.droppableLeadingBytes(buffer)
+      };
+    }
+    const payloadLength = (0, _le16FromHex.le16FromHex)(buffer, start + PAYLOAD_LENGTH_INDEX);
+    const frameLength = HEADER_BYTES + payloadLength + CHECKSUM_BYTES;
+    if (start + frameLength > buffer.length) {
+      return {
+        status: _frameReadStatus.FrameReadStatus.INCOMPLETE,
+        consumedBytes: start
+      };
+    }
+    const frame = buffer.slice(start, start + frameLength);
+    if (!this.hasValidChecksum(frame)) {
+      return {
+        status: _frameReadStatus.FrameReadStatus.CORRUPT,
+        consumedBytes: start + START_PATTERN_BYTES
+      };
+    }
+    return {
+      status: _frameReadStatus.FrameReadStatus.COMPLETE,
+      consumedBytes: start + frameLength,
+      frame
+    };
+  }
+  isFrameStart(buffer, index) {
+    if (!this.startBytes.includes((buffer[index] || "").toLowerCase())) {
+      return false;
+    }
+    const command = (0, _hexToByte.hexToByte)(buffer[index + COMMAND_INDEX] || "0");
+    const complement = (0, _hexToByte.hexToByte)(buffer[index + COMMAND_COMPLEMENT_INDEX] || "0");
+    return command === (~complement & BYTE_MASK);
+  }
+  findFrameStart(buffer) {
+    const lastCandidate = buffer.length - START_PATTERN_BYTES;
+    for (let index = 0; index <= lastCandidate; index++) {
+      if (this.isFrameStart(buffer, index)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  /**
+   * 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.
+   */
+  droppableLeadingBytes(buffer) {
+    return Math.max(0, buffer.length - (START_PATTERN_BYTES - 1));
+  }
+  hasValidChecksum(frame) {
+    const checksummedBytes = frame.length - CHECKSUM_BYTES;
+    const declared = (0, _hexToByte.hexToByte)(frame[checksummedBytes] || "0");
+    return declared === (0, _calculateCrc.calculateCrc8)(frame, checksummedBytes);
+  }
+}
+exports.LepuFrameReader = LepuFrameReader;
+//# sourceMappingURL=lepu.frame-reader.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_frameReadStatus","require","_calculateCrc","_hexToByte","_le16FromHex","COMMAND_INDEX","COMMAND_COMPLEMENT_INDEX","PAYLOAD_LENGTH_INDEX","HEADER_BYTES","CHECKSUM_BYTES","BYTE_MASK","START_PATTERN_BYTES","LepuFrameReader","constructor","startBytes","readFrame","buffer","start","findFrameStart","status","FrameReadStatus","INCOMPLETE","consumedBytes","droppableLeadingBytes","payloadLength","le16FromHex","frameLength","length","frame","slice","hasValidChecksum","CORRUPT","COMPLETE","isFrameStart","index","includes","toLowerCase","command","hexToByte","complement","lastCandidate","Math","max","checksummedBytes","declared","calculateCrc8","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.frame-reader.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lepuPayloadOf = exports.lepuCommandOf = void 0;
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+var _le16FromHex = require("../../../utils/le-16-from-hex.js");
+const COMMAND_INDEX = 1;
+const PAYLOAD_LENGTH_INDEX = 5;
+const HEADER_BYTES = 7;
+
+/** The opcode a frame answers, which is what correlates a reply to its request. */
+const lepuCommandOf = frame => (0, _hexToByte.hexToByte)(frame[COMMAND_INDEX] ?? "0");
+
+/**
+ * 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.
+ */
+exports.lepuCommandOf = lepuCommandOf;
+const lepuPayloadOf = frame => {
+  const length = (0, _le16FromHex.le16FromHex)(frame, PAYLOAD_LENGTH_INDEX);
+  return frame.slice(HEADER_BYTES, HEADER_BYTES + length);
+};
+exports.lepuPayloadOf = lepuPayloadOf;
+//# sourceMappingURL=lepu.frame.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToByte","require","_le16FromHex","COMMAND_INDEX","PAYLOAD_LENGTH_INDEX","HEADER_BYTES","lepuCommandOf","frame","hexToByte","exports","lepuPayloadOf","length","le16FromHex","slice"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.frame.ts"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,MAAME,aAAa,GAAG,CAAC;AACvB,MAAMC,oBAAoB,GAAG,CAAC;AAC9B,MAAMC,YAAY,GAAG,CAAC;;AAEtB;AACA,MAAMC,aAAa,GAAIC,KAAwB,IAC7C,IAAAC,oBAAS,EAACD,KAAK,CAACJ,aAAa,CAAC,IAAI,GAAG,CAAC;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA;AANAM,OAAA,CAAAH,aAAA,GAAAA,aAAA;AAOA,MAAMI,aAAa,GAAIH,KAAwB,IAAe;EAC5D,MAAMI,MAAM,GAAG,IAAAC,wBAAW,EAACL,KAAK,EAAEH,oBAAoB,CAAC;EAEvD,OAAOG,KAAK,CAACM,KAAK,CAACR,YAAY,EAAEA,YAAY,GAAGM,MAAM,CAAC;AACzD,CAAC;AAACF,OAAA,CAAAC,aAAA,GAAAA,aAAA","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.identity-gate.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LepuIdentityGate = void 0;
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+var _lepuCommands = require("./lepu.commands.js");
+var _lepuDeviceInfo = require("./lepu.device-info.js");
+var _lepuResponseType = require("./lepu.response-type.js");
+const COMMAND_INDEX = 1;
+
+/**
+ * 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.
+ */
+class LepuIdentityGate {
+  isIdentified = false;
+  isRefused = false;
+  constructor(params) {
+    this.params = params;
+  }
+  initialCommands = () => [this.commandFor(_lepuCommands.LepuCommand.GET_INFO)];
+  nextCommand = frame => {
+    if (this.isRefused) {
+      return undefined;
+    }
+    if (this.isIdentified) {
+      return this.poll();
+    }
+    return this.admit(frame);
+  };
+
+  /**
+   * 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.
+   */
+  admit = frame => {
+    if ((0, _hexToByte.hexToByte)(frame[COMMAND_INDEX] ?? "0") !== _lepuCommands.LepuCommand.GET_INFO) {
+      return undefined;
+    }
+    if (!(0, _lepuResponseType.isLepuSuccess)(frame)) {
+      return this.refuse(`the device would not say what it is: ${(0, _lepuResponseType.describeLepuResponseType)(frame)}`);
+    }
+    const info = (0, _lepuDeviceInfo.parseLepuDeviceInfo)(frame);
+    if (!info) {
+      return this.refuse("the device answered with a frame too short to hold its own model number");
+    }
+    this.params.onIdentified?.(info);
+    if (this.params.pollCommand === undefined) {
+      return undefined;
+    }
+    const isNarrowed = this.params.expectedDeviceTypes.length > 0;
+    if (isNarrowed && !this.params.expectedDeviceTypes.includes(info.deviceType)) {
+      return this.refuse(`the hardware reported model ${info.deviceType} (branch "${info.branchCode}"), which this declaration was not written for`);
+    }
+    this.isIdentified = true;
+    return this.poll();
+  };
+
+  /** Closes the gate for good. There is no state a refused device can be talked back from. */
+  refuse = reason => {
+    this.isRefused = true;
+    this.params.onRefused(reason);
+    return undefined;
+  };
+
+  /** Nothing, for a declaration that asks what the device is and stops there. */
+  poll = () => this.params.pollCommand === undefined ? undefined : [this.commandFor(this.params.pollCommand)];
+  commandFor = command => ({
+    ...this.params.write,
+    frame: this.params.builder.build(command)
+  });
+}
+exports.LepuIdentityGate = LepuIdentityGate;
+//# sourceMappingURL=lepu.identity-gate.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.identity-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToByte","require","_lepuCommands","_lepuDeviceInfo","_lepuResponseType","COMMAND_INDEX","LepuIdentityGate","isIdentified","isRefused","constructor","params","initialCommands","commandFor","LepuCommand","GET_INFO","nextCommand","frame","undefined","poll","admit","hexToByte","isLepuSuccess","refuse","describeLepuResponseType","info","parseLepuDeviceInfo","onIdentified","pollCommand","isNarrowed","expectedDeviceTypes","length","includes","deviceType","branchCode","reason","onRefused","command","write","builder","build","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.identity-gate.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.name-match.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lepuNameMatch = void 0;
+var _lepuDeviceNames = require("./lepu.device-names.js");
+const REGEXP_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+const escapeRegExp = value => value.replace(REGEXP_SPECIAL, "\\$&");
+
+/**
+ * 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.
+ */
+const lepuNameMatch = (name, vocabulary = _lepuDeviceNames.LEPU_DEVICE_NAMES) => {
+  const extensions = vocabulary.filter(other => other !== name && other.startsWith(name)).map(other => escapeRegExp(other.slice(name.length)));
+  const exclusion = extensions.length > 0 ? `(?!${extensions.join("|")})` : "";
+  return new RegExp(`^${escapeRegExp(name)}${exclusion}`);
+};
+exports.lepuNameMatch = lepuNameMatch;
+//# sourceMappingURL=lepu.name-match.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.name-match.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lepuDeviceNames","require","REGEXP_SPECIAL","escapeRegExp","value","replace","lepuNameMatch","name","vocabulary","LEPU_DEVICE_NAMES","extensions","filter","other","startsWith","map","slice","length","exclusion","join","RegExp","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.name-match.ts"],"mappings":";;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AAEA,MAAMC,cAAc,GAAG,qBAAqB;AAE5C,MAAMC,YAAY,GAAIC,KAAa,IACjCA,KAAK,CAACC,OAAO,CAACH,cAAc,EAAE,MAAM,CAAC;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMI,aAAa,GAAGA,CAC3BC,IAAY,EACZC,UAA6B,GAAGC,kCAAiB,KACtC;EACX,MAAMC,UAAU,GAAGF,UAAU,CAC1BG,MAAM,CAAEC,KAAK,IAAKA,KAAK,KAAKL,IAAI,IAAIK,KAAK,CAACC,UAAU,CAACN,IAAI,CAAC,CAAC,CAC3DO,GAAG,CAAEF,KAAK,IAAKT,YAAY,CAACS,KAAK,CAACG,KAAK,CAACR,IAAI,CAACS,MAAM,CAAC,CAAC,CAAC;EAEzD,MAAMC,SAAS,GACbP,UAAU,CAACM,MAAM,GAAG,CAAC,GAAG,MAAMN,UAAU,CAACQ,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE;EAE5D,OAAO,IAAIC,MAAM,CAAC,IAAIhB,YAAY,CAACI,IAAI,CAAC,GAAGU,SAAS,EAAE,CAAC;AACzD,CAAC;AAACG,OAAA,CAAAd,aAAA,GAAAA,aAAA","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.response-type.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lepuResponseType = exports.isLepuSuccess = exports.describeLepuResponseType = exports.LepuResponseType = void 0;
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+/** Byte 3 of every frame: the direction on a request, the outcome on a reply. */
+const RESPONSE_TYPE_INDEX = 3;
+
+/**
+ * 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.
+ */
+const LepuResponseType = exports.LepuResponseType = {
+  /** A request, phone to device. Never seen on a reply. */
+  REQUEST: 0x00,
+  SUCCESS: 0x01,
+  /** The device rejected our checksum. */
+  CRC_ERROR: 0x02,
+  FILE_NOT_FOUND: 0xe0,
+  FILE_READ_FAILED: 0xe1,
+  FILE_WRITE_FAILED: 0xe2,
+  PARAMETER_ILLEGAL: 0xf1,
+  PERMISSION_DENIED: 0xf2,
+  DECRYPT_FAILED: 0xf3,
+  /** Mid-measurement or otherwise occupied. Worth backing off rather than giving up. */
+  DEVICE_BUSY: 0xfb,
+  COMMAND_FORMAT_ERROR: 0xfc,
+  /** The opcode is unknown to this firmware, which is how a feature is detected. */
+  COMMAND_NOT_SUPPORTED: 0xfd,
+  ERROR: 0xff
+};
+const RESPONSE_TYPE_NAMES = {
+  [LepuResponseType.CRC_ERROR]: "it rejected our checksum",
+  [LepuResponseType.FILE_NOT_FOUND]: "the file does not exist",
+  [LepuResponseType.FILE_READ_FAILED]: "the file could not be read",
+  [LepuResponseType.FILE_WRITE_FAILED]: "the file could not be written",
+  [LepuResponseType.PARAMETER_ILLEGAL]: "the parameter was rejected",
+  [LepuResponseType.PERMISSION_DENIED]: "permission was denied",
+  [LepuResponseType.DECRYPT_FAILED]: "it could not decrypt the request",
+  [LepuResponseType.DEVICE_BUSY]: "it is busy",
+  [LepuResponseType.COMMAND_FORMAT_ERROR]: "the command was malformed",
+  [LepuResponseType.COMMAND_NOT_SUPPORTED]: "the opcode is unknown to this firmware",
+  [LepuResponseType.ERROR]: "it reported a generic error"
+};
+const lepuResponseType = frame => (0, _hexToByte.hexToByte)(frame[RESPONSE_TYPE_INDEX] ?? "0");
+exports.lepuResponseType = lepuResponseType;
+const isLepuSuccess = frame => lepuResponseType(frame) === LepuResponseType.SUCCESS;
+
+/** Why a device refused, in words, for an error a person will read. */
+exports.isLepuSuccess = isLepuSuccess;
+const describeLepuResponseType = frame => {
+  const type = lepuResponseType(frame);
+  const known = RESPONSE_TYPE_NAMES[type];
+  const code = `0x${type.toString(16).padStart(2, "0")}`;
+  return known ? `${known} (${code})` : `it answered with ${code}`;
+};
+exports.describeLepuResponseType = describeLepuResponseType;
+//# sourceMappingURL=lepu.response-type.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.response-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToByte","require","RESPONSE_TYPE_INDEX","LepuResponseType","exports","REQUEST","SUCCESS","CRC_ERROR","FILE_NOT_FOUND","FILE_READ_FAILED","FILE_WRITE_FAILED","PARAMETER_ILLEGAL","PERMISSION_DENIED","DECRYPT_FAILED","DEVICE_BUSY","COMMAND_FORMAT_ERROR","COMMAND_NOT_SUPPORTED","ERROR","RESPONSE_TYPE_NAMES","lepuResponseType","frame","hexToByte","isLepuSuccess","describeLepuResponseType","type","known","code","toString","padStart"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.response-type.ts"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAEA;AACA,MAAMC,mBAAmB,GAAG,CAAC;;AAE7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAG;EACvB;EACAE,OAAO,EAAE,IAAI;EAEbC,OAAO,EAAE,IAAI;EAEb;EACAC,SAAS,EAAE,IAAI;EAEfC,cAAc,EAAE,IAAI;EACpBC,gBAAgB,EAAE,IAAI;EACtBC,iBAAiB,EAAE,IAAI;EACvBC,iBAAiB,EAAE,IAAI;EACvBC,iBAAiB,EAAE,IAAI;EACvBC,cAAc,EAAE,IAAI;EAEpB;EACAC,WAAW,EAAE,IAAI;EAEjBC,oBAAoB,EAAE,IAAI;EAE1B;EACAC,qBAAqB,EAAE,IAAI;EAE3BC,KAAK,EAAE;AACT,CAAU;AAEV,MAAMC,mBAAqD,GAAG;EAC5D,CAACf,gBAAgB,CAACI,SAAS,GAAG,0BAA0B;EACxD,CAACJ,gBAAgB,CAACK,cAAc,GAAG,yBAAyB;EAC5D,CAACL,gBAAgB,CAACM,gBAAgB,GAAG,4BAA4B;EACjE,CAACN,gBAAgB,CAACO,iBAAiB,GAAG,+BAA+B;EACrE,CAACP,gBAAgB,CAACQ,iBAAiB,GAAG,4BAA4B;EAClE,CAACR,gBAAgB,CAACS,iBAAiB,GAAG,uBAAuB;EAC7D,CAACT,gBAAgB,CAACU,cAAc,GAAG,kCAAkC;EACrE,CAACV,gBAAgB,CAACW,WAAW,GAAG,YAAY;EAC5C,CAACX,gBAAgB,CAACY,oBAAoB,GAAG,2BAA2B;EACpE,CAACZ,gBAAgB,CAACa,qBAAqB,GACrC,wCAAwC;EAC1C,CAACb,gBAAgB,CAACc,KAAK,GAAG;AAC5B,CAAC;AAED,MAAME,gBAAgB,GAAIC,KAAwB,IAChD,IAAAC,oBAAS,EAACD,KAAK,CAAClB,mBAAmB,CAAC,IAAI,GAAG,CAAC;AAACE,OAAA,CAAAe,gBAAA,GAAAA,gBAAA;AAE/C,MAAMG,aAAa,GAAIF,KAAwB,IAC7CD,gBAAgB,CAACC,KAAK,CAAC,KAAKjB,gBAAgB,CAACG,OAAO;;AAEtD;AAAAF,OAAA,CAAAkB,aAAA,GAAAA,aAAA;AACA,MAAMC,wBAAwB,GAAIH,KAAwB,IAAa;EACrE,MAAMI,IAAI,GAAGL,gBAAgB,CAACC,KAAK,CAAC;EACpC,MAAMK,KAAK,GAAGP,mBAAmB,CAACM,IAAI,CAAC;EACvC,MAAME,IAAI,GAAG,KAAKF,IAAI,CAACG,QAAQ,CAAC,EAAE,CAAC,CAACC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE;EAEtD,OAAOH,KAAK,GAAG,GAAGA,KAAK,KAAKC,IAAI,GAAG,GAAG,oBAAoBA,IAAI,EAAE;AAClE,CAAC;AAACtB,OAAA,CAAAmB,wBAAA,GAAAA,wBAAA","ignoreList":[]}