njs-modbus 3.1.1 → 3.3.0

package/dist/index.cjs

@@ -91,6 +91,10 @@ exports.ConformityLevel = void 0;
 })(exports.ConformityLevel || (exports.ConformityLevel = {}));
 /** Shared empty Buffer to avoid repeated allocations. */
 const EMPTY_BUFFER = Buffer.alloc(0);
+/** Shared no-op function to avoid repeated allocations. */
+const NOOP = () => {
+    /* no-op */
+};
 /** Modbus V1.1b3 PDU quantity limits. */
 const LIMITS = {
     READ_COILS_MIN: 0x0001,
@@ -162,40 +166,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,
@@ -212,11 +251,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;
 }
@@ -229,110 +268,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) {
-    return (~data.reduce((sum, n) => sum + n, 0) + 1) & 0xff;
+function lrc(data, start, end) {
+    let sum = 0;
+    for (let i = start; i < end; i++) {
+        sum += data[i];
+    }
+    return -sum & 0xff;
 }
 
-const REQUEST_FIXED_LENGTHS = {
-    [exports.FunctionCode.READ_COILS]: 8,
-    [exports.FunctionCode.READ_DISCRETE_INPUTS]: 8,
-    [exports.FunctionCode.READ_HOLDING_REGISTERS]: 8,
-    [exports.FunctionCode.READ_INPUT_REGISTERS]: 8,
-    [exports.FunctionCode.WRITE_SINGLE_COIL]: 8,
-    [exports.FunctionCode.WRITE_SINGLE_REGISTER]: 8,
-    [exports.FunctionCode.REPORT_SERVER_ID]: 4,
-    [exports.FunctionCode.MASK_WRITE_REGISTER]: 10,
-    [exports.FunctionCode.READ_DEVICE_IDENTIFICATION]: 7,
-};
-const REQUEST_BYTE_COUNT = {
-    [exports.FunctionCode.WRITE_MULTIPLE_COILS]: { offset: 6, extra: 9 },
-    [exports.FunctionCode.WRITE_MULTIPLE_REGISTERS]: { offset: 6, extra: 9 },
-    [exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 10, extra: 13 },
-};
-const RESPONSE_FIXED_LENGTHS = {
-    [exports.FunctionCode.WRITE_SINGLE_COIL]: 8,
-    [exports.FunctionCode.WRITE_SINGLE_REGISTER]: 8,
-    [exports.FunctionCode.WRITE_MULTIPLE_COILS]: 8,
-    [exports.FunctionCode.WRITE_MULTIPLE_REGISTERS]: 8,
-    [exports.FunctionCode.MASK_WRITE_REGISTER]: 10,
-};
-const RESPONSE_BYTE_COUNT = {
-    [exports.FunctionCode.READ_COILS]: { offset: 2, extra: 5 },
-    [exports.FunctionCode.READ_DISCRETE_INPUTS]: { offset: 2, extra: 5 },
-    [exports.FunctionCode.READ_HOLDING_REGISTERS]: { offset: 2, extra: 5 },
-    [exports.FunctionCode.READ_INPUT_REGISTERS]: { offset: 2, extra: 5 },
-    [exports.FunctionCode.REPORT_SERVER_ID]: { offset: 2, extra: 5 },
-    [exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 2, extra: 5 },
-};
-/** 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, isResponse) {
-    if (buffer.length < 2) {
+const REQ_TABLE = new Int32Array(256);
+const RES_TABLE = new Int32Array(256);
+(function initTables() {
+    REQ_TABLE[exports.FunctionCode.READ_COILS] = 8;
+    REQ_TABLE[exports.FunctionCode.READ_DISCRETE_INPUTS] = 8;
+    REQ_TABLE[exports.FunctionCode.READ_HOLDING_REGISTERS] = 8;
+    REQ_TABLE[exports.FunctionCode.READ_INPUT_REGISTERS] = 8;
+    REQ_TABLE[exports.FunctionCode.WRITE_SINGLE_COIL] = 8;
+    REQ_TABLE[exports.FunctionCode.WRITE_SINGLE_REGISTER] = 8;
+    REQ_TABLE[exports.FunctionCode.REPORT_SERVER_ID] = 4;
+    REQ_TABLE[exports.FunctionCode.MASK_WRITE_REGISTER] = 10;
+    REQ_TABLE[exports.FunctionCode.READ_DEVICE_IDENTIFICATION] = 7;
+    REQ_TABLE[exports.FunctionCode.WRITE_MULTIPLE_COILS] = -1545;
+    REQ_TABLE[exports.FunctionCode.WRITE_MULTIPLE_REGISTERS] = -1545;
+    REQ_TABLE[exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -2573;
+    RES_TABLE[exports.FunctionCode.WRITE_SINGLE_COIL] = 8;
+    RES_TABLE[exports.FunctionCode.WRITE_SINGLE_REGISTER] = 8;
+    RES_TABLE[exports.FunctionCode.WRITE_MULTIPLE_COILS] = 8;
+    RES_TABLE[exports.FunctionCode.WRITE_MULTIPLE_REGISTERS] = 8;
+    RES_TABLE[exports.FunctionCode.MASK_WRITE_REGISTER] = 10;
+    RES_TABLE[exports.FunctionCode.READ_COILS] = -517;
+    RES_TABLE[exports.FunctionCode.READ_DISCRETE_INPUTS] = -517;
+    RES_TABLE[exports.FunctionCode.READ_HOLDING_REGISTERS] = -517;
+    RES_TABLE[exports.FunctionCode.READ_INPUT_REGISTERS] = -517;
+    RES_TABLE[exports.FunctionCode.REPORT_SERVER_ID] = -517;
+    RES_TABLE[exports.FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -517;
+    RES_TABLE[exports.FunctionCode.READ_DEVICE_IDENTIFICATION] = -999;
+})();
+function predictRtuFrameLength(buffer, start, end, isResponse) {
+    const len = end - start;
+    if (len < 2) {
         return PREDICT_NEED_MORE;
     }
-    const fc = buffer[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 (buffer.length <= bc.offset) {
-            return PREDICT_NEED_MORE;
+    const fc = buffer[start + 1];
+    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[bc.offset];
-    }
-    if (isResponse && fc === exports.FunctionCode.READ_DEVICE_IDENTIFICATION) {
-        return predictFc43_14Response(buffer);
-    }
-    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) {
-    if (buffer.length < 8) {
-        return PREDICT_NEED_MORE;
-    }
-    if (buffer[2] !== MEI_READ_DEVICE_ID) {
-        return PREDICT_UNKNOWN;
     }
-    const numObjs = buffer[7];
-    let offset = 8;
-    for (let i = 0; i < numObjs; i++) {
-        if (buffer.length < offset + 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[offset + 1];
-        offset += 2 + objLen;
     }
-    return offset + 2;
+    return PREDICT_UNKNOWN;
 }
 
 /**
@@ -341,10 +374,12 @@ function predictFc43_14Response(buffer) {
 function promisifyCb(fn) {
     return new Promise((resolve, reject) => {
         fn((err) => {
-            if (err)
+            if (err) {
                 reject(err);
-            else
+            }
+            else {
                 resolve();
+            }
         });
     });
 }
@@ -397,6 +432,177 @@ function resolveRtuTiming(opts = {}, baudRate) {
     return { intervalBetweenFrames, interCharTimeout };
 }
 
+/**
+ * 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[]
+ *
+ * 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;
+    _boundTick;
+    _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;
+    }
+    get size() {
+        return this._mode === 'direct' ? this._directTimers.size : this._deadlines.length;
+    }
+    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);
+        this._seqs.push(seq);
+        while (i > 0) {
+            const p = (i - 1) >> 1;
+            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;
+        this._seqs[i] = seq;
+        if (i === 0) {
+            this._refresh();
+        }
+    }
+    _refresh() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        if (this._deadlines.length === 0) {
+            return;
+        }
+        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
+        const safeDelay = Math.min(delay, 2147483647);
+        this._timer = setTimeout(this._boundTick, safeDelay);
+    }
+    _onTick() {
+        this._timer = null;
+        const now = performance.now();
+        try {
+            while (this._deadlines.length > 0 && this._deadlines[0] <= now) {
+                const id = this._pop();
+                this._onFire(id);
+            }
+        }
+        finally {
+            this._refresh();
+        }
+    }
+    _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;
+            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[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;
+    }
+}
+
 /**
  * Normalize an IP address by stripping the IPv4-mapped IPv6 prefix.
  * This ensures consistent comparison of addresses like `::ffff:192.168.1.1`.
@@ -1341,14 +1547,16 @@ function createPhysicalLayer(config) {
  * established and discarded when the connection closes. Subclasses implement
  * ASCII, RTU, or TCP framing rules.
  */
-class AbstractApplicationLayer extends EventEmitter {
+class AbstractApplicationLayer {
+    /** Called when a complete frame is decoded. Defaults to no-op. */
+    onFraming = NOOP;
+    /** Called when a framing error is detected. Defaults to no-op. */
+    onFramingError = NOOP;
     flush() {
         // no-op — override in subclasses
     }
-    addCustomFunctionCode(cfc) {
-    }
-    removeCustomFunctionCode(fc) {
-    }
+    addCustomFunctionCode(cfc) { }
+    removeCustomFunctionCode(fc) { }
 }
 
 const MAX_FRAME_LENGTH = 256;
@@ -1362,7 +1570,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
     _threePointFiveT;
     _onePointFiveT;
     _customFunctionCodes = new Map();
-    _cleanupFns = new Set();
+    _cleanupCbs = [];
     get connection() {
         return this._connection;
     }
@@ -1378,7 +1586,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
         const onData = (data) => {
             const state = this._state;
             if (state.t15Expired && state.end > state.start) {
-                this.emit('framing-error', new Error('Inter-character timeout (t1.5) exceeded'));
+                this.onFramingError(new Error('Inter-character timeout (t1.5) exceeded'));
                 state.start = 0;
                 state.end = 0;
             }
@@ -1420,7 +1628,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                             // 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.emit('framing-error', new Error('Frame buffer exhausted before complete frame received'));
+                            this.onFramingError(new Error('Frame buffer exhausted before complete frame received'));
                             currentState.start = 0;
                             currentState.end = 0;
                             currentState.t15Expired = false;
@@ -1456,16 +1664,16 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             }
         };
         connection.on('data', onData);
-        this._cleanupFns.add(() => connection.off('data', onData));
+        this._cleanupCbs.push(() => connection.off('data', onData));
         const onClose = () => {
-            for (const fn of this._cleanupFns) {
+            for (const fn of this._cleanupCbs) {
                 fn();
             }
-            this._cleanupFns.clear();
+            this._cleanupCbs.length = 0;
             this.clearStateTimers();
         };
         connection.on('close', onClose);
-        this._cleanupFns.add(() => connection.off('close', onClose));
+        this._cleanupCbs.push(() => connection.off('close', onClose));
     }
     clearStateTimers() {
         const state = this._state;
@@ -1478,35 +1686,40 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             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;
-        // Shared handler for every "frame is not yet complete" exit. Returns true
-        // when the caller should `return` (strict reset), false to `break` the
-        // parse loop. Hot path never reaches here — only error/incomplete edges.
-        const handleIncomplete = () => {
-            if (strict) {
-                this.emit('framing-error', new Error(state.t15Expired ? 'Inter-character timeout (t1.5) exceeded' : 'Incomplete frame at t3.5'));
-                state.start = 0;
-                state.end = 0;
-                state.t15Expired = false;
-                return true;
-            }
-            if (state.t15Expired) {
-                this.emit('framing-error', new Error('Inter-character timeout (t1.5) exceeded'));
-                state.start = 0;
-                state.end = 0;
-                state.t15Expired = false;
-            }
-            return false;
-        };
         while (state.end - state.start > 0) {
             const available = state.end - state.start;
             if (available < MIN_FRAME_LENGTH) {
-                if (handleIncomplete())
+                if (this._handleIncomplete(state, strict)) {
                     return;
+                }
                 break;
             }
             const fc = pool[state.start + 1];
@@ -1514,7 +1727,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             let expected;
             if (cfc) {
                 const predictor = isResponse ? cfc.predictResponseLength : cfc.predictRequestLength;
-                const predicted = predictor(pool.subarray(state.start, state.end));
+                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;
@@ -1522,9 +1735,9 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             else {
                 // Standard FC path. predictRtuFrameLength uses sentinel returns to
                 // avoid per-call object allocation on the decode hot path.
-                expected = predictRtuFrameLength(pool.subarray(state.start, state.end), isResponse);
+                expected = predictRtuFrameLength(pool, state.start, state.end, isResponse);
                 if (expected === PREDICT_UNKNOWN) {
-                    this.emit('framing-error', new Error(`Unknown function code 0x${fc.toString(16).padStart(2, '0')} — register a CustomFunctionCode to frame this FC`));
+                    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;
@@ -1535,12 +1748,13 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                     state.start += 1;
                     continue;
                 }
-                if (handleIncomplete())
+                if (this._handleIncomplete(state, strict)) {
                     return;
+                }
                 break;
             }
             if (expected > MAX_FRAME_LENGTH || expected < MIN_FRAME_LENGTH) {
-                this.emit('framing-error', new Error('Invalid data'));
+                this.onFramingError(new Error('Invalid data'));
                 state.start = 0;
                 state.end = 0;
                 return;
@@ -1550,8 +1764,9 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                     state.start += 1;
                     continue;
                 }
-                if (handleIncomplete())
+                if (this._handleIncomplete(state, strict)) {
                     return;
+                }
                 break;
             }
             // CRC check inline: no helper call, no subarray for the CRC body.
@@ -1561,7 +1776,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             const actualCrc = crc(pool, crcStart, crcEnd);
             if (expectedCrc !== actualCrc) {
                 if (strict) {
-                    this.emit('framing-error', new Error('CRC mismatch'));
+                    this.onFramingError(new Error('CRC mismatch'));
                     state.start = 0;
                     state.end = 0;
                     state.t15Expired = false;
@@ -1582,7 +1797,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                 data: frameBuf.subarray(2, expected - 2),
                 buffer: frameBuf,
             };
-            this.emit('framing', frame);
+            this.onFraming(frame);
         }
         if (state.start > 0) {
             if (state.start < state.end) {
@@ -1609,11 +1824,22 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     encode(unit, fc, data, transaction) {
         const buffer = Buffer.allocUnsafe(data.length + 4);
-        buffer.writeUInt8(unit, 0);
-        buffer.writeUInt8(fc, 1);
-        buffer.set(data, 2);
+        // Inline header — direct typed-array stores skip Buffer's per-call checks.
+        buffer[0] = unit;
+        buffer[1] = fc;
+        if (data.length <= 16) {
+            for (let i = 0; i < data.length; i++) {
+                buffer[2 + i] = data[i];
+            }
+        }
+        else {
+            buffer.set(data, 2);
+        }
         const crcEnd = buffer.length - 2;
-        buffer.writeUInt16LE(crc(buffer, 0, crcEnd), crcEnd);
+        const c = crc(buffer, 0, crcEnd);
+        // Little-endian inline write of CRC trailer.
+        buffer[crcEnd] = c & 0xff;
+        buffer[crcEnd + 1] = (c >>> 8) & 0xff;
         return buffer;
     }
 }
@@ -1623,9 +1849,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);
@@ -1644,8 +1869,8 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
     ROLE;
     lenientHex;
     _connection;
-    _state = { status: 'idle', frame: [] };
-    _cleanupFns = new Set();
+    _state = { status: 'idle', frame: new Uint8Array(MAX_ASCII_PAYLOAD), frameLen: 0 };
+    _cleanupCbs = [];
     get connection() {
         return this._connection;
     }
@@ -1669,114 +1894,148 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
         };
         const onData = (data) => {
             const state = this._state;
-            data.forEach((value) => {
+            for (let i = 0; i < data.length; i++) {
+                const value = data[i];
                 switch (state.status) {
                     case 'idle': {
                         if (value === CHAR_CODE.COLON) {
                             state.status = 'reception';
-                            state.frame = [];
+                            state.frameLen = 0;
                         }
                         break;
                     }
                     case 'reception': {
                         if (value === CHAR_CODE.COLON) {
-                            state.frame = [];
+                            state.frameLen = 0;
                         }
                         else if (value === CHAR_CODE.CR) {
                             state.status = 'waiting end';
                         }
-                        else if (state.frame.length >= MAX_ASCII_PAYLOAD) {
+                        else if (state.frameLen >= MAX_ASCII_PAYLOAD) {
                             state.status = 'idle';
-                            state.frame = [];
-                            this.emit('framing-error', new Error('Invalid data'));
+                            state.frameLen = 0;
+                            this.onFramingError(new Error('Invalid data'));
                         }
                         else if (!isHexChar(value)) {
                             state.status = 'idle';
-                            state.frame = [];
-                            this.emit('framing-error', new Error('Invalid hex character'));
+                            state.frameLen = 0;
+                            this.onFramingError(new Error('Invalid hex character'));
                         }
                         else {
-                            state.frame.push(value);
+                            state.frame[state.frameLen++] = value;
                         }
                         break;
                     }
                     case 'waiting end': {
                         if (value === CHAR_CODE.COLON) {
                             state.status = 'reception';
-                            state.frame = [];
+                            state.frameLen = 0;
                         }
                         else {
                             state.status = 'idle';
                             if (value === CHAR_CODE.LF) {
-                                this.framing(Buffer.from(state.frame));
+                                this.framing(state.frame, state.frameLen);
                             }
                         }
                         break;
                     }
                 }
-            });
+            }
         };
         connection.on('data', onData);
-        this._cleanupFns.add(() => connection.off('data', onData));
+        this._cleanupCbs.push(() => connection.off('data', onData));
         const onClose = () => {
-            for (const fn of this._cleanupFns) {
+            for (const fn of this._cleanupCbs) {
                 fn();
             }
-            this._cleanupFns.clear();
+            this._cleanupCbs.length = 0;
         };
         connection.on('close', onClose);
-        this._cleanupFns.add(() => connection.off('close', onClose));
+        this._cleanupCbs.push(() => connection.off('close', onClose));
     }
-    framing(hexChars) {
-        if (hexChars.length < 6) {
-            this.emit('framing-error', new Error('Insufficient data length'));
+    framing(hexChars, hexLen) {
+        if (hexLen < 6) {
+            this.onFramingError(new Error('Insufficient data length'));
+            return;
+        }
+        if (hexLen % 2 !== 0) {
+            this.onFramingError(new Error('Invalid data'));
             return;
         }
-        if (hexChars.length % 2 !== 0) {
-            this.emit('framing-error', new Error('Invalid data'));
+        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]];
+        if (unitHi === 0xff || unitLo === 0xff || fcHi === 0xff || fcLo === 0xff) {
+            this.onFramingError(new Error('Invalid hex character'));
             return;
         }
-        const decoded = Buffer.allocUnsafe(hexChars.length / 2);
-        for (let i = 0; i < hexChars.length; i += 2) {
-            const hi = HEX_DECODE[hexChars[i]];
-            const lo = HEX_DECODE[hexChars[i + 1]];
-            // Defensive: the FSM should already have filtered non-hex characters,
-            // but guard here in case framing is ever called directly.
+        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]];
+        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.
+        // 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[hexOff]];
+            const lo = HEX_DECODE[hexChars[hexOff + 1]];
             if (hi === 0xff || lo === 0xff) {
-                this.emit('framing-error', new Error('Invalid hex character'));
+                this.onFramingError(new Error('Invalid hex character'));
                 return;
             }
-            decoded[i / 2] = (hi << 4) | lo;
+            data[i] = (hi << 4) | lo;
+            hexOff += 2;
         }
-        const frame = {
-            unit: decoded[0],
-            fc: decoded[1],
-            data: decoded.subarray(2, decoded.length - 1),
-            buffer: hexChars,
-        };
-        const lrcPassed = decoded[decoded.length - 1] === lrc(decoded.subarray(0, decoded.length - 1));
-        if (!lrcPassed) {
-            this.emit('framing-error', new Error('LRC check failed'));
+        // Compute LRC over unit + fc + data.
+        let sum = unit + fc;
+        for (let i = 0; i < dataLen; i++) {
+            sum += data[i];
+        }
+        const lrcComputed = (~sum + 1) & 0xff;
+        if (lrcIn !== lrcComputed) {
+            this.onFramingError(new Error('LRC check failed'));
             return;
         }
-        this.emit('framing', frame);
+        const frame = {
+            unit,
+            fc,
+            data,
+            buffer: Buffer.copyBytesFrom(hexChars, 0, hexLen),
+        };
+        this.onFraming(frame);
     }
     flush() {
-        this._state = { status: 'idle', frame: [] };
+        this._state.status = 'idle';
+        this._state.frameLen = 0;
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     encode(unit, fc, data, transaction) {
         const buffer = Buffer.allocUnsafe(data.length + 3);
-        buffer.writeUInt8(unit, 0);
-        buffer.writeUInt8(fc, 1);
+        // Inline header + LRC — direct typed-array stores skip Buffer's per-call checks.
+        buffer[0] = unit;
+        buffer[1] = fc;
         buffer.set(data, 2);
-        buffer.writeUInt8(lrc(buffer.subarray(0, -1)), buffer.length - 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;
@@ -1791,7 +2050,7 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
     _connection;
     _transactionId = 1;
     _buffer = EMPTY_BUFFER;
-    _cleanupFns = new Set();
+    _cleanupCbs = [];
     get connection() {
         return this._connection;
     }
@@ -1800,6 +2059,17 @@ 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;
+                }
+            }
             let buffer = this._buffer;
             if (buffer.length === 0) {
                 buffer = data;
@@ -1817,7 +2087,7 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
                     break;
                 }
                 else {
-                    this.emit('framing-error', result.error);
+                    this.onFramingError(result.error);
                     buffer = EMPTY_BUFFER;
                     break;
                 }
@@ -1837,15 +2107,15 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
             }
         };
         connection.on('data', onData);
-        this._cleanupFns.add(() => connection.off('data', onData));
+        this._cleanupCbs.push(() => connection.off('data', onData));
         const onClose = () => {
-            for (const fn of this._cleanupFns) {
+            for (const fn of this._cleanupCbs) {
                 fn();
             }
-            this._cleanupFns.clear();
+            this._cleanupCbs.length = 0;
         };
         connection.on('close', onClose);
-        this._cleanupFns.add(() => connection.off('close', onClose));
+        this._cleanupCbs.push(() => connection.off('close', onClose));
     }
     tryExtract(buffer) {
         if (buffer.length < 8) {
@@ -1854,7 +2124,7 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
         if (buffer[2] !== 0 || buffer[3] !== 0) {
             return { kind: 'error', error: new Error('Invalid data') };
         }
-        const length = buffer.readUInt16BE(4);
+        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') };
@@ -1862,29 +2132,48 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
         if (buffer.length < total) {
             return { kind: 'insufficient' };
         }
-        return { kind: 'frame', frame: buffer.subarray(0, total), rest: buffer.subarray(total) };
+        return { kind: 'frame', frame: buffer.subarray(0, total), rest: total === buffer.length ? EMPTY_BUFFER : buffer.subarray(total) };
     }
     processFrame(buffer) {
         const frame = {
-            transaction: buffer.readUInt16BE(0),
+            // Inline 16-bit BE read — direct typed-array loads skip readUInt16BE's
+            // argument coercion + bounds check. Symmetric to the header writes in
+            // encode() below. Hits on every received TCP frame.
+            transaction: (buffer[0] << 8) | buffer[1],
             unit: buffer[6],
             fc: buffer[7],
             data: buffer.subarray(8),
             buffer,
         };
-        this.emit('framing', frame);
+        this.onFraming(frame);
     }
     flush() {
         this._buffer = EMPTY_BUFFER;
     }
     encode(unit, fc, data, transaction) {
         const buffer = Buffer.allocUnsafe(data.length + 8);
-        buffer.writeUInt16BE(transaction ?? this._transactionId, 0);
-        buffer.writeUInt16BE(0, 2);
-        buffer.writeUInt16BE(data.length + 2, 4);
-        buffer.writeUInt8(unit, 6);
-        buffer.writeUInt8(fc, 7);
-        buffer.set(data, 8);
+        // Inline big-endian header writes — direct typed-array stores skip the
+        // argument validation + bounds checks that `writeUInt16BE/writeUInt8` run.
+        const tid = transaction ?? this._transactionId;
+        const len = data.length + 2;
+        buffer[0] = (tid >>> 8) & 0xff;
+        buffer[1] = tid & 0xff;
+        buffer[2] = 0;
+        buffer[3] = 0;
+        buffer[4] = (len >>> 8) & 0xff;
+        buffer[5] = len & 0xff;
+        buffer[6] = unit;
+        buffer[7] = fc;
+        // 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++) {
+                buffer[8 + i] = data[i];
+            }
+        }
+        else {
+            buffer.set(data, 8);
+        }
         if (transaction === undefined) {
             this._transactionId = (this._transactionId + 1) % 65536 || 1;
         }
@@ -1928,26 +2217,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;
@@ -1963,14 +2259,32 @@ class ModbusMaster extends EventEmitter {
     _queueDatas = [];
     _queueTimeouts = [];
     _queueBroadcasts = [];
-    _queueResolves = [];
-    _queueRejects = [];
+    _queueCallbacks = [];
     _queueHead = 0;
     _queueLen = 0;
     _draining = false;
     _nextTid = 1;
     _cleanupFns = new Set();
     _closePromise = null;
+    _nextExchangeId = 1;
+    // Global timer heap with lazy deletion — one native setTimeout for all requests.
+    _pendingExchanges = new Map();
+    _timerHeap = new TimerHeap((id) => {
+        const pending = this._pendingExchanges.get(id);
+        if (!pending) {
+            return;
+        } // lazy deletion: already handled
+        pending.settled = true;
+        this._pendingExchanges.delete(id);
+        if (pending.sessionKey !== null) {
+            this._masterSession.stop(pending.sessionKey);
+        }
+        const cb = pending.callback;
+        if (cb) {
+            pending.callback = null;
+            cb(new Error('Timeout'));
+        }
+    });
     get state() {
         return this._physicalLayer.state;
     }
@@ -1997,17 +2311,21 @@ class ModbusMaster extends EventEmitter {
             for (const cfc of this._customFunctionCodes.values()) {
                 appLayer.addCustomFunctionCode(cfc);
             }
-            const cleanupFraming = () => appLayer.off('framing', onFraming);
+            const cleanupFraming = () => {
+                appLayer.onFraming = NOOP;
+            };
             const onFraming = (frame) => {
                 this._masterSession.handleFrame(frame);
             };
-            appLayer.on('framing', onFraming);
+            appLayer.onFraming = onFraming;
             this._cleanupFns.add(cleanupFraming);
-            const cleanupFramingError = () => appLayer.off('framing-error', onFramingError);
+            const cleanupFramingError = () => {
+                appLayer.onFramingError = NOOP;
+            };
             const onFramingError = (error) => {
                 this._masterSession.handleError(error);
             };
-            appLayer.on('framing-error', onFramingError);
+            appLayer.onFramingError = onFramingError;
             this._cleanupFns.add(cleanupFramingError);
             const cleanupClose = () => connection.off('close', onClose);
             const onClose = () => {
@@ -2063,31 +2381,23 @@ class ModbusMaster extends EventEmitter {
         }
         return new AsciiApplicationLayer('MASTER', connection, this._protocol.opts);
     }
-    send(unit, fc, data, timeout, broadcast) {
+    _send(unit, fc, data, timeout, broadcast, callback) {
         if (this._physicalLayer.state !== exports.PhysicalState.OPEN) {
-            return Promise.reject(new Error('Master is not open'));
+            callback(new Error('Master is not open'));
+            return;
         }
         if (this.concurrent) {
-            return new Promise((resolve, reject) => {
-                this._exchange(unit, fc, data, timeout, broadcast, (err, frame) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(frame);
-                });
-            });
+            this._exchange(unit, fc, data, timeout, broadcast, callback);
+            return;
         }
-        return new Promise((resolve, reject) => {
-            this._queueUnits.push(unit);
-            this._queueFcs.push(fc);
-            this._queueDatas.push(data);
-            this._queueTimeouts.push(timeout);
-            this._queueBroadcasts.push(broadcast);
-            this._queueResolves.push(resolve);
-            this._queueRejects.push(reject);
-            this._queueLen++;
-            this._drain();
-        });
+        this._queueUnits.push(unit);
+        this._queueFcs.push(fc);
+        this._queueDatas.push(data);
+        this._queueTimeouts.push(timeout);
+        this._queueBroadcasts.push(broadcast);
+        this._queueCallbacks.push(callback);
+        this._queueLen++;
+        this._drain();
     }
     _drain() {
         if (this._draining || this._physicalLayer.state !== exports.PhysicalState.OPEN) {
@@ -2108,14 +2418,12 @@ class ModbusMaster extends EventEmitter {
         const data = this._queueDatas[h];
         const timeout = this._queueTimeouts[h];
         const broadcast = this._queueBroadcasts[h];
-        const resolve = this._queueResolves[h];
-        const reject = this._queueRejects[h];
-        // Drop references so the GC can reclaim data buffers and resolve/reject
+        const callback = this._queueCallbacks[h];
+        // Drop references so the GC can reclaim data buffers and callback
         // closures while the rest of the queue is still draining. Primitives
         // (unit/fc/timeout/broadcast) need no clearing.
         this._queueDatas[h] = undefined;
-        this._queueResolves[h] = undefined;
-        this._queueRejects[h] = undefined;
+        this._queueCallbacks[h] = undefined;
         this._queueHead = h + 1;
         this._queueLen--;
         if (this._queueLen === 0) {
@@ -2126,15 +2434,11 @@ class ModbusMaster extends EventEmitter {
             this._queueDatas.length = 0;
             this._queueTimeouts.length = 0;
             this._queueBroadcasts.length = 0;
-            this._queueResolves.length = 0;
-            this._queueRejects.length = 0;
+            this._queueCallbacks.length = 0;
             this._queueHead = 0;
         }
         this._exchange(unit, fc, data, timeout, broadcast, (err, frame) => {
-            if (err)
-                reject(err);
-            else
-                resolve(frame);
+            callback(err, frame);
             this._processNext();
         });
     }
@@ -2154,30 +2458,39 @@ class ModbusMaster extends EventEmitter {
         if (!this.concurrent) {
             appLayer.flush();
         }
+        // Lazy-deletion timer architecture:
+        // 1. Assign an exchangeId and register in _pendingExchanges.
+        // 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++;
+        const pending = { settled: false, callback, sessionKey: null };
+        this._pendingExchanges.set(exchangeId, pending);
         if (broadcast) {
-            // Broadcast: no response expected. Skip the session entirely — registering
-            // a waiter under FIFO_KEY would race with any concurrent FIFO request (the
-            // broadcast's stop() would clear the other request's slot/timer).
-            let settled = false;
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                callback(new Error('Timeout'));
-            }, timeout);
+            // Broadcast: no response expected. Skip the session entirely.
+            this._timerHeap.add(exchangeId, timeout);
             connection.write(appLayer.encode(unit, fc, data), (writeErr) => {
-                if (settled)
+                const p = this._pendingExchanges.get(exchangeId);
+                if (!p || p.settled) {
                     return;
-                clearTimeout(timer);
-                settled = true;
+                }
+                const cb = p.callback;
+                if (!cb) {
+                    return;
+                }
+                p.settled = true;
+                p.callback = null;
+                this._pendingExchanges.delete(exchangeId);
                 if (writeErr) {
-                    callback(writeErr);
+                    cb(writeErr);
                 }
                 else if (this._physicalLayer.state !== exports.PhysicalState.OPEN) {
-                    callback(new Error('Master is not open'));
+                    cb(new Error('Master is not open'));
                 }
                 else {
-                    callback(null);
+                    cb(null);
                 }
             });
             return;
@@ -2191,62 +2504,118 @@ class ModbusMaster extends EventEmitter {
         }
         const key = tid ?? FIFO_KEY;
         const payload = appLayer.encode(unit, fc, data, tid);
-        // Timeout starts before write (covers write + response phases).
-        // The session waiter is registered only after write succeeds.
-        // settled guard prevents double-invocation when timeout fires during write.
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            this._masterSession.stop(key);
-            callback(new Error('Timeout'));
-        }, timeout);
+        pending.sessionKey = key;
+        this._timerHeap.add(exchangeId, timeout);
         connection.write(payload, (writeErr) => {
+            const p = this._pendingExchanges.get(exchangeId);
+            if (!p || p.settled) {
+                return;
+            }
             if (writeErr) {
-                if (!settled) {
-                    clearTimeout(timer);
-                    settled = true;
-                    callback(writeErr);
+                const cb = p.callback;
+                if (cb) {
+                    p.settled = true;
+                    p.callback = null;
+                    this._pendingExchanges.delete(exchangeId);
+                    cb(writeErr);
                 }
                 return;
             }
             if (this._physicalLayer.state !== exports.PhysicalState.OPEN) {
-                if (!settled) {
-                    clearTimeout(timer);
-                    settled = true;
-                    callback(new Error('Master is not open'));
+                const cb = p.callback;
+                if (cb) {
+                    p.settled = true;
+                    p.callback = null;
+                    this._pendingExchanges.delete(exchangeId);
+                    cb(new Error('Master is not open'));
                 }
                 return;
             }
             // Write succeeded — register in session for frame matching only.
-            // Timeout is managed by the local timer above.
+            // Timeout is managed by the global timer heap above.
             this._masterSession.start(key, (err, frame) => {
-                if (settled)
+                const p2 = this._pendingExchanges.get(exchangeId);
+                if (!p2 || p2.settled) {
                     return;
-                clearTimeout(timer);
-                settled = true;
-                callback(err, frame);
+                }
+                const cb = p2.callback;
+                if (cb) {
+                    p2.settled = true;
+                    p2.callback = null;
+                    this._pendingExchanges.delete(exchangeId);
+                    cb(err, frame);
+                }
             });
         });
     }
     writeFC1Or2(unit, fc, address, length, timeout) {
         const byteCount = Math.ceil(length / 8);
         const bufferTx = Buffer.allocUnsafe(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(length, 2);
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateByteCountResponse(frame, unit, fc, byteCount);
-            const data = new Array(length);
-            for (let i = 0; i < length; i++) {
-                data[i] = (frame.data[1 + ~~(i / 8)] & (1 << i % 8)) > 0;
-            }
-            // Mutate the frame in place rather than spread-copying — `frame` is freshly
-            // allocated per request and not retained anywhere else.
-            frame.data = data;
-            return frame;
+        // 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;
+        bufferTx[3] = length & 0xff;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateByteCountResponse(frame, unit, fc, byteCount);
+                    const data = new Array(length);
+                    let byteIdx = 1;
+                    let outIdx = 0;
+                    const fullBytes = length >> 3;
+                    for (let b = 0; b < fullBytes; b++) {
+                        const byte = frame.data[byteIdx++];
+                        data[outIdx++] = (byte & 0x01) > 0;
+                        data[outIdx++] = (byte & 0x02) > 0;
+                        data[outIdx++] = (byte & 0x04) > 0;
+                        data[outIdx++] = (byte & 0x08) > 0;
+                        data[outIdx++] = (byte & 0x10) > 0;
+                        data[outIdx++] = (byte & 0x20) > 0;
+                        data[outIdx++] = (byte & 0x40) > 0;
+                        data[outIdx++] = (byte & 0x80) > 0;
+                    }
+                    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.
+                    frame.data = data;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     writeFC1;
@@ -2260,19 +2629,42 @@ class ModbusMaster extends EventEmitter {
     writeFC3Or4(unit, fc, address, length, timeout) {
         const byteCount = length * 2;
         const bufferTx = Buffer.allocUnsafe(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(length, 2);
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateByteCountResponse(frame, unit, fc, byteCount);
-            const bufferRx = frame.data.subarray(1);
-            const data = new Array(length);
-            for (let i = 0; i < length; i++) {
-                data[i] = bufferRx.readUInt16BE(i * 2);
-            }
-            frame.data = data;
-            return frame;
+        // Inline big-endian writes — see writeFC1Or2 for the rationale.
+        bufferTx[0] = (address >>> 8) & 0xff;
+        bufferTx[1] = address & 0xff;
+        bufferTx[2] = (length >>> 8) & 0xff;
+        bufferTx[3] = length & 0xff;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateByteCountResponse(frame, unit, fc, byteCount);
+                    const bufferRx = frame.data.subarray(1);
+                    const data = new Array(length);
+                    // Inline big-endian read — `bufferRx[i]` is a direct typed-array
+                    // load, while `readUInt16BE` runs argument coercion + bounds check
+                    // 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++) {
+                        data[i] = (bufferRx[off] << 8) | bufferRx[off + 1];
+                        off += 2;
+                    }
+                    frame.data = data;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     writeFC3;
@@ -2287,28 +2679,61 @@ class ModbusMaster extends EventEmitter {
     writeSingleCoil(unit, address, value, timeout = this.timeout) {
         const fc = exports.FunctionCode.WRITE_SINGLE_COIL;
         const bufferTx = Buffer.allocUnsafe(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value ? COIL_ON : COIL_OFF, 2);
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateEchoResponse(frame, unit, fc, bufferTx);
-            frame.data = value;
-            return frame;
+        const coilValue = value ? COIL_ON : COIL_OFF;
+        // Inline big-endian writes — see writeFC1Or2 for the rationale.
+        bufferTx[0] = (address >>> 8) & 0xff;
+        bufferTx[1] = address & 0xff;
+        bufferTx[2] = (coilValue >>> 8) & 0xff;
+        bufferTx[3] = coilValue & 0xff;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateEchoResponse(frame, unit, fc, bufferTx);
+                    frame.data = value;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     writeFC6;
     writeSingleRegister(unit, address, value, timeout = this.timeout) {
         const fc = exports.FunctionCode.WRITE_SINGLE_REGISTER;
         const bufferTx = Buffer.allocUnsafe(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value, 2);
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateEchoResponse(frame, unit, fc, bufferTx);
-            frame.data = value;
-            return frame;
+        // Inline big-endian writes — see writeFC1Or2 for the rationale.
+        bufferTx[0] = (address >>> 8) & 0xff;
+        bufferTx[1] = address & 0xff;
+        bufferTx[2] = (value >>> 8) & 0xff;
+        bufferTx[3] = value & 0xff;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateEchoResponse(frame, unit, fc, bufferTx);
+                    frame.data = value;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     writeFC15;
@@ -2316,20 +2741,45 @@ class ModbusMaster extends EventEmitter {
         const fc = exports.FunctionCode.WRITE_MULTIPLE_COILS;
         const byteCount = Math.ceil(value.length / 8);
         const bufferTx = Buffer.alloc(5 + byteCount);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value.length, 2);
-        bufferTx.writeUInt8(byteCount, 4);
-        value.forEach((v, i) => {
-            if (v) {
-                bufferTx[5 + ~~(i / 8)] |= 1 << i % 8;
+        // 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[4] = byteCount;
+        let acc = 0;
+        let out = 5;
+        for (let i = 0; i < value.length; i++) {
+            if (value[i]) {
+                acc |= 1 << (i & 7);
             }
-        });
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateEchoResponse(frame, unit, fc, bufferTx.subarray(0, 4));
-            frame.data = value;
-            return frame;
+            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) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateEchoResponse(frame, unit, fc, bufferTx.subarray(0, 4));
+                    frame.data = value;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     writeFC16;
@@ -2337,53 +2787,105 @@ class ModbusMaster extends EventEmitter {
         const fc = exports.FunctionCode.WRITE_MULTIPLE_REGISTERS;
         const byteCount = value.length * 2;
         const bufferTx = Buffer.allocUnsafe(5 + byteCount);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value.length, 2);
-        bufferTx.writeUInt8(byteCount, 4);
-        value.forEach((v, i) => {
-            bufferTx.writeUInt16BE(v, 5 + i * 2);
-        });
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateEchoResponse(frame, unit, fc, bufferTx.subarray(0, 4));
-            frame.data = value;
-            return frame;
+        // 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[4] = byteCount;
+        let off = 5;
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            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) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateEchoResponse(frame, unit, fc, bufferTx.subarray(0, 4));
+                    frame.data = value;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     handleFC17;
     reportServerId(unit, serverIdLength = 1, timeout = this.timeout) {
         const fc = exports.FunctionCode.REPORT_SERVER_ID;
-        return this.send(unit, fc, EMPTY_BUFFER, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateResponse(frame, unit, fc);
-            if (frame.data.length < 2 + serverIdLength)
-                throw new Error('Insufficient data length');
-            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)),
-            };
-            return frame;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, EMPTY_BUFFER, timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateResponse(frame, unit, fc);
+                    if (frame.data.length < 2 + serverIdLength) {
+                        throw new Error('Insufficient data length');
+                    }
+                    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)),
+                    };
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     handleFC22;
     maskWriteRegister(unit, address, andMask, orMask, timeout = this.timeout) {
         const fc = exports.FunctionCode.MASK_WRITE_REGISTER;
         const bufferTx = Buffer.allocUnsafe(6);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(andMask, 2);
-        bufferTx.writeUInt16BE(orMask, 4);
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateEchoResponse(frame, unit, fc, bufferTx);
-            frame.data = { andMask, orMask };
-            return frame;
+        // Inline big-endian writes — see writeFC1Or2 for the rationale.
+        bufferTx[0] = (address >>> 8) & 0xff;
+        bufferTx[1] = address & 0xff;
+        bufferTx[2] = (andMask >>> 8) & 0xff;
+        bufferTx[3] = andMask & 0xff;
+        bufferTx[4] = (orMask >>> 8) & 0xff;
+        bufferTx[5] = orMask & 0xff;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, bufferTx, timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateEchoResponse(frame, unit, fc, bufferTx);
+                    frame.data = { andMask, orMask };
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     handleFC23;
@@ -2392,71 +2894,121 @@ class ModbusMaster extends EventEmitter {
         const byteCount = write.value.length * 2;
         const readByteCount = read.length * 2;
         const bufferTx = Buffer.allocUnsafe(9 + byteCount);
-        bufferTx.writeUInt16BE(read.address, 0);
-        bufferTx.writeUInt16BE(read.length, 2);
-        bufferTx.writeUInt16BE(write.address, 4);
-        bufferTx.writeUInt16BE(write.value.length, 6);
-        bufferTx.writeUInt8(byteCount, 8);
-        write.value.forEach((v, i) => {
-            bufferTx.writeUInt16BE(v, 9 + i * 2);
-        });
-        return this.send(unit, fc, bufferTx, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateByteCountResponse(frame, unit, fc, readByteCount);
-            const bufferRx = frame.data.subarray(1);
-            frame.data = Array.from({ length: read.length }, (_, index) => bufferRx.readUInt16BE(index * 2));
-            return frame;
+        // Inline big-endian writes — see writeFC1Or2 for the rationale.
+        bufferTx[0] = (read.address >>> 8) & 0xff;
+        bufferTx[1] = read.address & 0xff;
+        bufferTx[2] = (read.length >>> 8) & 0xff;
+        bufferTx[3] = read.length & 0xff;
+        bufferTx[4] = (write.address >>> 8) & 0xff;
+        bufferTx[5] = write.address & 0xff;
+        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];
+            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) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateByteCountResponse(frame, unit, fc, readByteCount);
+                    const bufferRx = frame.data.subarray(1);
+                    // Dense pre-sized array + inline BE read — drops the Array.from
+                    // 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++) {
+                        data[i] = (bufferRx[off] << 8) | bufferRx[off + 1];
+                        off += 2;
+                    }
+                    frame.data = data;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     handleFC43_14;
     readDeviceIdentification(unit, readDeviceIDCode, objectId, timeout = this.timeout) {
         const fc = exports.FunctionCode.READ_DEVICE_IDENTIFICATION;
-        return this.send(unit, fc, Buffer.from([MEI_READ_DEVICE_ID, readDeviceIDCode, objectId]), timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateResponse(frame, unit, fc);
-            if (frame.data.length < 6)
-                throw new Error('Insufficient data length');
-            if (frame.data[0] !== MEI_READ_DEVICE_ID || frame.data[1] !== readDeviceIDCode)
-                throw new Error('Invalid response');
-            const objects = [];
-            let object = [];
-            let totalBytes = 0;
-            for (const v of frame.data.subarray(6)) {
-                switch (object.length) {
-                    case 0:
-                    case 1: {
-                        object.push(v);
-                        break;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, Buffer.from([MEI_READ_DEVICE_ID, readDeviceIDCode, objectId]), timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateResponse(frame, unit, fc);
+                    if (frame.data.length < 6) {
+                        throw new Error('Insufficient data length');
                     }
-                    case 2: {
-                        object.push([v]);
-                        break;
+                    if (frame.data[0] !== MEI_READ_DEVICE_ID || frame.data[1] !== readDeviceIDCode) {
+                        throw new Error('Invalid response');
                     }
-                    case 3: {
-                        object[2].push(v);
-                        if (object[1] === object[2].length) {
-                            objects.push({ id: object[0], value: Buffer.from(object[2]).toString() });
-                            totalBytes += 2 + object[1];
-                            object = [];
+                    const objects = [];
+                    let object = [];
+                    let totalBytes = 0;
+                    for (const v of frame.data.subarray(6)) {
+                        switch (object.length) {
+                            case 0:
+                            case 1: {
+                                object.push(v);
+                                break;
+                            }
+                            case 2: {
+                                object.push([v]);
+                                break;
+                            }
+                            case 3: {
+                                object[2].push(v);
+                                if (object[1] === object[2].length) {
+                                    objects.push({ id: object[0], value: Buffer.from(object[2]).toString() });
+                                    totalBytes += 2 + object[1];
+                                    object = [];
+                                }
+                                break;
+                            }
+                            default:
+                                break;
                         }
-                        break;
                     }
+                    if (objects.length !== frame.data[5]) {
+                        throw new Error('Invalid response');
+                    }
+                    if (frame.data.length !== 6 + totalBytes) {
+                        throw new Error('Invalid response');
+                    }
+                    frame.data = {
+                        readDeviceIDCode,
+                        conformityLevel: frame.data[2],
+                        moreFollows: frame.data[3] === 0xff,
+                        nextObjectId: frame.data[4],
+                        objects,
+                    };
+                    resolve(frame);
                 }
-            }
-            if (objects.length !== frame.data[5])
-                throw new Error('Invalid response');
-            if (frame.data.length !== 6 + totalBytes)
-                throw new Error('Invalid response');
-            frame.data = {
-                readDeviceIDCode,
-                conformityLevel: frame.data[2],
-                moreFollows: frame.data[3] === 0xff,
-                nextObjectId: frame.data[4],
-                objects,
-            };
-            return frame;
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     addCustomFunctionCode(cfc) {
@@ -2469,15 +3021,28 @@ class ModbusMaster extends EventEmitter {
     }
     sendCustomFC(unit, fc, data, timeout = this.timeout) {
         const payload = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        return this.send(unit, fc, payload, timeout, unit === 0).then((frame) => {
-            if (!frame)
-                return;
-            validateResponse(frame, unit, fc);
-            return frame.data;
+        return new Promise((resolve, reject) => {
+            this._send(unit, fc, payload, timeout, unit === 0, (err, frame) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (!frame) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    validateResponse(frame, unit, fc);
+                    resolve(frame.data);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     /**
-     * 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 —
@@ -2499,9 +3064,25 @@ class ModbusMaster extends EventEmitter {
         const end = this._queueHead + this._queueLen;
         this._queueLen = 0;
         for (let i = this._queueHead; i < end; i++) {
-            this._queueRejects[i](rejectErr);
+            this._queueCallbacks[i](rejectErr);
         }
         this._masterSession.stopAll(rejectErr);
+        this._timerHeap.clear();
+        // Settle any in-flight exchanges that weren't reached by stopAll
+        // (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) {
+                continue;
+            }
+            pending.settled = true;
+            const cb = pending.callback;
+            if (cb) {
+                pending.callback = null;
+                cb(rejectErr);
+            }
+        }
+        this._pendingExchanges.clear();
         let err = null;
         try {
             await promisifyCb((cb) => this._physicalLayer.close(cb));
@@ -2538,7 +3119,9 @@ class ModbusSlave extends EventEmitter {
     _protocol;
     _appLayers = new Map();
     _customFunctionCodes = new Map();
-    _locks = new Map();
+    // Active interval locks. Typical length: 0 (no contention) — 1-2 (cross-
+    // connection contention). Linear scan for overlap is sub-µs.
+    _intervalLocks = [];
     _cleanupFns = new Set();
     _closePromise = null;
     get state() {
@@ -2565,7 +3148,9 @@ class ModbusSlave extends EventEmitter {
             for (const cfc of this._customFunctionCodes.values()) {
                 appLayer.addCustomFunctionCode(cfc);
             }
-            const cleanupFraming = () => appLayer.off('framing', onFraming);
+            const cleanupFraming = () => {
+                appLayer.onFraming = NOOP;
+            };
             const onFraming = (frame) => {
                 if (this._physicalLayer.state !== exports.PhysicalState.OPEN) {
                     return;
@@ -2580,7 +3165,7 @@ class ModbusSlave extends EventEmitter {
                 appLayerData.queues.frames.push(frame);
                 this._drain(appLayer, appLayerData.queues);
             };
-            appLayer.on('framing', onFraming);
+            appLayer.onFraming = onFraming;
             this._cleanupFns.add(cleanupFraming);
             const cleanupClose = () => connection.off('close', onClose);
             const onClose = () => {
@@ -2647,10 +3232,66 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            pdu.fill(0, 1, byteCount + 1);
-            for (let i = 0; i < length; i++) {
-                if (coils[i]) {
-                    pdu[1 + (i >> 3)] |= 1 << (i & 7);
+            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;
                 }
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
@@ -2683,10 +3324,60 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            pdu.fill(0, 1, byteCount + 1);
-            for (let i = 0; i < length; i++) {
-                if (discreteInputs[i]) {
-                    pdu[1 + (i >> 3)] |= 1 << (i & 7);
+            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;
                 }
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
@@ -2718,8 +3409,15 @@ class ModbusSlave extends EventEmitter {
             const registers = await model.readHoldingRegisters(address, length);
             const pdu = Buffer.allocUnsafe(length * 2 + 1);
             pdu[0] = length * 2;
+            // 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++) {
-                pdu.writeUInt16BE(registers[i], 1 + i * 2);
+                const v = registers[i];
+                pdu[off] = (v >>> 8) & 0xff;
+                pdu[off + 1] = v & 0xff;
+                off += 2;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -2750,8 +3448,13 @@ class ModbusSlave extends EventEmitter {
             const registers = await model.readInputRegisters(address, length);
             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++) {
-                pdu.writeUInt16BE(registers[i], 1 + i * 2);
+                const v = registers[i];
+                pdu[off] = (v >>> 8) & 0xff;
+                pdu[off + 1] = v & 0xff;
+                off += 2;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -2830,8 +3533,42 @@ class ModbusSlave extends EventEmitter {
             return;
         }
         const value = new Array(length);
-        for (let i = 0; i < length; i++) {
-            value[i] = (frame.data[5 + Math.floor(i / 8)] & (1 << i % 8)) > 0;
+        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) {
@@ -2869,8 +3606,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) {
@@ -2935,7 +3674,7 @@ class ModbusSlave extends EventEmitter {
             return;
         }
         try {
-            await this._withAddressLock([address], async () => {
+            await this._withIntervalLock(address, address + 1, async () => {
                 if (model.maskWriteRegister) {
                     await model.maskWriteRegister(address, andMask, orMask);
                 }
@@ -2981,12 +3720,13 @@ 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 {
-            const writeAddresses = Array.from({ length: length.write }, (_, i) => address.write + i);
-            await this._withAddressLock(writeAddresses, async () => {
+            await this._withIntervalLock(address.write, address.write + length.write, async () => {
                 if (model.writeMultipleRegisters) {
                     await model.writeMultipleRegisters(address.write, value);
                 }
@@ -2999,8 +3739,13 @@ class ModbusSlave extends EventEmitter {
             const registers = await model.readHoldingRegisters(address.read, length.read);
             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++) {
-                pdu.writeUInt16BE(registers[i], 1 + i * 2);
+                const v = registers[i];
+                pdu[off] = (v >>> 8) & 0xff;
+                pdu[off + 1] = v & 0xff;
+                off += 2;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -3159,7 +3904,11 @@ class ModbusSlave extends EventEmitter {
                 return Promise.resolve();
             }
             return new Promise((resolve) => {
-                appLayer.connection.write(data, () => resolve());
+                // Pass `resolve` directly as the write cb (vs `() => resolve()`) —
+                // saves one closure allocation per response. `resolve` may receive
+                // the write's err arg, but our Promise<void> contract ignores any
+                // resolved value and the response handler doesn't check success.
+                appLayer.connection.write(data, resolve);
             });
         };
         // Hot path: unicast to a known unit dispatches to a single model.
@@ -3208,24 +3957,68 @@ class ModbusSlave extends EventEmitter {
             return true;
         }
     }
-    async _withAddressLock(addresses, fn) {
-        const sorted = [...new Set(addresses)].sort((a, b) => a - b);
-        const previous = sorted.map((addr) => this._locks.get(addr) ?? Promise.resolve());
-        const work = Promise.all(previous).then(() => fn());
-        const cleanup = work.catch(() => {
-            /* ignore */
-        });
-        for (const addr of sorted) {
-            this._locks.set(addr, cleanup);
+    /**
+     * Serialize a code block over the half-open address interval `[lo, hi)`.
+     * The block runs after all previously-installed locks whose intervals
+     * overlap with this one have completed. Two non-overlapping intervals
+     * execute in parallel.
+     *
+     * Locks are tracked in a flat array (`_intervalLocks`); the typical depth
+     * is 0-2 entries, so the linear overlap scan is sub-µs. Compare with the
+     * old per-address Map design, where FC23 writing 121 registers allocated
+     * ~125 objects per request (one Promise.resolve / address + Set + sort +
+     * Promise.all); this version allocates 1-3.
+     */
+    async _withIntervalLock(lo, hi, fn) {
+        // Find overlapping active entries. Two half-open intervals [a, b) and
+        // [c, d) overlap iff a < d && c < b.
+        let overlap = null;
+        const locks = this._intervalLocks;
+        for (let i = 0; i < locks.length; i++) {
+            const l = locks[i];
+            if (l.lo < hi && lo < l.hi) {
+                if (overlap === null) {
+                    overlap = [];
+                }
+                overlap.push(l.promise);
+            }
+        }
+        // Install our entry BEFORE awaiting so any concurrent caller arriving
+        // after this point sees us and waits. Promise field is filled in below.
+        const entry = { lo, hi, promise: undefined };
+        locks.push(entry);
+        let work;
+        if (overlap === null) {
+            work = fn();
+        }
+        else if (overlap.length === 1) {
+            // Skip Promise.all when there's exactly one prior — avoids one
+            // intermediate Promise allocation in the most common contention case.
+            // `.then(fn)` (vs `.then(() => fn())`) saves a closure: fn's signature
+            // is () => Promise<T>, and the resolved value `.then` passes in is
+            // silently discarded by JS's loose-arity rule.
+            work = overlap[0].then(fn);
+        }
+        else {
+            work = Promise.all(overlap).then(fn);
         }
+        // We never want the cleanup latch to reject — swallow errors so
+        // downstream `.then` chains don't see an unhandled rejection. Using the
+        // shared `NOOP` singleton avoids allocating a fresh arrow function on
+        // every locked request.
+        entry.promise = work.catch(NOOP);
         try {
             return await work;
         }
         finally {
-            for (const addr of sorted) {
-                if (this._locks.get(addr) === cleanup) {
-                    this._locks.delete(addr);
+            const i = locks.indexOf(entry);
+            if (i !== -1) {
+                // O(1) swap-and-pop since lock order doesn't matter for correctness.
+                const last = locks.length - 1;
+                if (i !== last) {
+                    locks[i] = locks[last];
                 }
+                locks.pop();
             }
         }
     }
@@ -3356,6 +4149,7 @@ exports.MasterSession = MasterSession;
 exports.ModbusError = ModbusError;
 exports.ModbusMaster = ModbusMaster;
 exports.ModbusSlave = ModbusSlave;
+exports.NOOP = NOOP;
 exports.RtuApplicationLayer = RtuApplicationLayer;
 exports.SerialPhysicalLayer = SerialPhysicalLayer;
 exports.TcpApplicationLayer = TcpApplicationLayer;