njs-modbus 3.3.0 → 3.4.0

package/dist/utils.cjs

@@ -92,7 +92,7 @@ function checkRange(value, range) {
     return false;
 }
 
-const TABLE = new Uint16Array([
+const CRC_TABLE = new Uint16Array([
     0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01,
     0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0,
     0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581,
@@ -110,23 +110,29 @@ const TABLE = new Uint16Array([
     0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
     0x4040,
 ]);
-function crc(data, start, end) {
+/** CRC-16 (Modbus) over a single contiguous buffer. */
+function crcFixed(data, start, end) {
     let crc = 0xffff;
     for (let index = start; index < end; index++) {
-        crc = TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
+        crc = CRC_TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
     }
     return crc;
 }
-
 /**
- * Returns true when `n` is an integer in the unsigned-byte range [0, 255].
- *
- * Used for byte-level Modbus payload validation (function-code values, raw
- * byte arrays in FC17/FC43 responses) — rejects negative, fractional, NaN,
- * Infinity, and out-of-range values uniformly.
+ * CRC-16 (Modbus) over two contiguous buffer segments.
+ * Computes CRC(head[headOff:headOff+headLen]) followed by CRC(tail[tailOff:tailOff+tailLen]).
  */
-function isUint8(n) {
-    return (n & 0xff) === n;
+function crcDual(head, headOff, headLen, tail, tailOff, tailLen) {
+    let crc = 0xffff;
+    const headEnd = headOff + headLen;
+    for (let i = headOff; i < headEnd; i++) {
+        crc = CRC_TABLE[(crc ^ head[i]) & 0xff] ^ (crc >> 8);
+    }
+    const tailEnd = tailOff + tailLen;
+    for (let i = tailOff; i < tailEnd; i++) {
+        crc = CRC_TABLE[(crc ^ tail[i]) & 0xff] ^ (crc >> 8);
+    }
+    return crc;
 }
 
 function lrc(data, start, end) {
@@ -207,12 +213,12 @@ const RES_TABLE = new Int32Array(256);
     RES_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -517;
     RES_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = -999;
 })();
-function predictRtuFrameLength(buffer, start, end, isResponse) {
+function predictRtuFrameLength(residual, data, residualLen, start, end, isResponse) {
     const len = end - start;
     if (len < 2) {
         return PREDICT_NEED_MORE;
     }
-    const fc = buffer[start + 1];
+    const fc = start + 1 < residualLen ? residual[start + 1] : data[start + 1 - residualLen];
     if (isResponse) {
         if ((fc & EXCEPTION_OFFSET) !== 0) {
             return 5;
@@ -228,16 +234,16 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
                 if (end - start < 8) {
                     return PREDICT_NEED_MORE;
                 }
-                if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
+                if ((start + 2 < residualLen ? residual[start + 2] : data[start + 2 - residualLen]) !== MEI_READ_DEVICE_ID) {
                     return PREDICT_UNKNOWN;
                 }
-                const numObjs = buffer[start + 7];
+                const numObjs = start + 7 < residualLen ? residual[start + 7] : data[start + 7 - residualLen];
                 let cursor = start + 8;
                 for (let i = 0; i < numObjs; i++) {
                     if (end < cursor + 2) {
                         return PREDICT_NEED_MORE;
                     }
-                    cursor += 2 + buffer[cursor + 1];
+                    cursor += 2 + (cursor + 1 < residualLen ? residual[cursor + 1] : data[cursor + 1 - residualLen]);
                 }
                 return cursor - start + 2;
             }
@@ -246,7 +252,7 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
             if (len <= offset) {
                 return PREDICT_NEED_MORE;
             }
-            return (decode & 0xff) + buffer[start + offset];
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
     }
     else {
@@ -260,7 +266,7 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
             if (len <= offset) {
                 return PREDICT_NEED_MORE;
             }
-            return (decode & 0xff) + buffer[start + offset];
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
     }
     return PREDICT_UNKNOWN;
@@ -303,7 +309,12 @@ function resolveOne(value, baudRate, fastBaudMs) {
     if (baudRate === undefined) {
         return undefined;
     }
-    return baudRate > 19200 ? fastBaudMs : Math.ceil(bitsToMs(baudRate, value.value));
+    if (baudRate > 19200) {
+        return fastBaudMs;
+    }
+    const ms = bitsToMs(baudRate, value.value);
+    const trunc = ms | 0;
+    return trunc + (ms > trunc ? 1 : 0);
 }
 /**
  * Resolve Modbus RTU timing parameters from user options into milliseconds.
@@ -320,7 +331,17 @@ function resolveRtuTiming(opts = {}, baudRate) {
     if (intervalBetweenFrames === undefined) {
         // Spec default: t3.5 derived from baudRate, or 0 when neither option nor
         // baudRate were supplied.
-        intervalBetweenFrames = baudRate !== undefined ? (baudRate > 19200 ? 1.75 : Math.ceil(bitsToMs(baudRate, 38.5))) : 0;
+        if (baudRate === undefined) {
+            intervalBetweenFrames = 0;
+        }
+        else if (baudRate > 19200) {
+            intervalBetweenFrames = 1.75;
+        }
+        else {
+            const ms = bitsToMs(baudRate, 38.5);
+            const trunc = ms | 0;
+            intervalBetweenFrames = trunc + (ms > trunc ? 1 : 0);
+        }
     }
     let interCharTimeout = resolveOne(opts.interCharTimeout, baudRate, 0.75);
     if (interCharTimeout === undefined) {
@@ -388,7 +409,9 @@ class TimerHeap {
             this._mode = 'heap';
             for (const [existingId, { handle, deadline }] of this._directTimers) {
                 clearTimeout(handle);
-                const remaining = Math.max(0, Math.ceil(deadline - performance.now()));
+                const diff = deadline - performance.now();
+                const trunc = diff | 0;
+                const remaining = diff > 0 ? trunc + (diff > trunc ? 1 : 0) : 0;
                 if (remaining === 0) {
                     this._onFire(existingId);
                 }
@@ -448,8 +471,10 @@ class TimerHeap {
         if (this._deadlines.length === 0) {
             return;
         }
-        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
-        const safeDelay = Math.min(delay, 2147483647);
+        const diff = this._deadlines[0] - performance.now();
+        const trunc = diff | 0;
+        const delay = diff > 0 ? trunc + (diff > trunc ? 1 : 0) : 0;
+        const safeDelay = delay < 2147483647 ? delay : 2147483647;
         this._timer = setTimeout(this._boundTick, safeDelay);
     }
     _onTick() {
@@ -521,14 +546,17 @@ function isWhitelisted(address, whitelist) {
     return whitelist.includes(normalized);
 }
 
+exports.CRC_TABLE = CRC_TABLE;
 exports.PREDICT_NEED_MORE = PREDICT_NEED_MORE;
 exports.PREDICT_UNKNOWN = PREDICT_UNKNOWN;
+exports.REQ_TABLE = REQ_TABLE;
+exports.RES_TABLE = RES_TABLE;
 exports.TimerHeap = TimerHeap;
 exports.bitsToMs = bitsToMs;
 exports.checkRange = checkRange;
-exports.crc = crc;
+exports.crcDual = crcDual;
+exports.crcFixed = crcFixed;
 exports.drainCbs = drainCbs;
-exports.isUint8 = isUint8;
 exports.isWhitelisted = isWhitelisted;
 exports.lrc = lrc;
 exports.predictRtuFrameLength = predictRtuFrameLength;

package/dist/utils.d.ts

@@ -39,11 +39,12 @@ interface RtuProtocolOptions {
      */
     interCharTimeout?: RtuTimingValue;
     /**
-     * Buffer pool size per connection (bytes). Defaults to `MAX_FRAME_LENGTH * 2`
-     * (512 bytes). Increase this if you expect frames larger than 256 bytes or
-     * heavy pipelining on a single connection.
+     * Enforces strict Modbus RTU timing. When true, any frame containing a t1.5
+     * inter-character timeout event will be discarded immediately, even if the
+     * CRC16 is valid.
+     * @default false
      */
-    poolSize?: number;
+    strictTiming?: boolean;
 }
 /** Resolved RTU timing values in milliseconds. */
 interface ResolvedRtuTiming {
@@ -87,22 +88,22 @@ declare function drainCbs(cbs: (((err?: Error | null) => void) | undefined)[] |
 
 declare function checkRange(value: number | number[], range?: [number, number] | [number, number][]): boolean;
 
-declare function crc(data: Uint8Array, start: number, end: number): number;
-
+declare const CRC_TABLE: Uint16Array<ArrayBuffer>;
+/** CRC-16 (Modbus) over a single contiguous buffer. */
+declare function crcFixed(data: Uint8Array, start: number, end: number): number;
 /**
- * Returns true when `n` is an integer in the unsigned-byte range [0, 255].
- *
- * Used for byte-level Modbus payload validation (function-code values, raw
- * byte arrays in FC17/FC43 responses) — rejects negative, fractional, NaN,
- * Infinity, and out-of-range values uniformly.
+ * CRC-16 (Modbus) over two contiguous buffer segments.
+ * Computes CRC(head[headOff:headOff+headLen]) followed by CRC(tail[tailOff:tailOff+tailLen]).
  */
-declare function isUint8(n: number): boolean;
+declare function crcDual(head: Uint8Array, headOff: number, headLen: number, tail: Uint8Array, tailOff: number, tailLen: number): number;
 
 declare function lrc(data: Uint8Array, start: number, end: number): number;
 
 declare const PREDICT_NEED_MORE = 0;
 declare const PREDICT_UNKNOWN = -1;
-declare function predictRtuFrameLength(buffer: Buffer, start: number, end: number, isResponse: boolean): number;
+declare const REQ_TABLE: Int32Array<ArrayBuffer>;
+declare const RES_TABLE: Int32Array<ArrayBuffer>;
+declare function predictRtuFrameLength(residual: Buffer, data: Buffer, residualLen: number, start: number, end: number, isResponse: boolean): number;
 
 /**
  * Convert a callback-style `(cb: (err?) => void) => void` call into a Promise.
@@ -159,5 +160,5 @@ declare class TimerHeap {
  */
 declare function isWhitelisted(address: string | undefined, whitelist: string[] | undefined): boolean;
 
-export { PREDICT_NEED_MORE, PREDICT_UNKNOWN, TimerHeap, bitsToMs, checkRange, crc, drainCbs, isUint8, isWhitelisted, lrc, predictRtuFrameLength, promisifyCb, resolveRtuTiming };
+export { CRC_TABLE, PREDICT_NEED_MORE, PREDICT_UNKNOWN, REQ_TABLE, RES_TABLE, TimerHeap, bitsToMs, checkRange, crcDual, crcFixed, drainCbs, isWhitelisted, lrc, predictRtuFrameLength, promisifyCb, resolveRtuTiming };
 export type { ResolvedRtuTiming, RtuProtocolOptions };

package/dist/utils.mjs

@@ -90,7 +90,7 @@ function checkRange(value, range) {
     return false;
 }
 
-const TABLE = new Uint16Array([
+const CRC_TABLE = new Uint16Array([
     0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01,
     0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0,
     0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581,
@@ -108,23 +108,29 @@ const TABLE = new Uint16Array([
     0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
     0x4040,
 ]);
-function crc(data, start, end) {
+/** CRC-16 (Modbus) over a single contiguous buffer. */
+function crcFixed(data, start, end) {
     let crc = 0xffff;
     for (let index = start; index < end; index++) {
-        crc = TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
+        crc = CRC_TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
     }
     return crc;
 }
-
 /**
- * Returns true when `n` is an integer in the unsigned-byte range [0, 255].
- *
- * Used for byte-level Modbus payload validation (function-code values, raw
- * byte arrays in FC17/FC43 responses) — rejects negative, fractional, NaN,
- * Infinity, and out-of-range values uniformly.
+ * CRC-16 (Modbus) over two contiguous buffer segments.
+ * Computes CRC(head[headOff:headOff+headLen]) followed by CRC(tail[tailOff:tailOff+tailLen]).
  */
-function isUint8(n) {
-    return (n & 0xff) === n;
+function crcDual(head, headOff, headLen, tail, tailOff, tailLen) {
+    let crc = 0xffff;
+    const headEnd = headOff + headLen;
+    for (let i = headOff; i < headEnd; i++) {
+        crc = CRC_TABLE[(crc ^ head[i]) & 0xff] ^ (crc >> 8);
+    }
+    const tailEnd = tailOff + tailLen;
+    for (let i = tailOff; i < tailEnd; i++) {
+        crc = CRC_TABLE[(crc ^ tail[i]) & 0xff] ^ (crc >> 8);
+    }
+    return crc;
 }
 
 function lrc(data, start, end) {
@@ -205,12 +211,12 @@ const RES_TABLE = new Int32Array(256);
     RES_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -517;
     RES_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = -999;
 })();
-function predictRtuFrameLength(buffer, start, end, isResponse) {
+function predictRtuFrameLength(residual, data, residualLen, start, end, isResponse) {
     const len = end - start;
     if (len < 2) {
         return PREDICT_NEED_MORE;
     }
-    const fc = buffer[start + 1];
+    const fc = start + 1 < residualLen ? residual[start + 1] : data[start + 1 - residualLen];
     if (isResponse) {
         if ((fc & EXCEPTION_OFFSET) !== 0) {
             return 5;
@@ -226,16 +232,16 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
                 if (end - start < 8) {
                     return PREDICT_NEED_MORE;
                 }
-                if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
+                if ((start + 2 < residualLen ? residual[start + 2] : data[start + 2 - residualLen]) !== MEI_READ_DEVICE_ID) {
                     return PREDICT_UNKNOWN;
                 }
-                const numObjs = buffer[start + 7];
+                const numObjs = start + 7 < residualLen ? residual[start + 7] : data[start + 7 - residualLen];
                 let cursor = start + 8;
                 for (let i = 0; i < numObjs; i++) {
                     if (end < cursor + 2) {
                         return PREDICT_NEED_MORE;
                     }
-                    cursor += 2 + buffer[cursor + 1];
+                    cursor += 2 + (cursor + 1 < residualLen ? residual[cursor + 1] : data[cursor + 1 - residualLen]);
                 }
                 return cursor - start + 2;
             }
@@ -244,7 +250,7 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
             if (len <= offset) {
                 return PREDICT_NEED_MORE;
             }
-            return (decode & 0xff) + buffer[start + offset];
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
     }
     else {
@@ -258,7 +264,7 @@ function predictRtuFrameLength(buffer, start, end, isResponse) {
             if (len <= offset) {
                 return PREDICT_NEED_MORE;
             }
-            return (decode & 0xff) + buffer[start + offset];
+            return (decode & 0xff) + (start + offset < residualLen ? residual[start + offset] : data[start + offset - residualLen]);
         }
     }
     return PREDICT_UNKNOWN;
@@ -301,7 +307,12 @@ function resolveOne(value, baudRate, fastBaudMs) {
     if (baudRate === undefined) {
         return undefined;
     }
-    return baudRate > 19200 ? fastBaudMs : Math.ceil(bitsToMs(baudRate, value.value));
+    if (baudRate > 19200) {
+        return fastBaudMs;
+    }
+    const ms = bitsToMs(baudRate, value.value);
+    const trunc = ms | 0;
+    return trunc + (ms > trunc ? 1 : 0);
 }
 /**
  * Resolve Modbus RTU timing parameters from user options into milliseconds.
@@ -318,7 +329,17 @@ function resolveRtuTiming(opts = {}, baudRate) {
     if (intervalBetweenFrames === undefined) {
         // Spec default: t3.5 derived from baudRate, or 0 when neither option nor
         // baudRate were supplied.
-        intervalBetweenFrames = baudRate !== undefined ? (baudRate > 19200 ? 1.75 : Math.ceil(bitsToMs(baudRate, 38.5))) : 0;
+        if (baudRate === undefined) {
+            intervalBetweenFrames = 0;
+        }
+        else if (baudRate > 19200) {
+            intervalBetweenFrames = 1.75;
+        }
+        else {
+            const ms = bitsToMs(baudRate, 38.5);
+            const trunc = ms | 0;
+            intervalBetweenFrames = trunc + (ms > trunc ? 1 : 0);
+        }
     }
     let interCharTimeout = resolveOne(opts.interCharTimeout, baudRate, 0.75);
     if (interCharTimeout === undefined) {
@@ -386,7 +407,9 @@ class TimerHeap {
             this._mode = 'heap';
             for (const [existingId, { handle, deadline }] of this._directTimers) {
                 clearTimeout(handle);
-                const remaining = Math.max(0, Math.ceil(deadline - performance.now()));
+                const diff = deadline - performance.now();
+                const trunc = diff | 0;
+                const remaining = diff > 0 ? trunc + (diff > trunc ? 1 : 0) : 0;
                 if (remaining === 0) {
                     this._onFire(existingId);
                 }
@@ -446,8 +469,10 @@ class TimerHeap {
         if (this._deadlines.length === 0) {
             return;
         }
-        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
-        const safeDelay = Math.min(delay, 2147483647);
+        const diff = this._deadlines[0] - performance.now();
+        const trunc = diff | 0;
+        const delay = diff > 0 ? trunc + (diff > trunc ? 1 : 0) : 0;
+        const safeDelay = delay < 2147483647 ? delay : 2147483647;
         this._timer = setTimeout(this._boundTick, safeDelay);
     }
     _onTick() {
@@ -519,4 +544,4 @@ function isWhitelisted(address, whitelist) {
     return whitelist.includes(normalized);
 }
 
-export { PREDICT_NEED_MORE, PREDICT_UNKNOWN, TimerHeap, bitsToMs, checkRange, crc, drainCbs, isUint8, isWhitelisted, lrc, predictRtuFrameLength, promisifyCb, resolveRtuTiming };
+export { CRC_TABLE, PREDICT_NEED_MORE, PREDICT_UNKNOWN, REQ_TABLE, RES_TABLE, TimerHeap, bitsToMs, checkRange, crcDual, crcFixed, drainCbs, isWhitelisted, lrc, predictRtuFrameLength, promisifyCb, resolveRtuTiming };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "njs-modbus",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "A pure JavaScript implementation of Modbus for Node.js.",
   "keywords": [
     "modbus",
@@ -45,16 +45,10 @@
   "scripts": {
     "build": "node -e \"fs.rmSync('dist', {recursive: true, force: true})\" && rollup -c && node -e \"fs.rmSync('dist/src', {recursive: true, force: true})\"",
     "test": "tsx --test test/**/*.test.ts",
-    "benchmark": "tsx benchmark/encode-decode.ts && echo && tsx benchmark/tcp-throughput.ts && echo && tsx benchmark/concurrent.ts",
-    "benchmark:encode-decode": "tsx benchmark/encode-decode.ts",
-    "benchmark:tcp": "tsx benchmark/tcp-throughput.ts",
-    "benchmark:concurrent": "tsx benchmark/concurrent.ts",
-    "benchmark:rtu": "tsx benchmark/rtu-throughput.ts",
-    "benchmark:all-fcs": "tsx benchmark/all-fcs.ts",
     "benchmark:report": "tsx benchmark/generate-report.ts",
+    "benchmark:report:test": "tsx benchmark/test-report.ts",
     "benchmark:report:quick": "tsx benchmark/generate-report.ts -- --duration 10s --runs 2",
-    "benchmark:report:full": "tsx benchmark/generate-report.ts -- --duration 120s --runs 3 --max-payload",
-    "benchmark:profile": "tsx benchmark/all-fcs.ts -- --duration 30s --runs 1 --only fc03 --libs njs-modbus --profile",
+    "benchmark:report:full": "tsx benchmark/generate-report.ts -- --duration 120s --runs 5 --max-payload",
     "util:sort-package-json": "sort-package-json"
   },
   "devDependencies": {