njs-modbus 3.2.0 → 3.4.0

package/dist/index.mjs

@@ -164,40 +164,75 @@ function bitsToMs(baudRate, bits) {
  * open / close / destroy callbacks.
  */
 function drainCbs(cbs, err) {
-    if (!cbs)
+    if (!cbs) {
         return;
+    }
     for (const cb of cbs) {
         cb?.(err);
     }
 }
 
-function inRange(n, [min, max]) {
-    return n >= min && n <= max;
-}
-function isRangeArray(range) {
-    return Array.isArray(range[0]);
-}
 function checkRange(value, range) {
     if (!range || range.length === 0) {
         return true;
     }
-    const values = Array.isArray(value) ? value : [value];
-    if (isRangeArray(range)) {
-        for (const r of range) {
-            const [min, max] = r;
-            const [lo, hi] = min <= max ? [min, max] : [max, min];
-            if (values.every((n) => inRange(n, [lo, hi]))) {
+    const isMultiRange = Array.isArray(range[0]);
+    const isValueArray = Array.isArray(value);
+    if (!isValueArray && !isMultiRange) {
+        const r = range;
+        const min = r[0], max = r[1];
+        const v = value;
+        return min <= max ? v >= min && v <= max : v >= max && v <= min;
+    }
+    if (!isValueArray && isMultiRange) {
+        const ranges = range;
+        const v = value;
+        for (let i = 0; i < ranges.length; i++) {
+            const min = ranges[i][0], max = ranges[i][1];
+            const lo = min <= max ? min : max;
+            const hi = min <= max ? max : min;
+            if (v >= lo && v <= hi) {
                 return true;
             }
         }
         return false;
     }
-    const [min, max] = range;
-    const [lo, hi] = min <= max ? [min, max] : [max, min];
-    return values.every((n) => inRange(n, [lo, hi]));
+    const values = value;
+    if (values.length === 0) {
+        return true;
+    }
+    if (!isMultiRange) {
+        const r = range;
+        const min = r[0], max = r[1];
+        const lo = min <= max ? min : max;
+        const hi = min <= max ? max : min;
+        for (let i = 0; i < values.length; i++) {
+            if (values[i] < lo || values[i] > hi) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const ranges = range;
+    for (let i = 0; i < ranges.length; i++) {
+        const min = ranges[i][0], max = ranges[i][1];
+        const lo = min <= max ? min : max;
+        const hi = min <= max ? max : min;
+        let allInRange = true;
+        for (let j = 0; j < values.length; j++) {
+            if (values[j] < lo || values[j] > hi) {
+                allInRange = false;
+                break;
+            }
+        }
+        if (allInRange) {
+            return true;
+        }
+    }
+    return false;
 }
 
-const TABLE = [
+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,
@@ -214,131 +249,127 @@ const TABLE = [
     0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0,
     0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
     0x4040,
-];
-function crc(data, start = 0, end = data.length) {
+]);
+/** 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)) & 0xffff;
+        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 Number.isInteger(n) && n >= 0 && n <= 255;
+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 = 0, end = data.length) {
+function lrc(data, start, end) {
     let sum = 0;
     for (let i = start; i < end; i++) {
         sum += data[i];
     }
-    return (~sum + 1) & 0xff;
+    return -sum & 0xff;
 }
 
-const REQUEST_FIXED_LENGTHS = {
-    [FunctionCode.READ_COILS]: 8,
-    [FunctionCode.READ_DISCRETE_INPUTS]: 8,
-    [FunctionCode.READ_HOLDING_REGISTERS]: 8,
-    [FunctionCode.READ_INPUT_REGISTERS]: 8,
-    [FunctionCode.WRITE_SINGLE_COIL]: 8,
-    [FunctionCode.WRITE_SINGLE_REGISTER]: 8,
-    [FunctionCode.REPORT_SERVER_ID]: 4,
-    [FunctionCode.MASK_WRITE_REGISTER]: 10,
-    [FunctionCode.READ_DEVICE_IDENTIFICATION]: 7,
-};
-const REQUEST_BYTE_COUNT = {
-    [FunctionCode.WRITE_MULTIPLE_COILS]: { offset: 6, extra: 9 },
-    [FunctionCode.WRITE_MULTIPLE_REGISTERS]: { offset: 6, extra: 9 },
-    [FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 10, extra: 13 },
-};
-const RESPONSE_FIXED_LENGTHS = {
-    [FunctionCode.WRITE_SINGLE_COIL]: 8,
-    [FunctionCode.WRITE_SINGLE_REGISTER]: 8,
-    [FunctionCode.WRITE_MULTIPLE_COILS]: 8,
-    [FunctionCode.WRITE_MULTIPLE_REGISTERS]: 8,
-    [FunctionCode.MASK_WRITE_REGISTER]: 10,
-};
-const RESPONSE_BYTE_COUNT = {
-    [FunctionCode.READ_COILS]: { offset: 2, extra: 5 },
-    [FunctionCode.READ_DISCRETE_INPUTS]: { offset: 2, extra: 5 },
-    [FunctionCode.READ_HOLDING_REGISTERS]: { offset: 2, extra: 5 },
-    [FunctionCode.READ_INPUT_REGISTERS]: { offset: 2, extra: 5 },
-    [FunctionCode.REPORT_SERVER_ID]: { offset: 2, extra: 5 },
-    [FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 2, extra: 5 },
-};
-/** Sentinel: caller needs to feed more bytes before length can be determined. */
 const PREDICT_NEED_MORE = 0;
-/** Sentinel: function code is not in the standard tables. */
 const PREDICT_UNKNOWN = -1;
-/**
- * Predict the total RTU frame length (PDU + 2-byte CRC) given the leading bytes.
- *
- * Returns a sentinel-encoded number to avoid per-call object allocation on the
- * RTU decode hot path:
- * - Positive integer (>= 4): total frame length, function code is known.
- * - {@link PREDICT_NEED_MORE} (0): function code is known but more bytes are
- *   required (typically waiting on the byteCount byte).
- * - {@link PREDICT_UNKNOWN} (-1): function code is not in the standard tables —
- *   the framing layer must defer to a registered `CustomFunctionCode` or treat
- *   this as a framing error.
- */
-function predictRtuFrameLength(buffer, start, end, isResponse) {
-    if (end - start < 2) {
+const REQ_TABLE = new Int32Array(256);
+const RES_TABLE = new Int32Array(256);
+(function initTables() {
+    REQ_TABLE[FunctionCode.READ_COILS] = 8;
+    REQ_TABLE[FunctionCode.READ_DISCRETE_INPUTS] = 8;
+    REQ_TABLE[FunctionCode.READ_HOLDING_REGISTERS] = 8;
+    REQ_TABLE[FunctionCode.READ_INPUT_REGISTERS] = 8;
+    REQ_TABLE[FunctionCode.WRITE_SINGLE_COIL] = 8;
+    REQ_TABLE[FunctionCode.WRITE_SINGLE_REGISTER] = 8;
+    REQ_TABLE[FunctionCode.REPORT_SERVER_ID] = 4;
+    REQ_TABLE[FunctionCode.MASK_WRITE_REGISTER] = 10;
+    REQ_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = 7;
+    REQ_TABLE[FunctionCode.WRITE_MULTIPLE_COILS] = -1545;
+    REQ_TABLE[FunctionCode.WRITE_MULTIPLE_REGISTERS] = -1545;
+    REQ_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -2573;
+    RES_TABLE[FunctionCode.WRITE_SINGLE_COIL] = 8;
+    RES_TABLE[FunctionCode.WRITE_SINGLE_REGISTER] = 8;
+    RES_TABLE[FunctionCode.WRITE_MULTIPLE_COILS] = 8;
+    RES_TABLE[FunctionCode.WRITE_MULTIPLE_REGISTERS] = 8;
+    RES_TABLE[FunctionCode.MASK_WRITE_REGISTER] = 10;
+    RES_TABLE[FunctionCode.READ_COILS] = -517;
+    RES_TABLE[FunctionCode.READ_DISCRETE_INPUTS] = -517;
+    RES_TABLE[FunctionCode.READ_HOLDING_REGISTERS] = -517;
+    RES_TABLE[FunctionCode.READ_INPUT_REGISTERS] = -517;
+    RES_TABLE[FunctionCode.REPORT_SERVER_ID] = -517;
+    RES_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -517;
+    RES_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = -999;
+})();
+function predictRtuFrameLength(residual, data, residualLen, start, end, isResponse) {
+    const len = end - start;
+    if (len < 2) {
         return PREDICT_NEED_MORE;
     }
-    const fc = buffer[start + 1];
-    if (isResponse && (fc & EXCEPTION_OFFSET) !== 0) {
-        return 5;
-    }
-    const fixed = (isResponse ? RESPONSE_FIXED_LENGTHS : REQUEST_FIXED_LENGTHS)[fc];
-    if (fixed !== undefined) {
-        return fixed;
-    }
-    const bc = (isResponse ? RESPONSE_BYTE_COUNT : REQUEST_BYTE_COUNT)[fc];
-    if (bc !== undefined) {
-        if (end - start <= bc.offset) {
-            return PREDICT_NEED_MORE;
+    const fc = start + 1 < residualLen ? residual[start + 1] : data[start + 1 - residualLen];
+    if (isResponse) {
+        if ((fc & EXCEPTION_OFFSET) !== 0) {
+            return 5;
+        }
+        const val = RES_TABLE[fc];
+        if (val > 0) {
+            return val;
+        }
+        if (val < 0) {
+            if (val === -999) {
+                // FC 43 / MEI 14 response — inline to avoid function-call overhead on
+                // the framing hot path (even though this FC is uncommon).
+                if (end - start < 8) {
+                    return PREDICT_NEED_MORE;
+                }
+                if ((start + 2 < residualLen ? residual[start + 2] : data[start + 2 - residualLen]) !== MEI_READ_DEVICE_ID) {
+                    return PREDICT_UNKNOWN;
+                }
+                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 + (cursor + 1 < residualLen ? residual[cursor + 1] : data[cursor + 1 - residualLen]);
+                }
+                return cursor - start + 2;
+            }
+            const decode = -val;
+            const offset = decode >> 8;
+            if (len <= offset) {
+                return PREDICT_NEED_MORE;
+            }
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
-        return bc.extra + buffer[start + bc.offset];
-    }
-    if (isResponse && fc === FunctionCode.READ_DEVICE_IDENTIFICATION) {
-        return predictFc43_14Response(buffer, start, end);
     }
-    return PREDICT_UNKNOWN;
-}
-/**
- * Walk the variable-length FC 0x2B / MEI 0x0E (Read Device Identification)
- * response structure per Modbus V1.1b3 §6.21.
- *
- * Layout (after unit and fc):
- *   mei(1) rdic(1) conformity(1) more(1) nextObjId(1) numObjs(1)
- *   [objId(1) objLen(1) objData(objLen)] × numObjs
- *   CRC(2)
- */
-function predictFc43_14Response(buffer, start, end) {
-    if (end - start < 8) {
-        return PREDICT_NEED_MORE;
-    }
-    if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
-        return PREDICT_UNKNOWN;
-    }
-    const numObjs = buffer[start + 7];
-    let cursor = start + 8;
-    for (let i = 0; i < numObjs; i++) {
-        if (end < cursor + 2) {
-            return PREDICT_NEED_MORE;
+    else {
+        const val = REQ_TABLE[fc];
+        if (val > 0) {
+            return val;
+        }
+        if (val < 0) {
+            const decode = -val;
+            const offset = decode >> 8;
+            if (len <= offset) {
+                return PREDICT_NEED_MORE;
+            }
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
-        const objLen = buffer[cursor + 1];
-        cursor += 2 + objLen;
     }
-    return cursor - start + 2;
+    return PREDICT_UNKNOWN;
 }
 
 /**
@@ -347,10 +378,12 @@ function predictFc43_14Response(buffer, start, end) {
 function promisifyCb(fn) {
     return new Promise((resolve, reject) => {
         fn((err) => {
-            if (err)
+            if (err) {
                 reject(err);
-            else
+            }
+            else {
                 resolve();
+            }
         });
     });
 }
@@ -376,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.
@@ -393,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) {
@@ -403,102 +451,176 @@ function resolveRtuTiming(opts = {}, baudRate) {
     return { intervalBetweenFrames, interCharTimeout };
 }
 
-/** @internal
- * Zero-allocation binary min-heap for coalescing per-request timeouts.
+/**
+ * Hybrid timer manager: uses native `setTimeout` for low concurrency
+ * and switches to a binary min-heap when concurrency exceeds the threshold.
  *
- * Uses two parallel numeric arrays (no object allocation per entry).
- * Lazy deletion: callers never remove from the heap; expired entries
- * are silently dropped when they surface at the top.
+ * Benchmarks (add + clear throughput, Node 24, x64):
+ *   1 concurrent:  setTimeout ~1.7× faster than heap
+ *   2 concurrent:  setTimeout ~1.6× faster than heap
+ *   5 concurrent:  setTimeout ~1.5-1.9× faster than heap
+ *  10 concurrent:  roughly equal
+ *  20 concurrent:  heap ~1.3× faster than setTimeout[]
+ *  50 concurrent:  heap ~1.4-1.7× faster than setTimeout[]
+ *
+ * The crossover point is around 10 concurrent timers, so the default
+ * `concurrentThreshold = 2` keeps the common 1-2 request case on the
+ * fast direct path while delegating to the heap for larger batches.
  */
 class TimerHeap {
     _deadlines = [];
     _ids = [];
+    _seqs = [];
+    _counter = 0;
     _timer = null;
     _onFire;
-    /** Pre-bound tick handler to avoid creating a new arrow function on every setTimeout. */
     _boundTick;
-    constructor(onFire) {
+    _threshold;
+    _mode = 'direct';
+    _directTimers = new Map();
+    /**
+     * @param onFire  Callback invoked with the timer id when it expires.
+     * @param concurrentThreshold  Maximum number of timers kept as individual
+     *     native `setTimeout` handles. Once exceeded, all timers migrate to
+     *     the internal heap and share a single native timer. Default is 2.
+     */
+    constructor(onFire, concurrentThreshold = 2) {
         this._onFire = onFire;
         this._boundTick = this._onTick.bind(this);
+        this._threshold = concurrentThreshold;
     }
-    /** Number of pending timers in the heap. */
     get size() {
-        return this._deadlines.length;
+        return this._mode === 'direct' ? this._directTimers.size : this._deadlines.length;
     }
-    /** Schedule an entry. If it becomes the new top, the global timer is re-scheduled (pre-emption). */
     add(id, ms) {
+        if (this._mode === 'direct' && this._directTimers.size + 1 <= this._threshold) {
+            const deadline = performance.now() + ms;
+            const handle = setTimeout(() => {
+                if (this._mode !== 'direct') {
+                    return;
+                }
+                this._directTimers.delete(id);
+                this._onFire(id);
+            }, ms);
+            this._directTimers.set(id, { handle, deadline });
+            return;
+        }
+        if (this._mode === 'direct') {
+            this._mode = 'heap';
+            for (const [existingId, { handle, deadline }] of this._directTimers) {
+                clearTimeout(handle);
+                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);
+                }
+                else {
+                    this._heapAdd(existingId, remaining);
+                }
+            }
+            this._directTimers.clear();
+        }
+        this._heapAdd(id, ms);
+    }
+    clear() {
+        for (const { handle } of this._directTimers.values()) {
+            clearTimeout(handle);
+        }
+        this._directTimers.clear();
+        this._mode = 'direct';
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        this._deadlines.length = 0;
+        this._ids.length = 0;
+        this._seqs.length = 0;
+        this._counter = 0;
+    }
+    _heapAdd(id, ms) {
         const deadline = performance.now() + ms;
+        const seq = this._counter++;
         let i = this._deadlines.length;
         this._deadlines.push(deadline);
         this._ids.push(id);
-        // sift up
+        this._seqs.push(seq);
         while (i > 0) {
             const p = (i - 1) >> 1;
-            if (this._deadlines[p] <= deadline)
+            const parentComesFirst = this._deadlines[p] < deadline || (this._deadlines[p] === deadline && this._seqs[p] < seq);
+            if (parentComesFirst) {
                 break;
+            }
             this._deadlines[i] = this._deadlines[p];
             this._ids[i] = this._ids[p];
+            this._seqs[i] = this._seqs[p];
             i = p;
         }
         this._deadlines[i] = deadline;
         this._ids[i] = id;
-        // Only reschedule when the new entry became the heap top.
-        if (i === 0)
+        this._seqs[i] = seq;
+        if (i === 0) {
             this._refresh();
-    }
-    /** Dispose without firing callbacks. */
-    clear() {
-        if (this._timer) {
-            clearTimeout(this._timer);
-            this._timer = null;
         }
-        this._deadlines.length = 0;
-        this._ids.length = 0;
     }
     _refresh() {
         if (this._timer) {
             clearTimeout(this._timer);
             this._timer = null;
         }
-        if (this._deadlines.length === 0)
+        if (this._deadlines.length === 0) {
             return;
-        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
-        this._timer = setTimeout(this._boundTick, delay);
+        }
+        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() {
         this._timer = null;
         const now = performance.now();
-        while (this._deadlines.length > 0 && this._deadlines[0] <= now) {
-            const id = this._pop();
-            this._onFire(id);
+        try {
+            while (this._deadlines.length > 0 && this._deadlines[0] <= now) {
+                const id = this._pop();
+                this._onFire(id);
+            }
+        }
+        finally {
+            this._refresh();
         }
-        this._refresh();
     }
-    /** Pop and return the id with the earliest deadline. Assumes heap is non-empty. */
     _pop() {
         const topId = this._ids[0];
         const lastId = this._ids.pop();
         const lastDeadline = this._deadlines.pop();
+        const lastSeq = this._seqs.pop();
         const n = this._deadlines.length;
         if (n > 0) {
             let i = 0;
-            // sift down
-            while (true) {
-                let min = i;
-                const l = i * 2 + 1;
-                const r = l + 1;
-                if (l < n && this._deadlines[l] < this._deadlines[min])
-                    min = l;
-                if (r < n && this._deadlines[r] < this._deadlines[min])
-                    min = r;
-                if (min === i)
+            const half = n >> 1;
+            while (i < half) {
+                let minChild = (i << 1) + 1;
+                const rightChild = minChild + 1;
+                if (rightChild < n) {
+                    const rightComesFirst = this._deadlines[rightChild] < this._deadlines[minChild] ||
+                        (this._deadlines[rightChild] === this._deadlines[minChild] && this._seqs[rightChild] < this._seqs[minChild]);
+                    if (rightComesFirst) {
+                        minChild = rightChild;
+                    }
+                }
+                const lastComesFirst = lastDeadline < this._deadlines[minChild] || (lastDeadline === this._deadlines[minChild] && lastSeq < this._seqs[minChild]);
+                if (lastComesFirst) {
                     break;
-                this._deadlines[i] = this._deadlines[min];
-                this._ids[i] = this._ids[min];
-                i = min;
+                }
+                this._deadlines[i] = this._deadlines[minChild];
+                this._ids[i] = this._ids[minChild];
+                this._seqs[i] = this._seqs[minChild];
+                i = minChild;
             }
             this._deadlines[i] = lastDeadline;
             this._ids[i] = lastId;
+            this._seqs[i] = lastSeq;
         }
         return topId;
     }
@@ -536,6 +658,9 @@ class SerialPhysicalConnection extends AbstractPhysicalConnection {
     get physicalLayer() {
         return this._physicalLayer;
     }
+    get serialport() {
+        return this._serialport;
+    }
     constructor(physicalLayer, serialport) {
         super();
         this._physicalLayer = physicalLayer;
@@ -544,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);
@@ -572,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'));
@@ -733,6 +864,9 @@ class TcpPhysicalConnection extends AbstractPhysicalConnection {
     get physicalLayer() {
         return this._physicalLayer;
     }
+    get socket() {
+        return this._socket;
+    }
     constructor(physicalLayer, socket) {
         super();
         this._physicalLayer = physicalLayer;
@@ -741,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);
@@ -769,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'));
@@ -1051,6 +1191,9 @@ class UdpClientPhysicalConnection extends AbstractPhysicalConnection {
     get physicalLayer() {
         return this._physicalLayer;
     }
+    get socket() {
+        return this._socket;
+    }
     constructor(physicalLayer, socket) {
         super();
         this._physicalLayer = physicalLayer;
@@ -1059,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);
@@ -1087,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'));
@@ -1227,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;
@@ -1245,6 +1400,7 @@ class UdpServerPhysicalConnection extends AbstractPhysicalConnection {
                     }, idleTimeout);
                 }
             }
+            this.emit('rx', msg);
             this.emit('data', msg);
         };
         messageEventDelegation.add(onMessage);
@@ -1257,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'));
@@ -1460,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() {
@@ -1479,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);
@@ -1571,147 +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);
@@ -1726,14 +1937,15 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
         buffer[0] = unit;
         buffer[1] = fc;
         if (data.length <= 16) {
-            for (let i = 0; i < data.length; i++)
+            for (let i = 0; i < data.length; i++) {
                 buffer[2 + i] = data[i];
+            }
         }
         else {
             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;
@@ -1746,9 +1958,8 @@ const CHAR_CODE = {
     CR: '\r'.charCodeAt(0),
     LF: '\n'.charCodeAt(0),
 };
-// Modbus ASCII frame encodes at most 256 PDU bytes as 512 hex chars between
-// `:` and `\r`. Cap per-connection buffering so a peer that never sends `\r`
-// cannot grow `state.frame` without bound.
+// Modbus ASCII frame body is capped well below the theoretical maximum so a
+// peer that never sends `\r` cannot grow `state.frame` without bound.
 const MAX_ASCII_PAYLOAD = 512;
 const HEX_DECODE = new Uint8Array(256);
 HEX_DECODE.fill(0xff);
@@ -1761,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 = [];
@@ -1776,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': {
@@ -1814,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'));
@@ -1832,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;
@@ -1851,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;
@@ -1863,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;
@@ -1874,30 +2097,31 @@ 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[4 + i * 2]];
-            const lo = HEX_DECODE[hexChars[4 + i * 2 + 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;
-        }
-        // Compute LRC over unit + fc + data.
-        let sum = unit + fc;
-        for (let i = 0; i < dataLen; i++) {
-            sum += data[i];
+            const byte = (hi << 4) | lo;
+            data[i] = byte;
+            sum += byte;
+            hexOff += 2;
         }
         const lrcComputed = (~sum + 1) & 0xff;
         if (lrcIn !== lrcComputed) {
@@ -1923,13 +2147,15 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         buffer[0] = unit;
         buffer[1] = fc;
         buffer.set(data, 2);
-        buffer[buffer.length - 1] = lrc(buffer.subarray(0, -1));
+        buffer[buffer.length - 1] = lrc(buffer, 0, buffer.length - 1);
         const out = Buffer.allocUnsafe(1 + buffer.length * 2 + 2);
         out[0] = CHAR_CODE.COLON;
+        let outOff = 1;
         for (let i = 0; i < buffer.length; i++) {
             const byte = buffer[i];
-            out[1 + i * 2] = HEX_ENCODE[byte >> 4];
-            out[2 + i * 2] = HEX_ENCODE[byte & 0x0f];
+            out[outOff] = HEX_ENCODE[byte >> 4];
+            out[outOff + 1] = HEX_ENCODE[byte & 0x0f];
+            outOff += 2;
         }
         out[out.length - 2] = CHAR_CODE.CR;
         out[out.length - 1] = CHAR_CODE.LF;
@@ -1937,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;
@@ -1953,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);
@@ -2011,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() above. 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);
@@ -2061,8 +2317,9 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
         // Small-payload fast path: avoid C++ TypedArray.prototype.set boundary
         // crossing when the copy is just a few bytes (common for FC 3/4/6 requests).
         if (data.length <= 16) {
-            for (let i = 0; i < data.length; i++)
+            for (let i = 0; i < data.length; i++) {
                 buffer[8 + i] = data[i];
+            }
         }
         else {
             buffer.set(data, 8);
@@ -2110,26 +2367,33 @@ class MasterSession {
 }
 
 function validateResponse(frame, unit, fc) {
-    if (frame.unit !== unit || frame.fc !== fc)
+    if (frame.unit !== unit || frame.fc !== fc) {
         throw new Error('Invalid response');
+    }
 }
 function validateByteCountResponse(frame, unit, fc, byteCount) {
     validateResponse(frame, unit, fc);
-    if (frame.data.length < 1 + byteCount)
+    if (frame.data.length < 1 + byteCount) {
         throw new Error('Insufficient data length');
-    if (frame.data.length !== 1 + byteCount)
+    }
+    if (frame.data.length !== 1 + byteCount) {
         throw new Error('Invalid response');
-    if (frame.data[0] !== byteCount)
+    }
+    if (frame.data[0] !== byteCount) {
         throw new Error('Invalid response');
+    }
 }
 function validateEchoResponse(frame, unit, fc, expected) {
     validateResponse(frame, unit, fc);
-    if (frame.data.length < expected.length)
+    if (frame.data.length < expected.length) {
         throw new Error('Insufficient data length');
-    if (frame.data.length !== expected.length)
+    }
+    if (frame.data.length !== expected.length) {
         throw new Error('Invalid response');
-    if (!frame.data.equals(expected))
+    }
+    if (!frame.data.equals(expected)) {
         throw new Error('Invalid response');
+    }
 }
 class ModbusMaster extends EventEmitter {
     timeout;
@@ -2157,8 +2421,9 @@ class ModbusMaster extends EventEmitter {
     _pendingExchanges = new Map();
     _timerHeap = new TimerHeap((id) => {
         const pending = this._pendingExchanges.get(id);
-        if (!pending)
-            return; // lazy deletion: already handled
+        if (!pending) {
+            return;
+        } // lazy deletion: already handled
         pending.settled = true;
         this._pendingExchanges.delete(id);
         if (pending.sessionKey !== null) {
@@ -2200,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;
@@ -2208,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);
@@ -2258,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') {
@@ -2345,7 +2628,9 @@ class ModbusMaster extends EventEmitter {
         }
         // Lazy-deletion timer architecture:
         // 1. Assign an exchangeId and register in _pendingExchanges.
-        // 2. Push deadline into the global TimerHeap (no per-request setTimeout).
+        // 2. Push deadline into the global TimerHeap (one native setTimeout under
+        //    load; a fast direct-timer path is used when only 1-2 exchanges are
+        //    pending).
         // 3. When the response arrives, delete from Map — the heap entry is left
         //    behind and silently discarded when it surfaces at the top (lazy deletion).
         const exchangeId = this._nextExchangeId++;
@@ -2356,11 +2641,13 @@ class ModbusMaster extends EventEmitter {
             this._timerHeap.add(exchangeId, timeout);
             connection.write(appLayer.encode(unit, fc, data), (writeErr) => {
                 const p = this._pendingExchanges.get(exchangeId);
-                if (!p || p.settled)
+                if (!p || p.settled) {
                     return;
+                }
                 const cb = p.callback;
-                if (!cb)
+                if (!cb) {
                     return;
+                }
                 p.settled = true;
                 p.callback = null;
                 this._pendingExchanges.delete(exchangeId);
@@ -2389,8 +2676,9 @@ class ModbusMaster extends EventEmitter {
         this._timerHeap.add(exchangeId, timeout);
         connection.write(payload, (writeErr) => {
             const p = this._pendingExchanges.get(exchangeId);
-            if (!p || p.settled)
+            if (!p || p.settled) {
                 return;
+            }
             if (writeErr) {
                 const cb = p.callback;
                 if (cb) {
@@ -2415,8 +2703,9 @@ class ModbusMaster extends EventEmitter {
             // Timeout is managed by the global timer heap above.
             this._masterSession.start(key, (err, frame) => {
                 const p2 = this._pendingExchanges.get(exchangeId);
-                if (!p2 || p2.settled)
+                if (!p2 || p2.settled) {
                     return;
+                }
                 const cb = p2.callback;
                 if (cb) {
                     p2.settled = true;
@@ -2428,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;
@@ -2448,12 +2735,44 @@ class ModbusMaster extends EventEmitter {
                 }
                 try {
                     validateByteCountResponse(frame, unit, fc, byteCount);
-                    const data = new Array(length);
-                    for (let i = 0; i < length; i++) {
-                        data[i] = (frame.data[1 + Math.floor(i / 8)] & (1 << i % 8)) > 0;
+                    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;
+                        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;
+                        if (rem > 1) {
+                            data[outIdx++] = (byte >>> 1) & 0x01;
+                        }
+                        if (rem > 2) {
+                            data[outIdx++] = (byte >>> 2) & 0x01;
+                        }
+                        if (rem > 3) {
+                            data[outIdx++] = (byte >>> 3) & 0x01;
+                        }
+                        if (rem > 4) {
+                            data[outIdx++] = (byte >>> 4) & 0x01;
+                        }
+                        if (rem > 5) {
+                            data[outIdx++] = (byte >>> 5) & 0x01;
+                        }
+                        if (rem > 6) {
+                            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);
                 }
@@ -2498,9 +2817,10 @@ class ModbusMaster extends EventEmitter {
                     // on each call. Symmetric to the slave-side BE write inlining
                     // in handleFC3/FC4. At length=125 (FC3 max) that's 250 saved
                     // bounds-check pairs per response.
+                    let off = 0;
                     for (let i = 0; i < length; i++) {
-                        const off = i * 2;
                         data[i] = (bufferRx[off] << 8) | bufferRx[off + 1];
+                        off += 2;
                     }
                     frame.data = data;
                     resolve(frame);
@@ -2523,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;
@@ -2583,18 +2903,52 @@ 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;
-        for (let i = 0; i < value.length; i++) {
-            if (value[i]) {
-                bufferTx[5 + Math.floor(i / 8)] |= 1 << i % 8;
+        let out = 5;
+        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 (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;
+            }
+            bufferTx[out] = acc;
         }
         return new Promise((resolve, reject) => {
             this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
@@ -2628,11 +2982,12 @@ class ModbusMaster extends EventEmitter {
         bufferTx[2] = (value.length >>> 8) & 0xff;
         bufferTx[3] = value.length & 0xff;
         bufferTx[4] = byteCount;
+        let off = 5;
         for (let i = 0; i < value.length; i++) {
             const v = value[i];
-            const off = 5 + i * 2;
             bufferTx[off] = (v >>> 8) & 0xff;
             bufferTx[off + 1] = v & 0xff;
+            off += 2;
         }
         return new Promise((resolve, reject) => {
             this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
@@ -2670,15 +3025,17 @@ class ModbusMaster extends EventEmitter {
                 }
                 try {
                     validateResponse(frame, unit, fc);
-                    if (frame.data.length < 2 + serverIdLength)
+                    if (frame.data.length < 2 + serverIdLength) {
                         throw new Error('Insufficient data length');
-                    if (frame.data.length !== 1 + frame.data[0])
+                    }
+                    if (frame.data.length !== 1 + frame.data[0]) {
                         throw new Error('Invalid response');
+                    }
                     const runStatusIndex = 1 + serverIdLength;
                     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);
                 }
@@ -2736,11 +3093,12 @@ class ModbusMaster extends EventEmitter {
         bufferTx[6] = (write.value.length >>> 8) & 0xff;
         bufferTx[7] = write.value.length & 0xff;
         bufferTx[8] = byteCount;
+        let off = 9;
         for (let i = 0; i < write.value.length; i++) {
             const v = write.value[i];
-            const off = 9 + i * 2;
             bufferTx[off] = (v >>> 8) & 0xff;
             bufferTx[off + 1] = v & 0xff;
+            off += 2;
         }
         return new Promise((resolve, reject) => {
             this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
@@ -2759,9 +3117,10 @@ class ModbusMaster extends EventEmitter {
                     // closure + N readUInt16BE bounds-check pairs. See writeFC3Or4
                     // response handler for the same optimization.
                     const data = new Array(read.length);
+                    let off = 0;
                     for (let i = 0; i < read.length; i++) {
-                        const off = i * 2;
                         data[i] = (bufferRx[off] << 8) | bufferRx[off + 1];
+                        off += 2;
                     }
                     frame.data = data;
                     resolve(frame);
@@ -2787,10 +3146,12 @@ class ModbusMaster extends EventEmitter {
                 }
                 try {
                     validateResponse(frame, unit, fc);
-                    if (frame.data.length < 6)
+                    if (frame.data.length < 6) {
                         throw new Error('Insufficient data length');
-                    if (frame.data[0] !== MEI_READ_DEVICE_ID || frame.data[1] !== readDeviceIDCode)
+                    }
+                    if (frame.data[0] !== MEI_READ_DEVICE_ID || frame.data[1] !== readDeviceIDCode) {
                         throw new Error('Invalid response');
+                    }
                     const objects = [];
                     let object = [];
                     let totalBytes = 0;
@@ -2818,10 +3179,12 @@ class ModbusMaster extends EventEmitter {
                                 break;
                         }
                     }
-                    if (objects.length !== frame.data[5])
+                    if (objects.length !== frame.data[5]) {
                         throw new Error('Invalid response');
-                    if (frame.data.length !== 6 + totalBytes)
+                    }
+                    if (frame.data.length !== 6 + totalBytes) {
                         throw new Error('Invalid response');
+                    }
                     frame.data = {
                         readDeviceIDCode,
                         conformityLevel: frame.data[2],
@@ -2868,7 +3231,7 @@ class ModbusMaster extends EventEmitter {
         });
     }
     /**
-     * Open the underlying physical layer and begin accepting connections.
+     * Open the underlying physical layer and establish a connection.
      *
      * A `ModbusMaster` instance can only be opened once. Once {@link close}
      * is called — explicitly or because the physical layer disconnected —
@@ -2898,8 +3261,9 @@ class ModbusMaster extends EventEmitter {
         // (broadcasts have no session waiter; non-broadcasts still in the
         // pre-write-window haven't registered in session yet).
         for (const pending of this._pendingExchanges.values()) {
-            if (pending.settled)
+            if (pending.settled) {
                 continue;
+            }
             pending.settled = true;
             const cb = pending.callback;
             if (cb) {
@@ -2977,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;
                 }
@@ -2992,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);
             };
@@ -3025,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') {
@@ -3057,23 +3448,44 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            // Pack 8 booleans per byte without first zero-filling: accumulate into
-            // `acc` and write a full byte once each lane is finished. Saves the
-            // `pdu.fill(0, 1, ...)` pass and replaces N `|=` reads-modify-writes
-            // with N `read`s + ⌈N/8⌉ `write`s. Measured ~+5% on FC01 / ~+3% on FC02
-            // at max payload (2000 / 1968 coils) via benchmark/all-fcs.ts bisect.
-            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;
-                }
+            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);
             }
-            if ((length & 7) !== 0)
+            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;
+            }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
         catch (error) {
@@ -3104,19 +3516,44 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            // Accumulator-based bit pack — see handleFC1 for the rationale.
-            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;
-                }
+            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);
             }
-            if ((length & 7) !== 0)
+            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;
+            }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
         catch (error) {
@@ -3149,11 +3586,12 @@ class ModbusSlave extends EventEmitter {
             // Inline big-endian write — `pdu[i] = v` is a direct typed-array store,
             // while `writeUInt16BE` runs argument validation + bounds checks on each
             // call. At length=125 (FC3 max) that's 250 saved checks per request.
+            let off = 1;
             for (let i = 0; i < length; i++) {
                 const v = registers[i];
-                const off = 1 + i * 2;
                 pdu[off] = (v >>> 8) & 0xff;
                 pdu[off + 1] = v & 0xff;
+                off += 2;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -3185,11 +3623,12 @@ class ModbusSlave extends EventEmitter {
             const pdu = Buffer.allocUnsafe(length * 2 + 1);
             pdu[0] = length * 2;
             // Inline big-endian write — see handleFC3 for the rationale.
+            let off = 1;
             for (let i = 0; i < length; i++) {
                 const v = registers[i];
-                const off = 1 + i * 2;
                 pdu[off] = (v >>> 8) & 0xff;
                 pdu[off + 1] = v & 0xff;
+                off += 2;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -3217,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) {
@@ -3259,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;
         }
@@ -3267,13 +3706,43 @@ class ModbusSlave extends EventEmitter {
             await this.responseError(appLayer, frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
             return;
         }
-        const value = new Array(length);
-        for (let i = 0; i < length; i++) {
-            // Bit math: kept as `Math.floor(i / 8)` / `i % 8` — V8 pattern-matches
-            // both forms with `i` as an integer loop counter to direct shifts, but
-            // measured ~+3% throughput vs the bit-shift form on this exact loop
-            // (benchmark/all-fcs.ts FC15 slave A/B, 8/8 paired samples).
-            value[i] = (frame.data[5 + Math.floor(i / 8)] & (1 << i % 8)) > 0;
+        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;
+            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;
+            if (rem > 1) {
+                value[outIdx++] = (byte >>> 1) & 0x01;
+            }
+            if (rem > 2) {
+                value[outIdx++] = (byte >>> 2) & 0x01;
+            }
+            if (rem > 3) {
+                value[outIdx++] = (byte >>> 3) & 0x01;
+            }
+            if (rem > 4) {
+                value[outIdx++] = (byte >>> 4) & 0x01;
+            }
+            if (rem > 5) {
+                value[outIdx++] = (byte >>> 5) & 0x01;
+            }
+            if (rem > 6) {
+                value[outIdx++] = (byte >>> 6) & 0x01;
+            }
         }
         try {
             if (model.writeMultipleCoils) {
@@ -3311,8 +3780,10 @@ class ModbusSlave extends EventEmitter {
             return;
         }
         const value = new Array(length);
+        let off = 5;
         for (let i = 0; i < length; i++) {
-            value[i] = (frame.data[5 + i * 2] << 8) | frame.data[6 + i * 2];
+            value[i] = (frame.data[off] << 8) | frame.data[off + 1];
+            off += 2;
         }
         try {
             if (model.writeMultipleRegisters) {
@@ -3339,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) {
@@ -3423,8 +3914,10 @@ class ModbusSlave extends EventEmitter {
             return;
         }
         const value = new Array(length.write);
+        let off = 9;
         for (let i = 0; i < length.write; i++) {
-            value[i] = (frame.data[9 + i * 2] << 8) | frame.data[10 + i * 2];
+            value[i] = (frame.data[off] << 8) | frame.data[off + 1];
+            off += 2;
         }
         try {
             await this._withIntervalLock(address.write, address.write + length.write, async () => {
@@ -3441,11 +3934,12 @@ class ModbusSlave extends EventEmitter {
             const pdu = Buffer.allocUnsafe(length.read * 2 + 1);
             pdu[0] = length.read * 2;
             // Inline big-endian write — see handleFC3 for the rationale.
+            let off = 1;
             for (let i = 0; i < length.read; i++) {
                 const v = registers[i];
-                const off = 1 + i * 2;
                 pdu[off] = (v >>> 8) & 0xff;
                 pdu[off + 1] = v & 0xff;
+                off += 2;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -3677,8 +4171,9 @@ class ModbusSlave extends EventEmitter {
         for (let i = 0; i < locks.length; i++) {
             const l = locks[i];
             if (l.lo < hi && lo < l.hi) {
-                if (overlap === null)
+                if (overlap === null) {
                     overlap = [];
+                }
                 overlap.push(l.promise);
             }
         }
@@ -3714,8 +4209,9 @@ class ModbusSlave extends EventEmitter {
             if (i !== -1) {
                 // O(1) swap-and-pop since lock order doesn't matter for correctness.
                 const last = locks.length - 1;
-                if (i !== last)
+                if (i !== last) {
                     locks[i] = locks[last];
+                }
                 locks.pop();
             }
         }