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

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,13 +185,13 @@ 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)
@@ -195,7 +199,7 @@ var superviseReconnect = (reconnect, state, resolved) => Effect2.gen(function* (
   }
 });
 // 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 +232,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 +270,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,7 +454,7 @@ 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;
     }));
@@ -472,7 +468,7 @@ var makeMockTransport = (devices) => {
         yield* Effect4.forkIn(superviseReconnect(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 +490,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 +507,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 +529,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 +553,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(() => {
@@ -665,54 +661,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 +718,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 +730,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 +744,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 +758,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 +815,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 +825,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 +843,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 +859,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
 };

package/dist/src/AsciiTransportService.d.ts

@@ -1,16 +1,37 @@
-import { Effect, Layer } from 'effect';
+import { Context, Effect, Layer } from 'effect';
 import type { AsciiTransportOptions } from 'modbus-rs';
 import { SlaveDeviceDefinitions } from './mocks';
 import type { MockFaultOptions } from './mocks';
-import type { TransportResilienceOptions, WithoutUpstreamRetry } from './shared-transport';
+import type { TransportResilienceOptions, WithoutUpstreamRetry, TransportServiceApi } from './shared-transport';
 /**
  * {@link AsciiTransportOptions} minus the upstream retry knobs.
  *
  * @see WithoutUpstreamRetry — Why they are withheld.
  */
 export type AsciiTransportOpenOptions = WithoutUpstreamRetry<AsciiTransportOptions>;
-declare const AsciiTransportService_base: Effect.Service.Class<AsciiTransportService, "AsciiTransportService", {
-    readonly scoped: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+declare const AsciiTransportService_base: Context.ServiceClass<AsciiTransportService, "AsciiTransportService", TransportServiceApi>;
+/**
+ * Scoped Effect service wrapping the `modbus-rs` {@link AsyncAsciiTransport}
+ * for ASCII (serial) Modbus communication.
+ *
+ * The transport connection is opened lazily on the first call to
+ * `withClient(unitId)` and automatically closed when the consuming
+ * {@link Effect.Scope | Scope} finalizes.
+ *
+ * Clients are created per `unitId` via
+ * {@link AsyncAsciiTransport.createClient} and cached, so repeated
+ * requests for the same unit ID reuse the same client.
+ *
+ * @see AsyncAsciiTransport — Upstream `modbus-rs` ASCII transport.
+ * @see AsciiTransportOpenOptions — Configuration for the ASCII serial port.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class AsciiTransportService extends AsciiTransportService_base {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link AsciiTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -31,24 +52,12 @@ declare const AsciiTransportService_base: Effect.Service.Class<AsciiTransportSer
         close: () => Effect.Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
         hasPendingRequests: () => boolean;
     }, never, import("effect/Scope").Scope>;
-}>;
-/**
- * Scoped Effect service wrapping the `modbus-rs` {@link AsyncAsciiTransport}
- * for ASCII (serial) Modbus communication.
- *
- * The transport connection is opened lazily on the first call to
- * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
- *
- * Clients are created per `unitId` via
- * {@link AsyncAsciiTransport.createClient} and cached, so repeated
- * requests for the same unit ID reuse the same client.
- *
- * @see AsyncAsciiTransport — Upstream `modbus-rs` ASCII transport.
- * @see AsciiTransportOpenOptions — Configuration for the ASCII serial port.
- * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
- */
-export declare class AsciiTransportService extends AsciiTransportService_base {
+    /**
+     * Creates a {@link Layer} providing a live {@link AsciiTransportService}.
+     *
+     * @param options - Connection and resilience options for the transport.
+     */
+    static readonly make: (options: AsciiTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<AsciiTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link AsciiTransportService} for testing or development.

package/dist/src/RtuTransportService.d.ts

@@ -1,16 +1,37 @@
-import { Effect, Layer } from 'effect';
+import { Context, Effect, Layer } from 'effect';
 import type { RtuTransportOptions } from 'modbus-rs';
 import type { MockFaultOptions } from './mocks';
 import type { SlaveDeviceDefinitions } from './mocks';
-import type { TransportResilienceOptions, WithoutUpstreamRetry } from './shared-transport';
+import type { TransportResilienceOptions, WithoutUpstreamRetry, TransportServiceApi } from './shared-transport';
 /**
  * {@link RtuTransportOptions} minus the upstream retry knobs.
  *
  * @see WithoutUpstreamRetry — Why they are withheld.
  */
 export type RtuTransportOpenOptions = WithoutUpstreamRetry<RtuTransportOptions>;
-declare const RtuTransportService_base: Effect.Service.Class<RtuTransportService, "RtuTransportService", {
-    readonly scoped: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
+declare const RtuTransportService_base: Context.ServiceClass<RtuTransportService, "RtuTransportService", TransportServiceApi>;
+/**
+ * Scoped Effect service wrapping the `modbus-rs` {@link AsyncRtuTransport}
+ * for RTU (serial) Modbus communication.
+ *
+ * The transport connection is opened lazily on the first call to
+ * `withClient(unitId)` and automatically closed when the consuming
+ * {@link Effect.Scope | Scope} finalizes.
+ *
+ * Clients are created per `unitId` via
+ * {@link AsyncRtuTransport.createClient} and cached, so repeated
+ * requests for the same unit ID reuse the same client.
+ *
+ * @see AsyncRtuTransport — Upstream `modbus-rs` RTU transport.
+ * @see RtuTransportOpenOptions — Configuration for the RTU serial port.
+ * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
+ */
+export declare class RtuTransportService extends RtuTransportService_base {
+    /**
+     * Scoped constructor effect for the service. v4 does not auto-generate a
+     * layer from this, so {@link RtuTransportService.make} builds one explicitly.
+     */
+    static readonly makeScoped: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Effect.Effect<{
         connectionState: import("effect/SubscriptionRef").SubscriptionRef<{
             readonly _tag: "Connected";
         } | {
@@ -31,24 +52,12 @@ declare const RtuTransportService_base: Effect.Service.Class<RtuTransportService
         close: () => Effect.Effect<void, import("./errors").ModbusError, import("effect/Scope").Scope>;
         hasPendingRequests: () => boolean;
     }, never, import("effect/Scope").Scope>;
-}>;
-/**
- * Scoped Effect service wrapping the `modbus-rs` {@link AsyncRtuTransport}
- * for RTU (serial) Modbus communication.
- *
- * The transport connection is opened lazily on the first call to
- * `withClient(unitId)` and automatically closed when the consuming
- * {@link Effect.Scope | Scope} finalizes.
- *
- * Clients are created per `unitId` via
- * {@link AsyncRtuTransport.createClient} and cached, so repeated
- * requests for the same unit ID reuse the same client.
- *
- * @see AsyncRtuTransport — Upstream `modbus-rs` RTU transport.
- * @see RtuTransportOpenOptions — Configuration for the RTU serial port.
- * @see makeTransportScoped — Generic lifecycle logic from shared-transport.
- */
-export declare class RtuTransportService extends RtuTransportService_base {
+    /**
+     * Creates a {@link Layer} providing a live {@link RtuTransportService}.
+     *
+     * @param options - Connection and resilience options for the transport.
+     */
+    static readonly make: (options: RtuTransportOpenOptions & TransportResilienceOptions) => Layer.Layer<RtuTransportService>;
     /**
      * Creates a {@link Layer} providing an in-memory mock
      * {@link RtuTransportService} for testing or development.