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

package/dist/src/SerialTransportService.d.ts

@@ -1,9 +1,9 @@
 import { Context, Layer } from 'effect';
 import { type AsciiTransportOpenOptions } from './AsciiTransportService';
-import { type SlaveDeviceDefinitions } from './mocks';
+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.
  *
@@ -35,12 +35,22 @@ export declare class SerialTransportService extends SerialTransportService_base
      */
     static fromRtu(options: RtuTransportOpenOptions & TransportResilienceOptions): Layer.Layer<SerialTransportService>;
     /**
-     * Creates a mock {@link Layer} providing {@link SerialTransportService}
-     * for testing or development.
+     * Creates a mock {@link Layer} that provides {@link SerialTransportService}
+     * for tests or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
-     * simulated Modbus slaves and their register/coil maps.
+     * The `devices` parameter is an array of {@link SlaveDeviceDefinition}. Each
+     * definition gives the coil map and the register map of one simulated slave.
+     *
+     * The option set is the same as the option set of the concrete tags. Thus a
+     * test that keeps the framing abstract can also set `retry`, `reconnect`,
+     * `fault`, and `reconnectFault`.
+     *
+     * @param devices - The slave device definitions for the mock.
+     * @returns A function that takes the mock options and gives a scoped
+     *          {@link Layer} that provides the mock service.
+     * @see MockFaultOptions — The `fault` hook and the `reconnectFault` hook.
+     * @see makeMockTransport — The mock factory that this method uses.
      */
-    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: (AsciiTransportOpenOptions | RtuTransportOpenOptions) & TransportResilienceOptions) => Layer.Layer<SerialTransportService>;
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: (AsciiTransportOpenOptions | RtuTransportOpenOptions) & TransportResilienceOptions & MockFaultOptions) => Layer.Layer<SerialTransportService>;
 }
 export {};

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

@@ -1,9 +1,9 @@
 import { Context, Layer } from 'effect';
-import { type SlaveDeviceDefinitions } from './mocks';
-import type { TransportServiceApi } from './shared-transport';
+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.
  *
@@ -30,19 +30,29 @@ export declare class WasmSerialTransportService extends WasmSerialTransportServi
      * Creates a {@link Layer} providing {@link WasmSerialTransportService}
      * backed by an ASCII transport.
      */
-    static fromAscii(options: WasmAsciiTransportOpenOptions): Layer.Layer<WasmSerialTransportService>;
+    static fromAscii(options: WasmAsciiTransportOpenOptions & TransportResilienceOptions): Layer.Layer<WasmSerialTransportService>;
     /**
      * Creates a {@link Layer} providing {@link WasmSerialTransportService}
      * backed by an RTU transport.
      */
-    static fromRtu(options: WasmRtuTransportOpenOptions): Layer.Layer<WasmSerialTransportService>;
+    static fromRtu(options: WasmRtuTransportOpenOptions & TransportResilienceOptions): Layer.Layer<WasmSerialTransportService>;
     /**
-     * Creates a mock {@link Layer} providing {@link WasmSerialTransportService}
-     * for testing or development.
+     * Creates a mock {@link Layer} that provides {@link WasmSerialTransportService}
+     * for tests or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
-     * simulated Modbus slaves and their register/coil maps.
+     * The `devices` parameter is an array of {@link SlaveDeviceDefinition}. Each
+     * definition gives the coil map and the register map of one simulated slave.
+     *
+     * The option set is the same as the option set of the concrete tags. Thus a
+     * test that keeps the framing abstract can also set `retry`, `reconnect`,
+     * `fault`, and `reconnectFault`.
+     *
+     * @param devices - The slave device definitions for the mock.
+     * @returns A function that takes the mock options and gives a scoped
+     *          {@link Layer} that provides the mock service.
+     * @see MockFaultOptions — The `fault` hook and the `reconnectFault` hook.
+     * @see makeMockTransport — The mock factory that this method uses.
      */
-    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: WasmAsciiTransportOpenOptions | WasmRtuTransportOpenOptions) => Layer.Layer<WasmSerialTransportService>;
+    static makeMockTransport: (devices: SlaveDeviceDefinitions) => (options: (WasmAsciiTransportOpenOptions | WasmRtuTransportOpenOptions) & TransportResilienceOptions & MockFaultOptions) => Layer.Layer<WasmSerialTransportService>;
 }
 export {};

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"]`.

package/dist/src/mock-options.test.d.ts

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

package/dist/src/mocks.d.ts

@@ -36,8 +36,8 @@ export interface MockFaultOptions {
  * used when the mock transport initialises.
  */
 export declare const CoilDefinition: Schema.Struct<{
-    address: typeof Schema.Number;
-    default: typeof Schema.Boolean;
+    readonly address: Schema.Number;
+    readonly default: Schema.Boolean;
 }>;
 /**
  * Schema for a single discrete input (digital input) definition.
@@ -46,8 +46,8 @@ export declare const CoilDefinition: Schema.Struct<{
  * boolean state used when the mock transport initialises.
  */
 export declare const DiscreteInputDefinition: Schema.Struct<{
-    address: typeof Schema.Number;
-    default: typeof Schema.Boolean;
+    readonly address: Schema.Number;
+    readonly default: Schema.Boolean;
 }>;
 /**
  * Schema for a single register (holding or input) definition.
@@ -56,8 +56,8 @@ export declare const DiscreteInputDefinition: Schema.Struct<{
  * value used when the mock transport initialises.
  */
 export declare const RegisterDefinition: Schema.Struct<{
-    address: typeof Schema.Number;
-    default: typeof Schema.Number;
+    readonly address: Schema.Number;
+    readonly default: Schema.Number;
 }>;
 /**
  * Schema for a complete slave device definition.
@@ -67,62 +67,46 @@ export declare const RegisterDefinition: Schema.Struct<{
  * registers. All arrays default to `[]` when omitted.
  */
 export declare const SlaveDeviceDefinition: Schema.Struct<{
-    unitId: typeof Schema.Number;
-    coils: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Boolean;
-    }>>, {
-        default: () => never[];
-    }>;
-    discreteInputs: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Boolean;
-    }>>, {
-        default: () => never[];
-    }>;
-    holdingRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Number;
-    }>>, {
-        default: () => never[];
-    }>;
-    inputRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Number;
-    }>>, {
-        default: () => never[];
-    }>;
+    readonly unitId: Schema.Number;
+    readonly coils: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Boolean;
+    }>>, never>;
+    readonly discreteInputs: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Boolean;
+    }>>, never>;
+    readonly holdingRegisters: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Number;
+    }>>, never>;
+    readonly inputRegisters: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Number;
+    }>>, never>;
 }>;
 /**
  * Schema for an array of {@link SlaveDeviceDefinition} — the complete
  * set of slave devices the mock transport should simulate.
  */
-export declare const SlaveDeviceDefinitions: Schema.Array$<Schema.Struct<{
-    unitId: typeof Schema.Number;
-    coils: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Boolean;
-    }>>, {
-        default: () => never[];
-    }>;
-    discreteInputs: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Boolean;
-    }>>, {
-        default: () => never[];
-    }>;
-    holdingRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Number;
-    }>>, {
-        default: () => never[];
-    }>;
-    inputRegisters: Schema.optionalWith<Schema.Array$<Schema.Struct<{
-        address: typeof Schema.Number;
-        default: typeof Schema.Number;
-    }>>, {
-        default: () => never[];
-    }>;
+export declare const SlaveDeviceDefinitions: Schema.$Array<Schema.Struct<{
+    readonly unitId: Schema.Number;
+    readonly coils: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Boolean;
+    }>>, never>;
+    readonly discreteInputs: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Boolean;
+    }>>, never>;
+    readonly holdingRegisters: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Number;
+    }>>, never>;
+    readonly inputRegisters: Schema.withDecodingDefaultType<Schema.$Array<Schema.Struct<{
+        readonly address: Schema.Number;
+        readonly default: Schema.Number;
+    }>>, never>;
 }>>;
 /** Inferred TypeScript type for a {@link CoilDefinition} schema. */
 export type CoilDefinition = Schema.Schema.Type<typeof CoilDefinition>;