njs-modbus 3.1.0 → 3.2.0

package/dist/utils.mjs

@@ -0,0 +1,425 @@
+/**
+ * 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 inRange(n, [min, max]) {
+    return n >= min && n <= max;
+}
+function isRangeArray(range) {
+    return Array.isArray(range[0]);
+}
+function checkRange(value, range) {
+    if (!range || range.length === 0) {
+        return true;
+    }
+    const values = Array.isArray(value) ? value : [value];
+    if (isRangeArray(range)) {
+        for (const r of range) {
+            const [min, max] = r;
+            const [lo, hi] = min <= max ? [min, max] : [max, min];
+            if (values.every((n) => inRange(n, [lo, hi]))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const [min, max] = range;
+    const [lo, hi] = min <= max ? [min, max] : [max, min];
+    return values.every((n) => inRange(n, [lo, hi]));
+}
+
+const TABLE = [
+    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 = 0, end = data.length) {
+    let crc = 0xffff;
+    for (let index = start; index < end; index++) {
+        crc = (TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8)) & 0xffff;
+    }
+    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 Number.isInteger(n) && n >= 0 && n <= 255;
+}
+
+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;
+}
+
+/**
+ * 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 REQUEST_FIXED_LENGTHS = {
+    [FunctionCode.READ_COILS]: 8,
+    [FunctionCode.READ_DISCRETE_INPUTS]: 8,
+    [FunctionCode.READ_HOLDING_REGISTERS]: 8,
+    [FunctionCode.READ_INPUT_REGISTERS]: 8,
+    [FunctionCode.WRITE_SINGLE_COIL]: 8,
+    [FunctionCode.WRITE_SINGLE_REGISTER]: 8,
+    [FunctionCode.REPORT_SERVER_ID]: 4,
+    [FunctionCode.MASK_WRITE_REGISTER]: 10,
+    [FunctionCode.READ_DEVICE_IDENTIFICATION]: 7,
+};
+const REQUEST_BYTE_COUNT = {
+    [FunctionCode.WRITE_MULTIPLE_COILS]: { offset: 6, extra: 9 },
+    [FunctionCode.WRITE_MULTIPLE_REGISTERS]: { offset: 6, extra: 9 },
+    [FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 10, extra: 13 },
+};
+const RESPONSE_FIXED_LENGTHS = {
+    [FunctionCode.WRITE_SINGLE_COIL]: 8,
+    [FunctionCode.WRITE_SINGLE_REGISTER]: 8,
+    [FunctionCode.WRITE_MULTIPLE_COILS]: 8,
+    [FunctionCode.WRITE_MULTIPLE_REGISTERS]: 8,
+    [FunctionCode.MASK_WRITE_REGISTER]: 10,
+};
+const RESPONSE_BYTE_COUNT = {
+    [FunctionCode.READ_COILS]: { offset: 2, extra: 5 },
+    [FunctionCode.READ_DISCRETE_INPUTS]: { offset: 2, extra: 5 },
+    [FunctionCode.READ_HOLDING_REGISTERS]: { offset: 2, extra: 5 },
+    [FunctionCode.READ_INPUT_REGISTERS]: { offset: 2, extra: 5 },
+    [FunctionCode.REPORT_SERVER_ID]: { offset: 2, extra: 5 },
+    [FunctionCode.READ_WRITE_MULTIPLE_REGISTERS]: { offset: 2, extra: 5 },
+};
+/** Sentinel: caller needs to feed more bytes before length can be determined. */
+const PREDICT_NEED_MORE = 0;
+/** Sentinel: function code is not in the standard tables. */
+const PREDICT_UNKNOWN = -1;
+/**
+ * Predict the total RTU frame length (PDU + 2-byte CRC) given the leading bytes.
+ *
+ * Returns a sentinel-encoded number to avoid per-call object allocation on the
+ * RTU decode hot path:
+ * - Positive integer (>= 4): total frame length, function code is known.
+ * - {@link PREDICT_NEED_MORE} (0): function code is known but more bytes are
+ *   required (typically waiting on the byteCount byte).
+ * - {@link PREDICT_UNKNOWN} (-1): function code is not in the standard tables —
+ *   the framing layer must defer to a registered `CustomFunctionCode` or treat
+ *   this as a framing error.
+ */
+function predictRtuFrameLength(buffer, start, end, isResponse) {
+    if (end - start < 2) {
+        return PREDICT_NEED_MORE;
+    }
+    const fc = buffer[start + 1];
+    if (isResponse && (fc & EXCEPTION_OFFSET) !== 0) {
+        return 5;
+    }
+    const fixed = (isResponse ? RESPONSE_FIXED_LENGTHS : REQUEST_FIXED_LENGTHS)[fc];
+    if (fixed !== undefined) {
+        return fixed;
+    }
+    const bc = (isResponse ? RESPONSE_BYTE_COUNT : REQUEST_BYTE_COUNT)[fc];
+    if (bc !== undefined) {
+        if (end - start <= bc.offset) {
+            return PREDICT_NEED_MORE;
+        }
+        return bc.extra + buffer[start + bc.offset];
+    }
+    if (isResponse && fc === FunctionCode.READ_DEVICE_IDENTIFICATION) {
+        return predictFc43_14Response(buffer, start, end);
+    }
+    return PREDICT_UNKNOWN;
+}
+/**
+ * Walk the variable-length FC 0x2B / MEI 0x0E (Read Device Identification)
+ * response structure per Modbus V1.1b3 §6.21.
+ *
+ * Layout (after unit and fc):
+ *   mei(1) rdic(1) conformity(1) more(1) nextObjId(1) numObjs(1)
+ *   [objId(1) objLen(1) objData(objLen)] × numObjs
+ *   CRC(2)
+ */
+function predictFc43_14Response(buffer, start, end) {
+    if (end - start < 8) {
+        return PREDICT_NEED_MORE;
+    }
+    if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
+        return PREDICT_UNKNOWN;
+    }
+    const numObjs = buffer[start + 7];
+    let cursor = start + 8;
+    for (let i = 0; i < numObjs; i++) {
+        if (end < cursor + 2) {
+            return PREDICT_NEED_MORE;
+        }
+        const objLen = buffer[cursor + 1];
+        cursor += 2 + objLen;
+    }
+    return cursor - start + 2;
+}
+
+/**
+ * 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 };
+}
+
+/** @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`.
+ */
+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.0",
+  "version": "3.2.0",
   "description": "A pure JavaScript implementation of Modbus for Node.js.",
   "keywords": [
     "modbus",
@@ -26,15 +26,28 @@
   "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 && 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:all-fcs": "tsx benchmark/all-fcs.ts",
     "benchmark:report": "tsx benchmark/generate-report.ts",
-    "build": "node -e \"fs.rmSync('dist', {recursive: true, force: true})\" && rollup -c",
-    "test": "tsx --test test/**/*.test.ts",
     "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;
-}

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

@@ -1,16 +0,0 @@
-import type { AbstractPhysicalConnection } from '../physical';
-import { AbstractApplicationLayer } from './abstract-application-layer';
-export declare class TcpApplicationLayer extends AbstractApplicationLayer {
-    readonly PROTOCOL: "TCP";
-    readonly ROLE: 'MASTER' | 'SLAVE';
-    private _connection;
-    private _transactionId;
-    private _buffer;
-    private _cleanupFns;
-    get connection(): AbstractPhysicalConnection;
-    constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection);
-    private tryExtract;
-    private processFrame;
-    flush(): void;
-    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}

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

@@ -1,50 +0,0 @@
-import type { SerialPhysicalLayer } from './serial-physical-layer';
-import type { TcpClientPhysicalLayer } from './tcp-client-physical-layer';
-import type { TcpServerPhysicalLayer } from './tcp-server-physical-layer';
-import type { UdpClientPhysicalLayer } from './udp-client-physical-layer';
-import type { UdpServerPhysicalLayer } from './udp-server-physical-layer';
-import type { PhysicalConnectionState, PhysicalState } from './vars';
-import EventEmitter from 'node:events';
-interface AbstractPhysicalConnectionEvents {
-    data: [data: Buffer];
-    close: [];
-}
-/**
- * A one-way data transmission channel.
- *
- * State transitions are unidirectional: CONNECTED → DESTROYING → DESTROYED.
- * Once closed, the instance cannot be reused; create a new connection instead.
- */
-export declare abstract class AbstractPhysicalConnection extends EventEmitter<AbstractPhysicalConnectionEvents> {
-    abstract readonly state: PhysicalConnectionState;
-    abstract readonly physicalLayer: AbstractPhysicalLayer;
-    abstract write(data: Buffer, cb?: (err?: Error | null) => void): void;
-    abstract destroy(cb?: (err?: Error | null) => void): void;
-}
-export interface AbstractPhysicalLayerEvents {
-    open: [];
-    connect: [connection: AbstractPhysicalConnection];
-    close: [];
-    error: [error: Error];
-}
-/**
- * An abstraction over local hardware or network resources.
- *
- * `open()` acquires the resource (serial port, TCP socket, UDP socket, etc.).
- * Once ready, it emits `connect` with an {@link AbstractPhysicalConnection},
- * unifying serial, TCP client, TCP server, and UDP under a single
- * "connection-oriented" model similar to a TCP server accepting sockets.
- */
-export declare abstract class AbstractPhysicalLayer extends EventEmitter<AbstractPhysicalLayerEvents> {
-    abstract readonly TYPE: 'SERIAL' | 'TCP_CLIENT' | 'TCP_SERVER' | 'UDP_CLIENT' | 'UDP_SERVER';
-    is(type: 'SERIAL'): this is SerialPhysicalLayer;
-    is(type: 'TCP_CLIENT'): this is TcpClientPhysicalLayer;
-    is(type: 'TCP_SERVER'): this is TcpServerPhysicalLayer;
-    is(type: 'UDP_CLIENT'): this is UdpClientPhysicalLayer;
-    is(type: 'UDP_SERVER'): this is UdpServerPhysicalLayer;
-    abstract readonly state: PhysicalState;
-    /** Last argument is the callback: `(err?: Error | null) => void`. Callback is optional. */
-    abstract open(...args: any[]): void;
-    abstract close(cb?: (err?: Error | null) => void): void;
-}
-export {};

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

@@ -1,12 +0,0 @@
-export type { AbstractPhysicalLayerEvents } from './abstract-physical-layer';
-export type { PhysicalConfig, OpenArgs } from './utils';
-export type { TcpServerPhysicalLayerOptions } from './tcp-server-physical-layer';
-export type { UdpServerPhysicalLayerOptions } from './udp-server-physical-layer';
-export { AbstractPhysicalConnection, AbstractPhysicalLayer } from './abstract-physical-layer';
-export { SerialPhysicalLayer } from './serial-physical-layer';
-export { TcpClientPhysicalLayer } from './tcp-client-physical-layer';
-export { TcpServerPhysicalLayer } from './tcp-server-physical-layer';
-export { UdpClientPhysicalLayer } from './udp-client-physical-layer';
-export { UdpServerPhysicalLayer } from './udp-server-physical-layer';
-export { PhysicalState, PhysicalConnectionState } from './vars';
-export { createPhysicalLayer } from './utils';