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

package/dist/index.js

@@ -54,216 +54,11 @@ var toModbusError = (cause) => {
 // src/AsciiTransportService.ts
 import { Effect as Effect4, Layer } from "effect";
 
-// src/shared-transport.ts
-import { Effect as Effect2, Exit, Scope } from "effect";
-
-// src/modbus-client.ts
-import { Effect } from "effect";
-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)
-  })
-});
-
-// 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;
-      }
-    };
-  });
-}
-
 // src/mocks.ts
-import { Effect as Effect3, Schema } from "effect";
+import { Effect, Schema } from "effect";
+import {
+  CoilState
+} from "modbus-rs";
 var CoilDefinition = Schema.Struct({
   address: Schema.Number,
   default: Schema.Boolean
@@ -317,30 +112,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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.logDebug(`[Mock] unitId=${unitId} readHoldingRegisters`, opts);
     if (opts.address + opts.quantity > state.maxHoldingAddress + 1) {
       return yield* failOutOfRange("HoldingRegister", opts.address, opts.quantity);
     }
@@ -348,10 +143,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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.logDebug(`[Mock] unitId=${unitId} readInputRegisters`, opts);
     if (opts.address + opts.quantity > state.maxInputAddress + 1) {
       return yield* failOutOfRange("InputRegister", opts.address, opts.quantity);
     }
@@ -359,33 +154,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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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 +188,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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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 +203,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: Effect.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: Effect.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: Effect.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: Effect.fnUntraced(function* () {
+    yield* Effect.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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.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: Effect.fnUntraced(function* (opts) {
+    yield* Effect.logDebug(`[Mock] unitId=${unitId} readDeviceIdentification`, opts);
     return {
       conformityLevel: 1,
       moreFollows: false,
@@ -465,10 +260,10 @@ var makeMockTransport = (devices) => {
       maxInputAddress: input.maxAddress
     });
   }
-  return (_options) => Effect3.gen(function* () {
-    yield* Effect3.logDebug("Mock transport opened with devices:", deviceDefs);
+  return (_options) => Effect.gen(function* () {
+    yield* Effect.logDebug("Mock transport opened with devices:", deviceDefs);
     return {
-      withClient: Effect3.fnUntraced(function* (unitId) {
+      withClient: Effect.fnUntraced(function* (unitId) {
         const state = deviceStates.get(unitId);
         if (!state) {
           return yield* new ModbusInvalidArgumentError({
@@ -478,15 +273,182 @@ var makeMockTransport = (devices) => {
         }
         return makeMockModbusClient(state, unitId);
       }),
-      setRequestTimeout: (_timeoutMs) => Effect3.void,
-      clearRequestTimeout: () => Effect3.void,
-      reconnect: () => Effect3.asVoid(Effect3.logDebug("Mock: reconnecting")),
-      close: () => Effect3.logDebug("Mock: closing transport"),
+      setRequestTimeout: (_timeoutMs) => Effect.void,
+      clearRequestTimeout: () => Effect.void,
+      reconnect: () => Effect.asVoid(Effect.logDebug("Mock: reconnecting")),
+      close: () => Effect.logDebug("Mock: closing transport"),
       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
+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"));
+    const TC = mod[transportKey];
+    let transport = null;
+    let connectPromise = null;
+    let reconnectPromise = null;
+    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"
+        });
+      }
+      transport = t;
+      return t;
+    });
+    yield* Effect3.addFinalizer(() => {
+      if (closed)
+        return Effect3.void;
+      closed = true;
+      const t = transport;
+      if (!t)
+        return Effect3.void;
+      return Effect3.andThen(Effect3.logDebug(`Closing ${serviceName}`), Effect3.promise(() => t.close()));
+    });
+    const notConnectedMsg = "Transport is not connected. Call withClient() first.";
+    return {
+      withClient: Effect3.fnUntraced(function* (unitId) {
+        const t = yield* ensureOpen();
+        let client = clientSet.get(unitId);
+        if (!client) {
+          client = yield* Effect3.try({
+            try: () => t.createClient({ unitId }),
+            catch: (error) => toModbusError(error)
+          });
+          clientSet.set(unitId, client);
+        }
+        return makeEffectModbusClient(client);
+      }),
+      setRequestTimeout: Effect3.fnUntraced(function* (timeoutMs) {
+        const t = transport;
+        if (!t || closed) {
+          return yield* new ModbusNotConnectedError({
+            cause: new Error(notConnectedMsg),
+            message: notConnectedMsg
+          });
+        }
+        t.setRequestTimeout(timeoutMs);
+      }),
+      clearRequestTimeout: Effect3.fnUntraced(function* () {
+        const t = transport;
+        if (!t || closed) {
+          return yield* new ModbusNotConnectedError({
+            cause: new Error(notConnectedMsg),
+            message: notConnectedMsg
+          });
+        }
+        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 {
+          yield* ensureOpen();
+        }
+      }),
+      close: Effect3.fnUntraced(function* () {
+        if (closed)
+          return;
+        closed = true;
+        const t = transport;
+        if (t) {
+          yield* Effect3.tryPromise({
+            try: () => t.close(),
+            catch: (error) => toModbusError(error)
+          });
+        }
+        const scope = yield* Effect3.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", {
   scoped: makeTransportScoped("AsyncAsciiTransport", (TC, options) => TC.open(options), "AsciiTransportService")
@@ -587,12 +549,125 @@ var tcpGatewayLayer = (options, gatewayConfig) => Layer7.scopedDiscard(Effect10.
     catch: (error) => toModbusError(error)
   })), Effect10.catchAll(() => Effect10.void)));
 }));
+// src/WasmWsTransportService.ts
+import { Effect as Effect11, Layer as Layer8 } from "effect";
+class WasmWsTransportService extends Effect11.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 Effect12, Layer as Layer9 } from "effect";
+class WasmRtuTransportService extends Effect12.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 Effect13, Layer as Layer10 } from "effect";
+class WasmAsciiTransportService extends Effect13.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,
+  requestSerialPort,
+  WasmWsTransportService,
+  WasmSerialTransportService,
+  WasmRtuTransportService,
+  WasmAsciiTransportService,
   TcpTransportService,
   SerialTransportService,
   RtuTransportService,