njs-modbus 3.2.0 → 3.3.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 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,11 +249,11 @@ 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) {
+]);
+function crc(data, start, end) {
     let crc = 0xffff;
     for (let index = start; index < end; index++) {
-        crc = (TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8)) & 0xffff;
+        crc = TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
     }
     return crc;
 }
@@ -231,114 +266,104 @@ function crc(data, start = 0, end = data.length) {
  * Infinity, and out-of-range values uniformly.
  */
 function isUint8(n) {
-    return Number.isInteger(n) && n >= 0 && n <= 255;
+    return (n & 0xff) === n;
 }
 
-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.
- */
+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(buffer, start, end, isResponse) {
-    if (end - start < 2) {
+    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;
+    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 (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;
+                    }
+                    cursor += 2 + buffer[cursor + 1];
+                }
+                return cursor - start + 2;
+            }
+            const decode = -val;
+            const offset = decode >> 8;
+            if (len <= offset) {
+                return PREDICT_NEED_MORE;
+            }
+            return (decode & 0xff) + buffer[start + offset];
         }
-        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) + buffer[start + offset];
         }
-        const objLen = buffer[cursor + 1];
-        cursor += 2 + objLen;
     }
-    return cursor - start + 2;
+    return PREDICT_UNKNOWN;
 }
 
 /**
@@ -347,10 +372,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();
+            }
         });
     });
 }
@@ -403,102 +430,172 @@ 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.
+ *
+ * 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[]
  *
- * 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.
+ * 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 remaining = Math.max(0, Math.ceil(deadline - performance.now()));
+                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 safeDelay = Math.min(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;
     }
@@ -1618,8 +1715,9 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
         while (state.end - state.start > 0) {
             const available = state.end - state.start;
             if (available < MIN_FRAME_LENGTH) {
-                if (this._handleIncomplete(state, strict))
+                if (this._handleIncomplete(state, strict)) {
                     return;
+                }
                 break;
             }
             const fc = pool[state.start + 1];
@@ -1648,8 +1746,9 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                     state.start += 1;
                     continue;
                 }
-                if (this._handleIncomplete(state, strict))
+                if (this._handleIncomplete(state, strict)) {
                     return;
+                }
                 break;
             }
             if (expected > MAX_FRAME_LENGTH || expected < MIN_FRAME_LENGTH) {
@@ -1663,8 +1762,9 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                     state.start += 1;
                     continue;
                 }
-                if (this._handleIncomplete(state, strict))
+                if (this._handleIncomplete(state, strict)) {
                     return;
+                }
                 break;
             }
             // CRC check inline: no helper call, no subarray for the CRC body.
@@ -1726,8 +1826,9 @@ 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);
@@ -1746,9 +1847,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);
@@ -1885,14 +1985,16 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         // 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;
         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 = HEX_DECODE[hexChars[hexOff]];
+            const lo = HEX_DECODE[hexChars[hexOff + 1]];
             if (hi === 0xff || lo === 0xff) {
                 this.onFramingError(new Error('Invalid hex character'));
                 return;
             }
             data[i] = (hi << 4) | lo;
+            hexOff += 2;
         }
         // Compute LRC over unit + fc + data.
         let sum = unit + fc;
@@ -1923,13 +2025,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;
@@ -2032,7 +2136,7 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
         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.
+            // encode() below. Hits on every received TCP frame.
             transaction: (buffer[0] << 8) | buffer[1],
             unit: buffer[6],
             fc: buffer[7],
@@ -2061,8 +2165,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 +2215,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 +2269,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) {
@@ -2345,7 +2458,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 +2471,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 +2506,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 +2533,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;
@@ -2449,8 +2568,42 @@ 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;
+                    let byteIdx = 1;
+                    let outIdx = 0;
+                    const fullBytes = length >> 3;
+                    for (let b = 0; b < fullBytes; b++) {
+                        const byte = frame.data[byteIdx++];
+                        data[outIdx++] = (byte & 0x01) > 0;
+                        data[outIdx++] = (byte & 0x02) > 0;
+                        data[outIdx++] = (byte & 0x04) > 0;
+                        data[outIdx++] = (byte & 0x08) > 0;
+                        data[outIdx++] = (byte & 0x10) > 0;
+                        data[outIdx++] = (byte & 0x20) > 0;
+                        data[outIdx++] = (byte & 0x40) > 0;
+                        data[outIdx++] = (byte & 0x80) > 0;
+                    }
+                    const rem = length & 7;
+                    if (rem) {
+                        const byte = frame.data[byteIdx];
+                        data[outIdx++] = (byte & 0x01) > 0;
+                        if (rem > 1) {
+                            data[outIdx++] = (byte & 0x02) > 0;
+                        }
+                        if (rem > 2) {
+                            data[outIdx++] = (byte & 0x04) > 0;
+                        }
+                        if (rem > 3) {
+                            data[outIdx++] = (byte & 0x08) > 0;
+                        }
+                        if (rem > 4) {
+                            data[outIdx++] = (byte & 0x10) > 0;
+                        }
+                        if (rem > 5) {
+                            data[outIdx++] = (byte & 0x20) > 0;
+                        }
+                        if (rem > 6) {
+                            data[outIdx++] = (byte & 0x40) > 0;
+                        }
                     }
                     // Mutate the frame in place rather than spread-copying — `frame` is freshly
                     // allocated per request and not retained anywhere else.
@@ -2498,9 +2651,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);
@@ -2591,10 +2745,19 @@ class ModbusMaster extends EventEmitter {
         bufferTx[2] = (value.length >>> 8) & 0xff;
         bufferTx[3] = value.length & 0xff;
         bufferTx[4] = byteCount;
+        let acc = 0;
+        let out = 5;
         for (let i = 0; i < value.length; i++) {
             if (value[i]) {
-                bufferTx[5 + Math.floor(i / 8)] |= 1 << i % 8;
+                acc |= 1 << (i & 7);
             }
+            if ((i & 7) === 7) {
+                bufferTx[out++] = acc;
+                acc = 0;
+            }
+        }
+        if ((value.length & 7) !== 0) {
+            bufferTx[out] = acc;
         }
         return new Promise((resolve, reject) => {
             this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
@@ -2628,11 +2791,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,10 +2834,12 @@ 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)),
@@ -2736,11 +2902,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 +2926,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 +2955,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 +2988,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 +3040,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 +3070,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) {
@@ -3057,23 +3230,68 @@ 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;
+            if (coils instanceof Uint8Array) {
+                // Branchless fast path — `coils[i]` is already 0/1, no boolean
+                // coercion or conditional jumps. At max payload (2000 coils) this
+                // avoids 2000 branch-predictor slots and boolean-to-number casts.
+                let out = 1;
+                const fullBytes = length >> 3;
+                for (let i = 0; i < fullBytes; i++) {
+                    const base = i << 3;
+                    pdu[out++] =
+                        (coils[base] & 1) |
+                            ((coils[base + 1] & 1) << 1) |
+                            ((coils[base + 2] & 1) << 2) |
+                            ((coils[base + 3] & 1) << 3) |
+                            ((coils[base + 4] & 1) << 4) |
+                            ((coils[base + 5] & 1) << 5) |
+                            ((coils[base + 6] & 1) << 6) |
+                            ((coils[base + 7] & 1) << 7);
+                }
+                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;
+                }
+            }
+            else {
+                // Fallback for boolean[] — accumulate into `acc` and write a full byte
+                // once each lane is finished. Saves N `|=` read-modify-writes on the
+                // output buffer.
+                let acc = 0;
+                let out = 1;
+                for (let i = 0; i < length; i++) {
+                    if (coils[i]) {
+                        acc |= 1 << (i & 7);
+                    }
+                    if ((i & 7) === 7) {
+                        pdu[out++] = acc;
+                        acc = 0;
+                    }
+                }
+                if ((length & 7) !== 0) {
+                    pdu[out] = acc;
                 }
             }
-            if ((length & 7) !== 0)
-                pdu[out] = acc;
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
         catch (error) {
@@ -3104,19 +3322,62 @@ 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;
+            if (discreteInputs instanceof Uint8Array) {
+                let out = 1;
+                const fullBytes = length >> 3;
+                for (let i = 0; i < fullBytes; i++) {
+                    const base = i << 3;
+                    pdu[out++] =
+                        (discreteInputs[base] & 1) |
+                            ((discreteInputs[base + 1] & 1) << 1) |
+                            ((discreteInputs[base + 2] & 1) << 2) |
+                            ((discreteInputs[base + 3] & 1) << 3) |
+                            ((discreteInputs[base + 4] & 1) << 4) |
+                            ((discreteInputs[base + 5] & 1) << 5) |
+                            ((discreteInputs[base + 6] & 1) << 6) |
+                            ((discreteInputs[base + 7] & 1) << 7);
+                }
+                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;
+                }
+            }
+            else {
+                let acc = 0;
+                let out = 1;
+                for (let i = 0; i < length; i++) {
+                    if (discreteInputs[i]) {
+                        acc |= 1 << (i & 7);
+                    }
+                    if ((i & 7) === 7) {
+                        pdu[out++] = acc;
+                        acc = 0;
+                    }
+                }
+                if ((length & 7) !== 0) {
+                    pdu[out] = acc;
                 }
             }
-            if ((length & 7) !== 0)
-                pdu[out] = acc;
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
         catch (error) {
@@ -3149,11 +3410,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 +3447,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));
         }
@@ -3268,12 +3531,42 @@ class ModbusSlave extends EventEmitter {
             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;
+        let byteIdx = 5;
+        let outIdx = 0;
+        const fullBytes = length >> 3;
+        for (let b = 0; b < fullBytes; b++) {
+            const byte = frame.data[byteIdx++];
+            value[outIdx++] = (byte & 0x01) > 0;
+            value[outIdx++] = (byte & 0x02) > 0;
+            value[outIdx++] = (byte & 0x04) > 0;
+            value[outIdx++] = (byte & 0x08) > 0;
+            value[outIdx++] = (byte & 0x10) > 0;
+            value[outIdx++] = (byte & 0x20) > 0;
+            value[outIdx++] = (byte & 0x40) > 0;
+            value[outIdx++] = (byte & 0x80) > 0;
+        }
+        const rem = length & 7;
+        if (rem) {
+            const byte = frame.data[byteIdx];
+            value[outIdx++] = (byte & 0x01) > 0;
+            if (rem > 1) {
+                value[outIdx++] = (byte & 0x02) > 0;
+            }
+            if (rem > 2) {
+                value[outIdx++] = (byte & 0x04) > 0;
+            }
+            if (rem > 3) {
+                value[outIdx++] = (byte & 0x08) > 0;
+            }
+            if (rem > 4) {
+                value[outIdx++] = (byte & 0x10) > 0;
+            }
+            if (rem > 5) {
+                value[outIdx++] = (byte & 0x20) > 0;
+            }
+            if (rem > 6) {
+                value[outIdx++] = (byte & 0x40) > 0;
+            }
         }
         try {
             if (model.writeMultipleCoils) {
@@ -3311,8 +3604,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) {
@@ -3423,8 +3718,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 +3738,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 +3975,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 +4013,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();
             }
         }