njs-modbus 3.3.0 → 4.0.0

package/dist/index.d.cts

@@ -0,0 +1,2862 @@
+import EventEmitter from "node:events";
+import { SerialPort } from "serialport";
+import { ListenOptions, Server, ServerOpts, Socket, SocketConnectOpts, SocketConstructorOpts } from "node:net";
+import { CommonConnectionOptions, ConnectionOptions, SecureContextOptions, Server as Server$1, TLSSocket, TlsOptions } from "node:tls";
+import { BindOptions, RemoteInfo, Socket as Socket$1, SocketOptions } from "node:dgram";
+
+//#region src/error-code.d.ts
+/**
+ * Modbus protocol exception codes (V1.1b3 §7).
+ *
+ * The wire-byte appears immediately after a function code with the exception
+ * bit (0x80) set. Values are sparse on purpose — 0x00, 0x07, 0x09 and gaps
+ * above 0x0B are reserved by the spec and must not be used by custom slaves.
+ */
+declare enum ErrorCode {
+  /** Function code received in the request is not supported. */
+  ILLEGAL_FUNCTION = 1,
+  /** Data address in the request is not allowed on this slave. */
+  ILLEGAL_DATA_ADDRESS = 2,
+  /** Value in the request data field is not allowed for this function. */
+  ILLEGAL_DATA_VALUE = 3,
+  /** An unrecoverable error occurred while the slave was processing the request. */
+  SERVER_DEVICE_FAILURE = 4,
+  /** Slave has accepted the request and is processing it, but this will take time. */
+  ACKNOWLEDGE = 5,
+  /** Slave is engaged in processing a long-duration program command. */
+  SERVER_DEVICE_BUSY = 6,
+  /** Slave parity error in memory or associated device. */
+  MEMORY_PARITY_ERROR = 8,
+  /** Gateway could not allocate an internal communication path to the target device. */
+  GATEWAY_PATH_UNAVAILABLE = 10,
+  /** No response was received from the target device behind the gateway. */
+  GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11
+}
+/**
+ * Strongly-typed `Error` subclass that carries a Modbus exception code.
+ *
+ * Throwing this from a slave handler causes the slave dispatcher to encode
+ * the exception response (FC | 0x80 followed by `code`); throwing it from a
+ * master callback path surfaces the slave's reported exception to user code.
+ *
+ * The `name` property is fixed to `'ModbusError'` so {@link getCodeByError}
+ * can reliably identify it across realm / V8 isolate boundaries without
+ * relying on `instanceof`.
+ */
+declare class ModbusError extends Error {
+  readonly code: ErrorCode;
+  /**
+   * @param code Modbus exception code carried on the wire.
+   * @param message Human-readable description; defaults to the spec-defined
+   *   English label for `code`.
+   */
+  constructor(code: ErrorCode, message?: string);
+}
+/**
+ * Construct a {@link ModbusError} from a wire-level exception code.
+ *
+ * @param code Modbus exception code byte (0x01..0x0B per V1.1b3 §7).
+ * @returns Newly allocated `ModbusError` with the spec-defined message.
+ */
+declare function getErrorByCode(code: ErrorCode): ModbusError;
+/**
+ * Map an arbitrary `Error` back to a Modbus exception code for transport on
+ * the wire. Used by the slave dispatch path when a user handler throws.
+ *
+ * Recognises `ModbusError` instances by `name === 'ModbusError'` and a valid
+ * `code`; everything else is normalized to `SERVER_DEVICE_FAILURE` (0x04),
+ * the spec-defined catch-all for internal slave failures.
+ *
+ * @param err Error thrown by user code (or surfaced by the runtime).
+ * @returns A wire-encodable {@link ErrorCode}; never throws.
+ */
+declare function getCodeByError(err: Error): ErrorCode;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Modbus Application Data Unit (ADU) — the protocol-agnostic, transport-stripped
+ * representation passed between the application layer and the master/slave
+ * orchestrators.
+ *
+ * Concretely the framing layers strip away their transport header / trailer
+ * (MBAP for TCP, address + CRC for RTU, `:` / `\r\n` + LRC for ASCII) and
+ * emit a normalized ADU; the inverse path encodes the ADU back onto the wire.
+ */
+interface ApplicationDataUnit {
+  /**
+   * MBAP transaction identifier (TCP only). Set on TCP, undefined on RTU/ASCII.
+   * 16-bit unsigned, big-endian on the wire (per Modbus Messaging on TCP/IP §3.1).
+   */
+  transaction?: number;
+  /**
+   * Unit / slave address byte (0..247 per spec; 0 = broadcast, 248..255 reserved).
+   */
+  unit: number;
+  /**
+   * Modbus function code (1 byte, 0..255; bit 0x80 reserved for exceptions).
+   */
+  fc: number;
+  /**
+   * PDU payload — bytes after the function code and before the transport
+   * checksum (i.e. neither CRC16 nor LRC nor MBAP header is included here).
+   */
+  data: Buffer;
+}
+/**
+ * A parsed Modbus frame as emitted by the framing layer.
+ *
+ * Extends {@link ApplicationDataUnit} with the raw, on-wire buffer that
+ * produced it. The raw buffer is useful for audit logging, replay, and
+ * diagnostic events.
+ */
+type ModbusFrame = ApplicationDataUnit & {
+  buffer: Buffer;
+};
+/**
+ * Slave-side configuration block used to answer FC 17 (`REPORT_SERVER_ID`).
+ *
+ * Bytes are emitted in the order: `serverId` array → `runIndicatorStatus`
+ * (0x00 OFF / 0xFF ON) → `additionalData`.
+ */
+interface ServerId {
+  /**
+   * Server ID as a byte array (e.g. single-byte IDs use `[id]`).
+   */
+  serverId?: Uint8Array;
+  /**
+   * Run-indicator status; encoded as 0xFF (ON) or 0x00 (OFF) on the wire.
+   */
+  runIndicatorStatus?: boolean;
+  /**
+   * Additional data bytes. Using Buffer avoids intermediate array conversions.
+   */
+  additionalData?: Buffer;
+}
+/**
+ * Slave-side configuration block used to answer FC 43 / MEI 14
+ * (`READ_DEVICE_IDENTIFICATION`, V1.1b3 §6.21).
+ *
+ * Each entry in `objects` represents a TLV (id, length-prefixed string) tuple
+ * on the wire; the framing layer fragments the response when the cumulative
+ * payload would exceed the 253-byte PDU limit and toggles `moreFollows`
+ * accordingly.
+ */
+interface DeviceIdentification {
+  /**
+   * Echoed Read Device ID code (1..4); see `ReadDeviceIDCode`.
+   */
+  readDeviceIDCode: number;
+  /**
+   * Conformity level reported back to the master (0x81/0x82/0x83).
+   */
+  conformityLevel: number;
+  /**
+   * `true` when the response is fragmented and more objects follow.
+   */
+  moreFollows: boolean;
+  /**
+   * Next object id to query when `moreFollows` is set; 0 when terminated.
+   */
+  nextObjectId: number;
+  /**
+   * TLV objects to return; each `value` is encoded as ASCII bytes.
+   */
+  objects: {
+    id: number;
+    value: string;
+  }[];
+}
+/**
+ * Modbus ADU queue processing strategy.
+ *
+ * Controls pruning, deduplication, and scheduling behavior when new requests arrive.
+ */
+type ModbusQueueStrategy = /** Strict first-in-first-out, execute in queued order. */'fifo'
+/**
+ * Last-arrived overwrites; new requests clear all stale unexecuted items in
+ * the queue. This is the default used by {@link ModbusMaster} and
+ * {@link ModbusSlave} when no strategy is specified.
+ */
+| 'drop-stale' /** Smart deduplication based on ADU fingerprint. */ | 'deduplicate'
+/**
+ * Concurrent async dispatch (⚠️ Modbus TCP or multi-link Master only, use
+ * with caution on RTU bus).
+ */
+| 'concurrent';
+/**
+ * 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 `0` to signal "need more bytes before I can decide".
+ * Return `-1` to signal "cannot determine the length".
+ * Return a positive integer (>= 4, <= 256) for the total frame length.
+ */
+interface CustomFunctionCode {
+  /**
+   * Function code byte (0..255, excluding 0x80 exception bit).
+   */
+  fc: number;
+  /**
+   * Optional address-range extractor for access-control gating.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Function code byte.
+   * @param data PDU payload bytes (after the FC).
+   * @returns Address ranges touched by this request, keyed by table name.
+   *
+   * @example Declare that a custom FC touches holding registers 0..N-1.
+   * ```ts
+   * {
+   *   fc: 0x65,
+   *   requestAddressRange: (_unit, _fc, data) => ({
+   *     holdingRegisters: [[0, data.length - 1]],
+   *   }),
+   * }
+   * ```
+   */
+  requestAddressRange?: (unit: number, fc: number, data: Buffer) => { [P in 'discreteInputs' | 'coils' | 'inputRegisters' | 'holdingRegisters']?: [startAddress: number, endAddress: number][] };
+  /**
+   * Optional fingerprint extractor for deduplication queue strategy.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Function code byte.
+   * @param data PDU payload bytes (after the FC).
+   * @returns 32-bit unsigned fingerprint, or `null` to disable deduplication for this request.
+   */
+  requestFingerprint?: (unit: number, fc: number, data: Buffer) => number;
+}
+/**
+ * Optional access-control policy evaluated by the master before a request
+ * enters the queue and by the slave before a request is dispatched to a
+ * unit handler.
+ *
+ * Each hook may return synchronously or asynchronously:
+ * - `true` — allow the operation.
+ * - `false` — deny with {@link UnauthorizedAccessError}.
+ * - {@link ErrorCode} — deny and surface as a typed {@link ModbusError}.
+ *
+ * Omit a hook to disable that gate.
+ *
+ * @example Synchronous unit whitelist.
+ * ```ts
+ * { checkUnit: (unit) => unit === 1 }
+ * ```
+ *
+ * @example Asynchronous authorization against an external directory.
+ * ```ts
+ * {
+ *   checkUnit: async (unit) => {
+ *     const allowed = await policyService.isUnitAllowed(unit);
+ *     return allowed;
+ *   },
+ * }
+ * ```
+ *
+ * @example Returning a typed Modbus exception code.
+ * ```ts
+ * { checkRuntime: () => ErrorCode.SERVER_DEVICE_BUSY }
+ * ```
+ */
+interface AccessAuthorizer {
+  /**
+   * Authorize the target unit / slave address.
+   *
+   * @param unit Unit / slave address byte (0..247, inclusive).
+   * @returns `true`, `false`, or an {@link ErrorCode}.
+   */
+  checkUnit?: (unit: number) => ErrorCode | boolean | Promise<ErrorCode | boolean>;
+  /**
+   * Authorize the address range touched by the request.
+   *
+   * Only invoked for standard function codes and for custom function codes
+   * that declare {@link CustomFunctionCode.requestAddressRange}.
+   *
+   * @param unit Unit / slave address byte (0..247, inclusive).
+   * @param table Modbus table being accessed.
+   * @param addressRange Inclusive zero-based `[startAddress, endAddress]` pair.
+   * @returns `true`, `false`, or an {@link ErrorCode}.
+   */
+  checkAddress?: (unit: number, table: 'discreteInputs' | 'coils' | 'inputRegisters' | 'holdingRegisters', addressRange: [startAddress: number, endAddress: number]) => ErrorCode | boolean | Promise<ErrorCode | boolean>;
+  /**
+   * Last-chance runtime authorization evaluated immediately before wire I/O.
+   *
+   * On the master this runs after the queue drains; on the slave it runs
+   * after the unit handler produces a successful response.
+   *
+   * @param unit Unit / slave address byte (0..247, inclusive).
+   * @param fc Function code byte (0..255).
+   * @param data PDU payload bytes (length 0..253).
+   * @returns `true`, `false`, or an {@link ErrorCode}.
+   */
+  checkRuntime?: (unit: number, fc: number, data: Buffer) => ErrorCode | boolean | Promise<ErrorCode | boolean>;
+}
+//#endregion
+//#region src/utils/adu-fingerprint.d.ts
+/**
+ * Compute a 32-bit MurmurHash3-x86 fingerprint over up to four single-byte
+ * header arguments concatenated with an optional binary buffer.
+ *
+ * Used as the canonical hashing primitive for `aduFingerprint` — the
+ * deduplication queue strategy keys on this value, so the algorithm must be
+ * stable across releases (any change here invalidates in-flight queue state
+ * for callers running a mixed-version cluster).
+ *
+ * The four header bytes are packed little-endian into the same 32-bit word
+ * as the buffer payload, so e.g. `(unit, fc, length-byte)` with no buffer
+ * produces the exact same hash as a 3-byte buffer with no header.
+ *
+ * @param buffer Trailing binary payload, or `null` for header-only hashing.
+ * @param n1 Optional 1st header byte (low 8 bits used; rest discarded).
+ * @param n2 Optional 2nd header byte.
+ * @param n3 Optional 3rd header byte.
+ * @param n4 Optional 4th header byte.
+ * @returns 32-bit unsigned hash in `[0, 0xFFFFFFFF]`.
+ *
+ * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+ */
+declare function generateAduHashFingerprint(buffer: Buffer | null, n1?: number, n2?: number, n3?: number, n4?: number): number;
+//#endregion
+//#region src/utils/ip-whitelist.d.ts
+/**
+ * A single whitelist entry: an exact IP string, an IPv4 CIDR string, or a
+ * custom predicate.
+ *
+ * String entries are canonicalized at construction time. Predicate functions
+ * receive the already-canonicalized remote address.
+ */
+type WhitelistEntry = string | ((address: string) => boolean);
+//#endregion
+//#region src/utils/compact-event.d.ts
+/** Sentinel type used as the default event map for an untyped emitter. */
+type DefaultEventMap = [never];
+/**
+ * Event map contract: either a record of event names to argument tuples, or
+ * the {@link DefaultEventMap} sentinel for untyped emitters.
+ *
+ * @template T The emitter's event map type.
+ */
+type EventMap<T> = Record<keyof T, any[]> | DefaultEventMap;
+/**
+ * Valid event key type for a given event map.
+ *
+ * @template K Candidate key from the typed map.
+ * @template T The emitter's event map type.
+ */
+type Key<K, T> = T extends DefaultEventMap ? string | symbol : K | keyof T;
+/** Shorthand for an arbitrary argument list. */
+type AnyRest = [...args: any[]];
+/**
+ * Argument tuple for a specific event key.
+ *
+ * @template K Candidate key from the typed map.
+ * @template T The emitter's event map type.
+ */
+type Args<K, T> = T extends DefaultEventMap ? AnyRest : K extends keyof T ? T[K] : never;
+/**
+ * Listener signature for a specific event key and fallback shape.
+ *
+ * @template K Candidate key from the typed map.
+ * @template T The emitter's event map type.
+ * @template F Fallback listener signature when the map is untyped.
+ */
+type Listener<K, T, F> = T extends DefaultEventMap ? F : K extends keyof T ? T[K] extends unknown[] ? (...args: T[K]) => void : never : never;
+/**
+ * Listener signature with a generic fallback, used by {@link CompactEventEmitter.on}.
+ *
+ * @template K Candidate key from the typed map.
+ * @template T The emitter's event map type.
+ */
+type Listener1<K, T> = Listener<K, T, (...args: any[]) => void>;
+/**
+ * A tiny, zero-dependency event emitter optimized for typed, internal use.
+ *
+ * Supports the same `on`/`once`/`off`/`emit` surface as Node's
+ * `EventEmitter`, but stores listeners in a flat object keyed by event name
+ * and unrolls the emit loop for up to five arguments to avoid rest-array
+ * allocation on common call patterns.
+ *
+ * @template T Typed event map. Use the default `DefaultEventMap` for an
+ *   untyped emitter that accepts any string/symbol event.
+ */
+declare class CompactEventEmitter<T extends EventMap<T> = DefaultEventMap> {
+  /** Alias for {@link on}. */
+  addListener: this['on'];
+  /** Alias for {@link off}. */
+  removeListener: this['off'];
+  private _registry;
+  constructor();
+  /**
+   * Register a listener for `eventName`.
+   *
+   * @template K Candidate event key inferred from the typed map.
+   * @param eventName Event name to subscribe to.
+   * @param listener Callback invoked when the event fires.
+   * @returns `this` for chaining.
+   */
+  on<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+  /**
+   * Register a one-time listener for `eventName`.
+   *
+   * The listener is removed automatically before it is invoked.
+   *
+   * @template K Candidate event key inferred from the typed map.
+   * @param eventName Event name to subscribe to.
+   * @param listener Callback invoked when the event fires.
+   * @returns `this` for chaining.
+   */
+  once<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+  /**
+   * Remove a previously registered listener for `eventName`.
+   *
+   * @template K Candidate event key inferred from the typed map.
+   * @param eventName Event name to unsubscribe from.
+   * @param listener Listener reference to remove.
+   * @returns `this` for chaining.
+   */
+  off<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+  /**
+   * Remove all listeners for a specific event, or for all events.
+   *
+   * @template K Candidate event key inferred from the typed map.
+   * @param event Optional event name. When omitted, every listener is cleared.
+   * @returns `this` for chaining.
+   */
+  removeAllListeners(event?: Key<unknown, T>): this;
+  /**
+   * Synchronously invoke all listeners for `eventName`.
+   *
+   * @template K Candidate event key inferred from the typed map.
+   * @param eventName Event name to emit.
+   * @param args Arguments passed to each listener.
+   * @returns `true` if listeners were registered, `false` otherwise.
+   */
+  protected emit<K>(eventName: Key<K, T>, ...args: Args<K, T>): boolean;
+  /**
+   * Emit a single-argument event, but only compute the payload if listeners
+   * are registered.
+   *
+   * @template K Candidate event key inferred from the typed map.
+   * @param eventName Event name to emit.
+   * @param payloadFactory Factory called once when at least one listener exists.
+   * @returns `true` if listeners were registered, `false` otherwise.
+   */
+  protected emitLazy<K>(eventName: Key<K, T>, payloadFactory: () => Args<K, T>[0]): boolean;
+}
+//#endregion
+//#region src/utils/crc.d.ts
+/**
+ * Compute CRC-16 (Modbus) over a single contiguous byte range.
+ *
+ * The loop body is deliberately one statement — `crc = TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8)` —
+ * so V8 keeps `crc` in a register and emits a single 16-bit table load per
+ * byte.
+ *
+ * @param data Source bytes (any `Uint8Array`-compatible view, including `Buffer`).
+ * @param start Inclusive byte offset where the CRC computation starts.
+ * @param end Exclusive byte offset where the CRC computation stops.
+ * @returns 16-bit CRC value in `[0, 0xFFFF]`. Caller is responsible for
+ *   little-endian wire encoding (low byte first per Modbus RTU §2.5.1.2).
+ *
+ * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+ */
+declare function crcFixed(data: Uint8Array, start: number, end: number): number;
+//#endregion
+//#region src/utils/lrc.d.ts
+/**
+ * Compute Modbus ASCII LRC (Longitudinal Redundancy Check, V1.1b3 §2.5.2.2).
+ *
+ * Algorithm — sum all bytes in the range, take the two's complement of the
+ * low 8 bits, return as a single byte. Equivalent to the spec's
+ * `((-sum) & 0xff)` formulation.
+ *
+ * On the wire ASCII frames carry the LRC as two hex characters
+ * before the `\r\n` terminator — caller is responsible for hex encoding.
+ *
+ * @param data Source bytes (the binary-decoded PDU including unit + FC + payload).
+ * @param start Inclusive byte offset where the LRC computation starts.
+ * @param end Exclusive byte offset where the LRC computation stops.
+ * @returns 8-bit LRC value in `[0, 0xFF]`.
+ *
+ * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+ */
+declare function lrc(data: Uint8Array, start: number, end: number): number;
+//#endregion
+//#region src/vars.d.ts
+/**
+ * Standard Modbus function codes (V1.1b3 §6).
+ *
+ * Values are the wire-byte that follows the unit / MBAP header. Bit 0x80 is
+ * reserved as the exception flag (see `EXCEPTION_OFFSET`); function
+ * codes never overlap with the exception space.
+ */
+declare enum FunctionCode {
+  /** FC 1 — Read Coils. */
+  READ_COILS = 1,
+  /** FC 2 — Read Discrete Inputs. */
+  READ_DISCRETE_INPUTS = 2,
+  /** FC 3 — Read Holding Registers. */
+  READ_HOLDING_REGISTERS = 3,
+  /** FC 4 — Read Input Registers. */
+  READ_INPUT_REGISTERS = 4,
+  /** FC 5 — Write Single Coil. */
+  WRITE_SINGLE_COIL = 5,
+  /** FC 6 — Write Single Register. */
+  WRITE_SINGLE_REGISTER = 6,
+  /** FC 8 — Diagnostics. */
+  DIAGNOSTICS = 8,
+  /** FC 15 — Write Multiple Coils. */
+  WRITE_MULTIPLE_COILS = 15,
+  /** FC 16 — Write Multiple Registers. */
+  WRITE_MULTIPLE_REGISTERS = 16,
+  /** FC 17 — Report Server ID. */
+  REPORT_SERVER_ID = 17,
+  /** FC 22 — Mask Write Register. */
+  MASK_WRITE_REGISTER = 22,
+  /** FC 23 — Read/Write Multiple Registers. */
+  READ_WRITE_MULTIPLE_REGISTERS = 23,
+  /** FC 43 — Read Device Identification. */
+  READ_DEVICE_IDENTIFICATION = 43
+}
+/**
+ * Error thrown when an access-control hook denies a request.
+ *
+ * This is a normal `Error` subclass with a fixed `name` so callers can
+ * distinguish access denials from transport or protocol failures.
+ */
+declare class UnauthorizedAccessError extends Error {
+  /**
+   * @param message Human-readable denial reason.
+   */
+  constructor(message?: string);
+}
+//#endregion
+//#region src/layers/protocol/types.d.ts
+/**
+ * Discriminant for {@link FrameErrorEvent} describing why a frame was rejected by
+ * a protocol framing layer.
+ */
+type FrameErrorEventType = /** ASCII hex body contained a character outside `0..9` / `A..F` (or lowercase when strict). */'hex_character_invalid' /** ASCII LRC sum-of-bytes check did not match the trailing LRC byte. */ | 'lrc_check_failed' /** ASCII hex body exceeded the 512-character limit. */ | 'frame_too_long' /** ASCII hex body was shorter than the 6 characters required for unit + FC + LRC. */ | 'frame_length_insufficient' /** ASCII hex body had an odd character count or TCP MBAP length field was out of range. */ | 'frame_length_invalid' /** RTU t3.5 inter-frame silence expired before a complete frame was assembled. */ | 't3.5_timeout' /** RTU t1.5 inter-character timeout expired (emitted only when strict timing is enabled). */ | 't1.5_timeout' /** TCP MBAP protocol identifier was not `0x0000`. */ | 'protocol_id_invalid';
+/**
+ * Payload emitted with the `frameError` event when a protocol layer discards a
+ * malformed, incomplete, or out-of-spec frame.
+ */
+interface FrameErrorEvent {
+  /** Error classification; see {@link FrameErrorEventType}. */
+  type: FrameErrorEventType;
+  /**
+   * Human-readable description of the failure; sufficient to diagnose the
+   * problem without reading {@link raw}.
+   */
+  message: string;
+  /**
+   * The raw, unprocessable bytes that caused the failure.
+   * This is a snapshot of the bad frame data and is safe to inspect or log.
+   * Its length is capped at the protocol-specific maximum frame length.
+   */
+  raw: Buffer;
+  /** TCP MBAP transaction identifier (big-endian, 16-bit), when available. */
+  transaction?: number;
+  /** Modbus function code byte (0..255), extracted from the frame when available. */
+  fc?: number;
+}
+//#endregion
+//#region src/layers/protocol/abstract-protocol-layer.d.ts
+/**
+ * Base class for all Modbus protocol framing layers.
+ *
+ * Concrete implementations (TCP, RTU, ASCII) own the wire-specific bytes that
+ * wrap the protocol-agnostic {@link ApplicationDataUnit}: MBAP headers, CRC16
+ * trailers, LRC sums, `:` / `\r\n` delimiters, and timing-driven frame boundaries.
+ *
+ * The layer exposes typed callbacks (`onFrame`, `onFrameError`) for eager
+ * delivery, plus lazy variants (`onFrameLazy`, `onFrameErrorLazy`) for
+ * consumers that only need the payload when an observer is actually attached.
+ * It also owns a registry for non-standard function codes so that RTU framing
+ * can predict custom frame lengths without allocating intermediate buffers.
+ *
+ * @abstract
+ */
+declare abstract class AbstractProtocolLayer {
+  /**
+   * Wire protocol identifier implemented by this layer.
+   * Set as a `const` literal so downstream type narrowing can distinguish
+   * TCP / RTU / ASCII paths without runtime inspection.
+   */
+  abstract readonly PROTOCOL: 'TCP' | 'RTU' | 'ASCII';
+  /**
+   * Role of the owning stack.
+   * - `MASTER` — initiates requests and decodes responses.
+   * - `SLAVE` — listens for requests and encodes responses.
+   */
+  abstract ROLE: 'MASTER' | 'SLAVE';
+  /** Callback invoked when a complete, valid frame is decoded. Receives the frame eagerly. */
+  onFrame?: (frame: ModbusFrame) => void;
+  /** Callback invoked when a complete, valid frame is decoded. Receives a lazy producer. */
+  onFrameLazy?: (lazy: () => ModbusFrame) => void;
+  /** Callback invoked when a malformed or incomplete frame is discarded. Receives the event eagerly. */
+  onFrameError?: (event: FrameErrorEvent) => void;
+  /** Callback invoked when a malformed or incomplete frame is discarded. Receives a lazy producer. */
+  onFrameErrorLazy?: (lazy: () => FrameErrorEvent) => void;
+  /**
+   * Registry of custom function codes for variable-length frame prediction.
+   *
+   * Indexed by function-code byte (`0..255`); empty slots are `undefined`.
+   * Concrete layers (especially RTU) use this array to decide how many bytes to
+   * expect before declaring a frame complete.
+   */
+  customFunctionCodes: (CustomFunctionCode | undefined)[];
+  /**
+   * Register a custom function code for framing-level length prediction.
+   *
+   * @param cfc Custom function code descriptor.
+   * @returns `void`.
+   * @throws When `cfc.fc` is not an integer in `0..255`.
+   */
+  addCustomFunctionCode(cfc: CustomFunctionCode): void;
+  /**
+   * Remove a previously registered custom function code.
+   *
+   * @param fc Function code byte (0..255) to deregister.
+   * @returns `void`.
+   */
+  removeCustomFunctionCode(fc: number): void;
+  /**
+   * Reset any internal framing state (residual bytes, timers, FSM state).
+   * Safe to call when the transport signals a disconnect or when re-syncing.
+   *
+   * @returns `void`.
+   */
+  flush(): void;
+  /**
+   * Decode incoming wire bytes and invoke `onFrame` / `onFrameError` callbacks,
+   * falling back to `onFrameLazy` / `onFrameErrorLazy` when the eager variants are
+   * not registered.
+   *
+   * Implementations may retain unprocessed trailing bytes internally to handle
+   * fragmented or coalesced network chunks.
+   *
+   * @param data Raw bytes received from the transport. Must not be modified.
+   * @returns `void`.
+   */
+  abstract decode(data: Buffer): void;
+  /**
+   * Encode a protocol-agnostic ADU into wire bytes.
+   *
+   * @param unit Unit / slave address byte (0..247 per spec).
+   * @param fc Modbus function code byte (0..255, bit 0x80 reserved for exceptions).
+   * @param data PDU payload bytes (everything after the function code, before the checksum).
+   * @param transaction TCP MBAP transaction identifier (16-bit unsigned, big-endian
+   *   on the wire). Ignored by RTU/ASCII; for TCP masters, omitting auto-increments.
+   * @returns The fully framed wire buffer, ready for the transport layer.
+   * @throws When the payload exceeds the protocol-specific maximum PDU length.
+   */
+  abstract encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
+}
+//#endregion
+//#region src/layers/protocol/ascii-protocol-layer.d.ts
+/** User-facing ASCII protocol options. */
+interface AsciiProtocolLayerOptions {
+  /**
+   * Allow lowercase hex digits (`a..f`) in incoming frames.
+   * The Modbus ASCII spec requires uppercase only; enable lenience only when
+   * interoperating with non-compliant peers.
+   * @default false
+   */
+  lenientHex?: boolean;
+}
+/**
+ * Modbus ASCII protocol framing layer.
+ *
+ * Frames begin with a colon (`:`), carry two hex characters per byte, and end
+ * with `\r\n`. An LRC sum-of-bytes checksum immediately precedes the CRLF. The
+ * layer parses frames from arbitrary byte chunks using a small FSM and supports
+ * strict uppercase hex or lenient lowercase hex.
+ */
+declare class AsciiProtocolLayer extends AbstractProtocolLayer {
+  /** Always `'ASCII'` for this implementation. */
+  readonly PROTOCOL: 'ASCII';
+  /** Role of the owning stack — `'MASTER'` or `'SLAVE'`. */
+  readonly ROLE: 'MASTER' | 'SLAVE';
+  private _status;
+  private _frame;
+  private _frameLen;
+  private _lenientHex;
+  private _hexTable;
+  /**
+   * @param role `'MASTER'` for request issuance / response decoding,
+   *   `'SLAVE'` for request decoding / response issuance.
+   * @param options ASCII framing options.
+   * @returns A new {@link AsciiProtocolLayer} instance.
+   */
+  constructor(role: 'MASTER' | 'SLAVE', options?: AsciiProtocolLayerOptions);
+  /**
+   * Reset the framing FSM to its `idle` state and discard any partial frame.
+   *
+   * @returns `void`.
+   */
+  flush(): void;
+  /**
+   * Decode incoming ASCII bytes into ADU `frame` events.
+   *
+   * @param data Raw bytes received from the transport. Must not be modified.
+   * @returns `void`.
+   *
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  decode(data: Buffer): void;
+  /**
+   * Encode a unit/FC/payload tuple into a complete Modbus ASCII frame.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Modbus function code byte (0..255).
+   * @param data PDU payload bytes (length 0..253).
+   * @param transaction Ignored by ASCII; present only for signature compatibility.
+   * @returns The framed ASCII buffer (`:` + uppercase hex body + LRC + `\r\n`).
+   *
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
+}
+//#endregion
+//#region src/layers/protocol/rtu-protocol-layer.d.ts
+/**
+ * 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.
+ */
+type RtuTimingValue = number | {
+  unit: 'bit' | 'ms';
+  value: number;
+};
+/** User-facing RTU protocol options (supports both bit and ms units). */
+interface RtuProtocolLayerOptions {
+  /**
+   * Serial baud rate, in bits per second.
+   * Required when using `{ unit: 'bit', value: N }` timing values; ignored otherwise.
+   */
+  baudRate?: number;
+  /**
+   * 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)
+   * - `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?: 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)
+   * - `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?: RtuTimingValue;
+  /**
+   * 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
+   */
+  strictTiming?: boolean;
+}
+/**
+ * RTU-specific narrowing of the protocol-layer contract.
+ *
+ * Merged with the {@link RtuProtocolLayer} class via TypeScript declaration
+ * merging. It overrides the inherited {@link AbstractProtocolLayer.customFunctionCodes}
+ * and {@link AbstractProtocolLayer.addCustomFunctionCode} signatures so that
+ * every RTU custom function code must declare a `determineFrameLength` callback; the
+ * RTU framing FSM needs it to determine the total frame length without a
+ * sliding-window CRC fallback.
+ */
+interface RtuProtocolLayer {
+  /**
+   * Registry of RTU custom function codes.
+   *
+   * Unlike the base {@link AbstractProtocolLayer.customFunctionCodes} array, each
+   * entry must include a `determineFrameLength` callback so the framing layer can
+   * predict the total frame length from leading bytes.
+   */
+  customFunctionCodes: ((CustomFunctionCode & {
+    determineFrameLength: (getByte: (idx: number) => number, length: number) => number;
+  }) | undefined)[];
+  /**
+   * Register a custom function code for RTU framing.
+   *
+   * @param cfc Custom function code descriptor. Must include `determineFrameLength`
+   *   so the RTU framing layer can derive the total frame length
+   *   (unit + FC + PDU + 2-byte CRC) from the bytes received so far.
+   * @returns `void`.
+   * @throws When `cfc.fc` is not an integer in `0..255`.
+   */
+  addCustomFunctionCode: (cfc: CustomFunctionCode & {
+    determineFrameLength: (getByte: (idx: number) => number, length: number) => number;
+  }) => void;
+  /**
+   * Remove a previously registered custom function code.
+   *
+   * @param fc Function code byte (0..255) to deregister.
+   * @returns `void`.
+   */
+  removeCustomFunctionCode: (fc: number) => void;
+}
+/**
+ * Modbus RTU protocol framing layer.
+ *
+ * Parses binary RTU frames (unit + FC + PDU + CRC16) from arbitrary byte chunks,
+ * validates CRC16, and optionally enforces Modbus V1.02 t1.5 / t3.5 timing using
+ * a single t3.5 `setTimeout` deadline plus inter-chunk timestamp comparison for
+ * t1.5. Custom function codes can be registered so variable-length frames can be
+ * predicted without a sliding-window CRC fallback.
+ */
+declare class RtuProtocolLayer extends AbstractProtocolLayer {
+  /** Always `'RTU'` for this implementation. */
+  readonly PROTOCOL: 'RTU';
+  /** Role of the owning stack — `'MASTER'` or `'SLAVE'`. */
+  readonly ROLE: 'MASTER' | 'SLAVE';
+  private _residual;
+  private _residualLen;
+  private _expectedLen;
+  private _isMaster;
+  private _t15Time;
+  private _t35Time;
+  private _t15Strict;
+  private _t35Timer?;
+  private _t15Marker;
+  private _lastChunkTime;
+  private _timingEnabled;
+  /**
+   * @param role `'MASTER'` for request issuance / response decoding,
+   *   `'SLAVE'` for request decoding / response issuance.
+   * @param options RTU timing and strictness options.
+   * @returns A new {@link RtuProtocolLayer} instance.
+   * @throws When `t3.5` is configured to be less than `t1.5`.
+   */
+  constructor(role: 'MASTER' | 'SLAVE', options?: RtuProtocolLayerOptions);
+  /**
+   * Resolve a {@link RtuTimingValue} into a concrete millisecond value.
+   *
+   * @param value Raw timing option supplied by the caller.
+   * @param baudRate Baud rate, required only for `{ unit: 'bit' }` values.
+   * @param fastBaudMs Fixed millisecond value used when `baudRate > 19200`.
+   * @returns Resolved milliseconds, or `undefined` when the value requires a
+   *   `baudRate` that was not provided.
+   */
+  private _resolveTime;
+  /**
+   * Reset the framing FSM — drop residual bytes, expected-length pin, and
+   * any pending silence safety timer. Used by the master/slave after
+   * a transport hiccup to re-align with the next clean frame boundary.
+   *
+   * @returns `void`.
+   */
+  flush(): void;
+  /**
+   * Decode incoming RTU bytes into ADU `frame` events.
+   *
+   * Incoming bus activity unconditionally cancels the pending t3.5 silence
+   * deadline. The gap since the previous chunk is then compared against t3.5
+   * (frame boundary) and, when configured, t1.5 (inter-character). The t3.5
+   * deadline is re-armed at the end of the pass whenever residual bytes remain.
+   * Frames are predicted from leading bytes using standard FC tables,
+   * custom-function-code predictors, or the shared RTU predictor; only once the
+   * full frame is available is the CRC16 validated. Frames that experience a
+   * t1.5 gap may be discarded when strict timing is enabled.
+   *
+   * @param data Raw bytes received from the transport. Must not be modified.
+   * @returns `void`.
+   *
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  decode(data: Buffer): void;
+  /**
+   * Encode a unit/FC/payload tuple into a complete Modbus RTU frame.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Modbus function code byte (0..255).
+   * @param data PDU payload bytes (length 0..254).
+   * @param transaction Ignored by RTU; present only for signature compatibility.
+   * @returns The framed RTU buffer (length `4 + data.length`) with little-endian CRC16.
+   *
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
+}
+//#endregion
+//#region src/layers/protocol/tcp-protocol-layer.d.ts
+/**
+ * Modbus TCP/IP protocol framing layer.
+ *
+ * Handles the 7-byte MBAP header (transaction identifier, protocol ID `0x0000`,
+ * length, unit ID) followed by the PDU. Frames are parsed from arbitrary byte
+ * chunks, including fragmented or coalesced TCP reads, using a flat residual
+ * buffer.
+ */
+declare class TcpProtocolLayer extends AbstractProtocolLayer {
+  /** Always `'TCP'` for this implementation. */
+  readonly PROTOCOL: 'TCP';
+  /** Role of the owning stack — `'MASTER'` or `'SLAVE'`. */
+  readonly ROLE: 'MASTER' | 'SLAVE';
+  private _residual;
+  private _residualLen;
+  /**
+   * @param role `'MASTER'` for request issuance / response decoding,
+   *   `'SLAVE'` for request decoding / response issuance.
+   * @returns A new {@link TcpProtocolLayer} instance.
+   */
+  constructor(role: 'MASTER' | 'SLAVE');
+  /**
+   * Reset the framing FSM — drop residual bytes.
+   *
+   * @returns `void`.
+   */
+  flush(): void;
+  /**
+   * Decode incoming TCP bytes into ADU `frame` events.
+   *
+   * @param data Raw bytes received from the transport. Must not be modified.
+   * @returns `void`.
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  decode(data: Buffer): void;
+  /**
+   * Encode a unit/FC/payload tuple into a complete Modbus TCP frame.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Modbus function code byte (0..255).
+   * @param data PDU payload bytes (length 0..253; caller must respect the
+   *   253-byte PDU ceiling, as this routine allocates `data.length + 8` bytes
+   *   without a runtime ceiling check).
+   * @param transaction 16-bit TCP transaction identifier (big-endian on the
+   *   wire). The caller supplies and tracks transaction IDs; this layer does not
+   *   maintain an internal counter.
+   * @returns The framed TCP buffer (length `8 + data.length`).
+   *
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  encode(unit: number, fc: number, data: Buffer, transaction: number): Buffer;
+}
+//#endregion
+//#region src/layers/abstract-pipeline-adapter.d.ts
+/**
+ * Events emitted by an {@link AbstractPipelineAdapter}.
+ */
+interface AbstractPipelineAdapterEvents {
+  /** Raw bytes received from the transport, passed to protocol layers. */
+  data: [data: Buffer];
+}
+/**
+ * Structural contract for a write-only adapter that sits between a protocol
+ * layer and the underlying transport.
+ *
+ * Implementations are provided by the plugin layer (serial / TCP / UDP); the
+ * protocol layer only needs the {@link write} contract and the `data` event.
+ */
+interface AbstractPipelineAdapter {
+  /**
+   * Write a raw frame to the transport.
+   *
+   * @param data Encoded frame bytes to transmit; must not be modified.
+   * @param cb Optional callback invoked once the write completes or fails.
+   */
+  write: (data: Buffer, cb?: (err: Error | null) => void) => void;
+  /** Subscribe to the `data` event. */
+  on: (event: 'data', listener: (data: Buffer) => void) => this;
+  /** Subscribe once to the `data` event. */
+  once: (event: 'data', listener: (data: Buffer) => void) => this;
+  /** Unsubscribe from the `data` event. */
+  off: (event: 'data', listener: (data: Buffer) => void) => this;
+  /** Emit a `data` event. */
+  emit: (event: 'data', data: Buffer) => boolean;
+}
+//#endregion
+//#region src/master/master.d.ts
+/**
+ * Events emitted by {@link ModbusMaster}.
+ */
+interface ModbusMasterEvents {
+  /** A frame failed validation; see {@link FrameErrorEvent}. */
+  frameError: [event: FrameErrorEvent];
+}
+/**
+ * Construction-time configuration for {@link ModbusMaster}.
+ *
+ * The `protocol` discriminator selects the application-layer codec (RTU / TCP /
+ * ASCII); each protocol accepts an optional `opts` bag (RTU/ASCII framing
+ * options, or `{ transactionId }` for TCP to seed the 16-bit MBAP transaction
+ * counter); `queueStrategy` and `timeout` tune the request scheduler; and an
+ * optional `customFunctionCodes` array can be seeded at construction time so the
+ * master recognises non-standard function codes immediately.
+ *
+ * @template P Transport protocol literal — `'TCP'`, `'RTU'`, or `'ASCII'`.
+ */
+interface ModbusMasterOptions<P extends 'TCP' | 'RTU' | 'ASCII'> {
+  pipelineAdapter: AbstractPipelineAdapter;
+  protocol: P extends 'TCP' ? {
+    type: 'TCP';
+    opts?: {
+      transactionId?: number;
+    };
+  } : P extends 'RTU' ? {
+    type: 'RTU';
+    opts?: RtuProtocolLayerOptions;
+  } : {
+    type: 'ASCII';
+    opts?: AsciiProtocolLayerOptions;
+  };
+  /**
+   * Modbus ADU queue processing strategy.
+   * Controls pruning, deduplication, and scheduling behavior when new requests arrive.
+   * - 'fifo': strict first-in-first-out, execute in queued order.
+   * - 'drop-stale' (default): last-arrived overwrites; new requests clear all stale unexecuted items in the queue.
+   * - 'deduplicate': smart deduplication based on ADU fingerprint.
+   * - 'concurrent': concurrent async dispatch (⚠️ Modbus TCP or multi-link Master only, use with caution on RTU bus).
+   */
+  queueStrategy?: P extends 'TCP' ? ModbusQueueStrategy : Exclude<ModbusQueueStrategy, 'concurrent'>;
+  /** Per-request timeout in ms. Default 1000. */
+  timeout?: number;
+}
+/**
+ * Resolved response from a Modbus slave / server.
+ *
+ * `transaction` is only present for Modbus TCP (MBAP transaction id); it is
+ * omitted for RTU and ASCII transports. `buffer` is the raw on-wire ADU that
+ * produced this response — useful for audit logs or replay debugging.
+ *
+ * @template T Type of the decoded payload (`Uint8Array` for bit reads,
+ *   `Uint16Array` for register reads, `number` for single-value writes, etc.).
+ */
+interface ModbusResponse<T> {
+  transaction?: number;
+  unit: number;
+  fc: number;
+  data: T;
+  buffer: Buffer;
+}
+/**
+ * Modbus master / client orchestrator.
+ *
+ * One instance owns:
+ * 1. A single {@link AbstractProtocolLayer} (RTU / TCP / ASCII codec) created
+ *    at construction time.
+ * 2. A single {@link AbstractPipelineAdapter} supplied at construction time.
+ * 3. A request queue with the chosen {@link ModbusQueueStrategy}.
+ * 4. A `MasterSession` that matches inbound frames to in-flight
+ *    requests by transaction id (TCP) or strict FIFO (RTU/ASCII).
+ * 5. A global lazy-deletion `TimerHeap` that arms one native
+ *    `setTimeout` per pending exchange under load.
+ *
+ * The instance emits decoded frames and framing errors on the protocol
+ * layer's event surface so external observers can log or audit the wire
+ * traffic without touching the internal queue machinery.
+ *
+ * Lifecycle notes:
+ * - A protocol layer is created once in the constructor and lives as long as
+ *   the master instance.
+ * - The pipeline layer is supplied at construction time and exists for the
+ *   lifetime of the master instance.
+ *
+ * @template P Transport protocol literal — `'TCP'`, `'RTU'`, or `'ASCII'`.
+ */
+declare class ModbusMaster<P extends 'TCP' | 'RTU' | 'ASCII'> extends CompactEventEmitter<ModbusMasterEvents> {
+  /** Resolved queue strategy — see {@link ModbusQueueStrategy}. */
+  readonly queueStrategy: ModbusQueueStrategy;
+  /** Default per-request timeout in milliseconds. */
+  readonly timeout: number;
+  /**
+   * The next 16-bit TCP transaction identifier that will be stamped into an
+   * outbound MBAP header. For RTU and ASCII transports the counter is unused
+   * and remains at its initial value.
+   */
+  get transactionId(): number;
+  /** `true` after {@link destroy} has been called. */
+  get destroyed(): boolean;
+  private _destroyed;
+  private _masterSession;
+  private _protocolLayer;
+  private _pipelineAdapter;
+  private _accessAuthorizer?;
+  private _queueUnits;
+  private _queueFcs;
+  private _queueDatas;
+  private _queueTimeouts;
+  private _queueBroadcasts;
+  private _queueCallbacks;
+  private _queueFingerprints;
+  private _queueHead;
+  private _queueLen;
+  private _draining;
+  private _transactionId;
+  private _cleanupSession;
+  private _nextExchangeId;
+  private _pendingExchanges;
+  private _timerHeap;
+  /**
+   * @param options Construction options; `protocol` is mandatory,
+   *   `queueStrategy` defaults to `'drop-stale'`, and `timeout`
+   *   defaults to 1000 ms. An optional `customFunctionCodes` array can be
+   *   supplied to pre-register non-standard function codes.
+   * @returns A new {@link ModbusMaster} instance.
+   * @throws `Error('Concurrent mode requires a Modbus TCP protocol layer')`
+   *   when `queueStrategy: 'concurrent'` is paired with a non-TCP protocol —
+   *   RTU/ASCII have no transaction id, so concurrent dispatch would have
+   *   no way to match responses back to requests.
+   */
+  constructor(options: ModbusMasterOptions<P>);
+  /**
+   * Queue-aware request entry point.
+   *
+   * Behaviour by {@link queueStrategy}:
+   * - **`'concurrent'`** (TCP only): bypass the queue entirely and dispatch
+   *   immediately via `_exchange`.
+   * - **`'fifo'`**: append to the queue; drained one-at-a-time.
+   * - **`'drop-stale'`** (default): reject every pending request with
+   *   `Error('Request dropped by drop-stale strategy')`, then enqueue the
+   *   new one — keeps only the latest intent.
+   * - **`'deduplicate'`**: scan the pending queue and reject every request
+   *   whose ADU fingerprint matches the new one, then enqueue.
+   *
+   * Authorization gates are evaluated in the order
+   * function-code support → `checkUnit` → `checkAddress` before any queue
+   * insertion or wire I/O, so rejected requests fail fast and never enter
+   * the queue.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Modbus function code byte (0..255).
+   * @param data PDU payload bytes (length 0..253).
+   * @param timeout Per-request timeout override in milliseconds.
+   * @param broadcast `true` when `unit === 0` (no response awaited).
+   * @param callback Callback invoked with `(err, frame)` on completion.
+   * @returns `void`.
+   * @throws Via `callback`: `Error('Master has been destroyed')` when the master
+   *   instance has already been destroyed; `Error('Unsupported function code 0x..')`
+   *   when the FC is neither a standard nor registered custom code;
+   *   `Error('Request denied by access authorizer')` / {@link UnauthorizedAccessError}
+   *   when `checkUnit` or `checkAddress` rejects the request; typed {@link ModbusError}
+   *   when either gate returns a numeric {@link ErrorCode}.
+   */
+  private _send;
+  /**
+   * Kick off the queue-drain loop if not already running. Idempotent — a
+   * second concurrent call returns without re-entering, so the loop stays
+   * single-threaded for the FIFO / drop-stale / deduplicate strategies.
+   */
+  private _drain;
+  /**
+   * Pop the head request off the parallel-array queue, dispatch it via
+   * `_exchange`, and chain the next pop onto the request's callback.
+   *
+   * Uses a head-index dequeue (O(1) per pop) instead of `Array.shift()`
+   * (O(N) reindex × 6 parallel arrays). The arrays are shrunk back to
+   * length 0 once the queue empties so the backing storage is reused
+   * across drain cycles instead of growing unboundedly.
+   *
+   * The drain loop is guarded against synchronous callbacks from
+   * `_exchange` (early error paths such as a detached pipeline or
+   * access-authorizer rejection): synchronous completion iterates via the
+   * `while` loop, asynchronous completion resumes through the callback.
+   * This prevents unbounded stack growth when many consecutive requests
+   * fail before entering the transport.
+   */
+  private _processNext;
+  /**
+   * Single request/response exchange — the lowest level of the master's
+   * write path. Owns the lazy-deletion timer architecture:
+   *
+   * 1. Allocate an `exchangeId` and register a {@link PendingEntry} so
+   *    every async checkpoint can detect cancellation in O(1).
+   * 2. Arm the timeout via `TimerHeap`: one shared native
+   *    `setTimeout` for ≥3 in-flight requests; per-request timers below
+   *    that. On expiry, the heap callback flips `settled = true` and
+   *    fires `Error('Request timed out')`.
+   * 3. For non-broadcast TCP frames, allocate the next free transaction
+   *    id (skipping ids already in the session map), encode the ADU, and
+   *    register a `MasterSession` waiter keyed on the tid **before**
+   *    `pipeline.write()` is called. Registering the waiter first prevents
+   *    responses that arrive before the write callback runs (loopback,
+   *    mock transports, or very fast slaves) from being discarded.
+   * 4. For non-broadcast RTU/ASCII frames, the session waiter is keyed on
+   *    the `FIFO_KEY` constant — only one in-flight request can match at
+   *    a time, which is enforced by the upstream queue.
+   * 5. For broadcasts (`unit === 0`), no response is expected — the
+   *    callback fires as soon as the write resolves (success) or the
+   *    timeout elapses.
+   *
+   * Stale frames (response arrived after `settled = true`) and stale
+   * timer fires (response arrived first) are silently discarded — the
+   * `settled` flag is the single source of truth.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Modbus function code byte (0..255).
+   * @param data PDU payload bytes (length 0..253).
+   * @param timeout Per-request timeout override in milliseconds.
+   * @param broadcast `true` when `unit === 0` (no response awaited).
+   * @param callback Callback invoked with `(err, frame)` on completion.
+   * @returns `void`.
+   * @throws Via `callback`: `Error('Request denied by access authorizer')` /
+   *   {@link UnauthorizedAccessError} when the configured
+   *   {@link AccessAuthorizer.checkRuntime} callback rejects the request;
+   *   typed {@link ModbusError} when `checkRuntime` returns a numeric
+   *   {@link ErrorCode}; the error reported by
+   *   {@link AbstractPipelineAdapter.write} when the transport rejects the
+   *   outbound bytes; `Error('Request timed out')` when the heap deadline
+   *   elapses; typed {@link ModbusError} when the slave returns an exception
+   *   response.
+   */
+  private _exchange;
+  /**
+   * Execute the wire write for a single exchange.
+   *
+   * This is the synchronous continuation of `_exchange` after access
+   * control has approved the request. It encodes the frame, registers the
+   * session waiter, arms the timer, and writes to the pipeline adapter.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Modbus function code byte (0..255).
+   * @param data PDU payload bytes (length 0..253).
+   * @param timeout Per-request timeout override in milliseconds.
+   * @param broadcast `true` when `unit === 0` (no response awaited).
+   * @param callback Callback invoked with `(err, frame)` on completion.
+   * @returns `void`.
+   */
+  private _runExchange;
+  /**
+   * Shared implementation for FC 1 (Read Coils) and FC 2 (Read Discrete Inputs).
+   *
+   * The two FCs share an identical request body (`address` + `length`,
+   * each big-endian 16-bit) and an identical response shape (a byte-count
+   * prefix followed by `(length + 7) >> 3` packed bits, LSB-first inside
+   * each byte per V1.1b3 §6.1). This helper unpacks the bit-packed payload
+   * into a `number[]` of 0/1 values via an inlined per-byte 8-way
+   * shift-and-mask.
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Function code byte — `FunctionCode.READ_COILS` or
+   *   `FunctionCode.READ_DISCRETE_INPUTS`.
+   * @param address Zero-based starting address (0..0xFFFF).
+   * @param length Number of discretes to read (1..2000).
+   * @param timeout Per-request timeout override in milliseconds.
+   * @returns Promise resolving to `{ unit, fc, data, buffer }` where `data`
+   *   is a length-`length` `(0 | 1)[]`, or `void` for broadcast.
+   *
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  private writeFC1Or2;
+  /** Alias for {@link readCoils} — kept for users that prefer the FC-numeric naming. */
+  writeFC1: this['readCoils'];
+  /**
+   * FC 1 — Read Coils (V1.1b3 §6.1). Reads `length` discrete coil values
+   * starting at `address`.
+   *
+   * @param unit Unit / slave address. Pass `0` for broadcast (no response
+   *   awaited; resolves with `void`).
+   * @param address Zero-based coil starting address (0..0xFFFF).
+   * @param length Number of coils to read (1..2000 per spec).
+   * @param timeout Per-request timeout override in milliseconds; defaults
+   *   to {@link timeout}.
+   * @returns Promise resolving to `{ unit, fc, data, buffer }` where `data`
+   *   is a length-`length` `(0 | 1)[]` of 0/1 values.
+   * @throws `Error('Request timed out')` when no response arrives within `timeout`;
+   *   typed {@link ModbusError} when the slave returns an exception response.
+   */
+  readCoils(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
+  readCoils(unit: number, address: number, length: number, timeout?: number): Promise<ModbusResponse<(0 | 1)[]>>;
+  /** Alias for {@link readDiscreteInputs}. */
+  writeFC2: this['readDiscreteInputs'];
+  /**
+   * FC 2 — Read Discrete Inputs (V1.1b3 §6.2). Identical request/response
+   * shape to FC 1, against the read-only discrete-input table.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based discrete-input starting address (0..0xFFFF).
+   * @param length Number of inputs to read (1..2000).
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to a `(0 | 1)[]` of 0/1 values, or `void` for broadcast.
+   * @throws Same as {@link readCoils}.
+   */
+  readDiscreteInputs(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
+  readDiscreteInputs(unit: number, address: number, length: number, timeout?: number): Promise<ModbusResponse<(0 | 1)[]>>;
+  /**
+   * Shared implementation for FC 3 (Read Holding Registers) and FC 4 (Read
+   * Input Registers).
+   *
+   * Both FCs share an identical request body (`address` + `length`, each
+   * big-endian 16-bit) and an identical response shape (byte-count prefix
+   * followed by `length` big-endian 16-bit values). The response loop uses
+   * inline `(buf[i] << 8) | buf[i+1]` reads instead of `readUInt16BE` —
+   * at FC 3's max length of 125 that saves 250 bounds-check pairs per
+   * response — per CLAUDE.md "Hot Paths: Strictly Inline".
+   *
+   * @param unit Unit / slave address byte (0..247).
+   * @param fc Function code byte — `FunctionCode.READ_HOLDING_REGISTERS` or
+   *   `FunctionCode.READ_INPUT_REGISTERS`.
+   * @param address Zero-based starting address (0..0xFFFF).
+   * @param length Number of registers to read (1..125).
+   * @param timeout Per-request timeout override in milliseconds.
+   * @returns Promise resolving to `{ unit, fc, data, buffer }` where `data`
+   *   is a length-`length` `number[]` of 16-bit register values, or `void`
+   *   for broadcast.
+   *
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  private writeFC3Or4;
+  /** Alias for {@link readHoldingRegisters}. */
+  writeFC3: this['readHoldingRegisters'];
+  /**
+   * FC 3 — Read Holding Registers (V1.1b3 §6.3). Reads `length` holding
+   * registers starting at `address`.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based register starting address (0..0xFFFF).
+   * @param length Number of registers to read (1..125 per spec).
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to a length-`length` `number[]` of 16-bit
+   *   register values.
+   * @throws Same as {@link readCoils}.
+   */
+  readHoldingRegisters(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
+  readHoldingRegisters(unit: number, address: number, length: number, timeout?: number): Promise<ModbusResponse<number[]>>;
+  /** Alias for {@link readInputRegisters}. */
+  writeFC4: this['readInputRegisters'];
+  /**
+   * FC 4 — Read Input Registers (V1.1b3 §6.4). Identical request/response
+   * shape to FC 3, against the read-only input-register table.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based register starting address (0..0xFFFF).
+   * @param length Number of registers to read (1..125).
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to a `number[]` of 16-bit register values.
+   * @throws Same as {@link readCoils}.
+   */
+  readInputRegisters(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
+  readInputRegisters(unit: number, address: number, length: number, timeout?: number): Promise<ModbusResponse<number[]>>;
+  /** Alias for {@link writeSingleCoil}. */
+  writeFC5: this['writeSingleCoil'];
+  /**
+   * FC 5 — Write Single Coil (V1.1b3 §6.5). Sets a single coil to ON / OFF.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based coil address (0..0xFFFF).
+   * @param value Coil state — pass `0` for OFF (`0x0000` on the wire) and any
+   *   non-zero value for ON (`0xFF00`).
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: value, ... }` echoed from the slave.
+   * @throws Same as {@link readCoils}.
+   */
+  writeSingleCoil(unit: 0, address: number, value: number, timeout?: number): Promise<void>;
+  writeSingleCoil(unit: number, address: number, value: number, timeout?: number): Promise<ModbusResponse<number>>;
+  /** Alias for {@link writeSingleRegister}. */
+  writeFC6: this['writeSingleRegister'];
+  /**
+   * FC 6 — Write Single Register (V1.1b3 §6.6). Writes one 16-bit value
+   * into the holding-register table.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based register address (0..0xFFFF).
+   * @param value Big-endian 16-bit value to write (0..0xFFFF).
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: value, ... }` echoed from the slave.
+   * @throws Same as {@link readCoils}.
+   */
+  writeSingleRegister(unit: 0, address: number, value: number, timeout?: number): Promise<void>;
+  writeSingleRegister(unit: number, address: number, value: number, timeout?: number): Promise<ModbusResponse<number>>;
+  /** Alias for {@link diagnosticsReturnQueryData}. */
+  handleFC8_0: this['diagnosticsReturnQueryData'];
+  /**
+   * FC 8 / Sub-function 0x0000 — Diagnostics: Return Query Data (V1.1b3 §6.8).
+   * Sends a 2-byte sub-function code (`0x0000`) and a 2-byte data value; the
+   * slave echoes both back verbatim. Used for loopback / communication testing.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param data 16-bit diagnostic data value (0..0xFFFF) sent big-endian.
+   * @param timeout Per-request timeout override in milliseconds.
+   * @returns Promise resolving to `{ data: number, ... }` where `data` is the
+   *   echoed 16-bit value.
+   * @throws Same as {@link readCoils}; `Error('Response echo does not match request')`
+   *   when the echoed data does not match the request.
+   */
+  diagnosticsReturnQueryData(unit: 0, data: number, timeout?: number): Promise<void>;
+  diagnosticsReturnQueryData(unit: number, data: number, timeout?: number): Promise<ModbusResponse<number>>;
+  /** Alias for {@link writeMultipleCoils}. */
+  writeFC15: this['writeMultipleCoils'];
+  /**
+   * FC 15 — Write Multiple Coils (V1.1b3 §6.11). Writes a contiguous block
+   * of coil values starting at `address`.
+   *
+   * Coil values are bit-packed LSB-first into the request body — the
+   * inline 8-way pack in this method's body matches the 8-way unpack in
+   * `writeFC1Or2` for symmetry.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based coil starting address (0..0xFFFF).
+   * @param value Coil values to write — `ArrayLike<0 | 1>` where element `i`
+   *   is `0` (OFF) or `1` (ON). Length must be 1..1968 per spec.
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: value, ... }` (the original input
+   *   value, not the wire echo, for caller convenience).
+   * @throws Same as {@link readCoils}.
+   */
+  writeMultipleCoils(unit: 0, address: number, value: ArrayLike<0 | 1>, timeout?: number): Promise<void>;
+  writeMultipleCoils<T extends ArrayLike<0 | 1> = ArrayLike<0 | 1>>(unit: number, address: number, value: T, timeout?: number): Promise<ModbusResponse<T>>;
+  /** Alias for {@link writeMultipleRegisters}. */
+  writeFC16: this['writeMultipleRegisters'];
+  /**
+   * FC 16 — Write Multiple Registers (V1.1b3 §6.12). Writes a contiguous
+   * block of 16-bit holding-register values starting at `address`.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based register starting address (0..0xFFFF).
+   * @param value Register values to write as an `ArrayLike<number>` (each
+   *   element is a 16-bit word, 0..0xFFFF). Length must be 1..123 per spec.
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: value, ... }` (the original input
+   *   value; the wire echo is just the address+quantity tuple).
+   * @throws Same as {@link readCoils}.
+   */
+  writeMultipleRegisters(unit: 0, address: number, value: ArrayLike<number>, timeout?: number): Promise<void>;
+  writeMultipleRegisters<T extends ArrayLike<number> = ArrayLike<number>>(unit: number, address: number, value: T, timeout?: number): Promise<ModbusResponse<T>>;
+  /** Alias for {@link reportServerId}. */
+  handleFC17: this['reportServerId'];
+  /**
+   * FC 17 — Report Server ID (V1.1b3 §6.13). Queries the slave for its
+   * vendor-specific identification block.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param serverIdLength Number of bytes the slave is expected to use for
+   *   `serverId`. Defaults to `1`. The remaining bytes are surfaced as
+   *   `additionalData` so legacy multi-byte server IDs can be parsed
+   *   without losing the trailing payload.
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: ServerId, ... }`.
+   * @throws Same as {@link readCoils}; `Error('Report server ID response too short')`
+   *   when the response is too short to contain `serverIdLength` bytes;
+   *   `Error('Report server ID length mismatch')` when the embedded byte-count
+   *   disagrees with the actual response length.
+   */
+  reportServerId(unit: 0, serverIdLength?: number, timeout?: number): Promise<void>;
+  reportServerId(unit: number, serverIdLength?: number, timeout?: number): Promise<ModbusResponse<ServerId>>;
+  /** Alias for {@link maskWriteRegister}. */
+  handleFC22: this['maskWriteRegister'];
+  /**
+   * FC 22 — Mask Write Register (V1.1b3 §6.16). Atomically updates one
+   * holding register: `result = (current AND andMask) OR (orMask AND NOT andMask)`.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param address Zero-based register address (0..0xFFFF).
+   * @param andMask 16-bit AND mask (0..0xFFFF).
+   * @param orMask 16-bit OR mask (0..0xFFFF).
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: { andMask, orMask }, ... }`
+   *   echoed from the slave.
+   * @throws Same as {@link readCoils}.
+   */
+  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<ModbusResponse<{
+    andMask: number;
+    orMask: number;
+  }>>;
+  /** Alias for {@link readAndWriteMultipleRegisters}. */
+  handleFC23: this['readAndWriteMultipleRegisters'];
+  /**
+   * FC 23 — Read/Write Multiple Registers (V1.1b3 §6.17). Atomically
+   * performs a write-then-read against two register windows in one frame.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param read Read window: `{ address, length }` (length 1..125).
+   * @param write Write window: `{ address, value }` where `value` is an
+   *   `ArrayLike<number>` of 1..121 registers.
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: number[], ... }` containing the
+   *   read window values **after** the write has been applied.
+   * @throws Same as {@link readCoils}.
+   */
+  readAndWriteMultipleRegisters(unit: 0, read: {
+    address: number;
+    length: number;
+  }, write: {
+    address: number;
+    value: ArrayLike<number>;
+  }, timeout?: number): Promise<void>;
+  readAndWriteMultipleRegisters<T extends ArrayLike<number> = ArrayLike<number>>(unit: number, read: {
+    address: number;
+    length: number;
+  }, write: {
+    address: number;
+    value: T;
+  }, timeout?: number): Promise<ModbusResponse<number[]>>;
+  /** Alias for {@link readDeviceIdentification}. */
+  handleFC43_14: this['readDeviceIdentification'];
+  /**
+   * FC 43 / MEI 14 — Read Device Identification (V1.1b3 §6.21). Queries
+   * the slave's TLV identification table.
+   *
+   * The response is parsed into a {@link DeviceIdentification} record:
+   * each TLV is unpacked into `{ id, value }` (where `value` is the ASCII
+   * decoding of the byte run), and `moreFollows` / `nextObjectId` are
+   * surfaced verbatim so callers can fragment-walk the table by re-issuing
+   * the call with `objectId = nextObjectId` until `moreFollows === false`.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param readDeviceIDCode `1`/`2`/`3` for streaming basic / regular /
+   *   extended; `4` for individual access — see `ReadDeviceIDCode`.
+   * @param objectId Starting object id (0..0xFF). For streaming
+   *   reads, the slave returns objects starting from this id.
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to `{ data: DeviceIdentification, ... }`.
+   * @throws Same as {@link readCoils}; `Error('Read device identification response too short')`
+   *   when the response is below the 6-byte MEI header; `Error('Invalid read device identification response')`
+   *   when the MEI byte / readDeviceIDCode does not match; `Error('Device identification object count mismatch')`
+   *   when the embedded number-of-objects disagrees with the parsed count; and
+   *   `Error('Device identification length mismatch')` when the total length
+   *   does not match the cumulative TLV body length.
+   */
+  readDeviceIdentification(unit: 0, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<void>;
+  readDeviceIdentification(unit: number, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<ModbusResponse<DeviceIdentification>>;
+  /**
+   * Issue a request against a custom (non-standard) function code.
+   *
+   * The FC must already be registered via {@link addCustomFunctionCode} on
+   * the master — otherwise the queue layer rejects the call with
+   * `Error('Unsupported function code 0x..')`.
+   *
+   * @param unit Unit / slave address; `0` = broadcast.
+   * @param fc Custom function-code byte.
+   * @param data Request PDU payload (bytes after FC, before checksum).
+   *   Accepts a `Buffer` for arbitrary bytes, or a `number[]` for a
+   *   word-oriented payload that will be encoded big-endian.
+   * @param timeout Per-request timeout override (ms).
+   * @returns Promise resolving to the raw response PDU `Buffer` (no FC,
+   *   no checksum) — caller is responsible for parsing the body.
+   * @throws `Error('Request timed out')` when no response arrives within `timeout`;
+   *   typed {@link ModbusError} when the slave returns an exception response.
+   */
+  sendCustomFC(unit: 0, fc: number, data: Buffer | number[], timeout?: number): Promise<void>;
+  sendCustomFC(unit: number, fc: number, data: Buffer | number[], timeout?: number): Promise<Buffer>;
+  /**
+   * Register a custom (non-standard) function code for outbound requests.
+   *
+   * For RTU transports the descriptor must also include `determineFrameLength` so the
+   * framing layer can determine the total frame length without buffering.
+   *
+   * @param cfc Custom function-code descriptor.
+   */
+  addCustomFunctionCode(cfc: P extends 'RTU' ? CustomFunctionCode & {
+    determineFrameLength: (getByte: (idx: number) => number, length: number) => number;
+  } : CustomFunctionCode): void;
+  /**
+   * Unregister a previously added custom function code.
+   *
+   * @param fc Function code byte to remove.
+   */
+  removeCustomFunctionCode(fc: number): void;
+  /** Remove all custom function codes registered on this master. */
+  removeAllCustomFunctionCodes(): void;
+  /**
+   * Install an access-control policy on the master.
+   *
+   * The policy is evaluated for every outbound request:
+   * - `checkUnit` and `checkAddress` are evaluated in `_send`, before
+   *   queue insertion, so rejected requests fail fast and never enter the queue.
+   * - `checkRuntime` is evaluated in `_exchange`, after the queue drains but
+   *   before any wire I/O.
+   *
+   * Requests that fail any gate are rejected locally and never sent to the
+   * transport.
+   *
+   * @param authorizer The policy to enforce. Omit a hook to disable that gate.
+   * @returns `this` for chaining.
+   *
+   * @example
+   * ```ts
+   * master.setAccessAuthorizer({
+   *   checkUnit: (unit) => unit === 1,
+   *   checkAddress: (_unit, table, [start, end]) =>
+   *     table === 'holdingRegisters' && start >= 0 && end < 100,
+   * });
+   * ```
+   */
+  setAccessAuthorizer(authorizer: AccessAuthorizer): void;
+  /**
+   * Remove the access-control policy installed by {@link setAccessAuthorizer}.
+   *
+   * After this call all outbound requests flow through the master without any
+   * access-control gate until a new authorizer is installed.
+   *
+   * @returns `this` for chaining.
+   */
+  deleteAccessAuthorizer(): void;
+  /**
+   * Destroy the master and cancel all pending activity.
+   *
+   * After this call the instance is unusable: pending queue entries and
+   * in-flight exchanges are rejected with `Error('Master has been destroyed')`,
+   * timers are cleared, and listeners are removed.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region src/slave/types.d.ts
+/**
+ * Discriminated callback arguments for a slave handler that returns `D`.
+ *
+ * On success the handler receives `[null, data]`; on failure it receives
+ * `[errorCode, undefined]`.
+ *
+ * @template D Payload type returned on success.
+ */
+type CallbackArgs<D> = [errorCode: null, data: D] | [errorCode: ErrorCode, data: undefined];
+/**
+ * Slave handler callback shape.
+ *
+ * When `D` is `void` the callback is invoked with only the error code;
+ * otherwise it receives the discriminated tuple from {@link CallbackArgs}.
+ *
+ * @template D Payload type returned on success.
+ */
+type Callback<D> = D extends void ? (errorCode: ErrorCode | null) => void : (...args: CallbackArgs<D>) => void;
+/**
+ * Lazy variant of {@link CallbackArgs}: the data payload is wrapped in a
+ * zero-argument factory so the slave can defer response encoding until the
+ * framing layer is ready to write.
+ *
+ * @template D Payload type returned on success.
+ */
+type CallbackLazyArgs<D> = [errorCode: null, data: () => D] | [errorCode: ErrorCode, data: undefined];
+/**
+ * Lazy variant of {@link Callback} used by the slave dispatcher.
+ *
+ * The payload factory is only called when the response is actually encoded,
+ * letting handlers return large or computed payloads without allocation
+ * unless the request is authorized and the pipeline is connected.
+ *
+ * @template D Payload type returned on success.
+ */
+type CallbackLazy<D> = (...args: CallbackLazyArgs<D>) => void;
+/**
+ * Unit model contract implemented by user code and registered with
+ * {@link ModbusSlave.addUnit}.
+ *
+ * Each property is an optional handler for one Modbus function code. The
+ * slave dispatcher validates the request shape, invokes the matching handler,
+ * and encodes the response. Handlers should follow the callback convention
+ * `[errorCode, data]` (or just `errorCode` for void payloads).
+ */
+interface ModbusUnitModel {
+  /**
+   * Unit identifier this model claims.
+   *
+   * Valid range is `1..247` per the Modbus spec; `0` is reserved for broadcast.
+   * Defaults to `1` when omitted; pass an explicit value when a single slave
+   * instance hosts multiple unit IDs.
+   */
+  unit?: number;
+  /**
+   * FC 2 — Read Discrete Inputs.
+   *
+   * @param address Zero-based input starting address (0..0xFFFF).
+   * @param length Number of inputs to read (1..2000).
+   * @param callback Invoked with `[null, values]` on success or
+   *   `[errorCode, undefined]` on failure; `values` may be any `ArrayLike<0 | 1>`
+   *   (e.g. `number[]`), where each element represents OFF (`0`) or ON (`1`).
+   */
+  readDiscreteInputs?: (address: number, length: number, callback: Callback<ArrayLike<0 | 1>>) => void;
+  /**
+   * FC 1 — Read Coils.
+   *
+   * @param address Zero-based coil starting address (0..0xFFFF).
+   * @param length Number of coils to read (1..2000).
+   * @param callback Invoked with `[null, values]` on success or
+   *   `[errorCode, undefined]` on failure; `values` may be any `ArrayLike<0 | 1>`
+   *   (e.g. `number[]`), where each element represents OFF (`0`) or ON (`1`).
+   */
+  readCoils?: (address: number, length: number, callback: Callback<ArrayLike<0 | 1>>) => void;
+  /**
+   * FC 5 — Write Single Coil.
+   *
+   * @param address Zero-based coil address (0..0xFFFF).
+   * @param value Coil state — `0` (OFF) or `1` (ON).
+   * @param callback Invoked with `[null]` on success or `[errorCode]` on failure.
+   */
+  writeSingleCoil?: (address: number, value: number, callback: Callback<void>) => void;
+  /**
+   * FC 15 — Write Multiple Coils.
+   *
+   * @param address Zero-based coil starting address (0..0xFFFF).
+   * @param value Coil states — array of `0` (OFF) or `1` (ON), length 1..1968.
+   * @param callback Invoked with `[null]` on success or `[errorCode]` on failure.
+   */
+  writeMultipleCoils?: (address: number, value: (0 | 1)[], callback: Callback<void>) => void;
+  /**
+   * FC 4 — Read Input Registers.
+   *
+   * @param address Zero-based register starting address (0..0xFFFF).
+   * @param length Number of registers to read (1..125).
+   * @param callback Invoked with `[null, values]` on success or
+   *   `[errorCode, undefined]` on failure; `values` may be any `ArrayLike<number>`
+   *   of 16-bit words (e.g. `number[]`, `Uint16Array`, `Buffer`).
+   */
+  readInputRegisters?: (address: number, length: number, callback: Callback<ArrayLike<number>>) => void;
+  /**
+   * FC 3 — Read Holding Registers.
+   *
+   * @param address Zero-based register starting address (0..0xFFFF).
+   * @param length Number of registers to read (1..125).
+   * @param callback Invoked with `[null, values]` on success or
+   *   `[errorCode, undefined]` on failure; `values` may be any `ArrayLike<number>`
+   *   of 16-bit words (e.g. `number[]`, `Uint16Array`, `Buffer`).
+   */
+  readHoldingRegisters?: (address: number, length: number, callback: Callback<ArrayLike<number>>) => void;
+  /**
+   * FC 6 — Write Single Register.
+   *
+   * @param address Zero-based register address (0..0xFFFF).
+   * @param value Big-endian 16-bit value to write (0..0xFFFF).
+   * @param callback Invoked with `[null]` on success or `[errorCode]` on failure.
+   */
+  writeSingleRegister?: (address: number, value: number, callback: Callback<void>) => void;
+  /**
+   * FC 16 — Write Multiple Registers.
+   *
+   * @param address Zero-based register starting address (0..0xFFFF).
+   * @param value Register values to write as a `number[]` of 16-bit words,
+   *   length 1..123.
+   * @param callback Invoked with `[null]` on success or `[errorCode]` on failure.
+   */
+  writeMultipleRegisters?: (address: number, value: number[], callback: Callback<void>) => void;
+  /**
+   * FC 22 — Mask Write Register.
+   *
+   * @param address Zero-based register address (0..0xFFFF).
+   * @param andMask 16-bit AND mask (0..0xFFFF).
+   * @param orMask 16-bit OR mask (0..0xFFFF).
+   * @param callback Invoked with `[null]` on success or `[errorCode]` on failure.
+   */
+  maskWriteRegister?: (address: number, andMask: number, orMask: number, callback: Callback<void>) => void;
+  /**
+   * FC 8 / Sub-function 0x0000 — Diagnostics: Return Query Data.
+   *
+   * The handler receives the 16-bit diagnostic data from the request and may
+   * inspect, log, or reject it; the response is always the original request PDU
+   * echoed verbatim.
+   *
+   * @param data 16-bit diagnostic data value from the request (0..0xFFFF).
+   * @param callback Invoked with `[null]` on success or `[errorCode]` on failure.
+   */
+  diagnosticsReturnQueryData?: (data: number, callback: Callback<void>) => void;
+  /**
+   * FC 17 — Report Server ID.
+   *
+   * @param callback Invoked with `[null, serverId]` on success or
+   *   `[errorCode, undefined]` on failure.
+   */
+  reportServerId?: (callback: Callback<ServerId>) => void;
+  /**
+   * FC 43 / MEI 14 — Read Device Identification.
+   *
+   * Return the slave's TLV identification table keyed by object id (0..255).
+   * Object ids 0x07..0x7F are reserved by the spec and rejected by the
+   * dispatcher with `SERVER_DEVICE_FAILURE`.
+   *
+   * @param callback Invoked with `[null, objects]` on success or
+   *   `[errorCode, undefined]` on failure.
+   */
+  readDeviceIdentification?: (callback: Callback<{
+    [index: number]: string;
+  }>) => void;
+}
+/**
+ * Discriminant for {@link ProtocolExceptionEvent} describing the reason a slave
+ * produced a Modbus exception response.
+ */
+type ProtocolExceptionEventType = /** Function code is not supported by this slave or the framing layer. */'function_illegal' /** Function code is legal but no handler is implemented for the target unit. */ | 'function_not_implemented' /** PDU length, value range, or structure violates the Modbus specification. */ | 'data_value_illegal' /** Data address or object id is outside the allowed range. */ | 'data_address_illegal' /** Slave handler detected an internal/device-side failure while building the response. */ | 'server_device_failure' /** Target unit is not registered on this slave session. */ | 'gateway_path_unavailable';
+/**
+ * Payload emitted with the `protocolException` event when the slave responds
+ * with a Modbus exception function code.
+ *
+ * @example
+ * ```ts
+ * slave.on('protocolException', (event) => {
+ *   logger.info({ exception: event }, 'modbus exception');
+ * });
+ * ```
+ *
+ * @see {@link ProtocolExceptionEventType}
+ */
+interface ProtocolExceptionEvent {
+  /** Error classification; see {@link ProtocolExceptionEventType}. */
+  type: ProtocolExceptionEventType;
+  /**
+   * Human-readable description of the failure; sufficient to diagnose the
+   * problem without inspecting {@link data}.
+   */
+  message: string;
+  /** TCP MBAP transaction identifier (big-endian, 16-bit), when available. */
+  transaction?: number;
+  /** Modbus unit/slave address byte (0..247). */
+  unit: number;
+  /** Modbus function code byte (0..255). */
+  fc: number;
+  /**
+   * Snapshot of the PDU payload that triggered the exception.
+   * This is a copy of the original bytes and is safe to inspect or log.
+   */
+  data: Buffer;
+}
+/**
+ * Discriminant for {@link AccessAuditEvent} describing a request that was
+ * rejected by the configured access authorizer.
+ */
+type AccessAuditEventType = /** Unit address was rejected by the configured access authorizer. */'unit_access_denied' /** Address range or table was rejected by the configured access authorizer. */ | 'address_access_denied' /** Runtime authorization denied or returned an exception code. */ | 'runtime_access_denied';
+/**
+ * Payload emitted with the `accessAudit` event when a request is rejected by
+ * the configured access authorizer.
+ *
+ * @example
+ * ```ts
+ * slave.on('accessAudit', (event) => {
+ *   logger.warn({ audit: event }, 'modbus access denied');
+ * });
+ * ```
+ *
+ * @see {@link AccessAuditEventType} {@link AccessAuthorizer}
+ */
+interface AccessAuditEvent {
+  /** Audit classification; see {@link AccessAuditEventType}. */
+  type: AccessAuditEventType;
+  /**
+   * Human-readable description of the audit event; sufficient to diagnose the
+   * problem without inspecting {@link data}.
+   */
+  message: string;
+  /** TCP MBAP transaction identifier (big-endian, 16-bit), when available. */
+  transaction?: number;
+  /** Modbus unit/slave address byte (0..247). */
+  unit: number;
+  /** Modbus function code byte (0..255). */
+  fc: number;
+  /**
+   * Snapshot of the PDU payload that triggered the audit event.
+   * This is a copy of the original bytes and is safe to inspect or log.
+   */
+  data: Buffer;
+}
+/**
+ * Discriminant for {@link PipelineFaultEvent} describing a transport-layer
+ * failure while emitting a response frame.
+ */
+type PipelineFaultEventType = /** The pipeline layer failed to write the encoded response frame. */'write_failed';
+/**
+ * Payload emitted with the `pipelineFault` event when the slave has produced a
+ * response but the underlying pipeline layer could not transmit it.
+ */
+interface PipelineFaultEvent {
+  /** Fault classification; see {@link PipelineFaultEventType}. */
+  type: PipelineFaultEventType;
+  /**
+   * Human-readable description of the failure; sufficient to diagnose the
+   * problem without inspecting {@link data} / {@link responseRaw}.
+   */
+  message: string;
+  /** TCP MBAP transaction identifier (big-endian, 16-bit), when available. */
+  transaction?: number;
+  /** Modbus unit/slave address byte (0..247). */
+  unit: number;
+  /** Modbus function code byte (0..255). */
+  fc: number;
+  /**
+   * Snapshot of the request PDU payload that triggered the attempted response.
+   * This is a copy of the original bytes and is safe to inspect or log.
+   */
+  data: Buffer;
+  /**
+   * The raw, encoded response frame that the pipeline layer failed to write.
+   * This is the exact buffer passed to the pipeline layer's write operation.
+   */
+  responseRaw: Buffer;
+  /** The error returned by the pipeline layer's write operation. */
+  error: Error;
+}
+//#endregion
+//#region src/slave/slave.d.ts
+/**
+ * Events emitted by {@link ModbusSlave}.
+ */
+interface ModbusSlaveEvents {
+  /** A frame failed validation; see {@link FrameErrorEvent}. */
+  frameError: [event: FrameErrorEvent];
+  /** The slave produced a Modbus exception response; see {@link ProtocolExceptionEvent}. */
+  protocolException: [event: ProtocolExceptionEvent];
+  /** A request was rejected by the configured access authorizer; see {@link AccessAuditEvent}. */
+  accessAudit: [event: AccessAuditEvent];
+  /** The pipeline layer failed to transmit a response; see {@link PipelineFaultEvent}. */
+  pipelineFault: [event: PipelineFaultEvent];
+}
+/**
+ * Construction-time configuration for {@link ModbusSlave}.
+ *
+ * The `protocol` discriminator selects the application-layer codec (RTU / TCP /
+ * ASCII); `queueStrategy` and `enableWriteRangeLock` tune the frame scheduler.
+ *
+ * @template P Transport protocol literal — `'TCP'`, `'RTU'`, or `'ASCII'`.
+ */
+interface ModbusSlaveOptions<P extends 'TCP' | 'RTU' | 'ASCII'> {
+  pipelineAdapter: AbstractPipelineAdapter;
+  protocol: P extends 'TCP' ? {
+    type: 'TCP';
+  } : P extends 'RTU' ? {
+    type: 'RTU';
+    opts?: RtuProtocolLayerOptions;
+  } : {
+    type: 'ASCII';
+    opts?: AsciiProtocolLayerOptions;
+  };
+  /**
+   * Modbus ADU queue processing strategy.
+   * Controls pruning, deduplication, and scheduling behavior when new frames arrive.
+   * - 'fifo': strict first-in-first-out, execute in queued order.
+   * - 'drop-stale' (default): last-arrived overwrites; new frames clear all stale unexecuted items in the queue.
+   * - 'deduplicate': smart deduplication based on ADU fingerprint.
+   * - 'concurrent': concurrent async dispatch (⚠️ Modbus TCP only, use with caution on RTU bus).
+   */
+  queueStrategy?: P extends 'TCP' ? ModbusQueueStrategy : Exclude<ModbusQueueStrategy, 'concurrent'>;
+  /**
+   * When `queueStrategy` is `'concurrent'`, serialize concurrent write
+   * requests (FC05/06/15/16) whose address ranges overlap on the same unit.
+   * Set to `false` for purely synchronous in-memory slaves that do not need
+   * the coordination overhead.
+   * @default true
+   */
+  enableWriteRangeLock?: boolean;
+}
+/**
+ * Modbus slave / server orchestrator.
+ *
+ * One instance owns:
+ * 1. A single {@link AbstractProtocolLayer} (RTU / TCP / ASCII codec) created
+ *    at construction time.
+ * 2. A single {@link AbstractPipelineAdapter} supplied at construction time.
+ * 3. A {@link ModbusQueueStrategy} frame queue for non-concurrent modes.
+ * 4. Per-unit write-range locking for concurrent TCP mode when
+ *    `enableWriteRangeLock` is `true`.
+ * 5. Typed access control, protocol, and pipeline fault events.
+ *
+ * Register unit models with {@link addUnit}, install an optional
+ * {@link AccessAuthorizer} with {@link setAccessAuthorizer}, and destroy with
+ * {@link destroy} when the transport closes.
+ *
+ * @template P Transport protocol literal — `'TCP'`, `'RTU'`, or `'ASCII'`.
+ */
+declare class ModbusSlave<P extends 'TCP' | 'RTU' | 'ASCII'> extends CompactEventEmitter<ModbusSlaveEvents> {
+  readonly queueStrategy: ModbusQueueStrategy;
+  readonly enableWriteRangeLock: boolean;
+  /** `true` after {@link destroy} has been called. */
+  get destroyed(): boolean;
+  private _destroyed;
+  private _units;
+  private _protocolLayer;
+  private _pipelineAdapter;
+  private _cfcResponses;
+  private _accessAuthorizer?;
+  private _queue;
+  private _cleanupSession;
+  private _unitWriteQueues;
+  private _flushingPending;
+  private _pendingFlushPending;
+  /**
+   * @param options Construction options; `protocol` is mandatory,
+   *   `queueStrategy` defaults to `'drop-stale'`, and `enableWriteRangeLock`
+   *   defaults to `true`.
+   * @throws `Error('Concurrent mode requires a Modbus TCP protocol layer')`
+   *   when `queueStrategy: 'concurrent'` is paired with a non-TCP protocol.
+   */
+  constructor(options: ModbusSlaveOptions<P>);
+  private _handleFC1;
+  private _handleFC2;
+  private _handleFC3;
+  private _handleFC4;
+  private _handleFC5;
+  private _handleFC6;
+  private _handleFC8_0;
+  private _handleFC15;
+  private _handleFC16;
+  private _handleFC17;
+  private _handleFC22;
+  private _handleFC23;
+  private _handleFC43_14;
+  /**
+   * Dispatch a validated ADU to the appropriate FC handler.
+   *
+   * Kept synchronous so the slave dispatch path avoids one `async/await`
+   * suspend/resume per request.
+   *
+   * @param model Unit model that will handle the request.
+   * @param frame Parsed ADU including the PDU payload.
+   * @param callback Lazy callback that receives the encoded response PDU.
+   * @note Hot Path: Strictly Inline. Do not refactor into sub-routines.
+   */
+  private _handleFC;
+  private _flushPendingWrites;
+  private _executeUnitWrite;
+  private _processUnitWrite;
+  private _onLockedUnitWriteDone;
+  private _processFrame;
+  /**
+   * Register a unit model that will handle requests for `unit`.
+   *
+   * @param unit Unit / slave address (1..247).
+   * @param model Handler model implementing the function codes to support.
+   * @returns `this` for chaining.
+   * @throws When `unit` is not an integer in `1..247`.
+   */
+  addUnit(unit: number, model: ModbusUnitModel): this;
+  /**
+   * Unregister the model for `unit`.
+   *
+   * @param unit Unit / slave address to remove.
+   * @returns `this` for chaining.
+   */
+  removeUnit(unit: number): void;
+  /**
+   * Unregister every unit model on this slave.
+   *
+   * @returns `this` for chaining.
+   */
+  removeAllUnits(): void;
+  /**
+   * Register a custom function code and its handler on this slave.
+   *
+   * For RTU transports the descriptor must also include `determineFrameLength` so the
+   * framing layer can determine the total frame length without buffering.
+   *
+   * @param cfc Custom function-code descriptor.
+   * @param response Handler called to produce the response PDU.
+   * @returns `this` for chaining.
+   */
+  addCustomFunctionCode(cfc: P extends 'RTU' ? CustomFunctionCode & {
+    determineFrameLength: (getByte: (idx: number) => number, length: number) => number;
+  } : CustomFunctionCode, response: (unit: number, fc: number, data: Buffer, callback: CallbackLazy<Buffer>) => void): void;
+  /**
+   * Unregister a previously added custom function code.
+   *
+   * @param fc Function code byte to remove.
+   * @returns `this` for chaining.
+   */
+  removeCustomFunctionCode(fc: number): void;
+  /**
+   * Remove all custom function codes registered on this slave.
+   *
+   * @returns `this` for chaining.
+   */
+  removeAllCustomFunctionCodes(): void;
+  /**
+   * Install an access-control policy on the slave.
+   *
+   * The policy is evaluated for every inbound frame:
+   * - `checkUnit` and `checkAddress` run before dispatch.
+   * - `checkRuntime` runs after the unit handler produces a successful response
+   *   but before the response is encoded and written.
+   *
+   * @param authorizer The policy to enforce. Omit a hook to disable that gate.
+   * @returns `this` for chaining.
+   *
+   * @example
+   * ```ts
+   * slave.setAccessAuthorizer({
+   *   checkUnit: (unit) => allowedUnits.has(unit),
+   *   checkAddress: (_unit, table, [start, end]) =>
+   *     table === 'holdingRegisters' && start >= 0 && end < 100,
+   * });
+   * ```
+   */
+  setAccessAuthorizer(authorizer: AccessAuthorizer): void;
+  /**
+   * Remove the access-control policy installed by {@link setAccessAuthorizer}.
+   *
+   * After this call all inbound frames flow through the slave without any
+   * access-control gate until a new authorizer is installed.
+   *
+   * @returns `this` for chaining.
+   */
+  deleteAccessAuthorizer(): void;
+  /**
+   * Destroy the slave and release all resources.
+   *
+   * After this call the instance is unusable: protocol callbacks are cleaned,
+   * queues are cleared, units and custom function codes are removed, and
+   * listeners are detached.
+   *
+   * @returns `this` for chaining.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region src/plugins/connection-security-options.d.ts
+/**
+ * Shared security and resource-limit options for TCP and UDP server physical
+ * layers.
+ *
+ * The same field names are used for both transports. For UDP, `maxConnections`
+ * and `maxConnectionsPerIp` limit concurrent peers rather than OS-level
+ * connections.
+ */
+interface ConnectionSecurityOptions {
+  /**
+   * Allowed remote addresses. Each entry is either an exact IP string, an IPv4
+   * CIDR string, or a predicate that receives the canonicalized address.
+   *
+   * If omitted or empty, all addresses are allowed.
+   */
+  whitelist?: WhitelistEntry[];
+  /**
+   * Maximum number of concurrent connections (TCP) or peers (UDP).
+   *
+   * If omitted, no limit is enforced. `0` is treated as "no limit".
+   */
+  maxConnections?: number;
+  /**
+   * Maximum number of concurrent connections (TCP) or peers (UDP) allowed from
+   * a single remote IP address.
+   *
+   * If omitted, no limit is enforced. `0` is treated as "no limit".
+   */
+  maxConnectionsPerIp?: number;
+  /**
+   * Inactivity timeout before a connection or peer pipeline is automatically
+   * destroyed (unit: ms).
+   *
+   * If omitted, no idle timeout is enforced for either TCP or UDP. `0`
+   * disables the timer.
+   */
+  idleTimeout?: number;
+}
+/**
+ * Security and resource-limit options for {@link TcpServerPhysicalLayer}.
+ */
+type TcpConnectionSecurityOptions = ConnectionSecurityOptions;
+/**
+ * Security and resource-limit options for {@link UdpServerPhysicalLayer}.
+ */
+type UdpConnectionSecurityOptions = ConnectionSecurityOptions;
+/**
+ * Security and resource-limit options for {@link TlsServerPhysicalLayer}.
+ */
+type TlsConnectionSecurityOptions = ConnectionSecurityOptions;
+//#endregion
+//#region src/plugins/vars.d.ts
+/**
+ * Lifecycle states of a physical layer (serial port, TCP server/client, UDP socket).
+ */
+declare enum PhysicalLayerState {
+  OPENING = "opening",
+  OPEN = "open",
+  CLOSING = "closing",
+  CLOSED = "closed"
+}
+/**
+ * Lifecycle states of a pipeline layer (a single connection / stream).
+ */
+declare enum PipelineLayerState {
+  CONNECTED = "connected",
+  DESTROYING = "destroying",
+  DESTROYED = "destroyed"
+}
+//#endregion
+//#region src/plugins/abstract-pipeline-layer.d.ts
+/**
+ * Events emitted by {@link AbstractPipelineLayer}.
+ */
+interface AbstractPipelineLayerEvents {
+  /** Raw bytes received from the transport, forwarded to the protocol layer. */
+  data: [data: Buffer];
+  /** The pipeline layer has closed. */
+  close: [];
+  /** A frame was transmitted on the wire. */
+  tx: [buffer: Buffer];
+  /** A raw chunk was received from the transport. */
+  rx: [buffer: Buffer];
+}
+/**
+ * Abstract pipeline layer that owns a single connection / stream.
+ *
+ * Pipeline layers bridge the physical transport and the protocol layer:
+ * they emit `data` events carrying raw bytes and expose `write` for outbound
+ * frames. Implementations are transport-specific (serial, TCP, UDP).
+ */
+declare abstract class AbstractPipelineLayer extends EventEmitter<AbstractPipelineLayerEvents> {
+  /** Current lifecycle state of the pipeline. */
+  abstract readonly state: PipelineLayerState;
+  /**
+   * Write a raw frame to the transport.
+   *
+   * @param data Encoded frame bytes (unit: byte). Must not be modified.
+   * @param cb Optional callback invoked on completion or error.
+   * @returns `void`.
+   */
+  abstract write(data: Buffer, cb?: (err: Error | null) => void): void;
+  /**
+   * Tear down the pipeline.
+   *
+   * @param cb Optional callback invoked once the layer is destroyed.
+   * @returns `void`.
+   */
+  abstract destroy(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/abstract-physical-layer.d.ts
+/**
+ * Events emitted by {@link AbstractPhysicalLayer}.
+ */
+interface AbstractPhysicalLayerEvents {
+  /** The physical layer is open and ready to accept connections. */
+  open: [];
+  /** A new pipeline connection has been established. */
+  connect: [pipeline: AbstractPipelineLayer];
+  /**
+   * A TCP connection or UDP peer was rejected by a security or resource-limit
+   * policy.
+   */
+  connectionRejected: [event: {
+    /** Policy that caused the rejection. */reason: 'whitelist' | 'max_connections' | 'max_connections_per_ip'; /** Canonicalized remote IP address. */
+    address: string; /** Remote port; present for UDP peers and optionally for TCP connections. */
+    port?: number;
+  }];
+  /** The physical layer has closed. */
+  close: [];
+  /** A non-fatal transport error occurred. */
+  error: [error: Error];
+}
+/**
+ * Abstract physical layer that manages the lifecycle of a transport endpoint.
+ *
+ * Subclasses open a serial port, TCP client/server socket, or UDP socket and
+ * emit {@link AbstractPipelineLayer} instances through the `connect` event.
+ */
+declare abstract class AbstractPhysicalLayer extends EventEmitter<AbstractPhysicalLayerEvents> {
+  /** Current lifecycle state of the physical layer. */
+  abstract readonly state: PhysicalLayerState;
+  /**
+   * Open the transport endpoint.
+   *
+   * @param args Transport-specific open arguments (port path, listen options, etc.).
+   * @returns `void`.
+   */
+  abstract open(...args: any[]): void;
+  /**
+   * Close the transport endpoint.
+   *
+   * @param cb Optional callback invoked once the layer is closed.
+   * @returns `void`.
+   */
+  abstract close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/serial/serial-physical-layer.d.ts
+/**
+ * Construction-time configuration for {@link SerialPhysicalLayer}.
+ *
+ * Forwarded almost verbatim to `node-serialport`; the per-field doc strings
+ * mirror the upstream `OpenOptions` semantics so users do not have to cross-
+ * reference two manuals. The path / baudRate pair is the only required
+ * tuple — every other field has a hardware-safe default.
+ */
+interface SerialPhysicalLayerOptions {
+  /** The system path of the serial port you want to open. For example, `/dev/tty.XXX` on Mac/Linux, or `COM1` on Windows */
+  path: string;
+  /**
+   * The baud rate of the port to be opened. This should match one of the commonly available baud rates, such as 110, 300, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600, or 115200. Custom rates are supported best effort per platform. The device connected to the serial port is not guaranteed to support the requested baud rate, even if the port itself supports that baud rate.
+   */
+  baudRate: number;
+  /** Must be one of these: 5, 6, 7, or 8. Defaults to 8 */
+  dataBits?: 5 | 6 | 7 | 8;
+  /** Prevent other processes from opening the port. Windows does not currently support `false`. Defaults to true */
+  lock?: boolean;
+  /** Must be 1, 1.5 or 2. Defaults to 1 */
+  stopBits?: 1 | 1.5 | 2;
+  /** Device parity. Defaults to none */
+  parity?: 'none' | 'even' | 'odd' | 'mark' | 'space';
+  /** Flow control Setting. Defaults to false */
+  rtscts?: boolean;
+  /** Flow control Setting. Defaults to false */
+  xon?: boolean;
+  /** Flow control Setting. Defaults to false */
+  xoff?: boolean;
+  /** Flow control Setting. Defaults to false */
+  xany?: boolean;
+  /** drop DTR on close. Defaults to true */
+  hupcl?: boolean;
+  /** The size of the read and write buffers. Defaults to 64k */
+  highWaterMark?: number;
+  /** Emit 'end' on port close. Defaults to false */
+  endOnClose?: boolean;
+  /** see `man termios`. Defaults to 1 (Darwin/Linux only) */
+  vmin?: number;
+  /** see `man termios`. Defaults to 0 (Darwin/Linux only) */
+  vtime?: number;
+  /** RTS mode. Defaults to handshake (Windows only) */
+  rtsMode?: 'handshake' | 'enable' | 'toggle';
+}
+/**
+ * Serial pipeline layer backed by a `node-serialport` `SerialPort`.
+ *
+ * Buffers writes so that only one `SerialPort.write`+`drain` cycle is in
+ * flight at a time, matching the half-duplex expectations of Modbus RTU/ASCII.
+ */
+declare class SerialPipelineLayer extends AbstractPipelineLayer {
+  private _state;
+  private _physicalLayer;
+  private _serialport;
+  private _isDraining;
+  private _writeDataQueue;
+  private _writeCbQueue;
+  private _pendingDestroyCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this pipeline. */
+  get state(): PipelineLayerState;
+  /** Parent physical layer that created this pipeline. */
+  get physicalLayer(): AbstractPhysicalLayer;
+  /** Underlying `SerialPort` instance. */
+  get serialport(): SerialPort;
+  /**
+   * @param physicalLayer Parent physical layer.
+   * @param serialport Opened `SerialPort` instance.
+   */
+  constructor(physicalLayer: SerialPhysicalLayer, serialport: SerialPort);
+  /**
+   * Write a frame to the serial port.
+   *
+   * Writes are serialized so that each frame is fully drained before the next
+   * one starts.
+   *
+   * @param data Encoded frame bytes (unit: byte).
+   * @param cb Optional callback invoked once the write (and drain) completes.
+   * @returns `void`.
+   */
+  write(data: Buffer, cb?: (err: Error | null) => void): void;
+  private _executeWrite;
+  private _next;
+  private _flushQueueWithError;
+  /**
+   * Close the underlying serial port and tear down the pipeline.
+   *
+   * @param cb Optional callback invoked once the port is closed.
+   * @returns `void`.
+   */
+  destroy(cb?: (err: Error | null) => void): void;
+}
+/**
+ * Serial physical layer that opens a `node-serialport` port and emits a
+ * single {@link SerialPipelineLayer} on `connect`.
+ */
+declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
+  private _state;
+  private _pipelines;
+  private _serialport;
+  private _serialportOpts;
+  private _path;
+  private _baudRate;
+  private _pendingOpenCbs;
+  private _pendingCloseCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this physical layer. */
+  get state(): PhysicalLayerState;
+  /** Underlying `SerialPort` instance when open, otherwise `null`. */
+  get serialport(): SerialPort | null;
+  /** System path of the serial port (e.g., `/dev/ttyUSB0`). */
+  get path(): string;
+  /** Configured baud rate. */
+  get baudRate(): number;
+  /**
+   * @param options Serial port open options.
+   */
+  constructor(options: SerialPhysicalLayerOptions);
+  /**
+   * Open the serial port.
+   *
+   * @param cb Optional callback invoked once the port is open.
+   * @returns `void`.
+   */
+  open(cb?: (err: Error | null) => void): void;
+  /**
+   * Close the serial port and destroy any associated pipelines.
+   *
+   * @param cb Optional callback invoked once the port is closed.
+   * @returns `void`.
+   */
+  close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/tcp/tcp-pipeline-layer.d.ts
+/**
+ * TCP pipeline layer backed by a `node:net` `Socket`.
+ *
+ * Forwards `data` events from the socket and emits `tx` after a successful
+ * `socket.write`. An optional `idleTimeout` destroys the pipeline after the
+ * specified milliseconds with no received data.
+ */
+declare class TcpPipelineLayer extends AbstractPipelineLayer {
+  private _state;
+  private _physicalLayer;
+  private _socket;
+  private _idleTid;
+  private _pendingDestroyCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this pipeline. */
+  get state(): PipelineLayerState;
+  /** Parent physical layer that created this pipeline. */
+  get physicalLayer(): AbstractPhysicalLayer;
+  /** Underlying `Socket` instance. */
+  get socket(): Socket;
+  /**
+   * @param physicalLayer Parent physical layer.
+   * @param socket Connected `Socket` instance.
+   * @param idleTimeout Optional inactivity timeout (unit: ms). `0` disables the
+   *   timer.
+   */
+  constructor(physicalLayer: AbstractPhysicalLayer, socket: Socket, idleTimeout?: number);
+  /**
+   * Write a frame to the TCP socket.
+   *
+   * @param data Encoded frame bytes (unit: byte).
+   * @param cb Optional callback invoked once the write completes.
+   * @returns `void`.
+   */
+  write(data: Buffer, cb?: (err: Error | null) => void): void;
+  /**
+   * Destroy the underlying socket and tear down the pipeline.
+   *
+   * @param cb Optional callback invoked once the layer is destroyed.
+   * @returns `void`.
+   */
+  destroy(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/tcp/tcp-client-physical-layer.d.ts
+/**
+ * TCP client physical layer.
+ *
+ * Opens a `node:net` socket to a remote host and emits a {@link TcpPipelineLayer}
+ * on `connect`.
+ */
+declare class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
+  private _state;
+  private _pipelines;
+  private _socket;
+  private _socketOpts?;
+  private _pendingOpenCbs;
+  private _pendingCloseCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this physical layer. */
+  get state(): PhysicalLayerState;
+  /** Underlying `Socket` instance when connected, otherwise `null`. */
+  get socket(): Socket | null;
+  /**
+   * @param options Optional `Socket` constructor options.
+   */
+  constructor(options?: SocketConstructorOpts);
+  /**
+   * Connect to a remote Modbus TCP endpoint.
+   *
+   * @param options Connection target (`host` and `port`). Port defaults to `502`
+   *   (unit: port number).
+   * @param cb Optional callback invoked once the socket connects.
+   * @returns `void`.
+   */
+  open(options: SocketConnectOpts, cb?: (err: Error | null) => void): void;
+  /**
+   * Close the socket and destroy any associated pipelines.
+   *
+   * @param cb Optional callback invoked once the layer is closed.
+   * @returns `void`.
+   */
+  close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/tcp/tcp-server-physical-layer.d.ts
+/**
+ * TCP server physical layer.
+ *
+ * Listens on a local port and emits a {@link TcpPipelineLayer} for every
+ * incoming connection.
+ */
+declare class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
+  private _state;
+  private _pipelines;
+  private _server;
+  private _serverOpts?;
+  private _whitelist;
+  private _maxConnections;
+  private _maxConnectionsPerIp;
+  private _idleTimeout;
+  private _pipelinesByIp;
+  private _pendingOpenCbs;
+  private _pendingCloseCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this physical layer. */
+  get state(): PhysicalLayerState;
+  /** Underlying `Server` instance when listening, otherwise `null`. */
+  get server(): Server | null;
+  /**
+   * @param options Optional `Server` constructor options.
+   * @param security Optional security and resource-limit options.
+   */
+  constructor(options?: ServerOpts, security?: TcpConnectionSecurityOptions);
+  /**
+   * Start listening for incoming Modbus TCP connections.
+   *
+   * @param options Listen options. Port defaults to `502` (unit: port number).
+   * @param cb Optional callback invoked once the server is listening.
+   * @returns `void`.
+   */
+  open(options: ListenOptions, cb?: (err: Error | null) => void): void;
+  /**
+   * Close the server and destroy any active connection pipelines.
+   *
+   * @param cb Optional callback invoked once the server is closed.
+   * @returns `void`.
+   */
+  close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/tls/tls-pipeline-layer.d.ts
+/**
+ * TLS pipeline layer backed by a `node:tls` `TLSSocket`.
+ *
+ * Forwards `data` events from the TLS socket and emits `tx` after a successful
+ * `socket.write`. An optional `idleTimeout` destroys the pipeline after the
+ * specified milliseconds with no received data.
+ */
+declare class TlsPipelineLayer extends AbstractPipelineLayer {
+  private _state;
+  private _physicalLayer;
+  private _socket;
+  private _idleTid;
+  private _pendingDestroyCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this pipeline. */
+  get state(): PipelineLayerState;
+  /** Parent physical layer that created this pipeline. */
+  get physicalLayer(): AbstractPhysicalLayer;
+  /** Underlying `TLSSocket` instance. */
+  get socket(): TLSSocket;
+  /**
+   * @param physicalLayer Parent physical layer.
+   * @param socket Connected `TLSSocket` instance.
+   * @param idleTimeout Optional inactivity timeout (unit: ms). `0` disables the
+   *   timer.
+   */
+  constructor(physicalLayer: AbstractPhysicalLayer, socket: TLSSocket, idleTimeout?: number);
+  /**
+   * Write a frame to the TLS socket.
+   *
+   * @param data Encoded frame bytes (unit: byte).
+   * @param cb Optional callback invoked once the write completes.
+   * @returns `void`.
+   */
+  write(data: Buffer, cb?: (err: Error | null) => void): void;
+  /**
+   * Destroy the underlying TLS socket and tear down the pipeline.
+   *
+   * @param cb Optional callback invoked once the layer is destroyed.
+   * @returns `void`.
+   */
+  destroy(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/tls/tls-client-physical-layer.d.ts
+/**
+ * TLS client physical layer.
+ *
+ * Opens a `node:tls` connection to a remote host and emits a {@link TlsPipelineLayer}
+ * on `secureConnect`.
+ */
+declare class TlsClientPhysicalLayer extends AbstractPhysicalLayer {
+  private _state;
+  private _pipelines;
+  private _socket;
+  private _tlsOpts?;
+  private _pendingOpenCbs;
+  private _pendingCloseCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this physical layer. */
+  get state(): PhysicalLayerState;
+  /** Underlying `TLSSocket` instance when connected, otherwise `null`. */
+  get socket(): TLSSocket | null;
+  /**
+   * @param options Optional TLS context options (cert/key/ca/etc.).
+   */
+  constructor(options?: SecureContextOptions & CommonConnectionOptions);
+  /**
+   * Connect to a remote Modbus TLS endpoint.
+   *
+   * @param options Connection target (`host` and `port`) merged with the
+   *   constructor TLS options. Port defaults to `502` (unit: port number).
+   * @param cb Optional callback invoked once the TLS handshake completes.
+   * @returns `void`.
+   */
+  open(options: ConnectionOptions, cb?: (err: Error | null) => void): void;
+  /**
+   * Close the TLS socket and destroy any associated pipelines.
+   *
+   * @param cb Optional callback invoked once the layer is closed.
+   * @returns `void`.
+   */
+  close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/tls/tls-server-physical-layer.d.ts
+/**
+ * TLS server physical layer.
+ *
+ * Listens on a local port and emits a {@link TlsPipelineLayer} for every
+ * incoming TLS connection after the handshake succeeds.
+ */
+declare class TlsServerPhysicalLayer extends AbstractPhysicalLayer {
+  private _state;
+  private _pipelines;
+  private _server;
+  private _tlsOpts?;
+  private _whitelist;
+  private _maxConnections;
+  private _maxConnectionsPerIp;
+  private _idleTimeout;
+  private _pipelinesByIp;
+  private _pendingOpenCbs;
+  private _pendingCloseCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this physical layer. */
+  get state(): PhysicalLayerState;
+  /** Underlying `Server` instance when listening, otherwise `null`. */
+  get server(): Server$1 | null;
+  /**
+   * @param options Optional TLS context options for `tls.createServer`.
+   * @param security Optional security and resource-limit options.
+   */
+  constructor(options?: TlsOptions, security?: TlsConnectionSecurityOptions);
+  /**
+   * Start listening for incoming Modbus TLS connections.
+   *
+   * @param options Listen options. Port defaults to `502` (unit: port number).
+   * @param cb Optional callback invoked once the server is listening.
+   * @returns `void`.
+   */
+  open(options: ListenOptions, cb?: (err: Error | null) => void): void;
+  /**
+   * Close the server and destroy any active connection pipelines.
+   *
+   * @param cb Optional callback invoked once the server is closed.
+   * @returns `void`.
+   */
+  close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/udp/udp-client-physical-layer.d.ts
+/**
+ * UDP client pipeline layer backed by a connected `node:dgram` `Socket`.
+ *
+ * Emits `data` for incoming datagrams and `tx` after a successful `send`.
+ */
+declare class UdpClientPipelineLayer extends AbstractPipelineLayer {
+  private _state;
+  private _physicalLayer;
+  private _socket;
+  private _pendingDestroyCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this pipeline. */
+  get state(): PipelineLayerState;
+  /** Parent physical layer that created this pipeline. */
+  get physicalLayer(): AbstractPhysicalLayer;
+  /** Underlying `Socket` instance. */
+  get socket(): Socket$1;
+  /**
+   * @param physicalLayer Parent physical layer.
+   * @param socket Connected UDP `Socket` instance.
+   */
+  constructor(physicalLayer: UdpClientPhysicalLayer, socket: Socket$1);
+  /**
+   * Send a frame through the connected UDP socket.
+   *
+   * @param data Encoded frame bytes (unit: byte).
+   * @param cb Optional callback invoked once the datagram is sent.
+   * @returns `void`.
+   */
+  write(data: Buffer, cb?: (err: Error | null) => void): void;
+  /**
+   * Close the UDP socket and tear down the pipeline.
+   *
+   * @param cb Optional callback invoked once the socket is closed.
+   * @returns `void`.
+   */
+  destroy(cb?: (err: Error | null) => void): void;
+}
+/**
+ * UDP client physical layer.
+ *
+ * Binds a local UDP socket, connects it to a remote endpoint, and emits a
+ * {@link UdpClientPipelineLayer} on `connect`.
+ */
+declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
+  private _state;
+  private _pipelines;
+  private _socket;
+  private _socketOpts;
+  private _pendingOpenCbs;
+  private _pendingCloseCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this physical layer. */
+  get state(): PhysicalLayerState;
+  /** Underlying `Socket` instance when open, otherwise `null`. */
+  get socket(): Socket$1 | null;
+  /**
+   * @param options Optional `SocketOptions`. Defaults to `udp4`.
+   */
+  constructor(options?: Partial<SocketOptions>);
+  /**
+   * Open a connected UDP socket to a remote Modbus endpoint.
+   *
+   * @param remote Remote endpoint (`address` and `port`). Port defaults to `502`
+   *   (unit: port number).
+   * @param cb Optional callback invoked once the socket is bound and connected.
+   * @returns `void`.
+   */
+  open(remote: {
+    port?: number;
+    address?: string;
+  }, cb?: (err?: Error | null) => void): void;
+  /**
+   * Close the UDP socket and destroy any associated pipelines.
+   *
+   * @param cb Optional callback invoked once the layer is closed.
+   * @returns `void`.
+   */
+  close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/plugins/udp/udp-server-physical-layer.d.ts
+/**
+ * UDP server-side pipeline layer representing one remote peer.
+ *
+ * Created by {@link UdpServerPhysicalLayer} for each unique remote address;
+ * destroyed automatically after `idleTimeout` ms with no traffic.
+ */
+declare class UdpServerPipelineLayer extends AbstractPipelineLayer {
+  private _state;
+  private _physicalLayer;
+  private _socket;
+  private _remote;
+  private _idleTid;
+  private _cleanupFns;
+  /** Current lifecycle state of this pipeline. */
+  get state(): PipelineLayerState;
+  /** Parent physical layer that created this pipeline. */
+  get physicalLayer(): AbstractPhysicalLayer;
+  /** Underlying shared UDP `Socket` instance. */
+  get socket(): Socket$1;
+  /** Remote peer address information. */
+  get remote(): RemoteInfo;
+  /**
+   * @param physicalLayer Parent physical layer.
+   * @param socket Shared UDP `Socket` instance.
+   * @param remote Remote peer information.
+   * @param idleTimeout Inactivity timeout (unit: ms); `0` disables the timer.
+   * @param messageEventDelegation Hook for subscribing to datagrams scoped to this peer.
+   */
+  constructor(physicalLayer: UdpServerPhysicalLayer, socket: Socket$1, remote: RemoteInfo, idleTimeout: number, messageEventDelegation: {
+    add: (listener: (msg: Buffer, rinfo: RemoteInfo) => void) => void;
+    remove: (listener: (...args: any[]) => void) => void;
+  });
+  /**
+   * Send a frame to the remote peer.
+   *
+   * @param data Encoded frame bytes (unit: byte).
+   * @param cb Optional callback invoked once the datagram is sent.
+   * @returns `void`.
+   */
+  write(data: Buffer, cb?: (err: Error | null) => void): void;
+  /**
+   * Tear down this peer pipeline and stop the idle timer.
+   *
+   * @param cb Optional callback invoked once the pipeline is destroyed.
+   * @returns `void`.
+   */
+  destroy(cb?: (err: Error | null) => void): void;
+}
+/**
+ * UDP server physical layer.
+ *
+ * Binds a UDP socket, creates a {@link UdpServerPipelineLayer} for every
+ * unique remote peer, and emits it through the `connect` event.
+ */
+declare class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
+  private _state;
+  private _pipelines;
+  private _socket;
+  private _socketOpts;
+  private _whitelist;
+  private _maxConnections;
+  private _maxConnectionsPerIp;
+  private _idleTimeout;
+  private _pipelinesByIp;
+  private _pendingOpenCbs;
+  private _pendingCloseCbs;
+  private _cleanupFns;
+  /** Current lifecycle state of this physical layer. */
+  get state(): PhysicalLayerState;
+  /** Underlying `Socket` instance when bound, otherwise `null`. */
+  get socket(): Socket$1 | null;
+  /**
+   * @param options Optional `SocketOptions`. Defaults to `udp4`.
+   * @param security Optional security and resource-limit options.
+   */
+  constructor(options?: SocketOptions, security?: UdpConnectionSecurityOptions);
+  /**
+   * Bind the UDP socket and start accepting datagrams from remote peers.
+   *
+   * @param options Bind options. Port defaults to `502` (unit: port number).
+   * @param cb Optional callback invoked once the socket is bound.
+   * @returns `void`.
+   */
+  open(options: BindOptions, cb?: (err: Error | null) => void): void;
+  /**
+   * Close the UDP socket and destroy all peer pipelines.
+   *
+   * @param cb Optional callback invoked once the socket is closed.
+   * @returns `void`.
+   */
+  close(cb?: (err: Error | null) => void): void;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Runtime version string of the installed `njs-modbus` package.
+ *
+ * Resolved from the bundler-injected `__VERSION__` define when present;
+ * falls back to `'1.0.0-dev'` for unbundled source consumption (e.g., CI
+ * tests linking the workspace directly). Useful for client-side telemetry,
+ * version-gated diagnostics, and log lines that need to pin protocol
+ * behaviour to a specific release.
+ */
+declare const NJS_MODBUS_VERSION: string;
+//#endregion
+export { AbstractPhysicalLayer, AbstractPipelineAdapter, AbstractPipelineAdapterEvents, AbstractPipelineLayer, AbstractProtocolLayer, type AccessAuditEvent, type AccessAuditEventType, type AccessAuthorizer, type ApplicationDataUnit, AsciiProtocolLayer, type AsciiProtocolLayerOptions, type ConnectionSecurityOptions, type CustomFunctionCode, type DeviceIdentification, ErrorCode, type FrameErrorEvent, type FrameErrorEventType, FunctionCode, ModbusError, type ModbusFrame, ModbusMaster, type ModbusMasterOptions, type ModbusQueueStrategy, type ModbusResponse, ModbusSlave, type ModbusSlaveOptions, type ModbusUnitModel, NJS_MODBUS_VERSION, PhysicalLayerState, type PipelineFaultEvent, type PipelineFaultEventType, PipelineLayerState, type ProtocolExceptionEvent, type ProtocolExceptionEventType, RtuProtocolLayer, type RtuProtocolLayerOptions, SerialPhysicalLayer, type SerialPhysicalLayerOptions, SerialPipelineLayer, type ServerId, TcpClientPhysicalLayer, type TcpConnectionSecurityOptions, TcpPipelineLayer, TcpProtocolLayer, TcpServerPhysicalLayer, TlsClientPhysicalLayer, type TlsConnectionSecurityOptions, TlsPipelineLayer, TlsServerPhysicalLayer, UdpClientPhysicalLayer, UdpClientPipelineLayer, type UdpConnectionSecurityOptions, UdpServerPhysicalLayer, UdpServerPipelineLayer, UnauthorizedAccessError, type WhitelistEntry, crcFixed as crc, generateAduHashFingerprint, getCodeByError, getErrorByCode, lrc };