njs-modbus 1.5.0 → 2.0.0

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var EventEmitter = require('node:events');
 var serialport = require('serialport');
+var node_crypto = require('node:crypto');
 var node_net = require('node:net');
 var node_dgram = require('node:dgram');
 
@@ -17,20 +18,293 @@ exports.ErrorCode = void 0;
     ErrorCode[ErrorCode["GATEWAY_PATH_UNAVAILABLE"] = 10] = "GATEWAY_PATH_UNAVAILABLE";
     ErrorCode[ErrorCode["GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND"] = 11] = "GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND";
 })(exports.ErrorCode || (exports.ErrorCode = {}));
-const PREFIX = 'MODBUS_ERROR_CODE_';
+/** Internal error codes for programmatic error handling. */
+const ModbusErrorCode = {
+    TIMEOUT: 'ETIMEOUT',
+    INVALID_RESPONSE: 'EINVALID_RESPONSE',
+    INSUFFICIENT_DATA: 'EINSUFFICIENT_DATA',
+    MASTER_CLOSED: 'EMASTER_CLOSED',
+    MASTER_DESTROYED: 'EMASTER_DESTROYED',
+    CONCURRENT_NOT_TCP: 'ECONCURRENT_NOT_TCP',
+    PORT_DESTROYED: 'EPORT_DESTROYED',
+    PORT_ALREADY_OPEN: 'EPORT_ALREADY_OPEN',
+    PORT_NOT_OPEN: 'EPORT_NOT_OPEN',
+    NOT_SUPPORTED: 'ENOT_SUPPORTED',
+    INVALID_DATA: 'EINVALID_DATA',
+    INVALID_HEX: 'EINVALID_HEX',
+    CRC_MISMATCH: 'ECRC_MISMATCH',
+    LRC_MISMATCH: 'ELRC_MISMATCH',
+    INCOMPLETE_FRAME: 'EINCOMPLETE_FRAME',
+    T1_5_EXCEEDED: 'ET1_5_EXCEEDED',
+    UNKNOWN_FC: 'EUNKNOWN_FC',
+    INVALID_ROLE: 'EINVALID_ROLE',
+    RANGE: 'ERANGE',
+};
+const MODBUS_PREFIX = 'MODBUS_ERROR_CODE_';
+class ModbusError extends Error {
+    constructor(code, message) {
+        super(message !== null && message !== void 0 ? message : code);
+        Object.defineProperty(this, "code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: code
+        });
+        this.name = 'ModbusError';
+    }
+}
 function getErrorByCode(code) {
-    return new Error(PREFIX + code);
+    return new ModbusError(String(code), `${MODBUS_PREFIX}${code}`);
 }
 function getCodeByError(err) {
-    if (err.message.startsWith(PREFIX)) {
-        return Number(err.message.slice(PREFIX.length));
+    if (err instanceof ModbusError) {
+        const num = Number(err.code);
+        if (!Number.isNaN(num) && num in exports.ErrorCode) {
+            return num;
+        }
+    }
+    if (err.message.startsWith(MODBUS_PREFIX)) {
+        return Number(err.message.slice(MODBUS_PREFIX.length));
     }
     return exports.ErrorCode.SERVER_DEVICE_FAILURE;
 }
 
+/**
+ * Standard Modbus function codes (V1.1b3 §6).
+ */
+exports.FunctionCode = void 0;
+(function (FunctionCode) {
+    FunctionCode[FunctionCode["READ_COILS"] = 1] = "READ_COILS";
+    FunctionCode[FunctionCode["READ_DISCRETE_INPUTS"] = 2] = "READ_DISCRETE_INPUTS";
+    FunctionCode[FunctionCode["READ_HOLDING_REGISTERS"] = 3] = "READ_HOLDING_REGISTERS";
+    FunctionCode[FunctionCode["READ_INPUT_REGISTERS"] = 4] = "READ_INPUT_REGISTERS";
+    FunctionCode[FunctionCode["WRITE_SINGLE_COIL"] = 5] = "WRITE_SINGLE_COIL";
+    FunctionCode[FunctionCode["WRITE_SINGLE_REGISTER"] = 6] = "WRITE_SINGLE_REGISTER";
+    FunctionCode[FunctionCode["WRITE_MULTIPLE_COILS"] = 15] = "WRITE_MULTIPLE_COILS";
+    FunctionCode[FunctionCode["WRITE_MULTIPLE_REGISTERS"] = 16] = "WRITE_MULTIPLE_REGISTERS";
+    FunctionCode[FunctionCode["REPORT_SERVER_ID"] = 17] = "REPORT_SERVER_ID";
+    FunctionCode[FunctionCode["MASK_WRITE_REGISTER"] = 22] = "MASK_WRITE_REGISTER";
+    FunctionCode[FunctionCode["READ_WRITE_MULTIPLE_REGISTERS"] = 23] = "READ_WRITE_MULTIPLE_REGISTERS";
+    FunctionCode[FunctionCode["READ_DEVICE_IDENTIFICATION"] = 43] = "READ_DEVICE_IDENTIFICATION";
+})(exports.FunctionCode || (exports.FunctionCode = {}));
+/** Exception response FC = request FC | EXCEPTION_OFFSET (V1.1b3 §7). */
+const EXCEPTION_OFFSET = 0x80;
+/** Coil value encoding for FC 5 / FC 15 (V1.1b3 §6.5/§6.11). */
+const COIL_ON = 0xff00;
+const COIL_OFF = 0x0000;
+/** FC 0x2B MEI sub-function selecting Read Device Identification (V1.1b3 §6.21). */
+const MEI_READ_DEVICE_ID = 0x0e;
+/** Read Device ID code values inside an FC 0x2B / MEI 0x0E request. */
+exports.ReadDeviceIDCode = void 0;
+(function (ReadDeviceIDCode) {
+    ReadDeviceIDCode[ReadDeviceIDCode["BASIC_STREAM"] = 1] = "BASIC_STREAM";
+    ReadDeviceIDCode[ReadDeviceIDCode["REGULAR_STREAM"] = 2] = "REGULAR_STREAM";
+    ReadDeviceIDCode[ReadDeviceIDCode["EXTENDED_STREAM"] = 3] = "EXTENDED_STREAM";
+    ReadDeviceIDCode[ReadDeviceIDCode["SPECIFIC_ACCESS"] = 4] = "SPECIFIC_ACCESS";
+})(exports.ReadDeviceIDCode || (exports.ReadDeviceIDCode = {}));
+/** Conformity level reported in an FC 0x2B / MEI 0x0E response. */
+exports.ConformityLevel = void 0;
+(function (ConformityLevel) {
+    ConformityLevel[ConformityLevel["BASIC"] = 129] = "BASIC";
+    ConformityLevel[ConformityLevel["REGULAR"] = 130] = "REGULAR";
+    ConformityLevel[ConformityLevel["EXTENDED"] = 131] = "EXTENDED";
+})(exports.ConformityLevel || (exports.ConformityLevel = {}));
+/** Modbus V1.1b3 PDU quantity limits. */
+const LIMITS = {
+    READ_COILS_MIN: 0x0001,
+    READ_COILS_MAX: 0x07d0,
+    READ_REGISTERS_MIN: 0x0001,
+    READ_REGISTERS_MAX: 0x007d,
+    WRITE_COILS_MAX: 0x07b0,
+    WRITE_REGISTERS_MAX: 0x007b,
+    RW_REGISTERS_WRITE_MAX: 0x0079,
+};
+
 class AbstractPhysicalLayer extends EventEmitter {
 }
 
+function inRange(n, [min, max]) {
+    return n >= min && n <= max;
+}
+function checkRange(value, range) {
+    if (!range) {
+        return true;
+    }
+    const values = Array.isArray(value) ? value : [value];
+    if (typeof range[0] === 'number' && typeof range[1] === 'number') {
+        const [min, max] = range;
+        const [lo, hi] = min <= max ? [min, max] : [max, min];
+        return values.every((n) => inRange(n, [lo, hi]));
+    }
+    else if (range.length > 0) {
+        for (const r of range) {
+            const [min, max] = r;
+            const [lo, hi] = min <= max ? [min, max] : [max, min];
+            if (values.every((n) => inRange(n, [lo, hi]))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return true;
+}
+
+const TABLE = [
+    0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01,
+    0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0,
+    0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581,
+    0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141,
+    0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01,
+    0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0,
+    0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681,
+    0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
+    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01,
+    0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0,
+    0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381,
+    0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741,
+    0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901,
+    0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0,
+    0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
+    0x4040,
+];
+function crc(data, seed = 0xffff) {
+    let crc = seed;
+    for (let index = 0; index < data.length; index++) {
+        crc = (TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8)) & 0xffff;
+    }
+    return crc;
+}
+
+/** Cross-process unique id: `${prefix}-${uuid-v4}`. */
+function genConnectionId(prefix) {
+    return `${prefix}-${node_crypto.randomUUID()}`;
+}
+
+/**
+ * Convert a number of bits to milliseconds at a given baud rate.
+ *
+ * Used to derive Modbus RTU timing intervals from bit counts — e.g. 38.5 bits
+ * = 3.5 character times at 11 bits/char (t3.5 inter-frame silence), or 16.5
+ * bits = 1.5 character times (t1.5 inter-character timeout), per Modbus V1.02
+ * §2.5.1.1.
+ *
+ * @param baudRate Serial port baud rate.
+ * @param bits Number of bits to convert.
+ * @returns Duration in milliseconds.
+ */
+function bitsToMs(baudRate, bits) {
+    return (bits * 1000) / baudRate;
+}
+
+/**
+ * Returns true when `n` is an integer in the unsigned-byte range [0, 255].
+ *
+ * Used for byte-level Modbus payload validation (function-code values, raw
+ * byte arrays in FC17/FC43 responses) — rejects negative, fractional, NaN,
+ * Infinity, and out-of-range values uniformly.
+ */
+function isUint8(n) {
+    return Number.isInteger(n) && n >= 0 && n <= 255;
+}
+
+function lrc(data) {
+    return (~data.reduce((sum, n) => sum + n, 0) + 1) & 0xff;
+}
+
+const REQUEST_FIXED_LENGTHS = {
+    [exports.FunctionCode.READ_COILS]: 8,
+    [exports.FunctionCode.READ_DISCRETE_INPUTS]: 8,
+    [exports.FunctionCode.READ_HOLDING_REGISTERS]: 8,
+    [exports.FunctionCode.READ_INPUT_REGISTERS]: 8,
+    [exports.FunctionCode.WRITE_SINGLE_COIL]: 8,
+    [exports.FunctionCode.WRITE_SINGLE_REGISTER]: 8,
+    [exports.FunctionCode.REPORT_SERVER_ID]: 4,
+    [exports.FunctionCode.MASK_WRITE_REGISTER]: 10,
+    [exports.FunctionCode.READ_DEVICE_IDENTIFICATION]: 7,
+};
+const REQUEST_BYTE_COUNT = {
+    [exports.FunctionCode.WRITE_MULTIPLE_COILS]: { offset: 6, extra: 9 },
+    [exports.FunctionCode.WRITE_MULTIPLE_REGISTERS]: { offset: 6, extra: 9 },
+    [exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 10, extra: 13 },
+};
+const RESPONSE_FIXED_LENGTHS = {
+    [exports.FunctionCode.WRITE_SINGLE_COIL]: 8,
+    [exports.FunctionCode.WRITE_SINGLE_REGISTER]: 8,
+    [exports.FunctionCode.WRITE_MULTIPLE_COILS]: 8,
+    [exports.FunctionCode.WRITE_MULTIPLE_REGISTERS]: 8,
+    [exports.FunctionCode.MASK_WRITE_REGISTER]: 10,
+};
+const RESPONSE_BYTE_COUNT = {
+    [exports.FunctionCode.READ_COILS]: { offset: 2, extra: 5 },
+    [exports.FunctionCode.READ_DISCRETE_INPUTS]: { offset: 2, extra: 5 },
+    [exports.FunctionCode.READ_HOLDING_REGISTERS]: { offset: 2, extra: 5 },
+    [exports.FunctionCode.READ_INPUT_REGISTERS]: { offset: 2, extra: 5 },
+    [exports.FunctionCode.REPORT_SERVER_ID]: { offset: 2, extra: 5 },
+    [exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 2, extra: 5 },
+};
+/**
+ * Predict the total RTU frame length (PDU + 2-byte CRC) given the leading bytes.
+ *
+ * Returns a discriminated result so callers can distinguish:
+ * - `{ kind: 'length' }`: function code is known and total frame length is determined.
+ * - `{ kind: 'need-more' }`: function code is known, but more bytes are required
+ *   (typically waiting on the byteCount byte).
+ * - `{ kind: 'unknown' }`: function code is not in the standard tables — the
+ *   framing layer must defer to a registered `CustomFunctionCode` or treat this
+ *   as a framing error.
+ */
+function predictRtuFrameLength(buffer, isResponse) {
+    if (buffer.length < 2) {
+        return { kind: 'need-more' };
+    }
+    const fc = buffer[1];
+    if (isResponse && (fc & EXCEPTION_OFFSET) !== 0) {
+        return { kind: 'length', length: 5 };
+    }
+    const fixed = (isResponse ? RESPONSE_FIXED_LENGTHS : REQUEST_FIXED_LENGTHS)[fc];
+    if (fixed !== undefined) {
+        return { kind: 'length', length: fixed };
+    }
+    const bc = (isResponse ? RESPONSE_BYTE_COUNT : REQUEST_BYTE_COUNT)[fc];
+    if (bc !== undefined) {
+        if (buffer.length <= bc.offset) {
+            return { kind: 'need-more' };
+        }
+        return { kind: 'length', length: bc.extra + buffer[bc.offset] };
+    }
+    if (isResponse && fc === exports.FunctionCode.READ_DEVICE_IDENTIFICATION) {
+        return predictFc43_14Response(buffer);
+    }
+    return { kind: 'unknown' };
+}
+/**
+ * Walk the variable-length FC 0x2B / MEI 0x0E (Read Device Identification)
+ * response structure per Modbus V1.1b3 §6.21.
+ *
+ * Layout (after unit and fc):
+ *   mei(1) rdic(1) conformity(1) more(1) nextObjId(1) numObjs(1)
+ *   [objId(1) objLen(1) objData(objLen)] × numObjs
+ *   CRC(2)
+ */
+function predictFc43_14Response(buffer) {
+    if (buffer.length < 8) {
+        return { kind: 'need-more' };
+    }
+    if (buffer[2] !== MEI_READ_DEVICE_ID) {
+        return { kind: 'unknown' };
+    }
+    const numObjs = buffer[7];
+    let offset = 8;
+    for (let i = 0; i < numObjs; i++) {
+        if (buffer.length < offset + 2) {
+            return { kind: 'need-more' };
+        }
+        const objLen = buffer[offset + 1];
+        offset += 2 + objLen;
+    }
+    return { kind: 'length', length: offset + 2 };
+}
+
 class SerialPhysicalLayer extends AbstractPhysicalLayer {
     get isOpen() {
         return this._serialport.isOpen;
@@ -55,6 +329,18 @@ class SerialPhysicalLayer extends AbstractPhysicalLayer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_isOpening", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "_destroyed", {
             enumerable: true,
             configurable: true,
@@ -71,27 +357,41 @@ class SerialPhysicalLayer extends AbstractPhysicalLayer {
         this._baudRate = options.baudRate;
     }
     open() {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
+        if (this._destroyed) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_DESTROYED, 'Port is destroyed'));
+        }
+        if (this.isOpen || this._isOpening) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_ALREADY_OPEN, 'Port is already open'));
         }
+        this._isOpening = true;
+        const connection = { id: genConnectionId('serial') };
+        this._connection = connection;
         return new Promise((resolve, reject) => {
             this._serialport.open((error) => {
                 if (error) {
+                    this._isOpening = false;
+                    if (this._connection === connection) {
+                        this._connection = null;
+                    }
                     reject(error);
+                    return;
                 }
-                else {
-                    this._serialport.on('data', (data) => {
-                        this.emit('data', data, (data) => this.write(data));
-                    });
-                    this._serialport.on('error', (error) => {
-                        this.emit('error', error);
-                    });
-                    this._serialport.on('close', () => {
+                this._isOpening = false;
+                this._serialport.on('data', (data) => {
+                    this.emit('data', data, (d) => this.write(d), connection);
+                });
+                this._serialport.on('error', (err) => {
+                    this.emit('error', err);
+                });
+                this._serialport.once('close', () => {
+                    if (this._connection === connection) {
                         this._serialport.removeAllListeners();
+                        this._connection = null;
+                        this.emit('connection-close', connection);
                         this.emit('close');
-                    });
-                    resolve();
-                }
+                    }
+                });
+                resolve();
             });
         });
     }
@@ -109,22 +409,24 @@ class SerialPhysicalLayer extends AbstractPhysicalLayer {
                 });
             }
             else {
-                reject(new Error('Port is not open'));
+                reject(new ModbusError(ModbusErrorCode.PORT_NOT_OPEN, 'Port is not open'));
             }
         });
     }
     close() {
+        if (!this._serialport.isOpen) {
+            return Promise.resolve();
+        }
         return new Promise((resolve) => {
-            this._serialport.removeAllListeners();
-            this._serialport.close(() => {
-                resolve();
-            });
+            this._serialport.once('close', () => resolve());
+            this._serialport.close();
         });
     }
     destroy() {
         this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
+        return this.close().then(() => {
+            this.removeAllListeners();
+        });
     }
 }
 
@@ -147,7 +449,13 @@ class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
+        });
+        Object.defineProperty(this, "_connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
         });
         Object.defineProperty(this, "_isOpen", {
             enumerable: true,
@@ -155,46 +463,79 @@ class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_isOpening", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "_destroyed", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        this._socket = new node_net.Socket(options);
+        Object.defineProperty(this, "_socketOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._socketOptions = options;
     }
     open(options) {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
+        if (this._destroyed) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_DESTROYED, 'Port is destroyed'));
+        }
+        if (this._isOpen || this._isOpening) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_ALREADY_OPEN, 'Port is already open'));
         }
+        this._isOpening = true;
+        const socket = new node_net.Socket(this._socketOptions);
+        const connection = { id: genConnectionId('tcp-client') };
+        this._socket = socket;
+        this._connection = connection;
         return new Promise((resolve, reject) => {
-            let called = false;
-            this._socket.connect(options !== null && options !== void 0 ? options : { port: 502 }, () => {
-                called = true;
-                this._isOpen = true;
-                this._socket.on('data', (data) => {
-                    this.emit('data', data, (data) => this.write(data));
-                });
-                this._socket.on('close', () => {
-                    this._isOpen = false;
-                    this._socket.removeAllListeners();
-                    this.emit('close');
-                });
-                resolve();
+            let connected = false;
+            socket.on('data', (data) => {
+                this.emit('data', data, (d) => this.write(d), connection);
             });
-            this._socket.on('error', (error) => {
-                if (called) {
-                    this.emit('error', error);
+            socket.on('error', (err) => {
+                if (connected) {
+                    this.emit('error', err);
                 }
                 else {
-                    reject(error);
+                    if (this._connection === connection) {
+                        this._isOpening = false;
+                        this._socket = null;
+                        this._connection = null;
+                    }
+                    socket.removeAllListeners();
+                    reject(err);
+                }
+            });
+            socket.once('close', () => {
+                if (this._connection === connection) {
+                    this._isOpen = false;
+                    this._isOpening = false;
+                    this._socket = null;
+                    this._connection = null;
+                    socket.removeAllListeners();
+                    this.emit('connection-close', connection);
+                    this.emit('close');
                 }
             });
+            socket.connect(options !== null && options !== void 0 ? options : { port: 502 }, () => {
+                connected = true;
+                this._isOpening = false;
+                this._isOpen = true;
+                resolve();
+            });
         });
     }
     write(data) {
         return new Promise((resolve, reject) => {
-            if (this.isOpen) {
+            if (this._isOpen && this._socket) {
                 this._socket.write(data, (error) => {
                     if (error) {
                         reject(error);
@@ -206,22 +547,25 @@ class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
                 });
             }
             else {
-                reject(new Error('Port is not open'));
+                reject(new ModbusError(ModbusErrorCode.PORT_NOT_OPEN, 'Port is not open'));
             }
         });
     }
     close() {
+        if (!this._socket) {
+            return Promise.resolve();
+        }
+        const socket = this._socket;
         return new Promise((resolve) => {
-            this._isOpen = false;
-            this._socket.removeAllListeners();
-            this._socket.destroy();
-            resolve();
+            socket.once('close', () => resolve());
+            socket.destroy();
         });
     }
     destroy() {
         this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
+        return this.close().then(() => {
+            this.removeAllListeners();
+        });
     }
 }
 
@@ -244,7 +588,7 @@ class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
         Object.defineProperty(this, "_isOpen", {
             enumerable: true,
@@ -252,92 +596,129 @@ class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_isOpening", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "_destroyed", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        Object.defineProperty(this, "_sockets", {
+        Object.defineProperty(this, "_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "_serverOptions", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Set()
+            value: void 0
         });
-        this._server = node_net.createServer(options, (socket) => {
-            this._sockets.add(socket);
+        this._serverOptions = options;
+    }
+    open(options) {
+        if (this._destroyed) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_DESTROYED, 'Port is destroyed'));
+        }
+        if (this._isOpen || this._isOpening) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_ALREADY_OPEN, 'Port is already open'));
+        }
+        this._isOpening = true;
+        this._connections.clear();
+        const server = node_net.createServer(this._serverOptions, (socket) => {
+            const conn = { id: genConnectionId('tcp-server') };
+            this._connections.set(socket, conn);
+            const response = (data) => new Promise((resolve, reject) => {
+                socket.write(data, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
             socket.on('data', (data) => {
-                this.emit('data', data, (data) => new Promise((resolve, reject) => {
-                    socket.write(data, (error) => {
-                        if (error) {
-                            reject(error);
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                }));
+                this.emit('data', data, response, conn);
+            });
+            socket.on('error', (err) => {
+                this.emit('error', err);
             });
             socket.once('close', () => {
+                if (this._connections.delete(socket)) {
+                    this.emit('connection-close', conn);
+                }
                 socket.removeAllListeners();
-                this._sockets.delete(socket);
             });
         });
-    }
-    open(options) {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
-        }
+        this._server = server;
         return new Promise((resolve, reject) => {
             var _a;
-            let called = false;
-            this._server.listen(Object.assign(Object.assign({}, options), { port: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 502 }), () => {
-                called = true;
-                this._isOpen = true;
-                this._sockets.clear();
-                this._server.on('close', () => {
+            let listening = false;
+            server.once('error', (err) => {
+                if (listening) {
+                    this.emit('error', err);
+                }
+                else {
+                    if (this._server === server) {
+                        this._isOpening = false;
+                        this._server = null;
+                    }
+                    server.removeAllListeners();
+                    reject(err);
+                }
+            });
+            server.once('close', () => {
+                if (this._server === server) {
                     this._isOpen = false;
-                    this._server.removeAllListeners();
-                    for (const socket of this._sockets) {
-                        socket.removeAllListeners();
+                    this._isOpening = false;
+                    this._server = null;
+                    const conns = Array.from(this._connections.values());
+                    this._connections.clear();
+                    for (const conn of conns) {
+                        this.emit('connection-close', conn);
                     }
                     this.emit('close');
-                });
-                resolve();
-            });
-            this._server.on('error', (error) => {
-                if (called) {
-                    this.emit('error', error);
-                }
-                else {
-                    reject(error);
                 }
             });
+            server.listen(Object.assign(Object.assign({}, options), { port: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 502 }), () => {
+                listening = true;
+                this._isOpening = false;
+                this._isOpen = true;
+                resolve();
+            });
         });
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     write(data) {
         return new Promise((resolve, reject) => {
-            reject(new Error('Not supported'));
+            reject(new ModbusError(ModbusErrorCode.NOT_SUPPORTED, 'Not supported'));
         });
     }
     close() {
+        if (!this._server) {
+            return Promise.resolve();
+        }
+        const server = this._server;
         return new Promise((resolve) => {
-            this._isOpen = false;
-            this._server.removeAllListeners();
-            for (const socket of this._sockets) {
-                socket.removeAllListeners();
+            server.once('close', () => resolve());
+            for (const [socket] of this._connections) {
                 socket.destroy();
             }
-            this._server.close(() => {
-                resolve();
-            });
+            server.close();
         });
     }
     destroy() {
         this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
+        return this.close().then(() => {
+            this.removeAllListeners();
+        });
     }
 }
 
@@ -348,14 +729,8 @@ class UdpPhysicalLayer extends AbstractPhysicalLayer {
     get destroyed() {
         return this._destroyed;
     }
-    /**
-     *
-     * @param options
-     * @param remote If omitted, as server.
-     * Otherwise as client.
-     */
-    constructor(options, remote) {
-        var _a, _b;
+    constructor(options) {
+        var _a, _b, _c, _d;
         super();
         Object.defineProperty(this, "TYPE", {
             enumerable: true,
@@ -367,7 +742,13 @@ class UdpPhysicalLayer extends AbstractPhysicalLayer {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
+        });
+        Object.defineProperty(this, "_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
         });
         Object.defineProperty(this, "_isOpen", {
             enumerable: true,
@@ -375,12 +756,24 @@ class UdpPhysicalLayer extends AbstractPhysicalLayer {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_isOpening", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "_destroyed", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_socketOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_port", {
             enumerable: true,
             configurable: true,
@@ -393,186 +786,225 @@ class UdpPhysicalLayer extends AbstractPhysicalLayer {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "isServer", {
+        Object.defineProperty(this, "_idleTimeout", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this._socket = node_dgram.createSocket(Object.assign(Object.assign({}, options), { type: (_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'udp4' }), (msg, rinfo) => {
-            this.emit('data', msg, (data) => new Promise((resolve, reject) => {
-                this._socket.send(data, rinfo.port, rinfo.address, (error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            }));
+        Object.defineProperty(this, "isServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
-        this.isServer = !remote;
-        this._port = (_b = remote === null || remote === void 0 ? void 0 : remote.port) !== null && _b !== void 0 ? _b : 502;
-        this._address = remote === null || remote === void 0 ? void 0 : remote.address;
+        this._socketOptions = options === null || options === void 0 ? void 0 : options.socket;
+        this.isServer = !(options === null || options === void 0 ? void 0 : options.remote);
+        this._port = (_b = (_a = options === null || options === void 0 ? void 0 : options.remote) === null || _a === void 0 ? void 0 : _a.port) !== null && _b !== void 0 ? _b : 502;
+        this._address = (_c = options === null || options === void 0 ? void 0 : options.remote) === null || _c === void 0 ? void 0 : _c.address;
+        this._idleTimeout = (_d = options === null || options === void 0 ? void 0 : options.idleTimeout) !== null && _d !== void 0 ? _d : 30000;
     }
     open(options) {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
+        var _a, _b;
+        if (this._destroyed) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_DESTROYED, 'Port is destroyed'));
+        }
+        if (this._isOpen || this._isOpening) {
+            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_ALREADY_OPEN, 'Port is already open'));
         }
+        this._isOpening = true;
+        this._connections.clear();
+        const socket = node_dgram.createSocket(Object.assign(Object.assign({}, this._socketOptions), { type: (_b = (_a = this._socketOptions) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'udp4' }), (msg, rinfo) => this._handleMessage(socket, msg, rinfo));
+        this._socket = socket;
         return new Promise((resolve, reject) => {
             var _a;
+            let started = false;
+            socket.on('error', (err) => {
+                if (started) {
+                    this.emit('error', err);
+                }
+                else {
+                    if (this._socket === socket) {
+                        this._isOpening = false;
+                        this._socket = null;
+                    }
+                    socket.removeAllListeners();
+                    reject(err);
+                }
+            });
+            socket.once('close', () => {
+                if (this._socket !== socket) {
+                    return;
+                }
+                this._isOpen = false;
+                this._isOpening = false;
+                this._socket = null;
+                socket.removeAllListeners();
+                const entries = Array.from(this._connections.values());
+                this._connections.clear();
+                for (const entry of entries) {
+                    if (entry.idleTimer) {
+                        clearTimeout(entry.idleTimer);
+                    }
+                    this.emit('connection-close', entry.conn);
+                }
+                this.emit('close');
+            });
             if (this.isServer) {
-                let called = false;
-                this._socket.bind(Object.assign(Object.assign({}, options), { port: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 502 }), () => {
-                    called = true;
+                socket.bind(Object.assign(Object.assign({}, options), { port: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 502 }), () => {
+                    started = true;
+                    this._isOpening = false;
                     this._isOpen = true;
-                    this._socket.on('close', () => {
-                        this._isOpen = false;
-                        this._socket.removeAllListeners();
-                        this.emit('close');
-                    });
                     resolve();
                 });
-                this._socket.on('error', (error) => {
-                    if (called) {
-                        this.emit('error', error);
-                    }
-                    else {
-                        reject(error);
-                    }
-                });
             }
             else {
+                started = true;
+                this._isOpening = false;
                 this._isOpen = true;
                 resolve();
             }
         });
     }
-    write(data) {
-        return new Promise((resolve, reject) => {
-            if (this.isOpen) {
-                this._socket.send(data, this._port, this._address, (error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        this.emit('write', data);
-                        resolve();
-                    }
+    _handleMessage(socket, msg, rinfo) {
+        if (this._socket !== socket) {
+            return;
+        }
+        if (!this.isServer) {
+            if (rinfo.port !== this._port) {
+                return;
+            }
+            if (this._address !== undefined && rinfo.address !== this._address) {
+                return;
+            }
+        }
+        const key = `${rinfo.address}:${rinfo.port}`;
+        let entry = this._connections.get(key);
+        if (!entry) {
+            entry = { conn: { id: genConnectionId('udp') } };
+            this._connections.set(key, entry);
+        }
+        if (this.isServer && this._idleTimeout > 0) {
+            if (entry.idleTimer) {
+                clearTimeout(entry.idleTimer);
+            }
+            const conn = entry.conn;
+            entry.idleTimer = setTimeout(() => {
+                const e = this._connections.get(key);
+                if (!e || e.conn !== conn) {
+                    return;
+                }
+                this._connections.delete(key);
+                this.emit('connection-close', conn);
+            }, this._idleTimeout);
+        }
+        const conn = entry.conn;
+        const response = (data) => new Promise((resolve, reject) => {
+            socket.send(data, rinfo.port, rinfo.address, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        this.emit('data', msg, response, conn);
+    }
+    write(data) {
+        return new Promise((resolve, reject) => {
+            if (this._isOpen && this._socket) {
+                this._socket.send(data, this._port, this._address, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        this.emit('write', data);
+                        resolve();
+                    }
                 });
             }
             else {
-                reject(new Error('Port is not open'));
+                reject(new ModbusError(ModbusErrorCode.PORT_NOT_OPEN, 'Port is not open'));
             }
         });
     }
     close() {
+        if (!this._socket) {
+            return Promise.resolve();
+        }
+        const socket = this._socket;
         return new Promise((resolve) => {
-            this._isOpen = false;
-            this._socket.removeAllListeners();
-            this._socket.close(() => {
-                resolve();
-            });
+            socket.once('close', () => resolve());
+            try {
+                socket.close();
+            }
+            catch (_a) {
+                // Socket may already be closed; the registered 'close' listener still fires asynchronously.
+            }
         });
     }
     destroy() {
         this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
+        return this.close().then(() => {
+            this.removeAllListeners();
+        });
     }
 }
 
 class AbstractApplicationLayer extends EventEmitter {
-}
-
-function checkRange(value, range) {
-    if (range) {
-        if (typeof range[0] === 'number' && typeof range[1] === 'number') {
-            if (range[0] < range[1]) {
-                return (Array.isArray(value) ? value : [value]).every((n) => n >= range[0] && n <= range[1]);
-            }
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "_role", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    get role() {
+        if (!this._role) {
+            throw new ModbusError(ModbusErrorCode.INVALID_ROLE, 'Application layer role not set');
         }
-        else if (range.length > 0) {
-            for (const r of range) {
-                if (r[0] < r[1]) {
-                    if ((Array.isArray(value) ? value : [value]).every((n) => n >= r[0] && n <= r[1])) {
-                        return true;
-                    }
-                }
-            }
-            return false;
+        return this._role;
+    }
+    set role(value) {
+        if (this._role && this._role !== value) {
+            throw new ModbusError(ModbusErrorCode.INVALID_ROLE, `Application layer role already set to ${this._role}`);
         }
+        this._role = value;
     }
-    return true;
-}
-
-const TABLE = [
-    0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01,
-    0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0,
-    0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581,
-    0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141,
-    0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01,
-    0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0,
-    0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681,
-    0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
-    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01,
-    0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0,
-    0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381,
-    0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741,
-    0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901,
-    0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0,
-    0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
-    0x4040,
-];
-function crc(data) {
-    let crc = 0xffff;
-    for (let index = 0; index < data.length; index++) {
-        crc = (TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8)) & 0xffff;
+    flush() {
+        // no-op — override in subclasses
+    }
+    addCustomFunctionCode(cfc) {
+    }
+    removeCustomFunctionCode(fc) {
     }
-    return crc;
-}
-
-/**
- * Get time interval between message frames witch well-known as 3.5T.
- * @param baudRate Serial port baud rate.
- * @param {number} [approximation=48] Approximate number of bits corresponding to 3.5T.
- * @returns `ms`.
- */
-function getThreePointFiveT(baudRate, approximation = 48) {
-    return (approximation * 1000) / baudRate;
-}
-
-function lrc(data) {
-    return (~data.reduce((sum, n) => sum + n, 0) + 1) & 0xff;
 }
 
 const MAX_FRAME_LENGTH = 256;
+const MIN_FRAME_LENGTH = 4;
 class RtuApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer, 
-    /**
-     * The time interval between two frames, support two formats:
-     * - bit: `48bit` as default
-     * - millisecond: `20ms`
-     */
-    intervalBetweenFrames) {
+    constructor(physicalLayer, options = {}) {
         super();
-        Object.defineProperty(this, "_waitingResponse", {
+        Object.defineProperty(this, "PROTOCOL", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: 'RTU'
         });
-        Object.defineProperty(this, "_timerThreePointFive", {
+        Object.defineProperty(this, "_states", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: new Map()
         });
-        Object.defineProperty(this, "_bufferRx", {
+        Object.defineProperty(this, "_customFunctionCodes", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: Buffer.alloc(0)
+            value: new Map()
         });
         Object.defineProperty(this, "_removeAllListeners", {
             enumerable: true,
@@ -580,129 +1012,276 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "_threePointFiveT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_onePointFiveT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const { intervalBetweenFrames, interCharTimeout } = options;
         let threePointFiveT = 0;
+        let onePointFiveT = 0;
         if (physicalLayer.TYPE === 'SERIAL') {
-            if (intervalBetweenFrames && intervalBetweenFrames.endsWith('ms')) {
-                threePointFiveT = Number(intervalBetweenFrames.slice(0, -2));
+            const baudRate = physicalLayer.baudRate;
+            if (intervalBetweenFrames && intervalBetweenFrames.unit === 'ms') {
+                threePointFiveT = intervalBetweenFrames.value;
             }
             else {
-                threePointFiveT = Math.ceil(physicalLayer.baudRate > 19200
-                    ? 1.8
-                    : getThreePointFiveT(physicalLayer.baudRate, intervalBetweenFrames ? Number(intervalBetweenFrames.slice(0, -3)) : 48));
-            }
-        }
-        const handleData = (data, response) => {
-            this._bufferRx = Buffer.concat([this._bufferRx, data]);
-            clearTimeout(this._timerThreePointFive);
-            const handleData = () => {
-                this.framing(this._bufferRx, (error, frame) => {
-                    if (this._waitingResponse) {
-                        if (error && error.message === 'Insufficient data length') {
-                            return;
-                        }
-                        this._waitingResponse.callback(error, frame);
-                        this._bufferRx = Buffer.alloc(0);
-                    }
-                    else {
-                        if (!error) {
-                            this.emit('framing', frame, response);
-                        }
-                        this._bufferRx = Buffer.alloc(0);
-                    }
-                });
-            };
-            if (this._bufferRx.length >= MAX_FRAME_LENGTH) {
-                handleData();
+                threePointFiveT =
+                    baudRate > 19200 ? 1.75 : Math.ceil(bitsToMs(baudRate, intervalBetweenFrames ? intervalBetweenFrames.value : 38.5));
             }
-            else {
-                if (threePointFiveT) {
-                    this._timerThreePointFive = setTimeout(handleData, threePointFiveT);
+            if (interCharTimeout) {
+                if (interCharTimeout.unit === 'ms') {
+                    onePointFiveT = interCharTimeout.value;
                 }
                 else {
-                    handleData();
+                    onePointFiveT = baudRate > 19200 ? 0.75 : Math.ceil(bitsToMs(baudRate, interCharTimeout.value));
                 }
             }
+        }
+        this._threePointFiveT = threePointFiveT;
+        this._onePointFiveT = onePointFiveT;
+        const handleData = (data, response, connection) => {
+            let state = this.getState(connection.id);
+            if (state.t15Expired && state.end > state.start) {
+                this.emit('framing-error', new ModbusError(ModbusErrorCode.T1_5_EXCEEDED, 'Inter-character timeout (t1.5) exceeded'));
+                state.start = 0;
+                state.end = 0;
+            }
+            state.t15Expired = false;
+            let dataOffset = 0;
+            while (dataOffset < data.length) {
+                const space = state.pool.length - state.end;
+                if (space === 0) {
+                    this.clearStateTimers(state);
+                    this.flushBuffer(connection.id, response, connection, this._threePointFiveT > 0);
+                    state = this.getState(connection.id);
+                    if (state.pool.length - state.end === 0) {
+                        this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_DATA, 'Frame buffer exhausted before complete frame received'));
+                        state.start = 0;
+                        state.end = 0;
+                        state.t15Expired = false;
+                    }
+                    continue;
+                }
+                const toCopy = Math.min(space, data.length - dataOffset);
+                data.copy(state.pool, state.end, dataOffset, dataOffset + toCopy);
+                state.end += toCopy;
+                dataOffset += toCopy;
+            }
+            this.clearStateTimers(state);
+            const commitFrame = () => {
+                this.clearStateTimers(state);
+                this.flushBuffer(connection.id, response, connection, this._threePointFiveT > 0);
+            };
+            if (state.end - state.start >= MAX_FRAME_LENGTH) {
+                commitFrame();
+            }
+            else if (this._threePointFiveT) {
+                if (this._onePointFiveT > 0) {
+                    state.interCharTimer = setTimeout(() => {
+                        state.interCharTimer = undefined;
+                        state.t15Expired = true;
+                    }, this._onePointFiveT);
+                }
+                state.timer = setTimeout(commitFrame, this._threePointFiveT);
+            }
+            else {
+                commitFrame();
+            }
         };
         physicalLayer.on('data', handleData);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('data', handleData);
-        });
+        this._removeAllListeners.push(() => physicalLayer.removeListener('data', handleData));
+        const handleConnectionClose = (connection) => {
+            this.clearState(connection.id);
+        };
+        physicalLayer.on('connection-close', handleConnectionClose);
+        this._removeAllListeners.push(() => physicalLayer.removeListener('connection-close', handleConnectionClose));
         const handleClose = () => {
-            clearTimeout(this._timerThreePointFive);
-            this._bufferRx = Buffer.alloc(0);
+            for (const key of [...this._states.keys()]) {
+                this.clearState(key);
+            }
         };
         physicalLayer.on('close', handleClose);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('close', handleClose);
-        });
+        this._removeAllListeners.push(() => physicalLayer.removeListener('close', handleClose));
     }
-    framing(buffer, callback) {
-        if (buffer.length >= 4) {
-            const frame = {
-                unit: buffer[0],
-                fc: buffer[1],
-                data: Array.from(buffer.subarray(2, buffer.length - 2)),
-                buffer,
-            };
-            if (this._waitingResponse) {
-                for (const check of this._waitingResponse.preCheck) {
-                    const res = check(frame);
-                    if (typeof res === 'undefined') {
-                        callback(new Error('Insufficient data length'));
-                        return;
-                    }
-                    if (typeof res === 'number') {
-                        if (frame.data.length < res) {
-                            callback(new Error('Insufficient data length'));
-                            return;
-                        }
-                        if (frame.data.length !== res) {
-                            callback(new Error('Invalid response'));
-                            return;
-                        }
-                    }
-                    if (!res) {
-                        callback(new Error('Invalid response'));
-                        return;
-                    }
+    getState(key) {
+        let state = this._states.get(key);
+        if (!state) {
+            state = { pool: Buffer.alloc(MAX_FRAME_LENGTH * 2), start: 0, end: 0 };
+            this._states.set(key, state);
+        }
+        return state;
+    }
+    clearStateTimers(state) {
+        if (state.timer) {
+            clearTimeout(state.timer);
+            state.timer = undefined;
+        }
+        if (state.interCharTimer) {
+            clearTimeout(state.interCharTimer);
+            state.interCharTimer = undefined;
+        }
+    }
+    clearState(key) {
+        const state = this._states.get(key);
+        if (state) {
+            this.clearStateTimers(state);
+        }
+        this._states.delete(key);
+    }
+    flush() {
+        for (const state of this._states.values()) {
+            this.clearStateTimers(state);
+            state.start = 0;
+            state.end = 0;
+        }
+        this._states.clear();
+    }
+    addCustomFunctionCode(cfc) {
+        if (!isUint8(cfc.fc)) {
+            throw new ModbusError(ModbusErrorCode.RANGE, `fc must be an integer in 0..255, got ${cfc.fc}`);
+        }
+        this._customFunctionCodes.set(cfc.fc, cfc);
+    }
+    removeCustomFunctionCode(fc) {
+        this._customFunctionCodes.delete(fc);
+    }
+    flushBuffer(key, response, connection, strict) {
+        const state = this._states.get(key);
+        if (!state) {
+            return;
+        }
+        while (state.end - state.start > 0) {
+            const buffer = state.pool.subarray(state.start, state.end);
+            const result = this.tryExtract(buffer);
+            if (result.kind === 'frame') {
+                state.start += result.frame.length;
+                this.deliverFrame(result.frame, response, connection);
+            }
+            else if (result.kind === 'skip') {
+                if (strict) {
+                    this.emit('framing-error', new ModbusError(ModbusErrorCode.CRC_MISMATCH, 'CRC mismatch'));
+                    state.start = 0;
+                    state.end = 0;
+                    state.t15Expired = false;
+                    return;
                 }
+                state.start += 1;
             }
-            const crcPassed = buffer.readUInt16LE(buffer.length - 2) === crc(buffer.subarray(0, buffer.length - 2));
-            if (crcPassed) {
-                callback(null, frame);
+            else if (result.kind === 'insufficient') {
+                if (state.end - state.start >= MAX_FRAME_LENGTH) {
+                    state.start += 1;
+                    continue;
+                }
+                if (strict) {
+                    this.emit('framing-error', new ModbusError(state.t15Expired ? ModbusErrorCode.T1_5_EXCEEDED : ModbusErrorCode.INCOMPLETE_FRAME, state.t15Expired ? 'Inter-character timeout (t1.5) exceeded' : 'Incomplete frame at t3.5'));
+                    state.start = 0;
+                    state.end = 0;
+                    state.t15Expired = false;
+                    return;
+                }
+                if (state.t15Expired) {
+                    this.emit('framing-error', new ModbusError(ModbusErrorCode.T1_5_EXCEEDED, 'Inter-character timeout (t1.5) exceeded'));
+                    state.start = 0;
+                    state.end = 0;
+                    state.t15Expired = false;
+                }
+                break;
             }
             else {
-                callback(new Error('CRC check failed'));
+                this.emit('framing-error', result.error);
+                state.start = 0;
+                state.end = 0;
+                return;
             }
         }
-        else {
-            callback(new Error('Insufficient data length'));
+        if (state.start > 0) {
+            if (state.start < state.end) {
+                state.pool.copy(state.pool, 0, state.start, state.end);
+            }
+            state.end -= state.start;
+            state.start = 0;
+        }
+        if (state.end === 0 && !state.timer) {
+            this._states.delete(key);
         }
     }
-    startWaitingResponse(preCheck, callback) {
-        this._waitingResponse = { preCheck, callback };
-        clearTimeout(this._timerThreePointFive);
-        this._bufferRx = Buffer.alloc(0);
+    tryExtract(buffer) {
+        if (buffer.length < MIN_FRAME_LENGTH) {
+            return { kind: 'insufficient' };
+        }
+        const isResponse = this.role === 'MASTER';
+        const fc = buffer[1];
+        const cfc = this._customFunctionCodes.get(fc);
+        if (cfc) {
+            const predictor = isResponse ? cfc.predictResponseLength : cfc.predictRequestLength;
+            const expected = predictor(buffer);
+            if (expected === null) {
+                return { kind: 'insufficient' };
+            }
+            return this.checkExpected(buffer, expected);
+        }
+        const result = predictRtuFrameLength(buffer, isResponse);
+        if (result.kind === 'length') {
+            return this.checkExpected(buffer, result.length);
+        }
+        if (result.kind === 'need-more') {
+            return { kind: 'insufficient' };
+        }
+        return {
+            kind: 'error',
+            error: new ModbusError(ModbusErrorCode.UNKNOWN_FC, `Unknown function code 0x${fc.toString(16).padStart(2, '0')} — register a CustomFunctionCode to frame this FC`),
+        };
     }
-    stopWaitingResponse() {
-        this._waitingResponse = undefined;
+    checkExpected(buffer, expected) {
+        if (expected > MAX_FRAME_LENGTH || expected < MIN_FRAME_LENGTH) {
+            return { kind: 'error', error: new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data') };
+        }
+        if (buffer.length < expected) {
+            return { kind: 'insufficient' };
+        }
+        if (this.crcMatches(buffer, expected)) {
+            return { kind: 'frame', frame: buffer.subarray(0, expected), rest: buffer.subarray(expected) };
+        }
+        return { kind: 'skip', rest: buffer.subarray(1) };
+    }
+    crcMatches(buffer, length) {
+        return buffer.readUInt16LE(length - 2) === crc(buffer.subarray(0, length - 2));
+    }
+    deliverFrame(buffer, response, connection) {
+        const frameBuf = Buffer.from(buffer);
+        const frame = {
+            unit: frameBuf[0],
+            fc: frameBuf[1],
+            data: frameBuf.subarray(2, frameBuf.length - 2),
+            buffer: frameBuf,
+        };
+        this.emit('framing', frame, response, connection);
     }
     encode(data) {
         const buffer = Buffer.alloc(data.data.length + 4);
         buffer.writeUInt8(data.unit, 0);
         buffer.writeUInt8(data.fc, 1);
-        data.data.forEach((num, index) => {
-            buffer.writeUInt8(num, 2 + index);
-        });
+        buffer.set(data.data, 2);
         buffer.writeUInt16LE(crc(buffer.subarray(0, -2)), buffer.length - 2);
         return buffer;
     }
     destroy() {
         this.removeAllListeners();
-        for (const removeAllListener of this._removeAllListeners) {
-            removeAllListener();
+        for (const removeListener of this._removeAllListeners) {
+            removeListener();
         }
-        clearTimeout(this._timerThreePointFive);
+        for (const state of this._states.values()) {
+            this.clearStateTimers(state);
+        }
+        this._states.clear();
     }
 }
 
@@ -711,26 +1290,43 @@ const CHAR_CODE = {
     CR: '\r'.charCodeAt(0),
     LF: '\n'.charCodeAt(0),
 };
+// Modbus ASCII frame encodes at most 256 PDU bytes as 512 hex chars between
+// `:` and `\r`. Cap per-connection buffering so a peer that never sends `\r`
+// cannot grow `state.frame` without bound.
+const MAX_ASCII_PAYLOAD = 512;
+const HEX_DECODE = new Uint8Array(256);
+HEX_DECODE.fill(0xff);
+for (let i = 0x30; i <= 0x39; i++) {
+    HEX_DECODE[i] = i - 0x30;
+}
+for (let i = 0x41; i <= 0x46; i++) {
+    HEX_DECODE[i] = i - 0x41 + 10;
+}
+for (let i = 0x61; i <= 0x66; i++) {
+    HEX_DECODE[i] = i - 0x61 + 10;
+}
+const HEX_ENCODE = new Uint8Array('0123456789ABCDEF'.split('').map((c) => c.charCodeAt(0)));
 class AsciiApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer) {
+    constructor(physicalLayer, options = {}) {
+        var _a;
         super();
-        Object.defineProperty(this, "_waitingResponse", {
+        Object.defineProperty(this, "PROTOCOL", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: 'ASCII'
         });
-        Object.defineProperty(this, "_status", {
+        Object.defineProperty(this, "lenientHex", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'idle'
+            value: void 0
         });
-        Object.defineProperty(this, "_frame", {
+        Object.defineProperty(this, "_states", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: new Map()
         });
         Object.defineProperty(this, "_removeAllListeners", {
             enumerable: true,
@@ -738,44 +1334,62 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
             writable: true,
             value: []
         });
-        const handleData = (data, response) => {
+        this.lenientHex = (_a = options.lenientHex) !== null && _a !== void 0 ? _a : false;
+        const lenientHex = this.lenientHex;
+        const isHexChar = (value) => {
+            if (value >= 0x30 && value <= 0x39) {
+                return true;
+            }
+            if (value >= 0x41 && value <= 0x46) {
+                return true;
+            }
+            if (lenientHex && value >= 0x61 && value <= 0x66) {
+                return true;
+            }
+            return false;
+        };
+        const handleData = (data, response, connection) => {
+            const state = this.getState(connection.id);
             data.forEach((value) => {
-                switch (this._status) {
+                switch (state.status) {
                     case 'idle': {
                         if (value === CHAR_CODE.COLON) {
-                            this._status = 'reception';
-                            this._frame = [];
+                            state.status = 'reception';
+                            state.frame = [];
                         }
                         break;
                     }
                     case 'reception': {
                         if (value === CHAR_CODE.COLON) {
-                            this._frame = [];
+                            state.frame = [];
                         }
                         else if (value === CHAR_CODE.CR) {
-                            this._status = 'waiting end';
+                            state.status = 'waiting end';
+                        }
+                        else if (state.frame.length >= MAX_ASCII_PAYLOAD) {
+                            state.status = 'idle';
+                            state.frame = [];
+                            this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data'));
+                        }
+                        else if (!isHexChar(value)) {
+                            state.status = 'idle';
+                            state.frame = [];
+                            this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_HEX, 'Invalid hex character'));
                         }
                         else {
-                            this._frame.push(value);
+                            state.frame.push(value);
                         }
                         break;
                     }
                     case 'waiting end': {
                         if (value === CHAR_CODE.COLON) {
-                            this._status = 'reception';
-                            this._frame = [];
+                            state.status = 'reception';
+                            state.frame = [];
                         }
                         else {
-                            this._status = 'idle';
+                            state.status = 'idle';
                             if (value === CHAR_CODE.LF) {
-                                this.framing(Buffer.from(this._frame), (error, frame) => {
-                                    if (this._waitingResponse) {
-                                        this._waitingResponse.callback(error, frame);
-                                    }
-                                    else if (!error) {
-                                        this.emit('framing', frame, response);
-                                    }
-                                });
+                                this.framing(Buffer.from(state.frame), response, connection);
                             }
                         }
                         break;
@@ -784,115 +1398,97 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
             });
         };
         physicalLayer.on('data', handleData);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('data', handleData);
-        });
+        this._removeAllListeners.push(() => physicalLayer.removeListener('data', handleData));
+        const handleConnectionClose = (connection) => {
+            this._states.delete(connection.id);
+        };
+        physicalLayer.on('connection-close', handleConnectionClose);
+        this._removeAllListeners.push(() => physicalLayer.removeListener('connection-close', handleConnectionClose));
         const handleClose = () => {
-            this._status = 'idle';
-            this._frame = [];
+            this._states.clear();
         };
         physicalLayer.on('close', handleClose);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('close', handleClose);
-        });
-    }
-    framing(_buffer, callback) {
-        if (_buffer.length >= 6) {
-            if (_buffer.length % 2 === 0) {
-                const ascii = [];
-                let num = '';
-                for (const value of _buffer) {
-                    num += String.fromCharCode(value);
-                    if (num.length === 2) {
-                        ascii.push(Number('0x' + num));
-                        num = '';
-                    }
-                }
-                const buffer = Buffer.from(ascii);
-                const frame = {
-                    unit: buffer[0],
-                    fc: buffer[1],
-                    data: Array.from(buffer.subarray(2, buffer.length - 1)),
-                    buffer: _buffer,
-                };
-                if (this._waitingResponse) {
-                    for (const check of this._waitingResponse.preCheck) {
-                        const res = check(frame);
-                        if (typeof res === 'undefined') {
-                            callback(new Error('Insufficient data length'));
-                            return;
-                        }
-                        if (typeof res === 'number') {
-                            if (frame.data.length < res) {
-                                callback(new Error('Insufficient data length'));
-                                return;
-                            }
-                            if (frame.data.length !== res) {
-                                callback(new Error('Invalid response'));
-                                return;
-                            }
-                        }
-                        if (!res) {
-                            callback(new Error('Invalid response'));
-                            return;
-                        }
-                    }
-                }
-                const lrcPassed = buffer[buffer.length - 1] === lrc(buffer.subarray(0, buffer.length - 1));
-                if (lrcPassed) {
-                    callback(null, frame);
-                }
-                else {
-                    callback(new Error('LRC check failed'));
-                }
-            }
-            else {
-                callback(new Error('Invalid data'));
-            }
-        }
-        else {
-            callback(new Error('Insufficient data length'));
+        this._removeAllListeners.push(() => physicalLayer.removeListener('close', handleClose));
+    }
+    getState(key) {
+        let state = this._states.get(key);
+        if (!state) {
+            state = { status: 'idle', frame: [] };
+            this._states.set(key, state);
         }
+        return state;
     }
-    startWaitingResponse(preCheck, callback) {
-        this._waitingResponse = { preCheck, callback };
-        this._status = 'idle';
-        this._frame = [];
+    flush() {
+        this._states.clear();
     }
-    stopWaitingResponse() {
-        this._waitingResponse = undefined;
+    framing(_buffer, response, connection) {
+        if (_buffer.length < 6) {
+            this.emit('framing-error', new ModbusError(ModbusErrorCode.INSUFFICIENT_DATA, 'Insufficient data length'));
+            return;
+        }
+        if (_buffer.length % 2 !== 0) {
+            this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data'));
+            return;
+        }
+        const buffer = Buffer.allocUnsafe(_buffer.length / 2);
+        for (let i = 0; i < _buffer.length; i += 2) {
+            const hi = HEX_DECODE[_buffer[i]];
+            const lo = HEX_DECODE[_buffer[i + 1]];
+            if (hi === 0xff || lo === 0xff) {
+                this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_HEX, 'Invalid hex character'));
+                return;
+            }
+            buffer[i / 2] = (hi << 4) | lo;
+        }
+        const frame = {
+            unit: buffer[0],
+            fc: buffer[1],
+            data: buffer.subarray(2, buffer.length - 1),
+            buffer: _buffer,
+        };
+        const lrcPassed = buffer[buffer.length - 1] === lrc(buffer.subarray(0, buffer.length - 1));
+        if (!lrcPassed) {
+            this.emit('framing-error', new ModbusError(ModbusErrorCode.LRC_MISMATCH, 'LRC check failed'));
+            return;
+        }
+        this.emit('framing', frame, response, connection);
     }
     encode(data) {
         const buffer = Buffer.alloc(data.data.length + 3);
         buffer.writeUInt8(data.unit, 0);
         buffer.writeUInt8(data.fc, 1);
-        data.data.forEach((num, index) => {
-            buffer.writeUInt8(num, 2 + index);
-        });
+        buffer.set(data.data, 2);
         buffer.writeUInt8(lrc(buffer.subarray(0, -1)), buffer.length - 1);
-        let frame = ':';
-        for (const value of buffer) {
-            frame += value.toString(16).toUpperCase().padStart(2, '0');
+        const out = Buffer.allocUnsafe(1 + buffer.length * 2 + 2);
+        out[0] = CHAR_CODE.COLON;
+        for (let i = 0; i < buffer.length; i++) {
+            const byte = buffer[i];
+            out[1 + i * 2] = HEX_ENCODE[byte >> 4];
+            out[2 + i * 2] = HEX_ENCODE[byte & 0x0f];
         }
-        frame += '\r\n';
-        return Buffer.from(frame);
+        out[out.length - 2] = CHAR_CODE.CR;
+        out[out.length - 1] = CHAR_CODE.LF;
+        return out;
     }
     destroy() {
         this.removeAllListeners();
-        for (const removeAllListener of this._removeAllListeners) {
-            removeAllListener();
+        for (const removeListener of this._removeAllListeners) {
+            removeListener();
         }
+        this._states.clear();
     }
 }
 
+const MAX_TCP_FRAME = 260;
+const EMPTY_BUFFER = Buffer.alloc(0);
 class TcpApplicationLayer extends AbstractApplicationLayer {
     constructor(physicalLayer) {
         super();
-        Object.defineProperty(this, "_waitingResponse", {
+        Object.defineProperty(this, "PROTOCOL", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: 'TCP'
         });
         Object.defineProperty(this, "_transactionId", {
             enumerable: true,
@@ -900,98 +1496,209 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
             writable: true,
             value: 1
         });
+        Object.defineProperty(this, "_buffers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "_removeAllListeners", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: []
         });
-        const handleData = (data, response) => {
-            this.framing(data, (error, frame) => {
-                if (this._waitingResponse) {
-                    this._waitingResponse.callback(error, frame);
-                }
-                else if (!error) {
-                    this.emit('framing', frame, response);
+        const handleData = (data, response, connection) => {
+            var _a;
+            let buffer = (_a = this._buffers.get(connection.id)) !== null && _a !== void 0 ? _a : EMPTY_BUFFER;
+            buffer = buffer.length === 0 ? data : Buffer.concat([buffer, data]);
+            while (buffer.length > 0) {
+                const result = this.tryExtract(buffer);
+                if (result.kind === 'frame') {
+                    this.processFrame(result.frame, response, connection);
+                    buffer = result.rest;
+                }
+                else if (result.kind === 'insufficient') {
+                    break;
                 }
-            });
-        };
-        physicalLayer.on('data', handleData);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('data', handleData);
-        });
-    }
-    framing(buffer, callback) {
-        if (buffer.length >= 8) {
-            if (buffer[2] === 0 && buffer[3] === 0 && buffer.readUInt16BE(4) === buffer.length - 6) {
-                const frame = {
-                    transaction: buffer.readUInt16BE(0),
-                    unit: buffer[6],
-                    fc: buffer[7],
-                    data: Array.from(buffer.subarray(8)),
-                    buffer,
-                };
-                if (this._waitingResponse) {
-                    for (const check of this._waitingResponse.preCheck) {
-                        const res = check(frame);
-                        if (typeof res === 'undefined') {
-                            callback(new Error('Insufficient data length'));
-                            return;
-                        }
-                        if (typeof res === 'number') {
-                            if (frame.data.length < res) {
-                                callback(new Error('Insufficient data length'));
-                                return;
-                            }
-                            if (frame.data.length !== res) {
-                                callback(new Error('Invalid response'));
-                                return;
-                            }
-                        }
-                        if (!res) {
-                            callback(new Error('Invalid response'));
-                            return;
-                        }
-                    }
+                else {
+                    this.emit('framing-error', result.error);
+                    buffer = EMPTY_BUFFER;
+                    break;
                 }
-                callback(null, frame);
+            }
+            if (buffer.length === 0) {
+                this._buffers.delete(connection.id);
             }
             else {
-                callback(new Error('Invalid data'));
+                this._buffers.set(connection.id, buffer);
             }
+        };
+        physicalLayer.on('data', handleData);
+        this._removeAllListeners.push(() => physicalLayer.removeListener('data', handleData));
+        const handleConnectionClose = (connection) => {
+            this._buffers.delete(connection.id);
+        };
+        physicalLayer.on('connection-close', handleConnectionClose);
+        this._removeAllListeners.push(() => physicalLayer.removeListener('connection-close', handleConnectionClose));
+        const handleClose = () => {
+            this._buffers.clear();
+        };
+        physicalLayer.on('close', handleClose);
+        this._removeAllListeners.push(() => physicalLayer.removeListener('close', handleClose));
+    }
+    tryExtract(buffer) {
+        if (buffer.length < 8) {
+            return { kind: 'insufficient' };
+        }
+        if (buffer[2] !== 0 || buffer[3] !== 0) {
+            return { kind: 'error', error: new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data') };
+        }
+        const length = buffer.readUInt16BE(4);
+        const total = 6 + length;
+        if (total > MAX_TCP_FRAME || length < 2) {
+            return { kind: 'error', error: new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data') };
+        }
+        if (buffer.length < total) {
+            return { kind: 'insufficient' };
+        }
+        return { kind: 'frame', frame: buffer.subarray(0, total), rest: buffer.subarray(total) };
+    }
+    processFrame(buffer, response, connection) {
+        const frame = {
+            transaction: buffer.readUInt16BE(0),
+            unit: buffer[6],
+            fc: buffer[7],
+            data: buffer.subarray(8),
+            buffer,
+        };
+        this.emit('framing', frame, response, connection);
+    }
+    encode(data) {
+        var _a;
+        const transaction = (_a = data.transaction) !== null && _a !== void 0 ? _a : this._transactionId;
+        const buffer = Buffer.alloc(data.data.length + 8);
+        buffer.writeUInt16BE(transaction, 0);
+        buffer.writeUInt16BE(0, 2);
+        buffer.writeUInt16BE(data.data.length + 2, 4);
+        buffer.writeUInt8(data.unit, 6);
+        buffer.writeUInt8(data.fc, 7);
+        buffer.set(data.data, 8);
+        if (data.transaction === undefined) {
+            this._transactionId = (this._transactionId + 1) % 65536 || 1;
         }
-        else {
-            callback(new Error('Insufficient data length'));
+        return buffer;
+    }
+    destroy() {
+        this.removeAllListeners();
+        for (const removeListener of this._removeAllListeners) {
+            removeListener();
         }
+        this._buffers.clear();
     }
-    startWaitingResponse(preCheck, callback) {
-        this._waitingResponse = { preCheck, callback };
+}
+
+const FIFO_KEY = 'fifo';
+class MasterSession {
+    constructor() {
+        Object.defineProperty(this, "_waiters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    start(key, preCheck, callback) {
+        this._waiters.set(key, { preCheck, callback });
+    }
+    stop(key) {
+        this._waiters.delete(key);
+    }
+    stopAll(error) {
+        const waiters = [...this._waiters.values()];
+        this._waiters.clear();
+        for (const w of waiters) {
+            w.callback(error);
+        }
     }
-    stopWaitingResponse() {
-        this._waitingResponse = undefined;
+    has(key) {
+        return this._waiters.has(key);
     }
-    encode(data) {
+    handleFrame(frame) {
         var _a;
-        const buffer = Buffer.alloc(data.data.length + 8);
-        buffer.writeUInt16BE((_a = data.transaction) !== null && _a !== void 0 ? _a : this._transactionId, 0);
-        buffer.writeUInt16BE(0, 2);
-        buffer.writeUInt16BE(data.data.length + 2, 4);
-        buffer.writeUInt8(data.unit, 6);
-        buffer.writeUInt8(data.fc, 7);
-        data.data.forEach((num, index) => {
-            buffer.writeUInt8(num, 8 + index);
-        });
-        this._transactionId = (this._transactionId + 1) % 256 || 1;
-        return buffer;
-    }
-    destroy() {
-        this.removeAllListeners();
-        for (const removeAllListener of this._removeAllListeners) {
-            removeAllListener();
+        const key = (_a = frame.transaction) !== null && _a !== void 0 ? _a : FIFO_KEY;
+        const waiter = this._waiters.get(key);
+        if (!waiter) {
+            return;
+        }
+        if (!this.runPreChecks(waiter, frame)) {
+            return;
+        }
+        waiter.callback(null, frame);
+    }
+    handleError(error) {
+        // Framing errors lose transaction context; reject every in-flight waiter.
+        this.stopAll(error);
+    }
+    runPreChecks(waiter, frame) {
+        for (const check of waiter.preCheck) {
+            const res = check(frame);
+            if (typeof res === 'undefined') {
+                waiter.callback(new ModbusError(ModbusErrorCode.INSUFFICIENT_DATA, 'Insufficient data length'));
+                return false;
+            }
+            if (typeof res === 'number') {
+                if (frame.data.length < res) {
+                    waiter.callback(new ModbusError(ModbusErrorCode.INSUFFICIENT_DATA, 'Insufficient data length'));
+                    return false;
+                }
+                if (frame.data.length !== res) {
+                    waiter.callback(new ModbusError(ModbusErrorCode.INVALID_RESPONSE, 'Invalid response'));
+                    return false;
+                }
+                continue;
+            }
+            if (!res) {
+                waiter.callback(new ModbusError(ModbusErrorCode.INVALID_RESPONSE, 'Invalid response'));
+                return false;
+            }
         }
+        return true;
     }
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 class ModbusMaster extends EventEmitter {
     get isOpen() {
         return this.physicalLayer.isOpen;
@@ -999,7 +1706,8 @@ class ModbusMaster extends EventEmitter {
     get destroyed() {
         return this.physicalLayer.destroyed;
     }
-    constructor(applicationLayer, physicalLayer, timeout = 1000) {
+    constructor(applicationLayer, physicalLayer, options = {}) {
+        var _a, _b;
         super();
         Object.defineProperty(this, "applicationLayer", {
             enumerable: true,
@@ -1013,11 +1721,47 @@ class ModbusMaster extends EventEmitter {
             writable: true,
             value: physicalLayer
         });
+        Object.defineProperty(this, "_masterSession", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new MasterSession()
+        });
+        Object.defineProperty(this, "_queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "_draining", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_nextTid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "_closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "timeout", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: timeout
+            value: void 0
+        });
+        Object.defineProperty(this, "concurrent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
         Object.defineProperty(this, "writeFC1", {
             enumerable: true,
@@ -1091,6 +1835,12 @@ class ModbusMaster extends EventEmitter {
             writable: true,
             value: void 0
         });
+        this.timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : 1000;
+        this.concurrent = (_b = options.concurrent) !== null && _b !== void 0 ? _b : false;
+        if (this.concurrent && this.applicationLayer.PROTOCOL !== 'TCP') {
+            throw new ModbusError(ModbusErrorCode.CONCURRENT_NOT_TCP, 'concurrent mode requires a Modbus TCP application layer');
+        }
+        this.applicationLayer.role = 'MASTER';
         this.writeFC1 = this.readCoils;
         this.writeFC2 = this.readDiscreteInputs;
         this.writeFC3 = this.readHoldingRegisters;
@@ -1103,6 +1853,12 @@ class ModbusMaster extends EventEmitter {
         this.handleFC22 = this.maskWriteRegister;
         this.handleFC23 = this.readAndWriteMultipleRegisters;
         this.handleFC43_14 = this.readDeviceIdentification;
+        applicationLayer.on('framing', (frame) => {
+            this._masterSession.handleFrame(frame);
+        });
+        applicationLayer.on('framing-error', (error) => {
+            this._masterSession.handleError(error);
+        });
         physicalLayer.on('error', (error) => {
             this.emit('error', error);
         });
@@ -1110,50 +1866,90 @@ class ModbusMaster extends EventEmitter {
             this.emit('close');
         });
     }
-    waitResponse(request, response, timeout) {
+    send(adu, preCheck, timeout, broadcast) {
+        const task = () => this._exchange(adu, preCheck, timeout, broadcast);
+        if (this.concurrent) {
+            return task();
+        }
+        return new Promise((resolve, reject) => {
+            const run = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    resolve(yield task());
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            this._queue.push({ run, cancel: reject });
+            this._drain();
+        });
+    }
+    _drain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._draining) {
+                return;
+            }
+            this._draining = true;
+            try {
+                while (this._queue.length > 0) {
+                    const item = this._queue.shift();
+                    yield item.run();
+                }
+            }
+            finally {
+                this._draining = false;
+            }
+        });
+    }
+    _exchange(adu, preCheck, timeout, broadcast) {
         return new Promise((resolve, reject) => {
+            if (this._closed) {
+                reject(new ModbusError(ModbusErrorCode.MASTER_CLOSED, 'Master closed'));
+                return;
+            }
+            const usesTid = this.applicationLayer.PROTOCOL === 'TCP' && !broadcast;
+            let tid;
+            if (usesTid) {
+                tid = this._nextTid;
+                this._nextTid = (this._nextTid + 1) % 65536 || 1;
+            }
+            const key = tid !== null && tid !== void 0 ? tid : FIFO_KEY;
+            const payload = this.applicationLayer.encode(Object.assign(Object.assign({}, adu), { transaction: tid }));
             let settled = false;
-            const tid = setTimeout(() => {
-                if (!settled) {
-                    settled = true;
-                    this.applicationLayer.stopWaitingResponse();
-                    reject(new Error('Timeout'));
+            const settle = (error, frame) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                this._masterSession.stop(key);
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(frame);
                 }
-            }, timeout);
+            };
+            const timer = setTimeout(() => settle(new ModbusError(ModbusErrorCode.TIMEOUT, 'Timeout')), timeout);
+            // FIFO mode: clear stale buffer state before this request.
+            // Concurrent mode: must not flush — other in-flight requests share the buffer.
+            if (!this.concurrent) {
+                this.applicationLayer.flush();
+            }
             this.physicalLayer
-                .write(request.data)
+                .write(payload)
                 .then(() => {
-                if (!settled) {
-                    if (request.broadcast) {
-                        settled = true;
-                        clearTimeout(tid);
-                        resolve();
-                    }
-                    else {
-                        this.applicationLayer.startWaitingResponse(response.preCheck, (error, frame) => {
-                            if (!settled) {
-                                settled = true;
-                                clearTimeout(tid);
-                                this.applicationLayer.stopWaitingResponse();
-                                if (error) {
-                                    reject(error);
-                                }
-                                else {
-                                    resolve(frame);
-                                }
-                            }
-                        });
-                    }
+                if (settled) {
+                    return;
                 }
-            })
-                .catch((error) => {
-                if (!settled) {
-                    settled = true;
-                    clearTimeout(tid);
-                    this.applicationLayer.stopWaitingResponse();
-                    reject(error);
+                if (broadcast) {
+                    settle(null);
+                    return;
                 }
-            });
+                const finalChecks = usesTid ? [(frame) => frame.transaction === tid, ...preCheck] : preCheck;
+                this._masterSession.start(key, finalChecks, (error, frame) => settle(error, frame));
+            })
+                .catch((error) => settle(error));
         });
     }
     writeFC1Or2(unit, fc, address, length, timeout) {
@@ -1161,104 +1957,60 @@ class ModbusMaster extends EventEmitter {
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(length, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
-        }, timeout).then((frame) => {
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount], timeout, unit === 0).then((frame) => {
             if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }).map((_, index) => (frame.data[1 + ~~(index / 8)] & (1 << index % 8)) > 0) });
+                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }, (_, index) => (frame.data[1 + ~~(index / 8)] & (1 << index % 8)) > 0) });
             }
         });
     }
     readCoils(unit, address, length, timeout = this.timeout) {
-        return this.writeFC1Or2(unit, 0x01, address, length, timeout);
+        return this.writeFC1Or2(unit, exports.FunctionCode.READ_COILS, address, length, timeout);
     }
     readDiscreteInputs(unit, address, length, timeout = this.timeout) {
-        return this.writeFC1Or2(unit, 0x02, address, length, timeout);
+        return this.writeFC1Or2(unit, exports.FunctionCode.READ_DISCRETE_INPUTS, address, length, timeout);
     }
     writeFC3Or4(unit, fc, address, length, timeout) {
         const byteCount = length * 2;
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(length, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
-        }, timeout).then((frame) => {
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount], timeout, unit === 0).then((frame) => {
             if (frame) {
-                const bufferRx = Buffer.from(frame.data.slice(1));
-                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }).map((_, index) => bufferRx.readUInt16BE(index * 2)) });
+                const bufferRx = frame.data.subarray(1);
+                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }, (_, index) => bufferRx.readUInt16BE(index * 2)) });
             }
         });
     }
     readHoldingRegisters(unit, address, length, timeout = this.timeout) {
-        return this.writeFC3Or4(unit, 0x03, address, length, timeout);
+        return this.writeFC3Or4(unit, exports.FunctionCode.READ_HOLDING_REGISTERS, address, length, timeout);
     }
     readInputRegisters(unit, address, length, timeout = this.timeout) {
-        return this.writeFC3Or4(unit, 0x04, address, length, timeout);
+        return this.writeFC3Or4(unit, exports.FunctionCode.READ_INPUT_REGISTERS, address, length, timeout);
     }
     writeSingleCoil(unit, address, value, timeout = this.timeout) {
-        const fc = 0x05;
+        const fc = exports.FunctionCode.WRITE_SINGLE_COIL;
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value ? 0xff00 : 0x0000, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                () => bufferTx.length,
-                (frame) => frame.data.every((v, i) => v === bufferTx[i]),
-            ],
-        }, timeout).then((frame) => {
+        bufferTx.writeUInt16BE(value ? COIL_ON : COIL_OFF, 2);
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => bufferTx.length, (frame) => frame.data.equals(bufferTx)], timeout, unit === 0).then((frame) => {
             if (frame) {
                 return Object.assign(Object.assign({}, frame), { data: value });
             }
         });
     }
     writeSingleRegister(unit, address, value, timeout = this.timeout) {
-        const fc = 0x06;
+        const fc = exports.FunctionCode.WRITE_SINGLE_REGISTER;
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(value, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                () => bufferTx.length,
-                (frame) => frame.data.every((v, i) => v === bufferTx[i]),
-            ],
-        }, timeout).then((frame) => {
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => bufferTx.length, (frame) => frame.data.equals(bufferTx)], timeout, unit === 0).then((frame) => {
             if (frame) {
                 return Object.assign(Object.assign({}, frame), { data: value });
             }
         });
     }
     writeMultipleCoils(unit, address, value, timeout = this.timeout) {
-        const fc = 0x0f;
+        const fc = exports.FunctionCode.WRITE_MULTIPLE_COILS;
         const byteCount = Math.ceil(value.length / 8);
         const bufferTx = Buffer.alloc(5 + byteCount);
         bufferTx.writeUInt16BE(address, 0);
@@ -1269,23 +2021,14 @@ class ModbusMaster extends EventEmitter {
                 bufferTx[5 + ~~(i / 8)] |= 1 << i % 8;
             }
         });
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
-        }, timeout).then((frame) => {
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.equals(bufferTx.subarray(0, 4))], timeout, unit === 0).then((frame) => {
             if (frame) {
                 return Object.assign(Object.assign({}, frame), { data: value });
             }
         });
     }
     writeMultipleRegisters(unit, address, value, timeout = this.timeout) {
-        const fc = 0x10;
+        const fc = exports.FunctionCode.WRITE_MULTIPLE_REGISTERS;
         const byteCount = value.length * 2;
         const bufferTx = Buffer.alloc(5 + byteCount);
         bufferTx.writeUInt16BE(address, 0);
@@ -1294,73 +2037,48 @@ class ModbusMaster extends EventEmitter {
         value.forEach((v, i) => {
             bufferTx.writeUInt16BE(v, 5 + i * 2);
         });
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
-        }, timeout).then((frame) => {
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.equals(bufferTx.subarray(0, 4))], timeout, unit === 0).then((frame) => {
             if (frame) {
                 return Object.assign(Object.assign({}, frame), { data: value });
             }
         });
     }
-    reportServerId(unit, timeout = this.timeout) {
-        const fc = 0x11;
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: [],
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                (frame) => {
-                    if (frame.data.length >= 3) {
-                        return 1 + frame.data[0];
-                    }
-                },
-            ],
-        }, timeout).then((frame) => {
+    reportServerId(unit, serverIdLength = 1, timeout = this.timeout) {
+        const fc = exports.FunctionCode.REPORT_SERVER_ID;
+        return this.send({ unit, fc, data: Buffer.alloc(0) }, [
+            (frame) => frame.unit === unit && frame.fc === fc,
+            (frame) => {
+                if (frame.data.length >= 2 + serverIdLength) {
+                    return 1 + frame.data[0];
+                }
+            },
+        ], timeout, unit === 0).then((frame) => {
             if (frame) {
+                const runStatusIndex = 1 + serverIdLength;
                 return Object.assign(Object.assign({}, frame), { data: {
-                        serverId: frame.data[1],
-                        runIndicatorStatus: frame.data[2] === 0xff,
-                        additionalData: frame.data.slice(3),
+                        serverId: serverIdLength === 1 ? frame.data[1] : Array.from(frame.data.subarray(1, runStatusIndex)),
+                        runIndicatorStatus: frame.data[runStatusIndex] === 0xff,
+                        additionalData: Array.from(frame.data.subarray(runStatusIndex + 1)),
                     } });
             }
         });
     }
     maskWriteRegister(unit, address, andMask, orMask, timeout = this.timeout) {
-        const fc = 0x16;
+        const fc = exports.FunctionCode.MASK_WRITE_REGISTER;
         const bufferTx = Buffer.alloc(6);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(andMask, 2);
         bufferTx.writeUInt16BE(orMask, 4);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 6, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
-        }, timeout).then((frame) => {
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => 6, (frame) => frame.data.equals(bufferTx)], timeout, unit === 0).then((frame) => {
             if (frame) {
                 return Object.assign(Object.assign({}, frame), { data: { andMask, orMask } });
             }
         });
     }
     readAndWriteMultipleRegisters(unit, read, write, timeout = this.timeout) {
-        const fc = 0x17;
+        const fc = exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS;
         const byteCount = write.value.length * 2;
+        const readByteCount = read.length * 2;
         const bufferTx = Buffer.alloc(9 + byteCount);
         bufferTx.writeUInt16BE(read.address, 0);
         bufferTx.writeUInt16BE(read.length, 2);
@@ -1370,150 +2088,108 @@ class ModbusMaster extends EventEmitter {
         write.value.forEach((v, i) => {
             bufferTx.writeUInt16BE(v, 9 + i * 2);
         });
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
-        }, timeout).then((frame) => {
+        return this.send({ unit, fc, data: bufferTx }, [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + readByteCount, (frame) => frame.data[0] === readByteCount], timeout, unit === 0).then((frame) => {
             if (frame) {
-                const bufferRx = Buffer.from(frame.data.slice(1));
-                return Object.assign(Object.assign({}, frame), { data: Array.from({ length: read.length }).map((_, index) => bufferRx.readUInt16BE(index * 2)) });
+                const bufferRx = frame.data.subarray(1);
+                return Object.assign(Object.assign({}, frame), { data: Array.from({ length: read.length }, (_, index) => bufferRx.readUInt16BE(index * 2)) });
             }
         });
     }
     readDeviceIdentification(unit, readDeviceIDCode, objectId, timeout = this.timeout) {
-        const fc = 0x2b;
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: [0x0e, readDeviceIDCode, objectId],
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                (frame) => {
-                    if (frame.data.length >= 6) {
-                        if (frame.data[0] === 0x0e && frame.data[1] === readDeviceIDCode) {
-                            const objects = [];
-                            let object = [];
-                            for (const v of frame.data.slice(6)) {
-                                switch (object.length) {
-                                    case 0:
-                                    case 1: {
-                                        object.push(v);
-                                        break;
-                                    }
-                                    case 2: {
-                                        object.push([v]);
-                                        break;
-                                    }
-                                    case 3: {
-                                        object[2].push(v);
-                                        if (object[1] === object[2].length) {
-                                            objects.push(2 + object[1]);
-                                            object = [];
-                                        }
-                                        break;
+        const fc = exports.FunctionCode.READ_DEVICE_IDENTIFICATION;
+        let parsed;
+        return this.send({ unit, fc, data: Buffer.from([MEI_READ_DEVICE_ID, readDeviceIDCode, objectId]) }, [
+            (frame) => frame.unit === unit && frame.fc === fc,
+            (frame) => {
+                if (frame.data.length >= 6) {
+                    if (frame.data[0] === MEI_READ_DEVICE_ID && frame.data[1] === readDeviceIDCode) {
+                        const objects = [];
+                        let object = [];
+                        let totalBytes = 0;
+                        for (const v of frame.data.subarray(6)) {
+                            switch (object.length) {
+                                case 0:
+                                case 1: {
+                                    object.push(v);
+                                    break;
+                                }
+                                case 2: {
+                                    object.push([v]);
+                                    break;
+                                }
+                                case 3: {
+                                    object[2].push(v);
+                                    if (object[1] === object[2].length) {
+                                        objects.push({ id: object[0], value: Buffer.from(object[2]).toString() });
+                                        totalBytes += 2 + object[1];
+                                        object = [];
                                     }
+                                    break;
                                 }
                             }
-                            if (objects.length === frame.data[5]) {
-                                return 6 + objects.reduce((previous, current) => previous + current, 0);
-                            }
                         }
-                        else {
-                            return false;
+                        if (objects.length === frame.data[5]) {
+                            parsed = objects;
+                            return 6 + totalBytes;
                         }
                     }
-                },
-            ],
-        }, timeout).then((frame) => {
-            if (frame) {
-                const objects = [];
-                let object = [];
-                for (const v of frame.data.slice(6)) {
-                    switch (object.length) {
-                        case 0:
-                        case 1: {
-                            object.push(v);
-                            break;
-                        }
-                        case 2: {
-                            object.push([v]);
-                            break;
-                        }
-                        case 3: {
-                            object[2].push(v);
-                            if (object[1] === object[2].length) {
-                                objects.push({ id: object[0], value: Buffer.from(object[2]).toString() });
-                                object = [];
-                            }
-                            break;
-                        }
+                    else {
+                        return false;
                     }
                 }
+            },
+        ], timeout, unit === 0).then((frame) => {
+            if (frame && parsed) {
                 return Object.assign(Object.assign({}, frame), { data: {
                         readDeviceIDCode,
                         conformityLevel: frame.data[2],
                         moreFollows: frame.data[3] === 0xff,
                         nextObjectId: frame.data[4],
-                        objects,
+                        objects: parsed,
                     } });
             }
         });
     }
+    addCustomFunctionCode(cfc) {
+        this.applicationLayer.addCustomFunctionCode(cfc);
+    }
+    removeCustomFunctionCode(fc) {
+        this.applicationLayer.removeCustomFunctionCode(fc);
+    }
+    sendCustomFC(unit, fc, data, timeout = this.timeout) {
+        const payload = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        return this.send({ unit, fc, data: payload }, [(frame) => frame.unit === unit && frame.fc === fc], timeout, unit === 0).then((frame) => {
+            if (frame) {
+                return frame.data;
+            }
+        });
+    }
     open(...args) {
+        this._closed = false;
         return this.physicalLayer.open(...args);
     }
     close() {
+        this._closed = true;
+        const queued = this._queue.splice(0);
+        for (const item of queued) {
+            item.cancel(new ModbusError(ModbusErrorCode.MASTER_CLOSED, 'Master closed'));
+        }
+        this._masterSession.stopAll(new ModbusError(ModbusErrorCode.MASTER_CLOSED, 'Master closed'));
         return this.physicalLayer.close();
     }
     destroy() {
+        this._closed = true;
+        const queued = this._queue.splice(0);
+        for (const item of queued) {
+            item.cancel(new ModbusError(ModbusErrorCode.MASTER_DESTROYED, 'Master destroyed'));
+        }
+        this._masterSession.stopAll(new ModbusError(ModbusErrorCode.MASTER_DESTROYED, 'Master destroyed'));
         this.removeAllListeners();
         this.applicationLayer.destroy();
         return this.physicalLayer.destroy();
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 class ModbusSlave extends EventEmitter {
     get isOpen() {
         return this.physicalLayer.isOpen;
@@ -1521,7 +2197,8 @@ class ModbusSlave extends EventEmitter {
     get destroyed() {
         return this.physicalLayer.destroyed;
     }
-    constructor(applicationLayer, physicalLayer) {
+    constructor(applicationLayer, physicalLayer, options = {}) {
+        var _a;
         super();
         Object.defineProperty(this, "applicationLayer", {
             enumerable: true,
@@ -1541,444 +2218,493 @@ class ModbusSlave extends EventEmitter {
             writable: true,
             value: new Map()
         });
-        Object.defineProperty(this, "_processing", {
+        Object.defineProperty(this, "concurrent", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        Object.defineProperty(this, "_queue", {
+        Object.defineProperty(this, "_queues", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: new Map()
+        });
+        Object.defineProperty(this, "_customFunctionCodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "_locks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
         });
-        applicationLayer.on('framing', (frame, _response) => {
+        this.concurrent = (_a = options.concurrent) !== null && _a !== void 0 ? _a : false;
+        if (this.concurrent && this.applicationLayer.PROTOCOL !== 'TCP') {
+            throw new ModbusError(ModbusErrorCode.CONCURRENT_NOT_TCP, 'concurrent mode requires a Modbus TCP application layer');
+        }
+        this.applicationLayer.role = 'SLAVE';
+        applicationLayer.on('framing', (frame, response, connection) => {
             if (!(frame.unit === 0x00 || this.models.has(frame.unit))) {
                 return;
             }
-            this._queue.push({ frame, response: _response });
-            this._drain();
+            if (this.concurrent) {
+                this._processFrame(frame, response).catch((error) => this.emit('error', error));
+                return;
+            }
+            let q = this._queues.get(connection.id);
+            if (!q) {
+                q = { items: [], processing: false };
+                this._queues.set(connection.id, q);
+            }
+            q.items.push({ frame, response });
+            this._drain(connection.id, q);
         });
         physicalLayer.on('error', (error) => {
             this.emit('error', error);
         });
+        physicalLayer.on('connection-close', (connection) => {
+            const q = this._queues.get(connection.id);
+            if (!q) {
+                return;
+            }
+            q.items.length = 0;
+            if (!q.processing) {
+                this._queues.delete(connection.id);
+            }
+        });
         physicalLayer.on('close', () => {
+            for (const q of this._queues.values()) {
+                q.items.length = 0;
+            }
+            this._queues.clear();
             this.emit('close');
         });
     }
     handleFC1(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 4) {
-                if (model.readCoils) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const length = bufferRx.readUInt16BE(2);
-                    if (length >= 0x0001 && length <= 0x07d0) {
-                        if (checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).coils)) {
-                            try {
-                                const coils = yield Promise.resolve(model.readCoils(address, length));
-                                const bufferTx = Buffer.alloc(Math.ceil(length / 8));
-                                coils.forEach((coil, index) => {
-                                    if (coil) {
-                                        bufferTx[~~(index / 8)] |= 1 << index % 8;
-                                    }
-                                });
-                                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+            if (frame.data.length !== 4) {
+                return;
+            }
+            if (!model.readCoils) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const length = (frame.data[2] << 8) | frame.data[3];
+            if (length < LIMITS.READ_COILS_MIN || length > LIMITS.READ_COILS_MAX) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).coils)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            try {
+                const coils = yield model.readCoils(address, length);
+                const bufferTx = Buffer.alloc(Math.ceil(length / 8));
+                coils.forEach((coil, index) => {
+                    if (coil) {
+                        bufferTx[Math.floor(index / 8)] |= 1 << index % 8;
                     }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+                });
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([bufferTx.length]), bufferTx]) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC2(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 4) {
-                if (model.readDiscreteInputs) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const length = bufferRx.readUInt16BE(2);
-                    if (length >= 0x0001 && length <= 0x07d0) {
-                        if (checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).discreteInputs)) {
-                            try {
-                                const discreteInputs = yield Promise.resolve(model.readDiscreteInputs(address, length));
-                                const bufferTx = Buffer.alloc(Math.ceil(length / 8));
-                                discreteInputs.forEach((discreteInput, index) => {
-                                    if (discreteInput) {
-                                        bufferTx[~~(index / 8)] |= 1 << index % 8;
-                                    }
-                                });
-                                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+            if (frame.data.length !== 4) {
+                return;
+            }
+            if (!model.readDiscreteInputs) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const length = (frame.data[2] << 8) | frame.data[3];
+            if (length < LIMITS.READ_COILS_MIN || length > LIMITS.READ_COILS_MAX) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).discreteInputs)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            try {
+                const discreteInputs = yield model.readDiscreteInputs(address, length);
+                const bufferTx = Buffer.alloc(Math.ceil(length / 8));
+                discreteInputs.forEach((discreteInput, index) => {
+                    if (discreteInput) {
+                        bufferTx[Math.floor(index / 8)] |= 1 << index % 8;
                     }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+                });
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([bufferTx.length]), bufferTx]) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC3(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 4) {
-                if (model.readHoldingRegisters) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const length = bufferRx.readUInt16BE(2);
-                    if (length >= 0x0001 && length <= 0x007d) {
-                        if (checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
-                            try {
-                                const registers = yield Promise.resolve(model.readHoldingRegisters(address, length));
-                                const bufferTx = Buffer.alloc(length * 2);
-                                registers.forEach((register, index) => {
-                                    bufferTx.writeUInt16BE(register, index * 2);
-                                });
-                                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
-                    }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+            if (frame.data.length !== 4) {
+                return;
+            }
+            if (!model.readHoldingRegisters) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const length = (frame.data[2] << 8) | frame.data[3];
+            if (length < LIMITS.READ_REGISTERS_MIN || length > LIMITS.READ_REGISTERS_MAX) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            try {
+                const registers = yield model.readHoldingRegisters(address, length);
+                const bufferTx = Buffer.alloc(length * 2);
+                registers.forEach((register, index) => {
+                    bufferTx.writeUInt16BE(register, index * 2);
+                });
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([bufferTx.length]), bufferTx]) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC4(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 4) {
-                if (model.readInputRegisters) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const length = bufferRx.readUInt16BE(2);
-                    if (length >= 0x0001 && length <= 0x007d) {
-                        if (checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).inputRegisters)) {
-                            try {
-                                const registers = yield Promise.resolve(model.readInputRegisters(address, length));
-                                const bufferTx = Buffer.alloc(length * 2);
-                                registers.forEach((register, index) => {
-                                    bufferTx.writeUInt16BE(register, index * 2);
-                                });
-                                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
-                    }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+            if (frame.data.length !== 4) {
+                return;
+            }
+            if (!model.readInputRegisters) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const length = (frame.data[2] << 8) | frame.data[3];
+            if (length < LIMITS.READ_REGISTERS_MIN || length > LIMITS.READ_REGISTERS_MAX) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).inputRegisters)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            try {
+                const registers = yield model.readInputRegisters(address, length);
+                const bufferTx = Buffer.alloc(length * 2);
+                registers.forEach((register, index) => {
+                    bufferTx.writeUInt16BE(register, index * 2);
+                });
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([bufferTx.length]), bufferTx]) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC5(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 4) {
-                if (model.writeSingleCoil) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const value = bufferRx.readUInt16BE(2);
-                    if (value === 0x0000 || value === 0xff00) {
-                        if (checkRange(address, (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).coils)) {
-                            try {
-                                yield Promise.resolve(model.writeSingleCoil(address, value === 0xff00));
-                                yield response(this.applicationLayer.encode(frame));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
-                    }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+            if (frame.data.length !== 4) {
+                return;
+            }
+            if (!model.writeSingleCoil) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const value = (frame.data[2] << 8) | frame.data[3];
+            if (value !== COIL_OFF && value !== COIL_ON) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange(address, (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).coils)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            try {
+                yield model.writeSingleCoil(address, value === COIL_ON);
+                yield response(this.applicationLayer.encode(frame));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC6(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 4) {
-                if (model.writeSingleRegister) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const value = bufferRx.readUInt16BE(2);
-                    if (value >= 0x0000 && value <= 0xffff) {
-                        if (checkRange(address, (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
-                            try {
-                                yield Promise.resolve(model.writeSingleRegister(address, value));
-                                yield response(this.applicationLayer.encode(frame));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
-                    }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+            if (frame.data.length !== 4) {
+                return;
+            }
+            if (!model.writeSingleRegister) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const value = (frame.data[2] << 8) | frame.data[3];
+            if (!checkRange(address, (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            try {
+                yield model.writeSingleRegister(address, value);
+                yield response(this.applicationLayer.encode(frame));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC15(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length > 5 && frame.data.length === 5 + frame.data[4]) {
-                if (model.writeMultipleCoils || model.writeSingleCoil) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const length = bufferRx.readUInt16BE(2);
-                    const byteCount = bufferRx[4];
-                    if (length >= 0x0001 && length <= 0x07b0 && byteCount === Math.ceil(length / 8)) {
-                        if (checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).coils)) {
-                            const value = Array.from({ length }).map((_, index) => (bufferRx[5 + ~~(index / 8)] & (1 << index % 8)) > 0);
-                            try {
-                                yield Promise.resolve(model.writeMultipleCoils
-                                    ? model.writeMultipleCoils(address, value)
-                                    : Promise.all(value.map((v, i) => model.writeSingleCoil(address + i, v))));
-                                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Array.from(bufferRx).slice(0, 4) })));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
-                    }
+            if (frame.data.length <= 5 || frame.data.length !== 5 + frame.data[4]) {
+                return;
+            }
+            if (!model.writeMultipleCoils && !model.writeSingleCoil) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const length = (frame.data[2] << 8) | frame.data[3];
+            const byteCount = frame.data[4];
+            if (length < LIMITS.READ_COILS_MIN || length > LIMITS.WRITE_COILS_MAX || byteCount !== Math.ceil(length / 8)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).coils)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            const value = new Array(length);
+            for (let i = 0; i < length; i++) {
+                value[i] = (frame.data[5 + Math.floor(i / 8)] & (1 << i % 8)) > 0;
+            }
+            try {
+                if (model.writeMultipleCoils) {
+                    yield model.writeMultipleCoils(address, value);
                 }
                 else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                    for (let i = 0; i < value.length; i++) {
+                        yield model.writeSingleCoil(address + i, value[i]);
+                    }
                 }
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: frame.data.subarray(0, 4) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC16(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length > 5 && frame.data.length === 5 + frame.data[4]) {
-                if (model.writeMultipleRegisters || model.writeSingleRegister) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const length = bufferRx.readUInt16BE(2);
-                    const byteCount = bufferRx[4];
-                    if (length >= 0x0001 && length <= 0x007b && byteCount === length * 2) {
-                        if (checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
-                            const value = Array.from({ length }).map((_, index) => bufferRx.readUInt16BE(5 + index * 2));
-                            try {
-                                yield Promise.resolve(model.writeMultipleRegisters
-                                    ? model.writeMultipleRegisters(address, value)
-                                    : Promise.all(value.map((v, i) => model.writeSingleRegister(address + i, v))));
-                                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Array.from(bufferRx).slice(0, 4) })));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
-                    }
-                    else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
-                    }
+            if (frame.data.length <= 5 || frame.data.length !== 5 + frame.data[4]) {
+                return;
+            }
+            if (!model.writeMultipleRegisters && !model.writeSingleRegister) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const length = (frame.data[2] << 8) | frame.data[3];
+            const byteCount = frame.data[4];
+            if (length < LIMITS.READ_REGISTERS_MIN || length > LIMITS.WRITE_REGISTERS_MAX || byteCount !== length * 2) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange([address, address + length], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            const value = new Array(length);
+            for (let i = 0; i < length; i++) {
+                value[i] = (frame.data[5 + i * 2] << 8) | frame.data[6 + i * 2];
+            }
+            try {
+                if (model.writeMultipleRegisters) {
+                    yield model.writeMultipleRegisters(address, value);
                 }
                 else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                    for (let i = 0; i < value.length; i++) {
+                        yield model.writeSingleRegister(address + i, value[i]);
+                    }
                 }
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: frame.data.subarray(0, 4) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC17(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 0) {
-                if (model.reportServerId) {
-                    try {
-                        const { serverId = (_a = model.unit) !== null && _a !== void 0 ? _a : 1, runIndicatorStatus = true, additionalData = [] } = yield Promise.resolve(model.reportServerId());
-                        yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [2 + additionalData.length, serverId, runIndicatorStatus ? 0xff : 0x00].concat(additionalData) })));
-                    }
-                    catch (error) {
-                        yield this.responseError(frame, response, error);
-                    }
+            if (frame.data.length !== 0) {
+                return;
+            }
+            if (!model.reportServerId) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            try {
+                const { serverId = (_a = model.unit) !== null && _a !== void 0 ? _a : 1, runIndicatorStatus = true, additionalData = [] } = yield model.reportServerId();
+                const serverIdBytes = Array.isArray(serverId) ? serverId : [serverId];
+                const byteCount = serverIdBytes.length + 1 + additionalData.length;
+                if (byteCount > 255) {
+                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.SERVER_DEVICE_FAILURE));
+                    return;
                 }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                const allBytes = [...serverIdBytes, runIndicatorStatus ? 0xff : 0x00, ...additionalData];
+                if (allBytes.some((b) => !isUint8(b))) {
+                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.SERVER_DEVICE_FAILURE));
+                    return;
                 }
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([byteCount]), Buffer.from(allBytes)]) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC22(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length === 6) {
-                if (model.maskWriteRegister || (model.readHoldingRegisters && model.writeSingleRegister)) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = bufferRx.readUInt16BE(0);
-                    const andMask = bufferRx.readUInt16BE(2);
-                    const orMask = bufferRx.readUInt16BE(4);
-                    if (checkRange(address, (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
-                        try {
-                            yield Promise.resolve(model.maskWriteRegister
-                                ? model.maskWriteRegister(address, andMask, orMask)
-                                : Promise.resolve(model.readHoldingRegisters(address, 1)).then(([value]) => {
-                                    return Promise.resolve(model.writeSingleRegister(address, (value & andMask) | (orMask & (~andMask & 0xff))));
-                                }));
-                            yield response(this.applicationLayer.encode(frame));
-                        }
-                        catch (error) {
-                            yield this.responseError(frame, response, error);
-                        }
+            if (frame.data.length !== 6) {
+                return;
+            }
+            if (!model.maskWriteRegister && !(model.readHoldingRegisters && model.writeSingleRegister)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = (frame.data[0] << 8) | frame.data[1];
+            const andMask = (frame.data[2] << 8) | frame.data[3];
+            const orMask = (frame.data[4] << 8) | frame.data[5];
+            if (!checkRange(address, (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            try {
+                yield this.withAddressLock([address], () => __awaiter(this, void 0, void 0, function* () {
+                    if (model.maskWriteRegister) {
+                        yield model.maskWriteRegister(address, andMask, orMask);
                     }
                     else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                        const [value] = yield model.readHoldingRegisters(address, 1);
+                        yield model.writeSingleRegister(address, (value & andMask) | (orMask & (~andMask & 0xffff)));
                     }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+                }));
+                yield response(this.applicationLayer.encode(frame));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC23(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (frame.data.length > 9 && frame.data.length === 9 + frame.data[8]) {
-                if (model.readHoldingRegisters && (model.writeMultipleRegisters || model.writeSingleRegister)) {
-                    const bufferRx = Buffer.from(frame.data);
-                    const address = {
-                        read: bufferRx.readUInt16BE(0),
-                        write: bufferRx.readUInt16BE(4),
-                    };
-                    const length = {
-                        read: bufferRx.readUInt16BE(2),
-                        write: bufferRx.readUInt16BE(6),
-                    };
-                    const byteCount = bufferRx[8];
-                    if (length.read >= 0x0001 &&
-                        length.read <= 0x007d &&
-                        length.write >= 0x0001 &&
-                        length.write <= 0x0079 &&
-                        byteCount === length.write * 2) {
-                        if (checkRange([address.read, address.read + length.read, address.write, address.write + length.write], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
-                            const value = Array.from({ length: length.write }).map((_, index) => bufferRx.readUInt16BE(9 + index * 2));
-                            try {
-                                yield Promise.resolve(model.writeMultipleRegisters
-                                    ? model.writeMultipleRegisters(address.write, value)
-                                    : Promise.all(value.map((v, i) => model.writeSingleRegister(address.write + i, v))));
-                                const registers = yield Promise.resolve(model.readHoldingRegisters(address.read, length.read));
-                                const bufferTx = Buffer.alloc(length.read * 2);
-                                registers.forEach((register, index) => {
-                                    bufferTx.writeUInt16BE(register, index * 2);
-                                });
-                                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                            }
-                            catch (error) {
-                                yield this.responseError(frame, response, error);
-                            }
-                        }
-                        else {
-                            yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
-                        }
+            if (frame.data.length <= 9 || frame.data.length !== 9 + frame.data[8]) {
+                return;
+            }
+            if (!model.readHoldingRegisters || (!model.writeMultipleRegisters && !model.writeSingleRegister)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                return;
+            }
+            const address = {
+                read: (frame.data[0] << 8) | frame.data[1],
+                write: (frame.data[4] << 8) | frame.data[5],
+            };
+            const length = {
+                read: (frame.data[2] << 8) | frame.data[3],
+                write: (frame.data[6] << 8) | frame.data[7],
+            };
+            const byteCount = frame.data[8];
+            if (length.read < LIMITS.READ_REGISTERS_MIN ||
+                length.read > LIMITS.READ_REGISTERS_MAX ||
+                length.write < LIMITS.READ_REGISTERS_MIN ||
+                length.write > LIMITS.RW_REGISTERS_WRITE_MAX ||
+                byteCount !== length.write * 2) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                return;
+            }
+            if (!checkRange([address.read, address.read + length.read, address.write, address.write + length.write], (_a = model.getAddressRange) === null || _a === void 0 ? void 0 : _a.call(model).holdingRegisters)) {
+                yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
+                return;
+            }
+            const value = new Array(length.write);
+            for (let i = 0; i < length.write; i++) {
+                value[i] = (frame.data[9 + i * 2] << 8) | frame.data[10 + i * 2];
+            }
+            try {
+                const writeAddresses = Array.from({ length: length.write }, (_, i) => address.write + i);
+                yield this.withAddressLock(writeAddresses, () => __awaiter(this, void 0, void 0, function* () {
+                    if (model.writeMultipleRegisters) {
+                        yield model.writeMultipleRegisters(address.write, value);
                     }
                     else {
-                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_VALUE));
+                        for (let i = 0; i < value.length; i++) {
+                            yield model.writeSingleRegister(address.write + i, value[i]);
+                        }
                     }
-                }
-                else {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
-                }
+                }));
+                const registers = yield model.readHoldingRegisters(address.read, length.read);
+                const bufferTx = Buffer.alloc(length.read * 2);
+                registers.forEach((register, index) => {
+                    bufferTx.writeUInt16BE(register, index * 2);
+                });
+                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([bufferTx.length]), bufferTx]) })));
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
             }
         });
     }
     handleFC43_14(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             if (frame.data.length === 3) {
-                if (frame.data[0] === 0x0e && model.readDeviceIdentification) {
+                if (frame.data[0] === MEI_READ_DEVICE_ID && model.readDeviceIdentification) {
                     const readDeviceIDCode = frame.data[1];
                     let objectID = frame.data[2];
                     switch (readDeviceIDCode) {
-                        case 0x01: {
+                        case exports.ReadDeviceIDCode.BASIC_STREAM: {
                             if (objectID > 0x02 || (objectID > 0x06 && objectID < 0x80)) {
                                 objectID = 0x00;
                             }
                             break;
                         }
-                        case 0x02: {
+                        case exports.ReadDeviceIDCode.REGULAR_STREAM: {
                             if (objectID >= 0x80 || (objectID > 0x06 && objectID < 0x80)) {
                                 objectID = 0x00;
                             }
                             break;
                         }
-                        case 0x03: {
+                        case exports.ReadDeviceIDCode.EXTENDED_STREAM: {
                             if (objectID > 0x06 && objectID < 0x80) {
                                 objectID = 0x00;
                             }
                             break;
                         }
-                        case 0x04: {
+                        case exports.ReadDeviceIDCode.SPECIFIC_ACCESS: {
                             if (objectID > 0x06 && objectID < 0x80) {
                                 yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
                                 return;
@@ -1991,70 +2717,74 @@ class ModbusSlave extends EventEmitter {
                         }
                     }
                     try {
-                        const identification = yield Promise.resolve(model.readDeviceIdentification());
-                        const objects = new Map([
-                            [0x00, 'null'],
-                            [0x01, 'null'],
-                            [0x02, 'null'],
-                        ]);
-                        for (const [key, value] of Object.entries(identification)) {
-                            const id = parseInt(key);
-                            if (!isNaN(id) && id >= 0 && id <= 255) {
-                                objects.set(id, value);
+                        const identification = yield model.readDeviceIdentification();
+                        const objects = new Map();
+                        for (const key of Object.keys(identification)) {
+                            const id = Number(key);
+                            if (id >= 0 && id <= 255) {
+                                objects.set(id, identification[id]);
+                            }
+                        }
+                        for (let id = 0x00; id <= 0x02; id++) {
+                            if (!objects.has(id)) {
+                                objects.set(id, 'null');
                             }
                         }
                         if (!objects.has(objectID)) {
-                            if (readDeviceIDCode === 0x04) {
+                            if (readDeviceIDCode === exports.ReadDeviceIDCode.SPECIFIC_ACCESS) {
                                 yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_DATA_ADDRESS));
                                 return;
                             }
                             objectID = 0x00;
                         }
-                        const ids = [];
-                        let totalLength = 10;
-                        let lastID = 0;
-                        let conformityLevel = 0x81;
-                        for (const [id, value] of objects.entries()) {
-                            if (id < 0x00 || (id >= 0x07 && id <= 0x7f) || id > 0xff) {
+                        let maxId = 0;
+                        for (const id of objects.keys()) {
+                            if ((id >= 0x07 && id <= 0x7f) || id > 0xff) {
                                 yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.SERVER_DEVICE_FAILURE));
                                 return;
                             }
-                            if (id > 0x02) {
-                                conformityLevel = 0x82;
-                            }
-                            if (id > 0x80) {
-                                conformityLevel = 0x83;
+                            if (id > maxId) {
+                                maxId = id;
                             }
+                        }
+                        const conformityLevel = maxId >= 0x80 ? exports.ConformityLevel.EXTENDED : maxId > 0x02 ? exports.ConformityLevel.REGULAR : exports.ConformityLevel.BASIC;
+                        const ids = [];
+                        let totalLength = 10;
+                        let lastID = 0;
+                        for (const [id, value] of objects.entries()) {
                             if (objectID > id) {
                                 continue;
                             }
-                            if (value.length > 245) {
+                            const byteLength = Buffer.byteLength(value);
+                            if (byteLength > 245) {
                                 yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.SERVER_DEVICE_FAILURE));
                                 return;
                             }
                             if (lastID !== 0) {
                                 continue;
                             }
-                            if (value.length + 2 > 253 - totalLength) {
+                            if (byteLength + 2 > 253 - totalLength) {
                                 if (lastID === 0) {
                                     lastID = id;
                                 }
                             }
                             else {
-                                totalLength += value.length + 2;
+                                totalLength += byteLength + 2;
                                 ids.push(id);
-                                if (readDeviceIDCode === 0x04) {
+                                if (readDeviceIDCode === exports.ReadDeviceIDCode.SPECIFIC_ACCESS) {
                                     break;
                                 }
                             }
                         }
                         ids.sort((a, b) => a - b);
-                        yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [0x0e, readDeviceIDCode, conformityLevel, lastID === 0 ? 0x00 : 0xff, lastID, ids.length].concat(ids
-                                .map((id) => {
-                                const value = objects.get(id);
-                                return [id, value.length].concat(Array.from(Buffer.from(value)));
-                            })
-                                .flat()) })));
+                        const parts = [];
+                        parts.push(Buffer.from([MEI_READ_DEVICE_ID, readDeviceIDCode, conformityLevel, lastID === 0 ? 0x00 : 0xff, lastID, ids.length]));
+                        for (const id of ids) {
+                            const value = objects.get(id);
+                            parts.push(Buffer.from([id, Buffer.byteLength(value)]));
+                            parts.push(Buffer.from(value));
+                        }
+                        yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat(parts) })));
                     }
                     catch (error) {
                         yield this.responseError(frame, response, error);
@@ -2068,26 +2798,32 @@ class ModbusSlave extends EventEmitter {
     }
     responseError(frame, response, error) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { fc: frame.fc | 0x80, data: [getCodeByError(error)] })));
+            yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { fc: frame.fc | EXCEPTION_OFFSET, data: Buffer.from([getCodeByError(error)]) })));
         });
     }
-    _drain() {
+    _drain(key, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._processing || this._queue.length === 0) {
+            if (q.processing) {
                 return;
             }
-            this._processing = true;
-            const { frame, response: _response } = this._queue.shift();
+            q.processing = true;
             try {
-                yield this._processFrame(frame, _response);
-            }
-            catch (error) {
-                this.emit('error', error);
+                while (q.items.length > 0) {
+                    const { frame, response } = q.items.shift();
+                    try {
+                        yield this._processFrame(frame, response);
+                    }
+                    catch (error) {
+                        this.emit('error', error);
+                    }
+                }
             }
             finally {
-                this._processing = false;
-                if (this._queue.length > 0) {
-                    setImmediate(() => this._drain());
+                q.processing = false;
+                // Cleanup empty queue entries so the map doesn't grow unbounded across
+                // ephemeral connections (UDP rinfo, brief TCP clients).
+                if (q.items.length === 0 && this._queues.get(key) === q) {
+                    this._queues.delete(key);
                 }
             }
         });
@@ -2104,8 +2840,8 @@ class ModbusSlave extends EventEmitter {
                 catch (error) { }
             });
             for (const model of frame.unit === 0x00 ? this.models.values() : [this.models.get(frame.unit)]) {
-                const res = yield this._intercept(model, frame, response);
-                if (res !== 'break') {
+                const intercepted = yield this._intercept(model, frame, response);
+                if (!intercepted) {
                     yield this._handleFC(model, frame, response);
                 }
             }
@@ -2113,17 +2849,42 @@ class ModbusSlave extends EventEmitter {
     }
     _intercept(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (model.interceptor) {
-                try {
-                    const data = yield model.interceptor(frame.fc, frame.data);
-                    if (data) {
-                        yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data })));
-                        return 'break';
-                    }
+            if (!model.interceptor) {
+                return false;
+            }
+            try {
+                const data = yield model.interceptor(frame.fc, frame.data);
+                if (data !== undefined) {
+                    yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data })));
+                    return true;
                 }
-                catch (error) {
-                    yield this.responseError(frame, response, error);
-                    return 'break';
+                return false;
+            }
+            catch (error) {
+                yield this.responseError(frame, response, error);
+                return true;
+            }
+        });
+    }
+    withAddressLock(addresses, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sorted = [...new Set(addresses)].sort((a, b) => a - b);
+            const previous = sorted.map((addr) => { var _a; return (_a = this._locks.get(addr)) !== null && _a !== void 0 ? _a : Promise.resolve(); });
+            const work = Promise.all(previous).then(() => fn());
+            const cleanup = work.catch(() => {
+                /* ignore */
+            });
+            for (const addr of sorted) {
+                this._locks.set(addr, cleanup);
+            }
+            try {
+                return yield work;
+            }
+            finally {
+                for (const addr of sorted) {
+                    if (this._locks.get(addr) === cleanup) {
+                        this._locks.delete(addr);
+                    }
                 }
             }
         });
@@ -2131,56 +2892,68 @@ class ModbusSlave extends EventEmitter {
     _handleFC(model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             switch (frame.fc) {
-                case 0x01: {
+                case exports.FunctionCode.READ_COILS: {
                     yield this.handleFC1(model, frame, response);
                     break;
                 }
-                case 0x02: {
+                case exports.FunctionCode.READ_DISCRETE_INPUTS: {
                     yield this.handleFC2(model, frame, response);
                     break;
                 }
-                case 0x03: {
+                case exports.FunctionCode.READ_HOLDING_REGISTERS: {
                     yield this.handleFC3(model, frame, response);
                     break;
                 }
-                case 0x04: {
+                case exports.FunctionCode.READ_INPUT_REGISTERS: {
                     yield this.handleFC4(model, frame, response);
                     break;
                 }
-                case 0x05: {
+                case exports.FunctionCode.WRITE_SINGLE_COIL: {
                     yield this.handleFC5(model, frame, response);
                     break;
                 }
-                case 0x06: {
+                case exports.FunctionCode.WRITE_SINGLE_REGISTER: {
                     yield this.handleFC6(model, frame, response);
                     break;
                 }
-                case 0x0f: {
+                case exports.FunctionCode.WRITE_MULTIPLE_COILS: {
                     yield this.handleFC15(model, frame, response);
                     break;
                 }
-                case 0x10: {
+                case exports.FunctionCode.WRITE_MULTIPLE_REGISTERS: {
                     yield this.handleFC16(model, frame, response);
                     break;
                 }
-                case 0x11: {
+                case exports.FunctionCode.REPORT_SERVER_ID: {
                     yield this.handleFC17(model, frame, response);
                     break;
                 }
-                case 0x16: {
+                case exports.FunctionCode.MASK_WRITE_REGISTER: {
                     yield this.handleFC22(model, frame, response);
                     break;
                 }
-                case 0x17: {
+                case exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS: {
                     yield this.handleFC23(model, frame, response);
                     break;
                 }
-                case 0x2b: {
+                case exports.FunctionCode.READ_DEVICE_IDENTIFICATION: {
                     yield this.handleFC43_14(model, frame, response);
                     break;
                 }
                 default: {
-                    yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                    const cfc = this._customFunctionCodes.get(frame.fc);
+                    if (cfc === null || cfc === void 0 ? void 0 : cfc.handle) {
+                        try {
+                            const responseData = yield cfc.handle(frame.data, frame.unit);
+                            yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: responseData })));
+                        }
+                        catch (error) {
+                            yield this.responseError(frame, response, error);
+                        }
+                    }
+                    else {
+                        yield this.responseError(frame, response, getErrorByCode(exports.ErrorCode.ILLEGAL_FUNCTION));
+                    }
                     break;
                 }
             }
@@ -2193,6 +2966,14 @@ class ModbusSlave extends EventEmitter {
     remove(unit) {
         this.models.delete(unit);
     }
+    addCustomFunctionCode(cfc) {
+        this._customFunctionCodes.set(cfc.fc, cfc);
+        this.applicationLayer.addCustomFunctionCode(cfc);
+    }
+    removeCustomFunctionCode(fc) {
+        this._customFunctionCodes.delete(fc);
+        this.applicationLayer.removeCustomFunctionCode(fc);
+    }
     open(...args) {
         return this.physicalLayer.open(...args);
     }
@@ -2200,6 +2981,7 @@ class ModbusSlave extends EventEmitter {
         return this.physicalLayer.close();
     }
     destroy() {
+        this._locks.clear();
         this.removeAllListeners();
         this.applicationLayer.destroy();
         return this.physicalLayer.destroy();
@@ -2209,6 +2991,14 @@ class ModbusSlave extends EventEmitter {
 exports.AbstractApplicationLayer = AbstractApplicationLayer;
 exports.AbstractPhysicalLayer = AbstractPhysicalLayer;
 exports.AsciiApplicationLayer = AsciiApplicationLayer;
+exports.COIL_OFF = COIL_OFF;
+exports.COIL_ON = COIL_ON;
+exports.EXCEPTION_OFFSET = EXCEPTION_OFFSET;
+exports.LIMITS = LIMITS;
+exports.MEI_READ_DEVICE_ID = MEI_READ_DEVICE_ID;
+exports.MasterSession = MasterSession;
+exports.ModbusError = ModbusError;
+exports.ModbusErrorCode = ModbusErrorCode;
 exports.ModbusMaster = ModbusMaster;
 exports.ModbusSlave = ModbusSlave;
 exports.RtuApplicationLayer = RtuApplicationLayer;