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

package/dist/index.js

@@ -25,6 +25,9 @@ class ModbusInternalError extends Data.TaggedError("ModbusInternalError") {
 
 class ModbusNotConnectedError extends Data.TaggedError("ModbusNotConnectedError") {
 }
+
+class ModbusCircuitOpenError extends Data.TaggedError("ModbusCircuitOpenError") {
+}
 function parseExceptionCode(message) {
   const m = message.match(/\[MODBUS_EXCEPTION:(\d+)\]/);
   return m ? Number(m[1]) : undefined;
@@ -51,14 +54,204 @@ var toModbusError = (cause) => {
       return new ModbusInternalError({ cause, message });
   }
 };
+// src/retry.ts
+import { Duration, Effect, Schedule } from "effect";
+var retryableExceptionCodes = [5, 6, 10, 11];
+var defaultRetryableTags = {
+  ModbusTimeoutError: true,
+  ModbusTransportError: true,
+  ModbusConnectionClosedError: true,
+  ModbusExceptionError: true,
+  ModbusInvalidArgumentError: false,
+  ModbusNotConnectedError: false,
+  ModbusCircuitOpenError: true,
+  ModbusInternalError: false
+};
+var allTags = Object.keys(defaultRetryableTags);
+var toMillis = (input) => Duration.toMillis(Duration.decode(input));
+var resolveRetryableTags = (options) => {
+  const retryable = {};
+  for (const tag of allTags) {
+    const entry = options.errors?.[tag];
+    retryable[tag] = entry === undefined ? defaultRetryableTags[tag] : entry !== false;
+  }
+  return retryable;
+};
+var defaultCurve = { baseMs: 100, factor: 2, maxMs: 5000 };
+var resolveCurve = (overrides, fallback) => ({
+  baseMs: overrides.baseDelay === undefined ? fallback.baseMs : toMillis(overrides.baseDelay),
+  factor: overrides.factor ?? fallback.factor,
+  maxMs: overrides.maxDelay === undefined ? fallback.maxMs : toMillis(overrides.maxDelay)
+});
+var resolveDelays = (options) => {
+  const policyCurve = resolveCurve(options, defaultCurve);
+  const delays = {};
+  for (const tag of allTags) {
+    const entry = options.errors?.[tag];
+    delays[tag] = resolveCurve(typeof entry === "object" ? entry : {}, policyCurve);
+  }
+  return delays;
+};
+var mergeOptions = (base, overrides) => overrides === undefined ? base : {
+  ...base,
+  ...overrides,
+  ...base.errors || overrides.errors ? { errors: { ...base.errors, ...overrides.errors } } : {}
+};
+var makeRetryPolicy = (options = {}) => {
+  const retryable = resolveRetryableTags(options);
+  const delays = resolveDelays(options);
+  const exceptions = options.retryableExceptions ?? retryableExceptionCodes;
+  const isRetryable = (error) => {
+    if (!retryable[error._tag])
+      return false;
+    if (error._tag === "ModbusExceptionError")
+      return exceptions.includes(error.exception);
+    return true;
+  };
+  const delayFor = (error, retryIndex) => {
+    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 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);
+  return { schedule, isRetryable };
+};
+var RetryPolicies = {
+  none: (overrides) => makeRetryPolicy(mergeOptions({ maxRetries: 0 }, overrides)),
+  serial: (overrides) => makeRetryPolicy(mergeOptions({
+    maxRetries: 3,
+    baseDelay: "50 millis",
+    factor: 2,
+    maxDelay: "1 second",
+    errors: { ModbusTimeoutError: { baseDelay: "100 millis" } }
+  }, overrides)),
+  tcp: (overrides) => makeRetryPolicy(mergeOptions({
+    maxRetries: 4,
+    baseDelay: "100 millis",
+    factor: 2,
+    maxDelay: "5 seconds",
+    errors: {
+      ModbusConnectionClosedError: { baseDelay: "250 millis", maxDelay: "10 seconds" }
+    }
+  }, overrides)),
+  persistent: (overrides) => makeRetryPolicy(mergeOptions({
+    maxRetries: 10,
+    baseDelay: "250 millis",
+    factor: 2,
+    maxDelay: "30 seconds",
+    maxElapsed: "5 minutes"
+  }, overrides))
+};
+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";
+var ConnectionState = Data2.taggedEnum();
+var defaultReconnectPolicy = makeRetryPolicy({
+  maxRetries: 5,
+  baseDelay: "250 millis",
+  factor: 2,
+  maxDelay: "10 seconds"
+});
+var defaultTriggers = [
+  "ModbusConnectionClosedError",
+  "ModbusTransportError"
+];
+var resolveReconnect = (options) => {
+  const triggerTags = options.triggerOn ?? defaultTriggers;
+  return {
+    policy: options.policy ?? defaultReconnectPolicy,
+    resetAfter: Duration2.decode(options.resetAfter ?? "30 seconds"),
+    triggers: (error) => triggerTags.includes(error._tag)
+  };
+};
+var guardCircuit = (state) => Effect2.flatMap(SubscriptionRef.get(state), (current) => ConnectionState.$match(current, {
+  Disconnected: () => Effect2.void,
+  Connected: () => Effect2.void,
+  Reconnecting: ({ attempt }) => Effect2.fail(new ModbusCircuitOpenError({
+    cause: new Error("Transport is reconnecting"),
+    message: `Transport is reconnecting (attempt ${attempt}); request refused`
+  })),
+  Down: ({ cause }) => Effect2.fail(new ModbusCircuitOpenError({
+    cause: cause.cause,
+    message: `Transport is down (${cause.message}); request refused`
+  }))
+}));
+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)) {
+      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.sleep(resolved.resetAfter);
+    const probe = yield* SubscriptionRef.modify(state, (current) => ConnectionState.$is("Down")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
+    if (!probe)
+      return;
+  }
+});
 // src/AsciiTransportService.ts
-import { Effect as Effect4, Layer } from "effect";
+import { Effect as Effect6, Layer } from "effect";
 
 // src/mocks.ts
-import { Effect, Schema } from "effect";
+import { Effect as Effect4, Schema, SubscriptionRef as SubscriptionRef2 } from "effect";
 import {
   CoilState
 } from "modbus-rs";
+
+// src/modbus-client.ts
+import { Effect as Effect3 } from "effect";
+var wrap = (try_) => Effect3.tryPromise({
+  try: try_,
+  catch: (error) => toModbusError(error)
+});
+var makeEffectModbusClient = (client) => ({
+  readHoldingRegisters: (opts) => wrap(() => client.readHoldingRegisters(opts)),
+  readInputRegisters: (opts) => wrap(() => client.readInputRegisters(opts)),
+  writeSingleRegister: (opts) => wrap(() => client.writeSingleRegister(opts)),
+  writeMultipleRegisters: (opts) => wrap(() => client.writeMultipleRegisters(opts)),
+  readWriteMultipleRegisters: (opts) => wrap(() => client.readWriteMultipleRegisters(opts)),
+  readCoils: (opts) => wrap(() => client.readCoils(opts)),
+  writeSingleCoil: (opts) => wrap(() => client.writeSingleCoil(opts)),
+  writeMultipleCoils: (opts) => wrap(() => client.writeMultipleCoils(opts)),
+  readDiscreteInputs: (opts) => wrap(() => client.readDiscreteInputs(opts)),
+  readFifoQueue: (opts) => wrap(() => client.readFifoQueue(opts)),
+  readFileRecord: (opts) => wrap(() => client.readFileRecord(opts)),
+  writeFileRecord: (opts) => wrap(() => client.writeFileRecord(opts)),
+  readExceptionStatus: () => wrap(() => client.readExceptionStatus()),
+  diagnostics: (opts) => wrap(() => client.diagnostics(opts)),
+  readDeviceIdentification: (opts) => wrap(() => client.readDeviceIdentification(opts))
+});
+var withResilience = (operations, resilience) => {
+  const run = (operation) => {
+    const attempt = Effect3.zipRight(resilience.guard, Effect3.suspend(operation)).pipe(Effect3.tapError((error) => resilience.report(error)));
+    return resilience.policy ? retryModbus(resilience.policy)(attempt) : attempt;
+  };
+  return {
+    readHoldingRegisters: (opts) => run(() => operations.readHoldingRegisters(opts)),
+    readInputRegisters: (opts) => run(() => operations.readInputRegisters(opts)),
+    writeSingleRegister: (opts) => run(() => operations.writeSingleRegister(opts)),
+    writeMultipleRegisters: (opts) => run(() => operations.writeMultipleRegisters(opts)),
+    readWriteMultipleRegisters: (opts) => run(() => operations.readWriteMultipleRegisters(opts)),
+    readCoils: (opts) => run(() => operations.readCoils(opts)),
+    writeSingleCoil: (opts) => run(() => operations.writeSingleCoil(opts)),
+    writeMultipleCoils: (opts) => run(() => operations.writeMultipleCoils(opts)),
+    readDiscreteInputs: (opts) => run(() => operations.readDiscreteInputs(opts)),
+    readFifoQueue: (opts) => run(() => operations.readFifoQueue(opts)),
+    readFileRecord: (opts) => run(() => operations.readFileRecord(opts)),
+    writeFileRecord: (opts) => run(() => operations.writeFileRecord(opts)),
+    readExceptionStatus: () => run(() => operations.readExceptionStatus()),
+    diagnostics: (opts) => run(() => operations.diagnostics(opts)),
+    readDeviceIdentification: (opts) => run(() => operations.readDeviceIdentification(opts)),
+    withRetry: (policy) => withResilience(operations, { ...resilience, policy })
+  };
+};
+
+// src/mocks.ts
 var CoilDefinition = Schema.Struct({
   address: Schema.Number,
   default: Schema.Boolean
@@ -112,8 +305,8 @@ var failOutOfRange = (label, address, quantity) => new ModbusInvalidArgumentErro
   message: quantity !== undefined ? `${label} read out of range: address=${address}, quantity=${quantity}` : `${label} write out of range: address=${address}`
 });
 var makeMockModbusClient = (state, unitId) => ({
-  readCoils: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} readCoils`, opts);
+  readCoils: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readCoils`, opts);
     if (opts.address + opts.quantity > state.maxCoilAddress + 1) {
       return yield* failOutOfRange("Coil", opts.address, opts.quantity);
     }
@@ -123,8 +316,8 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return result;
   }),
-  readDiscreteInputs: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} readDiscreteInputs`, opts);
+  readDiscreteInputs: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readDiscreteInputs`, opts);
     if (opts.address + opts.quantity > state.maxDiscreteAddress + 1) {
       return yield* failOutOfRange("DiscreteInput", opts.address, opts.quantity);
     }
@@ -134,8 +327,8 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return result;
   }),
-  readHoldingRegisters: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} readHoldingRegisters`, opts);
+  readHoldingRegisters: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readHoldingRegisters`, opts);
     if (opts.address + opts.quantity > state.maxHoldingAddress + 1) {
       return yield* failOutOfRange("HoldingRegister", opts.address, opts.quantity);
     }
@@ -145,8 +338,8 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return new Uint16Array(result);
   }),
-  readInputRegisters: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} readInputRegisters`, opts);
+  readInputRegisters: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readInputRegisters`, opts);
     if (opts.address + opts.quantity > state.maxInputAddress + 1) {
       return yield* failOutOfRange("InputRegister", opts.address, opts.quantity);
     }
@@ -156,15 +349,15 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return new Uint16Array(result);
   }),
-  writeSingleCoil: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} writeSingleCoil`, opts);
+  writeSingleCoil: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeSingleCoil`, opts);
     if (opts.address > state.maxCoilAddress) {
       return yield* failOutOfRange("Coil", opts.address);
     }
     state.coils.set(opts.address, opts.value === CoilState.On);
   }),
-  writeMultipleCoils: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} writeMultipleCoils`, opts);
+  writeMultipleCoils: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeMultipleCoils`, opts);
     if (opts.address + opts.values.length > state.maxCoilAddress + 1) {
       return yield* failOutOfRange("Coil", opts.address, opts.values.length);
     }
@@ -172,15 +365,15 @@ var makeMockModbusClient = (state, unitId) => ({
       state.coils.set(opts.address + i, opts.values[i] === CoilState.On);
     }
   }),
-  writeSingleRegister: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} writeSingleRegister`, opts);
+  writeSingleRegister: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeSingleRegister`, opts);
     if (opts.address > state.maxHoldingAddress) {
       return yield* failOutOfRange("HoldingRegister", opts.address);
     }
     state.holdingRegisters.set(opts.address, opts.value);
   }),
-  writeMultipleRegisters: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} writeMultipleRegisters`, opts);
+  writeMultipleRegisters: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeMultipleRegisters`, opts);
     if (opts.address + opts.values.length > state.maxHoldingAddress + 1) {
       return yield* failOutOfRange("HoldingRegister", opts.address, opts.values.length);
     }
@@ -188,8 +381,8 @@ var makeMockModbusClient = (state, unitId) => ({
       state.holdingRegisters.set(opts.address + i, opts.values[i]);
     }
   }),
-  readWriteMultipleRegisters: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} readWriteMultipleRegisters`, opts);
+  readWriteMultipleRegisters: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readWriteMultipleRegisters`, opts);
     if (opts.writeAddress + opts.writeValues.length > state.maxHoldingAddress + 1) {
       return yield* failOutOfRange("HoldingRegister", opts.writeAddress, opts.writeValues.length);
     }
@@ -205,34 +398,34 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return new Uint16Array(result);
   }),
-  readFifoQueue: Effect.fnUntraced(function* (_opts) {
+  readFifoQueue: Effect4.fnUntraced(function* (_opts) {
     return yield* new ModbusInvalidArgumentError({
       cause: new Error("FIFO queue not yet supported in mock"),
       message: "FIFO queue not yet supported in mock"
     });
   }),
-  readFileRecord: Effect.fnUntraced(function* (_opts) {
+  readFileRecord: Effect4.fnUntraced(function* (_opts) {
     return yield* new ModbusInvalidArgumentError({
       cause: new Error("File records not yet supported in mock"),
       message: "File records not yet supported in mock"
     });
   }),
-  writeFileRecord: Effect.fnUntraced(function* (_opts) {
+  writeFileRecord: Effect4.fnUntraced(function* (_opts) {
     return yield* new ModbusInvalidArgumentError({
       cause: new Error("File records not yet supported in mock"),
       message: "File records not yet supported in mock"
     });
   }),
-  readExceptionStatus: Effect.fnUntraced(function* () {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} readExceptionStatus`);
+  readExceptionStatus: Effect4.fnUntraced(function* () {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readExceptionStatus`);
     return 0;
   }),
-  diagnostics: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} diagnostics`, opts);
+  diagnostics: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} diagnostics`, opts);
     return { subFunction: opts.subFunction, data: new Uint16Array };
   }),
-  readDeviceIdentification: Effect.fnUntraced(function* (opts) {
-    yield* Effect.logDebug(`[Mock] unitId=${unitId} readDeviceIdentification`, opts);
+  readDeviceIdentification: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readDeviceIdentification`, opts);
     return {
       conformityLevel: 1,
       moreFollows: false,
@@ -260,10 +453,32 @@ var makeMockTransport = (devices) => {
       maxInputAddress: input.maxAddress
     });
   }
-  return (_options) => Effect.gen(function* () {
-    yield* Effect.logDebug("Mock transport opened with devices:", deviceDefs);
+  return (options) => Effect4.gen(function* () {
+    yield* Effect4.logDebug("Mock transport opened with devices:", deviceDefs);
+    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 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);
+      });
+    };
+    const guard = Effect4.zipRight(supervised ? guardCircuit(connectionState) : Effect4.void, Effect4.suspend(() => {
+      const injected = options.fault?.();
+      return injected ? Effect4.fail(injected) : Effect4.void;
+    }));
     return {
-      withClient: Effect.fnUntraced(function* (unitId) {
+      connectionState,
+      withClient: Effect4.fnUntraced(function* (unitId, clientOptions) {
         const state = deviceStates.get(unitId);
         if (!state) {
           return yield* new ModbusInvalidArgumentError({
@@ -271,115 +486,122 @@ var makeMockTransport = (devices) => {
             message: `Device with unitId ${unitId} not found in mock configuration`
           });
         }
-        return makeMockModbusClient(state, unitId);
+        return withResilience(makeMockModbusClient(state, unitId), {
+          guard,
+          report,
+          policy: clientOptions?.retry ?? options.retry
+        });
       }),
-      setRequestTimeout: (_timeoutMs) => Effect.void,
-      clearRequestTimeout: () => Effect.void,
-      reconnect: () => Effect.asVoid(Effect.logDebug("Mock: reconnecting")),
-      close: () => Effect.logDebug("Mock: closing transport"),
+      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())),
       hasPendingRequests: () => false
     };
   });
 };
 
 // src/shared-transport.ts
-import { Effect as Effect3, Exit, Scope } from "effect";
-
-// src/modbus-client.ts
-import { Effect as Effect2 } from "effect";
-var wrap = (try_) => Effect2.tryPromise({
-  try: try_,
-  catch: (error) => toModbusError(error)
-});
-var makeEffectModbusClient = (client) => ({
-  readHoldingRegisters: (opts) => wrap(() => client.readHoldingRegisters(opts)),
-  readInputRegisters: (opts) => wrap(() => client.readInputRegisters(opts)),
-  writeSingleRegister: (opts) => wrap(() => client.writeSingleRegister(opts)),
-  writeMultipleRegisters: (opts) => wrap(() => client.writeMultipleRegisters(opts)),
-  readWriteMultipleRegisters: (opts) => wrap(() => client.readWriteMultipleRegisters(opts)),
-  readCoils: (opts) => wrap(() => client.readCoils(opts)),
-  writeSingleCoil: (opts) => wrap(() => client.writeSingleCoil(opts)),
-  writeMultipleCoils: (opts) => wrap(() => client.writeMultipleCoils(opts)),
-  readDiscreteInputs: (opts) => wrap(() => client.readDiscreteInputs(opts)),
-  readFifoQueue: (opts) => wrap(() => client.readFifoQueue(opts)),
-  readFileRecord: (opts) => wrap(() => client.readFileRecord(opts)),
-  writeFileRecord: (opts) => wrap(() => client.writeFileRecord(opts)),
-  readExceptionStatus: () => wrap(() => client.readExceptionStatus()),
-  diagnostics: (opts) => wrap(() => client.diagnostics(opts)),
-  readDeviceIdentification: (opts) => wrap(() => client.readDeviceIdentification(opts))
-});
-
-// src/shared-transport.ts
+import { Deferred, Effect as Effect5, Exit, Option, Ref, Scope, SubscriptionRef as SubscriptionRef3 } from "effect";
+var makeInFlight = () => Ref.make(Option.none());
+var singleFlight = (inFlight, work) => Effect5.uninterruptibleMask((restore) => Effect5.gen(function* () {
+  const fresh = yield* Deferred.make();
+  const [deferred, isLeader] = yield* Ref.modify(inFlight, (current) => Option.match(current, {
+    onSome: (existing) => [[existing, false], current],
+    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)))));
+  }
+  return yield* restore(Deferred.await(deferred));
+}));
 function makeTransportScoped(transportKey, openMethod, serviceName, config) {
-  return Effect3.fnUntraced(function* (options) {
-    const mod = config?.moduleSpecifier === "modbus-rs/web" ? yield* Effect3.promise(() => import("modbus-rs/web")) : yield* Effect3.promise(() => import("modbus-rs"));
+  return Effect5.fnUntraced(function* (options) {
+    const { retry: transportRetry, reconnect: reconnectOptions, ...rest } = options;
+    const openOptions = rest;
+    const mod = config?.moduleSpecifier === "modbus-rs/web" ? yield* Effect5.promise(() => import("modbus-rs/web")) : yield* Effect5.promise(() => import("modbus-rs"));
     const TC = mod[transportKey];
     let transport = null;
-    let connectPromise = null;
-    let reconnectPromise = null;
+    const opening = yield* makeInFlight();
+    const reconnecting = yield* makeInFlight();
+    const connectionState = yield* SubscriptionRef3.make(ConnectionState.Disconnected());
+    const supervised = reconnectOptions ? resolveReconnect(reconnectOptions) : null;
+    const serviceScope = yield* Effect5.scope;
     const clientSet = new Map;
     let closed = false;
-    const ensureOpen = Effect3.fnUntraced(function* () {
-      if (transport) {
-        if (closed) {
-          return yield* new ModbusNotConnectedError({
-            cause: new Error("Transport has been closed"),
-            message: "Transport has been closed"
-          });
-        }
-        return transport;
-      }
-      if (closed) {
-        return yield* new ModbusNotConnectedError({
-          cause: new Error("Transport has been closed"),
-          message: "Transport has been closed"
-        });
-      }
-      if (!connectPromise) {
-        connectPromise = openMethod(TC, options);
-      }
-      const t = yield* Effect3.tryPromise({
-        try: () => connectPromise,
-        catch: (error) => toModbusError(error)
-      }).pipe(Effect3.catchAll((err) => {
-        connectPromise = null;
-        return Effect3.fail(err);
-      }));
-      if (closed) {
-        connectPromise = null;
-        yield* Effect3.fork(Effect3.promise(() => t.close()).pipe(Effect3.catchAll(() => Effect3.void)));
-        return yield* new ModbusNotConnectedError({
-          cause: new Error("Transport has been closed"),
-          message: "Transport has been closed"
-        });
-      }
+    const transportClosed = () => new ModbusNotConnectedError({
+      cause: new Error("Transport has been closed"),
+      message: "Transport has been closed"
+    });
+    const closeOrphan = (t) => Effect5.forkDaemon(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(() => {
       transport = t;
+    }), SubscriptionRef3.set(connectionState, ConnectionState.Connected()))));
+    const ensureOpen = Effect5.fnUntraced(function* () {
+      if (closed)
+        return yield* transportClosed();
+      if (transport)
+        return transport;
+      const t = yield* singleFlight(opening, openTransport);
+      if (closed)
+        return yield* transportClosed();
       return t;
     });
-    yield* Effect3.addFinalizer(() => {
+    yield* Effect5.addFinalizer(() => {
       if (closed)
-        return Effect3.void;
+        return Effect5.void;
       closed = true;
       const t = transport;
       if (!t)
-        return Effect3.void;
-      return Effect3.andThen(Effect3.logDebug(`Closing ${serviceName}`), Effect3.promise(() => t.close()));
+        return SubscriptionRef3.set(connectionState, ConnectionState.Disconnected());
+      return Effect5.andThen(Effect5.logDebug(`Closing ${serviceName}`), Effect5.zipRight(Effect5.promise(() => t.close()), SubscriptionRef3.set(connectionState, ConnectionState.Disconnected())));
     });
     const notConnectedMsg = "Transport is not connected. Call withClient() first.";
+    const reconnectOnce = Effect5.suspend(() => {
+      const t = transport;
+      if (closed || !t)
+        return transportClosed();
+      return singleFlight(reconnecting, Effect5.tryPromise({
+        try: () => t.reconnect(),
+        catch: (error) => toModbusError(error)
+      }).pipe(Effect5.tap(() => closed ? closeOrphan(t) : Effect5.void)));
+    });
+    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);
+      });
+    };
+    const resilience = {
+      guard: supervised ? guardCircuit(connectionState) : Effect5.void,
+      report
+    };
     return {
-      withClient: Effect3.fnUntraced(function* (unitId) {
+      connectionState,
+      withClient: Effect5.fnUntraced(function* (unitId, clientOptions) {
         const t = yield* ensureOpen();
         let client = clientSet.get(unitId);
         if (!client) {
-          client = yield* Effect3.try({
+          client = yield* Effect5.try({
             try: () => t.createClient({ unitId }),
             catch: (error) => toModbusError(error)
           });
           clientSet.set(unitId, client);
         }
-        return makeEffectModbusClient(client);
+        return withResilience(makeEffectModbusClient(client), {
+          ...resilience,
+          policy: clientOptions?.retry ?? transportRetry
+        });
       }),
-      setRequestTimeout: Effect3.fnUntraced(function* (timeoutMs) {
+      setRequestTimeout: Effect5.fnUntraced(function* (timeoutMs) {
         const t = transport;
         if (!t || closed) {
           return yield* new ModbusNotConnectedError({
@@ -389,7 +611,7 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
         }
         t.setRequestTimeout(timeoutMs);
       }),
-      clearRequestTimeout: Effect3.fnUntraced(function* () {
+      clearRequestTimeout: Effect5.fnUntraced(function* () {
         const t = transport;
         if (!t || closed) {
           return yield* new ModbusNotConnectedError({
@@ -399,42 +621,35 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
         }
         t.clearRequestTimeout();
       }),
-      reconnect: Effect3.fnUntraced(function* () {
-        if (closed) {
-          return yield* new ModbusNotConnectedError({
-            cause: new Error("Transport has been closed"),
-            message: "Transport has been closed"
-          });
-        }
-        if (transport) {
-          if (!reconnectPromise) {
-            reconnectPromise = transport.reconnect().then(() => {
-              reconnectPromise = null;
-            }).catch((err) => {
-              reconnectPromise = null;
-              throw err;
-            });
-          }
-          yield* Effect3.tryPromise({
-            try: () => reconnectPromise,
-            catch: (error) => toModbusError(error)
-          });
-        } else {
+      reconnect: Effect5.fnUntraced(function* () {
+        if (closed)
+          return yield* transportClosed();
+        const t = transport;
+        if (!t) {
           yield* ensureOpen();
+          return;
         }
+        yield* singleFlight(reconnecting, Effect5.tryPromise({
+          try: () => t.reconnect(),
+          catch: (error) => toModbusError(error)
+        }).pipe(Effect5.tap(() => closed ? closeOrphan(t) : Effect5.void)));
+        if (closed)
+          return yield* transportClosed();
+        yield* SubscriptionRef3.set(connectionState, ConnectionState.Connected());
       }),
-      close: Effect3.fnUntraced(function* () {
+      close: Effect5.fnUntraced(function* () {
         if (closed)
           return;
         closed = true;
+        yield* SubscriptionRef3.set(connectionState, ConnectionState.Disconnected());
         const t = transport;
         if (t) {
-          yield* Effect3.tryPromise({
+          yield* Effect5.tryPromise({
             try: () => t.close(),
             catch: (error) => toModbusError(error)
           });
         }
-        const scope = yield* Effect3.scope;
+        const scope = yield* Effect5.scope;
         yield* Scope.close(scope, Exit.void);
       }),
       hasPendingRequests: () => {
@@ -450,7 +665,7 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
 }
 
 // src/AsciiTransportService.ts
-class AsciiTransportService extends Effect4.Service()("AsciiTransportService", {
+class AsciiTransportService extends Effect6.Service()("AsciiTransportService", {
   scoped: makeTransportScoped("AsyncAsciiTransport", (TC, options) => TC.open(options), "AsciiTransportService")
 }) {
   static makeMockTransport = (devices) => {
@@ -462,8 +677,8 @@ class AsciiTransportService extends Effect4.Service()("AsciiTransportService", {
 import { Context, Layer as Layer3 } from "effect";
 
 // src/RtuTransportService.ts
-import { Effect as Effect5, Layer as Layer2 } from "effect";
-class RtuTransportService extends Effect5.Service()("RtuTransportService", {
+import { Effect as Effect7, Layer as Layer2 } from "effect";
+class RtuTransportService extends Effect7.Service()("RtuTransportService", {
   scoped: makeTransportScoped("AsyncRtuTransport", (TC, options) => TC.open(options), "RtuTransportService")
 }) {
   static makeMockTransport = (devices) => {
@@ -486,8 +701,8 @@ class SerialTransportService extends Context.Tag("SerialTransportService")() {
   };
 }
 // src/TcpTransportService.ts
-import { Effect as Effect7, Layer as Layer4 } from "effect";
-class TcpTransportService extends Effect7.Service()("TcpTransportService", {
+import { Effect as Effect8, Layer as Layer4 } from "effect";
+class TcpTransportService extends Effect8.Service()("TcpTransportService", {
   scoped: makeTransportScoped("AsyncTcpTransport", (TC, options) => TC.connect(options), "TcpTransportService")
 }) {
   static makeMockTransport = (devices) => {
@@ -496,62 +711,62 @@ class TcpTransportService extends Effect7.Service()("TcpTransportService", {
   };
 }
 // src/SerialModbusServerService.ts
-import { Effect as Effect8, Layer as Layer5 } from "effect";
-var serialRtuServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect8.gen(function* () {
-  const { AsyncSerialModbusServer } = yield* Effect8.promise(() => import("modbus-rs"));
-  const server = yield* Effect8.tryPromise({
+import { Effect as Effect9, Layer as Layer5 } from "effect";
+var serialRtuServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect9.gen(function* () {
+  const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
+  const server = yield* Effect9.tryPromise({
     try: () => AsyncSerialModbusServer.bindRtu(options, handlers),
     catch: (error) => toModbusError(error)
   });
-  yield* Effect8.logDebug(`Serial RTU server bound to ${options.portPath}`);
-  yield* Effect8.addFinalizer(() => Effect8.logDebug("Serial RTU server shutting down").pipe(Effect8.andThen(Effect8.tryPromise({
+  yield* Effect9.logDebug(`Serial RTU server bound to ${options.portPath}`);
+  yield* Effect9.addFinalizer(() => Effect9.logDebug("Serial RTU server shutting down").pipe(Effect9.andThen(Effect9.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect8.catchAll(() => Effect8.void)));
+  })), Effect9.catchAll(() => Effect9.void)));
 }));
-var serialAsciiServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect8.gen(function* () {
-  const { AsyncSerialModbusServer } = yield* Effect8.promise(() => import("modbus-rs"));
-  const server = yield* Effect8.tryPromise({
+var serialAsciiServerLayer = (options, handlers) => Layer5.scopedDiscard(Effect9.gen(function* () {
+  const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
+  const server = yield* Effect9.tryPromise({
     try: () => AsyncSerialModbusServer.bindAscii(options, handlers),
     catch: (error) => toModbusError(error)
   });
-  yield* Effect8.logDebug(`Serial ASCII server bound to ${options.portPath}`);
-  yield* Effect8.addFinalizer(() => Effect8.logDebug("Serial ASCII server shutting down").pipe(Effect8.andThen(Effect8.tryPromise({
+  yield* Effect9.logDebug(`Serial ASCII server bound to ${options.portPath}`);
+  yield* Effect9.addFinalizer(() => Effect9.logDebug("Serial ASCII server shutting down").pipe(Effect9.andThen(Effect9.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect8.catchAll(() => Effect8.void)));
+  })), Effect9.catchAll(() => Effect9.void)));
 }));
 // src/TcpModbusServerService.ts
-import { Effect as Effect9, Layer as Layer6 } from "effect";
-var tcpServerLayer = (options, handlers) => Layer6.scopedDiscard(Effect9.gen(function* () {
-  const { AsyncTcpModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
-  const server = yield* Effect9.tryPromise({
+import { Effect as Effect10, Layer as Layer6 } from "effect";
+var tcpServerLayer = (options, handlers) => Layer6.scopedDiscard(Effect10.gen(function* () {
+  const { AsyncTcpModbusServer } = yield* Effect10.promise(() => import("modbus-rs"));
+  const server = yield* Effect10.tryPromise({
     try: () => AsyncTcpModbusServer.bind(options, handlers),
     catch: (error) => toModbusError(error)
   });
-  yield* Effect9.logDebug(`TCP server bound to ${options.host}:${options.port}`);
-  yield* Effect9.addFinalizer(() => Effect9.logDebug("TCP server shutting down").pipe(Effect9.andThen(Effect9.tryPromise({
+  yield* Effect10.logDebug(`TCP server bound to ${options.host}:${options.port}`);
+  yield* Effect10.addFinalizer(() => Effect10.logDebug("TCP server shutting down").pipe(Effect10.andThen(Effect10.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect9.catchAll(() => Effect9.void)));
+  })), Effect10.catchAll(() => Effect10.void)));
 }));
 // src/TcpGatewayService.ts
-import { Effect as Effect10, Layer as Layer7 } from "effect";
-var tcpGatewayLayer = (options, gatewayConfig) => Layer7.scopedDiscard(Effect10.gen(function* () {
-  const { AsyncTcpGateway } = yield* Effect10.promise(() => import("modbus-rs"));
-  const gateway = yield* Effect10.tryPromise({
+import { Effect as Effect11, Layer as Layer7 } from "effect";
+var tcpGatewayLayer = (options, gatewayConfig) => Layer7.scopedDiscard(Effect11.gen(function* () {
+  const { AsyncTcpGateway } = yield* Effect11.promise(() => import("modbus-rs"));
+  const gateway = yield* Effect11.tryPromise({
     try: () => AsyncTcpGateway.bind(options, gatewayConfig),
     catch: (error) => toModbusError(error)
   });
-  yield* Effect10.logDebug(`TCP gateway bound to ${options.host}:${options.port}`);
-  yield* Effect10.addFinalizer(() => Effect10.logDebug("TCP gateway shutting down").pipe(Effect10.andThen(Effect10.tryPromise({
+  yield* Effect11.logDebug(`TCP gateway bound to ${options.host}:${options.port}`);
+  yield* Effect11.addFinalizer(() => Effect11.logDebug("TCP gateway shutting down").pipe(Effect11.andThen(Effect11.tryPromise({
     try: () => gateway.shutdown(),
     catch: (error) => toModbusError(error)
-  })), Effect10.catchAll(() => Effect10.void)));
+  })), Effect11.catchAll(() => Effect11.void)));
 }));
 // src/WasmWsTransportService.ts
-import { Effect as Effect11, Layer as Layer8 } from "effect";
-class WasmWsTransportService extends Effect11.Service()("WasmWsTransportService", {
+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" })
 }) {
   static makeMockTransport = (devices) => {
@@ -560,8 +775,8 @@ class WasmWsTransportService extends Effect11.Service()("WasmWsTransportService"
   };
 }
 // src/WasmRtuTransportService.ts
-import { Effect as Effect12, Layer as Layer9 } from "effect";
-class WasmRtuTransportService extends Effect12.Service()("WasmRtuTransportService", {
+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" })
 }) {
   static makeMockTransport = (devices) => {
@@ -570,8 +785,8 @@ class WasmRtuTransportService extends Effect12.Service()("WasmRtuTransportServic
   };
 }
 // src/WasmAsciiTransportService.ts
-import { Effect as Effect13, Layer as Layer10 } from "effect";
-class WasmAsciiTransportService extends Effect13.Service()("WasmAsciiTransportService", {
+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" })
 }) {
   static makeMockTransport = (devices) => {
@@ -663,7 +878,10 @@ export {
   tcpGatewayLayer,
   serialRtuServerLayer,
   serialAsciiServerLayer,
+  retryableExceptionCodes,
+  retryModbus,
   requestSerialPort,
+  makeRetryPolicy,
   WasmWsTransportService,
   WasmSerialTransportService,
   WasmRtuTransportService,
@@ -671,6 +889,7 @@ export {
   TcpTransportService,
   SerialTransportService,
   RtuTransportService,
+  RetryPolicies,
   ModbusTransportError,
   ModbusTimeoutError,
   ModbusNotConnectedError,
@@ -678,5 +897,7 @@ export {
   ModbusInternalError,
   ModbusExceptionError,
   ModbusConnectionClosedError,
+  ModbusCircuitOpenError,
+  ConnectionState,
   AsciiTransportService
 };