modbus-webserial 0.10.1 → 0.11.0

package/README.md

@@ -1,7 +1,8 @@
 # modbus-webserial
 
-Tiny zero-dependency library for communicating with a Modbus-RTU serial device from the browser via WebSerial.
+Zero-dependency library for communicating with a Modbus-RTU serial device from the browser via WebSerial.
 
+[![Mentioned in Awesome](https://awesome.re/mentioned-badge.svg)](https://github.com/louisfoster/awesome-web-serial#code-utilities)
 ![npm](https://img.shields.io/npm/v/modbus-webserial)
 ![size](https://img.shields.io/bundlephobia/minzip/modbus-webserial)
 ![dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)
@@ -10,14 +11,13 @@ Tiny zero-dependency library for communicating with a Modbus-RTU serial device f
 ![types](https://img.shields.io/npm/types/modbus-webserial)
 ![esm](https://img.shields.io/badge/esm-%F0%9F%9A%80-green)
 
-## Install
-
-```bash
-npm install modbus-webserial
-```
 
 ## Usage
-**Connect  → read/write in browser**
+**Try the web UI at**
+**[modbuswebui.dev](https://modbuswebui.dev/)**
+
+
+**Establish connection and read/write in browser**
 ```javascript
 import { ModbusRTU } from 'modbus-webserial';
 
@@ -25,13 +25,25 @@ import { ModbusRTU } from 'modbus-webserial';
 const client = await ModbusRTU.openWebSerial({ baudRate: 9600 });
 client.setID(1);
 
-// Read holding registers 0x00 and 0x01
+// Read two holding registers from 0x0000 (0x0000 and 0x0001)
 const { data } = await client.readHoldingRegisters(0, 2);
 console.log('HR0=', data[0], 'HR1=', data[1]);
 
-// Write values to holding registers 0x00 and 0x01
+// Write values to holding registers 0x00 and 0x01 (i.e. two registers from 0x0000)
 await client.writeRegisters(0, [0x0A, 0x0B]);
 ```
+**You can also manually supply the port** 
+```javascript
+const [port] = await navigator.serial.getPorts()
+const client = await ModbusRTU.openWebSerial({ baudRate: 9600, port })
+
+// or on connect
+navigator.serial.addEventListener("connect", ({target: port}) => {
+   const client = await ModbusRTU.openWebSerial({ baudRate: 9600, port })
+})
+```
+
+---
 **Can also be used *without* WebSerial for building modbus frames in any environment**
 ```javascript
 import {
@@ -42,15 +54,18 @@ import {
 // Build a “Read Holding Registers” frame (ID=1, addr=0, qty=2)
 const rawRead = buildReadHoldingRegisters(1, 0x00, 2);
 console.log(rawRead);
-// → Uint8Array [0x01, 0x03, 0x00, 0x00, 0x00, 0x02, CRC_LO, CRC_HI]
+// Uint8Array [0x01, 0x03, 0x00, 0x00, 0x00, 0x02, CRC_LO, CRC_HI]
 
 // Build a “Write Multiple Registers” frame (ID=1, addr=0, values=[10,11])
 const rawWrite = buildWriteRegisters(1, 0x00, [0x0A, 0x0B]);
 console.log(rawWrite);
-// → Uint8Array [0x01, 0x10, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00,0x0A, 0x00,0x0B, CRC_LO, CRC_HI]
+// Uint8Array [0x01, 0x10, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00,0x0A, 0x00,0x0B, CRC_LO, CRC_HI]
 ```
 > [!TIP]
 > Check `src/index.ts` (or `dist/index.js`) for all exports 
+
+---
+
 ## Supported Functions
 
 ### Modbus Data Functions
@@ -86,6 +101,11 @@ Utility and configuration methods exposed on `ModbusRTU`:
 | `getID()`                | Get the current slave ID            |
 | `setTimeout(ms)`         | Set transaction timeout (ms)        |
 | `getTimeout()`           | Get current timeout (ms)            |
+| `getPort()`              | Get 'SerialPort' instance[^1]          |
+
+[^1]: The returned `SerialPort` instance from `getPort` can be used to access properties such as `usbVendorId` and `usbProductId` for retrieving information about the connected USB device.
+
+---
 
 ## Examples
 
@@ -96,7 +116,72 @@ The following demos are fully self‑contained HTML files, served via GitHub Pag
 * [64‑Register Smoke Test](https://anttikotajarvi.github.io/modbus-webserial/examples/smoke-test/)
   Automated loop testing read/write of 64 registers, coils, and discrete inputs with live counters and error logging.
 
+* [Modbus Web-UI](https://modbuswebui.dev)
+  MB Master web app with UX fetures etc.
+
+--- 
+
+## Behavior
+### CRC policy (strict vs resync)
+
+By default the transport uses **strict** CRC checking: if a received Modbus RTU frame fails CRC validation, the request fails with `CrcError`.
+
+You can switch to a more tolerant mode that tries to recover from occasional line noise:
+
+```js
+const client = await ModbusRTU.openWebSerial({
+  baudRate: 9600,
+  crcPolicy: { mode: "resync", maxResyncDrops: 32 },
+});
+```
+
+### Concurrency
+The WebSerial transport is **single-flight**: it can only have one in-progress Modbus RTU transaction at a time.
+
+This is intentional. Modbus RTU does not include a transaction identifier, so overlapping requests on the same serial link makes it ambiguous which response belongs to which request.
+
+There is **no internal request queue**. To avoid abstracting away the serial “one request at a time” nature of Modbus RTU, starting a new transaction while another is in progress will throw an error immediately.
+
+#### Wrong (concurrent calls on the same client/transport):
+```js
+// Two requests started without awaiting the first one.
+// This will throw (single-flight).
+const p1 = client.readHoldingRegisters(0x0000, 2);
+const p2 = client.readHoldingRegisters(0x0010, 2); 
+// -> Uncaught Error: Concurrent transact() calls are not supported
+
+await Promise.all([p1, p2]);
+```
+
+#### Right (serialize with `await`):
+```js
+await client.readHoldingRegisters(0x0000, 2);
+await client.readHoldingRegisters(0x0010, 2);
+```
+
+### Post-timeout recovery
+
+When a request times out, a Modbus RTU slave may still send a **late reply** afterwards. If you immediately send a new request (that is similar enough to the old one), that late reply can be mistaken as the response for the new request.
+
+To reduce that risk (along with strong request/response matching), the transport supports a post-timeout “quarantine” window.
+
+* If `postTimeoutWaitPeriod` is `0` (default), the next request is sent immediately after a timeout.
+* If `postTimeoutWaitPeriod` is `> 0`, the next `transact()` call will **delay sending** the request for the specified period, while **discarding** any bytes received during that window.
+
+```js
+const client = await ModbusRTU.openWebSerial({
+  // ...
+  postTimeoutWaitPeriod: 20, // ms
+});
+```
+
+Notes:
+* This affects **only the request after a timeout**.
+* When you use the client sequentially (with `await`), this shows up as a small delay before the next request. It does **not** change how timeouts are thrown or how you catch them.
+
+
 ## Current state
+* **v0.11**: Transport rework to handle edge cases explicitly
 * **v0.10**: Full modbus data-access coverage
 * **v0.9**: Full passing tests, smoke test passed, complete README, build scripts in place
 * **Beta**: Full Modbus RTU function‑code coverage
@@ -104,8 +189,4 @@ The following demos are fully self‑contained HTML files, served via GitHub Pag
 
 ## Roadmap
 
-* **v1.0.0**: Finalize API, apply bug fixes, refine docs, production-ready release
-
----
-
-© 2025 Antti Kotajärvi
+* **v1.0.0**: Create and document more tests for different boards using different browsers.

package/dist/index.d.ts

@@ -1,11 +1,23 @@
-interface WebSerialOptions {
+interface WebSerialOptions extends WebSerialConfig {
+    requestFilters?: SerialPortFilter[];
+    port?: SerialPort;
+}
+interface WebSerialConfig {
     baudRate?: number;
     dataBits?: 7 | 8;
     stopBits?: 1 | 2;
-    parity?: 'none' | 'even' | 'odd';
-    requestFilters?: SerialPortFilter[];
+    parity?: "none" | "even" | "odd";
     timeout?: number;
+    crcPolicy?: Required<CrcPolicy>;
+    postTimeoutWaitPeriod?: number;
+    interRequestDelay?: number;
 }
+type CrcPolicy = {
+    mode: "strict";
+} | {
+    mode: "resync";
+    maxResyncDrops?: number;
+};
 
 /** Result payloads returned by high-level helpers */
 interface ReadCoilResult {
@@ -194,12 +206,26 @@ declare function crc16(buf: Uint8Array): number;
 declare class CrcError extends Error {
     constructor();
 }
+declare class ResyncError extends Error {
+    readonly drops: number;
+    readonly maxDrops: number;
+    constructor(drops: number, maxDrops: number);
+}
 declare class TimeoutError extends Error {
     constructor();
 }
+declare class StreamClosedError extends Error {
+    constructor();
+}
 declare class ExceptionError extends Error {
     code: number;
     constructor(code: number);
 }
 
-export { CrcError, ExceptionError, type MaskWriteResult, ModbusRTU, type ReadFifoResult, type ReadRegisterResult, TimeoutError, type WebSerialOptions, type WriteFileResult, type WriteRegisterResult, buildMaskWriteRegister, buildReadCoils, buildReadDiscreteInputs, buildReadFifoQueue, buildReadFileRecord, buildReadHolding, buildReadInputRegisters, buildReadWriteMultiple, buildWriteFileRecord, buildWriteMultiple, buildWriteMultipleCoils, buildWriteSingle, buildWriteSingleCoil, crc16, parseMaskWriteRegister, parseReadCoils, parseReadDiscreteInputs, parseReadFifoQueue, parseReadFileRecord, parseReadHolding, parseReadInputRegisters, parseReadWriteMultiple, parseWriteSingle, parseWriteSingleCoil };
+declare const BUILD_INFO: {
+    readonly version: string;
+    readonly commit: string;
+    readonly buildTime: string;
+};
+
+export { BUILD_INFO, CrcError, ExceptionError, type MaskWriteResult, ModbusRTU, type ReadFifoResult, type ReadRegisterResult, ResyncError, StreamClosedError, TimeoutError, type WebSerialOptions, type WriteFileResult, type WriteRegisterResult, buildMaskWriteRegister, buildReadCoils, buildReadDiscreteInputs, buildReadFifoQueue, buildReadFileRecord, buildReadHolding, buildReadInputRegisters, buildReadWriteMultiple, buildWriteFileRecord, buildWriteMultiple, buildWriteMultipleCoils, buildWriteSingle, buildWriteSingleCoil, crc16, parseMaskWriteRegister, parseReadCoils, parseReadDiscreteInputs, parseReadFifoQueue, parseReadFileRecord, parseReadHolding, parseReadInputRegisters, parseReadWriteMultiple, parseWriteSingle, parseWriteSingleCoil };

package/dist/index.js

@@ -15,11 +15,24 @@ var CrcError = class extends Error {
     super("CRC check failed");
   }
 };
+var ResyncError = class extends Error {
+  constructor(drops, maxDrops) {
+    super(`Resync failed (dropped ${drops}/${maxDrops} bytes)`);
+    this.name = "ResyncError";
+    this.drops = drops;
+    this.maxDrops = maxDrops;
+  }
+};
 var TimeoutError = class extends Error {
   constructor() {
     super("Modbus response timed out");
   }
 };
+var StreamClosedError = class extends Error {
+  constructor() {
+    super("Modbus stream closed");
+  }
+};
 var ExceptionError = class extends Error {
   constructor(code) {
     var _a;
@@ -40,19 +53,59 @@ function crc16(buf) {
   return crc;
 }
 
+// src/core/types.ts
+var FC_READ_HOLDING_REGISTERS = 3;
+var FC_WRITE_SINGLE_HOLDING_REGISTER = 6;
+var FC_WRITE_MULTIPLE_HOLDING_REGISTERS = 16;
+var FC_READ_COILS = 1;
+var FC_WRITE_SINGLE_COIL = 5;
+var FC_WRITE_MULTIPLE_COILS = 15;
+var FC_READ_INPUT_REGISTERS = 4;
+var FC_READ_DISCRETE_INPUTS = 2;
+var FC_READ_FILE_RECORD = 20;
+var FC_WRITE_FILE_RECORD = 21;
+var FC_MASK_WRITE_REGISTER = 22;
+var FC_READ_WRITE_MULTIPLE_REGISTERS = 23;
+var FC_READ_FIFO_QUEUE = 24;
+
 // src/transport/webserial.ts
-var WebSerialTransport = class _WebSerialTransport {
+var DEFAULT_CRC_POLICY = { mode: "strict" };
+var DEFAULT_MAX_RESYNC_DROPS = 32;
+var DEFAULTS = {
+  baudRate: 9600,
+  dataBits: 8,
+  stopBits: 1,
+  parity: "none",
+  timeout: 500,
+  crcPolicy: DEFAULT_CRC_POLICY,
+  postTimeoutWaitPeriod: 0,
+  interRequestDelay: 0
+};
+var _WebSerialTransport = class _WebSerialTransport {
   constructor() {
-    this.timeout = 500;
     this.rxBuf = new Uint8Array(0);
+    // rolling buffer across calls
+    this.dirtyUntil = 0;
+    this.inFlight = false;
+    this.lastTransactionEnd = null;
+    this.cfg = {
+      baudRate: DEFAULTS.baudRate,
+      dataBits: DEFAULTS.dataBits,
+      stopBits: DEFAULTS.stopBits,
+      parity: DEFAULTS.parity,
+      timeout: DEFAULTS.timeout,
+      postTimeoutWaitPeriod: DEFAULTS.postTimeoutWaitPeriod,
+      interRequestDelay: DEFAULTS.interRequestDelay
+    };
+    this.MAX_RESYNC_DROPS = DEFAULT_MAX_RESYNC_DROPS;
+    this.CRC_STRICT = DEFAULT_CRC_POLICY.mode === "strict";
   }
-  // rolling buffer across calls
   // timeout gelpers
   setTimeout(ms) {
-    this.timeout = ms;
+    this.cfg.timeout = ms;
   }
   getTimeout() {
-    return this.timeout;
+    return this.cfg.timeout;
   }
   getPort() {
     return this.port;
@@ -66,72 +119,202 @@ var WebSerialTransport = class _WebSerialTransport {
     return t;
   }
   async init(opts) {
-    var _a, _b, _c, _d, _e, _f;
-    this.timeout = (_a = opts.timeout) != null ? _a : 500;
-    this.port = await navigator.serial.requestPort({ filters: (_b = opts.requestFilters) != null ? _b : [] });
+    var _a, _b, _c;
+    Object.entries(this.cfg).forEach(([key, defaultValue]) => {
+      if (typeof opts[key] !== "undefined") {
+        this.cfg[key] = opts[key];
+      }
+    });
+    if (opts.crcPolicy) {
+      this.CRC_STRICT = opts.crcPolicy.mode === "strict";
+      this.MAX_RESYNC_DROPS = opts.crcPolicy.mode === "resync" ? (_a = opts.crcPolicy.maxResyncDrops) != null ? _a : DEFAULT_MAX_RESYNC_DROPS : 0;
+    }
+    this.port = (_c = opts.port) != null ? _c : await navigator.serial.requestPort({
+      filters: (_b = opts.requestFilters) != null ? _b : []
+    });
     await this.port.open({
-      baudRate: (_c = opts.baudRate) != null ? _c : 9600,
-      dataBits: (_d = opts.dataBits) != null ? _d : 8,
-      stopBits: (_e = opts.stopBits) != null ? _e : 1,
-      parity: (_f = opts.parity) != null ? _f : "none"
+      baudRate: this.cfg.baudRate,
+      dataBits: this.cfg.dataBits,
+      stopBits: this.cfg.stopBits,
+      parity: this.cfg.parity
     });
     this.reader = this.port.readable.getReader();
     this.writer = this.port.writable.getWriter();
+    if (typeof performance !== "undefined") {
+      this.now = () => performance.now();
+    }
   }
   // ----------------------------------------------------------------
   //  transact(): Send `req` and await a response whose function-code matches the request
   // ---------------------------------------------------------------- */
   async transact(req) {
-    await this.writer.write(req);
-    const expectedFC = req[1] & 127;
-    const deadline = Date.now() + this.timeout;
-    while (true) {
-      while (this.rxBuf.length < 3) {
-        if (Date.now() > deadline) throw new TimeoutError();
-        const { value } = await this.reader.read();
-        if (!value) throw new TimeoutError();
-        this.rxBuf = concat(this.rxBuf, value);
-      }
-      const need = this.frameLengthIfComplete(this.rxBuf);
-      if (need === 0) {
-        if (Date.now() > deadline) throw new TimeoutError();
-        const { value } = await this.reader.read();
-        if (!value) throw new TimeoutError();
-        this.rxBuf = concat(this.rxBuf, value);
-        continue;
-      }
-      const frame = this.rxBuf.slice(0, need);
-      this.rxBuf = this.rxBuf.slice(need);
-      const crc = crc16(frame.subarray(0, frame.length - 2));
-      const crcOk = (crc & 255) === frame[frame.length - 2] && crc >> 8 === frame[frame.length - 1];
-      if (!crcOk) {
-        this.rxBuf = this.rxBuf.slice(1);
-        throw new CrcError();
+    if (this.inFlight) {
+      throw new Error("Concurrent transact() calls are not supported");
+    }
+    this.inFlight = true;
+    try {
+      if (this.cfg.interRequestDelay > 0 && this.lastTransactionEnd !== null) {
+        const wait = this.lastTransactionEnd + this.cfg.interRequestDelay - this.now();
+        if (wait > 0) await sleep(wait);
       }
-      const fc = frame[1] & 127;
-      if (fc === expectedFC) {
-        return frame;
-      } else {
-        continue;
+      await this.waitOutDirtyPeriod();
+      await this.writer.write(req);
+      const deadline = this.now() + this.cfg.timeout;
+      let State;
+      ((State2) => {
+        State2[State2["TRY_EXTRACT"] = 0] = "TRY_EXTRACT";
+        State2[State2["HAVE_FRAME"] = 1] = "HAVE_FRAME";
+        State2[State2["BAD_CRC"] = 2] = "BAD_CRC";
+        State2[State2["NEED_READ"] = 3] = "NEED_READ";
+      })(State || (State = {}));
+      let state = 0 /* TRY_EXTRACT */;
+      let frame = null;
+      let discardedBytes = 0;
+      while (true) {
+        switch (state) {
+          case 0 /* TRY_EXTRACT */: {
+            frame = this.extractFrame();
+            if (!frame) {
+              state = 3 /* NEED_READ */;
+              break;
+            }
+            state = 1 /* HAVE_FRAME */;
+          }
+          case 1 /* HAVE_FRAME */: {
+            if (this.crcOk(frame)) {
+              if (!proveRequestResponseMismatch(req, frame)) return frame;
+              frame = null;
+              state = 0 /* TRY_EXTRACT */;
+              continue;
+            }
+            state = 2 /* BAD_CRC */;
+          }
+          case 2 /* BAD_CRC */: {
+            if (this.CRC_STRICT) throw new CrcError();
+            discardedBytes += frame ? frame.length : 0;
+            frame = null;
+            if (discardedBytes >= this.MAX_RESYNC_DROPS) {
+              throw new ResyncError(discardedBytes, this.MAX_RESYNC_DROPS);
+            }
+            if (this.rxBuf.length > 0) {
+              state = 0 /* TRY_EXTRACT */;
+              continue;
+            }
+            state = 3 /* NEED_READ */;
+          }
+          case 3 /* NEED_READ */: {
+            const now = this.now();
+            const remaining = deadline - now;
+            if (remaining <= 0) throw new TimeoutError();
+            const value = await this.readWithTimeout(remaining);
+            this.rxBuf = concat(this.rxBuf, value);
+            state = 0 /* TRY_EXTRACT */;
+            continue;
+          }
+          default:
+            throw new Error("invalid state");
+        }
       }
+    } finally {
+      this.inFlight = false;
+      this.lastTransactionEnd = this.now();
     }
   }
+  async readOnce(maxMs) {
+    if (maxMs <= 0) return { kind: "timeout" };
+    const ms = Math.max(1, maxMs);
+    let timer;
+    try {
+      const result = await Promise.race([
+        this.reader.read(),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(_WebSerialTransport.TIMEOUT), ms);
+        })
+      ]);
+      if (result === _WebSerialTransport.TIMEOUT)
+        return { kind: "timeout" };
+      if (result.done || !result.value) return { kind: "closed" };
+      return { kind: "chunk", value: result.value };
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async waitOutDirtyPeriod() {
+    for (; ; ) {
+      const now = this.now();
+      if (now >= this.dirtyUntil) return;
+      const remaining = this.dirtyUntil - now;
+      const r = await this.readOnce(remaining);
+      if (r.kind !== "chunk") break;
+    }
+    this.rxBuf = new Uint8Array(0);
+  }
+  async readWithTimeout(ms) {
+    const r = await this.readOnce(ms);
+    if (r.kind === "chunk") return r.value;
+    if (r.kind === "timeout") {
+      await this.resetReaderAfterTimeout();
+      this.rxBuf = new Uint8Array(0);
+      this.dirtyUntil = this.now() + this.cfg.postTimeoutWaitPeriod;
+      throw new TimeoutError();
+    }
+    if (r.kind === "closed") {
+      throw new StreamClosedError();
+    }
+    throw new Error("invalid read result");
+  }
+  async resetReaderAfterTimeout() {
+    try {
+      await this.reader.cancel();
+    } catch (e) {
+    }
+    try {
+      this.reader.releaseLock();
+    } catch (e) {
+    }
+    this.reader = this.port.readable.getReader();
+  }
+  extractFrame() {
+    if (this.rxBuf.length < 3) return null;
+    const need = this.frameLengthIfComplete(this.rxBuf);
+    if (need === 0) return null;
+    const frame = this.rxBuf.slice(0, need);
+    this.rxBuf = this.rxBuf.slice(need);
+    return frame;
+  }
+  crcOk(frame) {
+    const crc = crc16(frame.subarray(0, frame.length - 2));
+    const crcOk = (crc & 255) === frame[frame.length - 2] && crc >> 8 === frame[frame.length - 1];
+    return crcOk;
+  }
+  now() {
+    return Date.now();
+  }
   // ----------------------------------------------------------------
   //  Determine expected length; return 0 if we still need more bytes
   // ----------------------------------------------------------------
   frameLengthIfComplete(buf) {
     if (buf.length < 3) return 0;
+    const id = buf[0];
     const fc = buf[1];
+    if (id === 0 || id > 247) return 0;
     if (fc & 128) return buf.length >= 5 ? 5 : 0;
     if (fc === 1 || fc === 2 || fc === 3 || fc === 4) {
-      const need = 3 + buf[2] + 2;
+      const byteCount = buf[2];
+      if (byteCount > 252) {
+        return buf.length >= 8 ? 8 : 0;
+      }
+      const need = 3 + byteCount + 2;
       return buf.length >= need ? need : 0;
     }
-    if (fc === 5 || fc === 6 || fc === 15 || fc === 16)
+    if (fc === 5 || // write single coil
+    fc === 6 || // write single register
+    fc === 15 || // write multiple coils
+    fc === 16 || // write multiple registers
+    fc === 22)
       return buf.length >= 8 ? 8 : 0;
     return buf.length >= 8 ? 8 : 0;
   }
-  // -- close port --
   async close() {
     var _a, _b, _c;
     await ((_a = this.reader) == null ? void 0 : _a.cancel());
@@ -139,27 +322,100 @@ var WebSerialTransport = class _WebSerialTransport {
     await ((_c = this.port) == null ? void 0 : _c.close());
   }
 };
+_WebSerialTransport.TIMEOUT = Symbol("timeout");
+var WebSerialTransport = _WebSerialTransport;
+function proveRequestResponseMismatch(req, res) {
+  if (req.length < 2 || res.length < 2) return false;
+  const reqAddr = req[0];
+  const reqFc = req[1] & 127;
+  const resAddr = res[0];
+  const resFc = res[1];
+  const resBaseFc = resFc & 127;
+  if (resAddr !== reqAddr) return true;
+  if (resBaseFc !== reqFc) return true;
+  if (resFc & 128) {
+    return res.length !== 5;
+  }
+  switch (reqFc) {
+    case FC_READ_COILS:
+    case FC_READ_DISCRETE_INPUTS: {
+      if (req.length < 6 || res.length < 3) return false;
+      const quantity = u16be(req, 4);
+      const expectedByteCount = Math.ceil(quantity / 8);
+      if (res[2] !== expectedByteCount) return true;
+      if (res.length !== 3 + expectedByteCount + 2) return true;
+      return false;
+    }
+    case FC_READ_HOLDING_REGISTERS:
+    case FC_READ_INPUT_REGISTERS: {
+      if (req.length < 6 || res.length < 3) return false;
+      const quantity = u16be(req, 4);
+      const expectedByteCount = quantity * 2;
+      if (res[2] !== expectedByteCount) return true;
+      if (res.length !== 3 + expectedByteCount + 2) return true;
+      return false;
+    }
+    case FC_WRITE_SINGLE_COIL:
+    case FC_WRITE_SINGLE_HOLDING_REGISTER:
+    case FC_MASK_WRITE_REGISTER: {
+      if (req.length < 8 || res.length < 8) return false;
+      if (res.length !== req.length) return true;
+      if (!bytesEqual(req, 2, res, 2, req.length - 4)) return true;
+      return false;
+    }
+    case FC_WRITE_MULTIPLE_COILS:
+    case FC_WRITE_MULTIPLE_HOLDING_REGISTERS: {
+      if (req.length < 6 || res.length < 8) return false;
+      if (res.length !== 8) return true;
+      if (!bytesEqual(req, 2, res, 2, 4)) return true;
+      return false;
+    }
+    case FC_READ_WRITE_MULTIPLE_REGISTERS: {
+      if (req.length < 10 || res.length < 3) return false;
+      const readQuantity = u16be(req, 4);
+      const expectedByteCount = readQuantity * 2;
+      if (res[2] !== expectedByteCount) return true;
+      if (res.length !== 3 + expectedByteCount + 2) return true;
+      return false;
+    }
+    case FC_READ_FIFO_QUEUE: {
+      if (res.length < 6) return true;
+      const byteCount = u16be(res, 2);
+      if (byteCount < 2) return true;
+      if (res.length !== 4 + byteCount + 2) return true;
+      const fifoDataBytes = byteCount - 2;
+      if (fifoDataBytes % 2 !== 0) return true;
+      return false;
+    }
+    case FC_READ_FILE_RECORD:
+    case FC_WRITE_FILE_RECORD: {
+      if (res.length < 5) return true;
+      const byteCount = res[2];
+      if (res.length !== 3 + byteCount + 2) return true;
+      return false;
+    }
+    default:
+      return false;
+  }
+}
 function concat(a, b) {
   const out = new Uint8Array(a.length + b.length);
   out.set(a, 0);
   out.set(b, a.length);
   return out;
 }
-
-// src/core/types.ts
-var FC_READ_HOLDING_REGISTERS = 3;
-var FC_WRITE_SINGLE_HOLDING_REGISTER = 6;
-var FC_WRITE_MULTIPLE_HOLDING_REGISTERS = 16;
-var FC_READ_COILS = 1;
-var FC_WRITE_SINGLE_COIL = 5;
-var FC_WRITE_MULTIPLE_COILS = 15;
-var FC_READ_INPUT_REGISTERS = 4;
-var FC_READ_DISCRETE_INPUTS = 2;
-var FC_READ_FILE_RECORD = 20;
-var FC_WRITE_FILE_RECORD = 21;
-var FC_MASK_WRITE_REGISTER = 22;
-var FC_READ_WRITE_MULTIPLE_REGISTERS = 23;
-var FC_READ_FIFO_QUEUE = 24;
+function u16be(buf, offset) {
+  return buf[offset] << 8 | buf[offset + 1];
+}
+function bytesEqual(a, aStart, b, bStart, len) {
+  for (let i = 0; i < len; i++) {
+    if (a[aStart + i] !== b[bStart + i]) return false;
+  }
+  return true;
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/core/frames.ts
 function buildReadHolding(id, addr, len) {
@@ -595,10 +851,20 @@ var ModbusRTU = class _ModbusRTU {
     return { data: parseReadFifoQueue(raw), raw };
   }
 };
+
+// src/index.ts
+var BUILD_INFO = {
+  version: "0.11.0",
+  commit: "0107e92",
+  buildTime: "2026-03-13T07:30:43.483Z"
+};
 export {
+  BUILD_INFO,
   CrcError,
   ExceptionError,
   ModbusRTU,
+  ResyncError,
+  StreamClosedError,
   TimeoutError,
   buildMaskWriteRegister,
   buildReadCoils,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modbus-webserial",
-  "version": "0.10.1",
-  "description": "Tiny TypeScript library for speaking Modbus-RTU from the browser via Web Serial",
+  "version": "0.11.0",
+  "description": "ESM library for speaking Modbus-RTU from the browser via Web Serial",
   "type": "module",
   "author": "Antti Kotajärvi <antti.kotajarvi@hotmail.com>",
   "license": "MIT",