@flux-control/effect-modbus-rs 0.7.0 → 0.8.1

package/dist/src/AsciiTransportService.d.ts

@@ -1,4 +1,5 @@
-import { Context, Layer } from 'effect';
+/** Provides scoped ASCII Modbus transport layers and an in-memory mock layer. */
+import { Context, Effect, Layer } from 'effect';
 import type { AsciiTransportOptions } from 'modbus-rs';
 import { type MockFaultOptions, type SlaveDeviceDefinitions } from './mocks';
 import type { TransportResilienceOptions, WithoutUpstreamRetry, TransportServiceApi } from './shared-transport';
@@ -15,7 +16,7 @@ declare const AsciiTransportService_base: Context.ServiceClass<AsciiTransportSer
  *
  * The transport connection is opened lazily on the first call to
  * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
+ * scope finalizes.
  *
  * Clients are created per `unitId` via
  * {@link AsyncAsciiTransport.createClient} and cached, so repeated
@@ -30,7 +31,7 @@ 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) => import("effect/Effect").Effect<{
+    static readonly makeScoped: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -44,34 +45,34 @@ export declare class AsciiTransportService extends AsciiTransportService_base {
         }>;
         withClient: (unitId: number, clientOptions?: {
             readonly retry?: import("./retry").ModbusRetryPolicy;
-        } | undefined) => import("effect/Effect").Effect<import("./modbus-client").EffectModbusClient, import("./errors").ModbusError, never>;
-        setRequestTimeout: (timeoutMs: number) => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
-        clearRequestTimeout: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
-        reconnect: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusError, never>;
-        close: () => import("effect/Effect").Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
+        } | 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: (scope: import("effect/Scope").Closeable) => Effect.Effect<void, import("./errors").ModbusError, never>;
         withBatchingClient: (unitId: number, options?: import("./batching-client").BatchingClientOptions & {
             readonly retry?: import("./retry").ModbusRetryPolicy;
-        }) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
-        batchingClient: (unitId: number) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError>;
+        }) => Effect.Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
+        batchingClient: (unitId: number) => Effect.Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError>;
         readonly touchedUnits: Set<number>;
         hasPendingRequests: () => boolean;
     }, never, import("effect/Scope").Scope>;
     /**
      * Creates a {@link Layer} providing a live {@link AsciiTransportService}.
      *
-     * @param options - Connection and resilience options for the transport.
+     * @param options - Serial ASCII options and optional retry, reconnect, and connect-timeout settings.
+     * @returns A layer whose scope opens the connection on first use and closes it on finalization.
      */
     static readonly make: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<AsciiTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link AsciiTransportService} for testing or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * Accepts an array of {@link SlaveDeviceDefinition} values describing the
      * simulated Modbus slaves and their register/coil maps.
      *
      * @param devices - Slave device definitions for the mock.
-     * @returns A function that takes {@link AsciiTransportOpenOptions} and
-     *          returns a scoped {@link Layer} providing the mock service.
+     * @returns A factory that accepts transport, resilience, and mock-fault options and returns a layer for the mock service.
      *
      * @see makeMockTransport — The underlying mock factory.
      */

package/dist/src/RtuTransportService.d.ts

@@ -1,4 +1,5 @@
-import { Context, Layer } from 'effect';
+/** Provides scoped RTU Modbus transport layers and an in-memory mock layer. */
+import { Context, Effect, Layer } from 'effect';
 import type { RtuTransportOptions } from 'modbus-rs';
 import { type MockFaultOptions, type SlaveDeviceDefinitions } from './mocks';
 import type { TransportResilienceOptions, WithoutUpstreamRetry, TransportServiceApi } from './shared-transport';
@@ -15,7 +16,7 @@ declare const RtuTransportService_base: Context.ServiceClass<RtuTransportService
  *
  * The transport connection is opened lazily on the first call to
  * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
+ * scope finalizes.
  *
  * Clients are created per `unitId` via
  * {@link AsyncRtuTransport.createClient} and cached, so repeated
@@ -30,7 +31,7 @@ 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) => import("effect/Effect").Effect<{
+    static readonly makeScoped: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -44,34 +45,34 @@ export declare class RtuTransportService extends RtuTransportService_base {
         }>;
         withClient: (unitId: number, clientOptions?: {
             readonly retry?: import("./retry").ModbusRetryPolicy;
-        } | undefined) => import("effect/Effect").Effect<import("./modbus-client").EffectModbusClient, import("./errors").ModbusError, never>;
-        setRequestTimeout: (timeoutMs: number) => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
-        clearRequestTimeout: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
-        reconnect: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusError, never>;
-        close: () => import("effect/Effect").Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
+        } | 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: (scope: import("effect/Scope").Closeable) => Effect.Effect<void, import("./errors").ModbusError, never>;
         withBatchingClient: (unitId: number, options?: import("./batching-client").BatchingClientOptions & {
             readonly retry?: import("./retry").ModbusRetryPolicy;
-        }) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
-        batchingClient: (unitId: number) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError>;
+        }) => Effect.Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
+        batchingClient: (unitId: number) => Effect.Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError>;
         readonly touchedUnits: Set<number>;
         hasPendingRequests: () => boolean;
     }, never, import("effect/Scope").Scope>;
     /**
      * Creates a {@link Layer} providing a live {@link RtuTransportService}.
      *
-     * @param options - Connection and resilience options for the transport.
+     * @param options - Serial RTU options and optional retry, reconnect, and connect-timeout settings.
+     * @returns A layer whose scope opens the connection on first use and closes it on finalization.
      */
     static readonly make: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<RtuTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link RtuTransportService} for testing or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * Accepts an array of {@link SlaveDeviceDefinition} values describing the
      * simulated Modbus slaves and their register/coil maps.
      *
      * @param devices - Slave device definitions for the mock.
-     * @returns A function that takes {@link RtuTransportOpenOptions} and
-     *          returns a scoped {@link Layer} providing the mock service.
+     * @returns A factory that accepts transport, resilience, and mock-fault options and returns a layer for the mock service.
      *
      * @see makeMockTransport — The underlying mock factory.
      */

package/dist/src/SerialModbusServerService.d.ts

@@ -1,3 +1,4 @@
+/** Defines scoped RTU and ASCII Modbus serial server layers. */
 import { Layer } from 'effect';
 import type { SerialServerOptions, ServerHandlers } from 'modbus-rs';
 import type { ModbusError } from './errors';
@@ -6,7 +7,7 @@ import type { ModbusError } from './errors';
  *
  * @param options - Serial port options (path, baud rate, unit ID, etc.).
  * @param handlers - Callback functions that handle incoming Modbus requests.
- * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ * @returns A layer that starts the server; bind failures enter the `ModbusError` channel. Scope finalization shuts it down, and shutdown failures are ignored.
  *
  * @example
  * ```ts
@@ -30,7 +31,7 @@ export declare const serialRtuServerLayer: (options: SerialServerOptions, handle
  *
  * @param options - Serial port options (path, baud rate, unit ID, etc.).
  * @param handlers - Callback functions that handle incoming Modbus requests.
- * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ * @returns A layer that starts the server; bind failures enter the `ModbusError` channel. Scope finalization shuts it down, and shutdown failures are ignored.
  *
  * @example
  * ```ts

package/dist/src/SerialTransportService.d.ts

@@ -1,3 +1,4 @@
+/** Exposes one serial transport tag that can use RTU, ASCII, or mock framing. */
 import { Context, Layer } from 'effect';
 import { type AsciiTransportOpenOptions } from './AsciiTransportService';
 import { type MockFaultOptions, type SlaveDeviceDefinitions } from './mocks';
@@ -27,11 +28,17 @@ export declare class SerialTransportService extends SerialTransportService_base
     /**
      * Creates a {@link Layer} providing {@link SerialTransportService}
      * backed by an ASCII transport.
+     *
+     * @param options - ASCII transport and optional resilience settings.
+     * @returns A layer that opens the transport on first use and closes it when its scope ends.
      */
     static fromAscii(options: AsciiTransportOpenOptions & TransportResilienceOptions): Layer.Layer<SerialTransportService>;
     /**
      * Creates a {@link Layer} providing {@link SerialTransportService}
      * backed by an RTU transport.
+     *
+     * @param options - RTU transport and optional resilience settings.
+     * @returns A layer that opens the transport on first use and closes it when its scope ends.
      */
     static fromRtu(options: RtuTransportOpenOptions & TransportResilienceOptions): Layer.Layer<SerialTransportService>;
     /**
@@ -46,8 +53,7 @@ export declare class SerialTransportService extends SerialTransportService_base
      * `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.
+     * @returns A factory that accepts either framing's transport options, resilience settings, and mock-fault settings, then provides a scoped mock layer.
      * @see MockFaultOptions — The `fault` hook and the `reconnectFault` hook.
      * @see makeMockTransport — The mock factory that this method uses.
      */

package/dist/src/TcpGatewayService.d.ts

@@ -1,3 +1,4 @@
+/** Defines a scoped layer for a Modbus TCP gateway. */
 import { Layer } from 'effect';
 import type { GatewayBindOptions, GatewayConfig } from 'modbus-rs';
 import type { ModbusError } from './errors';
@@ -12,7 +13,7 @@ import type { ModbusError } from './errors';
  * @param options - Gateway bind options (host, port).
  * @param gatewayConfig - Routing configuration with downstream server
  *   definitions and a unit-ID-to-channel route table.
- * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ * @returns A layer that starts the gateway; bind failures enter the `ModbusError` channel. Scope finalization shuts it down, and shutdown failures are ignored.
  *
  * @example
  * ```ts

package/dist/src/TcpModbusServerService.d.ts

@@ -1,3 +1,4 @@
+/** Defines a scoped layer for a Modbus TCP server. */
 import { Layer } from 'effect';
 import type { ServerHandlers, TcpServerOptions } from 'modbus-rs';
 import type { ModbusError } from './errors';
@@ -10,7 +11,7 @@ import type { ModbusError } from './errors';
  *
  * @param options - Server bind options (host, port, unit ID).
  * @param handlers - Callback functions that handle incoming Modbus requests.
- * @returns A `Layer` that fails with {@link ModbusError} on bind failure.
+ * @returns A layer that starts the server; bind failures enter the `ModbusError` channel. Scope finalization shuts it down, and shutdown failures are ignored.
  *
  * @example
  * ```ts

package/dist/src/TcpTransportService.d.ts

@@ -1,3 +1,4 @@
+/** Provides scoped TCP Modbus transport layers and an in-memory mock layer. */
 import { Context, Layer } from 'effect';
 import type { TcpTransportOptions } from 'modbus-rs';
 import { type MockFaultOptions, type SlaveDeviceDefinitions } from './mocks';
@@ -15,7 +16,7 @@ declare const TcpTransportService_base: Context.ServiceClass<TcpTransportService
  *
  * The transport connection is opened lazily on the first call to
  * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
+ * scope finalizes.
  *
  * Clients are created per `unitId` via
  * {@link AsyncTcpTransport.createClient} and cached, so repeated
@@ -48,7 +49,7 @@ export declare class TcpTransportService extends TcpTransportService_base {
         setRequestTimeout: (timeoutMs: number) => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         clearRequestTimeout: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         reconnect: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusError, never>;
-        close: () => import("effect/Effect").Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
+        close: (scope: import("effect/Scope").Closeable) => import("effect/Effect").Effect<void, import("./errors").ModbusError, never>;
         withBatchingClient: (unitId: number, options?: import("./batching-client").BatchingClientOptions & {
             readonly retry?: import("./retry").ModbusRetryPolicy;
         }) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
@@ -59,19 +60,19 @@ 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.
+     * @param options - TCP connection options and optional retry, reconnect, and connect-timeout settings.
+     * @returns A layer whose scope opens the connection on first use and closes it on finalization.
      */
     static readonly make: (options: TcpTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<TcpTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link TcpTransportService} for testing or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * Accepts an array of {@link SlaveDeviceDefinition} values describing the
      * simulated Modbus slaves and their register/coil maps.
      *
      * @param devices - Slave device definitions for the mock.
-     * @returns A function that takes {@link TcpTransportOpenOptions} and
-     *          returns a scoped {@link Layer} providing the mock service.
+     * @returns A factory that accepts transport, resilience, and mock-fault options and returns a layer for the mock service.
      *
      * @see makeMockTransport — The underlying mock factory.
      */

package/dist/src/WasmAsciiTransportService.d.ts

@@ -8,7 +8,8 @@ import type { TransportResilienceOptions, TransportServiceApi } from './shared-t
  * combines them into one object so it fits {@link createTransportScoped}'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).
+ * Obtain the `port` handle with {@link requestSerialPort}. Call it from a browser
+ * user-gesture handler because the browser may require transient user activation.
  */
 export type WasmAsciiTransportOpenOptions = WasmSerialTransportOptions & {
     port: WasmSerialPortHandle;
@@ -16,11 +17,12 @@ export type WasmAsciiTransportOpenOptions = 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.
+ * for Modbus ASCII over the Web Serial API. The caller obtains the port handle;
+ * this service does not request browser permission.
  *
  * The transport connection is opened lazily on the first call to
  * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
+ * 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.
@@ -31,8 +33,10 @@ declare const WasmAsciiTransportService_base: Context.ServiceClass<WasmAsciiTran
  */
 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.
+     * Builds the scoped transport service effect. The transport opens on first use
+     * and its connection closes when the consuming scope ends.
+     *
+     * @returns An effect that provides the service for the lifetime of its scope.
      */
     static readonly makeScoped: (options: WasmSerialTransportOptions & {
         port: WasmSerialPortHandle;
@@ -54,7 +58,7 @@ export declare class WasmAsciiTransportService extends WasmAsciiTransportService
         setRequestTimeout: (timeoutMs: number) => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         clearRequestTimeout: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         reconnect: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusError, never>;
-        close: () => import("effect/Effect").Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
+        close: (scope: import("effect/Scope").Closeable) => import("effect/Effect").Effect<void, import("./errors").ModbusError, never>;
         withBatchingClient: (unitId: number, options?: import("./batching-client").BatchingClientOptions & {
             readonly retry?: import("./retry").ModbusRetryPolicy;
         }) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
@@ -66,18 +70,20 @@ export declare class WasmAsciiTransportService extends WasmAsciiTransportService
      * Creates a {@link Layer} providing a live {@link WasmAsciiTransportService}.
      *
      * @param options - Connection and resilience options for the transport.
+     * @returns A layer that provides the scoped service.
      */
     static readonly make: (options: WasmAsciiTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<WasmAsciiTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link WasmAsciiTransportService} for testing or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * Accepts an array of {@link SlaveDeviceDefinitions} 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.
+     *          returns a scoped {@link Layer} providing the mock service. The mock
+     *          uses device definitions and fault hooks instead of browser I/O.
      *
      * @see makeMockTransport — The underlying mock factory.
      */

package/dist/src/WasmRtuTransportService.d.ts

@@ -8,7 +8,8 @@ import type { TransportResilienceOptions, TransportServiceApi } from './shared-t
  * combines them into one object so it fits {@link createTransportScoped}'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).
+ * Obtain the `port` handle with {@link requestSerialPort}. Call it from a browser
+ * user-gesture handler because the browser may require transient user activation.
  */
 export type WasmRtuTransportOpenOptions = WasmSerialTransportOptions & {
     port: WasmSerialPortHandle;
@@ -16,11 +17,12 @@ export type WasmRtuTransportOpenOptions = 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.
+ * for Modbus RTU over the Web Serial API. The caller obtains the port handle;
+ * this service does not request browser permission.
  *
  * The transport connection is opened lazily on the first call to
  * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
+ * 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.
@@ -31,8 +33,10 @@ declare const WasmRtuTransportService_base: Context.ServiceClass<WasmRtuTranspor
  */
 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.
+     * Builds the scoped transport service effect. The transport opens on first use
+     * and its connection closes when the consuming scope ends.
+     *
+     * @returns An effect that provides the service for the lifetime of its scope.
      */
     static readonly makeScoped: (options: WasmSerialTransportOptions & {
         port: WasmSerialPortHandle;
@@ -54,7 +58,7 @@ export declare class WasmRtuTransportService extends WasmRtuTransportService_bas
         setRequestTimeout: (timeoutMs: number) => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         clearRequestTimeout: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         reconnect: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusError, never>;
-        close: () => import("effect/Effect").Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
+        close: (scope: import("effect/Scope").Closeable) => import("effect/Effect").Effect<void, import("./errors").ModbusError, never>;
         withBatchingClient: (unitId: number, options?: import("./batching-client").BatchingClientOptions & {
             readonly retry?: import("./retry").ModbusRetryPolicy;
         }) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
@@ -66,18 +70,20 @@ export declare class WasmRtuTransportService extends WasmRtuTransportService_bas
      * Creates a {@link Layer} providing a live {@link WasmRtuTransportService}.
      *
      * @param options - Connection and resilience options for the transport.
+     * @returns A layer that provides the scoped service.
      */
     static readonly make: (options: WasmRtuTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<WasmRtuTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link WasmRtuTransportService} for testing or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * Accepts an array of {@link SlaveDeviceDefinitions} 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.
+     *          returns a scoped {@link Layer} providing the mock service. The mock
+     *          uses device definitions and fault hooks instead of browser I/O.
      *
      * @see makeMockTransport — The underlying mock factory.
      */

package/dist/src/WasmSerialModbusServerService.d.ts

@@ -19,7 +19,8 @@ import type { ModbusError } from './errors';
  * @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.
+ * @returns A layer that binds the server and runs its request loop within the
+ *   layer scope. Binding errors fail with {@link ModbusError}; loop errors are logged.
  *
  * @example
  * ```ts
@@ -46,7 +47,8 @@ export declare const wasmSerialRtuServerLayer: (options: WasmSerialServerOptions
  *
  * @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.
+ * @returns A layer that binds the server and runs its request loop within the
+ *   layer scope. Binding errors fail with {@link ModbusError}; loop errors are logged.
  *
  * @see WasmSerialServerOptions — Options accepted by the upstream WASM serial server.
  * @see ServerHandlers — Interface for request handler callbacks.

package/dist/src/WasmSerialPort.d.ts

@@ -6,10 +6,10 @@ import type { ModbusError } from './errors';
  * {@link WasmSerialTransportService.fromRtu} / `.fromAscii` (or
  * `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
- * constraint (`navigator.serial.requestPort()` semantics), not a library-imposed
- * restriction. Calling it outside a gesture will reject.
+ * Call this from a browser user-gesture handler, such as a click handler, because
+ * the Web Serial API may require transient user activation to show its chooser.
+ * The helper loads the browser binding before requesting the port, so it does not
+ * itself call the browser API synchronously in the handler.
  *
  * @example
  * ```ts
@@ -22,6 +22,8 @@ import type { ModbusError } from './errors';
  * });
  * ```
  *
+ * @returns An effect that succeeds with the selected opaque port handle or fails
+ *   with {@link ModbusError} when the browser request or binding fails.
  * @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

@@ -5,7 +5,7 @@ import { type WasmAsciiTransportOpenOptions } from './WasmAsciiTransportService'
 import { type WasmRtuTransportOpenOptions } from './WasmRtuTransportService';
 declare const WasmSerialTransportService_base: Context.ServiceClass<WasmSerialTransportService, "WasmSerialTransportService", TransportServiceApi>;
 /**
- * Abstract browser (WASM) serial Modbus transport service tag.
+ * Abstract browser 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
@@ -23,17 +23,24 @@ declare const WasmSerialTransportService_base: Context.ServiceClass<WasmSerialTr
  * Layer.provide(WasmSerialTransportService.fromRtu({ port, baudRate: 9600 }))
  * ```
  *
- * @see requestSerialPort — Obtains the `port` handle both providers need (must be called from a user gesture).
+ * Obtain the serial port handle with {@link requestSerialPort}. Call it from a
+ * browser user-gesture handler because the browser may require transient activation.
  */
 export declare class WasmSerialTransportService extends WasmSerialTransportService_base {
     /**
      * Creates a {@link Layer} providing {@link WasmSerialTransportService}
      * backed by an ASCII transport.
+     *
+     * @param options - Serial connection and resilience options.
+     * @returns A layer that provides the ASCII transport through the abstract service tag.
      */
     static fromAscii(options: WasmAsciiTransportOpenOptions & TransportResilienceOptions): Layer.Layer<WasmSerialTransportService>;
     /**
      * Creates a {@link Layer} providing {@link WasmSerialTransportService}
      * backed by an RTU transport.
+     *
+     * @param options - Serial connection and resilience options.
+     * @returns A layer that provides the RTU transport through the abstract service tag.
      */
     static fromRtu(options: WasmRtuTransportOpenOptions & TransportResilienceOptions): Layer.Layer<WasmSerialTransportService>;
     /**

package/dist/src/WasmTcpServerService.d.ts

@@ -17,7 +17,8 @@ import type { ModbusError } from './errors';
  * @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.
+ * @returns A layer that binds the server and runs its request loop within the
+ *   layer scope. Binding errors fail with {@link ModbusError}; loop errors are logged.
  *
  * @example
  * ```ts

package/dist/src/WasmWsTransportService.d.ts

@@ -9,7 +9,7 @@ declare const WasmWsTransportService_base: Context.ServiceClass<WasmWsTransportS
  *
  * The transport connection is opened lazily on the first call to
  * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
+ * 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.
@@ -20,8 +20,10 @@ declare const WasmWsTransportService_base: Context.ServiceClass<WasmWsTransportS
  */
 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.
+     * Builds the scoped transport service effect. The transport opens on first use
+     * and its connection closes when the consuming scope ends.
+     *
+     * @returns An effect that provides the service for the lifetime of its scope.
      */
     static readonly makeScoped: (options: WasmWsTransportOptions & TransportResilienceOptions) => import("effect/Effect").Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
@@ -41,7 +43,7 @@ export declare class WasmWsTransportService extends WasmWsTransportService_base
         setRequestTimeout: (timeoutMs: number) => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         clearRequestTimeout: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusNotConnectedError, never>;
         reconnect: () => import("effect/Effect").Effect<undefined, import("./errors").ModbusError, never>;
-        close: () => import("effect/Effect").Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
+        close: (scope: import("effect/Scope").Closeable) => import("effect/Effect").Effect<void, import("./errors").ModbusError, never>;
         withBatchingClient: (unitId: number, options?: import("./batching-client").BatchingClientOptions & {
             readonly retry?: import("./retry").ModbusRetryPolicy;
         }) => import("effect/Effect").Effect<import("./batching-client").BatchingModbusClient, import("./errors").ModbusError | import("./errors").ModbusUnitAlreadyDeclaredError>;
@@ -53,18 +55,20 @@ 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.
+     * @returns A layer that provides the scoped service.
      */
     static readonly make: (options: WasmWsTransportOptions & TransportResilienceOptions) => Layer.Layer<WasmWsTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link WasmWsTransportService} for testing or development.
      *
-     * Accepts an array of {@link SlaveDeviceDefinition} describing the
+     * Accepts an array of {@link SlaveDeviceDefinitions} describing the
      * simulated Modbus slaves and their register/coil maps.
      *
      * @param devices - Slave device definitions for the mock.
      * @returns A function that takes {@link WasmWsTransportOptions} and
-     *          returns a scoped {@link Layer} providing the mock service.
+     *          returns a scoped {@link Layer} providing the mock service. The mock
+     *          uses device definitions and fault hooks instead of network I/O.
      *
      * @see makeMockTransport — The underlying mock factory.
      */