@flux-control/effect-modbus-rs 0.8.0 → 0.9.0

package/dist/index.js

@@ -930,7 +930,7 @@ var createBatchingRegistry = (deps) => {
   };
 };
 // src/AsciiTransportService.ts
-import { Context, Layer } from "effect";
+import { Context, Effect as Effect10, Layer } from "effect";
 
 // src/mocks.ts
 import { Effect as Effect7, Exit as Exit3, Schema, Scope as Scope2, SubscriptionRef as SubscriptionRef3 } from "effect";
@@ -940,30 +940,36 @@ import {
 
 // src/modbus-client.ts
 import { Effect as Effect6 } from "effect";
+var identityWrapper = (call) => call;
 var wrap = (try_) => Effect6.tryPromise({
   try: try_,
   catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
 });
-var createEffectModbusClient = (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 createEffectModbusClient = (client, around = identityWrapper) => {
+  const resolve = Effect6.isEffect(client) ? client : Effect6.succeed(client);
+  const call = (try_) => around(Effect6.flatMap(resolve, (current) => wrap(() => try_(current))));
+  return {
+    readHoldingRegisters: (opts) => call((current) => current.readHoldingRegisters(opts)),
+    readInputRegisters: (opts) => call((current) => current.readInputRegisters(opts)),
+    writeSingleRegister: (opts) => call((current) => current.writeSingleRegister(opts)),
+    writeMultipleRegisters: (opts) => call((current) => current.writeMultipleRegisters(opts)),
+    readWriteMultipleRegisters: (opts) => call((current) => current.readWriteMultipleRegisters(opts)),
+    readCoils: (opts) => call((current) => current.readCoils(opts)),
+    writeSingleCoil: (opts) => call((current) => current.writeSingleCoil(opts)),
+    writeMultipleCoils: (opts) => call((current) => current.writeMultipleCoils(opts)),
+    readDiscreteInputs: (opts) => call((current) => current.readDiscreteInputs(opts)),
+    readFifoQueue: (opts) => call((current) => current.readFifoQueue(opts)),
+    readFileRecord: (opts) => call((current) => current.readFileRecord(opts)),
+    writeFileRecord: (opts) => call((current) => current.writeFileRecord(opts)),
+    readExceptionStatus: () => call((current) => current.readExceptionStatus()),
+    diagnostics: (opts) => call((current) => current.diagnostics(opts)),
+    readDeviceIdentification: (opts) => call((current) => current.readDeviceIdentification(opts))
+  };
+};
 var withResilience = (operations, resilience) => {
   const run = (operation) => {
-    const attempt = Effect6.andThen(resilience.guard, Effect6.suspend(operation)).pipe(Effect6.tap(() => resilience.onSuccess ?? Effect6.void), Effect6.tapError((error) => resilience.report(error)));
+    const guarded = Effect6.andThen(resilience.guard, Effect6.suspend(operation)).pipe(Effect6.tap(() => resilience.onSuccess ?? Effect6.void), Effect6.tapError((error) => resilience.report(error)));
+    const attempt = resilience.aroundAttempt?.(guarded) ?? guarded;
     return resilience.policy ? retryModbus(resilience.policy)(attempt) : attempt;
   };
   return {
@@ -1273,17 +1279,68 @@ var createMockTransport = (devices) => {
   });
 };
 
+// src/serial-port-path.ts
+import { Effect as Effect8 } from "effect";
+var MAX_SERIAL_PORT_PATH = 128;
+var resolveSerialPortPath = async (portPath) => {
+  if (portPath.length <= MAX_SERIAL_PORT_PATH)
+    return portPath;
+  const { realpath } = await import("node:fs/promises");
+  const target = await realpath(portPath).catch(() => portPath);
+  if (target.length <= MAX_SERIAL_PORT_PATH)
+    return target;
+  throw new Error(`[MODBUS_INVALID_ARGUMENT] Serial port path is ${portPath.length} characters long. modbus-rs accepts at most ${MAX_SERIAL_PORT_PATH} characters. Use a shorter path or a shorter link to the device: ${portPath}`);
+};
+var serialPortPathScoped = Effect8.fnUntraced(function* (portPath) {
+  let directory;
+  let alias;
+  yield* Effect8.addFinalizer(() => Effect8.promise(async () => {
+    if (directory === undefined)
+      return;
+    const { rm } = await import("node:fs/promises");
+    await rm(directory, { recursive: true, force: true });
+  }));
+  return async () => {
+    if (portPath.length <= MAX_SERIAL_PORT_PATH)
+      return portPath;
+    if (alias !== undefined)
+      return alias;
+    await resolveSerialPortPath(portPath);
+    const { mkdtemp, symlink } = await import("node:fs/promises");
+    const { tmpdir } = await import("node:os");
+    const { join, resolve } = await import("node:path");
+    directory = await mkdtemp(join(tmpdir(), "modbus-port-"));
+    const path = join(directory, "port");
+    if (path.length > MAX_SERIAL_PORT_PATH)
+      throw new Error("[MODBUS_INVALID_ARGUMENT] The temporary serial alias path exceeds the native limit");
+    await symlink(resolve(portPath), path);
+    alias = path;
+    return alias;
+  };
+});
+
 // src/shared-transport.ts
-import { Deferred as Deferred4, Duration as Duration6, Effect as Effect8, Exit as Exit4, Option, Ref, Scope as Scope3, SubscriptionRef as SubscriptionRef4 } from "effect";
+import {
+  Deferred as Deferred4,
+  Duration as Duration6,
+  Effect as Effect9,
+  Exit as Exit4,
+  Fiber as Fiber4,
+  Option,
+  Ref,
+  Scope as Scope3,
+  Semaphore as Semaphore4,
+  SubscriptionRef as SubscriptionRef4
+} from "effect";
 var makeInFlight = () => Ref.make(Option.none());
-var singleFlight = (inFlight, work) => Effect8.uninterruptibleMask((restore) => Effect8.gen(function* () {
+var singleFlight = (inFlight, work) => Effect9.uninterruptibleMask((restore) => Effect9.gen(function* () {
   const fresh = yield* Deferred4.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* Effect8.forkDetach(Effect8.interruptible(work).pipe(Effect8.onExit((exit) => Effect8.andThen(Ref.set(inFlight, Option.none()), Deferred4.done(deferred, exit)))));
+    yield* Effect9.forkDetach(Effect9.interruptible(work).pipe(Effect9.onExit((exit) => Effect9.andThen(Ref.set(inFlight, Option.none()), Deferred4.done(deferred, exit)))));
   }
   return yield* restore(Deferred4.await(deferred));
 }));
@@ -1314,44 +1371,67 @@ var loadTransportConstructor = async (transportKey, moduleSpecifier) => {
   }
 };
 function createTransportScoped(transportKey, openMethod, serviceName, config) {
-  return Effect8.fnUntraced(function* (options) {
+  return Effect9.fnUntraced(function* (options) {
     const { retry: transportRetry, reconnect: reconnectOptions } = options;
     const connectTimeout = options.connectTimeout === undefined ? undefined : Duration6.fromInputUnsafe(options.connectTimeout);
     const openOptions = { ...options };
     Reflect.deleteProperty(openOptions, "retry");
     Reflect.deleteProperty(openOptions, "reconnect");
     Reflect.deleteProperty(openOptions, "connectTimeout");
-    const TC = yield* Effect8.promise(() => loadTransportConstructor(transportKey, config?.moduleSpecifier ?? "modbus-rs"));
+    const nativeLock = config?.serializeRequests ? yield* Semaphore4.make(1) : undefined;
+    let nativeLimit = config?.responseTimeoutMs?.(options) ?? 1000;
+    let requestLimitOverride;
+    const aroundNative = nativeLock === undefined ? undefined : (call) => Effect9.uninterruptibleMask((restore) => Effect9.gen(function* () {
+      yield* restore(nativeLock.take(1));
+      const work = call.pipe(Effect9.ensuring(nativeLock.release(1)));
+      if (nativeLimit !== undefined)
+        return yield* work;
+      const worker = yield* Effect9.forkDetach(Effect9.exit(work));
+      const exit = yield* restore(Fiber4.join(worker)).pipe(Effect9.onInterrupt(() => invalidateNative));
+      return yield* exit;
+    }));
+    const TC = yield* Effect9.promise(() => loadTransportConstructor(transportKey, config?.moduleSpecifier ?? "modbus-rs"));
     let transport = null;
     const opening = yield* makeInFlight();
     const reconnecting = yield* makeInFlight();
     const connectionState = yield* SubscriptionRef4.make(ConnectionState.Disconnected());
     const resolvedReconnect = resolveReconnect(reconnectOptions ?? {});
     const supervised = reconnectOptions ? resolvedReconnect : null;
-    const serviceScope = yield* Effect8.scope;
+    const serviceScope = yield* Effect9.scope;
     const clientSet = new Map;
+    const touchedUnits = new Set;
     let closed = false;
+    const invalidateNative = Effect9.suspend(() => {
+      const current = transport;
+      transport = null;
+      clientSet.clear();
+      return Effect9.andThen(SubscriptionRef4.set(connectionState, ConnectionState.Disconnected()), current === null ? Effect9.void : Effect9.ignore(Effect9.tryPromise(() => current.close())));
+    });
     const transportClosed = () => new ModbusNotConnectedError({
       cause: new Error("Transport has been closed"),
       message: "Transport has been closed"
     });
-    const closeOrphan = (t) => Effect8.forkDetach(Effect8.ignore(Effect8.tryPromise(() => t.close())));
+    const closeOrphan = (t) => Effect9.forkDetach(Effect9.ignore(Effect9.tryPromise(() => t.close())));
     const limitConnect = (wait) => {
       if (connectTimeout === undefined)
         return wait;
       const message = `${serviceName}: connect did not complete within ${Duration6.format(connectTimeout)}`;
-      return Effect8.timeoutOrElse(wait, {
+      return Effect9.timeoutOrElse(wait, {
         duration: connectTimeout,
-        orElse: () => Effect8.fail(new ModbusTimeoutError({ cause: new Error(message), message }))
+        orElse: () => Effect9.fail(new ModbusTimeoutError({ cause: new Error(message), message }))
       });
     };
-    const openTransport = Effect8.tryPromise({
+    const openTransport = Effect9.tryPromise({
       try: () => openMethod(TC, openOptions),
       catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
-    }).pipe(Effect8.tap((t) => closed ? closeOrphan(t) : Effect8.andThen(Effect8.sync(() => {
+    }).pipe(Effect9.tap((t) => closed ? closeOrphan(t) : Effect9.andThen(Effect9.sync(() => {
+      if (requestLimitOverride === null)
+        t.clearRequestTimeout();
+      else if (requestLimitOverride !== undefined)
+        t.setRequestTimeout(requestLimitOverride);
       transport = t;
     }), SubscriptionRef4.set(connectionState, ConnectionState.Connected()))));
-    const ensureOpen = Effect8.fnUntraced(function* () {
+    const ensureOpen = Effect9.fnUntraced(function* () {
       if (closed)
         return yield* transportClosed();
       if (transport)
@@ -1361,56 +1441,65 @@ function createTransportScoped(transportKey, openMethod, serviceName, config) {
         return yield* transportClosed();
       return t;
     });
-    const closeTransport = Effect8.suspend(() => {
+    const closeTransport = Effect9.suspend(() => {
       if (closed)
-        return Effect8.void;
+        return Effect9.void;
       closed = true;
       const t = transport;
       if (!t)
         return SubscriptionRef4.set(connectionState, ConnectionState.Disconnected());
-      return Effect8.andThen(Effect8.logDebug(`Closing ${serviceName}`), Effect8.andThen(Effect8.tryPromise({
+      return Effect9.andThen(Effect9.logDebug(`Closing ${serviceName}`), Effect9.andThen(Effect9.tryPromise({
         try: () => t.close(),
         catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
       }), SubscriptionRef4.set(connectionState, ConnectionState.Disconnected())));
     });
-    yield* Effect8.addFinalizer(() => Effect8.orDie(closeTransport));
+    yield* Effect9.addFinalizer(() => Effect9.orDie(closeTransport));
     const notConnectedMsg = "Transport is not connected. Call withClient() first.";
-    const reconnectTransport = (t) => limitConnect(singleFlight(reconnecting, Effect8.tryPromise({
+    const withNativeLock = (effect) => nativeLock === undefined ? effect : nativeLock.withPermits(1)(effect);
+    const reconnectTransport = (t) => limitConnect(singleFlight(reconnecting, withNativeLock(Effect9.tryPromise({
       try: () => t.reconnect(),
       catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
-    }).pipe(Effect8.tap(() => closed ? closeOrphan(t) : SubscriptionRef4.update(connectionState, (current) => ConnectionState.$is("Down")(current) ? ConnectionState.Connected() : current)))));
-    const reconnectOnce = Effect8.suspend(() => {
+    })).pipe(Effect9.tap(() => closed ? closeOrphan(t) : SubscriptionRef4.update(connectionState, (current) => ConnectionState.$is("Down")(current) ? ConnectionState.Connected() : current)))));
+    const reconnectOnce = Effect9.suspend(() => {
       const t = transport;
       if (closed || !t)
         return transportClosed();
       return reconnectTransport(t);
     });
     const report = (error) => {
-      if (closed || !resolvedReconnect.triggers(error))
-        return Effect8.void;
+      if (closed)
+        return Effect9.void;
+      if (!resolvedReconnect.triggers(error))
+        return Effect9.void;
       if (!supervised) {
         return SubscriptionRef4.update(connectionState, (current) => ConnectionState.$is("Connected")(current) ? ConnectionState.Down({ cause: error }) : current);
       }
-      return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope, Effect8.logDebug(`${serviceName}: reconnecting after ${error.message}`));
+      return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope, Effect9.logDebug(`${serviceName}: reconnecting after ${error.message}`));
     };
     const resilience = {
-      guard: supervised ? guardCircuit(connectionState) : Effect8.void,
+      guard: supervised ? Effect9.suspend(() => transport === null ? Effect9.void : guardCircuit(connectionState)) : Effect9.void,
+      aroundAttempt: aroundNative,
       onSuccess: supervised ? undefined : SubscriptionRef4.update(connectionState, (current) => ConnectionState.$is("Down")(current) ? ConnectionState.Connected() : current),
       report
     };
-    const makeOperations = Effect8.fnUntraced(function* (unitId) {
+    const resolveClient = Effect9.fnUntraced(function* (unitId) {
       const t = yield* ensureOpen();
       let client = clientSet.get(unitId);
       if (!client) {
-        client = yield* Effect8.try({
+        client = yield* Effect9.try({
           try: () => t.createClient({ unitId }),
           catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
         });
         clientSet.set(unitId, client);
+        touchedUnits.add(unitId);
       }
-      return createEffectModbusClient(client);
+      return client;
+    });
+    const makeOperations = Effect9.fnUntraced(function* (unitId) {
+      yield* withNativeLock(resolveClient(unitId));
+      return createEffectModbusClient(resolveClient(unitId));
     });
-    const makeClient = Effect8.fnUntraced(function* (unitId, clientOptions) {
+    const makeClient = Effect9.fnUntraced(function* (unitId, clientOptions) {
       const operations = yield* makeOperations(unitId);
       return withResilience(operations, {
         ...resilience,
@@ -1422,7 +1511,7 @@ function createTransportScoped(transportKey, openMethod, serviceName, config) {
       connectionState,
       scope: serviceScope
     });
-    const withClient = Effect8.fnUntraced(function* (unitId, clientOptions) {
+    const withClient = Effect9.fnUntraced(function* (unitId, clientOptions) {
       const operations = yield* makeOperations(unitId);
       return withResilience(batching.guardRawWrites(unitId, operations), {
         ...resilience,
@@ -1432,7 +1521,7 @@ function createTransportScoped(transportKey, openMethod, serviceName, config) {
     return {
       connectionState,
       withClient,
-      setRequestTimeout: Effect8.fnUntraced(function* (timeoutMs) {
+      setRequestTimeout: Effect9.fnUntraced(function* (timeoutMs) {
         const t = transport;
         if (!t || closed) {
           return yield* new ModbusNotConnectedError({
@@ -1441,8 +1530,10 @@ function createTransportScoped(transportKey, openMethod, serviceName, config) {
           });
         }
         t.setRequestTimeout(timeoutMs);
+        nativeLimit = timeoutMs;
+        requestLimitOverride = timeoutMs;
       }),
-      clearRequestTimeout: Effect8.fnUntraced(function* () {
+      clearRequestTimeout: Effect9.fnUntraced(function* () {
         const t = transport;
         if (!t || closed) {
           return yield* new ModbusNotConnectedError({
@@ -1451,8 +1542,10 @@ function createTransportScoped(transportKey, openMethod, serviceName, config) {
           });
         }
         t.clearRequestTimeout();
+        nativeLimit = undefined;
+        requestLimitOverride = null;
       }),
-      reconnect: Effect8.fnUntraced(function* () {
+      reconnect: Effect9.fnUntraced(function* () {
         if (closed)
           return yield* transportClosed();
         const t = transport;
@@ -1465,15 +1558,15 @@ function createTransportScoped(transportKey, openMethod, serviceName, config) {
           return yield* transportClosed();
         yield* SubscriptionRef4.set(connectionState, ConnectionState.Connected());
       }),
-      close: Effect8.fnUntraced(function* (scope) {
+      close: Effect9.fnUntraced(function* (scope) {
         if (closed)
           return;
-        yield* Scope3.close(scope, Exit4.void).pipe(Effect8.onExit(() => closeTransport));
+        yield* Scope3.close(scope, Exit4.void).pipe(Effect9.onExit(() => closeTransport));
       }),
       withBatchingClient: batching.withBatchingClient,
       batchingClient: batching.batchingClient,
       get touchedUnits() {
-        return new Set(clientSet.keys());
+        return new Set(touchedUnits);
       },
       hasPendingRequests: () => {
         if (closed)
@@ -1489,9 +1582,19 @@ function createTransportScoped(transportKey, openMethod, serviceName, config) {
 
 // src/AsciiTransportService.ts
 class AsciiTransportService extends Context.Service()("AsciiTransportService") {
-  static makeScoped = createTransportScoped("AsyncAsciiTransport", (transportConstructor, options) => {
-    return transportConstructor.open(options);
-  }, "AsciiTransportService");
+  static makeScoped = Effect10.fnUntraced(function* (options) {
+    const portPath = yield* serialPortPathScoped(options.portPath);
+    return yield* createTransportScoped("AsyncAsciiTransport", async (transportConstructor, options2) => {
+      return transportConstructor.open({
+        ...options2,
+        portPath: await portPath(),
+        responseTimeoutMs: options2.responseTimeoutMs ?? options2.requestTimeoutMs
+      });
+    }, "AsciiTransportService", {
+      serializeRequests: true,
+      responseTimeoutMs: (options2) => options2.responseTimeoutMs ?? options2.requestTimeoutMs
+    })(options);
+  });
   static make = (options) => Layer.effect(AsciiTransportService, AsciiTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = createMockTransport(devices);
@@ -1502,11 +1605,21 @@ class AsciiTransportService extends Context.Service()("AsciiTransportService") {
 import { Context as Context3, Layer as Layer3 } from "effect";
 
 // src/RtuTransportService.ts
-import { Context as Context2, Layer as Layer2 } from "effect";
+import { Context as Context2, Effect as Effect11, Layer as Layer2 } from "effect";
 class RtuTransportService extends Context2.Service()("RtuTransportService") {
-  static makeScoped = createTransportScoped("AsyncRtuTransport", (transportConstructor, options) => {
-    return transportConstructor.open(options);
-  }, "RtuTransportService");
+  static makeScoped = Effect11.fnUntraced(function* (options) {
+    const portPath = yield* serialPortPathScoped(options.portPath);
+    return yield* createTransportScoped("AsyncRtuTransport", async (transportConstructor, options2) => {
+      return transportConstructor.open({
+        ...options2,
+        portPath: await portPath(),
+        responseTimeoutMs: options2.responseTimeoutMs ?? options2.requestTimeoutMs
+      });
+    }, "RtuTransportService", {
+      serializeRequests: true,
+      responseTimeoutMs: (options2) => options2.responseTimeoutMs ?? options2.requestTimeoutMs
+    })(options);
+  });
   static make = (options) => Layer2.effect(RtuTransportService, RtuTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
     const factory = createMockTransport(devices);
@@ -1531,7 +1644,10 @@ class SerialTransportService extends Context3.Service()("SerialTransportService"
 import { Context as Context4, Layer as Layer4 } from "effect";
 class TcpTransportService extends Context4.Service()("TcpTransportService") {
   static makeScoped = createTransportScoped("AsyncTcpTransport", (transportConstructor, options) => {
-    return transportConstructor.connect(options);
+    return transportConstructor.connect({
+      ...options,
+      responseTimeoutMs: options.responseTimeoutMs ?? options.requestTimeoutMs
+    });
   }, "TcpTransportService");
   static make = (options) => Layer4.effect(TcpTransportService, TcpTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
@@ -1540,58 +1656,58 @@ class TcpTransportService extends Context4.Service()("TcpTransportService") {
   };
 }
 // src/SerialModbusServerService.ts
-import { Effect as Effect9, Layer as Layer5 } from "effect";
-var serialRtuServerLayer = (options, handlers) => Layer5.effectDiscard(Effect9.gen(function* () {
-  const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
-  const server = yield* Effect9.tryPromise({
+import { Effect as Effect12, Layer as Layer5 } from "effect";
+var serialRtuServerLayer = (options, handlers) => Layer5.effectDiscard(Effect12.gen(function* () {
+  const { AsyncSerialModbusServer } = yield* Effect12.promise(() => import("modbus-rs"));
+  const server = yield* Effect12.tryPromise({
     try: () => AsyncSerialModbusServer.bindRtu(options, handlers),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  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({
+  yield* Effect12.logDebug(`Serial RTU server bound to ${options.portPath}`);
+  yield* Effect12.addFinalizer(() => Effect12.logDebug("Serial RTU server shutting down").pipe(Effect12.andThen(Effect12.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  })), Effect9.catch(() => Effect9.void)));
+  })), Effect12.catch(() => Effect12.void)));
 }));
-var serialAsciiServerLayer = (options, handlers) => Layer5.effectDiscard(Effect9.gen(function* () {
-  const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
-  const server = yield* Effect9.tryPromise({
+var serialAsciiServerLayer = (options, handlers) => Layer5.effectDiscard(Effect12.gen(function* () {
+  const { AsyncSerialModbusServer } = yield* Effect12.promise(() => import("modbus-rs"));
+  const server = yield* Effect12.tryPromise({
     try: () => AsyncSerialModbusServer.bindAscii(options, handlers),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  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({
+  yield* Effect12.logDebug(`Serial ASCII server bound to ${options.portPath}`);
+  yield* Effect12.addFinalizer(() => Effect12.logDebug("Serial ASCII server shutting down").pipe(Effect12.andThen(Effect12.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  })), Effect9.catch(() => Effect9.void)));
+  })), Effect12.catch(() => Effect12.void)));
 }));
 // src/TcpModbusServerService.ts
-import { Effect as Effect10, Layer as Layer6 } from "effect";
-var tcpServerLayer = (options, handlers) => Layer6.effectDiscard(Effect10.gen(function* () {
-  const { AsyncTcpModbusServer } = yield* Effect10.promise(() => import("modbus-rs"));
-  const server = yield* Effect10.tryPromise({
+import { Effect as Effect13, Layer as Layer6 } from "effect";
+var tcpServerLayer = (options, handlers) => Layer6.effectDiscard(Effect13.gen(function* () {
+  const { AsyncTcpModbusServer } = yield* Effect13.promise(() => import("modbus-rs"));
+  const server = yield* Effect13.tryPromise({
     try: () => AsyncTcpModbusServer.bind(options, handlers),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  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({
+  yield* Effect13.logDebug(`TCP server bound to ${options.host}:${options.port}`);
+  yield* Effect13.addFinalizer(() => Effect13.logDebug("TCP server shutting down").pipe(Effect13.andThen(Effect13.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  })), Effect10.catch(() => Effect10.void)));
+  })), Effect13.catch(() => Effect13.void)));
 }));
 // src/TcpGatewayService.ts
-import { Effect as Effect11, Layer as Layer7 } from "effect";
-var tcpGatewayLayer = (options, gatewayConfig) => Layer7.effectDiscard(Effect11.gen(function* () {
-  const { AsyncTcpGateway } = yield* Effect11.promise(() => import("modbus-rs"));
-  const gateway = yield* Effect11.tryPromise({
+import { Effect as Effect14, Layer as Layer7 } from "effect";
+var tcpGatewayLayer = (options, gatewayConfig) => Layer7.effectDiscard(Effect14.gen(function* () {
+  const { AsyncTcpGateway } = yield* Effect14.promise(() => import("modbus-rs"));
+  const gateway = yield* Effect14.tryPromise({
     try: () => AsyncTcpGateway.bind(options, gatewayConfig),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  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({
+  yield* Effect14.logDebug(`TCP gateway bound to ${options.host}:${options.port}`);
+  yield* Effect14.addFinalizer(() => Effect14.logDebug("TCP gateway shutting down").pipe(Effect14.andThen(Effect14.tryPromise({
     try: () => gateway.shutdown(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  })), Effect11.catch(() => Effect11.void)));
+  })), Effect14.catch(() => Effect14.void)));
 }));
 // src/WasmWsTransportService.ts
 import { Context as Context5, Layer as Layer8 } from "effect";
@@ -1644,8 +1760,8 @@ class WasmSerialTransportService extends Context8.Service()("WasmSerialTransport
   };
 }
 // src/WasmSerialPort.ts
-import { Effect as Effect12 } from "effect";
-var requestSerialPort = () => Effect12.tryPromise({
+import { Effect as Effect15 } from "effect";
+var requestSerialPort = () => Effect15.tryPromise({
   try: async () => {
     const mod = await import("modbus-rs/web");
     return mod.requestSerialPort();
@@ -1653,60 +1769,61 @@ var requestSerialPort = () => Effect12.tryPromise({
   catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
 });
 // src/WasmTcpServerService.ts
-import { Effect as Effect13, Layer as Layer12 } from "effect";
-var wasmWsServerLayer = (options, handlers) => Layer12.effectDiscard(Effect13.gen(function* () {
-  const { WasmWsModbusServer } = yield* Effect13.promise(() => import("modbus-rs/web"));
-  const server = yield* Effect13.tryPromise({
+import { Effect as Effect16, Layer as Layer12 } from "effect";
+var wasmWsServerLayer = (options, handlers) => Layer12.effectDiscard(Effect16.gen(function* () {
+  const { WasmWsModbusServer } = yield* Effect16.promise(() => import("modbus-rs/web"));
+  const server = yield* Effect16.tryPromise({
     try: () => WasmWsModbusServer.bind(options, handlers),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  yield* Effect13.logDebug(`WASM WS server bound to ${options.wsUrl}`);
-  yield* Effect13.forkScoped(Effect13.tryPromise({
+  yield* Effect16.logDebug(`WASM WS server bound to ${options.wsUrl}`);
+  yield* Effect16.forkScoped(Effect16.tryPromise({
     try: () => server.serve(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  }).pipe(Effect13.catch((error) => Effect13.logError("WASM WS server loop ended", error))));
-  yield* Effect13.addFinalizer(() => Effect13.logDebug("WASM WS server shutting down").pipe(Effect13.andThen(Effect13.tryPromise({
+  }).pipe(Effect16.catch((error) => Effect16.logError("WASM WS server loop ended", error))));
+  yield* Effect16.addFinalizer(() => Effect16.logDebug("WASM WS server shutting down").pipe(Effect16.andThen(Effect16.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  })), Effect13.catch(() => Effect13.void)));
+  })), Effect16.catch(() => Effect16.void)));
 }));
 // src/WasmSerialModbusServerService.ts
-import { Effect as Effect14, Layer as Layer13 } from "effect";
-var wasmSerialRtuServerLayer = (options, handlers) => Layer13.effectDiscard(Effect14.gen(function* () {
-  const { WasmSerialModbusServer } = yield* Effect14.promise(() => import("modbus-rs/web"));
-  const server = yield* Effect14.tryPromise({
+import { Effect as Effect17, Layer as Layer13 } from "effect";
+var wasmSerialRtuServerLayer = (options, handlers) => Layer13.effectDiscard(Effect17.gen(function* () {
+  const { WasmSerialModbusServer } = yield* Effect17.promise(() => import("modbus-rs/web"));
+  const server = yield* Effect17.tryPromise({
     try: () => WasmSerialModbusServer.bindRtu(options, handlers),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  yield* Effect14.logDebug("WASM serial RTU server bound");
-  yield* Effect14.forkScoped(Effect14.tryPromise({
+  yield* Effect17.logDebug("WASM serial RTU server bound");
+  yield* Effect17.forkScoped(Effect17.tryPromise({
     try: () => server.serve(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  }).pipe(Effect14.catch((error) => Effect14.logError("WASM serial RTU server loop ended", error))));
-  yield* Effect14.addFinalizer(() => Effect14.logDebug("WASM serial RTU server shutting down").pipe(Effect14.andThen(Effect14.tryPromise({
+  }).pipe(Effect17.catch((error) => Effect17.logError("WASM serial RTU server loop ended", error))));
+  yield* Effect17.addFinalizer(() => Effect17.logDebug("WASM serial RTU server shutting down").pipe(Effect17.andThen(Effect17.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  })), Effect14.catch(() => Effect14.void)));
+  })), Effect17.catch(() => Effect17.void)));
 }));
-var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.effectDiscard(Effect14.gen(function* () {
-  const { WasmSerialModbusServer } = yield* Effect14.promise(() => import("modbus-rs/web"));
-  const server = yield* Effect14.tryPromise({
+var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.effectDiscard(Effect17.gen(function* () {
+  const { WasmSerialModbusServer } = yield* Effect17.promise(() => import("modbus-rs/web"));
+  const server = yield* Effect17.tryPromise({
     try: () => WasmSerialModbusServer.bindAscii(options, handlers),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  yield* Effect14.logDebug("WASM serial ASCII server bound");
-  yield* Effect14.forkScoped(Effect14.tryPromise({
+  yield* Effect17.logDebug("WASM serial ASCII server bound");
+  yield* Effect17.forkScoped(Effect17.tryPromise({
     try: () => server.serve(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  }).pipe(Effect14.catch((error) => Effect14.logError("WASM serial ASCII server loop ended", error))));
-  yield* Effect14.addFinalizer(() => Effect14.logDebug("WASM serial ASCII server shutting down").pipe(Effect14.andThen(Effect14.tryPromise({
+  }).pipe(Effect17.catch((error) => Effect17.logError("WASM serial ASCII server loop ended", error))));
+  yield* Effect17.addFinalizer(() => Effect17.logDebug("WASM serial ASCII server shutting down").pipe(Effect17.andThen(Effect17.tryPromise({
     try: () => server.shutdown(),
     catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
-  })), Effect14.catch(() => Effect14.void)));
+  })), Effect17.catch(() => Effect17.void)));
 }));
 export {
   AsciiTransportService,
   ConnectionState,
+  MAX_SERIAL_PORT_PATH,
   MODBUS_MAX_READ_REGISTERS,
   MODBUS_MAX_WRITE_REGISTERS,
   ModbusCircuitOpenError,
@@ -1737,6 +1854,7 @@ export {
   planReads,
   planWrites,
   requestSerialPort,
+  resolveSerialPortPath,
   retryModbus,
   retryableExceptionCodes,
   serialAsciiServerLayer,