njs-modbus 3.1.1 → 3.2.0

package/dist/index.mjs

@@ -89,6 +89,10 @@ var ConformityLevel;
 })(ConformityLevel || (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,
@@ -230,8 +234,12 @@ function isUint8(n) {
     return Number.isInteger(n) && n >= 0 && n <= 255;
 }
 
-function lrc(data) {
-    return (~data.reduce((sum, n) => sum + n, 0) + 1) & 0xff;
+function lrc(data, start = 0, end = data.length) {
+    let sum = 0;
+    for (let i = start; i < end; i++) {
+        sum += data[i];
+    }
+    return (~sum + 1) & 0xff;
 }
 
 const REQUEST_FIXED_LENGTHS = {
@@ -281,11 +289,11 @@ const PREDICT_UNKNOWN = -1;
  *   the framing layer must defer to a registered `CustomFunctionCode` or treat
  *   this as a framing error.
  */
-function predictRtuFrameLength(buffer, isResponse) {
-    if (buffer.length < 2) {
+function predictRtuFrameLength(buffer, start, end, isResponse) {
+    if (end - start < 2) {
         return PREDICT_NEED_MORE;
     }
-    const fc = buffer[1];
+    const fc = buffer[start + 1];
     if (isResponse && (fc & EXCEPTION_OFFSET) !== 0) {
         return 5;
     }
@@ -295,13 +303,13 @@ function predictRtuFrameLength(buffer, isResponse) {
     }
     const bc = (isResponse ? RESPONSE_BYTE_COUNT : REQUEST_BYTE_COUNT)[fc];
     if (bc !== undefined) {
-        if (buffer.length <= bc.offset) {
+        if (end - start <= bc.offset) {
             return PREDICT_NEED_MORE;
         }
-        return bc.extra + buffer[bc.offset];
+        return bc.extra + buffer[start + bc.offset];
     }
     if (isResponse && fc === FunctionCode.READ_DEVICE_IDENTIFICATION) {
-        return predictFc43_14Response(buffer);
+        return predictFc43_14Response(buffer, start, end);
     }
     return PREDICT_UNKNOWN;
 }
@@ -314,23 +322,23 @@ function predictRtuFrameLength(buffer, isResponse) {
  *   [objId(1) objLen(1) objData(objLen)] × numObjs
  *   CRC(2)
  */
-function predictFc43_14Response(buffer) {
-    if (buffer.length < 8) {
+function predictFc43_14Response(buffer, start, end) {
+    if (end - start < 8) {
         return PREDICT_NEED_MORE;
     }
-    if (buffer[2] !== MEI_READ_DEVICE_ID) {
+    if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
         return PREDICT_UNKNOWN;
     }
-    const numObjs = buffer[7];
-    let offset = 8;
+    const numObjs = buffer[start + 7];
+    let cursor = start + 8;
     for (let i = 0; i < numObjs; i++) {
-        if (buffer.length < offset + 2) {
+        if (end < cursor + 2) {
             return PREDICT_NEED_MORE;
         }
-        const objLen = buffer[offset + 1];
-        offset += 2 + objLen;
+        const objLen = buffer[cursor + 1];
+        cursor += 2 + objLen;
     }
-    return offset + 2;
+    return cursor - start + 2;
 }
 
 /**
@@ -395,6 +403,107 @@ function resolveRtuTiming(opts = {}, baudRate) {
     return { intervalBetweenFrames, interCharTimeout };
 }
 
+/** @internal
+ * Zero-allocation binary min-heap for coalescing per-request timeouts.
+ *
+ * Uses two parallel numeric arrays (no object allocation per entry).
+ * Lazy deletion: callers never remove from the heap; expired entries
+ * are silently dropped when they surface at the top.
+ */
+class TimerHeap {
+    _deadlines = [];
+    _ids = [];
+    _timer = null;
+    _onFire;
+    /** Pre-bound tick handler to avoid creating a new arrow function on every setTimeout. */
+    _boundTick;
+    constructor(onFire) {
+        this._onFire = onFire;
+        this._boundTick = this._onTick.bind(this);
+    }
+    /** Number of pending timers in the heap. */
+    get size() {
+        return this._deadlines.length;
+    }
+    /** Schedule an entry. If it becomes the new top, the global timer is re-scheduled (pre-emption). */
+    add(id, ms) {
+        const deadline = performance.now() + ms;
+        let i = this._deadlines.length;
+        this._deadlines.push(deadline);
+        this._ids.push(id);
+        // sift up
+        while (i > 0) {
+            const p = (i - 1) >> 1;
+            if (this._deadlines[p] <= deadline)
+                break;
+            this._deadlines[i] = this._deadlines[p];
+            this._ids[i] = this._ids[p];
+            i = p;
+        }
+        this._deadlines[i] = deadline;
+        this._ids[i] = id;
+        // Only reschedule when the new entry became the heap top.
+        if (i === 0)
+            this._refresh();
+    }
+    /** Dispose without firing callbacks. */
+    clear() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        this._deadlines.length = 0;
+        this._ids.length = 0;
+    }
+    _refresh() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        if (this._deadlines.length === 0)
+            return;
+        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
+        this._timer = setTimeout(this._boundTick, delay);
+    }
+    _onTick() {
+        this._timer = null;
+        const now = performance.now();
+        while (this._deadlines.length > 0 && this._deadlines[0] <= now) {
+            const id = this._pop();
+            this._onFire(id);
+        }
+        this._refresh();
+    }
+    /** Pop and return the id with the earliest deadline. Assumes heap is non-empty. */
+    _pop() {
+        const topId = this._ids[0];
+        const lastId = this._ids.pop();
+        const lastDeadline = this._deadlines.pop();
+        const n = this._deadlines.length;
+        if (n > 0) {
+            let i = 0;
+            // sift down
+            while (true) {
+                let min = i;
+                const l = i * 2 + 1;
+                const r = l + 1;
+                if (l < n && this._deadlines[l] < this._deadlines[min])
+                    min = l;
+                if (r < n && this._deadlines[r] < this._deadlines[min])
+                    min = r;
+                if (min === i)
+                    break;
+                this._deadlines[i] = this._deadlines[min];
+                this._ids[i] = this._ids[min];
+                i = min;
+            }
+            this._deadlines[i] = lastDeadline;
+            this._ids[i] = lastId;
+        }
+        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`.
@@ -1339,14 +1448,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;
@@ -1360,7 +1471,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
     _threePointFiveT;
     _onePointFiveT;
     _customFunctionCodes = new Map();
-    _cleanupFns = new Set();
+    _cleanupCbs = [];
     get connection() {
         return this._connection;
     }
@@ -1376,7 +1487,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;
             }
@@ -1418,7 +1529,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;
@@ -1454,16 +1565,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;
@@ -1476,34 +1587,38 @@ 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;
             }
@@ -1512,7 +1627,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;
@@ -1520,9 +1635,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;
@@ -1533,12 +1648,12 @@ 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;
@@ -1548,7 +1663,7 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
                     state.start += 1;
                     continue;
                 }
-                if (handleIncomplete())
+                if (this._handleIncomplete(state, strict))
                     return;
                 break;
             }
@@ -1559,7 +1674,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;
@@ -1580,7 +1695,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) {
@@ -1607,11 +1722,21 @@ 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;
     }
 }
@@ -1642,8 +1767,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;
     }
@@ -1667,108 +1792,138 @@ 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;
+        }
+        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;
         }
-        if (hexChars.length % 2 !== 0) {
-            this.emit('framing-error', new Error('Invalid data'));
+        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 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 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);
+        for (let i = 0; i < dataLen; i++) {
+            const hi = HEX_DECODE[hexChars[4 + i * 2]];
+            const lo = HEX_DECODE[hexChars[4 + i * 2 + 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;
         }
-        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.subarray(0, -1));
         const out = Buffer.allocUnsafe(1 + buffer.length * 2 + 2);
         out[0] = CHAR_CODE.COLON;
         for (let i = 0; i < buffer.length; i++) {
@@ -1789,7 +1944,7 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
     _connection;
     _transactionId = 1;
     _buffer = EMPTY_BUFFER;
-    _cleanupFns = new Set();
+    _cleanupCbs = [];
     get connection() {
         return this._connection;
     }
@@ -1798,6 +1953,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;
@@ -1815,7 +1981,7 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
                     break;
                 }
                 else {
-                    this.emit('framing-error', result.error);
+                    this.onFramingError(result.error);
                     buffer = EMPTY_BUFFER;
                     break;
                 }
@@ -1835,15 +2001,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) {
@@ -1852,7 +2018,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') };
@@ -1860,29 +2026,47 @@ 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() above. Hits on every received TCP frame.
+            transaction: (buffer[0] << 8) | buffer[1],
             unit: buffer[6],
             fc: buffer[7],
             data: buffer.subarray(8),
             buffer,
         };
-        this.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;
         }
@@ -1961,14 +2145,31 @@ 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;
     }
@@ -1995,17 +2196,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 = () => {
@@ -2061,31 +2266,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 !== 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 !== PhysicalState.OPEN) {
@@ -2106,14 +2303,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) {
@@ -2124,15 +2319,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();
         });
     }
@@ -2152,30 +2343,35 @@ 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 (no per-request setTimeout).
+        // 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;
+                const cb = p.callback;
+                if (!cb)
                     return;
-                clearTimeout(timer);
-                settled = true;
+                p.settled = true;
+                p.callback = null;
+                this._pendingExchanges.delete(exchangeId);
                 if (writeErr) {
-                    callback(writeErr);
+                    cb(writeErr);
                 }
                 else if (this._physicalLayer.state !== PhysicalState.OPEN) {
-                    callback(new Error('Master is not open'));
+                    cb(new Error('Master is not open'));
                 }
                 else {
-                    callback(null);
+                    cb(null);
                 }
             });
             return;
@@ -2189,62 +2385,82 @@ 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 !== 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);
+                    for (let i = 0; i < length; i++) {
+                        data[i] = (frame.data[1 + Math.floor(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;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     writeFC1;
@@ -2258,19 +2474,41 @@ 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.
+                    for (let i = 0; i < length; i++) {
+                        const off = i * 2;
+                        data[i] = (bufferRx[off] << 8) | bufferRx[off + 1];
+                    }
+                    frame.data = data;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     writeFC3;
@@ -2285,28 +2523,61 @@ class ModbusMaster extends EventEmitter {
     writeSingleCoil(unit, address, value, timeout = this.timeout) {
         const fc = 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 = 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;
@@ -2314,20 +2585,36 @@ class ModbusMaster extends EventEmitter {
         const fc = 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;
+        for (let i = 0; i < value.length; i++) {
+            if (value[i]) {
+                bufferTx[5 + Math.floor(i / 8)] |= 1 << i % 8;
             }
-        });
-        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;
+        }
+        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;
@@ -2335,53 +2622,102 @@ class ModbusMaster extends EventEmitter {
         const fc = 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;
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            const off = 5 + i * 2;
+            bufferTx[off] = (v >>> 8) & 0xff;
+            bufferTx[off + 1] = v & 0xff;
+        }
+        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 = 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 = 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;
@@ -2390,71 +2726,115 @@ 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;
+        for (let i = 0; i < write.value.length; i++) {
+            const v = write.value[i];
+            const off = 9 + i * 2;
+            bufferTx[off] = (v >>> 8) & 0xff;
+            bufferTx[off + 1] = v & 0xff;
+        }
+        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);
+                    for (let i = 0; i < read.length; i++) {
+                        const off = i * 2;
+                        data[i] = (bufferRx[off] << 8) | bufferRx[off + 1];
+                    }
+                    frame.data = data;
+                    resolve(frame);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
         });
     }
     handleFC43_14;
     readDeviceIdentification(unit, readDeviceIDCode, objectId, timeout = this.timeout) {
         const fc = 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;
-                    }
-                    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 = [];
+        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');
+                    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;
+                            }
+                            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) {
@@ -2467,11 +2847,24 @@ 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);
+                }
+            });
         });
     }
     /**
@@ -2497,9 +2890,24 @@ 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));
@@ -2536,7 +2944,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() {
@@ -2563,7 +2973,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 !== PhysicalState.OPEN) {
                     return;
@@ -2578,7 +2990,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 = () => {
@@ -2645,12 +3057,23 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            pdu.fill(0, 1, byteCount + 1);
+            // Pack 8 booleans per byte without first zero-filling: accumulate into
+            // `acc` and write a full byte once each lane is finished. Saves the
+            // `pdu.fill(0, 1, ...)` pass and replaces N `|=` reads-modify-writes
+            // with N `read`s + ⌈N/8⌉ `write`s. Measured ~+5% on FC01 / ~+3% on FC02
+            // at max payload (2000 / 1968 coils) via benchmark/all-fcs.ts bisect.
+            let acc = 0;
+            let out = 1;
             for (let i = 0; i < length; i++) {
-                if (coils[i]) {
-                    pdu[1 + (i >> 3)] |= 1 << (i & 7);
+                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));
         }
         catch (error) {
@@ -2681,12 +3104,19 @@ class ModbusSlave extends EventEmitter {
             const byteCount = (length + 7) >> 3;
             const pdu = Buffer.allocUnsafe(byteCount + 1);
             pdu[0] = byteCount;
-            pdu.fill(0, 1, byteCount + 1);
+            // Accumulator-based bit pack — see handleFC1 for the rationale.
+            let acc = 0;
+            let out = 1;
             for (let i = 0; i < length; i++) {
-                if (discreteInputs[i]) {
-                    pdu[1 + (i >> 3)] |= 1 << (i & 7);
+                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));
         }
         catch (error) {
@@ -2716,8 +3146,14 @@ 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.
             for (let i = 0; i < length; i++) {
-                pdu.writeUInt16BE(registers[i], 1 + i * 2);
+                const v = registers[i];
+                const off = 1 + i * 2;
+                pdu[off] = (v >>> 8) & 0xff;
+                pdu[off + 1] = v & 0xff;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -2748,8 +3184,12 @@ 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.
             for (let i = 0; i < length; i++) {
-                pdu.writeUInt16BE(registers[i], 1 + i * 2);
+                const v = registers[i];
+                const off = 1 + i * 2;
+                pdu[off] = (v >>> 8) & 0xff;
+                pdu[off + 1] = v & 0xff;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -2829,6 +3269,10 @@ class ModbusSlave extends EventEmitter {
         }
         const value = new Array(length);
         for (let i = 0; i < length; i++) {
+            // Bit math: kept as `Math.floor(i / 8)` / `i % 8` — V8 pattern-matches
+            // both forms with `i` as an integer loop counter to direct shifts, but
+            // measured ~+3% throughput vs the bit-shift form on this exact loop
+            // (benchmark/all-fcs.ts FC15 slave A/B, 8/8 paired samples).
             value[i] = (frame.data[5 + Math.floor(i / 8)] & (1 << i % 8)) > 0;
         }
         try {
@@ -2933,7 +3377,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);
                 }
@@ -2983,8 +3427,7 @@ class ModbusSlave extends EventEmitter {
             value[i] = (frame.data[9 + i * 2] << 8) | frame.data[10 + i * 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);
                 }
@@ -2997,8 +3440,12 @@ 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.
             for (let i = 0; i < length.read; i++) {
-                pdu.writeUInt16BE(registers[i], 1 + i * 2);
+                const v = registers[i];
+                const off = 1 + i * 2;
+                pdu[off] = (v >>> 8) & 0xff;
+                pdu[off + 1] = v & 0xff;
             }
             await response(appLayer.encode(frame.unit, frame.fc, pdu, frame.transaction));
         }
@@ -3157,7 +3604,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.
@@ -3206,24 +3657,66 @@ 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();
             }
         }
     }
@@ -3340,4 +3833,4 @@ class ModbusSlave extends EventEmitter {
     }
 }
 
-export { AbstractApplicationLayer, AbstractPhysicalConnection, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EMPTY_BUFFER, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusMaster, ModbusSlave, PhysicalConnectionState, PhysicalState, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpClientPhysicalLayer, UdpServerPhysicalLayer, createPhysicalLayer, getCodeByError, getErrorByCode };
+export { AbstractApplicationLayer, AbstractPhysicalConnection, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EMPTY_BUFFER, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusMaster, ModbusSlave, NOOP, PhysicalConnectionState, PhysicalState, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpClientPhysicalLayer, UdpServerPhysicalLayer, createPhysicalLayer, getCodeByError, getErrorByCode };