@flux-control/effect-modbus-rs 0.1.1 → 0.3.0

package/dist/src/AsciiTransportService.d.ts

@@ -1,9 +1,30 @@
-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';
+import type { MockFaultOptions } from './mocks';
+import type { TransportResilienceOptions, WithoutUpstreamRetry } from './shared-transport';
+/**
+ * {@link AsciiTransportOptions} minus the upstream retry knobs.
+ *
+ * @see WithoutUpstreamRetry — Why they are withheld.
+ */
+export type AsciiTransportOpenOptions = WithoutUpstreamRetry<AsciiTransportOptions>;
 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>;
+    readonly scoped: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+        connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
+            readonly _tag: "Connected";
+        } | {
+            readonly _tag: "Disconnected";
+        } | {
+            readonly _tag: "Down";
+            readonly cause: import("./errors").ModbusError;
+        } | {
+            readonly _tag: "Reconnecting";
+            readonly attempt: number;
+        }>;
+        withClient: (unitId: number, clientOptions?: {
+            readonly retry?: import("./retry").ModbusRetryPolicy;
+        } | undefined) => 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>;
@@ -24,7 +45,7 @@ declare const AsciiTransportService_base: Effect.Service.Class<AsciiTransportSer
  * requests for the same unit ID reuse the same client.
  *
  * @see AsyncAsciiTransport — Upstream `modbus-rs` ASCII transport.
- * @see AsciiTransportOptions — Configuration for the ASCII serial port.
+ * @see AsciiTransportOpenOptions — Configuration for the ASCII serial port.
  * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
  */
 export declare class AsciiTransportService extends AsciiTransportService_base {
@@ -36,11 +57,11 @@ export declare class AsciiTransportService extends AsciiTransportService_base {
      * simulated Modbus slaves and their register/coil maps.
      *
      * @param devices - Slave device definitions for the mock.
-     * @returns A function that takes {@link AsciiTransportOptions} and
+     * @returns A function that takes {@link AsciiTransportOpenOptions} and
      *          returns a scoped {@link Layer} providing the mock service.
      *
      * @see makeMockTransport — The underlying mock factory.
      */
-    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: AsciiTransportOptions) => Layer.Layer<AsciiTransportService, never, never>;
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: AsciiTransportOpenOptions & TransportResilienceOptions & MockFaultOptions) => Layer.Layer<AsciiTransportService, never, never>;
 }
 export {};

package/dist/src/RtuTransportService.d.ts

@@ -1,9 +1,30 @@
-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 { MockFaultOptions } from './mocks';
+import type { SlaveDeviceDefinitions } from './mocks';
+import type { TransportResilienceOptions, WithoutUpstreamRetry } from './shared-transport';
+/**
+ * {@link RtuTransportOptions} minus the upstream retry knobs.
+ *
+ * @see WithoutUpstreamRetry — Why they are withheld.
+ */
+export type RtuTransportOpenOptions = WithoutUpstreamRetry<RtuTransportOptions>;
 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>;
+    readonly scoped: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+        connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
+            readonly _tag: "Connected";
+        } | {
+            readonly _tag: "Disconnected";
+        } | {
+            readonly _tag: "Down";
+            readonly cause: import("./errors").ModbusError;
+        } | {
+            readonly _tag: "Reconnecting";
+            readonly attempt: number;
+        }>;
+        withClient: (unitId: number, clientOptions?: {
+            readonly retry?: import("./retry").ModbusRetryPolicy;
+        } | undefined) => 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>;
@@ -24,7 +45,7 @@ declare const RtuTransportService_base: Effect.Service.Class<RtuTransportService
  * requests for the same unit ID reuse the same client.
  *
  * @see AsyncRtuTransport — Upstream `modbus-rs` RTU transport.
- * @see RtuTransportOptions — Configuration for the RTU serial port.
+ * @see RtuTransportOpenOptions — Configuration for the RTU serial port.
  * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
  */
 export declare class RtuTransportService extends RtuTransportService_base {
@@ -36,11 +57,11 @@ export declare class RtuTransportService extends RtuTransportService_base {
      * simulated Modbus slaves and their register/coil maps.
      *
      * @param devices - Slave device definitions for the mock.
-     * @returns A function that takes {@link RtuTransportOptions} and
+     * @returns A function that takes {@link RtuTransportOpenOptions} and
      *          returns a scoped {@link Layer} providing the mock service.
      *
      * @see makeMockTransport — The underlying mock factory.
      */
-    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: RtuTransportOptions) => Layer.Layer<RtuTransportService, never, never>;
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: RtuTransportOpenOptions & TransportResilienceOptions & MockFaultOptions) => Layer.Layer<RtuTransportService, never, never>;
 }
 export {};

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,8 @@
-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 AsciiTransportOpenOptions } from './AsciiTransportService';
+import { type SlaveDeviceDefinitions } from './mocks';
+import { type RtuTransportOpenOptions } from './RtuTransportService';
+import type { TransportResilienceOptions, TransportServiceApi } from './shared-transport';
 declare const SerialTransportService_base: Context.TagClass<SerialTransportService, "SerialTransportService", TransportServiceApi>;
 /**
  * Abstract serial Modbus transport service tag.
@@ -27,12 +28,12 @@ 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>;
+    static fromAscii(options: AsciiTransportOpenOptions & TransportResilienceOptions): Layer.Layer<SerialTransportService>;
     /**
      * Creates a {@link Layer} providing {@link SerialTransportService}
      * backed by an RTU transport.
      */
-    static fromRtu(options: RtuTransportOptions): Layer.Layer<SerialTransportService>;
+    static fromRtu(options: RtuTransportOpenOptions & TransportResilienceOptions): Layer.Layer<SerialTransportService>;
     /**
      * Creates a mock {@link Layer} providing {@link SerialTransportService}
      * for testing or development.
@@ -40,6 +41,6 @@ export declare class SerialTransportService extends SerialTransportService_base
      * 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>;
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: (AsciiTransportOpenOptions | RtuTransportOpenOptions) & TransportResilienceOptions) => Layer.Layer<SerialTransportService>;
 }
 export {};

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,9 +1,30 @@
-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';
+import type { MockFaultOptions } from './mocks';
+import type { TransportResilienceOptions, WithoutUpstreamRetry } from './shared-transport';
+/**
+ * {@link TcpTransportOptions} minus the upstream retry knobs.
+ *
+ * @see WithoutUpstreamRetry — Why they are withheld.
+ */
+export type TcpTransportOpenOptions = WithoutUpstreamRetry<TcpTransportOptions>;
 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>;
+    readonly scoped: (options: TcpTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+        connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
+            readonly _tag: "Connected";
+        } | {
+            readonly _tag: "Disconnected";
+        } | {
+            readonly _tag: "Down";
+            readonly cause: import("./errors").ModbusError;
+        } | {
+            readonly _tag: "Reconnecting";
+            readonly attempt: number;
+        }>;
+        withClient: (unitId: number, clientOptions?: {
+            readonly retry?: import("./retry").ModbusRetryPolicy;
+        } | undefined) => 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>;
@@ -24,7 +45,7 @@ declare const TcpTransportService_base: Effect.Service.Class<TcpTransportService
  * 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 TcpTransportOpenOptions — Configuration for the TCP connection.
  * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
  */
 export declare class TcpTransportService extends TcpTransportService_base {
@@ -36,11 +57,11 @@ export declare class TcpTransportService extends TcpTransportService_base {
      * 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 function that takes {@link TcpTransportOpenOptions} 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>;
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: TcpTransportOpenOptions & TransportResilienceOptions & MockFaultOptions) => Layer.Layer<TcpTransportService, never, never>;
 }
 export {};

package/dist/src/WasmAsciiTransportService.d.ts

@@ -0,0 +1,73 @@
+import { Effect, Layer } from 'effect';
+import type { WasmSerialPortHandle, WasmSerialTransportOptions } from 'modbus-rs/web';
+import { SlaveDeviceDefinitions } from './mocks';
+import type { MockFaultOptions } from './mocks';
+import type { TransportResilienceOptions } from './shared-transport';
+/**
+ * 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: WasmSerialTransportOptions & {
+        port: WasmSerialPortHandle;
+    } & TransportResilienceOptions) => Effect.Effect<{
+        connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
+            readonly _tag: "Connected";
+        } | {
+            readonly _tag: "Disconnected";
+        } | {
+            readonly _tag: "Down";
+            readonly cause: import("./errors").ModbusError;
+        } | {
+            readonly _tag: "Reconnecting";
+            readonly attempt: number;
+        }>;
+        withClient: (unitId: number, clientOptions?: {
+            readonly retry?: import("./retry").ModbusRetryPolicy;
+        } | undefined) => 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 & TransportResilienceOptions & MockFaultOptions) => Layer.Layer<WasmAsciiTransportService, never, never>;
+}
+export {};

package/dist/src/WasmRtuTransportService.d.ts

@@ -0,0 +1,73 @@
+import { Effect, Layer } from 'effect';
+import type { WasmSerialPortHandle, WasmSerialTransportOptions } from 'modbus-rs/web';
+import { SlaveDeviceDefinitions } from './mocks';
+import type { MockFaultOptions } from './mocks';
+import type { TransportResilienceOptions } from './shared-transport';
+/**
+ * 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: WasmSerialTransportOptions & {
+        port: WasmSerialPortHandle;
+    } & TransportResilienceOptions) => Effect.Effect<{
+        connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
+            readonly _tag: "Connected";
+        } | {
+            readonly _tag: "Disconnected";
+        } | {
+            readonly _tag: "Down";
+            readonly cause: import("./errors").ModbusError;
+        } | {
+            readonly _tag: "Reconnecting";
+            readonly attempt: number;
+        }>;
+        withClient: (unitId: number, clientOptions?: {
+            readonly retry?: import("./retry").ModbusRetryPolicy;
+        } | undefined) => 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 & TransportResilienceOptions & MockFaultOptions) => 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>;