@flux-control/effect-modbus-rs 0.3.1 → 0.4.0

package/dist/src/AsciiTransportService.d.ts

@@ -1,16 +1,37 @@
-import { Effect, Layer } from 'effect';
+import { Context, 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';
+import type { TransportResilienceOptions, WithoutUpstreamRetry, TransportServiceApi } 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: AsciiTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+declare const AsciiTransportService_base: Context.ServiceClass<AsciiTransportService, "AsciiTransportService", TransportServiceApi>;
+/**
+ * Scoped Effect service wrapping the `modbus-rs` {@link AsyncAsciiTransport}
+ * for ASCII (serial) 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 AsyncAsciiTransport.createClient} and cached, so repeated
+ * requests for the same unit ID reuse the same client.
+ *
+ * @see AsyncAsciiTransport — Upstream `modbus-rs` ASCII transport.
+ * @see AsciiTransportOpenOptions — Configuration for the ASCII serial port.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class AsciiTransportService extends AsciiTransportService_base {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link AsciiTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -31,24 +52,12 @@ declare const AsciiTransportService_base: Effect.Service.Class<AsciiTransportSer
         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 AsyncAsciiTransport}
- * for ASCII (serial) 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 AsyncAsciiTransport.createClient} and cached, so repeated
- * requests for the same unit ID reuse the same client.
- *
- * @see AsyncAsciiTransport — Upstream `modbus-rs` ASCII transport.
- * @see AsciiTransportOpenOptions — Configuration for the ASCII serial port.
- * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
- */
-export declare class AsciiTransportService extends AsciiTransportService_base {
+    /**
+     * Creates a {@link Layer} providing a live {@link AsciiTransportService}.
+     *
+     * @param options - Connection and resilience options for the transport.
+     */
+    static readonly make: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<AsciiTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link AsciiTransportService} for testing or development.

package/dist/src/RtuTransportService.d.ts

@@ -1,16 +1,37 @@
-import { Effect, Layer } from 'effect';
+import { Context, 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';
+import type { TransportResilienceOptions, WithoutUpstreamRetry, TransportServiceApi } 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: RtuTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+declare const RtuTransportService_base: Context.ServiceClass<RtuTransportService, "RtuTransportService", TransportServiceApi>;
+/**
+ * Scoped Effect service wrapping the `modbus-rs` {@link AsyncRtuTransport}
+ * for RTU (serial) 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 AsyncRtuTransport.createClient} and cached, so repeated
+ * requests for the same unit ID reuse the same client.
+ *
+ * @see AsyncRtuTransport — Upstream `modbus-rs` RTU transport.
+ * @see RtuTransportOpenOptions — Configuration for the RTU serial port.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class RtuTransportService extends RtuTransportService_base {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link RtuTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -31,24 +52,12 @@ declare const RtuTransportService_base: Effect.Service.Class<RtuTransportService
         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 AsyncRtuTransport}
- * for RTU (serial) 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 AsyncRtuTransport.createClient} and cached, so repeated
- * requests for the same unit ID reuse the same client.
- *
- * @see AsyncRtuTransport — Upstream `modbus-rs` RTU transport.
- * @see RtuTransportOpenOptions — Configuration for the RTU serial port.
- * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
- */
-export declare class RtuTransportService extends RtuTransportService_base {
+    /**
+     * Creates a {@link Layer} providing a live {@link RtuTransportService}.
+     *
+     * @param options - Connection and resilience options for the transport.
+     */
+    static readonly make: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<RtuTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link RtuTransportService} for testing or development.

package/dist/src/SerialTransportService.d.ts

@@ -3,7 +3,7 @@ import { type AsciiTransportOpenOptions } from './AsciiTransportService';
 import { type MockFaultOptions, 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>;
+declare const SerialTransportService_base: Context.ServiceClass<SerialTransportService, "SerialTransportService", TransportServiceApi>;
 /**
  * Abstract serial Modbus transport service tag.
  *

package/dist/src/TcpTransportService.d.ts

@@ -1,16 +1,37 @@
-import { Effect, Layer } from 'effect';
+import { Context, 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';
+import type { TransportResilienceOptions, TransportServiceApi, 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: TcpTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+declare const TcpTransportService_base: Context.ServiceClass<TcpTransportService, "TcpTransportService", TransportServiceApi>;
+/**
+ * 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 TcpTransportOpenOptions — Configuration for the TCP connection.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class TcpTransportService extends TcpTransportService_base {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link TcpTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: TcpTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -31,24 +52,12 @@ declare const TcpTransportService_base: Effect.Service.Class<TcpTransportService
         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 TcpTransportOpenOptions — 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 a live {@link TcpTransportService}.
+     *
+     * @param options - Connection and resilience options for the TCP transport.
+     */
+    static readonly make: (options: TcpTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<TcpTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link TcpTransportService} for testing or development.

package/dist/src/WasmAsciiTransportService.d.ts

@@ -1,8 +1,8 @@
-import { Effect, Layer } from 'effect';
+import { Context, 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';
+import type { TransportResilienceOptions, TransportServiceApi } from './shared-transport';
 /**
  * Options for {@link WasmAsciiTransportService}. `WasmAsciiTransport.open()` takes the
  * serial port handle and the connection options as two separate arguments; this
@@ -14,8 +14,28 @@ import type { TransportResilienceOptions } from './shared-transport';
 export type WasmAsciiTransportOpenOptions = WasmSerialTransportOptions & {
     port: WasmSerialPortHandle;
 };
-declare const WasmAsciiTransportService_base: Effect.Service.Class<WasmAsciiTransportService, "WasmAsciiTransportService", {
-    readonly scoped: (options: WasmSerialTransportOptions & {
+declare const WasmAsciiTransportService_base: Context.ServiceClass<WasmAsciiTransportService, "WasmAsciiTransportService", TransportServiceApi>;
+/**
+ * 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 {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link WasmAsciiTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: WasmSerialTransportOptions & {
         port: WasmSerialPortHandle;
     } & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
@@ -38,23 +58,12 @@ declare const WasmAsciiTransportService_base: Effect.Service.Class<WasmAsciiTran
         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 a live {@link WasmAsciiTransportService}.
+     *
+     * @param options - Connection and resilience options for the transport.
+     */
+    static readonly make: (options: WasmAsciiTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<WasmAsciiTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link WasmAsciiTransportService} for testing or development.

package/dist/src/WasmRtuTransportService.d.ts

@@ -1,8 +1,8 @@
-import { Effect, Layer } from 'effect';
+import { Context, 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';
+import type { TransportResilienceOptions, TransportServiceApi } from './shared-transport';
 /**
  * Options for {@link WasmRtuTransportService}. `WasmRtuTransport.open()` takes the
  * serial port handle and the connection options as two separate arguments; this
@@ -14,8 +14,28 @@ import type { TransportResilienceOptions } from './shared-transport';
 export type WasmRtuTransportOpenOptions = WasmSerialTransportOptions & {
     port: WasmSerialPortHandle;
 };
-declare const WasmRtuTransportService_base: Effect.Service.Class<WasmRtuTransportService, "WasmRtuTransportService", {
-    readonly scoped: (options: WasmSerialTransportOptions & {
+declare const WasmRtuTransportService_base: Context.ServiceClass<WasmRtuTransportService, "WasmRtuTransportService", TransportServiceApi>;
+/**
+ * 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 {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link WasmRtuTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: WasmSerialTransportOptions & {
         port: WasmSerialPortHandle;
     } & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
@@ -38,23 +58,12 @@ declare const WasmRtuTransportService_base: Effect.Service.Class<WasmRtuTranspor
         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 a live {@link WasmRtuTransportService}.
+     *
+     * @param options - Connection and resilience options for the transport.
+     */
+    static readonly make: (options: WasmRtuTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<WasmRtuTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link WasmRtuTransportService} for testing or development.

package/dist/src/WasmSerialPort.d.ts

@@ -4,7 +4,7 @@ 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).
+ * `WasmRtuTransportService.make` / `WasmAsciiTransportService.make` 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
@@ -16,7 +16,7 @@ import type { ModbusError } from './errors';
  * button.addEventListener("click", () => {
  *   Effect.runPromise(
  *     requestSerialPort().pipe(
- *       Effect.flatMap((port) => Effect.provide(program, WasmRtuTransportService.Default({ port, baudRate: 19200 }))),
+ *       Effect.flatMap((port) => Effect.provide(program, WasmRtuTransportService.make({ port, baudRate: 19200 }))),
  *     ),
  *   );
  * });

package/dist/src/WasmSerialTransportService.d.ts

@@ -3,7 +3,7 @@ import { type MockFaultOptions, type SlaveDeviceDefinitions } from './mocks';
 import type { TransportResilienceOptions, TransportServiceApi } from './shared-transport';
 import { type WasmAsciiTransportOpenOptions } from './WasmAsciiTransportService';
 import { type WasmRtuTransportOpenOptions } from './WasmRtuTransportService';
-declare const WasmSerialTransportService_base: Context.TagClass<WasmSerialTransportService, "WasmSerialTransportService", TransportServiceApi>;
+declare const WasmSerialTransportService_base: Context.ServiceClass<WasmSerialTransportService, "WasmSerialTransportService", TransportServiceApi>;
 /**
  * Abstract browser (WASM) serial Modbus transport service tag.
  *

package/dist/src/WasmWsTransportService.d.ts

@@ -1,10 +1,30 @@
-import { Effect, Layer } from 'effect';
+import { Context, Effect, Layer } from 'effect';
 import type { WasmWsTransportOptions } from 'modbus-rs/web';
 import { SlaveDeviceDefinitions } from './mocks';
 import type { MockFaultOptions } from './mocks';
-import type { TransportResilienceOptions } from './shared-transport';
-declare const WasmWsTransportService_base: Effect.Service.Class<WasmWsTransportService, "WasmWsTransportService", {
-    readonly scoped: (options: WasmWsTransportOptions & TransportResilienceOptions) => Effect.Effect<{
+import type { TransportResilienceOptions, TransportServiceApi } from './shared-transport';
+declare const WasmWsTransportService_base: Context.ServiceClass<WasmWsTransportService, "WasmWsTransportService", TransportServiceApi>;
+/**
+ * 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 {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link WasmWsTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: WasmWsTransportOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -25,23 +45,12 @@ declare const WasmWsTransportService_base: Effect.Service.Class<WasmWsTransportS
         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 a live {@link WasmWsTransportService}.
+     *
+     * @param options - Connection and resilience options for the transport.
+     */
+    static readonly make: (options: WasmWsTransportOptions & TransportResilienceOptions) => Layer.Layer<WasmWsTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link WasmWsTransportService} for testing or development.

package/dist/src/connection.d.ts

@@ -47,7 +47,7 @@ export declare const ConnectionState: {
         readonly _tag: Tag;
     }>;
     readonly $match: {
-        <const Cases extends { readonly [Tag in "Connected" | "Disconnected" | "Down" | "Reconnecting"]: (args: Extract<{
+        <Cases extends { readonly [Tag in "Connected" | "Disconnected" | "Down" | "Reconnecting"]: (args: Extract<{
             readonly _tag: "Connected";
         } | {
             readonly _tag: "Disconnected";
@@ -59,7 +59,7 @@ export declare const ConnectionState: {
             readonly attempt: number;
         }, {
             readonly _tag: Tag;
-        }>) => any; }>(cases: Cases & { [K in Exclude<keyof Cases, "Connected" | "Disconnected" | "Down" | "Reconnecting">]: never; }): (value: {
+        }>) => any; }>(cases: Cases): (value: {
             readonly _tag: "Connected";
         } | {
             readonly _tag: "Disconnected";
@@ -70,7 +70,7 @@ export declare const ConnectionState: {
             readonly _tag: "Reconnecting";
             readonly attempt: number;
         }) => import("effect/Unify").Unify<ReturnType<Cases["Connected" | "Disconnected" | "Down" | "Reconnecting"]>>;
-        <const Cases extends { readonly [Tag in "Connected" | "Disconnected" | "Down" | "Reconnecting"]: (args: Extract<{
+        <Cases extends { readonly [Tag in "Connected" | "Disconnected" | "Down" | "Reconnecting"]: (args: Extract<{
             readonly _tag: "Connected";
         } | {
             readonly _tag: "Disconnected";
@@ -92,19 +92,19 @@ export declare const ConnectionState: {
         } | {
             readonly _tag: "Reconnecting";
             readonly attempt: number;
-        }, cases: Cases & { [K in Exclude<keyof Cases, "Connected" | "Disconnected" | "Down" | "Reconnecting">]: never; }): import("effect/Unify").Unify<ReturnType<Cases["Connected" | "Disconnected" | "Down" | "Reconnecting"]>>;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Connected" | "Disconnected" | "Down" | "Reconnecting"]>>;
     };
-    readonly Connected: Data.Case.Constructor<{
+    readonly Connected: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Connected";
     }, "_tag">;
-    readonly Disconnected: Data.Case.Constructor<{
+    readonly Disconnected: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Disconnected";
     }, "_tag">;
-    readonly Down: Data.Case.Constructor<{
+    readonly Down: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Down";
         readonly cause: ModbusError;
     }, "_tag">;
-    readonly Reconnecting: Data.Case.Constructor<{
+    readonly Reconnecting: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Reconnecting";
         readonly attempt: number;
     }, "_tag">;
@@ -127,7 +127,7 @@ export interface ReconnectOptions {
      * How long the circuit stays open after attempts are exhausted, before the
      * supervisor probes again. Default `30 seconds`.
      */
-    readonly resetAfter?: Duration.DurationInput;
+    readonly resetAfter?: Duration.Input;
     /**
      * Which operation failures hand control to the supervisor.
      * Default `["ModbusConnectionClosedError", "ModbusTransportError"]`.