njs-modbus 1.5.0 → 2.0.0

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

@@ -9,5 +9,31 @@ export declare enum ErrorCode {
     GATEWAY_PATH_UNAVAILABLE = 10,
     GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11
 }
-export declare function getErrorByCode(code: ErrorCode): Error;
+/** Internal error codes for programmatic error handling. */
+export declare const ModbusErrorCode: {
+    readonly TIMEOUT: "ETIMEOUT";
+    readonly INVALID_RESPONSE: "EINVALID_RESPONSE";
+    readonly INSUFFICIENT_DATA: "EINSUFFICIENT_DATA";
+    readonly MASTER_CLOSED: "EMASTER_CLOSED";
+    readonly MASTER_DESTROYED: "EMASTER_DESTROYED";
+    readonly CONCURRENT_NOT_TCP: "ECONCURRENT_NOT_TCP";
+    readonly PORT_DESTROYED: "EPORT_DESTROYED";
+    readonly PORT_ALREADY_OPEN: "EPORT_ALREADY_OPEN";
+    readonly PORT_NOT_OPEN: "EPORT_NOT_OPEN";
+    readonly NOT_SUPPORTED: "ENOT_SUPPORTED";
+    readonly INVALID_DATA: "EINVALID_DATA";
+    readonly INVALID_HEX: "EINVALID_HEX";
+    readonly CRC_MISMATCH: "ECRC_MISMATCH";
+    readonly LRC_MISMATCH: "ELRC_MISMATCH";
+    readonly INCOMPLETE_FRAME: "EINCOMPLETE_FRAME";
+    readonly T1_5_EXCEEDED: "ET1_5_EXCEEDED";
+    readonly UNKNOWN_FC: "EUNKNOWN_FC";
+    readonly INVALID_ROLE: "EINVALID_ROLE";
+    readonly RANGE: "ERANGE";
+};
+export declare class ModbusError extends Error {
+    readonly code: string;
+    constructor(code: string, message?: string);
+}
+export declare function getErrorByCode(code: ErrorCode): ModbusError;
 export declare function getCodeByError(err: Error): ErrorCode;

package/dist/src/index.d.ts

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

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

@@ -1,17 +1,20 @@
-import type { ApplicationDataUnit } from '../../types';
+import type { ApplicationDataUnit, CustomFunctionCode } from '../../types';
+import type { PhysicalConnection } from '../physical';
 import EventEmitter from 'node:events';
 interface AbstractApplicationLayerEvents {
     framing: [frame: ApplicationDataUnit & {
         buffer: Buffer;
-    }, response: (data: Buffer) => Promise<void>];
+    }, response: (data: Buffer) => Promise<void>, connection: PhysicalConnection];
+    'framing-error': [error: Error];
 }
 export declare abstract class AbstractApplicationLayer extends EventEmitter<AbstractApplicationLayerEvents> {
-    abstract startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    abstract stopWaitingResponse(): void;
+    abstract readonly PROTOCOL: 'TCP' | 'RTU' | 'ASCII';
+    private _role?;
+    get role(): 'MASTER' | 'SLAVE';
+    set role(value: 'MASTER' | 'SLAVE');
+    flush(): void;
+    addCustomFunctionCode(cfc: CustomFunctionCode): void;
+    removeCustomFunctionCode(fc: number): void;
     abstract encode(data: ApplicationDataUnit): Buffer;
     abstract destroy(): void;
 }

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

@@ -2,19 +2,23 @@ import type { ApplicationDataUnit } from '../../types';
 import type { TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer } from '../physical';
 import type { SerialPhysicalLayer } 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 {
-    private _waitingResponse?;
-    private _status;
-    private _frame;
+    readonly PROTOCOL: "ASCII";
+    readonly lenientHex: boolean;
+    private _states;
     private _removeAllListeners;
-    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer);
+    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, options?: AsciiApplicationLayerOptions);
+    private getState;
+    flush(): void;
     private framing;
-    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    stopWaitingResponse(): void;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }

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

@@ -1,3 +1,5 @@
+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';

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

@@ -1,26 +1,60 @@
-import type { ApplicationDataUnit } from '../../types';
+import type { ApplicationDataUnit, CustomFunctionCode } from '../../types';
 import type { TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer } from '../physical';
 import type { SerialPhysicalLayer } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
-export declare class RtuApplicationLayer extends AbstractApplicationLayer {
-    private _waitingResponse?;
-    private _timerThreePointFive?;
-    private _bufferRx;
-    private _removeAllListeners;
-    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, 
+export interface RtuApplicationLayerOptions {
+    /**
+     * Inter-frame silence (Modbus RTU t3.5). Defaults to `{ unit: 'bit', value: 38.5 }`
+     * for serial (3.5 character times × 11 bits/char per Modbus V1.02 §2.5.1.1);
+     * ignored for TCP/UDP transports.
+     * - `{ unit: 'bit', value: 38.5 }` — spec bit-time approximation
+     * - `{ unit: 'ms', value: 20 }` — explicit milliseconds
+     *
+     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 the spec uses a fixed
+     * 1.75 ms regardless of the bit value supplied.
+     */
+    intervalBetweenFrames?: {
+        unit: 'bit' | 'ms';
+        value: number;
+    };
     /**
-     * The time interval between two frames, support two formats:
-     * - bit: `48bit` as default
-     * - millisecond: `20ms`
+     * Inter-character timeout (Modbus RTU t1.5). Opt-in; **disabled** by default
+     * because Node.js `setTimeout` precision (~1 ms minimum, ~15.6 ms on Windows)
+     * is too coarse to reliably honor t1.5 at common baud rates without
+     * false-positive frame discards. When set, a mid-frame gap exceeding this
+     * duration discards the in-progress buffer and emits `framing-error`.
+     * Only takes effect on serial transports.
+     *
+     * - `{ unit: 'bit', value: 21 }` — bit-time approximation (~1.5 char times)
+     * - `{ unit: 'ms', value: 1 }` — explicit milliseconds
+     *
+     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 the spec uses a fixed
+     * 0.75 ms regardless of the bit value supplied.
      */
-    intervalBetweenFrames?: `${number}bit` | `${number}ms`);
-    private framing;
-    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    stopWaitingResponse(): void;
+    interCharTimeout?: {
+        unit: 'bit' | 'ms';
+        value: number;
+    };
+}
+export declare class RtuApplicationLayer extends AbstractApplicationLayer {
+    readonly PROTOCOL: "RTU";
+    private _states;
+    private _customFunctionCodes;
+    private _removeAllListeners;
+    private _threePointFiveT;
+    private _onePointFiveT;
+    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, options?: RtuApplicationLayerOptions);
+    private getState;
+    private clearStateTimers;
+    private clearState;
+    flush(): void;
+    addCustomFunctionCode(cfc: CustomFunctionCode): void;
+    removeCustomFunctionCode(fc: number): void;
+    private flushBuffer;
+    private tryExtract;
+    private checkExpected;
+    private crcMatches;
+    private deliverFrame;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }

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

@@ -2,17 +2,13 @@ import type { ApplicationDataUnit } from '../../types';
 import type { TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
 export declare class TcpApplicationLayer extends AbstractApplicationLayer {
-    private _waitingResponse?;
+    readonly PROTOCOL: "TCP";
     private _transactionId;
+    private _buffers;
     private _removeAllListeners;
     constructor(physicalLayer: TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer);
-    private framing;
-    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    stopWaitingResponse(): void;
+    private tryExtract;
+    private processFrame;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }

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

@@ -1,8 +1,12 @@
 import EventEmitter from 'node:events';
+export interface PhysicalConnection {
+    readonly id: string | number;
+}
 interface AbstractPhysicalLayerEvents {
-    data: [data: Buffer, response: (data: Buffer) => Promise<void>];
+    data: [data: Buffer, response: (data: Buffer) => Promise<void>, connection: PhysicalConnection];
     write: [data: Buffer];
     error: [error: Error];
+    'connection-close': [connection: PhysicalConnection];
     close: [];
 }
 export declare abstract class AbstractPhysicalLayer extends EventEmitter<AbstractPhysicalLayerEvents> {

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

@@ -1,3 +1,4 @@
+export type { PhysicalConnection } from './abstract-physical-layer';
 export { AbstractPhysicalLayer } from './abstract-physical-layer';
 export { SerialPhysicalLayer } from './serial-physical-layer';
 export { TcpClientPhysicalLayer } from './tcp-client-physical-layer';

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

@@ -27,6 +27,8 @@ export interface SerialPhysicalLayerOptions {
 export declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _serialport;
+    private _connection;
+    private _isOpening;
     private _destroyed;
     private _baudRate;
     get isOpen(): boolean;

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

@@ -3,8 +3,11 @@ import { AbstractPhysicalLayer } from './abstract-physical-layer';
 export declare class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _socket;
+    private _connection;
     private _isOpen;
+    private _isOpening;
     private _destroyed;
+    private _socketOptions?;
     get isOpen(): boolean;
     get destroyed(): boolean;
     constructor(options?: SocketConstructorOpts);

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

@@ -4,8 +4,10 @@ export declare class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _server;
     private _isOpen;
+    private _isOpening;
     private _destroyed;
-    private _sockets;
+    private _connections;
+    private _serverOptions?;
     get isOpen(): boolean;
     get destroyed(): boolean;
     constructor(options?: NetConnectOpts);

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

@@ -1,26 +1,41 @@
 import type { BindOptions, SocketOptions } from 'node:dgram';
 import { AbstractPhysicalLayer } from './abstract-physical-layer';
+export interface UdpPhysicalLayerOptions {
+    /** dgram Socket creation options. */
+    socket?: Partial<SocketOptions>;
+    /**
+     * Provided → client mode (send to this single remote, filter inbound).
+     * Omitted → server mode (bind locally, accept from any rinfo).
+     */
+    remote?: {
+        port?: number;
+        address?: string;
+    };
+    /**
+     * Server mode only. Each unique rinfo (`address:port`) gets its own
+     * `PhysicalConnection`; if no datagram arrives within this many ms, the
+     * connection is evicted (`connection-close` emitted, upper-layer framing
+     * state released). Default 30000. Set 0 to disable eviction.
+     */
+    idleTimeout?: number;
+}
 export declare class UdpPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _socket;
+    private _connections;
     private _isOpen;
+    private _isOpening;
     private _destroyed;
+    private _socketOptions?;
     private _port;
     private _address?;
+    private _idleTimeout;
     isServer: boolean;
     get isOpen(): boolean;
     get destroyed(): boolean;
-    /**
-     *
-     * @param options
-     * @param remote If omitted, as server.
-     * Otherwise as client.
-     */
-    constructor(options?: Partial<SocketOptions>, remote?: {
-        port?: number;
-        address?: string;
-    });
+    constructor(options?: UdpPhysicalLayerOptions);
     open(options?: BindOptions): Promise<void>;
+    private _handleMessage;
     write(data: Buffer): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;

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

@@ -1 +1,3 @@
+export type { ModbusMasterOptions } from './master';
+export { MasterSession } from './master-session';
 export { ModbusMaster } from './master';

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

@@ -0,0 +1,18 @@
+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;
+    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

@@ -1,6 +1,6 @@
 import type { AbstractApplicationLayer } from '../layers/application';
 import type { AbstractPhysicalLayer } from '../layers/physical';
-import type { DeviceIdentification, ServerId } from '../types';
+import type { CustomFunctionCode, DeviceIdentification, ServerId } from '../types';
 import EventEmitter from 'node:events';
 interface ModbusMasterEvents {
     error: [error: Error];
@@ -13,14 +13,32 @@ interface ReturnValue<T> {
     data: T;
     buffer: Buffer;
 }
+export interface ModbusMasterOptions {
+    /** Per-request timeout in ms. Default 1000. */
+    timeout?: number;
+    /**
+     * Enable pipelined concurrent requests on a single connection.
+     * Only valid for Modbus TCP application layer.
+     * Default false (FIFO queue, requests are serialized).
+     */
+    concurrent?: boolean;
+}
 export declare class ModbusMaster<A extends AbstractApplicationLayer, P extends AbstractPhysicalLayer> extends EventEmitter<ModbusMasterEvents> {
     private applicationLayer;
     private physicalLayer;
+    private _masterSession;
+    private _queue;
+    private _draining;
+    private _nextTid;
+    private _closed;
     timeout: number;
+    readonly concurrent: boolean;
     get isOpen(): boolean;
     get destroyed(): boolean;
-    constructor(applicationLayer: A, physicalLayer: P, timeout?: number);
-    private waitResponse;
+    constructor(applicationLayer: A, physicalLayer: P, options?: ModbusMasterOptions);
+    private send;
+    private _drain;
+    private _exchange;
     private writeFC1Or2;
     writeFC1: this['readCoils'];
     readCoils(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
@@ -48,8 +66,8 @@ export declare class ModbusMaster<A extends AbstractApplicationLayer, P extends
     writeMultipleRegisters(unit: 0, address: number, value: number[], timeout?: number): Promise<void>;
     writeMultipleRegisters(unit: number, address: number, value: number[], timeout?: number): Promise<ReturnValue<number[]>>;
     handleFC17: this['reportServerId'];
-    reportServerId(unit: 0, timeout?: number): Promise<void>;
-    reportServerId(unit: number, timeout?: number): Promise<ReturnValue<ServerId>>;
+    reportServerId(unit: 0, serverIdLength?: number, timeout?: number): Promise<void>;
+    reportServerId(unit: number, serverIdLength?: number, timeout?: number): Promise<ReturnValue<ServerId>>;
     handleFC22: this['maskWriteRegister'];
     maskWriteRegister(unit: 0, address: number, andMask: number, orMask: number, timeout?: number): Promise<void>;
     maskWriteRegister(unit: number, address: number, andMask: number, orMask: number, timeout?: number): Promise<ReturnValue<{
@@ -74,6 +92,10 @@ export declare class ModbusMaster<A extends AbstractApplicationLayer, P extends
     handleFC43_14: this['readDeviceIdentification'];
     readDeviceIdentification(unit: 0, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<void>;
     readDeviceIdentification(unit: number, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<ReturnValue<DeviceIdentification>>;
+    addCustomFunctionCode(cfc: CustomFunctionCode): void;
+    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>;
     open(...args: Parameters<P['open']>): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;

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

@@ -1,2 +1,2 @@
-export type { ModbusSlaveModel } from './slave';
+export type { ModbusSlaveModel, ModbusSlaveOptions } from './slave';
 export { ModbusSlave } from './slave';

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

@@ -1,6 +1,6 @@
 import type { AbstractApplicationLayer } from '../layers/application';
 import type { AbstractPhysicalLayer } from '../layers/physical';
-import type { FConvertPromise, ServerId } from '../types';
+import type { CustomFunctionCode, FConvertPromise, ServerId } from '../types';
 import EventEmitter from 'node:events';
 export interface ModbusSlaveModel {
     unit?: number;
@@ -10,7 +10,7 @@ export interface ModbusSlaveModel {
      * If provide the return value, use this value as data of `PDU` to respond.
      * Otherwise keep the default read and write behavior.
      */
-    interceptor?: FConvertPromise<(fc: number, data: number[]) => number[] | undefined>;
+    interceptor?: FConvertPromise<(fc: number, data: Buffer) => Buffer | undefined>;
     readDiscreteInputs?: FConvertPromise<(address: number, length: number) => boolean[]>;
     readCoils?: FConvertPromise<(address: number, length: number) => boolean[]>;
     writeSingleCoil?: FConvertPromise<(address: number, value: boolean) => void>;
@@ -44,15 +44,25 @@ interface ModbusSlaveEvents {
     error: [error: Error];
     close: [];
 }
+export interface ModbusSlaveOptions {
+    /**
+     * Pipelined concurrent processing of requests within one connection.
+     * Only valid for Modbus TCP application layer (TID disambiguates responses).
+     * Default false — per-connection FIFO. RTU/ASCII + concurrent=true throws.
+     */
+    concurrent?: boolean;
+}
 export declare class ModbusSlave<A extends AbstractApplicationLayer, P extends AbstractPhysicalLayer> extends EventEmitter<ModbusSlaveEvents> {
     private applicationLayer;
     private physicalLayer;
     models: Map<number, ModbusSlaveModel>;
-    private _processing;
-    private _queue;
+    readonly concurrent: boolean;
+    private _queues;
+    private _customFunctionCodes;
+    private _locks;
     get isOpen(): boolean;
     get destroyed(): boolean;
-    constructor(applicationLayer: A, physicalLayer: P);
+    constructor(applicationLayer: A, physicalLayer: P, options?: ModbusSlaveOptions);
     private handleFC1;
     private handleFC2;
     private handleFC3;
@@ -69,9 +79,12 @@ export declare class ModbusSlave<A extends AbstractApplicationLayer, P extends A
     private _drain;
     private _processFrame;
     private _intercept;
+    private withAddressLock;
     private _handleFC;
     add(model: ModbusSlaveModel): void;
     remove(unit: number): void;
+    addCustomFunctionCode(cfc: CustomFunctionCode): void;
+    removeCustomFunctionCode(fc: number): void;
     open(...args: Parameters<P['open']>): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;

package/dist/src/types.d.ts

@@ -4,10 +4,11 @@ export interface ApplicationDataUnit {
     transaction?: number;
     unit: number;
     fc: number;
-    data: number[];
+    data: Buffer;
 }
 export interface ServerId {
-    serverId?: number;
+    /** Server ID; may be 1 byte (number) or multi-byte (number[]) per device spec. */
+    serverId?: number | number[];
     runIndicatorStatus?: boolean;
     additionalData?: number[];
 }
@@ -21,3 +22,33 @@ export interface DeviceIdentification {
         value: string;
     }[];
 }
+/**
+ * Defines a non-standard / user-defined Modbus function code.
+ *
+ * Registration paths:
+ * - `RtuApplicationLayer.addCustomFunctionCode(cfc)` — framing only.
+ * - `ModbusSlave.addCustomFunctionCode(cfc)` — framing + slave-side dispatch via `handle`.
+ * - `ModbusMaster.addCustomFunctionCode(cfc)` + `ModbusMaster.sendCustomFC(...)` — framing + request issuance.
+ *
+ * The two `predict*` callbacks declare how to derive the total RTU frame length
+ * (PDU + 2-byte CRC) from leading bytes; they are required so the framing FSM
+ * can advance without the deleted sliding-window CRC fallback.
+ *
+ * Return `null` from a predictor to signal "need more bytes before I can decide".
+ * Return a positive integer (>= 4, <= 256) for the total frame length.
+ */
+export interface CustomFunctionCode {
+    fc: number;
+    /** Predict total RTU frame length for an incoming request (slave-side framing). */
+    predictRequestLength: (buffer: Buffer) => number | null;
+    /** Predict total RTU frame length for an incoming response (master-side framing). */
+    predictResponseLength: (buffer: Buffer) => number | null;
+    /**
+     * Slave-side handler. Receives PDU payload (bytes after `fc`, before CRC) and
+     * the unit ID being addressed; must return the PDU payload of the response.
+     *
+     * Throwing inside `handle` is turned into a Modbus exception response by the slave.
+     * If `handle` is omitted, the slave returns an ILLEGAL_FUNCTION exception for this FC.
+     */
+    handle?: FConvertPromise<(data: Buffer, unit: number) => Buffer>;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ */
+export declare function bitsToMs(baudRate: number, bits: number): number;

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

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

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

@@ -0,0 +1,2 @@
+/** Cross-process unique id: `${prefix}-${uuid-v4}`. */
+export declare function genConnectionId(prefix: string): string;

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

@@ -1,4 +1,8 @@
 export { checkRange } from './checkRange';
 export { crc } from './crc';
-export { getThreePointFiveT } from './getThreePointFiveT';
+export { genConnectionId } from './genConnectionId';
+export { bitsToMs } from './bitsToMs';
+export { isUint8 } from './isUint8';
 export { lrc } from './lrc';
+export { predictRtuFrameLength } from './predictRtuFrameLength';
+export type { PredictResult } from './predictRtuFrameLength';

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

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare function isUint8(n: number): boolean;

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

@@ -0,0 +1,20 @@
+export type PredictResult = {
+    kind: 'length';
+    length: number;
+} | {
+    kind: 'need-more';
+} | {
+    kind: 'unknown';
+};
+/**
+ * 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.
+ */
+export declare function predictRtuFrameLength(buffer: Buffer, isResponse: boolean): PredictResult;

package/dist/src/vars.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Standard Modbus function codes (V1.1b3 §6).
+ */
+export declare enum FunctionCode {
+    READ_COILS = 1,
+    READ_DISCRETE_INPUTS = 2,
+    READ_HOLDING_REGISTERS = 3,
+    READ_INPUT_REGISTERS = 4,
+    WRITE_SINGLE_COIL = 5,
+    WRITE_SINGLE_REGISTER = 6,
+    WRITE_MULTIPLE_COILS = 15,
+    WRITE_MULTIPLE_REGISTERS = 16,
+    REPORT_SERVER_ID = 17,
+    MASK_WRITE_REGISTER = 22,
+    READ_WRITE_MULTIPLE_REGISTERS = 23,
+    READ_DEVICE_IDENTIFICATION = 43
+}
+/** Exception response FC = request FC | EXCEPTION_OFFSET (V1.1b3 §7). */
+export declare const EXCEPTION_OFFSET = 128;
+/** Coil value encoding for FC 5 / FC 15 (V1.1b3 §6.5/§6.11). */
+export declare const COIL_ON = 65280;
+export declare const COIL_OFF = 0;
+/** FC 0x2B MEI sub-function selecting Read Device Identification (V1.1b3 §6.21). */
+export declare const MEI_READ_DEVICE_ID = 14;
+/** Read Device ID code values inside an FC 0x2B / MEI 0x0E request. */
+export declare enum ReadDeviceIDCode {
+    BASIC_STREAM = 1,
+    REGULAR_STREAM = 2,
+    EXTENDED_STREAM = 3,
+    SPECIFIC_ACCESS = 4
+}
+/** Conformity level reported in an FC 0x2B / MEI 0x0E response. */
+export declare enum ConformityLevel {
+    BASIC = 129,
+    REGULAR = 130,
+    EXTENDED = 131
+}
+/** Modbus V1.1b3 PDU quantity limits. */
+export declare const LIMITS: {
+    readonly READ_COILS_MIN: 1;
+    readonly READ_COILS_MAX: 2000;
+    readonly READ_REGISTERS_MIN: 1;
+    readonly READ_REGISTERS_MAX: 125;
+    readonly WRITE_COILS_MAX: 1968;
+    readonly WRITE_REGISTERS_MAX: 123;
+    readonly RW_REGISTERS_WRITE_MAX: 121;
+};

package/dist/test/adu-buffer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/ascii-hex-sentry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/ascii-hex-validation.test.d.ts

@@ -0,0 +1 @@
+export {};