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

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,219 +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/shared-transport.ts
-import { Effect as Effect2, Exit, Scope } from "effect";
+// src/mocks.ts
+import { Effect as Effect4, Schema, SubscriptionRef as SubscriptionRef2 } from "effect";
+import {
+  CoilState
+} from "modbus-rs";
 
 // src/modbus-client.ts
-import { Effect } from "effect";
+import { Effect as Effect3 } from "effect";
+var wrap = (try_) => Effect3.tryPromise({
+  try: try_,
+  catch: (error) => toModbusError(error)
+});
 var makeEffectModbusClient = (client) => ({
-  readHoldingRegisters: (opts) => Effect.tryPromise({
-    try: () => client.readHoldingRegisters(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readInputRegisters: (opts) => Effect.tryPromise({
-    try: () => client.readInputRegisters(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  writeSingleRegister: (opts) => Effect.tryPromise({
-    try: () => client.writeSingleRegister(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  writeMultipleRegisters: (opts) => Effect.tryPromise({
-    try: () => client.writeMultipleRegisters(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readWriteMultipleRegisters: (opts) => Effect.tryPromise({
-    try: () => client.readWriteMultipleRegisters(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readCoils: (opts) => Effect.tryPromise({
-    try: () => client.readCoils(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  writeSingleCoil: (opts) => Effect.tryPromise({
-    try: () => client.writeSingleCoil(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  writeMultipleCoils: (opts) => Effect.tryPromise({
-    try: () => client.writeMultipleCoils(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readDiscreteInputs: (opts) => Effect.tryPromise({
-    try: () => client.readDiscreteInputs(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readFifoQueue: (opts) => Effect.tryPromise({
-    try: () => client.readFifoQueue(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readFileRecord: (opts) => Effect.tryPromise({
-    try: () => client.readFileRecord(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  writeFileRecord: (opts) => Effect.tryPromise({
-    try: () => client.writeFileRecord(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readExceptionStatus: () => Effect.tryPromise({
-    try: () => client.readExceptionStatus(),
-    catch: (error) => toModbusError(error)
-  }),
-  diagnostics: (opts) => Effect.tryPromise({
-    try: () => client.diagnostics(opts),
-    catch: (error) => toModbusError(error)
-  }),
-  readDeviceIdentification: (opts) => Effect.tryPromise({
-    try: () => client.readDeviceIdentification(opts),
-    catch: (error) => toModbusError(error)
-  })
+  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
-function makeTransportScoped(transportKey, openMethod, serviceName) {
-  return Effect2.fnUntraced(function* (options) {
-    const mod = yield* Effect2.promise(() => import("modbus-rs"));
-    const TC = mod[transportKey];
-    let transport = null;
-    let connectPromise = null;
-    let reconnectPromise = null;
-    const clientSet = new Map;
-    let closed = false;
-    const ensureOpen = Effect2.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* Effect2.tryPromise({
-        try: () => connectPromise,
-        catch: (error) => toModbusError(error)
-      }).pipe(Effect2.catchAll((err) => {
-        connectPromise = null;
-        return Effect2.fail(err);
-      }));
-      if (closed) {
-        connectPromise = null;
-        yield* Effect2.fork(Effect2.promise(() => t.close()).pipe(Effect2.catchAll(() => Effect2.void)));
-        return yield* new ModbusNotConnectedError({
-          cause: new Error("Transport has been closed"),
-          message: "Transport has been closed"
-        });
-      }
-      transport = t;
-      return t;
-    });
-    yield* Effect2.addFinalizer(() => {
-      if (closed)
-        return Effect2.void;
-      closed = true;
-      const t = transport;
-      if (!t)
-        return Effect2.void;
-      return Effect2.andThen(Effect2.logDebug(`Closing ${serviceName}`), Effect2.promise(() => t.close()));
-    });
-    const notConnectedMsg = "Transport is not connected. Call withClient() first.";
-    return {
-      withClient: Effect2.fnUntraced(function* (unitId) {
-        const t = yield* ensureOpen();
-        let client = clientSet.get(unitId);
-        if (!client) {
-          client = yield* Effect2.try({
-            try: () => t.createClient({ unitId }),
-            catch: (error) => toModbusError(error)
-          });
-          clientSet.set(unitId, client);
-        }
-        return makeEffectModbusClient(client);
-      }),
-      setRequestTimeout: Effect2.fnUntraced(function* (timeoutMs) {
-        const t = transport;
-        if (!t || closed) {
-          return yield* new ModbusNotConnectedError({
-            cause: new Error(notConnectedMsg),
-            message: notConnectedMsg
-          });
-        }
-        t.setRequestTimeout(timeoutMs);
-      }),
-      clearRequestTimeout: Effect2.fnUntraced(function* () {
-        const t = transport;
-        if (!t || closed) {
-          return yield* new ModbusNotConnectedError({
-            cause: new Error(notConnectedMsg),
-            message: notConnectedMsg
-          });
-        }
-        t.clearRequestTimeout();
-      }),
-      reconnect: Effect2.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* Effect2.tryPromise({
-            try: () => reconnectPromise,
-            catch: (error) => toModbusError(error)
-          });
-        } else {
-          yield* ensureOpen();
-        }
-      }),
-      close: Effect2.fnUntraced(function* () {
-        if (closed)
-          return;
-        closed = true;
-        const t = transport;
-        if (t) {
-          yield* Effect2.tryPromise({
-            try: () => t.close(),
-            catch: (error) => toModbusError(error)
-          });
-        }
-        const scope = yield* Effect2.scope;
-        yield* Scope.close(scope, Exit.void);
-      }),
-      hasPendingRequests: () => {
-        if (closed)
-          return false;
-        const t = transport;
-        if (!t)
-          return false;
-        return t.pendingRequests;
-      }
-    };
-  });
-}
+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
-import { Effect as Effect3, Schema } from "effect";
 var CoilDefinition = Schema.Struct({
   address: Schema.Number,
   default: Schema.Boolean
@@ -317,30 +305,30 @@ 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: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
     }
     const result = [];
     for (let i = opts.address;i < opts.address + opts.quantity; i++) {
-      result.push(state.coils.get(i) ?? false);
+      result.push(state.coils.get(i) ?? false ? CoilState.On : CoilState.Off);
     }
     return result;
   }),
-  readDiscreteInputs: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
     }
     const result = [];
     for (let i = opts.address;i < opts.address + opts.quantity; i++) {
-      result.push(state.discreteInputs.get(i) ?? false);
+      result.push(state.discreteInputs.get(i) ?? false ? CoilState.On : CoilState.Off);
     }
     return result;
   }),
-  readHoldingRegisters: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
     }
@@ -348,10 +336,10 @@ var makeMockModbusClient = (state, unitId) => ({
     for (let i = opts.address;i < opts.address + opts.quantity; i++) {
       result.push(state.holdingRegisters.get(i) ?? 0);
     }
-    return result;
+    return new Uint16Array(result);
   }),
-  readInputRegisters: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
     }
@@ -359,33 +347,33 @@ var makeMockModbusClient = (state, unitId) => ({
     for (let i = opts.address;i < opts.address + opts.quantity; i++) {
       result.push(state.inputRegisters.get(i) ?? 0);
     }
-    return result;
+    return new Uint16Array(result);
   }),
-  writeSingleCoil: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
+    state.coils.set(opts.address, opts.value === CoilState.On);
   }),
-  writeMultipleCoils: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
     }
     for (let i = 0;i < opts.values.length; i++) {
-      state.coils.set(opts.address + i, opts.values[i]);
+      state.coils.set(opts.address + i, opts.values[i] === CoilState.On);
     }
   }),
-  writeSingleRegister: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
     }
@@ -393,8 +381,8 @@ var makeMockModbusClient = (state, unitId) => ({
       state.holdingRegisters.set(opts.address + i, opts.values[i]);
     }
   }),
-  readWriteMultipleRegisters: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.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);
     }
@@ -408,36 +396,36 @@ var makeMockModbusClient = (state, unitId) => ({
     for (let i = opts.readAddress;i < opts.readAddress + opts.readQuantity; i++) {
       result.push(state.holdingRegisters.get(i) ?? 0);
     }
-    return result;
+    return new Uint16Array(result);
   }),
-  readFifoQueue: Effect3.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: Effect3.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: Effect3.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: Effect3.fnUntraced(function* () {
-    yield* Effect3.logDebug(`[Mock] unitId=${unitId} readExceptionStatus`);
+  readExceptionStatus: Effect4.fnUntraced(function* () {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readExceptionStatus`);
     return 0;
   }),
-  diagnostics: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.logDebug(`[Mock] unitId=${unitId} diagnostics`, opts);
-    return { subFunction: opts.subFunction, data: [] };
+  diagnostics: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} diagnostics`, opts);
+    return { subFunction: opts.subFunction, data: new Uint16Array };
   }),
-  readDeviceIdentification: Effect3.fnUntraced(function* (opts) {
-    yield* Effect3.logDebug(`[Mock] unitId=${unitId} readDeviceIdentification`, opts);
+  readDeviceIdentification: Effect4.fnUntraced(function* (opts) {
+    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readDeviceIdentification`, opts);
     return {
       conformityLevel: 1,
       moreFollows: false,
@@ -465,10 +453,32 @@ var makeMockTransport = (devices) => {
       maxInputAddress: input.maxAddress
     });
   }
-  return (_options) => Effect3.gen(function* () {
-    yield* Effect3.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: Effect3.fnUntraced(function* (unitId) {
+      connectionState,
+      withClient: Effect4.fnUntraced(function* (unitId, clientOptions) {
         const state = deviceStates.get(unitId);
         if (!state) {
           return yield* new ModbusInvalidArgumentError({
@@ -476,19 +486,186 @@ 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) => Effect3.void,
-      clearRequestTimeout: () => Effect3.void,
-      reconnect: () => Effect3.asVoid(Effect3.logDebug("Mock: reconnecting")),
-      close: () => Effect3.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 { 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 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;
+    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 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* Effect5.addFinalizer(() => {
+      if (closed)
+        return Effect5.void;
+      closed = true;
+      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())));
+    });
+    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 {
+      connectionState,
+      withClient: Effect5.fnUntraced(function* (unitId, clientOptions) {
+        const t = yield* ensureOpen();
+        let client = clientSet.get(unitId);
+        if (!client) {
+          client = yield* Effect5.try({
+            try: () => t.createClient({ unitId }),
+            catch: (error) => toModbusError(error)
+          });
+          clientSet.set(unitId, client);
+        }
+        return withResilience(makeEffectModbusClient(client), {
+          ...resilience,
+          policy: clientOptions?.retry ?? transportRetry
+        });
+      }),
+      setRequestTimeout: Effect5.fnUntraced(function* (timeoutMs) {
+        const t = transport;
+        if (!t || closed) {
+          return yield* new ModbusNotConnectedError({
+            cause: new Error(notConnectedMsg),
+            message: notConnectedMsg
+          });
+        }
+        t.setRequestTimeout(timeoutMs);
+      }),
+      clearRequestTimeout: Effect5.fnUntraced(function* () {
+        const t = transport;
+        if (!t || closed) {
+          return yield* new ModbusNotConnectedError({
+            cause: new Error(notConnectedMsg),
+            message: notConnectedMsg
+          });
+        }
+        t.clearRequestTimeout();
+      }),
+      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: Effect5.fnUntraced(function* () {
+        if (closed)
+          return;
+        closed = true;
+        yield* SubscriptionRef3.set(connectionState, ConnectionState.Disconnected());
+        const t = transport;
+        if (t) {
+          yield* Effect5.tryPromise({
+            try: () => t.close(),
+            catch: (error) => toModbusError(error)
+          });
+        }
+        const scope = yield* Effect5.scope;
+        yield* Scope.close(scope, Exit.void);
+      }),
+      hasPendingRequests: () => {
+        if (closed)
+          return false;
+        const t = transport;
+        if (!t)
+          return false;
+        return t.pendingRequests;
+      }
+    };
+  });
+}
+
 // 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) => {
@@ -500,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) => {
@@ -524,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) => {
@@ -534,68 +711,185 @@ 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 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) => {
+    const factory = makeMockTransport(devices);
+    return (options) => Layer8.scoped(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" })
+}) {
+  static makeMockTransport = (devices) => {
+    const factory = makeMockTransport(devices);
+    return (options) => Layer9.scoped(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" })
+}) {
+  static makeMockTransport = (devices) => {
+    const factory = makeMockTransport(devices);
+    return (options) => Layer10.scoped(WasmAsciiTransportService, factory(options));
+  };
+}
+// src/WasmSerialTransportService.ts
+import { Context as Context2, Layer as Layer11 } from "effect";
+class WasmSerialTransportService extends Context2.Tag("WasmSerialTransportService")() {
+  static fromAscii(options) {
+    return Layer11.project(WasmAsciiTransportService, WasmSerialTransportService, (ascii) => ascii)(WasmAsciiTransportService.Default(options));
+  }
+  static fromRtu(options) {
+    return Layer11.project(WasmRtuTransportService, WasmSerialTransportService, (rtu) => rtu)(WasmRtuTransportService.Default(options));
+  }
+  static makeMockTransport = (devices) => {
+    const factory = makeMockTransport(devices);
+    return (options) => Layer11.scoped(WasmSerialTransportService, factory(options));
+  };
+}
+// src/WasmSerialPort.ts
+import { Effect as Effect15 } from "effect";
+var requestSerialPort = () => Effect15.tryPromise({
+  try: async () => {
+    const mod = await import("modbus-rs/web");
+    return mod.requestSerialPort();
+  },
+  catch: (error) => toModbusError(error)
+});
+// src/WasmTcpServerService.ts
+import { Effect as Effect16, Layer as Layer12 } from "effect";
+var wasmWsServerLayer = (options, handlers) => Layer12.scopedDiscard(Effect16.gen(function* () {
+  const { WasmWsModbusServer } = yield* Effect16.promise(() => import("modbus-rs/web"));
+  const server = yield* Effect16.tryPromise({
+    try: () => WasmWsModbusServer.bind(options, handlers),
+    catch: (error) => toModbusError(error)
+  });
+  yield* Effect16.logDebug(`WASM WS server bound to ${options.wsUrl}`);
+  yield* Effect16.forkScoped(Effect16.tryPromise({
+    try: () => server.serve(),
+    catch: (error) => toModbusError(error)
+  }).pipe(Effect16.catchAll((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)));
+}));
+// src/WasmSerialModbusServerService.ts
+import { Effect as Effect17, Layer as Layer13 } from "effect";
+var wasmSerialRtuServerLayer = (options, handlers) => Layer13.scopedDiscard(Effect17.gen(function* () {
+  const { WasmSerialModbusServer } = yield* Effect17.promise(() => import("modbus-rs/web"));
+  const server = yield* Effect17.tryPromise({
+    try: () => WasmSerialModbusServer.bindRtu(options, handlers),
+    catch: (error) => toModbusError(error)
+  });
+  yield* Effect17.logDebug("WASM serial RTU server bound");
+  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))));
+  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)));
+}));
+var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.scopedDiscard(Effect17.gen(function* () {
+  const { WasmSerialModbusServer } = yield* Effect17.promise(() => import("modbus-rs/web"));
+  const server = yield* Effect17.tryPromise({
+    try: () => WasmSerialModbusServer.bindAscii(options, handlers),
+    catch: (error) => toModbusError(error)
+  });
+  yield* Effect17.logDebug("WASM serial ASCII server bound");
+  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))));
+  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)));
 }));
 export {
+  wasmWsServerLayer,
+  wasmSerialRtuServerLayer,
+  wasmSerialAsciiServerLayer,
   toModbusError,
   tcpServerLayer,
   tcpGatewayLayer,
   serialRtuServerLayer,
   serialAsciiServerLayer,
+  retryableExceptionCodes,
+  retryModbus,
+  requestSerialPort,
+  makeRetryPolicy,
+  WasmWsTransportService,
+  WasmSerialTransportService,
+  WasmRtuTransportService,
+  WasmAsciiTransportService,
   TcpTransportService,
   SerialTransportService,
   RtuTransportService,
+  RetryPolicies,
   ModbusTransportError,
   ModbusTimeoutError,
   ModbusNotConnectedError,
@@ -603,5 +897,7 @@ export {
   ModbusInternalError,
   ModbusExceptionError,
   ModbusConnectionClosedError,
+  ModbusCircuitOpenError,
+  ConnectionState,
   AsciiTransportService
 };