njs-modbus 2.1.0 → 3.0.2

package/dist/index.mjs

@@ -1,6 +1,5 @@
 import EventEmitter from 'node:events';
 import { SerialPort } from 'serialport';
-import { randomUUID } from 'node:crypto';
 import { Socket, createServer } from 'node:net';
 import { createSocket } from 'node:dgram';
 
@@ -16,32 +15,20 @@ var ErrorCode;
     ErrorCode[ErrorCode["GATEWAY_PATH_UNAVAILABLE"] = 10] = "GATEWAY_PATH_UNAVAILABLE";
     ErrorCode[ErrorCode["GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND"] = 11] = "GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND";
 })(ErrorCode || (ErrorCode = {}));
-/** 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 ERROR_MESSAGES = {
+    [ErrorCode.ILLEGAL_FUNCTION]: 'Illegal function',
+    [ErrorCode.ILLEGAL_DATA_ADDRESS]: 'Illegal data address',
+    [ErrorCode.ILLEGAL_DATA_VALUE]: 'Illegal data value',
+    [ErrorCode.SERVER_DEVICE_FAILURE]: 'Server device failure',
+    [ErrorCode.ACKNOWLEDGE]: 'Acknowledge',
+    [ErrorCode.SERVER_DEVICE_BUSY]: 'Server device busy',
+    [ErrorCode.MEMORY_PARITY_ERROR]: 'Memory parity error',
+    [ErrorCode.GATEWAY_PATH_UNAVAILABLE]: 'Gateway path unavailable',
+    [ErrorCode.GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND]: 'Gateway target device failed to respond',
 };
-const MODBUS_PREFIX = 'MODBUS_ERROR_CODE_';
 class ModbusError extends Error {
-    constructor(code, message) {
-        super(message !== null && message !== void 0 ? message : code);
+    constructor(code, message = ERROR_MESSAGES[code]) {
+        super(message);
         Object.defineProperty(this, "code", {
             enumerable: true,
             configurable: true,
@@ -52,18 +39,15 @@ class ModbusError extends Error {
     }
 }
 function getErrorByCode(code) {
-    return new ModbusError(String(code), `${MODBUS_PREFIX}${code}`);
+    return new ModbusError(code);
 }
 function getCodeByError(err) {
-    if (err instanceof ModbusError) {
-        const num = Number(err.code);
-        if (!Number.isNaN(num) && num in ErrorCode) {
-            return num;
+    if (err.name === 'ModbusError' && 'code' in err) {
+        const code = err.code;
+        if (code in ErrorCode) {
+            return code;
         }
     }
-    if (err.message.startsWith(MODBUS_PREFIX)) {
-        return Number(err.message.slice(MODBUS_PREFIX.length));
-    }
     return ErrorCode.SERVER_DEVICE_FAILURE;
 }
 
@@ -118,23 +102,584 @@ const LIMITS = {
     RW_REGISTERS_WRITE_MAX: 0x0079,
 };
 
+/**
+ * A one-way data transmission channel.
+ *
+ * State transitions are unidirectional: CONNECTED → DESTROYING → DESTROYED.
+ * Once closed, the instance cannot be reused; create a new connection instead.
+ */
+class AbstractPhysicalConnection extends EventEmitter {
+}
+/**
+ * An abstraction over local hardware or network resources.
+ *
+ * `open()` acquires the resource (serial port, TCP socket, UDP socket, etc.).
+ * Once ready, it emits `connect` with an {@link AbstractPhysicalConnection},
+ * unifying serial, TCP client, TCP server, and UDP under a single
+ * "connection-oriented" model similar to a TCP server accepting sockets.
+ */
 class AbstractPhysicalLayer extends EventEmitter {
+    is(type) {
+        return this.TYPE === type;
+    }
+}
+
+var PhysicalState;
+(function (PhysicalState) {
+    PhysicalState["OPENING"] = "opening";
+    PhysicalState["OPEN"] = "open";
+    PhysicalState["CLOSING"] = "closing";
+    PhysicalState["CLOSED"] = "closed";
+})(PhysicalState || (PhysicalState = {}));
+var PhysicalConnectionState;
+(function (PhysicalConnectionState) {
+    PhysicalConnectionState["CONNECTED"] = "connected";
+    PhysicalConnectionState["DESTROYING"] = "destroying";
+    PhysicalConnectionState["DESTROYED"] = "destroyed";
+})(PhysicalConnectionState || (PhysicalConnectionState = {}));
+
+class SerialPhysicalConnection extends AbstractPhysicalConnection {
+    get state() {
+        return this._state;
+    }
+    get physicalLayer() {
+        return this._physicalLayer;
+    }
+    constructor(physicalLayer, serialport) {
+        super();
+        Object.defineProperty(this, "_state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: PhysicalConnectionState.CONNECTED
+        });
+        Object.defineProperty(this, "_physicalLayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_serialport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_destroyPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_resolveDestroy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this._physicalLayer = physicalLayer;
+        this._serialport = serialport;
+        const onData = (chunk) => {
+            if (this.state !== PhysicalConnectionState.CONNECTED) {
+                return;
+            }
+            this.emit('data', chunk);
+        };
+        serialport.on('data', onData);
+        this._cleanupFns.add(() => serialport.off('data', onData));
+        const onSerialError = (err) => {
+            this.physicalLayer.emit('error', err);
+        };
+        serialport.on('error', onSerialError);
+        this._cleanupFns.add(() => serialport.off('error', onSerialError));
+        const cleanupClose = () => serialport.off('close', onClose);
+        const onClose = () => {
+            var _a;
+            this._cleanupFns.delete(cleanupClose);
+            this._state = PhysicalConnectionState.DESTROYED;
+            this._destroyPromise = null;
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
+            this.emit('close');
+            (_a = this._resolveDestroy) === null || _a === void 0 ? void 0 : _a.call(this);
+            this._resolveDestroy = null;
+        };
+        serialport.once('close', onClose);
+        this._cleanupFns.add(cleanupClose);
+    }
+    write(data) {
+        return new Promise((resolve, reject) => {
+            if (this.state === PhysicalConnectionState.CONNECTED) {
+                this._serialport.write(data, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            else {
+                reject(new Error('Connection is not connected'));
+            }
+        });
+    }
+    destroy() {
+        if (this.state === PhysicalConnectionState.DESTROYED) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalConnectionState.DESTROYING) {
+            return this._destroyPromise;
+        }
+        this._state = PhysicalConnectionState.DESTROYING;
+        this._destroyPromise = new Promise((resolve, reject) => {
+            this._resolveDestroy = resolve;
+            this._serialport.close((err) => {
+                if (err) {
+                    // Design choice: serialport.close() only rejects in extreme hardware
+                    // deadlock scenarios (e.g., stuck USB-to-serial adapter). At that
+                    // point the device is unrecoverable from software; propagating the
+                    // error is the best we can do.
+                    this._destroyPromise = null;
+                    this._resolveDestroy = null;
+                    reject(err);
+                }
+            });
+        });
+        return this._destroyPromise;
+    }
+}
+class SerialPhysicalLayer extends AbstractPhysicalLayer {
+    get state() {
+        return this._state;
+    }
+    get serialport() {
+        return this._serialport;
+    }
+    get path() {
+        return this._path;
+    }
+    get baudRate() {
+        return this._baudRate;
+    }
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "TYPE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'SERIAL'
+        });
+        Object.defineProperty(this, "_state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: PhysicalState.CLOSED
+        });
+        Object.defineProperty(this, "_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "_serialport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_serialportOpts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_baudRate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_openPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_closePromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_resolveClose", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this._serialportOpts = options;
+        this._path = options.path;
+        this._baudRate = options.baudRate;
+    }
+    open() {
+        if (this.state === PhysicalState.OPEN) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalState.OPENING) {
+            return this._openPromise;
+        }
+        if (this.state === PhysicalState.CLOSING) {
+            return Promise.reject(new Error('Port is closing'));
+        }
+        this._state = PhysicalState.OPENING;
+        this._openPromise = new Promise((resolve, reject) => {
+            const serialport = new SerialPort(Object.assign(Object.assign({}, this._serialportOpts), { autoOpen: false }));
+            this._serialport = serialport;
+            serialport.open((err) => {
+                if (err) {
+                    this._state = PhysicalState.CLOSED;
+                    this._openPromise = null;
+                    this._serialport = null;
+                    reject(err);
+                }
+                else {
+                    this._state = PhysicalState.OPEN;
+                    this._openPromise = null;
+                    this.emit('open');
+                    resolve();
+                    const connection = new SerialPhysicalConnection(this, serialport);
+                    this._connections.add(connection);
+                    const cleanupConnectionClose = () => connection.off('close', onConnectionClose);
+                    const onConnectionClose = () => {
+                        var _a;
+                        this._cleanupFns.delete(cleanupConnectionClose);
+                        this._connections.delete(connection);
+                        this._state = PhysicalState.CLOSED;
+                        this._closePromise = null;
+                        for (const fn of this._cleanupFns) {
+                            fn();
+                        }
+                        this._cleanupFns.clear();
+                        this._serialport = null;
+                        this.emit('close');
+                        (_a = this._resolveClose) === null || _a === void 0 ? void 0 : _a.call(this);
+                        this._resolveClose = null;
+                    };
+                    connection.once('close', onConnectionClose);
+                    this._cleanupFns.add(cleanupConnectionClose);
+                    this.emit('connect', connection);
+                }
+            });
+        });
+        return this._openPromise;
+    }
+    close() {
+        if (this.state === PhysicalState.CLOSED) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalState.CLOSING) {
+            return this._closePromise;
+        }
+        if (this.state === PhysicalState.OPENING) {
+            return Promise.reject(new Error('Port is opening'));
+        }
+        this._state = PhysicalState.CLOSING;
+        this._closePromise = new Promise((resolve, reject) => {
+            this._resolveClose = resolve;
+            Promise.all(Array.from(this._connections).map((connection) => connection.destroy())).catch((err) => {
+                this._resolveClose = null;
+                reject(err);
+            });
+        });
+        return this._closePromise;
+    }
+}
+
+class TcpPhysicalConnection extends AbstractPhysicalConnection {
+    get state() {
+        return this._state;
+    }
+    get physicalLayer() {
+        return this._physicalLayer;
+    }
+    constructor(physicalLayer, socket) {
+        super();
+        Object.defineProperty(this, "_state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: PhysicalConnectionState.CONNECTED
+        });
+        Object.defineProperty(this, "_physicalLayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_socket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_destroyPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_resolveDestroy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this._physicalLayer = physicalLayer;
+        this._socket = socket;
+        const onData = (chunk) => {
+            if (this.state !== PhysicalConnectionState.CONNECTED) {
+                return;
+            }
+            this.emit('data', chunk);
+        };
+        socket.on('data', onData);
+        this._cleanupFns.add(() => socket.off('data', onData));
+        const onSocketError = (err) => {
+            this.physicalLayer.emit('error', err);
+        };
+        socket.on('error', onSocketError);
+        this._cleanupFns.add(() => socket.off('error', onSocketError));
+        const cleanupClose = () => socket.off('close', onClose);
+        const onClose = () => {
+            var _a;
+            this._cleanupFns.delete(cleanupClose);
+            this._state = PhysicalConnectionState.DESTROYED;
+            this._destroyPromise = null;
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
+            this.emit('close');
+            (_a = this._resolveDestroy) === null || _a === void 0 ? void 0 : _a.call(this);
+            this._resolveDestroy = null;
+        };
+        socket.once('close', onClose);
+        this._cleanupFns.add(cleanupClose);
+    }
+    write(data) {
+        return new Promise((resolve, reject) => {
+            if (this.state === PhysicalConnectionState.CONNECTED) {
+                this._socket.write(data, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            else {
+                reject(new Error('Connection is not connected'));
+            }
+        });
+    }
+    destroy() {
+        if (this.state === PhysicalConnectionState.DESTROYED) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalConnectionState.DESTROYING) {
+            return this._destroyPromise;
+        }
+        this._state = PhysicalConnectionState.DESTROYING;
+        this._destroyPromise = new Promise((resolve) => {
+            this._resolveDestroy = resolve;
+            this._socket.destroy();
+        });
+        return this._destroyPromise;
+    }
+}
+
+class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
+    get state() {
+        return this._state;
+    }
+    get socket() {
+        return this._socket;
+    }
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "TYPE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'TCP_CLIENT'
+        });
+        Object.defineProperty(this, "_state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: PhysicalState.CLOSED
+        });
+        Object.defineProperty(this, "_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "_socket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_socketOpts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_openPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_closePromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_resolveClose", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this._socketOpts = options;
+    }
+    open(options) {
+        if (this.state === PhysicalState.OPEN) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalState.OPENING) {
+            return this._openPromise;
+        }
+        if (this.state === PhysicalState.CLOSING) {
+            return Promise.reject(new Error('Port is closing'));
+        }
+        this._state = PhysicalState.OPENING;
+        this._openPromise = new Promise((resolve, reject) => {
+            const socket = new Socket(this._socketOpts);
+            this._socket = socket;
+            const onConnect = () => {
+                socket.off('error', onError);
+                this._state = PhysicalState.OPEN;
+                this._openPromise = null;
+                this.emit('open');
+                resolve();
+                const connection = new TcpPhysicalConnection(this, socket);
+                this._connections.add(connection);
+                const cleanupConnectionClose = () => connection.off('close', onConnectionClose);
+                const onConnectionClose = () => {
+                    var _a;
+                    this._cleanupFns.delete(cleanupConnectionClose);
+                    this._connections.delete(connection);
+                    this._state = PhysicalState.CLOSED;
+                    this._closePromise = null;
+                    for (const fn of this._cleanupFns) {
+                        fn();
+                    }
+                    this._cleanupFns.clear();
+                    this._socket = null;
+                    this.emit('close');
+                    (_a = this._resolveClose) === null || _a === void 0 ? void 0 : _a.call(this);
+                    this._resolveClose = null;
+                };
+                connection.once('close', onConnectionClose);
+                this._cleanupFns.add(cleanupConnectionClose);
+                this.emit('connect', connection);
+            };
+            const onError = (err) => {
+                socket.off('connect', onConnect);
+                this._state = PhysicalState.CLOSED;
+                this._openPromise = null;
+                this._socket = null;
+                reject(err);
+            };
+            socket.once('connect', onConnect);
+            socket.once('error', onError);
+            socket.connect(options !== null && options !== void 0 ? options : { port: 502 });
+        });
+        return this._openPromise;
+    }
+    close() {
+        if (this.state === PhysicalState.CLOSED) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalState.CLOSING) {
+            return this._closePromise;
+        }
+        if (this.state === PhysicalState.OPENING) {
+            return Promise.reject(new Error('Port is opening'));
+        }
+        this._state = PhysicalState.CLOSING;
+        this._closePromise = new Promise((resolve, reject) => {
+            this._resolveClose = resolve;
+            Promise.all(Array.from(this._connections).map((connection) => connection.destroy())).catch((err) => {
+                this._resolveClose = null;
+                reject(err);
+            });
+        });
+        return this._closePromise;
+    }
 }
 
 function inRange(n, [min, max]) {
     return n >= min && n <= max;
 }
+function isRangeArray(range) {
+    return Array.isArray(range[0]);
+}
 function checkRange(value, range) {
-    if (!range) {
+    if (!range || range.length === 0) {
         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) {
+    if (isRangeArray(range)) {
         for (const r of range) {
             const [min, max] = r;
             const [lo, hi] = min <= max ? [min, max] : [max, min];
@@ -144,7 +689,9 @@ function checkRange(value, range) {
         }
         return false;
     }
-    return true;
+    const [min, max] = range;
+    const [lo, hi] = min <= max ? [min, max] : [max, min];
+    return values.every((n) => inRange(n, [lo, hi]));
 }
 
 const TABLE = [
@@ -173,11 +720,6 @@ function crc(data, seed = 0xffff) {
     return crc;
 }
 
-/** Cross-process unique id: `${prefix}-${uuid-v4}`. */
-function genConnectionId(prefix) {
-    return `${prefix}-${randomUUID()}`;
-}
-
 /**
  * Convert a number of bits to milliseconds at a given baud rate.
  *
@@ -303,15 +845,64 @@ function predictFc43_14Response(buffer) {
     return { kind: 'length', length: offset + 2 };
 }
 
-class SerialPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._serialport.isOpen;
+/**
+ * Resolve Modbus RTU timing parameters from user options into milliseconds.
+ *
+ * - `intervalBetweenFrames` (t3.5): if omitted and `baudRate` is present,
+ *   defaults to 38.5 bits per Modbus V1.02 §2.5.1.1.
+ * - `interCharTimeout` (t1.5): opt-in; only resolved when explicitly provided.
+ *
+ * Per the spec, at baud rates > 19200 fixed values are used
+ * (1.75 ms for t3.5, 0.75 ms for t1.5) regardless of the bit value.
+ */
+function resolveRtuTiming(opts = {}, baudRate) {
+    var _a, _b, _c;
+    let intervalBetweenFrames = 0;
+    let interCharTimeout = 0;
+    if (((_a = opts.intervalBetweenFrames) === null || _a === void 0 ? void 0 : _a.unit) === 'ms') {
+        intervalBetweenFrames = opts.intervalBetweenFrames.value;
     }
-    get destroyed() {
-        return this._destroyed;
+    else if (baudRate !== undefined) {
+        const bitValue = (_c = (_b = opts.intervalBetweenFrames) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : 38.5;
+        intervalBetweenFrames = baudRate > 19200 ? 1.75 : Math.ceil(bitsToMs(baudRate, bitValue));
     }
-    get baudRate() {
-        return this._baudRate;
+    if (opts.interCharTimeout) {
+        if (opts.interCharTimeout.unit === 'ms') {
+            interCharTimeout = opts.interCharTimeout.value;
+        }
+        else if (baudRate !== undefined) {
+            interCharTimeout = baudRate > 19200 ? 0.75 : Math.ceil(bitsToMs(baudRate, opts.interCharTimeout.value));
+        }
+    }
+    return { intervalBetweenFrames, interCharTimeout };
+}
+
+/**
+ * Normalize an IP address by stripping the IPv4-mapped IPv6 prefix.
+ * This ensures consistent comparison of addresses like `::ffff:192.168.1.1`.
+ */
+function normalizeAddress(address = '') {
+    return address.replace(/^::ffff:/, '');
+}
+/**
+ * Check whether a remote address is allowed by the given whitelist.
+ * IPv4-mapped IPv6 addresses are normalized before comparison.
+ * Returns `true` when whitelist is absent or empty.
+ */
+function isWhitelisted(address, whitelist) {
+    if (!whitelist || whitelist.length === 0) {
+        return true;
+    }
+    const normalized = normalizeAddress(address);
+    return whitelist.includes(normalized);
+}
+
+class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
+    get state() {
+        return this._state;
+    }
+    get server() {
+        return this._server;
     }
     constructor(options) {
         super();
@@ -319,327 +910,502 @@ class SerialPhysicalLayer extends AbstractPhysicalLayer {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'SERIAL'
+            value: 'TCP_SERVER'
         });
-        Object.defineProperty(this, "_serialport", {
+        Object.defineProperty(this, "_state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: PhysicalState.CLOSED
+        });
+        Object.defineProperty(this, "_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "_server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_opts", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_connection", {
+        Object.defineProperty(this, "_openPromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: null
         });
-        Object.defineProperty(this, "_isOpening", {
+        Object.defineProperty(this, "_closePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: null
         });
-        Object.defineProperty(this, "_destroyed", {
+        Object.defineProperty(this, "_resolveClose", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: null
         });
-        Object.defineProperty(this, "_baudRate", {
+        Object.defineProperty(this, "_cleanupFns", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: new Set()
         });
-        this._serialport = new SerialPort(Object.assign(Object.assign({}, options), { autoOpen: false }));
-        this._baudRate = options.baudRate;
+        this._opts = options !== null && options !== void 0 ? options : {};
     }
-    open() {
-        if (this._destroyed) {
-            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_DESTROYED, 'Port is destroyed'));
+    open(options) {
+        if (this.state === PhysicalState.OPEN) {
+            return Promise.resolve();
         }
-        if (this.isOpen || this._isOpening) {
-            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_ALREADY_OPEN, 'Port is already open'));
+        if (this.state === PhysicalState.OPENING) {
+            return this._openPromise;
         }
-        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);
+        if (this.state === PhysicalState.CLOSING) {
+            return Promise.reject(new Error('Port is closing'));
+        }
+        this._state = PhysicalState.OPENING;
+        this._openPromise = new Promise((resolve, reject) => {
+            var _a;
+            const server = createServer(this._opts.serverOpts, (socket) => {
+                if (!isWhitelisted(socket.remoteAddress, this._opts.whitelist)) {
+                    socket.destroy();
                     return;
                 }
-                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');
+                let cleanupTimeout = null;
+                if (this._opts.idleTimeout) {
+                    socket.setTimeout(this._opts.idleTimeout);
+                    cleanupTimeout = () => socket.off('timeout', onTimeout);
+                    const onTimeout = () => {
+                        this._cleanupFns.delete(cleanupTimeout);
+                        socket.destroy();
+                    };
+                    socket.once('timeout', onTimeout);
+                    this._cleanupFns.add(cleanupTimeout);
+                }
+                const connection = new TcpPhysicalConnection(this, socket);
+                this._connections.add(connection);
+                const cleanupConnectionClose = () => connection.off('close', onConnectionClose);
+                const onConnectionClose = () => {
+                    if (cleanupTimeout) {
+                        cleanupTimeout();
+                        this._cleanupFns.delete(cleanupTimeout);
                     }
-                });
+                    this._cleanupFns.delete(cleanupConnectionClose);
+                    this._connections.delete(connection);
+                };
+                connection.once('close', onConnectionClose);
+                this._cleanupFns.add(cleanupConnectionClose);
+                this.emit('connect', connection);
+            });
+            this._server = server;
+            if (this._opts.maxConnections !== undefined) {
+                server.maxConnections = this._opts.maxConnections;
+            }
+            const onConnect = () => {
+                server.off('error', onError);
+                this._state = PhysicalState.OPEN;
+                this._openPromise = null;
+                this.emit('open');
                 resolve();
+                {
+                    const onError = (err) => {
+                        this.emit('error', err);
+                    };
+                    server.on('error', onError);
+                    this._cleanupFns.add(() => server.off('error', onError));
+                    const cleanupClose = () => server.off('close', onClose);
+                    const onClose = () => {
+                        var _a;
+                        this._cleanupFns.delete(cleanupClose);
+                        this._state = PhysicalState.CLOSED;
+                        this._closePromise = null;
+                        for (const fn of this._cleanupFns) {
+                            fn();
+                        }
+                        this._cleanupFns.clear();
+                        this._server = null;
+                        this.emit('close');
+                        (_a = this._resolveClose) === null || _a === void 0 ? void 0 : _a.call(this);
+                        this._resolveClose = null;
+                    };
+                    server.once('close', onClose);
+                    this._cleanupFns.add(cleanupClose);
+                }
+            };
+            const onError = (err) => {
+                server.off('listening', onConnect);
+                this._state = PhysicalState.CLOSED;
+                this._openPromise = null;
+                this._server = null;
+                reject(err);
+            };
+            server.once('listening', onConnect);
+            server.once('error', onError);
+            server.listen(Object.assign(Object.assign({}, options), { port: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 502 }));
+        });
+        return this._openPromise;
+    }
+    close() {
+        if (this.state === PhysicalState.CLOSED) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalState.CLOSING) {
+            return this._closePromise;
+        }
+        if (this.state === PhysicalState.OPENING) {
+            return Promise.reject(new Error('Port is opening'));
+        }
+        this._state = PhysicalState.CLOSING;
+        this._closePromise = new Promise((resolve, reject) => {
+            this._resolveClose = resolve;
+            this.server.close();
+            Promise.all(Array.from(this._connections).map((connection) => connection.destroy())).catch((err) => {
+                this._resolveClose = null;
+                reject(err);
             });
         });
+        return this._closePromise;
+    }
+}
+
+class UdpClientPhysicalConnection extends AbstractPhysicalConnection {
+    get state() {
+        return this._state;
+    }
+    get physicalLayer() {
+        return this._physicalLayer;
+    }
+    constructor(physicalLayer, socket) {
+        super();
+        Object.defineProperty(this, "_state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: PhysicalConnectionState.CONNECTED
+        });
+        Object.defineProperty(this, "_physicalLayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_socket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_destroyPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_resolveDestroy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this._physicalLayer = physicalLayer;
+        this._socket = socket;
+        const onMessage = (msg) => {
+            if (this.state !== PhysicalConnectionState.CONNECTED) {
+                return;
+            }
+            this.emit('data', msg);
+        };
+        socket.on('message', onMessage);
+        this._cleanupFns.add(() => socket.off('message', onMessage));
+        const onSocketError = (err) => {
+            this.physicalLayer.emit('error', err);
+        };
+        socket.on('error', onSocketError);
+        this._cleanupFns.add(() => socket.off('error', onSocketError));
+        const cleanupClose = () => socket.off('close', onClose);
+        const onClose = () => {
+            var _a;
+            this._cleanupFns.delete(cleanupClose);
+            this._state = PhysicalConnectionState.DESTROYED;
+            this._destroyPromise = null;
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
+            this.emit('close');
+            (_a = this._resolveDestroy) === null || _a === void 0 ? void 0 : _a.call(this);
+            this._resolveDestroy = null;
+        };
+        socket.once('close', onClose);
+        this._cleanupFns.add(cleanupClose);
     }
     write(data) {
         return new Promise((resolve, reject) => {
-            if (this.isOpen) {
-                this._serialport.write(data, (error) => {
+            if (this.state === PhysicalConnectionState.CONNECTED) {
+                this._socket.send(data, (error) => {
                     if (error) {
                         reject(error);
                     }
                     else {
-                        this.emit('write', data);
                         resolve();
                     }
                 });
             }
             else {
-                reject(new ModbusError(ModbusErrorCode.PORT_NOT_OPEN, 'Port is not open'));
+                reject(new Error('Connection is not connected'));
             }
         });
     }
-    close() {
-        if (!this._serialport.isOpen) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            this._serialport.once('close', () => resolve());
-            this._serialport.close();
-        });
-    }
     destroy() {
-        if (this._destroyed) {
+        if (this.state === PhysicalConnectionState.DESTROYED) {
             return Promise.resolve();
         }
-        this._destroyed = true;
-        return this.close().then(() => {
-            this.removeAllListeners();
+        if (this.state === PhysicalConnectionState.DESTROYING) {
+            return this._destroyPromise;
+        }
+        this._state = PhysicalConnectionState.DESTROYING;
+        this._destroyPromise = new Promise((resolve) => {
+            this._resolveDestroy = resolve;
+            this._socket.close();
         });
+        return this._destroyPromise;
     }
 }
-
-class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._isOpen;
+class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
+    get state() {
+        return this._state;
     }
-    get destroyed() {
-        return this._destroyed;
+    get socket() {
+        return this._socket;
     }
     constructor(options) {
+        var _a;
         super();
         Object.defineProperty(this, "TYPE", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'NET'
+            value: 'UDP_CLIENT'
         });
-        Object.defineProperty(this, "_socket", {
+        Object.defineProperty(this, "_state", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: PhysicalState.CLOSED
         });
-        Object.defineProperty(this, "_connection", {
+        Object.defineProperty(this, "_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "_socket", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: null
         });
-        Object.defineProperty(this, "_isOpen", {
+        Object.defineProperty(this, "_socketOpts", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        Object.defineProperty(this, "_isOpening", {
+        Object.defineProperty(this, "_openPromise", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: null
         });
-        Object.defineProperty(this, "_destroyed", {
+        Object.defineProperty(this, "_closePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: null
         });
-        Object.defineProperty(this, "_socketOptions", {
+        Object.defineProperty(this, "_resolveClose", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
-        this._socketOptions = 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;
-        const socket = new Socket(this._socketOptions);
-        const connection = { id: genConnectionId('tcp-client') };
-        this._socket = socket;
-        this._connection = connection;
-        return new Promise((resolve, reject) => {
-            let connected = false;
-            socket.on('data', (data) => {
-                this.emit('data', data, (d) => this.write(d), connection);
-            });
-            socket.on('error', (err) => {
-                if (connected) {
-                    this.emit('error', err);
-                }
-                else {
-                    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();
-            });
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
         });
+        this._socketOpts = Object.assign(Object.assign({}, options), { type: (_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'udp4' });
     }
-    write(data) {
-        return new Promise((resolve, reject) => {
-            if (this._isOpen && this._socket) {
-                this._socket.write(data, (error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        this.emit('write', data);
-                        resolve();
+    open(remote) {
+        if (this.state === PhysicalState.OPEN) {
+            return Promise.resolve();
+        }
+        if (this.state === PhysicalState.OPENING) {
+            return this._openPromise;
+        }
+        if (this.state === PhysicalState.CLOSING) {
+            return Promise.reject(new Error('Port is closing'));
+        }
+        this._state = PhysicalState.OPENING;
+        this._openPromise = new Promise((resolve, reject) => {
+            const socket = createSocket(this._socketOpts);
+            this._socket = socket;
+            const onListening = () => {
+                var _a;
+                socket.off('error', onError);
+                socket.connect((_a = remote === null || remote === void 0 ? void 0 : remote.port) !== null && _a !== void 0 ? _a : 502, remote === null || remote === void 0 ? void 0 : remote.address);
+                this._state = PhysicalState.OPEN;
+                this._openPromise = null;
+                this.emit('open');
+                resolve();
+                const connection = new UdpClientPhysicalConnection(this, socket);
+                this._connections.add(connection);
+                const cleanupConnectionClose = () => connection.off('close', onConnectionClose);
+                const onConnectionClose = () => {
+                    var _a;
+                    this._cleanupFns.delete(cleanupConnectionClose);
+                    this._connections.delete(connection);
+                    this._state = PhysicalState.CLOSED;
+                    this._closePromise = null;
+                    for (const fn of this._cleanupFns) {
+                        fn();
                     }
-                });
-            }
-            else {
-                reject(new ModbusError(ModbusErrorCode.PORT_NOT_OPEN, 'Port is not open'));
-            }
+                    this._cleanupFns.clear();
+                    this._socket = null;
+                    this.emit('close');
+                    (_a = this._resolveClose) === null || _a === void 0 ? void 0 : _a.call(this);
+                    this._resolveClose = null;
+                };
+                connection.once('close', onConnectionClose);
+                this._cleanupFns.add(cleanupConnectionClose);
+                this.emit('connect', connection);
+            };
+            const onError = (err) => {
+                socket.off('listening', onListening);
+                this._state = PhysicalState.CLOSED;
+                this._openPromise = null;
+                this._socket = null;
+                reject(err);
+            };
+            socket.once('listening', onListening);
+            socket.once('error', onError);
+            socket.bind();
         });
+        return this._openPromise;
     }
     close() {
-        if (!this._socket) {
+        if (this.state === PhysicalState.CLOSED) {
             return Promise.resolve();
         }
-        const socket = this._socket;
-        return new Promise((resolve) => {
-            socket.once('close', () => resolve());
-            socket.destroy();
-        });
-    }
-    destroy() {
-        if (this._destroyed) {
-            return Promise.resolve();
+        if (this.state === PhysicalState.CLOSING) {
+            return this._closePromise;
         }
-        this._destroyed = true;
-        return this.close().then(() => {
-            this.removeAllListeners();
+        if (this.state === PhysicalState.OPENING) {
+            return Promise.reject(new Error('Port is opening'));
+        }
+        this._state = PhysicalState.CLOSING;
+        this._closePromise = new Promise((resolve, reject) => {
+            this._resolveClose = resolve;
+            Promise.all(Array.from(this._connections).map((connection) => connection.destroy())).catch((err) => {
+                this._resolveClose = null;
+                reject(err);
+            });
         });
+        return this._closePromise;
     }
 }
 
-class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._isOpen;
+class UdpServerPhysicalConnection extends AbstractPhysicalConnection {
+    get state() {
+        return this._state;
     }
-    get destroyed() {
-        return this._destroyed;
+    get physicalLayer() {
+        return this._physicalLayer;
     }
-    constructor(options) {
+    constructor(physicalLayer, socket, remote, idleTimeout, messageEventDelegation) {
         super();
-        Object.defineProperty(this, "TYPE", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'NET'
-        });
-        Object.defineProperty(this, "_server", {
+        Object.defineProperty(this, "_state", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: PhysicalConnectionState.CONNECTED
         });
-        Object.defineProperty(this, "_isOpen", {
+        Object.defineProperty(this, "_physicalLayer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        Object.defineProperty(this, "_isOpening", {
+        Object.defineProperty(this, "_socket", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        Object.defineProperty(this, "_destroyed", {
+        Object.defineProperty(this, "_remote", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        Object.defineProperty(this, "_connections", {
+        Object.defineProperty(this, "_idleTid", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: null
         });
-        Object.defineProperty(this, "_serverOptions", {
+        Object.defineProperty(this, "_cleanupFns", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: new Set()
         });
-        this._serverOptions = options;
+        this._physicalLayer = physicalLayer;
+        this._socket = socket;
+        this._remote = remote;
+        const onMessage = (msg) => {
+            if (this.state !== PhysicalConnectionState.CONNECTED) {
+                return;
+            }
+            if (this._idleTid !== null) {
+                clearTimeout(this._idleTid);
+                this._idleTid = null;
+                if (idleTimeout > 0) {
+                    this._idleTid = setTimeout(() => {
+                        this.destroy();
+                    }, idleTimeout);
+                }
+            }
+            this.emit('data', msg);
+        };
+        messageEventDelegation.add(onMessage);
+        this._cleanupFns.add(() => messageEventDelegation.remove(onMessage));
+        if (idleTimeout > 0) {
+            this._idleTid = setTimeout(() => {
+                this.destroy();
+            }, idleTimeout);
+        }
     }
-    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 = 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) => {
+    write(data) {
+        return new Promise((resolve, reject) => {
+            if (this.state === PhysicalConnectionState.CONNECTED) {
+                this._socket.send(data, this._remote.port, this._remote.address, (error) => {
                     if (error) {
                         reject(error);
                     }
@@ -647,114 +1413,46 @@ class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
                         resolve();
                     }
                 });
-            });
-            socket.on('data', (data) => {
-                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._server = server;
-        return new Promise((resolve, reject) => {
-            var _a;
-            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._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');
-                }
-            });
-            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 ModbusError(ModbusErrorCode.NOT_SUPPORTED, 'Not supported'));
-        });
-    }
-    close() {
-        if (!this._server) {
-            return Promise.resolve();
-        }
-        const server = this._server;
-        return new Promise((resolve) => {
-            server.once('close', () => resolve());
-            for (const [socket] of this._connections) {
-                socket.destroy();
-            }
-            try {
-                server.close();
             }
-            catch (_a) {
-                resolve();
+            else {
+                reject(new Error('Connection is not connected'));
             }
         });
     }
     destroy() {
-        if (this._destroyed) {
-            return Promise.resolve();
+        this._state = PhysicalConnectionState.DESTROYED;
+        for (const fn of this._cleanupFns) {
+            fn();
         }
-        this._destroyed = true;
-        return this.close().then(() => {
-            this.removeAllListeners();
-        });
+        this._cleanupFns.clear();
+        if (this._idleTid !== null) {
+            clearTimeout(this._idleTid);
+            this._idleTid = null;
+        }
+        this.emit('close');
+        return Promise.resolve();
     }
 }
-
-class UdpPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._isOpen;
+class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
+    get state() {
+        return this._state;
     }
-    get destroyed() {
-        return this._destroyed;
+    get socket() {
+        return this._socket;
     }
     constructor(options) {
-        var _a, _b, _c, _d;
         super();
         Object.defineProperty(this, "TYPE", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'NET'
+            value: 'UDP_SERVER'
         });
-        Object.defineProperty(this, "_socket", {
+        Object.defineProperty(this, "_state", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: PhysicalState.CLOSED
         });
         Object.defineProperty(this, "_connections", {
             enumerable: true,
@@ -762,233 +1460,197 @@ class UdpPhysicalLayer extends AbstractPhysicalLayer {
             writable: true,
             value: new Map()
         });
-        Object.defineProperty(this, "_isOpen", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_isOpening", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_destroyed", {
+        Object.defineProperty(this, "_socket", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: null
         });
-        Object.defineProperty(this, "_socketOptions", {
+        Object.defineProperty(this, "_opts", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_port", {
+        Object.defineProperty(this, "_openPromise", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
-        Object.defineProperty(this, "_address", {
+        Object.defineProperty(this, "_closePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
-        Object.defineProperty(this, "_idleTimeout", {
+        Object.defineProperty(this, "_resolveClose", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
-        Object.defineProperty(this, "isServer", {
+        Object.defineProperty(this, "_cleanupFns", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: new Set()
         });
-        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;
+        this._opts = options !== null && options !== void 0 ? options : {};
     }
+    /**
+     * Bind the UDP socket and start accepting datagrams.
+     *
+     * @param options Bind options (port, address, etc.). Defaults to port 502.
+     * @param [idleTimeout=30000] Maximum idle time in milliseconds before an
+     * inactive client connection is evicted. Pass `0` to disable eviction
+     * (connections never time out). Disabling eviction may cause unbounded
+     * memory growth if the server sees many unique clients.
+     */
     open(options) {
-        var _a, _b;
-        if (this._destroyed) {
-            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_DESTROYED, 'Port is destroyed'));
+        if (this.state === PhysicalState.OPEN) {
+            return Promise.resolve();
         }
-        if (this._isOpen || this._isOpening) {
-            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_ALREADY_OPEN, 'Port is already open'));
+        if (this.state === PhysicalState.OPENING) {
+            return this._openPromise;
         }
-        this._isOpening = true;
-        this._connections.clear();
-        const socket = 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) {
+        if (this.state === PhysicalState.CLOSING) {
+            return Promise.reject(new Error('Port is closing'));
+        }
+        this._state = PhysicalState.OPENING;
+        this._openPromise = new Promise((resolve, reject) => {
+            var _a, _b, _c;
+            const socket = createSocket(Object.assign(Object.assign({}, this._opts.socketOpts), { type: (_b = (_a = this._opts.socketOpts) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'udp4' }), (msg, rinfo) => {
+                var _a;
+                if (!isWhitelisted(rinfo.address, this._opts.whitelist)) {
                     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);
+                const id = `${rinfo.address}:${rinfo.port}`;
+                let connection = this._connections.get(id);
+                if (!connection) {
+                    if (this._opts.maxConnections !== undefined && this._connections.size >= this._opts.maxConnections) {
+                        return;
                     }
-                    this.emit('connection-close', entry.conn);
+                    const listeners = new Set();
+                    const conn = new UdpServerPhysicalConnection(this, socket, rinfo, (_a = this._opts.idleTimeout) !== null && _a !== void 0 ? _a : 30000, {
+                        add: (listener) => {
+                            listeners.add(listener);
+                        },
+                        remove: (listener) => {
+                            listeners.delete(listener);
+                        },
+                    });
+                    connection = { connection: conn, listeners };
+                    this._connections.set(id, connection);
+                    const cleanupConnectionClose = () => conn.off('close', onConnectionClose);
+                    const onConnectionClose = () => {
+                        this._cleanupFns.delete(cleanupConnectionClose);
+                        this._connections.delete(id);
+                    };
+                    conn.once('close', onConnectionClose);
+                    this._cleanupFns.add(cleanupConnectionClose);
+                    this.emit('connect', conn);
+                }
+                for (const fn of connection.listeners) {
+                    fn(msg, rinfo);
                 }
-                this.emit('close');
             });
-            if (this.isServer) {
-                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;
-                    resolve();
-                });
-            }
-            else {
-                started = true;
-                this._isOpening = false;
-                this._isOpen = true;
+            this._socket = socket;
+            const onListening = () => {
+                socket.off('error', onError);
+                this._state = PhysicalState.OPEN;
+                this._openPromise = null;
+                this.emit('open');
                 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();
+                {
+                    const onError = (err) => {
+                        this.emit('error', err);
+                    };
+                    socket.on('error', onError);
+                    this._cleanupFns.add(() => socket.off('error', onError));
+                    const cleanupClose = () => socket.off('close', onClose);
+                    const onClose = () => {
+                        var _a;
+                        this._socket = null;
+                        this._cleanupFns.delete(cleanupClose);
+                        this._state = PhysicalState.CLOSED;
+                        this._closePromise = null;
+                        for (const fn of this._cleanupFns) {
+                            fn();
+                        }
+                        this._cleanupFns.clear();
+                        this._socket = null;
+                        this.emit('close');
+                        (_a = this._resolveClose) === null || _a === void 0 ? void 0 : _a.call(this);
+                        this._resolveClose = null;
+                    };
+                    socket.once('close', onClose);
+                    this._cleanupFns.add(cleanupClose);
                 }
-            });
-        });
-        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 ModbusError(ModbusErrorCode.PORT_NOT_OPEN, 'Port is not open'));
-            }
+            };
+            const onError = (err) => {
+                socket.off('listening', onListening);
+                this._state = PhysicalState.CLOSED;
+                this._openPromise = null;
+                this._socket = null;
+                reject(err);
+            };
+            socket.once('listening', onListening);
+            socket.once('error', onError);
+            socket.bind(Object.assign(Object.assign({}, options), { port: (_c = options === null || options === void 0 ? void 0 : options.port) !== null && _c !== void 0 ? _c : 502 }));
         });
+        return this._openPromise;
     }
     close() {
-        if (!this._socket) {
+        if (this.state === PhysicalState.CLOSED) {
             return Promise.resolve();
         }
-        const socket = this._socket;
-        return new Promise((resolve) => {
-            socket.once('close', () => resolve());
-            try {
-                socket.close();
-            }
-            catch (_a) {
-                // Socket may already be closed; the registered 'close' listener still fires asynchronously.
+        if (this.state === PhysicalState.CLOSING) {
+            return this._closePromise;
+        }
+        if (this.state === PhysicalState.OPENING) {
+            return Promise.reject(new Error('Port is opening'));
+        }
+        this._state = PhysicalState.CLOSING;
+        this._closePromise = new Promise((resolve) => {
+            this._resolveClose = resolve;
+            this.socket.close();
+            // Snapshot connections so destruction (which removes from the Map)
+            // does not interfere with iteration.
+            const connections = Array.from(this._connections.values());
+            for (const { connection } of connections) {
+                connection.destroy();
             }
         });
+        return this._closePromise;
     }
-    destroy() {
-        if (this._destroyed) {
-            return Promise.resolve();
-        }
-        this._destroyed = true;
-        return this.close().then(() => {
-            this.removeAllListeners();
-        });
+}
+
+function createPhysicalLayer(config) {
+    switch (config.type) {
+        case 'SERIAL':
+            return new SerialPhysicalLayer(config.opts);
+        case 'TCP_CLIENT':
+            return new TcpClientPhysicalLayer(config.socketOpts);
+        case 'TCP_SERVER':
+            return new TcpServerPhysicalLayer(config.opts);
+        case 'UDP_CLIENT':
+            return new UdpClientPhysicalLayer(config.socketOpts);
+        case 'UDP_SERVER':
+            return new UdpServerPhysicalLayer(config.opts);
+        case 'CUSTOM':
+            return config.layer;
     }
 }
 
+/**
+ * Application-layer protocol handler bound to a single physical connection.
+ *
+ * Its lifetime follows the channel: created when the underlying connection is
+ * established and discarded when the connection closes. Subclasses implement
+ * ASCII, RTU, or TCP framing rules.
+ */
 class AbstractApplicationLayer extends EventEmitter {
-    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');
-        }
-        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;
-    }
     flush() {
         // no-op — override in subclasses
     }
@@ -1001,7 +1663,10 @@ class AbstractApplicationLayer extends EventEmitter {
 const MAX_FRAME_LENGTH = 256;
 const MIN_FRAME_LENGTH = 4;
 class RtuApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer, options = {}) {
+    get connection() {
+        return this._connection;
+    }
+    constructor(role, connection, options = {}) {
         super();
         Object.defineProperty(this, "PROTOCOL", {
             enumerable: true,
@@ -1009,23 +1674,29 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             writable: true,
             value: 'RTU'
         });
-        Object.defineProperty(this, "_states", {
+        Object.defineProperty(this, "ROLE", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
-        Object.defineProperty(this, "_customFunctionCodes", {
+        Object.defineProperty(this, "_connection", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
-        Object.defineProperty(this, "_removeAllListeners", {
+        Object.defineProperty(this, "_state", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: void 0
+        });
+        Object.defineProperty(this, "_poolSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
         Object.defineProperty(this, "_threePointFiveT", {
             enumerable: true,
@@ -1039,39 +1710,29 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_destroyed", {
+        Object.defineProperty(this, "_customFunctionCodes", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: new Map()
         });
-        const { intervalBetweenFrames, interCharTimeout } = options;
-        let threePointFiveT = 0;
-        let onePointFiveT = 0;
-        if (physicalLayer.TYPE === 'SERIAL') {
-            const baudRate = physicalLayer.baudRate;
-            if (intervalBetweenFrames && intervalBetweenFrames.unit === 'ms') {
-                threePointFiveT = intervalBetweenFrames.value;
-            }
-            else {
-                threePointFiveT =
-                    baudRate > 19200 ? 1.75 : Math.ceil(bitsToMs(baudRate, intervalBetweenFrames ? intervalBetweenFrames.value : 38.5));
-            }
-            if (interCharTimeout) {
-                if (interCharTimeout.unit === 'ms') {
-                    onePointFiveT = interCharTimeout.value;
-                }
-                else {
-                    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);
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this.ROLE = role;
+        this._connection = connection;
+        const { intervalBetweenFrames, interCharTimeout, poolSize } = options;
+        this._poolSize = poolSize !== null && poolSize !== void 0 ? poolSize : MAX_FRAME_LENGTH * 2;
+        this._state = { pool: Buffer.alloc(this._poolSize), start: 0, end: 0 };
+        this._threePointFiveT = intervalBetweenFrames !== null && intervalBetweenFrames !== void 0 ? intervalBetweenFrames : 0;
+        this._onePointFiveT = interCharTimeout !== null && interCharTimeout !== void 0 ? interCharTimeout : 0;
+        const onData = (data) => {
+            let state = this._state;
             if (state.t15Expired && state.end > state.start) {
-                this.emit('framing-error', new ModbusError(ModbusErrorCode.T1_5_EXCEEDED, 'Inter-character timeout (t1.5) exceeded'));
+                this.emit('framing-error', new Error('Inter-character timeout (t1.5) exceeded'));
                 state.start = 0;
                 state.end = 0;
             }
@@ -1080,11 +1741,11 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             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);
+                    this.clearStateTimers();
+                    this.flushBuffer(this._threePointFiveT > 0);
+                    state = this._state;
                     if (state.pool.length - state.end === 0) {
-                        this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_DATA, 'Frame buffer exhausted before complete frame received'));
+                        this.emit('framing-error', new Error('Frame buffer exhausted before complete frame received'));
                         state.start = 0;
                         state.end = 0;
                         state.t15Expired = false;
@@ -1096,10 +1757,10 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                 state.end += toCopy;
                 dataOffset += toCopy;
             }
-            this.clearStateTimers(state);
+            this.clearStateTimers();
             const commitFrame = () => {
-                this.clearStateTimers(state);
-                this.flushBuffer(connection.id, response, connection, this._threePointFiveT > 0);
+                this.clearStateTimers();
+                this.flushBuffer(this._threePointFiveT > 0);
             };
             if (state.end - state.start >= MAX_FRAME_LENGTH) {
                 commitFrame();
@@ -1117,30 +1778,20 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                 commitFrame();
             }
         };
-        physicalLayer.on('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 = () => {
-            for (const key of [...this._states.keys()]) {
-                this.clearState(key);
-            }
+        connection.on('data', onData);
+        this._cleanupFns.add(() => connection.off('data', onData));
+        const onClose = () => {
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
+            this.clearStateTimers();
         };
-        physicalLayer.on('close', handleClose);
-        this._removeAllListeners.push(() => physicalLayer.removeListener('close', handleClose));
-    }
-    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;
+        connection.on('close', onClose);
+        this._cleanupFns.add(() => connection.off('close', onClose));
     }
-    clearStateTimers(state) {
+    clearStateTimers() {
+        const state = this._state;
         if (state.timer) {
             clearTimeout(state.timer);
             state.timer = undefined;
@@ -1150,45 +1801,18 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             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;
-        }
+    flushBuffer(strict) {
+        const state = this._state;
         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);
+                this.deliverFrame(result.frame);
             }
             else if (result.kind === 'skip') {
                 if (strict) {
-                    this.emit('framing-error', new ModbusError(ModbusErrorCode.CRC_MISMATCH, 'CRC mismatch'));
+                    this.emit('framing-error', new Error('CRC mismatch'));
                     state.start = 0;
                     state.end = 0;
                     state.t15Expired = false;
@@ -1202,14 +1826,14 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                     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'));
+                    this.emit('framing-error', new Error(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'));
+                    this.emit('framing-error', new Error('Inter-character timeout (t1.5) exceeded'));
                     state.start = 0;
                     state.end = 0;
                     state.t15Expired = false;
@@ -1230,15 +1854,22 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             state.end -= state.start;
             state.start = 0;
         }
-        if (state.end === 0 && !state.timer) {
-            this._states.delete(key);
-        }
+    }
+    deliverFrame(buffer) {
+        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);
     }
     tryExtract(buffer) {
         if (buffer.length < MIN_FRAME_LENGTH) {
             return { kind: 'insufficient' };
         }
-        const isResponse = this.role === 'MASTER';
+        const isResponse = this.ROLE === 'MASTER';
         const fc = buffer[1];
         const cfc = this._customFunctionCodes.get(fc);
         if (cfc) {
@@ -1258,12 +1889,12 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
         }
         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`),
+            error: new Error(`Unknown function code 0x${fc.toString(16).padStart(2, '0')} — register a CustomFunctionCode to frame this FC`),
         };
     }
     checkExpected(buffer, expected) {
         if (expected > MAX_FRAME_LENGTH || expected < MIN_FRAME_LENGTH) {
-            return { kind: 'error', error: new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data') };
+            return { kind: 'error', error: new Error('Invalid data') };
         }
         if (buffer.length < expected) {
             return { kind: 'insufficient' };
@@ -1276,40 +1907,28 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
     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);
+    flush() {
+        this.clearStateTimers();
+        this._state.start = 0;
+        this._state.end = 0;
+    }
+    addCustomFunctionCode(cfc) {
+        if (!isUint8(cfc.fc)) {
+            throw new Error(`fc must be an integer in 0..255, got ${cfc.fc}`);
+        }
+        this._customFunctionCodes.set(cfc.fc, cfc);
+    }
+    removeCustomFunctionCode(fc) {
+        this._customFunctionCodes.delete(fc);
     }
     encode(data) {
-        const buffer = Buffer.alloc(data.data.length + 4);
+        const buffer = Buffer.allocUnsafe(data.data.length + 4);
         buffer.writeUInt8(data.unit, 0);
         buffer.writeUInt8(data.fc, 1);
         buffer.set(data.data, 2);
         buffer.writeUInt16LE(crc(buffer.subarray(0, -2)), buffer.length - 2);
         return buffer;
     }
-    destroy() {
-        if (this._destroyed) {
-            return;
-        }
-        this._destroyed = true;
-        this.removeAllListeners();
-        for (const removeListener of this._removeAllListeners) {
-            removeListener();
-        }
-        this._removeAllListeners = [];
-        for (const state of this._states.values()) {
-            this.clearStateTimers(state);
-        }
-        this._states.clear();
-        this._customFunctionCodes.clear();
-    }
 }
 
 const CHAR_CODE = {
@@ -1334,7 +1953,10 @@ for (let i = 0x61; i <= 0x66; i++) {
 }
 const HEX_ENCODE = new Uint8Array('0123456789ABCDEF'.split('').map((c) => c.charCodeAt(0)));
 class AsciiApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer, options = {}) {
+    get connection() {
+        return this._connection;
+    }
+    constructor(role, connection, options = {}) {
         var _a;
         super();
         Object.defineProperty(this, "PROTOCOL", {
@@ -1343,30 +1965,38 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
             writable: true,
             value: 'ASCII'
         });
+        Object.defineProperty(this, "ROLE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lenientHex", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_states", {
+        Object.defineProperty(this, "_connection", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
-        Object.defineProperty(this, "_removeAllListeners", {
+        Object.defineProperty(this, "_state", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: { status: 'idle', frame: [] }
         });
-        Object.defineProperty(this, "_destroyed", {
+        Object.defineProperty(this, "_cleanupFns", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: new Set()
         });
+        this.ROLE = role;
+        this._connection = connection;
         this.lenientHex = (_a = options.lenientHex) !== null && _a !== void 0 ? _a : false;
         const lenientHex = this.lenientHex;
         const isHexChar = (value) => {
@@ -1381,8 +2011,8 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
             }
             return false;
         };
-        const handleData = (data, response, connection) => {
-            const state = this.getState(connection.id);
+        const onData = (data) => {
+            const state = this._state;
             data.forEach((value) => {
                 switch (state.status) {
                     case 'idle': {
@@ -1402,12 +2032,12 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
                         else if (state.frame.length >= MAX_ASCII_PAYLOAD) {
                             state.status = 'idle';
                             state.frame = [];
-                            this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data'));
+                            this.emit('framing-error', new Error('Invalid data'));
                         }
                         else if (!isHexChar(value)) {
                             state.status = 'idle';
                             state.frame = [];
-                            this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_HEX, 'Invalid hex character'));
+                            this.emit('framing-error', new Error('Invalid hex character'));
                         }
                         else {
                             state.frame.push(value);
@@ -1422,7 +2052,7 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
                         else {
                             state.status = 'idle';
                             if (value === CHAR_CODE.LF) {
-                                this.framing(Buffer.from(state.frame), response, connection);
+                                this.framing(Buffer.from(state.frame));
                             }
                         }
                         break;
@@ -1430,64 +2060,56 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
                 }
             });
         };
-        physicalLayer.on('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._states.clear();
+        connection.on('data', onData);
+        this._cleanupFns.add(() => connection.off('data', onData));
+        const onClose = () => {
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
         };
-        physicalLayer.on('close', handleClose);
-        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;
+        connection.on('close', onClose);
+        this._cleanupFns.add(() => connection.off('close', onClose));
     }
-    flush() {
-        this._states.clear();
-    }
-    framing(_buffer, response, connection) {
-        if (_buffer.length < 6) {
-            this.emit('framing-error', new ModbusError(ModbusErrorCode.INSUFFICIENT_DATA, 'Insufficient data length'));
+    framing(hexChars) {
+        if (hexChars.length < 6) {
+            this.emit('framing-error', new Error('Insufficient data length'));
             return;
         }
-        if (_buffer.length % 2 !== 0) {
-            this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_DATA, 'Invalid data'));
+        if (hexChars.length % 2 !== 0) {
+            this.emit('framing-error', new Error('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]];
+        const decoded = Buffer.allocUnsafe(hexChars.length / 2);
+        for (let i = 0; i < hexChars.length; i += 2) {
+            const hi = HEX_DECODE[hexChars[i]];
+            const lo = HEX_DECODE[hexChars[i + 1]];
+            // Defensive: the FSM should already have filtered non-hex characters,
+            // but guard here in case framing is ever called directly.
             if (hi === 0xff || lo === 0xff) {
-                this.emit('framing-error', new ModbusError(ModbusErrorCode.INVALID_HEX, 'Invalid hex character'));
+                this.emit('framing-error', new Error('Invalid hex character'));
                 return;
             }
-            buffer[i / 2] = (hi << 4) | lo;
+            decoded[i / 2] = (hi << 4) | lo;
         }
         const frame = {
-            unit: buffer[0],
-            fc: buffer[1],
-            data: buffer.subarray(2, buffer.length - 1),
-            buffer: _buffer,
+            unit: decoded[0],
+            fc: decoded[1],
+            data: decoded.subarray(2, decoded.length - 1),
+            buffer: hexChars,
         };
-        const lrcPassed = buffer[buffer.length - 1] === lrc(buffer.subarray(0, buffer.length - 1));
+        const lrcPassed = decoded[decoded.length - 1] === lrc(decoded.subarray(0, decoded.length - 1));
         if (!lrcPassed) {
-            this.emit('framing-error', new ModbusError(ModbusErrorCode.LRC_MISMATCH, 'LRC check failed'));
+            this.emit('framing-error', new Error('LRC check failed'));
             return;
         }
-        this.emit('framing', frame, response, connection);
+        this.emit('framing', frame);
+    }
+    flush() {
+        this._state = { status: 'idle', frame: [] };
     }
     encode(data) {
-        const buffer = Buffer.alloc(data.data.length + 3);
+        const buffer = Buffer.allocUnsafe(data.data.length + 3);
         buffer.writeUInt8(data.unit, 0);
         buffer.writeUInt8(data.fc, 1);
         buffer.set(data.data, 2);
@@ -1503,24 +2125,14 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         out[out.length - 1] = CHAR_CODE.LF;
         return out;
     }
-    destroy() {
-        if (this._destroyed) {
-            return;
-        }
-        this._destroyed = true;
-        this.removeAllListeners();
-        for (const removeListener of this._removeAllListeners) {
-            removeListener();
-        }
-        this._removeAllListeners = [];
-        this._states.clear();
-    }
 }
 
 const MAX_TCP_FRAME = 260;
-const EMPTY_BUFFER = Buffer.alloc(0);
 class TcpApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer) {
+    get connection() {
+        return this._connection;
+    }
+    constructor(role, connection) {
         super();
         Object.defineProperty(this, "PROTOCOL", {
             enumerable: true,
@@ -1528,38 +2140,50 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
             writable: true,
             value: 'TCP'
         });
-        Object.defineProperty(this, "_transactionId", {
+        Object.defineProperty(this, "ROLE", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 1
+            value: void 0
         });
-        Object.defineProperty(this, "_buffers", {
+        Object.defineProperty(this, "_connection", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
-        Object.defineProperty(this, "_removeAllListeners", {
+        Object.defineProperty(this, "_transactionId", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: 1
         });
-        Object.defineProperty(this, "_destroyed", {
+        Object.defineProperty(this, "_buffer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: Buffer.alloc(0)
         });
-        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]);
+        Object.defineProperty(this, "_cleanupFns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this.ROLE = role;
+        this._connection = connection;
+        const onData = (data) => {
+            let buffer = this._buffer;
+            if (buffer.length === 0) {
+                buffer = data;
+            }
+            else if (data.length > 0) {
+                buffer = Buffer.concat([buffer, data]);
+            }
             while (buffer.length > 0) {
                 const result = this.tryExtract(buffer);
                 if (result.kind === 'frame') {
-                    this.processFrame(result.frame, response, connection);
+                    this.processFrame(result.frame);
                     buffer = result.rest;
                 }
                 else if (result.kind === 'insufficient') {
@@ -1567,48 +2191,53 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
                 }
                 else {
                     this.emit('framing-error', result.error);
-                    buffer = EMPTY_BUFFER;
+                    buffer = Buffer.alloc(0);
                     break;
                 }
             }
             if (buffer.length === 0) {
-                this._buffers.delete(connection.id);
+                this._buffer = Buffer.alloc(0);
+            }
+            else if (buffer === data) {
+                // Copy into a right-sized buffer so we do not retain the potentially
+                // large backing buffer of the original incoming data (Node.js pool).
+                const copy = Buffer.allocUnsafe(buffer.length);
+                buffer.copy(copy);
+                this._buffer = copy;
             }
             else {
-                this._buffers.set(connection.id, buffer);
+                this._buffer = 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();
+        connection.on('data', onData);
+        this._cleanupFns.add(() => connection.off('data', onData));
+        const onClose = () => {
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
         };
-        physicalLayer.on('close', handleClose);
-        this._removeAllListeners.push(() => physicalLayer.removeListener('close', handleClose));
+        connection.on('close', onClose);
+        this._cleanupFns.add(() => connection.off('close', onClose));
     }
     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') };
+            return { kind: 'error', error: new Error('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') };
+            return { kind: 'error', error: new Error('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) {
+    processFrame(buffer) {
         const frame = {
             transaction: buffer.readUInt16BE(0),
             unit: buffer[6],
@@ -1616,12 +2245,15 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
             data: buffer.subarray(8),
             buffer,
         };
-        this.emit('framing', frame, response, connection);
+        this.emit('framing', frame);
+    }
+    flush() {
+        this._buffer = Buffer.alloc(0);
     }
     encode(data) {
         var _a;
         const transaction = (_a = data.transaction) !== null && _a !== void 0 ? _a : this._transactionId;
-        const buffer = Buffer.alloc(data.data.length + 8);
+        const buffer = Buffer.allocUnsafe(data.data.length + 8);
         buffer.writeUInt16BE(transaction, 0);
         buffer.writeUInt16BE(0, 2);
         buffer.writeUInt16BE(data.data.length + 2, 4);
@@ -1633,18 +2265,6 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
         }
         return buffer;
     }
-    destroy() {
-        if (this._destroyed) {
-            return;
-        }
-        this._destroyed = true;
-        this.removeAllListeners();
-        for (const removeListener of this._removeAllListeners) {
-            removeListener();
-        }
-        this._removeAllListeners = [];
-        this._buffers.clear();
-    }
 }
 
 const FIFO_KEY = 'fifo';
@@ -1681,8 +2301,10 @@ class MasterSession {
             return;
         }
         if (!this.runPreChecks(waiter, frame)) {
+            this._waiters.delete(key);
             return;
         }
+        this._waiters.delete(key);
         waiter.callback(null, frame);
     }
     handleError(error) {
@@ -1693,22 +2315,22 @@ class MasterSession {
         for (const check of waiter.preCheck) {
             const res = check(frame);
             if (typeof res === 'undefined') {
-                waiter.callback(new ModbusError(ModbusErrorCode.INSUFFICIENT_DATA, 'Insufficient data length'));
+                waiter.callback(new Error('Insufficient data length'));
                 return false;
             }
             if (typeof res === 'number') {
                 if (frame.data.length < res) {
-                    waiter.callback(new ModbusError(ModbusErrorCode.INSUFFICIENT_DATA, 'Insufficient data length'));
+                    waiter.callback(new Error('Insufficient data length'));
                     return false;
                 }
                 if (frame.data.length !== res) {
-                    waiter.callback(new ModbusError(ModbusErrorCode.INVALID_RESPONSE, 'Invalid response'));
+                    waiter.callback(new Error('Invalid response'));
                     return false;
                 }
                 continue;
             }
             if (!res) {
-                waiter.callback(new ModbusError(ModbusErrorCode.INVALID_RESPONSE, 'Invalid response'));
+                waiter.callback(new Error('Invalid response'));
                 return false;
             }
         }
@@ -1749,26 +2371,26 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 class ModbusMaster extends EventEmitter {
-    get isOpen() {
-        return this.physicalLayer.isOpen;
+    get state() {
+        return this._physicalLayer.state;
     }
-    get destroyed() {
-        return this._cleanLevel === 'destroy' || this.physicalLayer.destroyed;
+    get physicalLayer() {
+        return this._physicalLayer;
     }
-    constructor(applicationLayer, physicalLayer, options = {}) {
+    constructor(options) {
         var _a, _b;
         super();
-        Object.defineProperty(this, "applicationLayer", {
+        Object.defineProperty(this, "timeout", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: applicationLayer
+            value: void 0
         });
-        Object.defineProperty(this, "physicalLayer", {
+        Object.defineProperty(this, "concurrent", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: physicalLayer
+            value: void 0
         });
         Object.defineProperty(this, "_masterSession", {
             enumerable: true,
@@ -1776,6 +2398,30 @@ class ModbusMaster extends EventEmitter {
             writable: true,
             value: new MasterSession()
         });
+        Object.defineProperty(this, "_physicalLayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_protocol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_appLayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_customFunctionCodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "_queue", {
             enumerable: true,
             configurable: true,
@@ -1794,23 +2440,17 @@ class ModbusMaster extends EventEmitter {
             writable: true,
             value: 1
         });
-        Object.defineProperty(this, "_cleanLevel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'none'
-        });
-        Object.defineProperty(this, "timeout", {
+        Object.defineProperty(this, "_cleanupFns", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: new Set()
         });
-        Object.defineProperty(this, "concurrent", {
+        Object.defineProperty(this, "_closePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
         Object.defineProperty(this, "writeFC1", {
             enumerable: true,
@@ -1886,10 +2526,60 @@ class ModbusMaster extends EventEmitter {
         });
         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._physicalLayer = createPhysicalLayer(options.physical);
+        this._protocol = options.protocol;
+        if (this.concurrent && options.protocol.type !== 'TCP') {
+            throw new Error('concurrent mode requires a Modbus TCP application layer');
         }
-        this.applicationLayer.role = 'MASTER';
+        const onOpen = () => {
+            this.emit('open');
+        };
+        this._physicalLayer.on('open', onOpen);
+        this._cleanupFns.add(() => this._physicalLayer.off('open', onOpen));
+        const onConnect = (connection) => {
+            const appLayer = this._createAppLayer(connection);
+            this._appLayer = appLayer;
+            for (const cfc of this._customFunctionCodes.values()) {
+                appLayer.addCustomFunctionCode(cfc);
+            }
+            const cleanupFraming = () => appLayer.off('framing', onFraming);
+            const onFraming = (frame) => {
+                this._masterSession.handleFrame(frame);
+            };
+            appLayer.on('framing', onFraming);
+            this._cleanupFns.add(cleanupFraming);
+            const cleanupFramingError = () => appLayer.off('framing-error', onFramingError);
+            const onFramingError = (error) => {
+                this._masterSession.handleError(error);
+            };
+            appLayer.on('framing-error', onFramingError);
+            this._cleanupFns.add(cleanupFramingError);
+            const cleanupClose = () => connection.off('close', onClose);
+            const onClose = () => {
+                cleanupFraming();
+                cleanupFramingError();
+                cleanupClose();
+                this._cleanupFns.delete(cleanupFraming);
+                this._cleanupFns.delete(cleanupFramingError);
+                this._cleanupFns.delete(cleanupClose);
+            };
+            connection.on('close', onClose);
+            this._cleanupFns.add(cleanupClose);
+            this.emit('connect', connection);
+        };
+        this._physicalLayer.on('connect', onConnect);
+        this._cleanupFns.add(() => this._physicalLayer.off('connect', onConnect));
+        const onClose = () => {
+            this.emit('close');
+            this.close();
+        };
+        this._physicalLayer.on('close', onClose);
+        this._cleanupFns.add(() => this._physicalLayer.off('close', onClose));
+        const onError = (err) => {
+            this.emit('error', err);
+        };
+        this._physicalLayer.on('error', onError);
+        this._cleanupFns.add(() => this._physicalLayer.off('error', onError));
         this.writeFC1 = this.readCoils;
         this.writeFC2 = this.readDiscreteInputs;
         this.writeFC3 = this.readHoldingRegisters;
@@ -1902,20 +2592,27 @@ 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);
-        });
-        physicalLayer.on('close', () => {
-            this.emit('close');
-        });
+    }
+    _createAppLayer(connection) {
+        var _a;
+        if (this._protocol.type === 'RTU') {
+            const baudRate = this._physicalLayer.is('SERIAL') ? this._physicalLayer.baudRate : undefined;
+            const { intervalBetweenFrames, interCharTimeout } = resolveRtuTiming(this._protocol.opts, baudRate);
+            return new RtuApplicationLayer('MASTER', connection, {
+                intervalBetweenFrames,
+                interCharTimeout,
+                poolSize: (_a = this._protocol.opts) === null || _a === void 0 ? void 0 : _a.poolSize,
+            });
+        }
+        if (this._protocol.type === 'TCP') {
+            return new TcpApplicationLayer('MASTER', connection);
+        }
+        return new AsciiApplicationLayer('MASTER', connection, this._protocol.opts);
     }
     send(adu, preCheck, timeout, broadcast) {
+        if (this._physicalLayer.state !== PhysicalState.OPEN) {
+            return Promise.reject(new Error('Master is not open'));
+        }
         const task = () => this._exchange(adu, preCheck, timeout, broadcast);
         if (this.concurrent) {
             return task();
@@ -1935,14 +2632,20 @@ class ModbusMaster extends EventEmitter {
     }
     _drain() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._draining) {
+            if (this._draining || this._physicalLayer.state !== PhysicalState.OPEN) {
                 return;
             }
             this._draining = true;
             try {
                 while (this._queue.length > 0) {
+                    if (this._physicalLayer.state !== PhysicalState.OPEN) {
+                        return;
+                    }
                     const item = this._queue.shift();
-                    yield item.run();
+                    try {
+                        yield item.run();
+                    }
+                    catch (_a) { }
                 }
             }
             finally {
@@ -1952,18 +2655,26 @@ class ModbusMaster extends EventEmitter {
     }
     _exchange(adu, preCheck, timeout, broadcast) {
         return new Promise((resolve, reject) => {
-            if (this._cleanLevel !== 'none') {
-                reject(new ModbusError(ModbusErrorCode.MASTER_CLOSED, 'Master closed'));
+            if (this._physicalLayer.state !== PhysicalState.OPEN) {
+                reject(new Error('Master is not open'));
+                return;
+            }
+            const appLayer = this._appLayer;
+            if (!appLayer) {
+                reject(new Error('Connection not established'));
                 return;
             }
-            const usesTid = this.applicationLayer.PROTOCOL === 'TCP' && !broadcast;
+            const connection = appLayer.connection;
+            const usesTid = appLayer.PROTOCOL === 'TCP' && !broadcast;
             let tid;
             if (usesTid) {
-                tid = this._nextTid;
-                this._nextTid = (this._nextTid + 1) % 65536 || 1;
+                do {
+                    tid = this._nextTid;
+                    this._nextTid = (this._nextTid + 1) % 65536 || 1;
+                } while (this._masterSession.has(tid));
             }
             const key = tid !== null && tid !== void 0 ? tid : FIFO_KEY;
-            const payload = this.applicationLayer.encode(Object.assign(Object.assign({}, adu), { transaction: tid }));
+            const payload = appLayer.encode(Object.assign(Object.assign({}, adu), { transaction: tid }));
             let settled = false;
             const settle = (error, frame) => {
                 if (settled) {
@@ -1979,18 +2690,22 @@ class ModbusMaster extends EventEmitter {
                     resolve(frame);
                 }
             };
-            const timer = setTimeout(() => settle(new ModbusError(ModbusErrorCode.TIMEOUT, 'Timeout')), timeout);
+            const timer = setTimeout(() => settle(new Error('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();
+                appLayer.flush();
             }
-            this.physicalLayer
+            connection
                 .write(payload)
                 .then(() => {
                 if (settled) {
                     return;
                 }
+                if (this._physicalLayer.state !== PhysicalState.OPEN) {
+                    settle(new Error('Master is not open'));
+                    return;
+                }
                 if (broadcast) {
                     settle(null);
                     return;
@@ -2003,7 +2718,7 @@ class ModbusMaster extends EventEmitter {
     }
     writeFC1Or2(unit, fc, address, length, timeout) {
         const byteCount = Math.ceil(length / 8);
-        const bufferTx = Buffer.alloc(4);
+        const bufferTx = Buffer.allocUnsafe(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(length, 2);
         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) => {
@@ -2020,7 +2735,7 @@ class ModbusMaster extends EventEmitter {
     }
     writeFC3Or4(unit, fc, address, length, timeout) {
         const byteCount = length * 2;
-        const bufferTx = Buffer.alloc(4);
+        const bufferTx = Buffer.allocUnsafe(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(length, 2);
         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) => {
@@ -2038,7 +2753,7 @@ class ModbusMaster extends EventEmitter {
     }
     writeSingleCoil(unit, address, value, timeout = this.timeout) {
         const fc = FunctionCode.WRITE_SINGLE_COIL;
-        const bufferTx = Buffer.alloc(4);
+        const bufferTx = Buffer.allocUnsafe(4);
         bufferTx.writeUInt16BE(address, 0);
         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) => {
@@ -2049,7 +2764,7 @@ class ModbusMaster extends EventEmitter {
     }
     writeSingleRegister(unit, address, value, timeout = this.timeout) {
         const fc = FunctionCode.WRITE_SINGLE_REGISTER;
-        const bufferTx = Buffer.alloc(4);
+        const bufferTx = Buffer.allocUnsafe(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(value, 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) => {
@@ -2079,7 +2794,7 @@ class ModbusMaster extends EventEmitter {
     writeMultipleRegisters(unit, address, value, timeout = this.timeout) {
         const fc = FunctionCode.WRITE_MULTIPLE_REGISTERS;
         const byteCount = value.length * 2;
-        const bufferTx = Buffer.alloc(5 + byteCount);
+        const bufferTx = Buffer.allocUnsafe(5 + byteCount);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(value.length, 2);
         bufferTx.writeUInt8(byteCount, 4);
@@ -2114,7 +2829,7 @@ class ModbusMaster extends EventEmitter {
     }
     maskWriteRegister(unit, address, andMask, orMask, timeout = this.timeout) {
         const fc = FunctionCode.MASK_WRITE_REGISTER;
-        const bufferTx = Buffer.alloc(6);
+        const bufferTx = Buffer.allocUnsafe(6);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(andMask, 2);
         bufferTx.writeUInt16BE(orMask, 4);
@@ -2128,7 +2843,7 @@ class ModbusMaster extends EventEmitter {
         const fc = FunctionCode.READ_WRITE_MULTIPLE_REGISTERS;
         const byteCount = write.value.length * 2;
         const readByteCount = read.length * 2;
-        const bufferTx = Buffer.alloc(9 + byteCount);
+        const bufferTx = Buffer.allocUnsafe(9 + byteCount);
         bufferTx.writeUInt16BE(read.address, 0);
         bufferTx.writeUInt16BE(read.length, 2);
         bufferTx.writeUInt16BE(write.address, 4);
@@ -2200,10 +2915,14 @@ class ModbusMaster extends EventEmitter {
         });
     }
     addCustomFunctionCode(cfc) {
-        this.applicationLayer.addCustomFunctionCode(cfc);
+        var _a;
+        this._customFunctionCodes.set(cfc.fc, cfc);
+        (_a = this._appLayer) === null || _a === void 0 ? void 0 : _a.addCustomFunctionCode(cfc);
     }
     removeCustomFunctionCode(fc) {
-        this.applicationLayer.removeCustomFunctionCode(fc);
+        var _a;
+        this._customFunctionCodes.delete(fc);
+        (_a = this._appLayer) === null || _a === void 0 ? void 0 : _a.removeCustomFunctionCode(fc);
     }
     sendCustomFC(unit, fc, data, timeout = this.timeout) {
         const payload = Buffer.isBuffer(data) ? data : Buffer.from(data);
@@ -2213,83 +2932,107 @@ class ModbusMaster extends EventEmitter {
             }
         });
     }
-    _clean(level) {
-        if (this._cleanLevel === 'destroy') {
-            return;
-        }
-        if (this._cleanLevel === 'close' && level === 'close') {
-            return;
-        }
-        const errorCode = level === 'destroy' ? ModbusErrorCode.MASTER_DESTROYED : ModbusErrorCode.MASTER_CLOSED;
-        const message = level === 'destroy' ? 'Master destroyed' : 'Master closed';
+    _clean(message) {
         const queued = this._queue.splice(0);
         for (const item of queued) {
-            item.cancel(new ModbusError(errorCode, message));
-        }
-        this._masterSession.stopAll(new ModbusError(errorCode, message));
-        this._cleanLevel = level;
-    }
+            item.cancel(new Error(message));
+        }
+        this._masterSession.stopAll(new Error(message));
+    }
+    /**
+     * Open the underlying physical layer and begin accepting connections.
+     *
+     * A `ModbusMaster` instance can only be opened once. Once {@link close}
+     * is called — explicitly or because the physical layer disconnected —
+     * the instance is permanently closed and cannot be reopened.
+     * Create a new `ModbusMaster` if a new connection is required.
+     */
     open(...args) {
-        if (this._cleanLevel === 'destroy') {
-            return Promise.reject(new ModbusError(ModbusErrorCode.PORT_DESTROYED, 'Master is destroyed'));
+        if (this._closePromise) {
+            return Promise.reject(new Error('The port has been permanently closed and CANNOT be reopened'));
         }
-        this._cleanLevel = 'none';
-        this._nextTid = 1;
-        return this.physicalLayer.open(...args);
+        return this._physicalLayer.open(...args);
     }
-    close() {
-        if (this._cleanLevel === 'destroy') {
-            return Promise.resolve();
-        }
-        this._clean('close');
-        return this.physicalLayer.close();
+    _close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
+            this._clean('Master is closing');
+            let err = null;
+            try {
+                yield this._physicalLayer.close();
+            }
+            catch (error) {
+                err = error;
+            }
+            this.removeAllListeners();
+            if (err) {
+                return Promise.reject(err);
+            }
+        });
     }
-    destroy() {
-        if (this._cleanLevel === 'destroy') {
-            return Promise.resolve();
-        }
-        this._clean('destroy');
-        this.removeAllListeners();
-        this.applicationLayer.destroy();
-        return this.physicalLayer.destroy();
+    /**
+     * Permanently close the master and release all resources.
+     *
+     * After calling this method the instance is considered dead:
+     * - No further requests can be sent.
+     * - The instance cannot be reopened via {@link open}.
+     * - All event listeners registered on this master are removed.
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._closePromise) {
+                return this._closePromise;
+            }
+            this._closePromise = this._close();
+            return this._closePromise;
+        });
     }
 }
 
+function prependByte(byte, buffer) {
+    const result = Buffer.allocUnsafe(buffer.length + 1);
+    result[0] = byte;
+    buffer.copy(result, 1);
+    return result;
+}
 class ModbusSlave extends EventEmitter {
-    get isOpen() {
-        return this.physicalLayer.isOpen;
+    get state() {
+        return this._physicalLayer.state;
     }
-    get destroyed() {
-        return this._cleanLevel === 'destroy' || this.physicalLayer.destroyed;
+    get physicalLayer() {
+        return this._physicalLayer;
     }
-    constructor(applicationLayer, physicalLayer, options = {}) {
+    constructor(options) {
         var _a;
         super();
-        Object.defineProperty(this, "applicationLayer", {
+        Object.defineProperty(this, "models", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: applicationLayer
+            value: new Map()
         });
-        Object.defineProperty(this, "physicalLayer", {
+        Object.defineProperty(this, "concurrent", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: physicalLayer
+            value: void 0
         });
-        Object.defineProperty(this, "models", {
+        Object.defineProperty(this, "_physicalLayer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
-        Object.defineProperty(this, "concurrent", {
+        Object.defineProperty(this, "_protocol", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_queues", {
+        Object.defineProperty(this, "_appLayers", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -2307,72 +3050,112 @@ class ModbusSlave extends EventEmitter {
             writable: true,
             value: new Map()
         });
-        Object.defineProperty(this, "_cleanLevel", {
+        Object.defineProperty(this, "_cleanupFns", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'none'
-        });
-        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;
-            }
-            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);
+            value: new Set()
         });
-        physicalLayer.on('connection-close', (connection) => {
-            const q = this._queues.get(connection.id);
-            if (!q) {
-                return;
-            }
-            q.items = [];
-            if (!q.processing) {
-                this._queues.delete(connection.id);
-            }
+        Object.defineProperty(this, "_closePromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
         });
-        physicalLayer.on('close', () => {
-            for (const q of this._queues.values()) {
-                q.items = [];
-            }
-            this._queues.clear();
+        this.concurrent = (_a = options.concurrent) !== null && _a !== void 0 ? _a : false;
+        this._physicalLayer = createPhysicalLayer(options.physical);
+        this._protocol = options.protocol;
+        if (this.concurrent && options.protocol.type !== 'TCP') {
+            throw new Error('concurrent mode requires a Modbus TCP application layer');
+        }
+        const onOpen = () => this.emit('open');
+        this._physicalLayer.on('open', onOpen);
+        this._cleanupFns.add(() => this._physicalLayer.off('open', onOpen));
+        const onConnect = (connection) => {
+            const appLayer = this._createAppLayer(connection);
+            const appLayerData = { queues: { frames: [], processing: false } };
+            this._appLayers.set(appLayer, appLayerData);
+            for (const cfc of this._customFunctionCodes.values()) {
+                appLayer.addCustomFunctionCode(cfc);
+            }
+            const cleanupFraming = () => appLayer.off('framing', onFraming);
+            const onFraming = (frame) => {
+                if (this._physicalLayer.state !== PhysicalState.OPEN) {
+                    return;
+                }
+                if (!(frame.unit === 0x00 || this.models.has(frame.unit))) {
+                    return;
+                }
+                if (this.concurrent) {
+                    this._processFrame(appLayer, frame);
+                    return;
+                }
+                appLayerData.queues.frames.push(frame);
+                this._drain(appLayer, appLayerData.queues);
+            };
+            appLayer.on('framing', onFraming);
+            this._cleanupFns.add(cleanupFraming);
+            const cleanupClose = () => connection.off('close', onClose);
+            const onClose = () => {
+                cleanupFraming();
+                cleanupClose();
+                this._cleanupFns.delete(cleanupFraming);
+                this._cleanupFns.delete(cleanupClose);
+                this._appLayers.delete(appLayer);
+            };
+            connection.on('close', onClose);
+            this._cleanupFns.add(cleanupClose);
+            this.emit('connect', connection);
+        };
+        this._physicalLayer.on('connect', onConnect);
+        this._cleanupFns.add(() => this._physicalLayer.off('connect', onConnect));
+        const onClose = () => {
             this.emit('close');
-        });
+            this.close();
+        };
+        this._physicalLayer.on('close', onClose);
+        this._cleanupFns.add(() => this._physicalLayer.off('close', onClose));
+        const onError = (err) => {
+            this.emit('error', err);
+        };
+        this._physicalLayer.on('error', onError);
+        this._cleanupFns.add(() => this._physicalLayer.off('error', onError));
+    }
+    _createAppLayer(connection) {
+        var _a;
+        if (this._protocol.type === 'RTU') {
+            const baudRate = this._physicalLayer.is('SERIAL') ? this._physicalLayer.baudRate : undefined;
+            const { intervalBetweenFrames, interCharTimeout } = resolveRtuTiming(this._protocol.opts, baudRate);
+            return new RtuApplicationLayer('SLAVE', connection, {
+                intervalBetweenFrames,
+                interCharTimeout,
+                poolSize: (_a = this._protocol.opts) === null || _a === void 0 ? void 0 : _a.poolSize,
+            });
+        }
+        if (this._protocol.type === 'TCP') {
+            return new TcpApplicationLayer('SLAVE', connection);
+        }
+        return new AsciiApplicationLayer('SLAVE', connection, this._protocol.opts);
     }
-    handleFC1(model, frame, response) {
+    handleFC1(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 4) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.readCoils) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             try {
@@ -2383,31 +3166,32 @@ class ModbusSlave extends EventEmitter {
                         bufferTx[Math.floor(index / 8)] |= 1 << index % 8;
                     }
                 });
-                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([bufferTx.length]), bufferTx]) })));
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: prependByte(bufferTx.length, bufferTx) })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC2(model, frame, response) {
+    handleFC2(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 4) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.readDiscreteInputs) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             try {
@@ -2418,152 +3202,157 @@ class ModbusSlave extends EventEmitter {
                         bufferTx[Math.floor(index / 8)] |= 1 << index % 8;
                     }
                 });
-                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([bufferTx.length]), bufferTx]) })));
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: prependByte(bufferTx.length, bufferTx) })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC3(model, frame, response) {
+    handleFC3(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 4) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.readHoldingRegisters) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             try {
                 const registers = yield model.readHoldingRegisters(address, length);
-                const bufferTx = Buffer.alloc(length * 2);
+                const bufferTx = Buffer.allocUnsafe(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]) })));
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: prependByte(bufferTx.length, bufferTx) })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC4(model, frame, response) {
+    handleFC4(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 4) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.readInputRegisters) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             try {
                 const registers = yield model.readInputRegisters(address, length);
-                const bufferTx = Buffer.alloc(length * 2);
+                const bufferTx = Buffer.allocUnsafe(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]) })));
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: prependByte(bufferTx.length, bufferTx) })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC5(model, frame, response) {
+    handleFC5(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 4) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.writeSingleCoil) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             try {
                 yield model.writeSingleCoil(address, value === COIL_ON);
-                yield response(this.applicationLayer.encode(frame));
+                yield response(appLayer.encode(frame));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC6(model, frame, response) {
+    handleFC6(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 4) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.writeSingleRegister) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             try {
                 yield model.writeSingleRegister(address, value);
-                yield response(this.applicationLayer.encode(frame));
+                yield response(appLayer.encode(frame));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC15(model, frame, response) {
+    handleFC15(appLayer, 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]) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.writeMultipleCoils && !model.writeSingleCoil) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             const value = new Array(length);
@@ -2579,32 +3368,33 @@ class ModbusSlave extends EventEmitter {
                         yield model.writeSingleCoil(address + i, value[i]);
                     }
                 }
-                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: frame.data.subarray(0, 4) })));
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: frame.data.subarray(0, 4) })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC16(model, frame, response) {
+    handleFC16(appLayer, 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]) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.writeMultipleRegisters && !model.writeSingleRegister) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             const value = new Array(length);
@@ -2620,21 +3410,22 @@ class ModbusSlave extends EventEmitter {
                         yield model.writeSingleRegister(address + i, value[i]);
                     }
                 }
-                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: frame.data.subarray(0, 4) })));
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: frame.data.subarray(0, 4) })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC17(model, frame, response) {
+    handleFC17(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 0) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.reportServerId) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
                 return;
             }
             try {
@@ -2642,40 +3433,44 @@ class ModbusSlave extends EventEmitter {
                 const serverIdBytes = serverId;
                 const byteCount = serverIdBytes.length + 1 + additionalData.length;
                 if (byteCount > 255) {
-                    yield this.responseError(frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
+                    yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
                     return;
                 }
                 const allBytes = [...serverIdBytes, runIndicatorStatus ? 0xff : 0x00, ...additionalData];
                 if (allBytes.some((b) => !isUint8(b))) {
-                    yield this.responseError(frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
+                    yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
                     return;
                 }
-                yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat([Buffer.from([byteCount]), Buffer.from(allBytes)]) })));
+                const data = Buffer.allocUnsafe(byteCount + 1);
+                data[0] = byteCount;
+                data.set(allBytes, 1);
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC22(model, frame, response) {
+    handleFC22(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (frame.data.length !== 6) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.maskWriteRegister && !(model.readHoldingRegisters && model.writeSingleRegister)) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             try {
-                yield this.withAddressLock([address], () => __awaiter(this, void 0, void 0, function* () {
+                yield this._withAddressLock([address], () => __awaiter(this, void 0, void 0, function* () {
                     if (model.maskWriteRegister) {
                         yield model.maskWriteRegister(address, andMask, orMask);
                     }
@@ -2684,21 +3479,22 @@ class ModbusSlave extends EventEmitter {
                         yield model.writeSingleRegister(address, (value & andMask) | (orMask & (~andMask & 0xffff)));
                     }
                 }));
-                yield response(this.applicationLayer.encode(frame));
+                yield response(appLayer.encode(frame));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC23(model, frame, response) {
+    handleFC23(appLayer, 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]) {
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                 return;
             }
             if (!model.readHoldingRegisters || (!model.writeMultipleRegisters && !model.writeSingleRegister)) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
                 return;
             }
             const address = {
@@ -2715,11 +3511,11 @@ class ModbusSlave extends EventEmitter {
                 length.write < LIMITS.READ_REGISTERS_MIN ||
                 length.write > LIMITS.RW_REGISTERS_WRITE_MAX ||
                 byteCount !== length.write * 2) {
-                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(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(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                 return;
             }
             const value = new Array(length.write);
@@ -2728,7 +3524,7 @@ class ModbusSlave extends EventEmitter {
             }
             try {
                 const writeAddresses = Array.from({ length: length.write }, (_, i) => address.write + i);
-                yield this.withAddressLock(writeAddresses, () => __awaiter(this, void 0, void 0, function* () {
+                yield this._withAddressLock(writeAddresses, () => __awaiter(this, void 0, void 0, function* () {
                     if (model.writeMultipleRegisters) {
                         yield model.writeMultipleRegisters(address.write, value);
                     }
@@ -2739,18 +3535,18 @@ class ModbusSlave extends EventEmitter {
                     }
                 }));
                 const registers = yield model.readHoldingRegisters(address.read, length.read);
-                const bufferTx = Buffer.alloc(length.read * 2);
+                const bufferTx = Buffer.allocUnsafe(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]) })));
+                yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: prependByte(bufferTx.length, bufferTx) })));
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
             }
         });
     }
-    handleFC43_14(model, frame, response) {
+    handleFC43_14(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             if (frame.data.length === 3) {
                 if (frame.data[0] === MEI_READ_DEVICE_ID && model.readDeviceIdentification) {
@@ -2777,13 +3573,13 @@ class ModbusSlave extends EventEmitter {
                         }
                         case ReadDeviceIDCode.SPECIFIC_ACCESS: {
                             if (objectID > 0x06 && objectID < 0x80) {
-                                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                                 return;
                             }
                             break;
                         }
                         default: {
-                            yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
+                            yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
                             return;
                         }
                     }
@@ -2803,7 +3599,7 @@ class ModbusSlave extends EventEmitter {
                         }
                         if (!objects.has(objectID)) {
                             if (readDeviceIDCode === ReadDeviceIDCode.SPECIFIC_ACCESS) {
-                                yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
+                                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
                                 return;
                             }
                             objectID = 0x00;
@@ -2811,7 +3607,7 @@ class ModbusSlave extends EventEmitter {
                         let maxId = 0;
                         for (const id of objects.keys()) {
                             if ((id >= 0x07 && id <= 0x7f) || id > 0xff) {
-                                yield this.responseError(frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
+                                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
                                 return;
                             }
                             if (id > maxId) {
@@ -2828,97 +3624,104 @@ class ModbusSlave extends EventEmitter {
                             }
                             const byteLength = Buffer.byteLength(value);
                             if (byteLength > 245) {
-                                yield this.responseError(frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
+                                yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
                                 return;
                             }
                             if (lastID !== 0) {
                                 continue;
                             }
                             if (byteLength + 2 > 253 - totalLength) {
-                                if (lastID === 0) {
-                                    lastID = id;
-                                }
+                                lastID = id;
                             }
                             else {
                                 totalLength += byteLength + 2;
-                                ids.push(id);
+                                ids.push({ id, byteLength });
                                 if (readDeviceIDCode === ReadDeviceIDCode.SPECIFIC_ACCESS) {
                                     break;
                                 }
                             }
                         }
-                        ids.sort((a, b) => a - b);
-                        const parts = [];
-                        parts.push(Buffer.from([MEI_READ_DEVICE_ID, readDeviceIDCode, conformityLevel, lastID === 0 ? 0x00 : 0xff, lastID, ids.length]));
-                        for (const id of ids) {
+                        ids.sort((a, b) => a.id - b.id);
+                        let dataLength = 6;
+                        for (const { byteLength } of ids) {
+                            dataLength += 2 + byteLength;
+                        }
+                        const data = Buffer.allocUnsafe(dataLength);
+                        let offset = 0;
+                        data[offset++] = MEI_READ_DEVICE_ID;
+                        data[offset++] = readDeviceIDCode;
+                        data[offset++] = conformityLevel;
+                        data[offset++] = lastID === 0 ? 0x00 : 0xff;
+                        data[offset++] = lastID;
+                        data[offset++] = ids.length;
+                        for (const { id, byteLength } of ids) {
                             const value = objects.get(id);
-                            parts.push(Buffer.from([id, Buffer.byteLength(value)]));
-                            parts.push(Buffer.from(value));
+                            data[offset++] = id;
+                            data[offset++] = byteLength;
+                            offset += data.write(value, offset);
                         }
-                        yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Buffer.concat(parts) })));
+                        yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data })));
                     }
                     catch (error) {
-                        yield this.responseError(frame, response, error);
+                        yield this.responseError(appLayer, frame, response, error);
                     }
                 }
                 else {
-                    yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                    yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
                 }
             }
         });
     }
-    responseError(frame, response, error) {
+    responseError(appLayer, frame, response, error) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { fc: frame.fc | EXCEPTION_OFFSET, data: Buffer.from([getCodeByError(error)]) })));
+            yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { fc: frame.fc | EXCEPTION_OFFSET, data: Buffer.from([getCodeByError(error)]) })));
         });
     }
-    _drain(key, q) {
+    _drain(appLayer, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (q.processing) {
+            if (q.processing || this._physicalLayer.state !== PhysicalState.OPEN) {
                 return;
             }
             q.processing = true;
             try {
-                while (q.items.length > 0) {
-                    const { frame, response } = q.items.shift();
-                    try {
-                        yield this._processFrame(frame, response);
-                    }
-                    catch (error) {
-                        this.emit('error', error);
+                while (q.frames.length > 0) {
+                    if (this._physicalLayer.state !== PhysicalState.OPEN) {
+                        return;
                     }
+                    const frame = q.frames.shift();
+                    yield this._processFrame(appLayer, frame);
                 }
             }
             finally {
                 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);
-                }
             }
         });
     }
-    _processFrame(frame, _response) {
+    _processFrame(appLayer, frame) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = (data) => __awaiter(this, void 0, void 0, function* () {
-                if (frame.unit === 0x00) {
+                if (frame.unit === 0x00 || this._physicalLayer.state !== PhysicalState.OPEN) {
                     return;
                 }
                 try {
-                    yield _response(data);
+                    yield appLayer.connection.write(data);
+                }
+                catch (_a) {
+                    /* A write failure usually means the connection is already broken; let the connection's close event handle cleanup. */
                 }
-                catch (error) { }
             });
             for (const model of frame.unit === 0x00 ? this.models.values() : [this.models.get(frame.unit)]) {
-                const intercepted = yield this._intercept(model, frame, response);
+                if (this._physicalLayer.state !== PhysicalState.OPEN) {
+                    return;
+                }
+                const intercepted = yield this._intercept(appLayer, model, frame, response);
                 if (!intercepted) {
-                    yield this._handleFC(model, frame, response);
+                    yield this._handleFC(appLayer, model, frame, response);
                 }
             }
         });
     }
-    _intercept(model, frame, response) {
+    _intercept(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!model.interceptor) {
                 return false;
@@ -2926,18 +3729,18 @@ class ModbusSlave extends EventEmitter {
             try {
                 const data = yield model.interceptor(frame.fc, frame.data);
                 if (data !== undefined) {
-                    yield response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data })));
+                    yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data })));
                     return true;
                 }
                 return false;
             }
             catch (error) {
-                yield this.responseError(frame, response, error);
+                yield this.responseError(appLayer, frame, response, error);
                 return true;
             }
         });
     }
-    withAddressLock(addresses, fn) {
+    _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(); });
@@ -2960,55 +3763,55 @@ class ModbusSlave extends EventEmitter {
             }
         });
     }
-    _handleFC(model, frame, response) {
+    _handleFC(appLayer, model, frame, response) {
         return __awaiter(this, void 0, void 0, function* () {
             switch (frame.fc) {
                 case FunctionCode.READ_COILS: {
-                    yield this.handleFC1(model, frame, response);
+                    yield this.handleFC1(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.READ_DISCRETE_INPUTS: {
-                    yield this.handleFC2(model, frame, response);
+                    yield this.handleFC2(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.READ_HOLDING_REGISTERS: {
-                    yield this.handleFC3(model, frame, response);
+                    yield this.handleFC3(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.READ_INPUT_REGISTERS: {
-                    yield this.handleFC4(model, frame, response);
+                    yield this.handleFC4(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.WRITE_SINGLE_COIL: {
-                    yield this.handleFC5(model, frame, response);
+                    yield this.handleFC5(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.WRITE_SINGLE_REGISTER: {
-                    yield this.handleFC6(model, frame, response);
+                    yield this.handleFC6(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.WRITE_MULTIPLE_COILS: {
-                    yield this.handleFC15(model, frame, response);
+                    yield this.handleFC15(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.WRITE_MULTIPLE_REGISTERS: {
-                    yield this.handleFC16(model, frame, response);
+                    yield this.handleFC16(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.REPORT_SERVER_ID: {
-                    yield this.handleFC17(model, frame, response);
+                    yield this.handleFC17(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.MASK_WRITE_REGISTER: {
-                    yield this.handleFC22(model, frame, response);
+                    yield this.handleFC22(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.READ_WRITE_MULTIPLE_REGISTERS: {
-                    yield this.handleFC23(model, frame, response);
+                    yield this.handleFC23(appLayer, model, frame, response);
                     break;
                 }
                 case FunctionCode.READ_DEVICE_IDENTIFICATION: {
-                    yield this.handleFC43_14(model, frame, response);
+                    yield this.handleFC43_14(appLayer, model, frame, response);
                     break;
                 }
                 default: {
@@ -3016,14 +3819,14 @@ class ModbusSlave extends EventEmitter {
                     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 })));
+                            yield response(appLayer.encode(Object.assign(Object.assign({}, frame), { data: responseData })));
                         }
                         catch (error) {
-                            yield this.responseError(frame, response, error);
+                            yield this.responseError(appLayer, frame, response, error);
                         }
                     }
                     else {
-                        yield this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
+                        yield this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
                     }
                     break;
                 }
@@ -3039,50 +3842,66 @@ class ModbusSlave extends EventEmitter {
     }
     addCustomFunctionCode(cfc) {
         this._customFunctionCodes.set(cfc.fc, cfc);
-        this.applicationLayer.addCustomFunctionCode(cfc);
+        for (const appLayer of this._appLayers.keys()) {
+            appLayer.addCustomFunctionCode(cfc);
+        }
     }
     removeCustomFunctionCode(fc) {
         this._customFunctionCodes.delete(fc);
-        this.applicationLayer.removeCustomFunctionCode(fc);
-    }
-    _clean(level) {
-        if (this._cleanLevel === 'destroy') {
-            return;
-        }
-        if (this._cleanLevel === 'close' && level === 'close') {
-            return;
-        }
-        for (const q of this._queues.values()) {
-            q.items = [];
-        }
-        this._queues.clear();
-        this._locks.clear();
-        if (level === 'destroy') {
-            this._customFunctionCodes.clear();
-            this.models.clear();
+        for (const appLayer of this._appLayers.keys()) {
+            appLayer.removeCustomFunctionCode(fc);
+        }
+    }
+    /**
+     * Open the underlying physical layer and begin accepting connections.
+     *
+     * A `ModbusSlave` instance can only be opened once. Once {@link close}
+     * is called — explicitly or because the physical layer disconnected —
+     * the instance is permanently closed and cannot be reopened.
+     * Create a new `ModbusSlave` if a new server is required.
+     */
+    open(...args) {
+        if (this._closePromise) {
+            return Promise.reject(new Error('The port has been permanently closed and CANNOT be reopened'));
         }
-        this._cleanLevel = level;
+        return this._physicalLayer.open(...args);
     }
-    open(...args) {
-        this._cleanLevel = 'none';
-        return this.physicalLayer.open(...args);
+    _close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const fn of this._cleanupFns) {
+                fn();
+            }
+            this._cleanupFns.clear();
+            let err = null;
+            try {
+                yield this._physicalLayer.close();
+            }
+            catch (error) {
+                err = error;
+            }
+            this.removeAllListeners();
+            if (err) {
+                return Promise.reject(err);
+            }
+        });
     }
+    /**
+     * Permanently close the slave and release all resources.
+     *
+     * After calling this method the instance is considered dead:
+     * - No further requests can be processed.
+     * - The instance cannot be reopened via {@link open}.
+     * - All event listeners registered on this slave are removed.
+     */
     close() {
-        if (this._cleanLevel === 'destroy') {
-            return Promise.resolve();
-        }
-        this._clean('close');
-        return this.physicalLayer.close();
-    }
-    destroy() {
-        if (this._cleanLevel === 'destroy') {
-            return Promise.resolve();
-        }
-        this._clean('destroy');
-        this.removeAllListeners();
-        this.applicationLayer.destroy();
-        return this.physicalLayer.destroy();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._closePromise) {
+                return this._closePromise;
+            }
+            this._closePromise = this._close();
+            return this._closePromise;
+        });
     }
 }
 
-export { AbstractApplicationLayer, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusErrorCode, ModbusMaster, ModbusSlave, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer, getCodeByError, getErrorByCode };
+export { AbstractApplicationLayer, AbstractPhysicalConnection, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusMaster, ModbusSlave, PhysicalConnectionState, PhysicalState, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpClientPhysicalLayer, UdpServerPhysicalLayer, createPhysicalLayer, getCodeByError, getErrorByCode };