njs-modbus 3.2.0 → 3.4.0

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,66 +88,68 @@ 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 function lrc(data: Uint8Array, start: number, end: number): number;
 
-/** Sentinel: caller needs to feed more bytes before length can be determined. */
 declare const PREDICT_NEED_MORE = 0;
-/** Sentinel: function code is not in the standard tables. */
 declare 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.
- */
-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.
  */
 declare function promisifyCb(fn: (cb: (err?: Error | null) => void) => void): Promise<void>;
 
-/** @internal
- * Zero-allocation binary min-heap for coalescing per-request timeouts.
+/**
+ * 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[]
  *
- * 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.
+ * 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.
  */
 declare class TimerHeap {
     private _deadlines;
     private _ids;
+    private _seqs;
+    private _counter;
     private _timer;
     private _onFire;
-    /** Pre-bound tick handler to avoid creating a new arrow function on every setTimeout. */
     private _boundTick;
-    constructor(onFire: (id: number) => void);
-    /** Number of pending timers in the heap. */
+    private _threshold;
+    private _mode;
+    private _directTimers;
+    /**
+     * @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: (id: number) => void, concurrentThreshold?: number);
     get size(): number;
-    /** Schedule an entry. If it becomes the new top, the global timer is re-scheduled (pre-emption). */
     add(id: number, ms: number): void;
-    /** Dispose without firing callbacks. */
     clear(): void;
+    private _heapAdd;
     private _refresh;
     private _onTick;
-    /** Pop and return the id with the earliest deadline. Assumes heap is non-empty. */
     private _pop;
 }
 
@@ -157,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 };