njs-modbus 3.1.1 → 3.3.0

package/dist/utils.mjs

@@ -0,0 +1,522 @@
+/**
+ * Convert a number of bits to milliseconds at a given baud rate.
+ *
+ * Used to derive Modbus RTU timing intervals from bit counts — e.g. 38.5 bits
+ * = 3.5 character times at 11 bits/char (t3.5 inter-frame silence), or 16.5
+ * bits = 1.5 character times (t1.5 inter-character timeout), per Modbus V1.02
+ * §2.5.1.1.
+ *
+ * @param baudRate Serial port baud rate.
+ * @param bits Number of bits to convert.
+ * @returns Duration in milliseconds.
+ */
+function bitsToMs(baudRate, bits) {
+    return (bits * 1000) / baudRate;
+}
+
+/**
+ * Drain a pending-callback array: invoke each callback with the given error (or null).
+ *
+ * Handles `null`/`undefined` entries (from optional `cb?` parameters) gracefully.
+ * Used by physical layers and connections to resolve queued
+ * open / close / destroy callbacks.
+ */
+function drainCbs(cbs, err) {
+    if (!cbs) {
+        return;
+    }
+    for (const cb of cbs) {
+        cb?.(err);
+    }
+}
+
+function checkRange(value, range) {
+    if (!range || range.length === 0) {
+        return true;
+    }
+    const isMultiRange = Array.isArray(range[0]);
+    const isValueArray = Array.isArray(value);
+    if (!isValueArray && !isMultiRange) {
+        const r = range;
+        const min = r[0], max = r[1];
+        const v = value;
+        return min <= max ? v >= min && v <= max : v >= max && v <= min;
+    }
+    if (!isValueArray && isMultiRange) {
+        const ranges = range;
+        const v = value;
+        for (let i = 0; i < ranges.length; i++) {
+            const min = ranges[i][0], max = ranges[i][1];
+            const lo = min <= max ? min : max;
+            const hi = min <= max ? max : min;
+            if (v >= lo && v <= hi) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const values = value;
+    if (values.length === 0) {
+        return true;
+    }
+    if (!isMultiRange) {
+        const r = range;
+        const min = r[0], max = r[1];
+        const lo = min <= max ? min : max;
+        const hi = min <= max ? max : min;
+        for (let i = 0; i < values.length; i++) {
+            if (values[i] < lo || values[i] > hi) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const ranges = range;
+    for (let i = 0; i < ranges.length; i++) {
+        const min = ranges[i][0], max = ranges[i][1];
+        const lo = min <= max ? min : max;
+        const hi = min <= max ? max : min;
+        let allInRange = true;
+        for (let j = 0; j < values.length; j++) {
+            if (values[j] < lo || values[j] > hi) {
+                allInRange = false;
+                break;
+            }
+        }
+        if (allInRange) {
+            return true;
+        }
+    }
+    return false;
+}
+
+const TABLE = 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,
+    0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141,
+    0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01,
+    0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0,
+    0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681,
+    0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
+    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01,
+    0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0,
+    0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381,
+    0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741,
+    0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901,
+    0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0,
+    0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
+    0x4040,
+]);
+function crc(data, start, end) {
+    let crc = 0xffff;
+    for (let index = start; index < end; index++) {
+        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.
+ */
+function isUint8(n) {
+    return (n & 0xff) === n;
+}
+
+function lrc(data, start, end) {
+    let sum = 0;
+    for (let i = start; i < end; i++) {
+        sum += data[i];
+    }
+    return -sum & 0xff;
+}
+
+/**
+ * Standard Modbus function codes (V1.1b3 §6).
+ */
+var FunctionCode;
+(function (FunctionCode) {
+    FunctionCode[FunctionCode["READ_COILS"] = 1] = "READ_COILS";
+    FunctionCode[FunctionCode["READ_DISCRETE_INPUTS"] = 2] = "READ_DISCRETE_INPUTS";
+    FunctionCode[FunctionCode["READ_HOLDING_REGISTERS"] = 3] = "READ_HOLDING_REGISTERS";
+    FunctionCode[FunctionCode["READ_INPUT_REGISTERS"] = 4] = "READ_INPUT_REGISTERS";
+    FunctionCode[FunctionCode["WRITE_SINGLE_COIL"] = 5] = "WRITE_SINGLE_COIL";
+    FunctionCode[FunctionCode["WRITE_SINGLE_REGISTER"] = 6] = "WRITE_SINGLE_REGISTER";
+    FunctionCode[FunctionCode["WRITE_MULTIPLE_COILS"] = 15] = "WRITE_MULTIPLE_COILS";
+    FunctionCode[FunctionCode["WRITE_MULTIPLE_REGISTERS"] = 16] = "WRITE_MULTIPLE_REGISTERS";
+    FunctionCode[FunctionCode["REPORT_SERVER_ID"] = 17] = "REPORT_SERVER_ID";
+    FunctionCode[FunctionCode["MASK_WRITE_REGISTER"] = 22] = "MASK_WRITE_REGISTER";
+    FunctionCode[FunctionCode["READ_WRITE_MULTIPLE_REGISTERS"] = 23] = "READ_WRITE_MULTIPLE_REGISTERS";
+    FunctionCode[FunctionCode["READ_DEVICE_IDENTIFICATION"] = 43] = "READ_DEVICE_IDENTIFICATION";
+})(FunctionCode || (FunctionCode = {}));
+/** Exception response FC = request FC | EXCEPTION_OFFSET (V1.1b3 §7). */
+const EXCEPTION_OFFSET = 0x80;
+/** FC 0x2B MEI sub-function selecting Read Device Identification (V1.1b3 §6.21). */
+const MEI_READ_DEVICE_ID = 0x0e;
+/** Read Device ID code values inside an FC 0x2B / MEI 0x0E request. */
+var ReadDeviceIDCode;
+(function (ReadDeviceIDCode) {
+    ReadDeviceIDCode[ReadDeviceIDCode["BASIC_STREAM"] = 1] = "BASIC_STREAM";
+    ReadDeviceIDCode[ReadDeviceIDCode["REGULAR_STREAM"] = 2] = "REGULAR_STREAM";
+    ReadDeviceIDCode[ReadDeviceIDCode["EXTENDED_STREAM"] = 3] = "EXTENDED_STREAM";
+    ReadDeviceIDCode[ReadDeviceIDCode["SPECIFIC_ACCESS"] = 4] = "SPECIFIC_ACCESS";
+})(ReadDeviceIDCode || (ReadDeviceIDCode = {}));
+/** Conformity level reported in an FC 0x2B / MEI 0x0E response. */
+var ConformityLevel;
+(function (ConformityLevel) {
+    ConformityLevel[ConformityLevel["BASIC"] = 129] = "BASIC";
+    ConformityLevel[ConformityLevel["REGULAR"] = 130] = "REGULAR";
+    ConformityLevel[ConformityLevel["EXTENDED"] = 131] = "EXTENDED";
+})(ConformityLevel || (ConformityLevel = {}));
+/** Shared empty Buffer to avoid repeated allocations. */
+Buffer.alloc(0);
+
+const PREDICT_NEED_MORE = 0;
+const PREDICT_UNKNOWN = -1;
+const REQ_TABLE = new Int32Array(256);
+const RES_TABLE = new Int32Array(256);
+(function initTables() {
+    REQ_TABLE[FunctionCode.READ_COILS] = 8;
+    REQ_TABLE[FunctionCode.READ_DISCRETE_INPUTS] = 8;
+    REQ_TABLE[FunctionCode.READ_HOLDING_REGISTERS] = 8;
+    REQ_TABLE[FunctionCode.READ_INPUT_REGISTERS] = 8;
+    REQ_TABLE[FunctionCode.WRITE_SINGLE_COIL] = 8;
+    REQ_TABLE[FunctionCode.WRITE_SINGLE_REGISTER] = 8;
+    REQ_TABLE[FunctionCode.REPORT_SERVER_ID] = 4;
+    REQ_TABLE[FunctionCode.MASK_WRITE_REGISTER] = 10;
+    REQ_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = 7;
+    REQ_TABLE[FunctionCode.WRITE_MULTIPLE_COILS] = -1545;
+    REQ_TABLE[FunctionCode.WRITE_MULTIPLE_REGISTERS] = -1545;
+    REQ_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -2573;
+    RES_TABLE[FunctionCode.WRITE_SINGLE_COIL] = 8;
+    RES_TABLE[FunctionCode.WRITE_SINGLE_REGISTER] = 8;
+    RES_TABLE[FunctionCode.WRITE_MULTIPLE_COILS] = 8;
+    RES_TABLE[FunctionCode.WRITE_MULTIPLE_REGISTERS] = 8;
+    RES_TABLE[FunctionCode.MASK_WRITE_REGISTER] = 10;
+    RES_TABLE[FunctionCode.READ_COILS] = -517;
+    RES_TABLE[FunctionCode.READ_DISCRETE_INPUTS] = -517;
+    RES_TABLE[FunctionCode.READ_HOLDING_REGISTERS] = -517;
+    RES_TABLE[FunctionCode.READ_INPUT_REGISTERS] = -517;
+    RES_TABLE[FunctionCode.REPORT_SERVER_ID] = -517;
+    RES_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -517;
+    RES_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = -999;
+})();
+function predictRtuFrameLength(buffer, start, end, isResponse) {
+    const len = end - start;
+    if (len < 2) {
+        return PREDICT_NEED_MORE;
+    }
+    const fc = buffer[start + 1];
+    if (isResponse) {
+        if ((fc & EXCEPTION_OFFSET) !== 0) {
+            return 5;
+        }
+        const val = RES_TABLE[fc];
+        if (val > 0) {
+            return val;
+        }
+        if (val < 0) {
+            if (val === -999) {
+                // FC 43 / MEI 14 response — inline to avoid function-call overhead on
+                // the framing hot path (even though this FC is uncommon).
+                if (end - start < 8) {
+                    return PREDICT_NEED_MORE;
+                }
+                if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
+                    return PREDICT_UNKNOWN;
+                }
+                const numObjs = buffer[start + 7];
+                let cursor = start + 8;
+                for (let i = 0; i < numObjs; i++) {
+                    if (end < cursor + 2) {
+                        return PREDICT_NEED_MORE;
+                    }
+                    cursor += 2 + buffer[cursor + 1];
+                }
+                return cursor - start + 2;
+            }
+            const decode = -val;
+            const offset = decode >> 8;
+            if (len <= offset) {
+                return PREDICT_NEED_MORE;
+            }
+            return (decode & 0xff) + buffer[start + offset];
+        }
+    }
+    else {
+        const val = REQ_TABLE[fc];
+        if (val > 0) {
+            return val;
+        }
+        if (val < 0) {
+            const decode = -val;
+            const offset = decode >> 8;
+            if (len <= offset) {
+                return PREDICT_NEED_MORE;
+            }
+            return (decode & 0xff) + buffer[start + offset];
+        }
+    }
+    return PREDICT_UNKNOWN;
+}
+
+/**
+ * Convert a callback-style `(cb: (err?) => void) => void` call into a Promise.
+ */
+function promisifyCb(fn) {
+    return new Promise((resolve, reject) => {
+        fn((err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+
+/**
+ * Resolve a single RTU timing parameter to milliseconds.
+ *
+ * Returns `undefined` when the caller did not supply the parameter at all
+ * (so the caller knows to fall back to a spec default). An explicit `0` or
+ * `{ value: 0 }` returns `0` — the parameter is set, just disabled.
+ */
+function resolveOne(value, baudRate, fastBaudMs) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (value.unit === 'ms') {
+        return value.value;
+    }
+    // unit === 'bit' — needs baudRate to convert
+    if (baudRate === undefined) {
+        return undefined;
+    }
+    return baudRate > 19200 ? fastBaudMs : Math.ceil(bitsToMs(baudRate, value.value));
+}
+/**
+ * Resolve Modbus RTU timing parameters from user options into milliseconds.
+ *
+ * - `intervalBetweenFrames` (t3.5): if omitted and `baudRate` is present,
+ *   defaults to 38.5 bits per Modbus V1.02 §2.5.1.1. Pass `0` to disable.
+ * - `interCharTimeout` (t1.5): opt-in; only resolved when explicitly provided.
+ *
+ * Per the spec, at baud rates > 19200 fixed values are used
+ * (1.75 ms for t3.5, 0.75 ms for t1.5) regardless of the bit value.
+ */
+function resolveRtuTiming(opts = {}, baudRate) {
+    let intervalBetweenFrames = resolveOne(opts.intervalBetweenFrames, baudRate, 1.75);
+    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;
+    }
+    let interCharTimeout = resolveOne(opts.interCharTimeout, baudRate, 0.75);
+    if (interCharTimeout === undefined) {
+        // t1.5 is opt-in — no spec-default fallback.
+        interCharTimeout = 0;
+    }
+    return { intervalBetweenFrames, interCharTimeout };
+}
+
+/**
+ * Hybrid timer manager: uses native `setTimeout` for low concurrency
+ * and switches to a binary min-heap when concurrency exceeds the threshold.
+ *
+ * Benchmarks (add + clear throughput, Node 24, x64):
+ *   1 concurrent:  setTimeout ~1.7× faster than heap
+ *   2 concurrent:  setTimeout ~1.6× faster than heap
+ *   5 concurrent:  setTimeout ~1.5-1.9× faster than heap
+ *  10 concurrent:  roughly equal
+ *  20 concurrent:  heap ~1.3× faster than setTimeout[]
+ *  50 concurrent:  heap ~1.4-1.7× faster than setTimeout[]
+ *
+ * The crossover point is around 10 concurrent timers, so the default
+ * `concurrentThreshold = 2` keeps the common 1-2 request case on the
+ * fast direct path while delegating to the heap for larger batches.
+ */
+class TimerHeap {
+    _deadlines = [];
+    _ids = [];
+    _seqs = [];
+    _counter = 0;
+    _timer = null;
+    _onFire;
+    _boundTick;
+    _threshold;
+    _mode = 'direct';
+    _directTimers = new Map();
+    /**
+     * @param onFire  Callback invoked with the timer id when it expires.
+     * @param concurrentThreshold  Maximum number of timers kept as individual
+     *     native `setTimeout` handles. Once exceeded, all timers migrate to
+     *     the internal heap and share a single native timer. Default is 2.
+     */
+    constructor(onFire, concurrentThreshold = 2) {
+        this._onFire = onFire;
+        this._boundTick = this._onTick.bind(this);
+        this._threshold = concurrentThreshold;
+    }
+    get size() {
+        return this._mode === 'direct' ? this._directTimers.size : this._deadlines.length;
+    }
+    add(id, ms) {
+        if (this._mode === 'direct' && this._directTimers.size + 1 <= this._threshold) {
+            const deadline = performance.now() + ms;
+            const handle = setTimeout(() => {
+                if (this._mode !== 'direct') {
+                    return;
+                }
+                this._directTimers.delete(id);
+                this._onFire(id);
+            }, ms);
+            this._directTimers.set(id, { handle, deadline });
+            return;
+        }
+        if (this._mode === 'direct') {
+            this._mode = 'heap';
+            for (const [existingId, { handle, deadline }] of this._directTimers) {
+                clearTimeout(handle);
+                const remaining = Math.max(0, Math.ceil(deadline - performance.now()));
+                if (remaining === 0) {
+                    this._onFire(existingId);
+                }
+                else {
+                    this._heapAdd(existingId, remaining);
+                }
+            }
+            this._directTimers.clear();
+        }
+        this._heapAdd(id, ms);
+    }
+    clear() {
+        for (const { handle } of this._directTimers.values()) {
+            clearTimeout(handle);
+        }
+        this._directTimers.clear();
+        this._mode = 'direct';
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        this._deadlines.length = 0;
+        this._ids.length = 0;
+        this._seqs.length = 0;
+        this._counter = 0;
+    }
+    _heapAdd(id, ms) {
+        const deadline = performance.now() + ms;
+        const seq = this._counter++;
+        let i = this._deadlines.length;
+        this._deadlines.push(deadline);
+        this._ids.push(id);
+        this._seqs.push(seq);
+        while (i > 0) {
+            const p = (i - 1) >> 1;
+            const parentComesFirst = this._deadlines[p] < deadline || (this._deadlines[p] === deadline && this._seqs[p] < seq);
+            if (parentComesFirst) {
+                break;
+            }
+            this._deadlines[i] = this._deadlines[p];
+            this._ids[i] = this._ids[p];
+            this._seqs[i] = this._seqs[p];
+            i = p;
+        }
+        this._deadlines[i] = deadline;
+        this._ids[i] = id;
+        this._seqs[i] = seq;
+        if (i === 0) {
+            this._refresh();
+        }
+    }
+    _refresh() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        if (this._deadlines.length === 0) {
+            return;
+        }
+        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
+        const safeDelay = Math.min(delay, 2147483647);
+        this._timer = setTimeout(this._boundTick, safeDelay);
+    }
+    _onTick() {
+        this._timer = null;
+        const now = performance.now();
+        try {
+            while (this._deadlines.length > 0 && this._deadlines[0] <= now) {
+                const id = this._pop();
+                this._onFire(id);
+            }
+        }
+        finally {
+            this._refresh();
+        }
+    }
+    _pop() {
+        const topId = this._ids[0];
+        const lastId = this._ids.pop();
+        const lastDeadline = this._deadlines.pop();
+        const lastSeq = this._seqs.pop();
+        const n = this._deadlines.length;
+        if (n > 0) {
+            let i = 0;
+            const half = n >> 1;
+            while (i < half) {
+                let minChild = (i << 1) + 1;
+                const rightChild = minChild + 1;
+                if (rightChild < n) {
+                    const rightComesFirst = this._deadlines[rightChild] < this._deadlines[minChild] ||
+                        (this._deadlines[rightChild] === this._deadlines[minChild] && this._seqs[rightChild] < this._seqs[minChild]);
+                    if (rightComesFirst) {
+                        minChild = rightChild;
+                    }
+                }
+                const lastComesFirst = lastDeadline < this._deadlines[minChild] || (lastDeadline === this._deadlines[minChild] && lastSeq < this._seqs[minChild]);
+                if (lastComesFirst) {
+                    break;
+                }
+                this._deadlines[i] = this._deadlines[minChild];
+                this._ids[i] = this._ids[minChild];
+                this._seqs[i] = this._seqs[minChild];
+                i = minChild;
+            }
+            this._deadlines[i] = lastDeadline;
+            this._ids[i] = lastId;
+            this._seqs[i] = lastSeq;
+        }
+        return topId;
+    }
+}
+
+/**
+ * Normalize an IP address by stripping the IPv4-mapped IPv6 prefix.
+ * This ensures consistent comparison of addresses like `::ffff:192.168.1.1`.
+ */
+function normalizeAddress(address = '') {
+    return address.replace(/^::ffff:/, '');
+}
+/**
+ * Check whether a remote address is allowed by the given whitelist.
+ * IPv4-mapped IPv6 addresses are normalized before comparison.
+ * Returns `true` when whitelist is absent or empty.
+ */
+function isWhitelisted(address, whitelist) {
+    if (!whitelist || whitelist.length === 0) {
+        return true;
+    }
+    const normalized = normalizeAddress(address);
+    return whitelist.includes(normalized);
+}
+
+export { PREDICT_NEED_MORE, PREDICT_UNKNOWN, TimerHeap, bitsToMs, checkRange, crc, drainCbs, isUint8, isWhitelisted, lrc, predictRtuFrameLength, promisifyCb, resolveRtuTiming };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "njs-modbus",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "description": "A pure JavaScript implementation of Modbus for Node.js.",
   "keywords": [
     "modbus",
@@ -26,15 +26,35 @@
   "module": "dist/index.mjs",
   "source": "src/index.ts",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils.mjs",
+      "require": "./dist/utils.cjs",
+      "types": "./dist/utils.d.ts"
+    }
+  },
   "files": [
     "dist",
     "*.d.ts"
   ],
   "scripts": {
-    "build": "node -e \"fs.rmSync('dist', {recursive: true, force: true})\" && rollup -c",
+    "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: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",
     "util:sort-package-json": "sort-package-json"
   },
   "devDependencies": {

package/dist/src/error-code.d.ts

@@ -1,17 +0,0 @@
-export declare enum ErrorCode {
-    ILLEGAL_FUNCTION = 1,
-    ILLEGAL_DATA_ADDRESS = 2,
-    ILLEGAL_DATA_VALUE = 3,
-    SERVER_DEVICE_FAILURE = 4,
-    ACKNOWLEDGE = 5,
-    SERVER_DEVICE_BUSY = 6,
-    MEMORY_PARITY_ERROR = 8,
-    GATEWAY_PATH_UNAVAILABLE = 10,
-    GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11
-}
-export declare class ModbusError extends Error {
-    readonly code: ErrorCode;
-    constructor(code: ErrorCode, message?: string);
-}
-export declare function getErrorByCode(code: ErrorCode): ModbusError;
-export declare function getCodeByError(err: Error): ErrorCode;

package/dist/src/index.d.ts

@@ -1,7 +0,0 @@
-export * from './types';
-export * from './error-code';
-export * from './vars';
-export * from './layers/physical';
-export * from './layers/application';
-export * from './master';
-export * from './slave';

package/dist/src/layers/application/abstract-application-layer.d.ts

@@ -1,26 +0,0 @@
-import type { ApplicationDataUnit, CustomFunctionCode } from '../../types';
-import type { AbstractPhysicalConnection } from '../physical';
-import EventEmitter from 'node:events';
-interface AbstractApplicationLayerEvents {
-    framing: [frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }];
-    'framing-error': [error: Error];
-}
-/**
- * Application-layer protocol handler bound to a single physical connection.
- *
- * Its lifetime follows the channel: created when the underlying connection is
- * established and discarded when the connection closes. Subclasses implement
- * ASCII, RTU, or TCP framing rules.
- */
-export declare abstract class AbstractApplicationLayer extends EventEmitter<AbstractApplicationLayerEvents> {
-    abstract readonly PROTOCOL: 'ASCII' | 'RTU' | 'TCP';
-    abstract ROLE: 'MASTER' | 'SLAVE';
-    abstract readonly connection: AbstractPhysicalConnection;
-    flush(): void;
-    addCustomFunctionCode(cfc: CustomFunctionCode): void;
-    removeCustomFunctionCode(fc: number): void;
-    abstract encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}
-export {};

package/dist/src/layers/application/ascii-application-layer.d.ts

@@ -1,23 +0,0 @@
-import type { AbstractPhysicalConnection } from '../physical';
-import { AbstractApplicationLayer } from './abstract-application-layer';
-export interface AsciiApplicationLayerOptions {
-    /**
-     * Accept lowercase hex digits (`a-f`) in addition to uppercase (`A-F`).
-     * Default false (strict per Modbus V1.1b3 §2.2 — uppercase only).
-     * Non-hex characters are always rejected with a `framing-error`.
-     */
-    lenientHex?: boolean;
-}
-export declare class AsciiApplicationLayer extends AbstractApplicationLayer {
-    readonly PROTOCOL: "ASCII";
-    readonly ROLE: 'MASTER' | 'SLAVE';
-    readonly lenientHex: boolean;
-    private _connection;
-    private _state;
-    private _cleanupFns;
-    get connection(): AbstractPhysicalConnection;
-    constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: AsciiApplicationLayerOptions);
-    private framing;
-    flush(): void;
-    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}

package/dist/src/layers/application/index.d.ts

@@ -1,6 +0,0 @@
-export type { AsciiApplicationLayerOptions } from './ascii-application-layer';
-export type { RtuApplicationLayerOptions } from './rtu-application-layer';
-export { AbstractApplicationLayer } from './abstract-application-layer';
-export { RtuApplicationLayer } from './rtu-application-layer';
-export { AsciiApplicationLayer } from './ascii-application-layer';
-export { TcpApplicationLayer } from './tcp-application-layer';

package/dist/src/layers/application/rtu-application-layer.d.ts

@@ -1,34 +0,0 @@
-import type { CustomFunctionCode } from '../../types';
-import type { AbstractPhysicalConnection } from '../physical';
-import { AbstractApplicationLayer } from './abstract-application-layer';
-export interface RtuApplicationLayerOptions {
-    /** Inter-frame silence in milliseconds (Modbus RTU t3.5). 0 = disabled (immediate parse). */
-    intervalBetweenFrames?: number;
-    /** Inter-character timeout in milliseconds (Modbus RTU t1.5). Opt-in. */
-    interCharTimeout?: number;
-    /**
-     * 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.
-     */
-    poolSize?: number;
-}
-export declare class RtuApplicationLayer extends AbstractApplicationLayer {
-    readonly PROTOCOL: "RTU";
-    readonly ROLE: 'MASTER' | 'SLAVE';
-    private _connection;
-    private _state;
-    private _poolSize;
-    private _threePointFiveT;
-    private _onePointFiveT;
-    private _customFunctionCodes;
-    private _cleanupFns;
-    get connection(): AbstractPhysicalConnection;
-    constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: RtuApplicationLayerOptions);
-    private clearStateTimers;
-    private flushBuffer;
-    flush(): void;
-    addCustomFunctionCode(cfc: CustomFunctionCode): void;
-    removeCustomFunctionCode(fc: number): void;
-    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}