njs-modbus 3.0.2 → 3.1.0

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

@@ -21,6 +21,6 @@ export declare abstract class AbstractApplicationLayer extends EventEmitter<Abst
     flush(): void;
     addCustomFunctionCode(cfc: CustomFunctionCode): void;
     removeCustomFunctionCode(fc: number): void;
-    abstract encode(data: ApplicationDataUnit): Buffer;
+    abstract encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }
 export {};

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

@@ -1,4 +1,3 @@
-import type { ApplicationDataUnit } from '../../types';
 import type { AbstractPhysicalConnection } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
 export interface AsciiApplicationLayerOptions {
@@ -20,5 +19,5 @@ export declare class AsciiApplicationLayer extends AbstractApplicationLayer {
     constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: AsciiApplicationLayerOptions);
     private framing;
     flush(): void;
-    encode(data: ApplicationDataUnit): Buffer;
+    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }

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

@@ -1,4 +1,4 @@
-import type { ApplicationDataUnit, CustomFunctionCode } from '../../types';
+import type { CustomFunctionCode } from '../../types';
 import type { AbstractPhysicalConnection } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
 export interface RtuApplicationLayerOptions {
@@ -27,12 +27,8 @@ export declare class RtuApplicationLayer extends AbstractApplicationLayer {
     constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: RtuApplicationLayerOptions);
     private clearStateTimers;
     private flushBuffer;
-    private deliverFrame;
-    private tryExtract;
-    private checkExpected;
-    private crcMatches;
     flush(): void;
     addCustomFunctionCode(cfc: CustomFunctionCode): void;
     removeCustomFunctionCode(fc: number): void;
-    encode(data: ApplicationDataUnit): Buffer;
+    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }

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

@@ -1,4 +1,3 @@
-import type { ApplicationDataUnit } from '../../types';
 import type { AbstractPhysicalConnection } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
 export declare class TcpApplicationLayer extends AbstractApplicationLayer {
@@ -13,5 +12,5 @@ export declare class TcpApplicationLayer extends AbstractApplicationLayer {
     private tryExtract;
     private processFrame;
     flush(): void;
-    encode(data: ApplicationDataUnit): Buffer;
+    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }

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

@@ -18,8 +18,8 @@ interface AbstractPhysicalConnectionEvents {
 export declare abstract class AbstractPhysicalConnection extends EventEmitter<AbstractPhysicalConnectionEvents> {
     abstract readonly state: PhysicalConnectionState;
     abstract readonly physicalLayer: AbstractPhysicalLayer;
-    abstract write(data: Buffer): Promise<void>;
-    abstract destroy(): Promise<void>;
+    abstract write(data: Buffer, cb?: (err?: Error | null) => void): void;
+    abstract destroy(cb?: (err?: Error | null) => void): void;
 }
 export interface AbstractPhysicalLayerEvents {
     open: [];
@@ -43,7 +43,8 @@ export declare abstract class AbstractPhysicalLayer extends EventEmitter<Abstrac
     is(type: 'UDP_CLIENT'): this is UdpClientPhysicalLayer;
     is(type: 'UDP_SERVER'): this is UdpServerPhysicalLayer;
     abstract readonly state: PhysicalState;
-    abstract open(...args: any[]): Promise<void>;
-    abstract close(): Promise<void>;
+    /** 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/serial-physical-layer.d.ts

@@ -41,14 +41,13 @@ export declare class SerialPhysicalConnection extends AbstractPhysicalConnection
     private _state;
     private _physicalLayer;
     private _serialport;
-    private _destroyPromise;
-    private _resolveDestroy;
+    private _pendingDestroyCbs;
     private _cleanupFns;
     get state(): PhysicalConnectionState;
     get physicalLayer(): AbstractPhysicalLayer;
     constructor(physicalLayer: SerialPhysicalLayer, serialport: SerialPort);
-    write(data: Buffer): Promise<void>;
-    destroy(): Promise<void>;
+    write(data: Buffer, cb?: (err?: Error | null) => void): void;
+    destroy(cb?: (err?: Error | null) => void): void;
 }
 export declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
     readonly TYPE: "SERIAL";
@@ -58,15 +57,14 @@ export declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
     private _serialportOpts;
     private _path;
     private _baudRate;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get serialport(): SerialPort | null;
     get path(): string;
     get baudRate(): number;
     constructor(options: SerialPhysicalLayerOptions);
-    open(): Promise<void>;
-    close(): Promise<void>;
+    open(cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }

package/dist/src/layers/physical/tcp-client-physical-layer.d.ts

@@ -8,13 +8,12 @@ export declare class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _socket;
     private _socketOpts?;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get socket(): Socket | null;
     constructor(options?: SocketConstructorOpts);
-    open(options?: SocketConnectOpts): Promise<void>;
-    close(): Promise<void>;
+    open(options?: SocketConnectOpts | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }

package/dist/src/layers/physical/tcp-physical-connection.d.ts

@@ -6,12 +6,11 @@ export declare class TcpPhysicalConnection extends AbstractPhysicalConnection {
     private _state;
     private _physicalLayer;
     private _socket;
-    private _destroyPromise;
-    private _resolveDestroy;
+    private _pendingDestroyCbs;
     private _cleanupFns;
     get state(): PhysicalConnectionState;
     get physicalLayer(): AbstractPhysicalLayer;
     constructor(physicalLayer: AbstractPhysicalLayer, socket: Socket);
-    write(data: Buffer): Promise<void>;
-    destroy(): Promise<void>;
+    write(data: Buffer, cb?: (err?: Error | null) => void): void;
+    destroy(cb?: (err?: Error | null) => void): void;
 }

package/dist/src/layers/physical/tcp-server-physical-layer.d.ts

@@ -17,13 +17,12 @@ export declare class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _server;
     private _opts;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get server(): Server | null;
     constructor(options?: TcpServerPhysicalLayerOptions);
-    open(options?: ListenOptions): Promise<void>;
-    close(): Promise<void>;
+    open(options?: ListenOptions | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }

package/dist/src/layers/physical/udp-client-physical-layer.d.ts

@@ -5,14 +5,13 @@ export declare class UdpClientPhysicalConnection extends AbstractPhysicalConnect
     private _state;
     private _physicalLayer;
     private _socket;
-    private _destroyPromise;
-    private _resolveDestroy;
+    private _pendingDestroyCbs;
     private _cleanupFns;
     get state(): PhysicalConnectionState;
     get physicalLayer(): AbstractPhysicalLayer;
     constructor(physicalLayer: UdpClientPhysicalLayer, socket: Socket);
-    write(data: Buffer): Promise<void>;
-    destroy(): Promise<void>;
+    write(data: Buffer, cb?: (err?: Error | null) => void): void;
+    destroy(cb?: (err?: Error | null) => void): void;
 }
 export declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
     readonly TYPE: "UDP_CLIENT";
@@ -20,9 +19,8 @@ export declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _socket;
     private _socketOpts;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get socket(): Socket | null;
@@ -30,6 +28,6 @@ export declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
     open(remote?: {
         port?: number;
         address?: string;
-    }): Promise<void>;
-    close(): Promise<void>;
+    } | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }

package/dist/src/layers/physical/udp-server-physical-layer.d.ts

@@ -24,8 +24,8 @@ export declare class UdpServerPhysicalConnection extends AbstractPhysicalConnect
         add: (listener: (msg: Buffer, rinfo: RemoteInfo) => void) => void;
         remove: (listener: (...args: any[]) => void) => void;
     });
-    write(data: Buffer): Promise<void>;
-    destroy(): Promise<void>;
+    write(data: Buffer, cb?: (err?: Error | null) => void): void;
+    destroy(cb?: (err?: Error | null) => void): void;
 }
 export declare class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
     readonly TYPE: "UDP_SERVER";
@@ -33,9 +33,8 @@ export declare class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _socket;
     private _opts;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get socket(): Socket | null;
@@ -44,11 +43,8 @@ export declare class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
      * Bind the UDP socket and start accepting datagrams.
      *
      * @param options Bind options (port, address, etc.). Defaults to port 502.
-     * @param [idleTimeout=30000] Maximum idle time in milliseconds before an
-     * inactive client connection is evicted. Pass `0` to disable eviction
-     * (connections never time out). Disabling eviction may cause unbounded
-     * memory growth if the server sees many unique clients.
+     * @param cb Callback invoked when binding completes or fails.
      */
-    open(options?: BindOptions): Promise<void>;
-    close(): Promise<void>;
+    open(options?: BindOptions | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }

package/dist/src/master/master-session.d.ts

@@ -2,17 +2,17 @@ import type { ApplicationDataUnit } from '../types';
 type Frame = ApplicationDataUnit & {
     buffer: Buffer;
 };
-type PreCheck = (frame: Frame) => boolean | number | undefined;
 type Callback = (error: Error | null, frame?: Frame) => void;
 export declare const FIFO_KEY: "fifo";
 export declare class MasterSession {
     private _waiters;
-    start(key: string | number, preCheck: PreCheck[], callback: Callback): void;
+    /** Register a callback for `key`. No timer — timeout is managed by the caller. */
+    start(key: string | number, callback: Callback): void;
+    /** Cancel a pending waiter without firing its callback. */
     stop(key: string | number): void;
     stopAll(error: Error): void;
     has(key: string | number): boolean;
     handleFrame(frame: Frame): void;
     handleError(error: Error): void;
-    private runPreChecks;
 }
 export {};

package/dist/src/master/master.d.ts

@@ -39,7 +39,15 @@ export declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOp
     private _protocol;
     private _appLayer?;
     private _customFunctionCodes;
-    private _queue;
+    private _queueUnits;
+    private _queueFcs;
+    private _queueDatas;
+    private _queueTimeouts;
+    private _queueBroadcasts;
+    private _queueResolves;
+    private _queueRejects;
+    private _queueHead;
+    private _queueLen;
     private _draining;
     private _nextTid;
     private _cleanupFns;
@@ -50,6 +58,7 @@ export declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOp
     private _createAppLayer;
     private send;
     private _drain;
+    private _processNext;
     private _exchange;
     private writeFC1Or2;
     writeFC1: this['readCoils'];
@@ -108,7 +117,6 @@ export declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOp
     removeCustomFunctionCode(fc: number): void;
     sendCustomFC(unit: 0, fc: number, data: Buffer | number[], timeout?: number): Promise<void>;
     sendCustomFC(unit: number, fc: number, data: Buffer | number[], timeout?: number): Promise<Buffer>;
-    private _clean;
     /**
      * Open the underlying physical layer and begin accepting connections.
      *

package/dist/src/slave/slave.d.ts

@@ -92,6 +92,7 @@ export declare class ModbusSlave<T extends ModbusSlaveOptions = ModbusSlaveOptio
     private _intercept;
     private _withAddressLock;
     private _handleFC;
+    private _handleCustomFC;
     add(model: ModbusSlaveModel): void;
     remove(unit: number): void;
     addCustomFunctionCode(cfc: CustomFunctionCode): void;

package/dist/src/utils/callback.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare function drainCbs(cbs: (((err?: Error | null) => void) | undefined)[] | null, err?: Error | null): void;

package/dist/src/utils/crc.d.ts

@@ -1 +1 @@
-export declare function crc(data: Uint8Array, seed?: number): number;
+export declare function crc(data: Uint8Array, start?: number, end?: number): number;

package/dist/src/utils/index.d.ts

@@ -1,10 +1,11 @@
-export type { PredictResult } from './predictRtuFrameLength';
 export type { RtuProtocolOptions, ResolvedRtuTiming } from './rtu-timing';
+export { bitsToMs } from './bitsToMs';
+export { drainCbs } from './callback';
 export { checkRange } from './checkRange';
 export { crc } from './crc';
-export { bitsToMs } from './bitsToMs';
 export { isUint8 } from './isUint8';
 export { lrc } from './lrc';
-export { predictRtuFrameLength } from './predictRtuFrameLength';
+export { PREDICT_NEED_MORE, PREDICT_UNKNOWN, predictRtuFrameLength } from './predictRtuFrameLength';
+export { promisifyCb } from './promisify-cb';
 export { resolveRtuTiming } from './rtu-timing';
 export { isWhitelisted } from './whitelist';

package/dist/src/utils/predictRtuFrameLength.d.ts

@@ -1,20 +1,17 @@
-export type PredictResult = {
-    kind: 'length';
-    length: number;
-} | {
-    kind: 'need-more';
-} | {
-    kind: 'unknown';
-};
+/** Sentinel: caller needs to feed more bytes before length can be determined. */
+export declare const PREDICT_NEED_MORE = 0;
+/** Sentinel: function code is not in the standard tables. */
+export declare const PREDICT_UNKNOWN = -1;
 /**
  * Predict the total RTU frame length (PDU + 2-byte CRC) given the leading bytes.
  *
- * Returns a discriminated result so callers can distinguish:
- * - `{ kind: 'length' }`: function code is known and total frame length is determined.
- * - `{ kind: 'need-more' }`: function code is known, but more bytes are required
- *   (typically waiting on the byteCount byte).
- * - `{ kind: 'unknown' }`: function code is not in the standard tables — the
- *   framing layer must defer to a registered `CustomFunctionCode` or treat this
- *   as a framing error.
+ * 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.
  */
-export declare function predictRtuFrameLength(buffer: Buffer, isResponse: boolean): PredictResult;
+export declare function predictRtuFrameLength(buffer: Buffer, isResponse: boolean): number;

package/dist/src/utils/promisify-cb.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Convert a callback-style `(cb: (err?) => void) => void` call into a Promise.
+ */
+export declare function promisifyCb(fn: (cb: (err?: Error | null) => void) => void): Promise<void>;

package/dist/src/utils/rtu-timing.d.ts

@@ -1,29 +1,43 @@
+/**
+ * RTU timing parameter — accepts either:
+ * - a bare `number` in milliseconds (`0` to disable the timer entirely)
+ * - `{ unit: 'ms', value: N }` — explicit milliseconds (equivalent to bare `N`)
+ * - `{ unit: 'bit', value: N }` — bit-time approximation, derived from `baudRate`
+ *
+ * The bare-number form is the recommended default; the object form exists for
+ * specs that quote bit-time. Pass `0` (or `{ unit: 'ms', value: 0 }`) to disable
+ * the timer; either form short-circuits the baudRate-derived fallback.
+ */
+export type RtuTimingValue = number | {
+    unit: 'bit' | 'ms';
+    value: number;
+};
 /** User-facing RTU protocol options (supports both bit and ms units). */
 export interface RtuProtocolOptions {
     /**
      * Inter-frame silence (Modbus RTU t3.5).
+     *
+     * - `20` or `{ unit: 'ms', value: 20 }` — 20 ms
      * - `{ unit: 'bit', value: 38.5 }` — spec bit-time approximation (default when `baudRate` is provided)
-     * - `{ unit: 'ms', value: 20 }` — explicit milliseconds
+     * - `0` — disable t3.5 timing (immediate parse on every chunk; useful for
+     *   lossless transports such as RTU-over-TCP or PTY-based tests where the
+     *   wire's silence semantics do not apply)
      *
      * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 1.75 ms is used
      * regardless of the bit value.
      */
-    intervalBetweenFrames?: {
-        unit: 'bit' | 'ms';
-        value: number;
-    };
+    intervalBetweenFrames?: RtuTimingValue;
     /**
      * Inter-character timeout (Modbus RTU t1.5). Opt-in; **disabled** by default.
+     *
+     * - `1` or `{ unit: 'ms', value: 1 }` — 1 ms
      * - `{ unit: 'bit', value: 21 }` — bit-time approximation (~1.5 char times)
-     * - `{ unit: 'ms', value: 1 }` — explicit milliseconds
+     * - `0` — disable explicitly
      *
      * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 0.75 ms is used
      * regardless of the bit value.
      */
-    interCharTimeout?: {
-        unit: 'bit' | 'ms';
-        value: number;
-    };
+    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
@@ -40,7 +54,7 @@ export interface ResolvedRtuTiming {
  * 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.
+ *   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

package/dist/src/vars.d.ts

@@ -35,6 +35,8 @@ export declare enum ConformityLevel {
     REGULAR = 130,
     EXTENDED = 131
 }
+/** Shared empty Buffer to avoid repeated allocations. */
+export declare const EMPTY_BUFFER: Buffer<ArrayBuffer>;
 /** Modbus V1.1b3 PDU quantity limits. */
 export declare const LIMITS: {
     readonly READ_COILS_MIN: 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "njs-modbus",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "A pure JavaScript implementation of Modbus for Node.js.",
   "keywords": [
     "modbus",
@@ -31,6 +31,8 @@
     "*.d.ts"
   ],
   "scripts": {
+    "benchmark": "tsx benchmark/encode-decode.ts && echo && tsx benchmark/tcp-throughput.ts && echo && tsx benchmark/concurrent.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"
@@ -50,7 +52,9 @@
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-import": "2.31.0",
     "eslint-plugin-prettier": "^5.4.1",
+    "jsmodbus": "^4.0.10",
     "microbundle": "^0.15.1",
+    "modbus-serial": "^8.0.25",
     "nx": "21.1.3",
     "prettier": "^3.5.3",
     "rollup": "^4.43.0",
@@ -66,5 +70,8 @@
   },
   "peerDependencies": {
     "serialport": ">=12.0.0"
+  },
+  "engines": {
+    "node": ">=18.19"
   }
 }