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

package/README.md

@@ -4,7 +4,7 @@
 
 For the complete API reference, see the [GitHub Pages documentation](https://flux-control-solutions.github.io/Effect-modbus-rs/).
 
-Provides scoped [`Effect.Service`](https://effect.website) constructors for RTU (serial), TCP, and ASCII Modbus transports. Clients expose a typed `Effect`-based API for all standard Modbus function codes.
+Provides scoped [`Context.Service`](https://effect.website) constructors for RTU (serial), TCP, and ASCII Modbus transports. Clients expose a typed `Effect`-based API for all standard Modbus function codes.
 
 > This project is under active development. Its API may change before the 1.0 release.
 
@@ -44,7 +44,7 @@ program.pipe(
     ModbusInvalidArgumentError: (err) => Console.log(`Invalid argument: ${err.message}`),
   }),
   Effect.catchAll((err) => Console.log(`Unhandled error: ${err.message}`)),
-  Effect.provide(RtuTransportService.Default({ portPath: '/dev/ttyUSB0', baudRate: 9600 })),
+  Effect.provide(RtuTransportService.make({ portPath: '/dev/ttyUSB0', baudRate: 9600 })),
   Effect.scoped,
   Effect.runPromise,
 );
@@ -64,7 +64,7 @@ const program = Effect.gen(function* () {
 });
 
 program.pipe(
-  Effect.provide(TcpTransportService.Default({ host: '192.168.1.100', port: 502 })),
+  Effect.provide(TcpTransportService.make({ host: '192.168.1.100', port: 502 })),
   Effect.scoped,
   Effect.runPromise,
 );
@@ -87,7 +87,7 @@ const program = Effect.gen(function* () {
 });
 
 program.pipe(
-  Effect.provide(AsciiTransportService.Default({ portPath: '/dev/ttyUSB0', baudRate: 9600 })),
+  Effect.provide(AsciiTransportService.make({ portPath: '/dev/ttyUSB0', baudRate: 9600 })),
   Effect.scoped,
   Effect.runPromise,
 );
@@ -112,7 +112,7 @@ const program = Effect.gen(function* () {
 });
 
 program.pipe(
-  Effect.provide(WasmWsTransportService.Default({ wsUrl: 'ws://localhost:8080' })),
+  Effect.provide(WasmWsTransportService.make({ wsUrl: 'ws://localhost:8080' })),
   Effect.scoped,
   Effect.runPromise,
 );
@@ -129,7 +129,7 @@ connectButton.addEventListener('click', () => {
     Effect.gen(function* () {
       const port = yield* requestSerialPort();
       yield* program.pipe(
-        Effect.provide(WasmRtuTransportService.Default({ port, baudRate: 19200 })),
+        Effect.provide(WasmRtuTransportService.make({ port, baudRate: 19200 })),
         Effect.scoped,
       );
     }),
@@ -150,7 +150,7 @@ Not demonstrated in `examples/wasm/` (see that app's README) — the same `impor
 
 ## Transports
 
-Each transport is a scoped `Effect.Service`. You provide it with `Effect.provide`, and the connection is opened on service access and closed when the scope ends.
+Each transport is a scoped `Context.Service`. You provide it with `Effect.provide`, and the connection is opened on service access and closed when the scope ends.
 
 | Service                               | Options                        | Connection                    |
 | ------------------------------------- | ------------------------------ | ----------------------------- |
@@ -279,7 +279,7 @@ Handle with `Effect.catchTags`. The `ModbusError` union type covers all seven va
 Resilience belongs to the **transport**, not to call sites. Attach a policy where the transport is created and every client derived from it carries it:
 
 ```ts
-const layer = TcpTransportService.Default({
+const layer = TcpTransportService.make({
   host: '192.168.1.50',
   port: 502,
   retry: RetryPolicies.tcp(), // applied to every operation
@@ -393,7 +393,7 @@ So `RetryPolicies.tcp()` waits roughly 80–120 ms before its first retry, not e
 Passing `reconnect` hands reconnection to a supervisor fiber owned by the transport — **one reconnect for the whole application**, however many fibers were in flight when the link dropped:
 
 ```ts
-TcpTransportService.Default({
+TcpTransportService.make({
   host,
   port,
   reconnect: {
@@ -445,7 +445,7 @@ See `examples/retry-policies.ts` for a runnable walkthrough.
 `modbus-rs` exposes `retryAttempts`, `retryDelayMs`, and `retryBackoffStrategy` on its transport options. This package removes all three from every transport constructor, so setting one is a compile error rather than a documented hazard:
 
 ```ts
-TcpTransportService.Default({ host, port, retryAttempts: 3 });
+TcpTransportService.make({ host, port, retryAttempts: 3 });
 //                                        ^^^^^^^^^^^^^ Object literal may only specify
 //                                        known properties, and 'retryAttempts' does not
 //                                        exist in type 'TcpTransportOpenOptions & …'
@@ -568,17 +568,17 @@ src/
   connection.ts              — Connection state machine, reconnect supervisor, circuit breaker
   retry.ts                   — Opt-in retry policies (backoff, jitter, per-error rules)
   shared-transport.ts        — Generic scoped transport lifecycle management, WithoutUpstreamRetry
-  RtuTransportService.ts     — Scoped Effect.Service wrapping AsyncRtuTransport
-  TcpTransportService.ts     — Scoped Effect.Service wrapping AsyncTcpTransport
-  AsciiTransportService.ts   — Scoped Effect.Service wrapping AsyncAsciiTransport
+  RtuTransportService.ts     — Scoped Context.Service wrapping AsyncRtuTransport
+  TcpTransportService.ts     — Scoped Context.Service wrapping AsyncTcpTransport
+  AsciiTransportService.ts   — Scoped Context.Service wrapping AsyncAsciiTransport
   SerialTransportService.ts  — Abstract serial transport (RTU/ASCII) tag
   TcpModbusServerService.ts  — tcpServerLayer
   SerialModbusServerService.ts — serialRtuServerLayer / serialAsciiServerLayer
   TcpGatewayService.ts       — tcpGatewayLayer
   WasmSerialPort.ts          — requestSerialPort() Effect helper (browser, user-gesture gated)
-  WasmWsTransportService.ts  — Scoped Effect.Service wrapping WasmWsTransport (browser, WS gateway)
-  WasmRtuTransportService.ts — Scoped Effect.Service wrapping WasmRtuTransport (browser, Web Serial RTU)
-  WasmAsciiTransportService.ts — Scoped Effect.Service wrapping WasmAsciiTransport (browser, Web Serial ASCII)
+  WasmWsTransportService.ts  — Scoped Context.Service wrapping WasmWsTransport (browser, WS gateway)
+  WasmRtuTransportService.ts — Scoped Context.Service wrapping WasmRtuTransport (browser, Web Serial RTU)
+  WasmAsciiTransportService.ts — Scoped Context.Service wrapping WasmAsciiTransport (browser, Web Serial ASCII)
   WasmSerialTransportService.ts — Abstract browser serial transport (RTU/ASCII) tag
   WasmTcpServerService.ts    — wasmWsServerLayer (experimental)
   WasmSerialModbusServerService.ts — wasmSerialRtuServerLayer / wasmSerialAsciiServerLayer (experimental)

package/dist/index.d.ts

@@ -54,7 +54,7 @@
  * every client derived from it:
  *
  * ```ts
- * TcpTransportService.Default({
+ * TcpTransportService.make({
  *   host, port,
  *   retry: RetryPolicies.tcp(),      // applied to every operation
  *   reconnect: {},                   // supervised reconnect + circuit breaker

package/dist/index.js

@@ -55,7 +55,7 @@ var toModbusError = (cause) => {
   }
 };
 // src/retry.ts
-import { Duration, Effect, Schedule } from "effect";
+import { Duration, Effect, Random, Schedule } from "effect";
 var retryableExceptionCodes = [5, 6, 10, 11];
 var defaultRetryableTags = {
   ModbusTimeoutError: true,
@@ -68,7 +68,7 @@ var defaultRetryableTags = {
   ModbusInternalError: false
 };
 var allTags = Object.keys(defaultRetryableTags);
-var toMillis = (input) => Duration.toMillis(Duration.decode(input));
+var toMillis = (input) => Duration.toMillis(Duration.fromInputUnsafe(input));
 var resolveRetryableTags = (options) => {
   const retryable = {};
   for (const tag of allTags) {
@@ -112,10 +112,14 @@ var makeRetryPolicy = (options = {}) => {
     const { baseMs, factor, maxMs } = delays[error._tag];
     return Duration.millis(Math.min(maxMs, baseMs * factor ** retryIndex));
   };
-  const base = Schedule.recurs(options.maxRetries ?? 3).pipe(Schedule.intersect(Schedule.identity()), Schedule.modifyDelay(([retryIndex, error]) => delayFor(error, retryIndex)), Schedule.whileInput(isRetryable));
+  const base = Schedule.recurs(options.maxRetries ?? 3).pipe(Schedule.setInputType(), Schedule.modifyDelay((metadata) => Effect.succeed(delayFor(metadata.input, metadata.attempt - 1))), Schedule.while((metadata) => Effect.succeed(isRetryable(metadata.input))));
   const jitter = options.jitter ?? true;
-  const jittered = jitter === false ? base : Schedule.jitteredWith(base, jitter === true ? {} : jitter);
-  const schedule = options.maxElapsed === undefined ? jittered : Schedule.upTo(jittered, options.maxElapsed);
+  const jittered = jitter === false ? base : jitter === true ? Schedule.jittered(base) : Schedule.modifyDelay(base, (metadata) => Effect.map(Random.next, (r) => {
+    const min = jitter.min ?? 0.8;
+    const max = jitter.max ?? 1.2;
+    return Duration.millis(Duration.toMillis(metadata.duration) * (min + r * (max - min)));
+  }));
+  const schedule = options.maxElapsed === undefined ? jittered : Schedule.upTo(jittered, { duration: options.maxElapsed });
   return { schedule, isRetryable };
 };
 var RetryPolicies = {
@@ -146,7 +150,7 @@ var RetryPolicies = {
 };
 var retryModbus = (policy) => (self) => Effect.retry(self, policy.schedule);
 // src/connection.ts
-import { Data as Data2, Duration as Duration2, Effect as Effect2, Either, SubscriptionRef } from "effect";
+import { Data as Data2, Duration as Duration2, Effect as Effect2, Result, SubscriptionRef } from "effect";
 var ConnectionState = Data2.taggedEnum();
 var defaultReconnectPolicy = makeRetryPolicy({
   maxRetries: 5,
@@ -162,7 +166,7 @@ var resolveReconnect = (options) => {
   const triggerTags = options.triggerOn ?? defaultTriggers;
   return {
     policy: options.policy ?? defaultReconnectPolicy,
-    resetAfter: Duration2.decode(options.resetAfter ?? "30 seconds"),
+    resetAfter: Duration2.fromInputUnsafe(options.resetAfter ?? "30 seconds"),
     triggers: (error) => triggerTags.includes(error._tag)
   };
 };
@@ -181,21 +185,29 @@ var guardCircuit = (state) => Effect2.flatMap(SubscriptionRef.get(state), (curre
 var superviseReconnect = (reconnect, state, resolved) => Effect2.gen(function* () {
   while (true) {
     const attempt = reconnect.pipe(Effect2.tapError(() => SubscriptionRef.update(state, (current) => ConnectionState.$is("Reconnecting")(current) ? ConnectionState.Reconnecting({ attempt: current.attempt + 1 }) : current)), retryModbus(resolved.policy));
-    const result = yield* Effect2.either(attempt);
-    if (Either.isRight(result)) {
+    const result = yield* Effect2.result(attempt);
+    if (Result.isSuccess(result)) {
       yield* SubscriptionRef.set(state, ConnectionState.Connected());
       return;
     }
-    yield* Effect2.logDebug(`Reconnect attempts exhausted: ${result.left.message}`);
-    yield* SubscriptionRef.set(state, ConnectionState.Down({ cause: result.left }));
+    yield* Effect2.logDebug(`Reconnect attempts exhausted: ${result.failure.message}`);
+    yield* SubscriptionRef.set(state, ConnectionState.Down({ cause: result.failure }));
     yield* Effect2.sleep(resolved.resetAfter);
     const probe = yield* SubscriptionRef.modify(state, (current) => ConnectionState.$is("Down")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
     if (!probe)
       return;
   }
 });
+var claimReconnect = (reconnect, state, resolved, scope, onClaim) => Effect2.gen(function* () {
+  const claimed = yield* SubscriptionRef.modify(state, (current) => ConnectionState.$is("Connected")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
+  if (!claimed)
+    return;
+  if (onClaim)
+    yield* onClaim;
+  yield* Effect2.forkIn(superviseReconnect(reconnect, state, resolved), scope);
+});
 // src/AsciiTransportService.ts
-import { Effect as Effect6, Layer } from "effect";
+import { Context, Layer } from "effect";
 
 // src/mocks.ts
 import { Effect as Effect4, Schema, SubscriptionRef as SubscriptionRef2 } from "effect";
@@ -228,7 +240,7 @@ var makeEffectModbusClient = (client) => ({
 });
 var withResilience = (operations, resilience) => {
   const run = (operation) => {
-    const attempt = Effect3.zipRight(resilience.guard, Effect3.suspend(operation)).pipe(Effect3.tapError((error) => resilience.report(error)));
+    const attempt = Effect3.andThen(resilience.guard, Effect3.suspend(operation)).pipe(Effect3.tapError((error) => resilience.report(error)));
     return resilience.policy ? retryModbus(resilience.policy)(attempt) : attempt;
   };
   return {
@@ -266,18 +278,10 @@ var RegisterDefinition = Schema.Struct({
 });
 var SlaveDeviceDefinition = Schema.Struct({
   unitId: Schema.Number,
-  coils: Schema.optionalWith(Schema.Array(CoilDefinition), {
-    default: () => []
-  }),
-  discreteInputs: Schema.optionalWith(Schema.Array(DiscreteInputDefinition), {
-    default: () => []
-  }),
-  holdingRegisters: Schema.optionalWith(Schema.Array(RegisterDefinition), {
-    default: () => []
-  }),
-  inputRegisters: Schema.optionalWith(Schema.Array(RegisterDefinition), {
-    default: () => []
-  })
+  coils: Schema.Array(CoilDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([]))),
+  discreteInputs: Schema.Array(DiscreteInputDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([]))),
+  holdingRegisters: Schema.Array(RegisterDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([]))),
+  inputRegisters: Schema.Array(RegisterDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([])))
 });
 var SlaveDeviceDefinitions = Schema.Array(SlaveDeviceDefinition);
 var buildCoils = (defs) => {
@@ -458,21 +462,16 @@ var makeMockTransport = (devices) => {
     const connectionState = yield* SubscriptionRef2.make(ConnectionState.Connected());
     const supervised = options.reconnect ? resolveReconnect(options.reconnect) : null;
     const serviceScope = yield* Effect4.scope;
-    const reconnectOnce = Effect4.zipRight(Effect4.logDebug("Mock: reconnecting"), Effect4.suspend(() => {
+    const reconnectOnce = Effect4.andThen(Effect4.logDebug("Mock: reconnecting"), Effect4.suspend(() => {
       const injected = options.reconnectFault?.();
       return injected ? Effect4.fail(injected) : Effect4.void;
     }));
     const report = (error) => {
       if (!supervised || !supervised.triggers(error))
         return Effect4.void;
-      return Effect4.gen(function* () {
-        const claimed = yield* SubscriptionRef2.modify(connectionState, (current) => ConnectionState.$is("Connected")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
-        if (!claimed)
-          return;
-        yield* Effect4.forkIn(superviseReconnect(reconnectOnce, connectionState, supervised), serviceScope);
-      });
+      return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope);
     };
-    const guard = Effect4.zipRight(supervised ? guardCircuit(connectionState) : Effect4.void, Effect4.suspend(() => {
+    const guard = Effect4.andThen(supervised ? guardCircuit(connectionState) : Effect4.void, Effect4.suspend(() => {
       const injected = options.fault?.();
       return injected ? Effect4.fail(injected) : Effect4.void;
     }));
@@ -494,8 +493,8 @@ var makeMockTransport = (devices) => {
       }),
       setRequestTimeout: (_timeoutMs) => Effect4.void,
       clearRequestTimeout: () => Effect4.void,
-      reconnect: () => Effect4.zipRight(reconnectOnce, SubscriptionRef2.set(connectionState, ConnectionState.Connected())),
-      close: () => Effect4.zipRight(Effect4.logDebug("Mock: closing transport"), SubscriptionRef2.set(connectionState, ConnectionState.Disconnected())),
+      reconnect: () => Effect4.andThen(reconnectOnce, SubscriptionRef2.set(connectionState, ConnectionState.Connected())),
+      close: () => Effect4.andThen(Effect4.logDebug("Mock: closing transport"), SubscriptionRef2.set(connectionState, ConnectionState.Disconnected())),
       hasPendingRequests: () => false
     };
   });
@@ -511,7 +510,7 @@ var singleFlight = (inFlight, work) => Effect5.uninterruptibleMask((restore) =>
     onNone: () => [[fresh, true], Option.some(fresh)]
   }));
   if (isLeader) {
-    yield* Effect5.forkDaemon(Effect5.interruptible(work).pipe(Effect5.onExit((exit) => Effect5.zipRight(Ref.set(inFlight, Option.none()), Deferred.done(deferred, exit)))));
+    yield* Effect5.forkDetach(Effect5.interruptible(work).pipe(Effect5.onExit((exit) => Effect5.andThen(Ref.set(inFlight, Option.none()), Deferred.done(deferred, exit)))));
   }
   return yield* restore(Deferred.await(deferred));
 }));
@@ -533,11 +532,11 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
       cause: new Error("Transport has been closed"),
       message: "Transport has been closed"
     });
-    const closeOrphan = (t) => Effect5.forkDaemon(Effect5.ignore(Effect5.tryPromise(() => t.close())));
+    const closeOrphan = (t) => Effect5.forkDetach(Effect5.ignore(Effect5.tryPromise(() => t.close())));
     const openTransport = Effect5.tryPromise({
       try: () => openMethod(TC, openOptions),
       catch: (error) => toModbusError(error)
-    }).pipe(Effect5.tap((t) => closed ? closeOrphan(t) : Effect5.zipRight(Effect5.sync(() => {
+    }).pipe(Effect5.tap((t) => closed ? closeOrphan(t) : Effect5.andThen(Effect5.sync(() => {
       transport = t;
     }), SubscriptionRef3.set(connectionState, ConnectionState.Connected()))));
     const ensureOpen = Effect5.fnUntraced(function* () {
@@ -557,7 +556,7 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
       const t = transport;
       if (!t)
         return SubscriptionRef3.set(connectionState, ConnectionState.Disconnected());
-      return Effect5.andThen(Effect5.logDebug(`Closing ${serviceName}`), Effect5.zipRight(Effect5.promise(() => t.close()), SubscriptionRef3.set(connectionState, ConnectionState.Disconnected())));
+      return Effect5.andThen(Effect5.logDebug(`Closing ${serviceName}`), Effect5.andThen(Effect5.promise(() => t.close()), SubscriptionRef3.set(connectionState, ConnectionState.Disconnected())));
     });
     const notConnectedMsg = "Transport is not connected. Call withClient() first.";
     const reconnectOnce = Effect5.suspend(() => {
@@ -572,13 +571,7 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
     const report = (error) => {
       if (!supervised || closed || !supervised.triggers(error))
         return Effect5.void;
-      return Effect5.gen(function* () {
-        const claimed = yield* SubscriptionRef3.modify(connectionState, (current) => ConnectionState.$is("Connected")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
-        if (!claimed)
-          return;
-        yield* Effect5.logDebug(`${serviceName}: reconnecting after ${error.message}`);
-        yield* Effect5.forkIn(superviseReconnect(reconnectOnce, connectionState, supervised), serviceScope);
-      });
+      return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope, Effect5.logDebug(`${serviceName}: reconnecting after ${error.message}`));
     };
     const resilience = {
       guard: supervised ? guardCircuit(connectionState) : Effect5.void,
@@ -665,54 +658,54 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
 }
 
 // src/AsciiTransportService.ts
-class AsciiTransportService extends Effect6.Service()("AsciiTransportService", {
-  scoped: makeTransportScoped("AsyncAsciiTransport", (TC, options) => TC.open(options), "AsciiTransportService")
-}) {
+class AsciiTransportService extends Context.Service()("AsciiTransportService") {
+  static makeScoped = makeTransportScoped("AsyncAsciiTransport", (TC, options) => TC.open(options), "AsciiTransportService");
+  static make = (options) => Layer.effect(AsciiTransportService, AsciiTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer.scoped(AsciiTransportService, factory(options));
+    return (options) => Layer.effect(AsciiTransportService, factory(options));
   };
 }
 // src/SerialTransportService.ts
-import { Context, Layer as Layer3 } from "effect";
+import { Context as Context3, Layer as Layer3 } from "effect";
 
 // src/RtuTransportService.ts
-import { Effect as Effect7, Layer as Layer2 } from "effect";
-class RtuTransportService extends Effect7.Service()("RtuTransportService", {
-  scoped: makeTransportScoped("AsyncRtuTransport", (TC, options) => TC.open(options), "RtuTransportService")
-}) {
+import { Context as Context2, Layer as Layer2 } from "effect";
+class RtuTransportService extends Context2.Service()("RtuTransportService") {
+  static makeScoped = makeTransportScoped("AsyncRtuTransport", (TC, options) => TC.open(options), "RtuTransportService");
+  static make = (options) => Layer2.effect(RtuTransportService, RtuTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer2.scoped(RtuTransportService, factory(options));
+    return (options) => Layer2.effect(RtuTransportService, factory(options));
   };
 }
 
 // src/SerialTransportService.ts
-class SerialTransportService extends Context.Tag("SerialTransportService")() {
+class SerialTransportService extends Context3.Service()("SerialTransportService") {
   static fromAscii(options) {
-    return Layer3.project(AsciiTransportService, SerialTransportService, (ascii) => ascii)(AsciiTransportService.Default(options));
+    return Layer3.flatMap(AsciiTransportService.make(options), (context) => Layer3.succeed(SerialTransportService, Context3.get(context, AsciiTransportService)));
   }
   static fromRtu(options) {
-    return Layer3.project(RtuTransportService, SerialTransportService, (rtu) => rtu)(RtuTransportService.Default(options));
+    return Layer3.flatMap(RtuTransportService.make(options), (context) => Layer3.succeed(SerialTransportService, Context3.get(context, RtuTransportService)));
   }
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer3.scoped(SerialTransportService, factory(options));
+    return (options) => Layer3.effect(SerialTransportService, factory(options));
   };
 }
 // src/TcpTransportService.ts
-import { Effect as Effect8, Layer as Layer4 } from "effect";
-class TcpTransportService extends Effect8.Service()("TcpTransportService", {
-  scoped: makeTransportScoped("AsyncTcpTransport", (TC, options) => TC.connect(options), "TcpTransportService")
-}) {
+import { Context as Context4, Layer as Layer4 } from "effect";
+class TcpTransportService extends Context4.Service()("TcpTransportService") {
+  static makeScoped = makeTransportScoped("AsyncTcpTransport", (TC, options) => TC.connect(options), "TcpTransportService");
+  static make = (options) => Layer4.effect(TcpTransportService, TcpTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer4.scoped(TcpTransportService, factory(options));
+    return (options) => Layer4.effect(TcpTransportService, factory(options));
   };
 }
 // src/SerialModbusServerService.ts
 import { Effect as Effect9, Layer as Layer5 } from "effect";
-var serialRtuServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect9.gen(function* () {
+var serialRtuServerLayer = (options, handlers) => Layer5.effectDiscard(Effect9.gen(function* () {
   const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
   const server = yield* Effect9.tryPromise({
     try: () => AsyncSerialModbusServer.bindRtu(options, handlers),
@@ -722,9 +715,9 @@ var serialRtuServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect9.g
   yield* Effect9.addFinalizer(() => Effect9.logDebug("Serial RTU server shutting down").pipe(Effect9.andThen(Effect9.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect9.catchAll(() => Effect9.void)));
+  })), Effect9.catch(() => Effect9.void)));
 }));
-var serialAsciiServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect9.gen(function* () {
+var serialAsciiServerLayer = (options, handlers) => Layer5.effectDiscard(Effect9.gen(function* () {
   const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
   const server = yield* Effect9.tryPromise({
     try: () => AsyncSerialModbusServer.bindAscii(options, handlers),
@@ -734,11 +727,11 @@ var serialAsciiServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect9
   yield* Effect9.addFinalizer(() => Effect9.logDebug("Serial ASCII server shutting down").pipe(Effect9.andThen(Effect9.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect9.catchAll(() => Effect9.void)));
+  })), Effect9.catch(() => Effect9.void)));
 }));
 // src/TcpModbusServerService.ts
 import { Effect as Effect10, Layer as Layer6 } from "effect";
-var tcpServerLayer = (options, handlers) => Layer6.scopedDiscard(Effect10.gen(function* () {
+var tcpServerLayer = (options, handlers) => Layer6.effectDiscard(Effect10.gen(function* () {
   const { AsyncTcpModbusServer } = yield* Effect10.promise(() => import("modbus-rs"));
   const server = yield* Effect10.tryPromise({
     try: () => AsyncTcpModbusServer.bind(options, handlers),
@@ -748,11 +741,11 @@ var tcpServerLayer = (options, handlers) => Layer6.scopedDiscard(Effect10.gen(fu
   yield* Effect10.addFinalizer(() => Effect10.logDebug("TCP server shutting down").pipe(Effect10.andThen(Effect10.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect10.catchAll(() => Effect10.void)));
+  })), Effect10.catch(() => Effect10.void)));
 }));
 // src/TcpGatewayService.ts
 import { Effect as Effect11, Layer as Layer7 } from "effect";
-var tcpGatewayLayer = (options, gatewayConfig) => Layer7.scopedDiscard(Effect11.gen(function* () {
+var tcpGatewayLayer = (options, gatewayConfig) => Layer7.effectDiscard(Effect11.gen(function* () {
   const { AsyncTcpGateway } = yield* Effect11.promise(() => import("modbus-rs"));
   const gateway = yield* Effect11.tryPromise({
     try: () => AsyncTcpGateway.bind(options, gatewayConfig),
@@ -762,50 +755,50 @@ var tcpGatewayLayer = (options, gatewayConfig) => Layer7.scopedDiscard(Effect11.
   yield* Effect11.addFinalizer(() => Effect11.logDebug("TCP gateway shutting down").pipe(Effect11.andThen(Effect11.tryPromise({
     try: () => gateway.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect11.catchAll(() => Effect11.void)));
+  })), Effect11.catch(() => Effect11.void)));
 }));
 // src/WasmWsTransportService.ts
-import { Effect as Effect12, Layer as Layer8 } from "effect";
-class WasmWsTransportService extends Effect12.Service()("WasmWsTransportService", {
-  scoped: makeTransportScoped("WasmWsTransport", (TC, options) => TC.connect(options), "WasmWsTransportService", { moduleSpecifier: "modbus-rs/web" })
-}) {
+import { Context as Context5, Layer as Layer8 } from "effect";
+class WasmWsTransportService extends Context5.Service()("WasmWsTransportService") {
+  static makeScoped = makeTransportScoped("WasmWsTransport", (TC, options) => TC.connect(options), "WasmWsTransportService", { moduleSpecifier: "modbus-rs/web" });
+  static make = (options) => Layer8.effect(WasmWsTransportService, WasmWsTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer8.scoped(WasmWsTransportService, factory(options));
+    return (options) => Layer8.effect(WasmWsTransportService, factory(options));
   };
 }
 // src/WasmRtuTransportService.ts
-import { Effect as Effect13, Layer as Layer9 } from "effect";
-class WasmRtuTransportService extends Effect13.Service()("WasmRtuTransportService", {
-  scoped: makeTransportScoped("WasmRtuTransport", (TC, { port, ...rest }) => TC.open(port, rest), "WasmRtuTransportService", { moduleSpecifier: "modbus-rs/web" })
-}) {
+import { Context as Context6, Layer as Layer9 } from "effect";
+class WasmRtuTransportService extends Context6.Service()("WasmRtuTransportService") {
+  static makeScoped = makeTransportScoped("WasmRtuTransport", (TC, { port, ...rest }) => TC.open(port, rest), "WasmRtuTransportService", { moduleSpecifier: "modbus-rs/web" });
+  static make = (options) => Layer9.effect(WasmRtuTransportService, WasmRtuTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer9.scoped(WasmRtuTransportService, factory(options));
+    return (options) => Layer9.effect(WasmRtuTransportService, factory(options));
   };
 }
 // src/WasmAsciiTransportService.ts
-import { Effect as Effect14, Layer as Layer10 } from "effect";
-class WasmAsciiTransportService extends Effect14.Service()("WasmAsciiTransportService", {
-  scoped: makeTransportScoped("WasmAsciiTransport", (TC, { port, ...rest }) => TC.open(port, rest), "WasmAsciiTransportService", { moduleSpecifier: "modbus-rs/web" })
-}) {
+import { Context as Context7, Layer as Layer10 } from "effect";
+class WasmAsciiTransportService extends Context7.Service()("WasmAsciiTransportService") {
+  static makeScoped = makeTransportScoped("WasmAsciiTransport", (TC, { port, ...rest }) => TC.open(port, rest), "WasmAsciiTransportService", { moduleSpecifier: "modbus-rs/web" });
+  static make = (options) => Layer10.effect(WasmAsciiTransportService, WasmAsciiTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer10.scoped(WasmAsciiTransportService, factory(options));
+    return (options) => Layer10.effect(WasmAsciiTransportService, factory(options));
   };
 }
 // src/WasmSerialTransportService.ts
-import { Context as Context2, Layer as Layer11 } from "effect";
-class WasmSerialTransportService extends Context2.Tag("WasmSerialTransportService")() {
+import { Context as Context8, Layer as Layer11 } from "effect";
+class WasmSerialTransportService extends Context8.Service()("WasmSerialTransportService") {
   static fromAscii(options) {
-    return Layer11.project(WasmAsciiTransportService, WasmSerialTransportService, (ascii) => ascii)(WasmAsciiTransportService.Default(options));
+    return Layer11.flatMap(WasmAsciiTransportService.make(options), (context) => Layer11.succeed(WasmSerialTransportService, Context8.get(context, WasmAsciiTransportService)));
   }
   static fromRtu(options) {
-    return Layer11.project(WasmRtuTransportService, WasmSerialTransportService, (rtu) => rtu)(WasmRtuTransportService.Default(options));
+    return Layer11.flatMap(WasmRtuTransportService.make(options), (context) => Layer11.succeed(WasmSerialTransportService, Context8.get(context, WasmRtuTransportService)));
   }
   static makeMockTransport = (devices) => {
     const factory = makeMockTransport(devices);
-    return (options) => Layer11.scoped(WasmSerialTransportService, factory(options));
+    return (options) => Layer11.effect(WasmSerialTransportService, factory(options));
   };
 }
 // src/WasmSerialPort.ts
@@ -819,7 +812,7 @@ var requestSerialPort = () => Effect15.tryPromise({
 });
 // src/WasmTcpServerService.ts
 import { Effect as Effect16, Layer as Layer12 } from "effect";
-var wasmWsServerLayer = (options, handlers) => Layer12.scopedDiscard(Effect16.gen(function* () {
+var wasmWsServerLayer = (options, handlers) => Layer12.effectDiscard(Effect16.gen(function* () {
   const { WasmWsModbusServer } = yield* Effect16.promise(() => import("modbus-rs/web"));
   const server = yield* Effect16.tryPromise({
     try: () => WasmWsModbusServer.bind(options, handlers),
@@ -829,15 +822,15 @@ var wasmWsServerLayer = (options, handlers) => Layer12.scopedDiscard(Effect16.ge
   yield* Effect16.forkScoped(Effect16.tryPromise({
     try: () => server.serve(),
     catch: (error) => toModbusError(error)
-  }).pipe(Effect16.catchAll((error) => Effect16.logError("WASM WS server loop ended", error))));
+  }).pipe(Effect16.catch((error) => Effect16.logError("WASM WS server loop ended", error))));
   yield* Effect16.addFinalizer(() => Effect16.logDebug("WASM WS server shutting down").pipe(Effect16.andThen(Effect16.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect16.catchAll(() => Effect16.void)));
+  })), Effect16.catch(() => Effect16.void)));
 }));
 // src/WasmSerialModbusServerService.ts
 import { Effect as Effect17, Layer as Layer13 } from "effect";
-var wasmSerialRtuServerLayer = (options, handlers) => Layer13.scopedDiscard(Effect17.gen(function* () {
+var wasmSerialRtuServerLayer = (options, handlers) => Layer13.effectDiscard(Effect17.gen(function* () {
   const { WasmSerialModbusServer } = yield* Effect17.promise(() => import("modbus-rs/web"));
   const server = yield* Effect17.tryPromise({
     try: () => WasmSerialModbusServer.bindRtu(options, handlers),
@@ -847,13 +840,13 @@ var wasmSerialRtuServerLayer = (options, handlers) => Layer13.scopedDiscard(Effe
   yield* Effect17.forkScoped(Effect17.tryPromise({
     try: () => server.serve(),
     catch: (error) => toModbusError(error)
-  }).pipe(Effect17.catchAll((error) => Effect17.logError("WASM serial RTU server loop ended", error))));
+  }).pipe(Effect17.catch((error) => Effect17.logError("WASM serial RTU server loop ended", error))));
   yield* Effect17.addFinalizer(() => Effect17.logDebug("WASM serial RTU server shutting down").pipe(Effect17.andThen(Effect17.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect17.catchAll(() => Effect17.void)));
+  })), Effect17.catch(() => Effect17.void)));
 }));
-var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.scopedDiscard(Effect17.gen(function* () {
+var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.effectDiscard(Effect17.gen(function* () {
   const { WasmSerialModbusServer } = yield* Effect17.promise(() => import("modbus-rs/web"));
   const server = yield* Effect17.tryPromise({
     try: () => WasmSerialModbusServer.bindAscii(options, handlers),
@@ -863,41 +856,41 @@ var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.scopedDiscard(Ef
   yield* Effect17.forkScoped(Effect17.tryPromise({
     try: () => server.serve(),
     catch: (error) => toModbusError(error)
-  }).pipe(Effect17.catchAll((error) => Effect17.logError("WASM serial ASCII server loop ended", error))));
+  }).pipe(Effect17.catch((error) => Effect17.logError("WASM serial ASCII server loop ended", error))));
   yield* Effect17.addFinalizer(() => Effect17.logDebug("WASM serial ASCII server shutting down").pipe(Effect17.andThen(Effect17.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect17.catchAll(() => Effect17.void)));
+  })), Effect17.catch(() => Effect17.void)));
 }));
 export {
-  wasmWsServerLayer,
-  wasmSerialRtuServerLayer,
-  wasmSerialAsciiServerLayer,
-  toModbusError,
-  tcpServerLayer,
-  tcpGatewayLayer,
-  serialRtuServerLayer,
-  serialAsciiServerLayer,
-  retryableExceptionCodes,
-  retryModbus,
-  requestSerialPort,
-  makeRetryPolicy,
-  WasmWsTransportService,
-  WasmSerialTransportService,
-  WasmRtuTransportService,
-  WasmAsciiTransportService,
-  TcpTransportService,
-  SerialTransportService,
-  RtuTransportService,
-  RetryPolicies,
-  ModbusTransportError,
-  ModbusTimeoutError,
-  ModbusNotConnectedError,
-  ModbusInvalidArgumentError,
-  ModbusInternalError,
-  ModbusExceptionError,
-  ModbusConnectionClosedError,
-  ModbusCircuitOpenError,
+  AsciiTransportService,
   ConnectionState,
-  AsciiTransportService
+  ModbusCircuitOpenError,
+  ModbusConnectionClosedError,
+  ModbusExceptionError,
+  ModbusInternalError,
+  ModbusInvalidArgumentError,
+  ModbusNotConnectedError,
+  ModbusTimeoutError,
+  ModbusTransportError,
+  RetryPolicies,
+  RtuTransportService,
+  SerialTransportService,
+  TcpTransportService,
+  WasmAsciiTransportService,
+  WasmRtuTransportService,
+  WasmSerialTransportService,
+  WasmWsTransportService,
+  makeRetryPolicy,
+  requestSerialPort,
+  retryModbus,
+  retryableExceptionCodes,
+  serialAsciiServerLayer,
+  serialRtuServerLayer,
+  tcpGatewayLayer,
+  tcpServerLayer,
+  toModbusError,
+  wasmSerialAsciiServerLayer,
+  wasmSerialRtuServerLayer,
+  wasmWsServerLayer
 };