njs-modbus 3.3.0 → 3.4.0

package/dist/index.mjs

@@ -232,7 +232,7 @@ function checkRange(value, range) {
     return false;
 }
 
-const TABLE = new Uint16Array([
+const CRC_TABLE = new Uint16Array([
     0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01,
     0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0,
     0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581,
@@ -250,23 +250,29 @@ const TABLE = new Uint16Array([
     0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
     0x4040,
 ]);
-function crc(data, start, end) {
+/** CRC-16 (Modbus) over a single contiguous buffer. */
+function crcFixed(data, start, end) {
     let crc = 0xffff;
     for (let index = start; index < end; index++) {
-        crc = TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
+        crc = CRC_TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
     }
     return crc;
 }
-
 /**
- * Returns true when `n` is an integer in the unsigned-byte range [0, 255].
- *
- * Used for byte-level Modbus payload validation (function-code values, raw
- * byte arrays in FC17/FC43 responses) — rejects negative, fractional, NaN,
- * Infinity, and out-of-range values uniformly.
+ * CRC-16 (Modbus) over two contiguous buffer segments.
+ * Computes CRC(head[headOff:headOff+headLen]) followed by CRC(tail[tailOff:tailOff+tailLen]).
  */
-function isUint8(n) {
-    return (n & 0xff) === n;
+function crcDual(head, headOff, headLen, tail, tailOff, tailLen) {
+    let crc = 0xffff;
+    const headEnd = headOff + headLen;
+    for (let i = headOff; i < headEnd; i++) {
+        crc = CRC_TABLE[(crc ^ head[i]) & 0xff] ^ (crc >> 8);
+    }
+    const tailEnd = tailOff + tailLen;
+    for (let i = tailOff; i < tailEnd; i++) {
+        crc = CRC_TABLE[(crc ^ tail[i]) & 0xff] ^ (crc >> 8);
+    }
+    return crc;
 }
 
 function lrc(data, start, end) {
@@ -307,12 +313,12 @@ const RES_TABLE = new Int32Array(256);
     RES_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -517;
     RES_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = -999;
 })();
-function predictRtuFrameLength(buffer, start, end, isResponse) {
+function predictRtuFrameLength(residual, data, residualLen, start, end, isResponse) {
     const len = end - start;
     if (len < 2) {
         return PREDICT_NEED_MORE;
     }
-    const fc = buffer[start + 1];
+    const fc = start + 1 < residualLen ? residual[start + 1] : data[start + 1 - residualLen];
     if (isResponse) {
         if ((fc & EXCEPTION_OFFSET) !== 0) {
             return 5;
@@ -328,16 +334,16 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
                 if (end - start < 8) {
                     return PREDICT_NEED_MORE;
                 }
-                if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
+                if ((start + 2 < residualLen ? residual[start + 2] : data[start + 2 - residualLen]) !== MEI_READ_DEVICE_ID) {
                     return PREDICT_UNKNOWN;
                 }
-                const numObjs = buffer[start + 7];
+                const numObjs = start + 7 < residualLen ? residual[start + 7] : data[start + 7 - residualLen];
                 let cursor = start + 8;
                 for (let i = 0; i < numObjs; i++) {
                     if (end < cursor + 2) {
                         return PREDICT_NEED_MORE;
                     }
-                    cursor += 2 + buffer[cursor + 1];
+                    cursor += 2 + (cursor + 1 < residualLen ? residual[cursor + 1] : data[cursor + 1 - residualLen]);
                 }
                 return cursor - start + 2;
             }
@@ -346,7 +352,7 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
             if (len <= offset) {
                 return PREDICT_NEED_MORE;
             }
-            return (decode & 0xff) + buffer[start + offset];
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
     }
     else {
@@ -360,7 +366,7 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
             if (len <= offset) {
                 return PREDICT_NEED_MORE;
             }
-            return (decode & 0xff) + buffer[start + offset];
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
     }
     return PREDICT_UNKNOWN;
@@ -403,7 +409,12 @@ function resolveOne(value, baudRate, fastBaudMs) {
     if (baudRate === undefined) {
         return undefined;
     }
-    return baudRate > 19200 ? fastBaudMs : Math.ceil(bitsToMs(baudRate, value.value));
+    if (baudRate > 19200) {
+        return fastBaudMs;
+    }
+    const ms = bitsToMs(baudRate, value.value);
+    const trunc = ms | 0;
+    return trunc + (ms > trunc ? 1 : 0);
 }
 /**
  * Resolve Modbus RTU timing parameters from user options into milliseconds.
@@ -420,7 +431,17 @@ function resolveRtuTiming(opts = {}, baudRate) {
     if (intervalBetweenFrames === undefined) {
         // Spec default: t3.5 derived from baudRate, or 0 when neither option nor
         // baudRate were supplied.
-        intervalBetweenFrames = baudRate !== undefined ? (baudRate > 19200 ? 1.75 : Math.ceil(bitsToMs(baudRate, 38.5))) : 0;
+        if (baudRate === undefined) {
+            intervalBetweenFrames = 0;
+        }
+        else if (baudRate > 19200) {
+            intervalBetweenFrames = 1.75;
+        }
+        else {
+            const ms = bitsToMs(baudRate, 38.5);
+            const trunc = ms | 0;
+            intervalBetweenFrames = trunc + (ms > trunc ? 1 : 0);
+        }
     }
     let interCharTimeout = resolveOne(opts.interCharTimeout, baudRate, 0.75);
     if (interCharTimeout === undefined) {
@@ -488,7 +509,9 @@ class TimerHeap {
             this._mode = 'heap';
             for (const [existingId, { handle, deadline }] of this._directTimers) {
                 clearTimeout(handle);
-                const remaining = Math.max(0, Math.ceil(deadline - performance.now()));
+                const diff = deadline - performance.now();
+                const trunc = diff | 0;
+                const remaining = diff > 0 ? trunc + (diff > trunc ? 1 : 0) : 0;
                 if (remaining === 0) {
                     this._onFire(existingId);
                 }
@@ -548,8 +571,10 @@ class TimerHeap {
         if (this._deadlines.length === 0) {
             return;
         }
-        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
-        const safeDelay = Math.min(delay, 2147483647);
+        const diff = this._deadlines[0] - performance.now();
+        const trunc = diff | 0;
+        const delay = diff > 0 ? trunc + (diff > trunc ? 1 : 0) : 0;
+        const safeDelay = delay < 2147483647 ? delay : 2147483647;
         this._timer = setTimeout(this._boundTick, safeDelay);
     }
     _onTick() {
@@ -633,6 +658,9 @@ class SerialPhysicalConnection extends AbstractPhysicalConnection {
     get physicalLayer() {
         return this._physicalLayer;
     }
+    get serialport() {
+        return this._serialport;
+    }
     constructor(physicalLayer, serialport) {
         super();
         this._physicalLayer = physicalLayer;
@@ -641,6 +669,7 @@ class SerialPhysicalConnection extends AbstractPhysicalConnection {
             if (this.state !== PhysicalConnectionState.CONNECTED) {
                 return;
             }
+            this.emit('rx', chunk);
             this.emit('data', chunk);
         };
         serialport.on('data', onData);
@@ -669,7 +698,12 @@ class SerialPhysicalConnection extends AbstractPhysicalConnection {
     }
     write(data, cb) {
         if (this.state === PhysicalConnectionState.CONNECTED) {
-            this._serialport.write(data, cb);
+            this._serialport.write(data, (err) => {
+                if (!err) {
+                    this.emit('tx', data);
+                }
+                cb?.(err);
+            });
         }
         else {
             cb?.(new Error('Connection is not connected'));
@@ -830,6 +864,9 @@ class TcpPhysicalConnection extends AbstractPhysicalConnection {
     get physicalLayer() {
         return this._physicalLayer;
     }
+    get socket() {
+        return this._socket;
+    }
     constructor(physicalLayer, socket) {
         super();
         this._physicalLayer = physicalLayer;
@@ -838,6 +875,7 @@ class TcpPhysicalConnection extends AbstractPhysicalConnection {
             if (this.state !== PhysicalConnectionState.CONNECTED) {
                 return;
             }
+            this.emit('rx', chunk);
             this.emit('data', chunk);
         };
         socket.on('data', onData);
@@ -866,7 +904,12 @@ class TcpPhysicalConnection extends AbstractPhysicalConnection {
     }
     write(data, cb) {
         if (this.state === PhysicalConnectionState.CONNECTED) {
-            this._socket.write(data, cb);
+            this._socket.write(data, (err) => {
+                if (!err) {
+                    this.emit('tx', data);
+                }
+                cb?.(err);
+            });
         }
         else {
             cb?.(new Error('Connection is not connected'));
@@ -1148,6 +1191,9 @@ class UdpClientPhysicalConnection extends AbstractPhysicalConnection {
     get physicalLayer() {
         return this._physicalLayer;
     }
+    get socket() {
+        return this._socket;
+    }
     constructor(physicalLayer, socket) {
         super();
         this._physicalLayer = physicalLayer;
@@ -1156,6 +1202,7 @@ class UdpClientPhysicalConnection extends AbstractPhysicalConnection {
             if (this.state !== PhysicalConnectionState.CONNECTED) {
                 return;
             }
+            this.emit('rx', msg);
             this.emit('data', msg);
         };
         socket.on('message', onMessage);
@@ -1184,7 +1231,12 @@ class UdpClientPhysicalConnection extends AbstractPhysicalConnection {
     }
     write(data, cb) {
         if (this.state === PhysicalConnectionState.CONNECTED) {
-            this._socket.send(data, cb);
+            this._socket.send(data, (err) => {
+                if (!err) {
+                    this.emit('tx', data);
+                }
+                cb?.(err);
+            });
         }
         else {
             cb?.(new Error('Connection is not connected'));
@@ -1324,6 +1376,12 @@ class UdpServerPhysicalConnection extends AbstractPhysicalConnection {
     get physicalLayer() {
         return this._physicalLayer;
     }
+    get socket() {
+        return this._socket;
+    }
+    get remote() {
+        return this._remote;
+    }
     constructor(physicalLayer, socket, remote, idleTimeout, messageEventDelegation) {
         super();
         this._physicalLayer = physicalLayer;
@@ -1342,6 +1400,7 @@ class UdpServerPhysicalConnection extends AbstractPhysicalConnection {
                     }, idleTimeout);
                 }
             }
+            this.emit('rx', msg);
             this.emit('data', msg);
         };
         messageEventDelegation.add(onMessage);
@@ -1354,7 +1413,12 @@ class UdpServerPhysicalConnection extends AbstractPhysicalConnection {
     }
     write(data, cb) {
         if (this.state === PhysicalConnectionState.CONNECTED) {
-            this._socket.send(data, this._remote.port, this._remote.address, cb);
+            this._socket.send(data, this._remote.port, this._remote.address, (err) => {
+                if (!err) {
+                    this.emit('tx', data);
+                }
+                cb?.(err);
+            });
         }
         else {
             cb?.(new Error('Connection is not connected'));
@@ -1557,16 +1621,23 @@ class AbstractApplicationLayer {
     removeCustomFunctionCode(fc) { }
 }
 
-const MAX_FRAME_LENGTH = 256;
+const MAX_FRAME_LENGTH$1 = 256;
 const MIN_FRAME_LENGTH = 4;
 class RtuApplicationLayer extends AbstractApplicationLayer {
     PROTOCOL = 'RTU';
     ROLE;
     _connection;
-    _state;
-    _poolSize;
-    _threePointFiveT;
-    _onePointFiveT;
+    // Stores leftover data between parse rounds
+    _residual = Buffer.alloc(MAX_FRAME_LENGTH$1);
+    _residualLen = 0;
+    _expectedLen = PREDICT_NEED_MORE;
+    _t15Time;
+    _t35Time;
+    _t15Strict;
+    _t15Timer;
+    _t35Timer;
+    // t1.5 cursor: 0 = not triggered; > 0 = virtual index where the gap occurred
+    _t15Marker = 0;
     _customFunctionCodes = new Map();
     _cleanupCbs = [];
     get connection() {
@@ -1576,89 +1647,246 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
         super();
         this.ROLE = role;
         this._connection = connection;
-        const { intervalBetweenFrames, interCharTimeout, poolSize } = options;
-        this._poolSize = poolSize ?? MAX_FRAME_LENGTH * 2;
-        this._state = { pool: Buffer.alloc(this._poolSize), start: 0, end: 0 };
-        this._threePointFiveT = intervalBetweenFrames ?? 0;
-        this._onePointFiveT = interCharTimeout ?? 0;
+        const { intervalBetweenFrames, interCharTimeout, strictTiming } = options;
+        this._t35Time = intervalBetweenFrames ?? 0;
+        this._t15Time = this._t35Time === 0 ? 0 : (interCharTimeout ?? 0);
+        if (this._t35Time < this._t15Time) {
+            throw new Error('t3.5 cannot be less than t1.5');
+        }
+        this._t15Strict = strictTiming ?? false;
+        const isResponse = role === 'MASTER';
+        const timingEnabled = this._t35Time > 0;
         const onData = (data) => {
-            const state = this._state;
-            if (state.t15Expired && state.end > state.start) {
-                this.onFramingError(new Error('Inter-character timeout (t1.5) exceeded'));
-                state.start = 0;
-                state.end = 0;
-            }
-            state.t15Expired = false;
             const dataLen = data.length;
-            const space = state.pool.length - state.end;
-            if (dataLen <= space) {
-                // Fast path: incoming chunk fits the current pool tail; one bulk copy,
-                // no per-iteration bookkeeping. This is the typical case.
-                data.copy(state.pool, state.end);
-                state.end += dataLen;
+            const residualLen = this._residualLen;
+            const totalAvailable = residualLen + dataLen;
+            // ========================================================================
+            // 1. Timing reset: any bus activity unconditionally kills all silence timers
+            // ========================================================================
+            if (timingEnabled) {
+                if (this._t15Timer !== undefined) {
+                    clearTimeout(this._t15Timer);
+                    this._t15Timer = undefined;
+                }
+                if (this._t35Timer !== undefined) {
+                    clearTimeout(this._t35Timer);
+                    this._t35Timer = undefined;
+                }
             }
-            else {
-                // Slow path: incoming chunk does NOT fit the pool's remaining tail
-                // space (not necessarily larger than the whole pool — typically the
-                // pool already holds undrained residue from earlier ticks).
-                // Strategy — drain & absorb in chunks:
-                //   1. Copy as much of `data` as fits the current tail.
-                //   2. When the pool fills mid-chunk, run flushBuffer(false) to emit
-                //      any complete frames and collapse the leftover bytes to offset
-                //      0, which reclaims tail space.
-                //   3. Repeat until `data` is fully ingested.
-                // The mid-chunk flush is NEVER strict — t3.5 has not actually elapsed,
-                // the rest of `data` is still in hand. Only the t3.5 timer callback
-                // below passes strict=true.
-                let dataOffset = 0;
-                let currentState = state;
-                while (dataOffset < dataLen) {
-                    const room = currentState.pool.length - currentState.end;
-                    if (room === 0) {
-                        // Pool full mid-ingest. Try to extract any complete frames and
-                        // reclaim tail space so the rest of `data` has somewhere to go.
-                        this.clearStateTimers();
-                        this.flushBuffer(false);
-                        // flushBuffer may emit; user callbacks could in principle replace
-                        // _state. Re-read to stay correct across that boundary.
-                        currentState = this._state;
-                        if (currentState.pool.length - currentState.end === 0) {
-                            // flushBuffer freed nothing — the entire pool is unparseable
-                            // residue (typically a misconfigured poolSize for the wire's
-                            // frame size). Hard reset; we cannot recover automatically.
-                            this.onFramingError(new Error('Frame buffer exhausted before complete frame received'));
-                            currentState.start = 0;
-                            currentState.end = 0;
-                            currentState.t15Expired = false;
+            // ========================================================================
+            // 2. Fast path: no residual data and the new chunk is exactly one frame
+            // ========================================================================
+            if (residualLen === 0 && dataLen >= MIN_FRAME_LENGTH) {
+                const fc = data[1];
+                let frameLen = PREDICT_NEED_MORE;
+                const cfc = this._customFunctionCodes.size > 0 ? this._customFunctionCodes.get(fc) : undefined;
+                if (cfc) {
+                    const predictor = isResponse ? cfc.predictResponseLength : cfc.predictRequestLength;
+                    frameLen = predictor((idx) => data[idx], dataLen);
+                }
+                else if (isResponse) {
+                    if ((fc & 0x80) !== 0) {
+                        frameLen = 5;
+                    }
+                    else {
+                        const val = RES_TABLE[fc];
+                        if (val > 0) {
+                            frameLen = val;
+                        }
+                        else if (val < 0 && val !== -999) {
+                            const decode = -val;
+                            const offset = decode >> 8;
+                            if (dataLen > offset) {
+                                frameLen = (decode & 0xff) + data[offset];
+                            }
                         }
-                        continue;
                     }
-                    // Copy the next chunk into the freshly-available tail space.
-                    const toCopy = room < dataLen - dataOffset ? room : dataLen - dataOffset;
-                    data.copy(currentState.pool, currentState.end, dataOffset, dataOffset + toCopy);
-                    currentState.end += toCopy;
-                    dataOffset += toCopy;
+                }
+                else {
+                    const val = REQ_TABLE[fc];
+                    if (val > 0) {
+                        frameLen = val;
+                    }
+                    else if (val < 0) {
+                        const decode = -val;
+                        const offset = decode >> 8;
+                        if (dataLen > offset) {
+                            frameLen = (decode & 0xff) + data[offset];
+                        }
+                    }
+                }
+                if (frameLen === dataLen) {
+                    const expectedCrc = data[frameLen - 2] | (data[frameLen - 1] << 8);
+                    // Inline CRC for the hot single-buffer path — local table reference helps V8 IC.
+                    const table = CRC_TABLE;
+                    let crc = 0xffff;
+                    const crcEnd = frameLen - 2;
+                    for (let i = 0; i < crcEnd; i++) {
+                        crc = table[(crc ^ data[i]) & 0xff] ^ (crc >> 8);
+                    }
+                    if (expectedCrc === crc) {
+                        const dropFrame = timingEnabled && this._t15Strict && this._t15Marker > 0;
+                        if (!dropFrame) {
+                            const frame = {
+                                unit: data[0],
+                                fc: data[1],
+                                data: data.subarray(2, frameLen - 2),
+                                buffer: data,
+                            };
+                            this.onFraming(frame);
+                        }
+                        this._expectedLen = PREDICT_NEED_MORE;
+                        this._t15Marker = 0;
+                        return;
+                    }
                 }
             }
-            this.clearStateTimers();
-            const liveState = this._state;
-            if (liveState.end - liveState.start >= MAX_FRAME_LENGTH) {
-                this.flushBuffer(this._threePointFiveT > 0);
-            }
-            else if (this._threePointFiveT) {
-                if (this._onePointFiveT > 0) {
-                    liveState.interCharTimer = setTimeout(() => {
-                        liveState.interCharTimer = undefined;
-                        liveState.t15Expired = true;
-                    }, this._onePointFiveT);
+            // ========================================================================
+            // 3. Extract frames in a loop until no complete frame remains (skip if data length below prediction)
+            // ========================================================================
+            let index = 0;
+            if (!(this._expectedLen > 0 && totalAvailable < this._expectedLen)) {
+                while (index <= totalAvailable - MIN_FRAME_LENGTH) {
+                    const fc = index + 1 < residualLen ? this._residual[index + 1] : data[index + 1 - residualLen];
+                    const cfc = this._customFunctionCodes.get(fc);
+                    let frameLen = PREDICT_NEED_MORE;
+                    if (cfc) {
+                        const predictor = isResponse ? cfc.predictResponseLength : cfc.predictRequestLength;
+                        frameLen = predictor((idx) => {
+                            const pos = index + idx;
+                            return pos < residualLen ? this._residual[pos] : data[pos - residualLen];
+                        }, totalAvailable - index);
+                    }
+                    else {
+                        frameLen = predictRtuFrameLength(this._residual, data, residualLen, index, totalAvailable, isResponse);
+                    }
+                    if (frameLen === PREDICT_UNKNOWN) {
+                        index++;
+                        continue;
+                    }
+                    if (frameLen === PREDICT_NEED_MORE) {
+                        break;
+                    }
+                    if (frameLen > MAX_FRAME_LENGTH$1 || frameLen < MIN_FRAME_LENGTH) {
+                        index++;
+                        continue;
+                    }
+                    if (totalAvailable - index < frameLen) {
+                        this._expectedLen = index + frameLen;
+                        break;
+                    }
+                    const expectedCrc = (index + frameLen - 2 < residualLen ? this._residual[index + frameLen - 2] : data[index + frameLen - 2 - residualLen]) |
+                        ((index + frameLen - 1 < residualLen ? this._residual[index + frameLen - 1] : data[index + frameLen - 1 - residualLen]) << 8);
+                    const crcEnd = index + frameLen - 2;
+                    let actualCrc;
+                    if (crcEnd <= residualLen) {
+                        // Entire CRC range sits in the old residual buffer
+                        actualCrc = crcFixed(this._residual, index, crcEnd);
+                    }
+                    else if (index >= residualLen) {
+                        // Entire CRC range sits in the new data chunk
+                        actualCrc = crcFixed(data, index - residualLen, crcEnd - residualLen);
+                    }
+                    else {
+                        // CRC range spans both buffers
+                        actualCrc = crcDual(this._residual, index, residualLen - index, data, 0, crcEnd - residualLen);
+                    }
+                    if (expectedCrc !== actualCrc) {
+                        index++;
+                        continue;
+                    }
+                    // A complete frame has been received; CRC verification still required
+                    this._expectedLen = PREDICT_NEED_MORE;
+                    const dropFrame = this._t15Strict && this._t15Marker > index && this._t15Marker < index + frameLen;
+                    if (!dropFrame) {
+                        // Build contiguous raw buffer — one alloc, zero-copy subarray for data.
+                        const raw = Buffer.allocUnsafe(frameLen);
+                        if (index + frameLen <= residualLen) {
+                            this._residual.copy(raw, 0, index, index + frameLen);
+                        }
+                        else if (index >= residualLen) {
+                            data.copy(raw, 0, index - residualLen, index - residualLen + frameLen);
+                        }
+                        else {
+                            const headLen = residualLen - index;
+                            this._residual.copy(raw, 0, index, residualLen);
+                            data.copy(raw, headLen, 0, frameLen - headLen);
+                        }
+                        const frame = {
+                            unit: raw[0],
+                            fc: raw[1],
+                            data: raw.subarray(2, frameLen - 2),
+                            buffer: raw,
+                        };
+                        this.onFraming(frame);
+                    }
+                    index += frameLen;
                 }
-                liveState.timer = setTimeout(() => {
-                    this.clearStateTimers();
-                    this.flushBuffer(true);
-                }, this._threePointFiveT);
+            }
+            // ========================================================================
+            // 4. Compact residual buffer and rebuild silence timers
+            // ========================================================================
+            const newFrameStart = index;
+            const finalRestLen = totalAvailable - newFrameStart;
+            if (finalRestLen === 0) {
+                this._residualLen = 0;
+                this._expectedLen = PREDICT_NEED_MORE;
+                this._t15Marker = 0;
             }
             else {
-                this.flushBuffer(false);
+                const keepLen = finalRestLen < MAX_FRAME_LENGTH$1 ? finalRestLen : MAX_FRAME_LENGTH$1;
+                const discardLen = totalAvailable - keepLen;
+                if (discardLen >= residualLen) {
+                    // Kept portion lies entirely within the new `data`
+                    data.copy(this._residual, 0, discardLen - residualLen, dataLen);
+                }
+                else if (discardLen > 0) {
+                    // Kept portion spans both buffers, or physical left-shift truncation occurred
+                    for (let i = 0; i < keepLen; i++) {
+                        this._residual[i] = discardLen + i < residualLen ? this._residual[discardLen + i] : data[discardLen + i - residualLen];
+                    }
+                }
+                else {
+                    // discardLen === 0 (old data not consumed, truncation limit not hit) — simple append
+                    data.copy(this._residual, residualLen, 0, dataLen);
+                }
+                this._residualLen = keepLen;
+                // Unify physical coordinate system translation
+                if (discardLen > 0) {
+                    if (this._expectedLen > 0) {
+                        const newExpectedLen = this._expectedLen - discardLen;
+                        this._expectedLen = newExpectedLen > PREDICT_NEED_MORE ? newExpectedLen : PREDICT_NEED_MORE;
+                    }
+                    if (this._t15Marker > 0) {
+                        const newT15Marker = this._t15Marker - discardLen;
+                        this._t15Marker = newT15Marker > 0 ? newT15Marker : 0;
+                    }
+                }
+                if (timingEnabled) {
+                    let hasErrorEmitted = false;
+                    // Establish t3.5 absolute deadline
+                    this._t35Timer = setTimeout(() => {
+                        this._t35Timer = undefined;
+                        // No complete frame parsed within t3.5: circuit-break, discard all data
+                        this._residualLen = 0;
+                        this._expectedLen = PREDICT_NEED_MORE;
+                        this._t15Marker = 0;
+                        if (!hasErrorEmitted) {
+                            this.onFramingError(new Error('Incomplete frame at t3.5'));
+                        }
+                    }, this._t35Time);
+                    if (this._t15Time > 0) {
+                        // Establish t1.5 inter-character gap monitor
+                        this._t15Timer = setTimeout(() => {
+                            this._t15Timer = undefined;
+                            this._t15Marker = this._residualLen; // Record the residual boundary where the gap occurred
+                            if (this._t15Strict) {
+                                hasErrorEmitted = true;
+                                this.onFramingError(new Error('Inter-character timeout (t1.5) exceeded'));
+                            }
+                        }, this._t15Time);
+                    }
+                }
             }
         };
         connection.on('data', onData);
@@ -1668,150 +1896,33 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                 fn();
             }
             this._cleanupCbs.length = 0;
-            this.clearStateTimers();
+            if (this._t15Timer !== undefined) {
+                clearTimeout(this._t15Timer);
+                this._t15Timer = undefined;
+            }
+            if (this._t35Timer !== undefined) {
+                clearTimeout(this._t35Timer);
+                this._t35Timer = undefined;
+            }
         };
         connection.on('close', onClose);
         this._cleanupCbs.push(() => connection.off('close', onClose));
     }
-    clearStateTimers() {
-        const state = this._state;
-        if (state.timer) {
-            clearTimeout(state.timer);
-            state.timer = undefined;
-        }
-        if (state.interCharTimer) {
-            clearTimeout(state.interCharTimer);
-            state.interCharTimer = undefined;
-        }
-    }
-    /**
-     * Shared handler for every "frame is not yet complete" exit in `flushBuffer`.
-     * Returns `true` when the caller should `return` (strict reset), `false` to
-     * `break` the parse loop. Hot path never reaches here — only error/incomplete
-     * edges. Extracted as a method so it is not recreated on every `flushBuffer`
-     * call.
-     */
-    _handleIncomplete(state, strict) {
-        if (strict) {
-            this.onFramingError(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 true;
-        }
-        if (state.t15Expired) {
-            this.onFramingError(new Error('Inter-character timeout (t1.5) exceeded'));
-            state.start = 0;
-            state.end = 0;
-            state.t15Expired = false;
-        }
-        return false;
-    }
-    flushBuffer(strict) {
-        const state = this._state;
-        const isResponse = this.ROLE === 'MASTER';
-        const pool = state.pool;
-        const customFCs = this._customFunctionCodes;
-        while (state.end - state.start > 0) {
-            const available = state.end - state.start;
-            if (available < MIN_FRAME_LENGTH) {
-                if (this._handleIncomplete(state, strict)) {
-                    return;
-                }
-                break;
-            }
-            const fc = pool[state.start + 1];
-            const cfc = customFCs.get(fc);
-            let expected;
-            if (cfc) {
-                const predictor = isResponse ? cfc.predictResponseLength : cfc.predictRequestLength;
-                const predicted = predictor(pool, state.start, state.end);
-                // Normalize custom predictor's `null` to the std sentinel so both
-                // paths share the same NEED_MORE tail below.
-                expected = predicted ?? PREDICT_NEED_MORE;
-            }
-            else {
-                // Standard FC path. predictRtuFrameLength uses sentinel returns to
-                // avoid per-call object allocation on the decode hot path.
-                expected = predictRtuFrameLength(pool, state.start, state.end, isResponse);
-                if (expected === PREDICT_UNKNOWN) {
-                    this.onFramingError(new Error(`Unknown function code 0x${fc.toString(16).padStart(2, '0')} — register a CustomFunctionCode to frame this FC`));
-                    state.start = 0;
-                    state.end = 0;
-                    return;
-                }
-            }
-            if (expected === PREDICT_NEED_MORE) {
-                if (available >= MAX_FRAME_LENGTH) {
-                    state.start += 1;
-                    continue;
-                }
-                if (this._handleIncomplete(state, strict)) {
-                    return;
-                }
-                break;
-            }
-            if (expected > MAX_FRAME_LENGTH || expected < MIN_FRAME_LENGTH) {
-                this.onFramingError(new Error('Invalid data'));
-                state.start = 0;
-                state.end = 0;
-                return;
-            }
-            if (available < expected) {
-                if (available >= MAX_FRAME_LENGTH) {
-                    state.start += 1;
-                    continue;
-                }
-                if (this._handleIncomplete(state, strict)) {
-                    return;
-                }
-                break;
-            }
-            // CRC check inline: no helper call, no subarray for the CRC body.
-            const crcStart = state.start;
-            const crcEnd = crcStart + expected - 2;
-            const expectedCrc = pool.readUInt16LE(crcEnd);
-            const actualCrc = crc(pool, crcStart, crcEnd);
-            if (expectedCrc !== actualCrc) {
-                if (strict) {
-                    this.onFramingError(new Error('CRC mismatch'));
-                    state.start = 0;
-                    state.end = 0;
-                    state.t15Expired = false;
-                    return;
-                }
-                state.start += 1;
-                continue;
-            }
-            // Frame located. Copy it out of the pool so the emitted buffer remains
-            // valid even if the consumer queues the frame across `onData` ticks.
-            // `Buffer.copyBytesFrom` is a native fast-path (Node 18.19+) — measurably
-            // faster than `Buffer.from(buffer)` for this size.
-            const frameBuf = Buffer.copyBytesFrom(pool, crcStart, expected);
-            state.start += expected;
-            const frame = {
-                unit: frameBuf[0],
-                fc: frameBuf[1],
-                data: frameBuf.subarray(2, expected - 2),
-                buffer: frameBuf,
-            };
-            this.onFraming(frame);
+    flush() {
+        this._residualLen = 0;
+        this._expectedLen = PREDICT_NEED_MORE;
+        this._t15Marker = 0;
+        if (this._t15Timer !== undefined) {
+            clearTimeout(this._t15Timer);
+            this._t15Timer = undefined;
         }
-        if (state.start > 0) {
-            if (state.start < state.end) {
-                state.pool.copy(state.pool, 0, state.start, state.end);
-            }
-            state.end -= state.start;
-            state.start = 0;
+        if (this._t35Timer !== undefined) {
+            clearTimeout(this._t35Timer);
+            this._t35Timer = undefined;
         }
     }
-    flush() {
-        this.clearStateTimers();
-        this._state.start = 0;
-        this._state.end = 0;
-    }
     addCustomFunctionCode(cfc) {
-        if (!isUint8(cfc.fc)) {
+        if ((cfc.fc & 0xff) !== cfc.fc) {
             throw new Error(`fc must be an integer in 0..255, got ${cfc.fc}`);
         }
         this._customFunctionCodes.set(cfc.fc, cfc);
@@ -1834,7 +1945,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             buffer.set(data, 2);
         }
         const crcEnd = buffer.length - 2;
-        const c = crc(buffer, 0, crcEnd);
+        const c = crcFixed(buffer, 0, crcEnd);
         // Little-endian inline write of CRC trailer.
         buffer[crcEnd] = c & 0xff;
         buffer[crcEnd + 1] = (c >>> 8) & 0xff;
@@ -1861,11 +1972,16 @@ for (let i = 0x41; i <= 0x46; i++) {
 for (let i = 0x61; i <= 0x66; i++) {
     HEX_DECODE[i] = i - 0x61 + 10;
 }
+// Strict variant: lowercase hex digits (a-f) are treated as invalid so the
+// hot-path validation loop needs only one table lookup instead of two checks.
+const HEX_DECODE_STRICT = new Uint8Array(HEX_DECODE);
+for (let i = 0x61; i <= 0x66; i++) {
+    HEX_DECODE_STRICT[i] = 0xff;
+}
 const HEX_ENCODE = new Uint8Array('0123456789ABCDEF'.split('').map((c) => c.charCodeAt(0)));
 class AsciiApplicationLayer extends AbstractApplicationLayer {
     PROTOCOL = 'ASCII';
     ROLE;
-    lenientHex;
     _connection;
     _state = { status: 'idle', frame: new Uint8Array(MAX_ASCII_PAYLOAD), frameLen: 0 };
     _cleanupCbs = [];
@@ -1876,23 +1992,30 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         super();
         this.ROLE = role;
         this._connection = connection;
-        this.lenientHex = options.lenientHex ?? false;
-        const lenientHex = this.lenientHex;
-        const isHexChar = (value) => {
-            if (value >= 0x30 && value <= 0x39) {
-                return true;
-            }
-            if (value >= 0x41 && value <= 0x46) {
-                return true;
-            }
-            if (lenientHex && value >= 0x61 && value <= 0x66) {
-                return true;
-            }
-            return false;
-        };
+        const lenientHex = options.lenientHex ?? false;
+        const hexTable = lenientHex ? HEX_DECODE : HEX_DECODE_STRICT;
         const onData = (data) => {
             const state = this._state;
-            for (let i = 0; i < data.length; i++) {
+            const dataLen = data.length;
+            // Fast path: idle state and the chunk is exactly one complete frame
+            // ASCII frame: length >= 9 and always odd (9 + 2n)
+            if (state.status === 'idle' && dataLen >= 9 && dataLen % 2 !== 0) {
+                if (data[0] === CHAR_CODE.COLON && data[dataLen - 2] === CHAR_CODE.CR && data[dataLen - 1] === CHAR_CODE.LF) {
+                    let valid = true;
+                    for (let i = 1; i < dataLen - 2; i++) {
+                        if (hexTable[data[i]] > 15) {
+                            valid = false;
+                            break;
+                        }
+                    }
+                    if (valid) {
+                        const hexView = data.subarray(1, dataLen - 2);
+                        this.framing(hexView, hexView.length, hexTable);
+                        return;
+                    }
+                }
+            }
+            for (let i = 0; i < dataLen; i++) {
                 const value = data[i];
                 switch (state.status) {
                     case 'idle': {
@@ -1914,7 +2037,7 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
                             state.frameLen = 0;
                             this.onFramingError(new Error('Invalid data'));
                         }
-                        else if (!isHexChar(value)) {
+                        else if (hexTable[value] > 15) {
                             state.status = 'idle';
                             state.frameLen = 0;
                             this.onFramingError(new Error('Invalid hex character'));
@@ -1932,7 +2055,7 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
                         else {
                             state.status = 'idle';
                             if (value === CHAR_CODE.LF) {
-                                this.framing(state.frame, state.frameLen);
+                                this.framing(state.frame, state.frameLen, hexTable);
                             }
                         }
                         break;
@@ -1951,7 +2074,7 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         connection.on('close', onClose);
         this._cleanupCbs.push(() => connection.off('close', onClose));
     }
-    framing(hexChars, hexLen) {
+    framing(hexChars, hexLen, hexTable) {
         if (hexLen < 6) {
             this.onFramingError(new Error('Insufficient data length'));
             return;
@@ -1963,10 +2086,10 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         const byteLen = hexLen >> 1;
         // Decode unit and fc directly from the first 4 hex characters —
         // avoids allocating a full decoded buffer just to read two bytes.
-        const unitHi = HEX_DECODE[hexChars[0]];
-        const unitLo = HEX_DECODE[hexChars[1]];
-        const fcHi = HEX_DECODE[hexChars[2]];
-        const fcLo = HEX_DECODE[hexChars[3]];
+        const unitHi = hexTable[hexChars[0]];
+        const unitLo = hexTable[hexChars[1]];
+        const fcHi = hexTable[hexChars[2]];
+        const fcLo = hexTable[hexChars[3]];
         if (unitHi === 0xff || unitLo === 0xff || fcHi === 0xff || fcLo === 0xff) {
             this.onFramingError(new Error('Invalid hex character'));
             return;
@@ -1974,33 +2097,32 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         const unit = (unitHi << 4) | unitLo;
         const fc = (fcHi << 4) | fcLo;
         // Decode LRC from the last 2 hex characters.
-        const lrcHi = HEX_DECODE[hexChars[hexLen - 2]];
-        const lrcLo = HEX_DECODE[hexChars[hexLen - 1]];
+        const lrcHi = hexTable[hexChars[hexLen - 2]];
+        const lrcLo = hexTable[hexChars[hexLen - 1]];
         if (lrcHi === 0xff || lrcLo === 0xff) {
             this.onFramingError(new Error('Invalid hex character'));
             return;
         }
         const lrcIn = (lrcHi << 4) | lrcLo;
-        // Decode data portion (between unit/fc and lrc) into a right-sized buffer.
+        // Decode data portion (between unit/fc and lrc) into a right-sized buffer,
+        // while simultaneously accumulating the LRC sum — one pass instead of two.
         // dataLen may be 0 for a frame that is only unit + fc + lrc.
         const dataLen = byteLen - 3;
         const data = Buffer.allocUnsafe(dataLen);
         let hexOff = 4;
+        let sum = unit + fc;
         for (let i = 0; i < dataLen; i++) {
-            const hi = HEX_DECODE[hexChars[hexOff]];
-            const lo = HEX_DECODE[hexChars[hexOff + 1]];
+            const hi = hexTable[hexChars[hexOff]];
+            const lo = hexTable[hexChars[hexOff + 1]];
             if (hi === 0xff || lo === 0xff) {
                 this.onFramingError(new Error('Invalid hex character'));
                 return;
             }
-            data[i] = (hi << 4) | lo;
+            const byte = (hi << 4) | lo;
+            data[i] = byte;
+            sum += byte;
             hexOff += 2;
         }
-        // Compute LRC over unit + fc + data.
-        let sum = unit + fc;
-        for (let i = 0; i < dataLen; i++) {
-            sum += data[i];
-        }
         const lrcComputed = (~sum + 1) & 0xff;
         if (lrcIn !== lrcComputed) {
             this.onFramingError(new Error('LRC check failed'));
@@ -2041,13 +2163,15 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
     }
 }
 
-const MAX_TCP_FRAME = 260;
+const MAX_FRAME_LENGTH = 260;
 class TcpApplicationLayer extends AbstractApplicationLayer {
     PROTOCOL = 'TCP';
     ROLE;
     _connection;
     _transactionId = 1;
-    _buffer = EMPTY_BUFFER;
+    _residual = Buffer.alloc(MAX_FRAME_LENGTH);
+    _residualLen = 0;
+    _expectedLen = PREDICT_NEED_MORE;
     _cleanupCbs = [];
     get connection() {
         return this._connection;
@@ -2057,51 +2181,108 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
         this.ROLE = role;
         this._connection = connection;
         const onData = (data) => {
-            // Fast path: _buffer is empty and data is a single, complete frame.
-            // This avoids the tryExtract subarray allocations + while loop
-            // for the overwhelmingly common case (one frame per TCP packet).
-            if (this._buffer.length === 0 && data.length >= 8) {
-                const length = (data[4] << 8) | data[5]; // inline BE read
-                const total = 6 + length;
-                if (data[2] === 0 && data[3] === 0 && total <= MAX_TCP_FRAME && length >= 2 && data.length === total) {
-                    this.processFrame(data);
-                    return;
+            const dataLen = data.length;
+            const residualLen = this._residualLen;
+            const totalAvailable = residualLen + dataLen;
+            // Fast path: no residual data and the new chunk is exactly one frame
+            if (residualLen === 0 && dataLen >= 8) {
+                if (data[2] === 0 && data[3] === 0) {
+                    const length = (data[4] << 8) | data[5];
+                    const frameLen = 6 + length;
+                    if (frameLen === dataLen && frameLen <= MAX_FRAME_LENGTH && length >= 2) {
+                        const frame = {
+                            transaction: (data[0] << 8) | data[1],
+                            unit: data[6],
+                            fc: data[7],
+                            data: data.subarray(8),
+                            buffer: data,
+                        };
+                        this.onFraming(frame);
+                        this._expectedLen = PREDICT_NEED_MORE;
+                        return;
+                    }
                 }
             }
-            let buffer = this._buffer;
-            if (buffer.length === 0) {
-                buffer = data;
+            let index = 0;
+            if (!(this._expectedLen > 0 && totalAvailable < this._expectedLen)) {
+                while (index <= totalAvailable - 6) {
+                    // Validate MBAP protocol ID (bytes 2-3 must be 0x0000)
+                    if ((index + 2 < residualLen ? this._residual[index + 2] : data[index + 2 - residualLen]) !== 0 ||
+                        (index + 3 < residualLen ? this._residual[index + 3] : data[index + 3 - residualLen]) !== 0) {
+                        this.onFramingError(new Error('Invalid data'));
+                        this._residualLen = 0;
+                        this._expectedLen = PREDICT_NEED_MORE;
+                        return;
+                    }
+                    const length = ((index + 4 < residualLen ? this._residual[index + 4] : data[index + 4 - residualLen]) << 8) |
+                        (index + 5 < residualLen ? this._residual[index + 5] : data[index + 5 - residualLen]);
+                    const frameLen = 6 + length;
+                    if (frameLen > MAX_FRAME_LENGTH || length < 2) {
+                        this.onFramingError(new Error('Invalid data'));
+                        this._residualLen = 0;
+                        this._expectedLen = PREDICT_NEED_MORE;
+                        return;
+                    }
+                    if (totalAvailable - index < frameLen) {
+                        this._expectedLen = index + frameLen;
+                        break;
+                    }
+                    // A complete frame has been received
+                    this._expectedLen = PREDICT_NEED_MORE;
+                    const raw = Buffer.allocUnsafe(frameLen);
+                    if (index + frameLen <= residualLen) {
+                        this._residual.copy(raw, 0, index, index + frameLen);
+                    }
+                    else if (index >= residualLen) {
+                        data.copy(raw, 0, index - residualLen, index - residualLen + frameLen);
+                    }
+                    else {
+                        const headLen = residualLen - index;
+                        this._residual.copy(raw, 0, index, residualLen);
+                        data.copy(raw, headLen, 0, frameLen - headLen);
+                    }
+                    const frame = {
+                        transaction: (raw[0] << 8) | raw[1],
+                        unit: raw[6],
+                        fc: raw[7],
+                        data: raw.subarray(8),
+                        buffer: raw,
+                    };
+                    this.onFraming(frame);
+                    index += frameLen;
+                }
             }
-            else if (data.length > 0) {
-                buffer = Buffer.concat([buffer, data]);
+            const newFrameStart = index;
+            const finalRestLen = totalAvailable - newFrameStart;
+            if (finalRestLen === 0) {
+                this._residualLen = 0;
+                this._expectedLen = PREDICT_NEED_MORE;
             }
-            while (buffer.length > 0) {
-                const result = this.tryExtract(buffer);
-                if (result.kind === 'frame') {
-                    this.processFrame(result.frame);
-                    buffer = result.rest;
+            else {
+                const keepLen = finalRestLen < MAX_FRAME_LENGTH ? finalRestLen : MAX_FRAME_LENGTH;
+                const discardLen = totalAvailable - keepLen;
+                if (discardLen >= residualLen) {
+                    // Kept portion lies entirely within the new `data`
+                    data.copy(this._residual, 0, discardLen - residualLen, dataLen);
                 }
-                else if (result.kind === 'insufficient') {
-                    break;
+                else if (discardLen > 0) {
+                    // Kept portion spans both buffers, or physical left-shift truncation occurred
+                    for (let i = 0; i < keepLen; i++) {
+                        this._residual[i] = discardLen + i < residualLen ? this._residual[discardLen + i] : data[discardLen + i - residualLen];
+                    }
                 }
                 else {
-                    this.onFramingError(result.error);
-                    buffer = EMPTY_BUFFER;
-                    break;
+                    // discardLen === 0 (old data not consumed, truncation limit not hit) — simple append
+                    data.copy(this._residual, residualLen, 0, dataLen);
+                }
+                this._residualLen = keepLen;
+                // Unify physical coordinate system translation
+                if (discardLen > 0) {
+                    if (this._expectedLen > 0) {
+                        const newExpectedLen = this._expectedLen - discardLen;
+                        this._expectedLen = newExpectedLen > PREDICT_NEED_MORE ? newExpectedLen : PREDICT_NEED_MORE;
+                    }
                 }
-            }
-            if (buffer.length === 0) {
-                this._buffer = EMPTY_BUFFER;
-            }
-            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).
-                // `Buffer.copyBytesFrom` is a native fast-path — one C++ memcpy
-                // vs allocUnsafe + JS-level copy.
-                this._buffer = Buffer.copyBytesFrom(buffer);
-            }
-            else {
-                this._buffer = buffer;
             }
         };
         connection.on('data', onData);
@@ -2115,38 +2296,9 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
         connection.on('close', onClose);
         this._cleanupCbs.push(() => 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 Error('Invalid data') };
-        }
-        const length = (buffer[4] << 8) | buffer[5]; // inline BE read
-        const total = 6 + length;
-        if (total > MAX_TCP_FRAME || length < 2) {
-            return { kind: 'error', error: new Error('Invalid data') };
-        }
-        if (buffer.length < total) {
-            return { kind: 'insufficient' };
-        }
-        return { kind: 'frame', frame: buffer.subarray(0, total), rest: total === buffer.length ? EMPTY_BUFFER : buffer.subarray(total) };
-    }
-    processFrame(buffer) {
-        const frame = {
-            // Inline 16-bit BE read — direct typed-array loads skip readUInt16BE's
-            // argument coercion + bounds check. Symmetric to the header writes in
-            // encode() below. Hits on every received TCP frame.
-            transaction: (buffer[0] << 8) | buffer[1],
-            unit: buffer[6],
-            fc: buffer[7],
-            data: buffer.subarray(8),
-            buffer,
-        };
-        this.onFraming(frame);
-    }
     flush() {
-        this._buffer = EMPTY_BUFFER;
+        this._residualLen = 0;
+        this._expectedLen = PREDICT_NEED_MORE;
     }
     encode(unit, fc, data, transaction) {
         const buffer = Buffer.allocUnsafe(data.length + 8);
@@ -2313,6 +2465,7 @@ class ModbusMaster extends EventEmitter {
                 appLayer.onFraming = NOOP;
             };
             const onFraming = (frame) => {
+                this.emit('framing', frame, connection);
                 this._masterSession.handleFrame(frame);
             };
             appLayer.onFraming = onFraming;
@@ -2321,17 +2474,34 @@ class ModbusMaster extends EventEmitter {
                 appLayer.onFramingError = NOOP;
             };
             const onFramingError = (error) => {
+                this.emit('framingError', error, connection);
                 this._masterSession.handleError(error);
             };
             appLayer.onFramingError = onFramingError;
             this._cleanupFns.add(cleanupFramingError);
+            const cleanupTx = () => connection.off('tx', onTx);
+            const onTx = (buffer) => {
+                this.emit('tx', buffer, connection);
+            };
+            connection.on('tx', onTx);
+            this._cleanupFns.add(cleanupTx);
+            const cleanupRx = () => connection.off('rx', onRx);
+            const onRx = (buffer) => {
+                this.emit('rx', buffer, connection);
+            };
+            connection.on('rx', onRx);
+            this._cleanupFns.add(cleanupRx);
             const cleanupClose = () => connection.off('close', onClose);
             const onClose = () => {
                 cleanupFraming();
                 cleanupFramingError();
+                cleanupTx();
+                cleanupRx();
                 cleanupClose();
                 this._cleanupFns.delete(cleanupFraming);
                 this._cleanupFns.delete(cleanupFramingError);
+                this._cleanupFns.delete(cleanupTx);
+                this._cleanupFns.delete(cleanupRx);
                 this._cleanupFns.delete(cleanupClose);
             };
             connection.on('close', onClose);
@@ -2371,7 +2541,7 @@ class ModbusMaster extends EventEmitter {
             return new RtuApplicationLayer('MASTER', connection, {
                 intervalBetweenFrames,
                 interCharTimeout,
-                poolSize: this._protocol.opts?.poolSize,
+                strictTiming: this._protocol.opts?.strictTiming,
             });
         }
         if (this._protocol.type === 'TCP') {
@@ -2547,10 +2717,8 @@ class ModbusMaster extends EventEmitter {
         });
     }
     writeFC1Or2(unit, fc, address, length, timeout) {
-        const byteCount = Math.ceil(length / 8);
+        const byteCount = (length + 7) >> 3;
         const bufferTx = Buffer.allocUnsafe(4);
-        // Inline big-endian writes — direct typed-array stores skip the argument
-        // validation + bounds checks that `writeUInt16BE` runs on each call.
         bufferTx[0] = (address >>> 8) & 0xff;
         bufferTx[1] = address & 0xff;
         bufferTx[2] = (length >>> 8) & 0xff;
@@ -2567,46 +2735,44 @@ class ModbusMaster extends EventEmitter {
                 }
                 try {
                     validateByteCountResponse(frame, unit, fc, byteCount);
-                    const data = new Array(length);
+                    const data = new Uint8Array(length);
                     let byteIdx = 1;
                     let outIdx = 0;
                     const fullBytes = length >> 3;
                     for (let b = 0; b < fullBytes; b++) {
                         const byte = frame.data[byteIdx++];
-                        data[outIdx++] = (byte & 0x01) > 0;
-                        data[outIdx++] = (byte & 0x02) > 0;
-                        data[outIdx++] = (byte & 0x04) > 0;
-                        data[outIdx++] = (byte & 0x08) > 0;
-                        data[outIdx++] = (byte & 0x10) > 0;
-                        data[outIdx++] = (byte & 0x20) > 0;
-                        data[outIdx++] = (byte & 0x40) > 0;
-                        data[outIdx++] = (byte & 0x80) > 0;
+                        data[outIdx++] = byte & 0x01;
+                        data[outIdx++] = (byte >>> 1) & 0x01;
+                        data[outIdx++] = (byte >>> 2) & 0x01;
+                        data[outIdx++] = (byte >>> 3) & 0x01;
+                        data[outIdx++] = (byte >>> 4) & 0x01;
+                        data[outIdx++] = (byte >>> 5) & 0x01;
+                        data[outIdx++] = (byte >>> 6) & 0x01;
+                        data[outIdx++] = (byte >>> 7) & 0x01;
                     }
                     const rem = length & 7;
                     if (rem) {
                         const byte = frame.data[byteIdx];
-                        data[outIdx++] = (byte & 0x01) > 0;
+                        data[outIdx++] = byte & 0x01;
                         if (rem > 1) {
-                            data[outIdx++] = (byte & 0x02) > 0;
+                            data[outIdx++] = (byte >>> 1) & 0x01;
                         }
                         if (rem > 2) {
-                            data[outIdx++] = (byte & 0x04) > 0;
+                            data[outIdx++] = (byte >>> 2) & 0x01;
                         }
                         if (rem > 3) {
-                            data[outIdx++] = (byte & 0x08) > 0;
+                            data[outIdx++] = (byte >>> 3) & 0x01;
                         }
                         if (rem > 4) {
-                            data[outIdx++] = (byte & 0x10) > 0;
+                            data[outIdx++] = (byte >>> 4) & 0x01;
                         }
                         if (rem > 5) {
-                            data[outIdx++] = (byte & 0x20) > 0;
+                            data[outIdx++] = (byte >>> 5) & 0x01;
                         }
                         if (rem > 6) {
-                            data[outIdx++] = (byte & 0x40) > 0;
+                            data[outIdx++] = (byte >>> 6) & 0x01;
                         }
                     }
-                    // Mutate the frame in place rather than spread-copying — `frame` is freshly
-                    // allocated per request and not retained anywhere else.
                     frame.data = data;
                     resolve(frame);
                 }
@@ -2677,7 +2843,7 @@ class ModbusMaster extends EventEmitter {
     writeSingleCoil(unit, address, value, timeout = this.timeout) {
         const fc = FunctionCode.WRITE_SINGLE_COIL;
         const bufferTx = Buffer.allocUnsafe(4);
-        const coilValue = value ? COIL_ON : COIL_OFF;
+        const coilValue = value === 1 ? COIL_ON : COIL_OFF;
         // Inline big-endian writes — see writeFC1Or2 for the rationale.
         bufferTx[0] = (address >>> 8) & 0xff;
         bufferTx[1] = address & 0xff;
@@ -2737,26 +2903,51 @@ class ModbusMaster extends EventEmitter {
     writeFC15;
     writeMultipleCoils(unit, address, value, timeout = this.timeout) {
         const fc = FunctionCode.WRITE_MULTIPLE_COILS;
-        const byteCount = Math.ceil(value.length / 8);
-        const bufferTx = Buffer.alloc(5 + byteCount);
+        const len = value.length;
+        const byteCount = (len + 7) >> 3;
+        const bufferTx = Buffer.allocUnsafe(5 + byteCount);
         // Inline big-endian writes — see writeFC1Or2 for the rationale.
         bufferTx[0] = (address >>> 8) & 0xff;
         bufferTx[1] = address & 0xff;
-        bufferTx[2] = (value.length >>> 8) & 0xff;
-        bufferTx[3] = value.length & 0xff;
+        bufferTx[2] = (len >>> 8) & 0xff;
+        bufferTx[3] = len & 0xff;
         bufferTx[4] = byteCount;
-        let acc = 0;
         let out = 5;
-        for (let i = 0; i < value.length; i++) {
-            if (value[i]) {
-                acc |= 1 << (i & 7);
+        const fullBytes = len >> 3;
+        for (let b = 0; b < fullBytes; b++) {
+            const base = b << 3;
+            bufferTx[out++] =
+                (value[base] & 1) |
+                    ((value[base + 1] & 1) << 1) |
+                    ((value[base + 2] & 1) << 2) |
+                    ((value[base + 3] & 1) << 3) |
+                    ((value[base + 4] & 1) << 4) |
+                    ((value[base + 5] & 1) << 5) |
+                    ((value[base + 6] & 1) << 6) |
+                    ((value[base + 7] & 1) << 7);
+        }
+        const rem = len & 7;
+        if (rem) {
+            const base = fullBytes << 3;
+            let acc = value[base] & 1;
+            if (rem > 1) {
+                acc |= (value[base + 1] & 1) << 1;
+            }
+            if (rem > 2) {
+                acc |= (value[base + 2] & 1) << 2;
             }
-            if ((i & 7) === 7) {
-                bufferTx[out++] = acc;
-                acc = 0;
+            if (rem > 3) {
+                acc |= (value[base + 3] & 1) << 3;
+            }
+            if (rem > 4) {
+                acc |= (value[base + 4] & 1) << 4;
+            }
+            if (rem > 5) {
+                acc |= (value[base + 5] & 1) << 5;
+            }
+            if (rem > 6) {
+                acc |= (value[base + 6] & 1) << 6;
             }
-        }
-        if ((value.length & 7) !== 0) {
             bufferTx[out] = acc;
         }
         return new Promise((resolve, reject) => {
@@ -2844,7 +3035,7 @@ class ModbusMaster extends EventEmitter {
                     frame.data = {
                         serverId: Array.from(frame.data.subarray(1, runStatusIndex)),
                         runIndicatorStatus: frame.data[runStatusIndex] === 0xff,
-                        additionalData: Array.from(frame.data.subarray(runStatusIndex + 1)),
+                        additionalData: frame.data.subarray(runStatusIndex + 1),
                     };
                     resolve(frame);
                 }
@@ -3150,6 +3341,7 @@ class ModbusSlave extends EventEmitter {
                 appLayer.onFraming = NOOP;
             };
             const onFraming = (frame) => {
+                this.emit('framing', frame, connection);
                 if (this._physicalLayer.state !== PhysicalState.OPEN) {
                     return;
                 }
@@ -3165,11 +3357,37 @@ class ModbusSlave extends EventEmitter {
             };
             appLayer.onFraming = onFraming;
             this._cleanupFns.add(cleanupFraming);
+            const cleanupFramingError = () => {
+                appLayer.onFramingError = NOOP;
+            };
+            const onFramingError = (error) => {
+                this.emit('framingError', error, connection);
+            };
+            appLayer.onFramingError = onFramingError;
+            this._cleanupFns.add(cleanupFramingError);
+            const cleanupTx = () => connection.off('tx', onTx);
+            const onTx = (buffer) => {
+                this.emit('tx', buffer, connection);
+            };
+            connection.on('tx', onTx);
+            this._cleanupFns.add(cleanupTx);
+            const cleanupRx = () => connection.off('rx', onRx);
+            const onRx = (buffer) => {
+                this.emit('rx', buffer, connection);
+            };
+            connection.on('rx', onRx);
+            this._cleanupFns.add(cleanupRx);
             const cleanupClose = () => connection.off('close', onClose);
             const onClose = () => {
                 cleanupFraming();
+                cleanupFramingError();
+                cleanupTx();
+                cleanupRx();
                 cleanupClose();
                 this._cleanupFns.delete(cleanupFraming);
+                this._cleanupFns.delete(cleanupFramingError);
+                this._cleanupFns.delete(cleanupTx);
+                this._cleanupFns.delete(cleanupRx);
                 this._cleanupFns.delete(cleanupClose);
                 this._appLayers.delete(appLayer);
             };
@@ -3198,7 +3416,7 @@ class ModbusSlave extends EventEmitter {
             return new RtuApplicationLayer('SLAVE', connection, {
                 intervalBetweenFrames,
                 interCharTimeout,
-                poolSize: this._protocol.opts?.poolSize,
+                strictTiming: this._protocol.opts?.strictTiming,
             });
         }
         if (this._protocol.type === 'TCP') {
@@ -3230,67 +3448,43 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            if (coils instanceof Uint8Array) {
-                // Branchless fast path — `coils[i]` is already 0/1, no boolean
-                // coercion or conditional jumps. At max payload (2000 coils) this
-                // avoids 2000 branch-predictor slots and boolean-to-number casts.
-                let out = 1;
-                const fullBytes = length >> 3;
-                for (let i = 0; i < fullBytes; i++) {
-                    const base = i << 3;
-                    pdu[out++] =
-                        (coils[base] & 1) |
-                            ((coils[base + 1] & 1) << 1) |
-                            ((coils[base + 2] & 1) << 2) |
-                            ((coils[base + 3] & 1) << 3) |
-                            ((coils[base + 4] & 1) << 4) |
-                            ((coils[base + 5] & 1) << 5) |
-                            ((coils[base + 6] & 1) << 6) |
-                            ((coils[base + 7] & 1) << 7);
+            let out = 1;
+            const fullBytes = length >> 3;
+            for (let i = 0; i < fullBytes; i++) {
+                const base = i << 3;
+                pdu[out++] =
+                    (coils[base] & 1) |
+                        ((coils[base + 1] & 1) << 1) |
+                        ((coils[base + 2] & 1) << 2) |
+                        ((coils[base + 3] & 1) << 3) |
+                        ((coils[base + 4] & 1) << 4) |
+                        ((coils[base + 5] & 1) << 5) |
+                        ((coils[base + 6] & 1) << 6) |
+                        ((coils[base + 7] & 1) << 7);
+            }
+            const rem = length & 7;
+            if (rem) {
+                const base = fullBytes << 3;
+                let acc = coils[base] & 1;
+                if (rem > 1) {
+                    acc |= (coils[base + 1] & 1) << 1;
                 }
-                const rem = length & 7;
-                if (rem) {
-                    const base = fullBytes << 3;
-                    let acc = coils[base] & 1;
-                    if (rem > 1) {
-                        acc |= (coils[base + 1] & 1) << 1;
-                    }
-                    if (rem > 2) {
-                        acc |= (coils[base + 2] & 1) << 2;
-                    }
-                    if (rem > 3) {
-                        acc |= (coils[base + 3] & 1) << 3;
-                    }
-                    if (rem > 4) {
-                        acc |= (coils[base + 4] & 1) << 4;
-                    }
-                    if (rem > 5) {
-                        acc |= (coils[base + 5] & 1) << 5;
-                    }
-                    if (rem > 6) {
-                        acc |= (coils[base + 6] & 1) << 6;
-                    }
-                    pdu[out] = acc;
+                if (rem > 2) {
+                    acc |= (coils[base + 2] & 1) << 2;
                 }
-            }
-            else {
-                // Fallback for boolean[] — accumulate into `acc` and write a full byte
-                // once each lane is finished. Saves N `|=` read-modify-writes on the
-                // output buffer.
-                let acc = 0;
-                let out = 1;
-                for (let i = 0; i < length; i++) {
-                    if (coils[i]) {
-                        acc |= 1 << (i & 7);
-                    }
-                    if ((i & 7) === 7) {
-                        pdu[out++] = acc;
-                        acc = 0;
-                    }
+                if (rem > 3) {
+                    acc |= (coils[base + 3] & 1) << 3;
+                }
+                if (rem > 4) {
+                    acc |= (coils[base + 4] & 1) << 4;
                 }
-                if ((length & 7) !== 0) {
-                    pdu[out] = acc;
+                if (rem > 5) {
+                    acc |= (coils[base + 5] & 1) << 5;
                 }
+                if (rem > 6) {
+                    acc |= (coils[base + 6] & 1) << 6;
+                }
+                pdu[out] = acc;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -3322,61 +3516,43 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            if (discreteInputs instanceof Uint8Array) {
-                let out = 1;
-                const fullBytes = length >> 3;
-                for (let i = 0; i < fullBytes; i++) {
-                    const base = i << 3;
-                    pdu[out++] =
-                        (discreteInputs[base] & 1) |
-                            ((discreteInputs[base + 1] & 1) << 1) |
-                            ((discreteInputs[base + 2] & 1) << 2) |
-                            ((discreteInputs[base + 3] & 1) << 3) |
-                            ((discreteInputs[base + 4] & 1) << 4) |
-                            ((discreteInputs[base + 5] & 1) << 5) |
-                            ((discreteInputs[base + 6] & 1) << 6) |
-                            ((discreteInputs[base + 7] & 1) << 7);
+            let out = 1;
+            const fullBytes = length >> 3;
+            for (let i = 0; i < fullBytes; i++) {
+                const base = i << 3;
+                pdu[out++] =
+                    (discreteInputs[base] & 1) |
+                        ((discreteInputs[base + 1] & 1) << 1) |
+                        ((discreteInputs[base + 2] & 1) << 2) |
+                        ((discreteInputs[base + 3] & 1) << 3) |
+                        ((discreteInputs[base + 4] & 1) << 4) |
+                        ((discreteInputs[base + 5] & 1) << 5) |
+                        ((discreteInputs[base + 6] & 1) << 6) |
+                        ((discreteInputs[base + 7] & 1) << 7);
+            }
+            const rem = length & 7;
+            if (rem) {
+                const base = fullBytes << 3;
+                let acc = discreteInputs[base] & 1;
+                if (rem > 1) {
+                    acc |= (discreteInputs[base + 1] & 1) << 1;
                 }
-                const rem = length & 7;
-                if (rem) {
-                    const base = fullBytes << 3;
-                    let acc = discreteInputs[base] & 1;
-                    if (rem > 1) {
-                        acc |= (discreteInputs[base + 1] & 1) << 1;
-                    }
-                    if (rem > 2) {
-                        acc |= (discreteInputs[base + 2] & 1) << 2;
-                    }
-                    if (rem > 3) {
-                        acc |= (discreteInputs[base + 3] & 1) << 3;
-                    }
-                    if (rem > 4) {
-                        acc |= (discreteInputs[base + 4] & 1) << 4;
-                    }
-                    if (rem > 5) {
-                        acc |= (discreteInputs[base + 5] & 1) << 5;
-                    }
-                    if (rem > 6) {
-                        acc |= (discreteInputs[base + 6] & 1) << 6;
-                    }
-                    pdu[out] = acc;
+                if (rem > 2) {
+                    acc |= (discreteInputs[base + 2] & 1) << 2;
                 }
-            }
-            else {
-                let acc = 0;
-                let out = 1;
-                for (let i = 0; i < length; i++) {
-                    if (discreteInputs[i]) {
-                        acc |= 1 << (i & 7);
-                    }
-                    if ((i & 7) === 7) {
-                        pdu[out++] = acc;
-                        acc = 0;
-                    }
+                if (rem > 3) {
+                    acc |= (discreteInputs[base + 3] & 1) << 3;
                 }
-                if ((length & 7) !== 0) {
-                    pdu[out] = acc;
+                if (rem > 4) {
+                    acc |= (discreteInputs[base + 4] & 1) << 4;
                 }
+                if (rem > 5) {
+                    acc |= (discreteInputs[base + 5] & 1) << 5;
+                }
+                if (rem > 6) {
+                    acc |= (discreteInputs[base + 6] & 1) << 6;
+                }
+                pdu[out] = acc;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -3480,7 +3656,7 @@ class ModbusSlave extends EventEmitter {
             return;
         }
         try {
-            await model.writeSingleCoil(address, value === COIL_ON);
+            await model.writeSingleCoil(address, value === COIL_ON ? 1 : 0);
             await response(appLayer.encode(frame.unit, frame.fc, frame.data, frame.transaction));
         }
         catch (error) {
@@ -3522,7 +3698,7 @@ class ModbusSlave extends EventEmitter {
         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)) {
+        if (length < LIMITS.READ_COILS_MIN || length > LIMITS.WRITE_COILS_MAX || byteCount !== (length + 7) >> 3) {
             await this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
             return;
         }
@@ -3530,42 +3706,42 @@ class ModbusSlave extends EventEmitter {
             await this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
             return;
         }
-        const value = new Array(length);
+        const value = new Uint8Array(length);
         let byteIdx = 5;
         let outIdx = 0;
         const fullBytes = length >> 3;
         for (let b = 0; b < fullBytes; b++) {
             const byte = frame.data[byteIdx++];
-            value[outIdx++] = (byte & 0x01) > 0;
-            value[outIdx++] = (byte & 0x02) > 0;
-            value[outIdx++] = (byte & 0x04) > 0;
-            value[outIdx++] = (byte & 0x08) > 0;
-            value[outIdx++] = (byte & 0x10) > 0;
-            value[outIdx++] = (byte & 0x20) > 0;
-            value[outIdx++] = (byte & 0x40) > 0;
-            value[outIdx++] = (byte & 0x80) > 0;
+            value[outIdx++] = byte & 0x01;
+            value[outIdx++] = (byte >>> 1) & 0x01;
+            value[outIdx++] = (byte >>> 2) & 0x01;
+            value[outIdx++] = (byte >>> 3) & 0x01;
+            value[outIdx++] = (byte >>> 4) & 0x01;
+            value[outIdx++] = (byte >>> 5) & 0x01;
+            value[outIdx++] = (byte >>> 6) & 0x01;
+            value[outIdx++] = (byte >>> 7) & 0x01;
         }
         const rem = length & 7;
         if (rem) {
             const byte = frame.data[byteIdx];
-            value[outIdx++] = (byte & 0x01) > 0;
+            value[outIdx++] = byte & 0x01;
             if (rem > 1) {
-                value[outIdx++] = (byte & 0x02) > 0;
+                value[outIdx++] = (byte >>> 1) & 0x01;
             }
             if (rem > 2) {
-                value[outIdx++] = (byte & 0x04) > 0;
+                value[outIdx++] = (byte >>> 2) & 0x01;
             }
             if (rem > 3) {
-                value[outIdx++] = (byte & 0x08) > 0;
+                value[outIdx++] = (byte >>> 3) & 0x01;
             }
             if (rem > 4) {
-                value[outIdx++] = (byte & 0x10) > 0;
+                value[outIdx++] = (byte >>> 4) & 0x01;
             }
             if (rem > 5) {
-                value[outIdx++] = (byte & 0x20) > 0;
+                value[outIdx++] = (byte >>> 5) & 0x01;
             }
             if (rem > 6) {
-                value[outIdx++] = (byte & 0x40) > 0;
+                value[outIdx++] = (byte >>> 6) & 0x01;
             }
         }
         try {
@@ -3634,21 +3810,41 @@ class ModbusSlave extends EventEmitter {
             return;
         }
         try {
-            const { serverId = [model.unit ?? 1], runIndicatorStatus = true, additionalData = [] } = await model.reportServerId();
-            const serverIdBytes = serverId;
-            const byteCount = serverIdBytes.length + 1 + additionalData.length;
+            const result = await model.reportServerId();
+            const sid = result.serverId;
+            const extra = result.additionalData;
+            const sidLen = sid?.length ?? 1;
+            const extraLen = extra?.length ?? 0;
+            const byteCount = sidLen + 1 + extraLen;
             if (byteCount > 255) {
                 await this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
                 return;
             }
-            const allBytes = [...serverIdBytes, runIndicatorStatus ? 0xff : 0x00, ...additionalData];
-            if (allBytes.some((b) => !isUint8(b))) {
-                await this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
-                return;
-            }
             const data = Buffer.allocUnsafe(byteCount + 1);
             data[0] = byteCount;
-            data.set(allBytes, 1);
+            let off = 1;
+            if (sid) {
+                for (let i = 0; i < sidLen; i++) {
+                    const b = sid[i];
+                    if ((b & 0xff) !== b) {
+                        await this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
+                        return;
+                    }
+                    data[off++] = b;
+                }
+            }
+            else {
+                const unitId = model.unit ?? 1;
+                if ((unitId & 0xff) !== unitId) {
+                    await this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
+                    return;
+                }
+                data[off++] = unitId;
+            }
+            data[off++] = (result.runIndicatorStatus ?? true) ? 0xff : 0x00;
+            if (extra) {
+                extra.copy(data, off);
+            }
             await response(appLayer.encode(frame.unit, frame.fc, data, frame.transaction));
         }
         catch (error) {