@flux-control/effect-modbus-rs 0.1.0 → 0.2.0

package/dist/src/AsciiTransportService.d.ts

@@ -1,6 +1,6 @@
-import type { AsciiTransportOptions } from "modbus-rs";
-import { Effect, Layer } from "effect";
-import { SlaveDeviceDefinitions } from "./mocks";
+import { Effect, Layer } from 'effect';
+import type { AsciiTransportOptions } from 'modbus-rs';
+import { SlaveDeviceDefinitions } from './mocks';
 declare const AsciiTransportService_base: Effect.Service.Class<AsciiTransportService, "AsciiTransportService", {
     readonly scoped: (options: AsciiTransportOptions) => Effect.Effect<{
         withClient: (unitId: number) => Effect.Effect<import("./modbus-client").EffectModbusClient, import("./errors").ModbusError, never>;

package/dist/src/RtuTransportService.d.ts

@@ -1,6 +1,6 @@
-import type { RtuTransportOptions } from "modbus-rs";
-import { Effect, Layer } from "effect";
-import type { SlaveDeviceDefinitions } from "./mocks";
+import { Effect, Layer } from 'effect';
+import type { RtuTransportOptions } from 'modbus-rs';
+import type { SlaveDeviceDefinitions } from './mocks';
 declare const RtuTransportService_base: Effect.Service.Class<RtuTransportService, "RtuTransportService", {
     readonly scoped: (options: RtuTransportOptions) => Effect.Effect<{
         withClient: (unitId: number) => Effect.Effect<import("./modbus-client").EffectModbusClient, import("./errors").ModbusError, never>;

package/dist/src/SerialModbusServerService.d.ts

@@ -1,6 +1,6 @@
-import type { SerialServerOptions, ServerHandlers } from "modbus-rs";
-import { Layer } from "effect";
-import type { ModbusError } from "./errors";
+import { Layer } from 'effect';
+import type { SerialServerOptions, ServerHandlers } from 'modbus-rs';
+import type { ModbusError } from './errors';
 /**
  * A scoped {@link Layer} that starts a Modbus serial RTU server.
  *
@@ -11,7 +11,7 @@ import type { ModbusError } from "./errors";
  * @example
  * ```ts
  * import { Effect, Layer } from "effect";
- * import { serialRtuServerLayer } from "effect-modbus-rs";
+ * import { serialRtuServerLayer } from "@flux-control/effect-modbus-rs";
  *
  * const ServerLive = serialRtuServerLayer(
  *   { portPath: "/dev/ttyUSB0", baudRate: 9600, unitId: 1 },
@@ -35,7 +35,7 @@ export declare const serialRtuServerLayer: (options: SerialServerOptions, handle
  * @example
  * ```ts
  * import { Effect, Layer } from "effect";
- * import { serialAsciiServerLayer } from "effect-modbus-rs";
+ * import { serialAsciiServerLayer } from "@flux-control/effect-modbus-rs";
  *
  * const ServerLive = serialAsciiServerLayer(
  *   { portPath: "/dev/ttyUSB0", baudRate: 9600, unitId: 1 },

package/dist/src/SerialTransportService.d.ts

@@ -1,7 +1,7 @@
-import { Context, Layer } from "effect";
-import type { AsciiTransportOptions, RtuTransportOptions } from "modbus-rs";
-import type { TransportServiceApi } from "./shared-transport";
-import { type SlaveDeviceDefinitions } from "./mocks";
+import { Context, Layer } from 'effect';
+import type { AsciiTransportOptions, RtuTransportOptions } from 'modbus-rs';
+import { type SlaveDeviceDefinitions } from './mocks';
+import type { TransportServiceApi } from './shared-transport';
 declare const SerialTransportService_base: Context.TagClass<SerialTransportService, "SerialTransportService", TransportServiceApi>;
 /**
  * Abstract serial Modbus transport service tag.

package/dist/src/TcpGatewayService.d.ts

@@ -1,6 +1,6 @@
-import type { GatewayBindOptions, GatewayConfig } from "modbus-rs";
-import { Layer } from "effect";
-import type { ModbusError } from "./errors";
+import { Layer } from 'effect';
+import type { GatewayBindOptions, GatewayConfig } from 'modbus-rs';
+import type { ModbusError } from './errors';
 /**
  * A scoped {@link Layer} that starts a Modbus TCP gateway.
  *
@@ -17,7 +17,7 @@ import type { ModbusError } from "./errors";
  * @example
  * ```ts
  * import { Effect, Layer } from "effect";
- * import { tcpGatewayLayer } from "effect-modbus-rs";
+ * import { tcpGatewayLayer } from "@flux-control/effect-modbus-rs";
  *
  * const GatewayLive = tcpGatewayLayer(
  *   { host: "0.0.0.0", port: 8502 },

package/dist/src/TcpModbusServerService.d.ts

@@ -1,6 +1,6 @@
-import type { ServerHandlers, TcpServerOptions } from "modbus-rs";
-import { Layer } from "effect";
-import type { ModbusError } from "./errors";
+import { Layer } from 'effect';
+import type { ServerHandlers, TcpServerOptions } from 'modbus-rs';
+import type { ModbusError } from './errors';
 /**
  * A scoped {@link Layer} that starts a Modbus TCP server.
  *
@@ -15,7 +15,7 @@ import type { ModbusError } from "./errors";
  * @example
  * ```ts
  * import { Effect, Layer } from "effect";
- * import { tcpServerLayer } from "effect-modbus-rs";
+ * import { tcpServerLayer } from "@flux-control/effect-modbus-rs";
  *
  * const ServerLive = tcpServerLayer(
  *   { host: "0.0.0.0", port: 502, unitId: 1 },

package/dist/src/TcpTransportService.d.ts

@@ -1,6 +1,6 @@
-import type { TcpTransportOptions } from "modbus-rs";
-import { Effect, Layer } from "effect";
-import { SlaveDeviceDefinitions } from "./mocks";
+import { Effect, Layer } from 'effect';
+import type { TcpTransportOptions } from 'modbus-rs';
+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>;

package/dist/src/WasmAsciiTransportService.d.ts

@@ -0,0 +1,56 @@
+import { Effect, Layer } from 'effect';
+import type { WasmSerialPortHandle, WasmSerialTransportOptions } from 'modbus-rs/web';
+import { SlaveDeviceDefinitions } from './mocks';
+/**
+ * Options for {@link WasmAsciiTransportService}. `WasmAsciiTransport.open()` takes the
+ * serial port handle and the connection options as two separate arguments; this
+ * combines them into one object so it fits {@link makeTransportScoped}'s single-options
+ * shape, with `port` destructured back out inside the service's `openMethod`.
+ *
+ * @see requestSerialPort — Obtains the `port` handle (must be called from a user gesture).
+ */
+export type WasmAsciiTransportOpenOptions = WasmSerialTransportOptions & {
+    port: WasmSerialPortHandle;
+};
+declare const WasmAsciiTransportService_base: Effect.Service.Class<WasmAsciiTransportService, "WasmAsciiTransportService", {
+    readonly scoped: (options: WasmAsciiTransportOpenOptions) => 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 `modbus-rs`'s browser {@link WasmAsciiTransport}
+ * for Modbus ASCII over the Web Serial API.
+ *
+ * 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 WasmAsciiTransport.createClient} and
+ * cached, so repeated requests for the same unit ID reuse the same client.
+ *
+ * @see WasmAsciiTransport — Upstream `modbus-rs` browser Web Serial ASCII transport.
+ * @see requestSerialPort — Obtains the serial port handle this service's `port` option needs.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class WasmAsciiTransportService extends WasmAsciiTransportService_base {
+    /**
+     * Creates a {@link Layer} providing an in-memory mock
+     * {@link WasmAsciiTransportService} 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 WasmAsciiTransportOpenOptions} and
+     *          returns a scoped {@link Layer} providing the mock service.
+     *
+     * @see makeMockTransport — The underlying mock factory.
+     */
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: WasmAsciiTransportOpenOptions) => Layer.Layer<WasmAsciiTransportService, never, never>;
+}
+export {};

package/dist/src/WasmRtuTransportService.d.ts

@@ -0,0 +1,56 @@
+import { Effect, Layer } from 'effect';
+import type { WasmSerialPortHandle, WasmSerialTransportOptions } from 'modbus-rs/web';
+import { SlaveDeviceDefinitions } from './mocks';
+/**
+ * Options for {@link WasmRtuTransportService}. `WasmRtuTransport.open()` takes the
+ * serial port handle and the connection options as two separate arguments; this
+ * combines them into one object so it fits {@link makeTransportScoped}'s single-options
+ * shape, with `port` destructured back out inside the service's `openMethod`.
+ *
+ * @see requestSerialPort — Obtains the `port` handle (must be called from a user gesture).
+ */
+export type WasmRtuTransportOpenOptions = WasmSerialTransportOptions & {
+    port: WasmSerialPortHandle;
+};
+declare const WasmRtuTransportService_base: Effect.Service.Class<WasmRtuTransportService, "WasmRtuTransportService", {
+    readonly scoped: (options: WasmRtuTransportOpenOptions) => 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 `modbus-rs`'s browser {@link WasmRtuTransport}
+ * for Modbus RTU over the Web Serial API.
+ *
+ * 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 WasmRtuTransport.createClient} and
+ * cached, so repeated requests for the same unit ID reuse the same client.
+ *
+ * @see WasmRtuTransport — Upstream `modbus-rs` browser Web Serial RTU transport.
+ * @see requestSerialPort — Obtains the serial port handle this service's `port` option needs.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class WasmRtuTransportService extends WasmRtuTransportService_base {
+    /**
+     * Creates a {@link Layer} providing an in-memory mock
+     * {@link WasmRtuTransportService} 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 WasmRtuTransportOpenOptions} and
+     *          returns a scoped {@link Layer} providing the mock service.
+     *
+     * @see makeMockTransport — The underlying mock factory.
+     */
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: WasmRtuTransportOpenOptions) => Layer.Layer<WasmRtuTransportService, never, never>;
+}
+export {};

package/dist/src/WasmSerialModbusServerService.d.ts

@@ -0,0 +1,54 @@
+import { Layer } from 'effect';
+import type { ServerHandlers } from 'modbus-rs';
+import type { WasmSerialServerOptions } from 'modbus-rs/web';
+import type { ModbusError } from './errors';
+/**
+ * A scoped {@link Layer} that starts a browser Modbus RTU server over the Web
+ * Serial API (experimental upstream surface).
+ *
+ * `options.serialPort` is the raw `SerialPort` object obtained from the
+ * consumer's own app code via `navigator.serial.requestPort()` (which has the
+ * `dom` lib types available) — **not** this package's {@link requestSerialPort}
+ * helper, which returns the `WasmSerialPortHandle` wrapper used only by the
+ * client-side transports (`WasmRtuTransportService`/`WasmAsciiTransportService`).
+ *
+ * Like {@link wasmWsServerLayer}, the WASM server requires a continuously-awaited
+ * `serve()` call to drive its request loop; this layer forks that call into the
+ * scope automatically so the returned `Layer` "just works".
+ *
+ * @param options - Serial port, baud rate, unit ID, etc.
+ * @param handlers - Callback functions that handle incoming Modbus requests
+ *   (same {@link ServerHandlers} shape as the native TCP/serial servers).
+ * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect";
+ * import { wasmSerialRtuServerLayer } from "@flux-control/effect-modbus-rs";
+ *
+ * const port = await navigator.serial.requestPort(); // user-gesture gated
+ * const ServerLive = wasmSerialRtuServerLayer(
+ *   { serialPort: port, unitId: 1, baudRate: 19200 },
+ *   { onReadCoils: (req) => [false, false] },
+ * );
+ *
+ * Layer.launch(ServerLive).pipe(Effect.runPromise);
+ * ```
+ *
+ * @see WasmSerialServerOptions — Options accepted by the upstream WASM serial server.
+ * @see ServerHandlers — Interface for request handler callbacks.
+ */
+export declare const wasmSerialRtuServerLayer: (options: WasmSerialServerOptions, handlers: ServerHandlers) => Layer.Layer<never, ModbusError>;
+/**
+ * A scoped {@link Layer} that starts a browser Modbus ASCII server over the Web
+ * Serial API. See {@link wasmSerialRtuServerLayer} for shared details (the
+ * `serialPort` source, and the `serve()`-forking behavior).
+ *
+ * @param options - Serial port, 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.
+ *
+ * @see WasmSerialServerOptions — Options accepted by the upstream WASM serial server.
+ * @see ServerHandlers — Interface for request handler callbacks.
+ */
+export declare const wasmSerialAsciiServerLayer: (options: WasmSerialServerOptions, handlers: ServerHandlers) => Layer.Layer<never, ModbusError>;

package/dist/src/WasmSerialPort.d.ts

@@ -0,0 +1,27 @@
+import { Effect } from 'effect';
+import type { WasmSerialPortHandle } from 'modbus-rs/web';
+import type { ModbusError } from './errors';
+/**
+ * Requests a browser serial port handle via the Web Serial API, for use with
+ * {@link WasmSerialTransportService.fromRtu} / `.fromAscii` (or
+ * `WasmRtuTransportService.Default` / `WasmAsciiTransportService.Default` directly).
+ *
+ * **Must be called synchronously from within a user-gesture event handler**
+ * (e.g. a `click` listener) — this is a hard Web Serial API / browser security
+ * constraint (`navigator.serial.requestPort()` semantics), not a library-imposed
+ * restriction. Calling it outside a gesture will reject.
+ *
+ * @example
+ * ```ts
+ * button.addEventListener("click", () => {
+ *   Effect.runPromise(
+ *     requestSerialPort().pipe(
+ *       Effect.flatMap((port) => Effect.provide(program, WasmRtuTransportService.Default({ port, baudRate: 19200 }))),
+ *     ),
+ *   );
+ * });
+ * ```
+ *
+ * @see WasmSerialPortHandle — Opaque handle returned by `modbus-rs`'s WASM bindings.
+ */
+export declare const requestSerialPort: () => Effect.Effect<WasmSerialPortHandle, ModbusError>;

package/dist/src/WasmSerialTransportService.d.ts

@@ -0,0 +1,48 @@
+import { Context, Layer } from 'effect';
+import { type SlaveDeviceDefinitions } from './mocks';
+import type { TransportServiceApi } from './shared-transport';
+import { type WasmAsciiTransportOpenOptions } from './WasmAsciiTransportService';
+import { type WasmRtuTransportOpenOptions } from './WasmRtuTransportService';
+declare const WasmSerialTransportService_base: Context.TagClass<WasmSerialTransportService, "WasmSerialTransportService", TransportServiceApi>;
+/**
+ * Abstract browser (WASM) serial Modbus transport service tag.
+ *
+ * Represents a Web Serial-based Modbus transport backed by either ASCII or RTU
+ * framing. Use this tag when you need a browser serial transport but don't care
+ * about the specific framing protocol.
+ *
+ * Consumers `yield* WasmSerialTransportService` to obtain a
+ * {@link TransportServiceApi} and satisfy the tag via one of the static
+ * provider methods:
+ *
+ * ```ts
+ * // Provide with ASCII framing
+ * Layer.provide(WasmSerialTransportService.fromAscii({ port, baudRate: 9600 }))
+ *
+ * // Provide with RTU framing
+ * Layer.provide(WasmSerialTransportService.fromRtu({ port, baudRate: 9600 }))
+ * ```
+ *
+ * @see requestSerialPort — Obtains the `port` handle both providers need (must be called from a user gesture).
+ */
+export declare class WasmSerialTransportService extends WasmSerialTransportService_base {
+    /**
+     * Creates a {@link Layer} providing {@link WasmSerialTransportService}
+     * backed by an ASCII transport.
+     */
+    static fromAscii(options: WasmAsciiTransportOpenOptions): Layer.Layer<WasmSerialTransportService>;
+    /**
+     * Creates a {@link Layer} providing {@link WasmSerialTransportService}
+     * backed by an RTU transport.
+     */
+    static fromRtu(options: WasmRtuTransportOpenOptions): Layer.Layer<WasmSerialTransportService>;
+    /**
+     * Creates a mock {@link Layer} providing {@link WasmSerialTransportService}
+     * 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: WasmAsciiTransportOpenOptions | WasmRtuTransportOpenOptions) => Layer.Layer<WasmSerialTransportService>;
+}
+export {};

package/dist/src/WasmTcpServerService.d.ts

@@ -0,0 +1,38 @@
+import { Layer } from 'effect';
+import type { ServerHandlers } from 'modbus-rs';
+import type { WasmTcpServerOptions } from 'modbus-rs/web';
+import type { ModbusError } from './errors';
+/**
+ * A scoped {@link Layer} that starts a browser Modbus server proxied over a
+ * WebSocket gateway (experimental upstream surface — browsers can't accept raw
+ * TCP connections, so this binds via `modbus-gateway` or an equivalent WS-to-TCP
+ * proxy).
+ *
+ * Unlike the native {@link tcpServerLayer}, the WASM server does not start
+ * serving on `bind()` — it requires an explicit, continuously-awaited `serve()`
+ * call to drive its request loop. This layer forks that call into the scope in
+ * the background so the returned `Layer` behaves the same as the native one
+ * from the consumer's perspective (no extra step needed).
+ *
+ * @param options - WebSocket gateway URL and unit ID.
+ * @param handlers - Callback functions that handle incoming Modbus requests
+ *   (same {@link ServerHandlers} shape as the native TCP/serial servers).
+ * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Layer } from "effect";
+ * import { wasmWsServerLayer } from "@flux-control/effect-modbus-rs";
+ *
+ * const ServerLive = wasmWsServerLayer(
+ *   { wsUrl: "ws://localhost:8080", unitId: 1 },
+ *   { onReadCoils: (req) => [false, false] },
+ * );
+ *
+ * Layer.launch(ServerLive).pipe(Effect.runPromise);
+ * ```
+ *
+ * @see WasmTcpServerOptions — Options accepted by the upstream WASM WS server.
+ * @see ServerHandlers — Interface for request handler callbacks.
+ */
+export declare const wasmWsServerLayer: (options: WasmTcpServerOptions, handlers: ServerHandlers) => Layer.Layer<never, ModbusError>;

package/dist/src/WasmWsTransportService.d.ts

@@ -0,0 +1,45 @@
+import { Effect, Layer } from 'effect';
+import type { WasmWsTransportOptions } from 'modbus-rs/web';
+import { SlaveDeviceDefinitions } from './mocks';
+declare const WasmWsTransportService_base: Effect.Service.Class<WasmWsTransportService, "WasmWsTransportService", {
+    readonly scoped: (options: WasmWsTransportOptions) => 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 `modbus-rs`'s browser {@link WasmWsTransport}
+ * for Modbus TCP over a WebSocket gateway (browsers can't open raw TCP sockets).
+ *
+ * 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 WasmWsTransport.createClient} and
+ * cached, so repeated requests for the same unit ID reuse the same client.
+ *
+ * @see WasmWsTransport — Upstream `modbus-rs` browser WebSocket transport.
+ * @see WasmWsTransportOptions — Configuration for the WebSocket gateway connection.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class WasmWsTransportService extends WasmWsTransportService_base {
+    /**
+     * Creates a {@link Layer} providing an in-memory mock
+     * {@link WasmWsTransportService} 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 WasmWsTransportOptions} and
+     *          returns a scoped {@link Layer} providing the mock service.
+     *
+     * @see makeMockTransport — The underlying mock factory.
+     */
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: WasmWsTransportOptions) => Layer.Layer<WasmWsTransportService, never, never>;
+}
+export {};

package/dist/src/mocks.d.ts

@@ -1,7 +1,8 @@
-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";
+import { Effect, Schema } from 'effect';
+import { type AsciiTransportOptions, type RtuTransportOptions, type TcpTransportOptions } from 'modbus-rs';
+import type { WasmWsTransportOptions, WasmSerialTransportOptions } from 'modbus-rs/web';
+import { ModbusInvalidArgumentError, type ModbusError } from './errors';
+import type { EffectModbusClient } from './modbus-client';
 /**
  * Schema for a single coil (digital output) definition.
  *
@@ -124,7 +125,7 @@ export type SlaveDeviceDefinitions = Schema.Schema.Type<typeof SlaveDeviceDefini
  * @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<{
+export declare const makeMockTransport: (devices: SlaveDeviceDefinitions) => (_options: RtuTransportOptions | AsciiTransportOptions | TcpTransportOptions | WasmWsTransportOptions | WasmSerialTransportOptions) => Effect.Effect<{
     withClient: (unitId: number) => Effect.Effect<EffectModbusClient, ModbusInvalidArgumentError, never>;
     setRequestTimeout: (_timeoutMs: number) => Effect.Effect<void, never, never>;
     clearRequestTimeout: () => Effect.Effect<void, never, never>;

package/dist/src/modbus-client.d.ts

@@ -1,13 +1,19 @@
-import type { ReadRegistersOptions, WriteSingleRegisterOptions, WriteMultipleRegistersOptions, ReadWriteMultipleRegistersOptions, ReadBitsOptions, WriteSingleCoilOptions, WriteMultipleCoilsOptions, ReadFifoQueueOptions, ReadFileRecordOptions, WriteFileRecordOptions, DiagnosticsOptions, ReadDeviceIdentificationOptions, FifoQueueResponse, DiagnosticsResponse, DeviceIdentificationResponse, AsyncSerialModbusClient, AsyncTcpModbusClient } from "modbus-rs";
-import { Effect } from "effect";
-import type { ModbusError } from "./errors";
-export type AnyModbusClient = AsyncSerialModbusClient | AsyncTcpModbusClient;
+import { Effect } from 'effect';
+import type { ReadRegistersOptions, WriteSingleRegisterOptions, WriteMultipleRegistersOptions, ReadWriteMultipleRegistersOptions, ReadBitsOptions, WriteSingleCoilOptions, WriteMultipleCoilsOptions, ReadFifoQueueOptions, ReadFileRecordOptions, WriteFileRecordOptions, DiagnosticsOptions, ReadDeviceIdentificationOptions, FifoQueueResponse, DiagnosticsResponse, DeviceIdentificationResponse, AsyncSerialModbusClient, AsyncTcpModbusClient, CoilState } from 'modbus-rs';
+import type { WasmWsModbusClient, WasmSerialModbusClient } from 'modbus-rs/web';
+import type { ModbusError } from './errors';
+/** The two native (napi) clients — same method surface, sharing one factory. */
+export type NativeModbusClient = AsyncSerialModbusClient | AsyncTcpModbusClient;
+/** The two browser (WASM) clients — same method surface, sharing one factory. */
+export type WasmModbusClient = WasmSerialModbusClient | WasmWsModbusClient;
+/** Any client this package knows how to wrap into an {@link EffectModbusClient}. */
+export type AnyModbusClient = NativeModbusClient | WasmModbusClient;
 /**
  * Effect-ified Modbus client wrapping a `modbus-rs` transport client.
  *
- * Each method delegates to the equivalent `AsyncSerialModbusClient` or
- * `AsyncTcpModbusClient` method, converting the Promise-based API into
- * an {@link Effect.Effect} with typed {@link ModbusError} failures.
+ * Each method delegates to the equivalent method on the underlying native
+ * or WASM client, converting the Promise-based API into an
+ * {@link Effect.Effect} with typed {@link ModbusError} failures.
  *
  * Thrown errors are classified using {@link toModbusError}, mapping
  * `modbus-rs` error codes (timeout, transport, exception, etc.) into
@@ -27,7 +33,7 @@ export interface EffectModbusClient {
      * @see ReadRegistersOptions — Options shape from `modbus-rs`.
      * @see AsyncSerialModbusClient.readHoldingRegisters — Upstream implementation.
      */
-    readHoldingRegisters(opts: ReadRegistersOptions): Effect.Effect<number[], ModbusError>;
+    readHoldingRegisters(opts: ReadRegistersOptions): Effect.Effect<Uint16Array, ModbusError>;
     /**
      * Reads input registers from the Modbus device (FC04).
      *
@@ -37,7 +43,7 @@ export interface EffectModbusClient {
      * @see ReadRegistersOptions — Options shape from `modbus-rs`.
      * @see AsyncSerialModbusClient.readInputRegisters — Upstream implementation.
      */
-    readInputRegisters(opts: ReadRegistersOptions): Effect.Effect<number[], ModbusError>;
+    readInputRegisters(opts: ReadRegistersOptions): Effect.Effect<Uint16Array, ModbusError>;
     /**
      * Writes a single holding register (FC06).
      *
@@ -67,7 +73,7 @@ export interface EffectModbusClient {
      *
      * @see ReadWriteMultipleRegistersOptions — Options shape from `modbus-rs`.
      */
-    readWriteMultipleRegisters(opts: ReadWriteMultipleRegistersOptions): Effect.Effect<number[], ModbusError>;
+    readWriteMultipleRegisters(opts: ReadWriteMultipleRegistersOptions): Effect.Effect<Uint16Array, ModbusError>;
     /**
      * Reads coils (digital outputs) from the Modbus device (FC01).
      *
@@ -76,7 +82,7 @@ export interface EffectModbusClient {
      *
      * @see ReadBitsOptions — Options shape from `modbus-rs`.
      */
-    readCoils(opts: ReadBitsOptions): Effect.Effect<boolean[], ModbusError>;
+    readCoils(opts: ReadBitsOptions): Effect.Effect<CoilState[], ModbusError>;
     /**
      * Writes a single coil (digital output) (FC05).
      *
@@ -103,7 +109,7 @@ export interface EffectModbusClient {
      *
      * @see ReadBitsOptions — Options shape from `modbus-rs`.
      */
-    readDiscreteInputs(opts: ReadBitsOptions): Effect.Effect<boolean[], ModbusError>;
+    readDiscreteInputs(opts: ReadBitsOptions): Effect.Effect<CoilState[], ModbusError>;
     /**
      * Reads the FIFO queue from the Modbus device (FC24).
      *
@@ -122,7 +128,7 @@ export interface EffectModbusClient {
      *
      * @see ReadFileRecordOptions — Options shape from `modbus-rs`.
      */
-    readFileRecord(opts: ReadFileRecordOptions): Effect.Effect<number[][], ModbusError>;
+    readFileRecord(opts: ReadFileRecordOptions): Effect.Effect<Uint16Array[], ModbusError>;
     /**
      * Writes file records to the Modbus device (FC21).
      *
@@ -162,21 +168,23 @@ export interface EffectModbusClient {
     readDeviceIdentification(opts: ReadDeviceIdentificationOptions): Effect.Effect<DeviceIdentificationResponse, ModbusError>;
 }
 /**
- * Wraps a raw `modbus-rs` client into an {@link EffectModbusClient}.
+ * Wraps a raw `modbus-rs` client — native (napi) or browser (WASM) — into an
+ * {@link EffectModbusClient}.
  *
  * Each method converts a Promise-based call from the upstream client
  * into an `Effect` via {@link Effect.tryPromise}, routing errors through
  * {@link toModbusError} for typed error discrimination.
  *
- * Accepts both serial (`AsyncSerialModbusClient`) and TCP
- * (`AsyncTcpModbusClient`) clients since they share the same method
- * signatures.
+ * The native and WASM clients share the same method surface (same options
+ * shapes, same resolved value shapes — `CoilState[]`, full `FifoQueueResponse`,
+ * full `DeviceIdentificationResponse`), so one factory covers both; no
+ * transport-specific reshaping is needed.
  *
- * @param client - The upstream `modbus-rs` client instance.
+ * @param client - The upstream `modbus-rs` or `modbus-rs/web` client instance.
  * @returns An `EffectModbusClient` that can be used within Effect
  *          workflows.
  *
- * @see AsyncSerialModbusClient — Upstream serial client API.
- * @see AsyncTcpModbusClient — Upstream TCP client API.
+ * @see AsyncSerialModbusClient — Upstream native serial client API.
+ * @see AsyncTcpModbusClient — Upstream native TCP client API.
  */
-export declare const makeEffectModbusClient: (client: AsyncSerialModbusClient | AsyncTcpModbusClient) => EffectModbusClient;
+export declare const makeEffectModbusClient: (client: AnyModbusClient) => EffectModbusClient;

package/dist/src/modbus-client.wasm.test.d.ts

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

package/dist/src/shared-transport.d.ts

@@ -1,6 +1,6 @@
-import { Effect, Scope } from "effect";
-import { type ModbusError, ModbusNotConnectedError } from "./errors";
-import { type AnyModbusClient, type EffectModbusClient } from "./modbus-client";
+import { Effect, Scope } from 'effect';
+import { type ModbusError, ModbusNotConnectedError } from './errors';
+import { type AnyModbusClient, type EffectModbusClient } from './modbus-client';
 /**
  * Shared API surface that every transport service exposes to consumers.
  *
@@ -51,9 +51,13 @@ interface TransportHandle<TClient> {
  * @param openMethod - A function that takes the transport constructor and options,
  *   returning a promise for the opened transport.
  * @param serviceName - Logical name used in log messages and the finalizer guard.
+ * @param config - Optional module specifier override for browser WASM transports.
  * @returns An `Effect` that produces a {@link TransportServiceApi}.
  */
-export declare function makeTransportScoped<TOptions, TClient extends AnyModbusClient, TTransport extends TransportHandle<TClient>>(transportKey: string, openMethod: (TC: unknown, options: TOptions) => Promise<TTransport>, serviceName: string): (options: TOptions) => Effect.Effect<{
+export declare function makeTransportScoped<TOptions, TClient extends AnyModbusClient, TTransport extends TransportHandle<TClient>>(transportKey: string, openMethod: (TC: unknown, options: TOptions) => Promise<TTransport>, serviceName: string, config?: {
+    /** Which `modbus-rs` conditional export to import from. Defaults to `"modbus-rs"` (native). */
+    moduleSpecifier?: 'modbus-rs' | 'modbus-rs/web';
+}): (options: TOptions) => Effect.Effect<{
     withClient: (unitId: number) => Effect.Effect<EffectModbusClient, ModbusError, never>;
     setRequestTimeout: (timeoutMs: number) => Effect.Effect<undefined, ModbusNotConnectedError, never>;
     clearRequestTimeout: () => Effect.Effect<undefined, ModbusNotConnectedError, never>;

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

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