@flux-control/effect-modbus-rs 0.1.0

package/dist/src/SerialModbusServerService.d.ts

@@ -0,0 +1,51 @@
+import type { SerialServerOptions, ServerHandlers } from "modbus-rs";
+import { Layer } from "effect";
+import type { ModbusError } from "./errors";
+/**
+ * A scoped {@link Layer} that starts a Modbus serial RTU server.
+ *
+ * @param options - Serial port options (path, baud rate, unit ID, etc.).
+ * @param handlers - Callback functions that handle incoming Modbus requests.
+ * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect";
+ * import { serialRtuServerLayer } from "effect-modbus-rs";
+ *
+ * const ServerLive = serialRtuServerLayer(
+ *   { portPath: "/dev/ttyUSB0", baudRate: 9600, unitId: 1 },
+ *   { onReadCoils: (req) => [false, false] },
+ * );
+ *
+ * Layer.launch(ServerLive).pipe(Effect.runPromise);
+ * ```
+ *
+ * @see SerialServerOptions — Options accepted by the upstream serial server.
+ * @see ServerHandlers — Interface for request handler callbacks.
+ */
+export declare const serialRtuServerLayer: (options: SerialServerOptions, handlers: ServerHandlers) => Layer.Layer<never, ModbusError>;
+/**
+ * A scoped {@link Layer} that starts a Modbus serial ASCII server.
+ *
+ * @param options - Serial port options (path, baud rate, unit ID, etc.).
+ * @param handlers - Callback functions that handle incoming Modbus requests.
+ * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect";
+ * import { serialAsciiServerLayer } from "effect-modbus-rs";
+ *
+ * const ServerLive = serialAsciiServerLayer(
+ *   { portPath: "/dev/ttyUSB0", baudRate: 9600, unitId: 1 },
+ *   { onReadCoils: (req) => [false, false] },
+ * );
+ *
+ * Layer.launch(ServerLive).pipe(Effect.runPromise);
+ * ```
+ *
+ * @see SerialServerOptions — Options accepted by the upstream serial server.
+ * @see ServerHandlers — Interface for request handler callbacks.
+ */
+export declare const serialAsciiServerLayer: (options: SerialServerOptions, handlers: ServerHandlers) => Layer.Layer<never, ModbusError>;

package/dist/src/SerialTransportService.d.ts

@@ -0,0 +1,45 @@
+import { Context, Layer } from "effect";
+import type { AsciiTransportOptions, RtuTransportOptions } from "modbus-rs";
+import type { TransportServiceApi } from "./shared-transport";
+import { type SlaveDeviceDefinitions } from "./mocks";
+declare const SerialTransportService_base: Context.TagClass<SerialTransportService, "SerialTransportService", TransportServiceApi>;
+/**
+ * Abstract serial Modbus transport service tag.
+ *
+ * Represents a serial (RS-232/485) Modbus transport backed by either
+ * ASCII or RTU framing.  Use this tag when you need a serial transport
+ * but don't care about the specific framing protocol.
+ *
+ * Consumers `yield* SerialTransportService` to obtain a
+ * {@link TransportServiceApi} and satisfy the tag via one of the static
+ * provider methods:
+ *
+ * ```ts
+ * // Provide with ASCII framing
+ * Layer.provide(SerialTransportService.fromAscii({ path: "/dev/ttyUSB0", baudRate: 9600 }))
+ *
+ * // Provide with RTU framing
+ * Layer.provide(SerialTransportService.fromRtu({ path: "/dev/ttyUSB0", baudRate: 9600 }))
+ * ```
+ */
+export declare class SerialTransportService extends SerialTransportService_base {
+    /**
+     * Creates a {@link Layer} providing {@link SerialTransportService}
+     * backed by an ASCII transport.
+     */
+    static fromAscii(options: AsciiTransportOptions): Layer.Layer<SerialTransportService>;
+    /**
+     * Creates a {@link Layer} providing {@link SerialTransportService}
+     * backed by an RTU transport.
+     */
+    static fromRtu(options: RtuTransportOptions): Layer.Layer<SerialTransportService>;
+    /**
+     * Creates a mock {@link Layer} providing {@link SerialTransportService}
+     * for testing or development.
+     *
+     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * simulated Modbus slaves and their register/coil maps.
+     */
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: AsciiTransportOptions | RtuTransportOptions) => Layer.Layer<SerialTransportService>;
+}
+export {};

package/dist/src/TcpGatewayService.d.ts

@@ -0,0 +1,42 @@
+import type { GatewayBindOptions, GatewayConfig } from "modbus-rs";
+import { Layer } from "effect";
+import type { ModbusError } from "./errors";
+/**
+ * A scoped {@link Layer} that starts a Modbus TCP gateway.
+ *
+ * The gateway binds to the specified host and port, forwarding incoming
+ * Modbus requests to downstream servers based on unit ID routing defined
+ * in the {@link GatewayConfig}. The gateway is automatically shut down
+ * when the consuming scope finalizes.
+ *
+ * @param options - Gateway bind options (host, port).
+ * @param gatewayConfig - Routing configuration with downstream server
+ *   definitions and a unit-ID-to-channel route table.
+ * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect";
+ * import { tcpGatewayLayer } from "effect-modbus-rs";
+ *
+ * const GatewayLive = tcpGatewayLayer(
+ *   { host: "0.0.0.0", port: 8502 },
+ *   {
+ *     downstreams: [
+ *       { host: "192.168.1.10", port: 502 },
+ *       { host: "192.168.1.20", port: 502 },
+ *     ],
+ *     routes: [
+ *       { unitId: 1, channel: 0 },
+ *       { unitId: 2, channel: 1 },
+ *     ],
+ *   },
+ * );
+ *
+ * Layer.launch(GatewayLive).pipe(Effect.runPromise);
+ * ```
+ *
+ * @see GatewayBindOptions — Options for the gateway bind address.
+ * @see GatewayConfig — Configuration for downstream servers and routing.
+ */
+export declare const tcpGatewayLayer: (options: GatewayBindOptions, gatewayConfig: GatewayConfig) => Layer.Layer<never, ModbusError>;

package/dist/src/TcpModbusServerService.d.ts

@@ -0,0 +1,31 @@
+import type { ServerHandlers, TcpServerOptions } from "modbus-rs";
+import { Layer } from "effect";
+import type { ModbusError } from "./errors";
+/**
+ * A scoped {@link Layer} that starts a Modbus TCP server.
+ *
+ * The server binds to the specified host and port, handling incoming
+ * Modbus requests via the provided {@link ServerHandlers}. The connection
+ * is automatically shut down when the consuming scope finalizes.
+ *
+ * @param options - Server bind options (host, port, unit ID).
+ * @param handlers - Callback functions that handle incoming Modbus requests.
+ * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect";
+ * import { tcpServerLayer } from "effect-modbus-rs";
+ *
+ * const ServerLive = tcpServerLayer(
+ *   { host: "0.0.0.0", port: 502, unitId: 1 },
+ *   { onReadCoils: (req) => [false, false] },
+ * );
+ *
+ * Layer.launch(ServerLive).pipe(Effect.runPromise);
+ * ```
+ *
+ * @see TcpServerOptions — Options accepted by the upstream TCP server.
+ * @see ServerHandlers — Interface for request handler callbacks.
+ */
+export declare const tcpServerLayer: (options: TcpServerOptions, handlers: ServerHandlers) => Layer.Layer<never, ModbusError>;

package/dist/src/TcpTransportService.d.ts

@@ -0,0 +1,46 @@
+import type { TcpTransportOptions } from "modbus-rs";
+import { Effect, Layer } from "effect";
+import { SlaveDeviceDefinitions } from "./mocks";
+declare const TcpTransportService_base: Effect.Service.Class<TcpTransportService, "TcpTransportService", {
+    readonly scoped: (options: TcpTransportOptions) => Effect.Effect<{
+        withClient: (unitId: number) => Effect.Effect<import("./modbus-client").EffectModbusClient, import("./errors").ModbusError, never>;
+        setRequestTimeout: (timeoutMs: number) => Effect.Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
+        clearRequestTimeout: () => Effect.Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
+        reconnect: () => Effect.Effect<undefined, import("./errors").ModbusError, never>;
+        close: () => Effect.Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
+        hasPendingRequests: () => boolean;
+    }, never, import("effect/Scope").Scope>;
+}>;
+/**
+ * Scoped Effect service wrapping the `modbus-rs` {@link AsyncTcpTransport}
+ * for TCP/IP Modbus communication.
+ *
+ * The transport connection is opened lazily on the first call to
+ * `withClient(unitId)` and automatically closed when the consuming
+ * {@link Effect.Scope | Scope} finalizes.
+ *
+ * Clients are created per `unitId` via
+ * {@link AsyncTcpTransport.createClient} and cached, so repeated
+ * requests for the same unit ID reuse the same client.
+ *
+ * @see AsyncTcpTransport — Upstream `modbus-rs` TCP transport.
+ * @see TcpTransportOptions — Configuration for the TCP connection.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class TcpTransportService extends TcpTransportService_base {
+    /**
+     * Creates a {@link Layer} providing an in-memory mock
+     * {@link TcpTransportService} for testing or development.
+     *
+     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * simulated Modbus slaves and their register/coil maps.
+     *
+     * @param devices - Slave device definitions for the mock.
+     * @returns A function that takes {@link TcpTransportOptions} and
+     *          returns a scoped {@link Layer} providing the mock service.
+     *
+     * @see makeMockTransport — The underlying mock factory.
+     */
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: TcpTransportOptions) => Layer.Layer<TcpTransportService, never, never>;
+}
+export {};

package/dist/src/errors.d.ts

@@ -0,0 +1,170 @@
+declare const ModbusExceptionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ModbusExceptionError";
+} & Readonly<A>;
+/**
+ * Error originating from a Modbus protocol exception response.
+ *
+ * Mapped from {@link ModbusErrorCode.EXCEPTION} via `modbus-rs`.
+ * The {@link exception} field holds the Modbus exception code
+ * (e.g. 1 = ILLEGAL_FUNCTION, 2 = ILLEGAL_DATA_ADDRESS, 3 = ILLEGAL_DATA_VALUE).
+ *
+ * @see ModbusErrorCode.EXCEPTION — `modbus-rs` error code that triggers this error.
+ */
+export declare class ModbusExceptionError extends ModbusExceptionError_base<{
+    /** Original error thrown by `modbus-rs`. */
+    readonly cause: Error;
+    /** Parsed Modbus exception code extracted from the error message. */
+    readonly exception: number;
+    /** Error message from the underlying `modbus-rs` error. */
+    readonly message: string;
+}> {
+}
+declare const ModbusTimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ModbusTimeoutError";
+} & Readonly<A>;
+/**
+ * Error indicating a request timed out while waiting for a response.
+ *
+ * Mapped from {@link ModbusErrorCode.TIMEOUT} via `modbus-rs`.
+ * Adjust timeouts via `setRequestTimeout` on the transport, or configure
+ * with {@link RtuTransportOptions.requestTimeoutMs | requestTimeoutMs} /
+ * {@link RtuTransportOptions.responseTimeoutMs | responseTimeoutMs}.
+ *
+ * @see ModbusErrorCode.TIMEOUT — `modbus-rs` error code that triggers this error.
+ */
+export declare class ModbusTimeoutError extends ModbusTimeoutError_base<{
+    /** Original error thrown by `modbus-rs`. */
+    readonly cause: Error;
+    /** Error message from the underlying `modbus-rs` error. */
+    readonly message: string;
+}> {
+}
+declare const ModbusTransportError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ModbusTransportError";
+} & Readonly<A>;
+/**
+ * Error indicating a transport-level failure (framing, CRC, or I/O error).
+ *
+ * Mapped from {@link ModbusErrorCode.TRANSPORT} via `modbus-rs`.
+ * Common causes: serial port issues, wiring problems, or baud rate mismatch.
+ *
+ * @see ModbusErrorCode.TRANSPORT — `modbus-rs` error code that triggers this error.
+ */
+export declare class ModbusTransportError extends ModbusTransportError_base<{
+    /** Original error thrown by `modbus-rs`. */
+    readonly cause: Error;
+    /** Error message from the underlying `modbus-rs` error. */
+    readonly message: string;
+}> {
+}
+declare const ModbusInvalidArgumentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ModbusInvalidArgumentError";
+} & Readonly<A>;
+/**
+ * Error indicating an invalid argument was passed to a Modbus API call.
+ *
+ * Mapped from {@link ModbusErrorCode.INVALID_ARGUMENT} via `modbus-rs`.
+ * Typically thrown when register/coil addresses or quantities are out of range.
+ *
+ * @see ModbusErrorCode.INVALID_ARGUMENT — `modbus-rs` error code that triggers this error.
+ */
+export declare class ModbusInvalidArgumentError extends ModbusInvalidArgumentError_base<{
+    /** Original error thrown by `modbus-rs`. */
+    readonly cause: Error;
+    /** Error message from the underlying `modbus-rs` error. */
+    readonly message: string;
+}> {
+}
+declare const ModbusConnectionClosedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ModbusConnectionClosedError";
+} & Readonly<A>;
+/**
+ * Error indicating the transport connection was closed unexpectedly.
+ *
+ * Mapped from {@link ModbusErrorCode.CONNECTION_CLOSED} via `modbus-rs`.
+ * The transport can be re-established using `reconnect()` on the transport service.
+ *
+ * @see ModbusErrorCode.CONNECTION_CLOSED — `modbus-rs` error code that triggers this error.
+ */
+export declare class ModbusConnectionClosedError extends ModbusConnectionClosedError_base<{
+    /** Original error thrown by `modbus-rs`. */
+    readonly cause: Error;
+    /** Error message from the underlying `modbus-rs` error. */
+    readonly message: string;
+}> {
+}
+declare const ModbusInternalError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ModbusInternalError";
+} & Readonly<A>;
+/**
+ * Error indicating an internal library error not covered by other categories.
+ *
+ * Mapped from any unrecognized error code returned by
+ * {@link getModbusErrorCode} (acts as the catch-all fallback).
+ *
+ * @see ModbusErrorCode.INTERNAL — `modbus-rs` error code for internal failures.
+ */
+export declare class ModbusInternalError extends ModbusInternalError_base<{
+    /** Original error thrown by `modbus-rs`. */
+    readonly cause: Error;
+    /** Error message from the underlying `modbus-rs` error. */
+    readonly message: string;
+}> {
+}
+declare const ModbusNotConnectedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ModbusNotConnectedError";
+} & Readonly<A>;
+/**
+ * Error indicating a transport operation was attempted before the
+ * connection was established or after it was closed.
+ *
+ * This is a **local** error — it is never returned by `modbus-rs`.
+ * It is thrown by the transport service when `setRequestTimeout`,
+ * `clearRequestTimeout`, or `withClient` is called before a
+ * successful connection.
+ *
+ * Connect by calling `withClient(unitId)` on the transport service.
+ * The connection is established lazily on the first call.
+ *
+ * @see ModbusNotConnectedError — Triggered when the transport is null.
+ */
+export declare class ModbusNotConnectedError extends ModbusNotConnectedError_base<{
+    /** The original cause (typically a descriptive error). */
+    readonly cause: Error;
+    /** Human-readable explanation of the error. */
+    readonly message: string;
+}> {
+}
+/**
+ * Union of all typed Modbus errors emitted by this library.
+ *
+ * Handle with {@linkcode Effect.catchTags}:
+ *
+ * ```ts
+ * Effect.catchTags(client.readHoldingRegisters({ address: 0, quantity: 10 }), {
+ *   ModbusTimeoutError: () => ...,
+ *   ModbusTransportError: () => ...,
+ *   ModbusExceptionError: (e) => ...,
+ * })
+ * ```
+ *
+ * Each variant maps to a specific {@link ModbusErrorCode} from `modbus-rs`.
+ *
+ * @see ModbusErrorCode — The upstream error code enum driving this mapping.
+ */
+export type ModbusError = ModbusExceptionError | ModbusTimeoutError | ModbusTransportError | ModbusInvalidArgumentError | ModbusConnectionClosedError | ModbusNotConnectedError | ModbusInternalError;
+/**
+ * Converts a raw `Error` from `modbus-rs` into a typed {@link ModbusError}.
+ *
+ * Uses {@link getModbusErrorCode} to classify the error by its internal
+ * error code, then constructs the appropriate `Data.TaggedError` variant.
+ * Unknown/unrecognized codes fall through to {@link ModbusInternalError}.
+ *
+ * @param cause - The raw `Error` thrown by a `modbus-rs` API call.
+ * @returns A typed `ModbusError` variant matching the error code.
+ *
+ * @see getModbusErrorCode — Upstream function that extracts the error discriminant.
+ * @see ModbusErrorCode — Enum of possible error codes.
+ */
+export declare const toModbusError: (cause: Error) => ModbusError;
+export {};

package/dist/src/mocks.d.ts

@@ -0,0 +1,134 @@
+import { Effect, Schema } from "effect";
+import type { AsciiTransportOptions, RtuTransportOptions, TcpTransportOptions } from "modbus-rs";
+import { ModbusInvalidArgumentError, type ModbusError } from "./errors";
+import type { EffectModbusClient } from "./modbus-client";
+/**
+ * Schema for a single coil (digital output) definition.
+ *
+ * Each entry declares a coil's address and its default boolean state
+ * used when the mock transport initialises.
+ */
+export declare const CoilDefinition: Schema.Struct<{
+    address: typeof Schema.Number;
+    default: typeof Schema.Boolean;
+}>;
+/**
+ * Schema for a single discrete input (digital input) definition.
+ *
+ * Each entry declares a discrete input's address and its default
+ * boolean state used when the mock transport initialises.
+ */
+export declare const DiscreteInputDefinition: Schema.Struct<{
+    address: typeof Schema.Number;
+    default: typeof Schema.Boolean;
+}>;
+/**
+ * Schema for a single register (holding or input) definition.
+ *
+ * Each entry declares a register's address and its default 16-bit
+ * value used when the mock transport initialises.
+ */
+export declare const RegisterDefinition: Schema.Struct<{
+    address: typeof Schema.Number;
+    default: typeof Schema.Number;
+}>;
+/**
+ * Schema for a complete slave device definition.
+ *
+ * Describes a Modbus slave identified by `unitId`, with optional
+ * arrays of coils, discrete inputs, holding registers, and input
+ * registers. All arrays default to `[]` when omitted.
+ */
+export declare const SlaveDeviceDefinition: Schema.Struct<{
+    unitId: typeof Schema.Number;
+    coils: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Boolean;
+    }>>, {
+        default: () => never[];
+    }>;
+    discreteInputs: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Boolean;
+    }>>, {
+        default: () => never[];
+    }>;
+    holdingRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Number;
+    }>>, {
+        default: () => never[];
+    }>;
+    inputRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Number;
+    }>>, {
+        default: () => never[];
+    }>;
+}>;
+/**
+ * Schema for an array of {@link SlaveDeviceDefinition} — the complete
+ * set of slave devices the mock transport should simulate.
+ */
+export declare const SlaveDeviceDefinitions: Schema.Array$<Schema.Struct<{
+    unitId: typeof Schema.Number;
+    coils: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Boolean;
+    }>>, {
+        default: () => never[];
+    }>;
+    discreteInputs: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Boolean;
+    }>>, {
+        default: () => never[];
+    }>;
+    holdingRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Number;
+    }>>, {
+        default: () => never[];
+    }>;
+    inputRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        address: typeof Schema.Number;
+        default: typeof Schema.Number;
+    }>>, {
+        default: () => never[];
+    }>;
+}>>;
+/** Inferred TypeScript type for a {@link CoilDefinition} schema. */
+export type CoilDefinition = Schema.Schema.Type<typeof CoilDefinition>;
+/** Inferred TypeScript type for a {@link DiscreteInputDefinition} schema. */
+export type DiscreteInputDefinition = Schema.Schema.Type<typeof DiscreteInputDefinition>;
+/** Inferred TypeScript type for a {@link RegisterDefinition} schema. */
+export type RegisterDefinition = Schema.Schema.Type<typeof RegisterDefinition>;
+/** Inferred TypeScript type for a {@link SlaveDeviceDefinition} schema. */
+export type SlaveDeviceDefinition = Schema.Schema.Type<typeof SlaveDeviceDefinition>;
+/** Inferred TypeScript type for a {@link SlaveDeviceDefinitions} schema. */
+export type SlaveDeviceDefinitions = Schema.Schema.Type<typeof SlaveDeviceDefinitions>;
+/**
+ * Creates a mock transport factory suitable for use as a `scoped`
+ * {@link Layer} dependency in tests or development.
+ *
+ * Accepts an array of {@link SlaveDeviceDefinition} that describe the
+ * simulated Modbus slaves, their register maps, and coil states.
+ * The returned factory matches the signature expected by the transport
+ * service constructors (`RtuTransportOptions | AsciiTransportOptions |
+ * TcpTransportOptions`) so it can be injected into any service layer.
+ *
+ * Unsupported function codes (FIFO queue, file records) return
+ * {@link ModbusInvalidArgumentError}.
+ *
+ * @param devices - Array of slave device definitions to simulate.
+ * @returns A transport factory function that returns a scoped Effect
+ *          providing the mock transport.
+ */
+export declare const makeMockTransport: (devices: SlaveDeviceDefinitions) => (_options: RtuTransportOptions | AsciiTransportOptions | TcpTransportOptions) => Effect.Effect<{
+    withClient: (unitId: number) => Effect.Effect<EffectModbusClient, ModbusInvalidArgumentError, never>;
+    setRequestTimeout: (_timeoutMs: number) => Effect.Effect<void, never, never>;
+    clearRequestTimeout: () => Effect.Effect<void, never, never>;
+    reconnect: () => Effect.Effect<void, ModbusError, never>;
+    close: () => Effect.Effect<void, ModbusError, never>;
+    hasPendingRequests: () => false;
+}, never, never>;

package/dist/src/mocks.test.d.ts

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