@flux-control/effect-modbus-rs 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,6 +1,3 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
 // src/errors.ts
 import { Data } from "effect";
 import { getModbusErrorCode, ModbusErrorCode } from "modbus-rs";
@@ -67,10 +64,19 @@ var defaultRetryableTags = {
   ModbusCircuitOpenError: true,
   ModbusInternalError: false
 };
-var allTags = Object.keys(defaultRetryableTags);
+var allTags = [
+  "ModbusTimeoutError",
+  "ModbusTransportError",
+  "ModbusConnectionClosedError",
+  "ModbusExceptionError",
+  "ModbusInvalidArgumentError",
+  "ModbusNotConnectedError",
+  "ModbusCircuitOpenError",
+  "ModbusInternalError"
+];
 var toMillis = (input) => Duration.toMillis(Duration.fromInputUnsafe(input));
 var resolveRetryableTags = (options) => {
-  const retryable = {};
+  const retryable = { ...defaultRetryableTags };
   for (const tag of allTags) {
     const entry = options.errors?.[tag];
     retryable[tag] = entry === undefined ? defaultRetryableTags[tag] : entry !== false;
@@ -85,19 +91,25 @@ var resolveCurve = (overrides, fallback) => ({
 });
 var resolveDelays = (options) => {
   const policyCurve = resolveCurve(options, defaultCurve);
-  const delays = {};
+  const delays = {
+    ModbusTimeoutError: policyCurve,
+    ModbusTransportError: policyCurve,
+    ModbusConnectionClosedError: policyCurve,
+    ModbusExceptionError: policyCurve,
+    ModbusInvalidArgumentError: policyCurve,
+    ModbusNotConnectedError: policyCurve,
+    ModbusCircuitOpenError: policyCurve,
+    ModbusInternalError: policyCurve
+  };
   for (const tag of allTags) {
     const entry = options.errors?.[tag];
-    delays[tag] = resolveCurve(typeof entry === "object" ? entry : {}, policyCurve);
+    const overrides = entry === undefined || entry === true || entry === false ? {} : entry;
+    delays[tag] = resolveCurve(overrides, policyCurve);
   }
   return delays;
 };
-var mergeOptions = (base, overrides) => overrides === undefined ? base : {
-  ...base,
-  ...overrides,
-  ...base.errors || overrides.errors ? { errors: { ...base.errors, ...overrides.errors } } : {}
-};
-var makeRetryPolicy = (options = {}) => {
+var mergeOptions = (base, overrides) => overrides === undefined ? base : base.errors || overrides.errors ? { ...base, ...overrides, errors: { ...base.errors, ...overrides.errors } } : { ...base, ...overrides };
+var createRetryPolicy = (options = {}) => {
   const retryable = resolveRetryableTags(options);
   const delays = resolveDelays(options);
   const exceptions = options.retryableExceptions ?? retryableExceptionCodes;
@@ -123,15 +135,15 @@ var makeRetryPolicy = (options = {}) => {
   return { schedule, isRetryable };
 };
 var RetryPolicies = {
-  none: (overrides) => makeRetryPolicy(mergeOptions({ maxRetries: 0 }, overrides)),
-  serial: (overrides) => makeRetryPolicy(mergeOptions({
+  none: (overrides) => createRetryPolicy(mergeOptions({ maxRetries: 0 }, overrides)),
+  serial: (overrides) => createRetryPolicy(mergeOptions({
     maxRetries: 3,
     baseDelay: "50 millis",
     factor: 2,
     maxDelay: "1 second",
     errors: { ModbusTimeoutError: { baseDelay: "100 millis" } }
   }, overrides)),
-  tcp: (overrides) => makeRetryPolicy(mergeOptions({
+  tcp: (overrides) => createRetryPolicy(mergeOptions({
     maxRetries: 4,
     baseDelay: "100 millis",
     factor: 2,
@@ -140,7 +152,7 @@ var RetryPolicies = {
       ModbusConnectionClosedError: { baseDelay: "250 millis", maxDelay: "10 seconds" }
     }
   }, overrides)),
-  persistent: (overrides) => makeRetryPolicy(mergeOptions({
+  persistent: (overrides) => createRetryPolicy(mergeOptions({
     maxRetries: 10,
     baseDelay: "250 millis",
     factor: 2,
@@ -152,7 +164,7 @@ var retryModbus = (policy) => (self) => Effect.retry(self, policy.schedule);
 // src/connection.ts
 import { Data as Data2, Duration as Duration2, Effect as Effect2, Result, SubscriptionRef } from "effect";
 var ConnectionState = Data2.taggedEnum();
-var defaultReconnectPolicy = makeRetryPolicy({
+var defaultReconnectPolicy = createRetryPolicy({
   maxRetries: 5,
   baseDelay: "250 millis",
   factor: 2,
@@ -206,22 +218,708 @@ var claimReconnect = (reconnect, state, resolved, scope, onClaim) => Effect2.gen
     yield* onClaim;
   yield* Effect2.forkIn(superviseReconnect(reconnect, state, resolved), scope);
 });
+// src/register-plan.ts
+var MODBUS_MAX_WRITE_REGISTERS = 123;
+var MODBUS_MAX_READ_REGISTERS = 125;
+var MAX_REGISTER_VALUE = 65535;
+var MAX_REGISTER_ADDRESS = 65535;
+var MIN_REGISTER_VALUE = -32768;
+var assertPositiveInteger = (name, value) => {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new RangeError(`${name} must be an integer of 1 or more, got ${value}`);
+  }
+};
+var assertTransactionLimit = (name, value, maximum) => {
+  if (!Number.isInteger(value) || value < 1 || value > maximum) {
+    throw new RangeError(`${name} must be an integer from 1 to ${maximum}, got ${value}`);
+  }
+};
+var assertAddress = (address) => {
+  if (!Number.isInteger(address) || address < 0 || address > MAX_REGISTER_ADDRESS) {
+    throw new RangeError(`address must be an integer from 0 to ${MAX_REGISTER_ADDRESS}, got ${address}`);
+  }
+};
+var encodeRegisterValue = (value) => {
+  if (!Number.isInteger(value) || value < MIN_REGISTER_VALUE || value > MAX_REGISTER_VALUE) {
+    throw new RangeError(`value must be an integer from ${MIN_REGISTER_VALUE} to ${MAX_REGISTER_VALUE}, got ${value}`);
+  }
+  return value & MAX_REGISTER_VALUE;
+};
+var planWrites = (writes, options = {}) => {
+  const maxRegistersPerWrite = options.maxRegistersPerWrite ?? MODBUS_MAX_WRITE_REGISTERS;
+  const minRunLength = options.minRunLength ?? 2;
+  assertTransactionLimit("maxRegistersPerWrite", maxRegistersPerWrite, MODBUS_MAX_WRITE_REGISTERS);
+  assertPositiveInteger("minRunLength", minRunLength);
+  const latest = new Map;
+  for (const write of writes) {
+    assertAddress(write.address);
+    latest.set(write.address, encodeRegisterValue(write.value));
+  }
+  if (latest.size === 0)
+    return [];
+  const addresses = Array.from(latest.keys()).sort((left, right) => left - right);
+  const steps = [];
+  const emitRun = (start, end) => {
+    const length = end - start;
+    if (length >= minRunLength) {
+      const values = new Uint16Array(length);
+      for (let index = 0;index < length; index += 1) {
+        values[index] = latest.get(addresses[start + index]);
+      }
+      steps.push({ kind: "multiple", address: addresses[start], values });
+      return;
+    }
+    for (let index = start;index < end; index += 1) {
+      const address = addresses[index];
+      steps.push({ kind: "single", address, value: latest.get(address) });
+    }
+  };
+  let runStart = 0;
+  for (let index = 1;index <= addresses.length; index += 1) {
+    const endsHere = index === addresses.length || addresses[index] !== addresses[index - 1] + 1 || index - runStart >= maxRegistersPerWrite;
+    if (endsHere) {
+      emitRun(runStart, index);
+      runStart = index;
+    }
+  }
+  return steps;
+};
+var planReads = (addresses, options = {}) => {
+  const maxRegistersPerRead = options.maxRegistersPerRead ?? MODBUS_MAX_READ_REGISTERS;
+  const maxGap = options.maxGap ?? 0;
+  assertTransactionLimit("maxRegistersPerRead", maxRegistersPerRead, MODBUS_MAX_READ_REGISTERS);
+  if (!Number.isInteger(maxGap) || maxGap < 0) {
+    throw new RangeError(`maxGap must be a non-negative integer, got ${maxGap}`);
+  }
+  for (const address of addresses)
+    assertAddress(address);
+  const sorted = Array.from(new Set(addresses)).sort((left, right) => left - right);
+  const spans = [];
+  if (sorted.length > 0) {
+    let start = sorted[0];
+    let end = sorted[0];
+    for (let index = 1;index < sorted.length; index += 1) {
+      const address = sorted[index];
+      const fitsGap = address - end - 1 <= maxGap;
+      const fitsSpan = address - start + 1 <= maxRegistersPerRead;
+      if (fitsGap && fitsSpan) {
+        end = address;
+        continue;
+      }
+      spans.push({ address: start, quantity: end - start + 1 });
+      start = address;
+      end = address;
+    }
+    spans.push({ address: start, quantity: end - start + 1 });
+  }
+  const locate = (address) => {
+    if (!Number.isInteger(address) || address < 0 || address > MAX_REGISTER_ADDRESS) {
+      return;
+    }
+    let low = 0;
+    let high = spans.length - 1;
+    while (low <= high) {
+      const middle = low + high >> 1;
+      const span = spans[middle];
+      if (address < span.address)
+        high = middle - 1;
+      else if (address >= span.address + span.quantity)
+        low = middle + 1;
+      else
+        return { span: middle, offset: address - span.address };
+    }
+    return;
+  };
+  return { spans, locate };
+};
+// src/register-cache.ts
+var assertRegisterAddress = (address) => {
+  if (!Number.isInteger(address) || address < 0 || address > 65535) {
+    throw new RangeError(`address must be an integer from 0 to 65535, got ${address}`);
+  }
+};
+var createRegisterCache = () => {
+  const held = new Map;
+  const keyOf = (unitId, address) => `${unitId}:${address}`;
+  const unitGenerations = new Map;
+  let busGeneration = 0;
+  const generationOf = (unitId) => (unitGenerations.get(unitId) ?? 0) + busGeneration;
+  return {
+    filter: (unitId, writes) => {
+      const latest = new Map;
+      const suppressed = [];
+      for (const write of writes) {
+        assertRegisterAddress(write.address);
+        const encoded = encodeRegisterValue(write.value);
+        const superseded = latest.get(write.address);
+        if (superseded !== undefined)
+          suppressed.push(superseded.write);
+        latest.set(write.address, { write, encoded });
+      }
+      const pending = [];
+      for (const { encoded, write } of latest.values()) {
+        if (held.get(keyOf(unitId, write.address)) === encoded) {
+          suppressed.push(write);
+        } else {
+          pending.push(write);
+        }
+      }
+      return { pending, suppressed };
+    },
+    generationOf,
+    observe: (unitId, address, value, generation) => {
+      assertRegisterAddress(address);
+      if (generation !== undefined && generation !== generationOf(unitId))
+        return;
+      held.set(keyOf(unitId, address), encodeRegisterValue(value));
+    },
+    invalidate: (unitId) => {
+      if (unitId === undefined) {
+        held.clear();
+        busGeneration += 1;
+        return;
+      }
+      unitGenerations.set(unitId, (unitGenerations.get(unitId) ?? 0) + 1);
+      const prefix = `${unitId}:`;
+      for (const key of held.keys()) {
+        if (key.startsWith(prefix))
+          held.delete(key);
+      }
+    },
+    get size() {
+      return held.size;
+    }
+  };
+};
+// src/write-debouncer.ts
+import { Clock, Deferred, Duration as Duration3, Effect as Effect3, Fiber, Semaphore } from "effect";
+var createWriteDebouncer = (options) => Effect3.gen(function* () {
+  const windowMs = Duration3.toMillis(Duration3.fromInputUnsafe(options.window));
+  const maxHoldMs = options.maxHold === undefined ? windowMs * 4 : Duration3.toMillis(Duration3.fromInputUnsafe(options.maxHold));
+  const scope = yield* Effect3.scope;
+  const lock = yield* Semaphore.make(1);
+  const flushLock = yield* Semaphore.make(1);
+  const held = new Map;
+  let timer;
+  let nextTimerId = 0;
+  let openedAtMs;
+  let closed = false;
+  const scopeClosedError = () => {
+    const message = "The write debouncer scope has been closed";
+    return new ModbusNotConnectedError({ cause: new Error(message), message });
+  };
+  const ensureOpen = Effect3.suspend(() => closed ? Effect3.fail(scopeClosedError()) : Effect3.void);
+  const validateWrites = (writes) => Effect3.try({
+    try: () => {
+      for (const write of writes) {
+        if (!Number.isInteger(write.address) || write.address < 0 || write.address > 65535) {
+          throw new RangeError(`address must be an integer from 0 to 65535, got ${write.address}`);
+        }
+        encodeRegisterValue(write.value);
+      }
+    },
+    catch: (cause) => {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      return new ModbusInvalidArgumentError({ cause: error, message: error.message });
+    }
+  });
+  const flushPending = (expectedTimer) => flushLock.withPermits(1)(Effect3.uninterruptibleMask((restore) => Effect3.gen(function* () {
+    const taken = yield* lock.withPermits(1)(Effect3.sync(() => {
+      if (expectedTimer !== undefined && timer?.id !== expectedTimer.id)
+        return;
+      const activeTimer = timer;
+      timer = undefined;
+      const batch = Array.from(held.values());
+      held.clear();
+      openedAtMs = undefined;
+      return { activeTimer, batch };
+    }));
+    if (taken === undefined)
+      return;
+    if (expectedTimer === undefined)
+      taken.activeTimer?.fiber?.interruptUnsafe();
+    if (taken.batch.length === 0)
+      return;
+    const exit = yield* Effect3.exit(restore(options.flush(taken.batch.map((entry) => ({
+      address: entry.write.address,
+      value: entry.write.value,
+      attributes: entry.attributes
+    })))));
+    yield* Effect3.forEach(taken.batch.flatMap((entry) => entry.waiters), (waiter) => Deferred.done(waiter, exit), { discard: true });
+  })));
+  const enqueue = (writes, attributes, restartTimer) => Effect3.gen(function* () {
+    const waiter = yield* Deferred.make();
+    yield* lock.withPermits(1)(Effect3.gen(function* () {
+      if (closed)
+        return yield* scopeClosedError();
+      for (const write of writes) {
+        const superseded = held.get(write.address);
+        held.set(write.address, {
+          write,
+          attributes,
+          waiters: [...superseded?.waiters ?? [], waiter]
+        });
+      }
+      const now = yield* Clock.currentTimeMillis;
+      openedAtMs ??= now;
+      if (!restartTimer)
+        return;
+      const delayMs = Math.max(0, Math.min(windowMs, openedAtMs + maxHoldMs - now));
+      const previous = timer;
+      const state = { id: nextTimerId++ };
+      timer = state;
+      const forked = yield* Effect3.forkIn(Effect3.sleep(Duration3.millis(delayMs)).pipe(Effect3.andThen(flushPending(state))), scope);
+      state.fiber = forked;
+      if (timer?.id !== state.id)
+        forked.interruptUnsafe();
+      previous?.fiber?.interruptUnsafe();
+    }));
+    return waiter;
+  });
+  const issueDirectly = (writes, attributes) => flushLock.withPermits(1)(options.flush(writes.map((write) => ({ address: write.address, value: write.value, attributes }))));
+  const writeAll = (writes, attributes) => {
+    if (writes.length === 0)
+      return Effect3.void;
+    return Effect3.andThen(ensureOpen, Effect3.andThen(validateWrites(writes), windowMs <= 0 ? issueDirectly(writes, attributes) : Effect3.flatMap(enqueue(writes, attributes, true), Deferred.await)));
+  };
+  const writeAllNow = (writes, attributes) => {
+    if (writes.length === 0)
+      return Effect3.void;
+    return Effect3.andThen(ensureOpen, Effect3.andThen(validateWrites(writes), windowMs <= 0 ? issueDirectly(writes, attributes) : Effect3.uninterruptibleMask((restore) => Effect3.gen(function* () {
+      const waiter = yield* enqueue(writes, attributes, false);
+      yield* Effect3.forkIn(flushPending(), scope);
+      return yield* restore(Deferred.await(waiter));
+    }))));
+  };
+  const write = (write, attributes) => writeAll([write], attributes);
+  const writeNow = (write, attributes) => writeAllNow([write], attributes);
+  const flush = Effect3.uninterruptibleMask((restore) => Effect3.gen(function* () {
+    const fiber = yield* Effect3.forkIn(flushPending(), scope);
+    yield* restore(Fiber.await(fiber));
+  }));
+  yield* Effect3.addFinalizer(() => Effect3.andThen(Effect3.sync(() => {
+    closed = true;
+  }), lock.withPermits(1)(Effect3.sync(() => {
+    const abandoned = Array.from(held.values());
+    held.clear();
+    openedAtMs = undefined;
+    return abandoned;
+  })).pipe(Effect3.flatMap((abandoned) => abandoned.length === 0 ? Effect3.void : Effect3.logWarning(`Discarding ${abandoned.length} pending register write(s) at shutdown`).pipe(Effect3.andThen(Effect3.forEach(abandoned.flatMap((entry) => entry.waiters), Deferred.interrupt, { discard: true })))))));
+  return {
+    write,
+    writeNow,
+    writeAll,
+    writeAllNow,
+    flush,
+    get pending() {
+      return held.size;
+    }
+  };
+});
+// src/read-debouncer.ts
+import { Deferred as Deferred2, Duration as Duration4, Effect as Effect4, Exit, Fiber as Fiber2, Semaphore as Semaphore2 } from "effect";
+var malformedResponse = (message) => new ModbusTransportError({ cause: new Error(message), message });
+var shortResponse = (address) => malformedResponse(`Response did not carry a value for register ${address}`);
+var settleWith = (value, address) => (waiter) => value === undefined ? Deferred2.fail(waiter, shortResponse(address)) : Deferred2.succeed(waiter, value);
+var createReadDebouncer = (options) => Effect4.gen(function* () {
+  const windowMs = Duration4.toMillis(Duration4.fromInputUnsafe(options.window));
+  const scope = yield* Effect4.scope;
+  const lock = yield* Semaphore2.make(1);
+  const collected = new Map;
+  let timer;
+  let nextTimerId = 0;
+  let closed = false;
+  const scopeClosedError = () => {
+    const message = "The read debouncer scope has been closed";
+    return new ModbusNotConnectedError({ cause: new Error(message), message });
+  };
+  const ensureOpen = Effect4.suspend(() => closed ? Effect4.fail(scopeClosedError()) : Effect4.void);
+  const validateAddresses = (addresses) => Effect4.try({
+    try: () => {
+      for (const address of addresses) {
+        if (!Number.isInteger(address) || address < 0 || address > 65535) {
+          throw new RangeError(`address must be an integer from 0 to 65535, got ${address}`);
+        }
+      }
+    },
+    catch: (cause) => {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      return new ModbusInvalidArgumentError({ cause: error, message: error.message });
+    }
+  });
+  const issue = (addresses) => Effect4.gen(function* () {
+    const plan = yield* Effect4.try({
+      try: () => planReads(addresses, options.plan),
+      catch: (cause) => {
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        return new ModbusInvalidArgumentError({ cause: error, message: error.message });
+      }
+    });
+    const responses = yield* options.fetch(plan.spans);
+    if (responses.length !== plan.spans.length) {
+      return yield* malformedResponse(`Expected ${plan.spans.length} read response(s), received ${responses.length}`);
+    }
+    for (let index = 0;index < plan.spans.length; index += 1) {
+      const span = plan.spans[index];
+      const response = responses[index];
+      if (response.length !== span.quantity) {
+        return yield* malformedResponse(`Expected ${span.quantity} register(s) for span at address ${span.address}, ` + `received ${response.length}`);
+      }
+    }
+    return (address) => {
+      const location = plan.locate(address);
+      return location === undefined ? undefined : responses[location.span]?.[location.offset];
+    };
+  });
+  const issueDirectly = (addresses) => Effect4.flatMap(issue(addresses), (valueOf) => Effect4.forEach(addresses, (address) => {
+    const value = valueOf(address);
+    return value === undefined ? Effect4.fail(shortResponse(address)) : Effect4.succeed(value);
+  }));
+  const flushPending = (expectedTimer) => Effect4.uninterruptibleMask((restore) => Effect4.gen(function* () {
+    const taken = yield* lock.withPermits(1)(Effect4.sync(() => {
+      if (expectedTimer !== undefined && timer?.id !== expectedTimer.id)
+        return;
+      const activeTimer = timer;
+      timer = undefined;
+      const batch = Array.from(collected.entries());
+      collected.clear();
+      return { activeTimer, batch };
+    }));
+    if (taken === undefined)
+      return;
+    if (expectedTimer === undefined)
+      taken.activeTimer?.fiber?.interruptUnsafe();
+    if (taken.batch.length === 0)
+      return;
+    const exit = yield* Effect4.exit(restore(issue(taken.batch.map(([address]) => address))));
+    yield* Effect4.forEach(taken.batch, ([address, waiters]) => {
+      const settle = Exit.isSuccess(exit) ? settleWith(exit.value(address), address) : (waiter) => Deferred2.failCause(waiter, exit.cause);
+      return Effect4.forEach(waiters, settle, { discard: true });
+    }, { discard: true });
+  }));
+  const enqueue = (addresses, startTimer) => Effect4.gen(function* () {
+    const waiters = yield* Effect4.forEach(addresses, () => Deferred2.make());
+    yield* lock.withPermits(1)(Effect4.gen(function* () {
+      if (closed)
+        return yield* scopeClosedError();
+      addresses.forEach((address, index) => {
+        const existing = collected.get(address);
+        if (existing === undefined)
+          collected.set(address, [waiters[index]]);
+        else
+          existing.push(waiters[index]);
+      });
+    }).pipe(Effect4.andThen(Effect4.suspend(() => {
+      if (!startTimer || timer !== undefined)
+        return Effect4.void;
+      const state = { id: nextTimerId++ };
+      timer = state;
+      return Effect4.map(Effect4.forkIn(Effect4.sleep(Duration4.millis(windowMs)).pipe(Effect4.andThen(flushPending(state))), scope), (forked) => {
+        state.fiber = forked;
+        if (timer?.id !== state.id)
+          forked.interruptUnsafe();
+      });
+    }))));
+    return waiters;
+  });
+  const readAll = (addresses) => {
+    if (addresses.length === 0)
+      return Effect4.succeed([]);
+    return Effect4.andThen(ensureOpen, Effect4.andThen(validateAddresses(addresses), windowMs <= 0 ? issueDirectly(addresses) : Effect4.flatMap(enqueue(addresses, true), (waiters) => Effect4.forEach(waiters, Deferred2.await))));
+  };
+  const readAllNow = (addresses) => {
+    if (addresses.length === 0)
+      return Effect4.succeed([]);
+    return Effect4.andThen(ensureOpen, Effect4.andThen(validateAddresses(addresses), windowMs <= 0 ? issueDirectly(addresses) : Effect4.uninterruptibleMask((restore) => Effect4.gen(function* () {
+      const waiters = yield* enqueue(addresses, false);
+      yield* Effect4.forkIn(flushPending(), scope);
+      return yield* restore(Effect4.forEach(waiters, Deferred2.await));
+    }))));
+  };
+  const read = (address) => Effect4.map(readAll([address]), (values) => values[0]);
+  const readNow = (address) => Effect4.map(readAllNow([address]), (values) => values[0]);
+  const flush = Effect4.uninterruptibleMask((restore) => Effect4.gen(function* () {
+    const fiber = yield* Effect4.forkIn(flushPending(), scope);
+    yield* restore(Fiber2.await(fiber));
+  }));
+  yield* Effect4.addFinalizer(() => Effect4.andThen(Effect4.sync(() => {
+    closed = true;
+  }), lock.withPermits(1)(Effect4.sync(() => {
+    const abandoned = Array.from(collected.values()).flat();
+    collected.clear();
+    return abandoned;
+  })).pipe(Effect4.flatMap((abandoned) => abandoned.length === 0 ? Effect4.void : Effect4.logWarning(`Discarding ${abandoned.length} pending register read(s) at shutdown`).pipe(Effect4.andThen(Effect4.forEach(abandoned, Deferred2.interrupt, { discard: true })))))));
+  return {
+    read,
+    readNow,
+    readAll,
+    readAllNow,
+    flush,
+    get pending() {
+      return collected.size;
+    }
+  };
+});
+// src/batching-client.ts
+import {
+  Deferred as Deferred3,
+  Effect as Effect5,
+  Exit as Exit2,
+  Fiber as Fiber3,
+  Scope,
+  Semaphore as Semaphore3,
+  Stream,
+  SubscriptionRef as SubscriptionRef2
+} from "effect";
+
+// src/span-attributes.ts
+var mergeSpanAttributes = (sources) => {
+  const collected = new Map;
+  for (const source of sources) {
+    if (source === undefined)
+      continue;
+    for (const [key, value] of Object.entries(source)) {
+      const entry = collected.get(key);
+      if (entry === undefined)
+        collected.set(key, { first: value, values: new Set([String(value)]) });
+      else
+        entry.values.add(String(value));
+    }
+  }
+  return Object.fromEntries(Array.from(collected, ([key, entry]) => [
+    key,
+    entry.values.size === 1 ? entry.first : Array.from(entry.values).join(",")
+  ]));
+};
+
+// src/batching-client.ts
+var makeBatchingClient = (options) => Effect5.gen(function* () {
+  const { unitId, client, cache } = options;
+  const scope = yield* Effect5.scope;
+  const invalidArgument = (cause) => {
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    return new ModbusInvalidArgumentError({ cause: error, message: error.message });
+  };
+  const own = (registerCount, transactionCount, suppressedCount) => ({
+    "modbus.unit_ids": String(unitId),
+    "modbus.register_count": registerCount,
+    "modbus.transaction_count": transactionCount,
+    "modbus.suppressed_count": suppressedCount
+  });
+  const issueWrites = (batch) => Effect5.gen(function* () {
+    const proposed = batch.map((entry) => ({ address: entry.address, value: entry.value }));
+    const filtered = yield* Effect5.try({
+      try: () => cache?.filter(unitId, proposed),
+      catch: invalidArgument
+    });
+    const pending = filtered?.pending ?? proposed;
+    if (pending.length === 0)
+      return;
+    const plan = yield* Effect5.try({
+      try: () => {
+        const steps = planWrites(pending, options.plan?.writes);
+        if (pending.length === proposed.length)
+          return { steps, written: proposed };
+        const whole = planWrites(proposed, options.plan?.writes);
+        return whole.length < steps.length ? { steps: whole, written: proposed } : { steps, written: pending };
+      },
+      catch: invalidArgument
+    });
+    const { steps, written } = plan;
+    const carried = new Set(written.map((write) => write.address));
+    const suppressed = proposed.length - written.length;
+    yield* Effect5.forEach(steps, (step) => Effect5.suspend(() => {
+      const generation = cache?.generationOf(unitId);
+      return step.kind === "single" ? Effect5.tap(client.writeSingleRegister({ address: step.address, value: step.value }), () => Effect5.sync(() => cache?.observe(unitId, step.address, step.value, generation))) : Effect5.tap(client.writeMultipleRegisters({ address: step.address, values: step.values }), () => Effect5.sync(() => step.values.forEach((value, index) => cache?.observe(unitId, step.address + index, value, generation))));
+    }), { discard: true }).pipe(Effect5.tapError(() => Effect5.sync(() => cache?.invalidate(unitId))), Effect5.withSpan("modbus.write", {
+      kind: "client",
+      attributes: {
+        ...mergeSpanAttributes(batch.filter((entry) => carried.has(entry.address)).map((entry) => entry.attributes)),
+        ...own(written.length, steps.length, suppressed)
+      }
+    }));
+  });
+  const issueReads = (name, read) => (spans) => Effect5.forEach(spans, (span) => read({ address: span.address, quantity: span.quantity })).pipe(Effect5.withSpan(name, {
+    kind: "client",
+    attributes: own(spans.reduce((total, span) => total + span.quantity, 0), spans.length, 0)
+  }));
+  const writes = yield* createWriteDebouncer({
+    window: options.debounce?.writes?.window ?? 0,
+    maxHold: options.debounce?.writes?.maxHold,
+    flush: issueWrites
+  });
+  const holding = yield* createReadDebouncer({
+    window: options.debounce?.reads?.window ?? 0,
+    plan: options.plan?.reads,
+    fetch: issueReads("modbus.read", client.readHoldingRegisters)
+  });
+  const inputs = yield* createReadDebouncer({
+    window: options.debounce?.reads?.window ?? 0,
+    plan: options.plan?.reads,
+    fetch: issueReads("modbus.read", client.readInputRegisters)
+  });
+  const readerOf = (debouncer) => ({
+    read: debouncer.read,
+    readNow: debouncer.readNow,
+    readAll: debouncer.readAll,
+    readAllNow: debouncer.readAllNow
+  });
+  const flush = Effect5.uninterruptibleMask((restore) => Effect5.gen(function* () {
+    const fiber = yield* Effect5.forkIn(Effect5.andThen(writes.flush, Effect5.andThen(holding.flush, inputs.flush)), scope);
+    yield* restore(Fiber3.await(fiber));
+  }));
+  const onShutdown = (action) => Effect5.addFinalizer(() => action.pipe(Effect5.tapError((error) => Effect5.logError(`Shutdown action for unit ${unitId} failed: ${error.message}`)), Effect5.orDie));
+  return {
+    unitId,
+    cache,
+    write: writes.write,
+    writeNow: writes.writeNow,
+    writeAll: writes.writeAll,
+    writeAllNow: writes.writeAllNow,
+    ...readerOf(holding),
+    inputs: readerOf(inputs),
+    flush,
+    onShutdown
+  };
+});
+var createBatchingRegistry = (deps) => {
+  const clientScope = Scope.forkUnsafe(deps.scope);
+  const clients = new Map;
+  const creating = new Map;
+  const writeLocks = new Map;
+  let shared;
+  let closed = false;
+  let watchingScope = false;
+  const scopeClosedError = () => {
+    const message = "The batching registry scope has been closed";
+    return new ModbusNotConnectedError({ cause: new Error(message), message });
+  };
+  const watchScope = Effect5.suspend(() => {
+    if (watchingScope)
+      return Effect5.void;
+    watchingScope = true;
+    return Scope.addFinalizer(clientScope, Effect5.gen(function* () {
+      closed = true;
+      const pending = Array.from(creating.values());
+      creating.clear();
+      yield* Effect5.forEach(pending, (deferred) => Deferred3.fail(deferred, scopeClosedError()), {
+        discard: true
+      });
+    }));
+  });
+  const sharedCache = Effect5.fnUntraced(function* () {
+    if (shared)
+      return shared;
+    const cache = createRegisterCache();
+    shared = cache;
+    yield* Effect5.forkIn(Stream.runForEach(SubscriptionRef2.changes(deps.connectionState), (state) => Effect5.sync(() => {
+      if (!ConnectionState.$is("Connected")(state))
+        cache.invalidate();
+    })), clientScope);
+    return cache;
+  });
+  const writeLockFor = (unitId) => {
+    const existing = writeLocks.get(unitId);
+    if (existing)
+      return existing;
+    const created = Semaphore3.makeUnsafe(1);
+    writeLocks.set(unitId, created);
+    return created;
+  };
+  const guardRawWrites = (unitId, operations) => {
+    const write = (operation) => writeLockFor(unitId).withPermits(1)(Effect5.suspend(() => {
+      if (!clients.has(unitId) && !creating.has(unitId))
+        return operation();
+      const message = `Raw register writes are disabled for unit ${unitId} because a batching client exists. ` + `Use the batching client for every holding-register write on that unit.`;
+      return Effect5.fail(new ModbusInvalidArgumentError({ cause: new Error(message), message }));
+    }));
+    return {
+      ...operations,
+      writeSingleRegister: (options) => write(() => operations.writeSingleRegister(options)),
+      writeMultipleRegisters: (options) => write(() => operations.writeMultipleRegisters(options)),
+      readWriteMultipleRegisters: (options) => write(() => operations.readWriteMultipleRegisters(options))
+    };
+  };
+  const alreadyDeclaredError = (unitId) => {
+    const message = `Unit ${unitId} already has a batching client. One unit has one batch, so a unit ` + `is declared once. Use batchingClient(${unitId}) to reach the existing one.`;
+    return new ModbusInvalidArgumentError({ cause: new Error(message), message });
+  };
+  const notDeclaredError = (unitId) => {
+    const message = `No batching client is declared for unit ${unitId}. Declare one with ` + `withBatchingClient(${unitId}) before reaching for it.`;
+    return new ModbusInvalidArgumentError({ cause: new Error(message), message });
+  };
+  return {
+    withBatchingClient: (unitId, options) => Effect5.uninterruptibleMask((restore) => Effect5.gen(function* () {
+      yield* watchScope;
+      if (closed)
+        return yield* scopeClosedError();
+      const configuredCache = options?.cache;
+      const injected = configuredCache === undefined || configuredCache === true || configuredCache === false ? undefined : configuredCache;
+      const fresh = yield* Deferred3.make();
+      const election = yield* Effect5.sync(() => {
+        if (closed)
+          return { _tag: "Closed" };
+        if (clients.has(unitId) || creating.has(unitId)) {
+          return { _tag: "Declared" };
+        }
+        creating.set(unitId, fresh);
+        return { _tag: "Leader" };
+      });
+      if (election._tag === "Closed")
+        return yield* scopeClosedError();
+      if (election._tag === "Declared")
+        return yield* alreadyDeclaredError(unitId);
+      const build = writeLockFor(unitId).withPermits(1)(Effect5.gen(function* () {
+        const raw = yield* deps.withClient(unitId, { retry: options?.retry });
+        let cache;
+        if (options?.cache !== false)
+          cache = injected ?? (yield* sharedCache());
+        const client = yield* Scope.provide(makeBatchingClient({
+          unitId,
+          client: raw,
+          cache,
+          debounce: options?.debounce,
+          plan: options?.plan
+        }), clientScope);
+        return { cache, client };
+      }));
+      yield* Effect5.forkIn(Effect5.uninterruptible(Effect5.flatMap(Effect5.exit(Effect5.interruptible(build)), (exit) => Effect5.andThen(Effect5.sync(() => {
+        creating.delete(unitId);
+        if (Exit2.isSuccess(exit))
+          clients.set(unitId, exit.value.client);
+      }), Deferred3.done(fresh, Exit2.hasInterrupts(exit) ? Exit2.fail(scopeClosedError()) : Exit2.map(exit, ({ client }) => client))))), clientScope);
+      return yield* restore(Deferred3.await(fresh));
+    })),
+    batchingClient: (unitId) => Effect5.uninterruptibleMask((restore) => Effect5.gen(function* () {
+      if (closed)
+        return yield* scopeClosedError();
+      const existing = clients.get(unitId);
+      if (existing)
+        return existing;
+      const pending = creating.get(unitId);
+      if (pending)
+        return yield* restore(Deferred3.await(pending));
+      return yield* notDeclaredError(unitId);
+    })),
+    guardRawWrites
+  };
+};
 // src/AsciiTransportService.ts
 import { Context, Layer } from "effect";
 
 // src/mocks.ts
-import { Effect as Effect4, Schema, SubscriptionRef as SubscriptionRef2 } from "effect";
+import { Effect as Effect7, Exit as Exit3, Schema, Scope as Scope2, SubscriptionRef as SubscriptionRef3 } from "effect";
 import {
   CoilState
 } from "modbus-rs";
 
 // src/modbus-client.ts
-import { Effect as Effect3 } from "effect";
-var wrap = (try_) => Effect3.tryPromise({
+import { Effect as Effect6 } from "effect";
+var wrap = (try_) => Effect6.tryPromise({
   try: try_,
-  catch: (error) => toModbusError(error)
+  catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
 });
-var makeEffectModbusClient = (client) => ({
+var createEffectModbusClient = (client) => ({
   readHoldingRegisters: (opts) => wrap(() => client.readHoldingRegisters(opts)),
   readInputRegisters: (opts) => wrap(() => client.readInputRegisters(opts)),
   writeSingleRegister: (opts) => wrap(() => client.writeSingleRegister(opts)),
@@ -240,7 +938,7 @@ var makeEffectModbusClient = (client) => ({
 });
 var withResilience = (operations, resilience) => {
   const run = (operation) => {
-    const attempt = Effect3.andThen(resilience.guard, Effect3.suspend(operation)).pipe(Effect3.tapError((error) => resilience.report(error)));
+    const attempt = Effect6.andThen(resilience.guard, Effect6.suspend(operation)).pipe(Effect6.tap(() => resilience.onSuccess ?? Effect6.void), Effect6.tapError((error) => resilience.report(error)));
     return resilience.policy ? retryModbus(resilience.policy)(attempt) : attempt;
   };
   return {
@@ -278,10 +976,10 @@ var RegisterDefinition = Schema.Struct({
 });
 var SlaveDeviceDefinition = Schema.Struct({
   unitId: Schema.Number,
-  coils: Schema.Array(CoilDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([]))),
-  discreteInputs: Schema.Array(DiscreteInputDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([]))),
-  holdingRegisters: Schema.Array(RegisterDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([]))),
-  inputRegisters: Schema.Array(RegisterDefinition).pipe(Schema.withDecodingDefaultType(Effect4.succeed([])))
+  coils: Schema.Array(CoilDefinition).pipe(Schema.withDecodingDefaultType(Effect7.succeed([]))),
+  discreteInputs: Schema.Array(DiscreteInputDefinition).pipe(Schema.withDecodingDefaultType(Effect7.succeed([]))),
+  holdingRegisters: Schema.Array(RegisterDefinition).pipe(Schema.withDecodingDefaultType(Effect7.succeed([]))),
+  inputRegisters: Schema.Array(RegisterDefinition).pipe(Schema.withDecodingDefaultType(Effect7.succeed([])))
 });
 var SlaveDeviceDefinitions = Schema.Array(SlaveDeviceDefinition);
 var buildCoils = (defs) => {
@@ -309,8 +1007,8 @@ var failOutOfRange = (label, address, quantity) => new ModbusInvalidArgumentErro
   message: quantity !== undefined ? `${label} read out of range: address=${address}, quantity=${quantity}` : `${label} write out of range: address=${address}`
 });
 var makeMockModbusClient = (state, unitId) => ({
-  readCoils: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readCoils`, opts);
+  readCoils: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} readCoils`, opts);
     if (opts.address + opts.quantity > state.maxCoilAddress + 1) {
       return yield* failOutOfRange("Coil", opts.address, opts.quantity);
     }
@@ -320,8 +1018,8 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return result;
   }),
-  readDiscreteInputs: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readDiscreteInputs`, opts);
+  readDiscreteInputs: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} readDiscreteInputs`, opts);
     if (opts.address + opts.quantity > state.maxDiscreteAddress + 1) {
       return yield* failOutOfRange("DiscreteInput", opts.address, opts.quantity);
     }
@@ -331,8 +1029,8 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return result;
   }),
-  readHoldingRegisters: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readHoldingRegisters`, opts);
+  readHoldingRegisters: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} readHoldingRegisters`, opts);
     if (opts.address + opts.quantity > state.maxHoldingAddress + 1) {
       return yield* failOutOfRange("HoldingRegister", opts.address, opts.quantity);
     }
@@ -342,8 +1040,8 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return new Uint16Array(result);
   }),
-  readInputRegisters: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readInputRegisters`, opts);
+  readInputRegisters: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} readInputRegisters`, opts);
     if (opts.address + opts.quantity > state.maxInputAddress + 1) {
       return yield* failOutOfRange("InputRegister", opts.address, opts.quantity);
     }
@@ -353,15 +1051,15 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return new Uint16Array(result);
   }),
-  writeSingleCoil: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeSingleCoil`, opts);
+  writeSingleCoil: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} writeSingleCoil`, opts);
     if (opts.address > state.maxCoilAddress) {
       return yield* failOutOfRange("Coil", opts.address);
     }
     state.coils.set(opts.address, opts.value === CoilState.On);
   }),
-  writeMultipleCoils: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeMultipleCoils`, opts);
+  writeMultipleCoils: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} writeMultipleCoils`, opts);
     if (opts.address + opts.values.length > state.maxCoilAddress + 1) {
       return yield* failOutOfRange("Coil", opts.address, opts.values.length);
     }
@@ -369,15 +1067,15 @@ var makeMockModbusClient = (state, unitId) => ({
       state.coils.set(opts.address + i, opts.values[i] === CoilState.On);
     }
   }),
-  writeSingleRegister: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeSingleRegister`, opts);
+  writeSingleRegister: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.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: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} writeMultipleRegisters`, opts);
+  writeMultipleRegisters: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} writeMultipleRegisters`, opts);
     if (opts.address + opts.values.length > state.maxHoldingAddress + 1) {
       return yield* failOutOfRange("HoldingRegister", opts.address, opts.values.length);
     }
@@ -385,8 +1083,8 @@ var makeMockModbusClient = (state, unitId) => ({
       state.holdingRegisters.set(opts.address + i, opts.values[i]);
     }
   }),
-  readWriteMultipleRegisters: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readWriteMultipleRegisters`, opts);
+  readWriteMultipleRegisters: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} readWriteMultipleRegisters`, opts);
     if (opts.writeAddress + opts.writeValues.length > state.maxHoldingAddress + 1) {
       return yield* failOutOfRange("HoldingRegister", opts.writeAddress, opts.writeValues.length);
     }
@@ -402,34 +1100,34 @@ var makeMockModbusClient = (state, unitId) => ({
     }
     return new Uint16Array(result);
   }),
-  readFifoQueue: Effect4.fnUntraced(function* (_opts) {
+  readFifoQueue: Effect7.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: Effect4.fnUntraced(function* (_opts) {
+  readFileRecord: Effect7.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: Effect4.fnUntraced(function* (_opts) {
+  writeFileRecord: Effect7.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: Effect4.fnUntraced(function* () {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readExceptionStatus`);
+  readExceptionStatus: Effect7.fnUntraced(function* () {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} readExceptionStatus`);
     return 0;
   }),
-  diagnostics: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} diagnostics`, opts);
+  diagnostics: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} diagnostics`, opts);
     return { subFunction: opts.subFunction, data: new Uint16Array };
   }),
-  readDeviceIdentification: Effect4.fnUntraced(function* (opts) {
-    yield* Effect4.logDebug(`[Mock] unitId=${unitId} readDeviceIdentification`, opts);
+  readDeviceIdentification: Effect7.fnUntraced(function* (opts) {
+    yield* Effect7.logDebug(`[Mock] unitId=${unitId} readDeviceIdentification`, opts);
     return {
       conformityLevel: 1,
       moreFollows: false,
@@ -438,7 +1136,7 @@ var makeMockModbusClient = (state, unitId) => ({
     };
   })
 });
-var makeMockTransport = (devices) => {
+var createMockTransport = (devices) => {
   const deviceDefs = Schema.decodeUnknownSync(SlaveDeviceDefinitions)(devices);
   const deviceStates = new Map;
   for (const def of deviceDefs) {
@@ -457,144 +1155,260 @@ var makeMockTransport = (devices) => {
       maxInputAddress: input.maxAddress
     });
   }
-  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.andThen(Effect4.logDebug("Mock: reconnecting"), Effect4.suspend(() => {
+  return (options) => Effect7.gen(function* () {
+    yield* Effect7.logDebug("Mock transport opened with devices:", deviceDefs);
+    const connectionState = yield* SubscriptionRef3.make(ConnectionState.Connected());
+    const resolvedReconnect = resolveReconnect(options.reconnect ?? {});
+    const supervised = options.reconnect ? resolvedReconnect : null;
+    const serviceScope = yield* Effect7.scope;
+    let closed = false;
+    const transportClosed = () => new ModbusNotConnectedError({
+      cause: new Error("Mock transport has been closed"),
+      message: "Mock transport has been closed"
+    });
+    const ensureOpen = Effect7.suspend(() => closed ? Effect7.fail(transportClosed()) : Effect7.void);
+    const closeTransport = Effect7.suspend(() => {
+      if (closed)
+        return Effect7.void;
+      closed = true;
+      return Effect7.andThen(Effect7.logDebug("Mock: closing transport"), SubscriptionRef3.set(connectionState, ConnectionState.Disconnected()));
+    });
+    yield* Effect7.addFinalizer(() => closeTransport);
+    const reconnectOnce = Effect7.andThen(ensureOpen, Effect7.andThen(Effect7.logDebug("Mock: reconnecting"), Effect7.suspend(() => {
       const injected = options.reconnectFault?.();
-      return injected ? Effect4.fail(injected) : Effect4.void;
-    }));
+      return injected ? Effect7.fail(injected) : Effect7.void;
+    })));
     const report = (error) => {
-      if (!supervised || !supervised.triggers(error))
-        return Effect4.void;
+      if (closed || !resolvedReconnect.triggers(error))
+        return Effect7.void;
+      if (!supervised) {
+        return SubscriptionRef3.update(connectionState, (current) => ConnectionState.$is("Connected")(current) ? ConnectionState.Down({ cause: error }) : current);
+      }
       return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope);
     };
-    const guard = Effect4.andThen(supervised ? guardCircuit(connectionState) : Effect4.void, Effect4.suspend(() => {
+    const guard = Effect7.andThen(ensureOpen, Effect7.andThen(supervised ? guardCircuit(connectionState) : Effect7.void, Effect7.suspend(() => {
       const injected = options.fault?.();
-      return injected ? Effect4.fail(injected) : Effect4.void;
-    }));
+      return injected ? Effect7.fail(injected) : Effect7.void;
+    })));
+    const onSuccess = supervised ? undefined : SubscriptionRef3.update(connectionState, (current) => ConnectionState.$is("Down")(current) ? ConnectionState.Connected() : current);
+    const touchedUnits = new Set;
+    const makeOperations = Effect7.fnUntraced(function* (unitId) {
+      yield* ensureOpen;
+      const state = deviceStates.get(unitId);
+      if (!state) {
+        return yield* new ModbusInvalidArgumentError({
+          cause: new Error(`Device with unitId ${unitId} not found in mock configuration`),
+          message: `Device with unitId ${unitId} not found in mock configuration`
+        });
+      }
+      touchedUnits.add(unitId);
+      return makeMockModbusClient(state, unitId);
+    });
+    const makeClient = Effect7.fnUntraced(function* (unitId, clientOptions) {
+      const operations = yield* makeOperations(unitId);
+      return withResilience(operations, {
+        guard,
+        onSuccess,
+        report,
+        policy: clientOptions?.retry ?? options.retry
+      });
+    });
+    const batching = createBatchingRegistry({
+      withClient: makeClient,
+      connectionState,
+      scope: serviceScope
+    });
+    const withClient = Effect7.fnUntraced(function* (unitId, clientOptions) {
+      const operations = yield* makeOperations(unitId);
+      return withResilience(batching.guardRawWrites(unitId, operations), {
+        guard,
+        onSuccess,
+        report,
+        policy: clientOptions?.retry ?? options.retry
+      });
+    });
     return {
       connectionState,
-      withClient: Effect4.fnUntraced(function* (unitId, clientOptions) {
-        const state = deviceStates.get(unitId);
-        if (!state) {
-          return yield* new ModbusInvalidArgumentError({
-            cause: new Error(`Device with unitId ${unitId} not found in mock configuration`),
-            message: `Device with unitId ${unitId} not found in mock configuration`
-          });
-        }
-        return withResilience(makeMockModbusClient(state, unitId), {
-          guard,
-          report,
-          policy: clientOptions?.retry ?? options.retry
-        });
+      withClient,
+      withBatchingClient: (unitId, clientOptions) => Effect7.andThen(ensureOpen, batching.withBatchingClient(unitId, clientOptions)),
+      batchingClient: (unitId) => Effect7.andThen(ensureOpen, batching.batchingClient(unitId)),
+      get touchedUnits() {
+        return new Set(touchedUnits);
+      },
+      setRequestTimeout: (_timeoutMs) => ensureOpen,
+      clearRequestTimeout: () => ensureOpen,
+      reconnect: () => Effect7.andThen(reconnectOnce, SubscriptionRef3.set(connectionState, ConnectionState.Connected())),
+      close: () => Effect7.gen(function* () {
+        if (closed)
+          return;
+        const scope = yield* Effect7.scope;
+        yield* Scope2.close(scope, Exit3.void).pipe(Effect7.onExit(() => closeTransport));
       }),
-      setRequestTimeout: (_timeoutMs) => Effect4.void,
-      clearRequestTimeout: () => Effect4.void,
-      reconnect: () => Effect4.andThen(reconnectOnce, SubscriptionRef2.set(connectionState, ConnectionState.Connected())),
-      close: () => Effect4.andThen(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";
+import { Deferred as Deferred4, Duration as Duration6, Effect as Effect8, Exit as Exit4, Option, Ref, Scope as Scope3, SubscriptionRef as SubscriptionRef4 } from "effect";
 var makeInFlight = () => Ref.make(Option.none());
-var singleFlight = (inFlight, work) => Effect5.uninterruptibleMask((restore) => Effect5.gen(function* () {
-  const fresh = yield* Deferred.make();
+var singleFlight = (inFlight, work) => Effect8.uninterruptibleMask((restore) => Effect8.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* Effect5.forkDetach(Effect5.interruptible(work).pipe(Effect5.onExit((exit) => Effect5.andThen(Ref.set(inFlight, Option.none()), Deferred.done(deferred, exit)))));
+    yield* Effect8.forkDetach(Effect8.interruptible(work).pipe(Effect8.onExit((exit) => Effect8.andThen(Ref.set(inFlight, Option.none()), Deferred4.done(deferred, exit)))));
   }
-  return yield* restore(Deferred.await(deferred));
+  return yield* restore(Deferred4.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];
+var loadTransportConstructor = async (transportKey, moduleSpecifier) => {
+  if (moduleSpecifier === "modbus-rs/web") {
+    const mod = await import("modbus-rs/web");
+    switch (transportKey) {
+      case "WasmAsciiTransport":
+        return mod.WasmAsciiTransport;
+      case "WasmRtuTransport":
+        return mod.WasmRtuTransport;
+      case "WasmWsTransport":
+        return mod.WasmWsTransport;
+      default:
+        throw new Error(`${transportKey} is not exported by modbus-rs/web`);
+    }
+  }
+  const mod = await import("modbus-rs");
+  switch (transportKey) {
+    case "AsyncAsciiTransport":
+      return mod.AsyncAsciiTransport;
+    case "AsyncRtuTransport":
+      return mod.AsyncRtuTransport;
+    case "AsyncTcpTransport":
+      return mod.AsyncTcpTransport;
+    default:
+      throw new Error(`${transportKey} is not exported by modbus-rs`);
+  }
+};
+function createTransportScoped(transportKey, openMethod, serviceName, config) {
+  return Effect8.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"));
     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 connectionState = yield* SubscriptionRef4.make(ConnectionState.Disconnected());
+    const resolvedReconnect = resolveReconnect(reconnectOptions ?? {});
+    const supervised = reconnectOptions ? resolvedReconnect : null;
+    const serviceScope = yield* Effect8.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.forkDetach(Effect5.ignore(Effect5.tryPromise(() => t.close())));
-    const openTransport = Effect5.tryPromise({
+    const closeOrphan = (t) => Effect8.forkDetach(Effect8.ignore(Effect8.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, {
+        duration: connectTimeout,
+        orElse: () => Effect8.fail(new ModbusTimeoutError({ cause: new Error(message), message }))
+      });
+    };
+    const openTransport = Effect8.tryPromise({
       try: () => openMethod(TC, openOptions),
-      catch: (error) => toModbusError(error)
-    }).pipe(Effect5.tap((t) => closed ? closeOrphan(t) : Effect5.andThen(Effect5.sync(() => {
+      catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
+    }).pipe(Effect8.tap((t) => closed ? closeOrphan(t) : Effect8.andThen(Effect8.sync(() => {
       transport = t;
-    }), SubscriptionRef3.set(connectionState, ConnectionState.Connected()))));
-    const ensureOpen = Effect5.fnUntraced(function* () {
+    }), SubscriptionRef4.set(connectionState, ConnectionState.Connected()))));
+    const ensureOpen = Effect8.fnUntraced(function* () {
       if (closed)
         return yield* transportClosed();
       if (transport)
         return transport;
-      const t = yield* singleFlight(opening, openTransport);
+      const t = yield* limitConnect(singleFlight(opening, openTransport));
       if (closed)
         return yield* transportClosed();
       return t;
     });
-    yield* Effect5.addFinalizer(() => {
+    const closeTransport = Effect8.suspend(() => {
       if (closed)
-        return Effect5.void;
+        return Effect8.void;
       closed = true;
       const t = transport;
       if (!t)
-        return SubscriptionRef3.set(connectionState, ConnectionState.Disconnected());
-      return Effect5.andThen(Effect5.logDebug(`Closing ${serviceName}`), Effect5.andThen(Effect5.promise(() => t.close()), SubscriptionRef3.set(connectionState, ConnectionState.Disconnected())));
+        return SubscriptionRef4.set(connectionState, ConnectionState.Disconnected());
+      return Effect8.andThen(Effect8.logDebug(`Closing ${serviceName}`), Effect8.andThen(Effect8.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));
     const notConnectedMsg = "Transport is not connected. Call withClient() first.";
-    const reconnectOnce = Effect5.suspend(() => {
+    const reconnectTransport = (t) => limitConnect(singleFlight(reconnecting, Effect8.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(() => {
       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)));
+      return reconnectTransport(t);
     });
     const report = (error) => {
-      if (!supervised || closed || !supervised.triggers(error))
-        return Effect5.void;
-      return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope, Effect5.logDebug(`${serviceName}: reconnecting after ${error.message}`));
+      if (closed || !resolvedReconnect.triggers(error))
+        return Effect8.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}`));
     };
     const resilience = {
-      guard: supervised ? guardCircuit(connectionState) : Effect5.void,
+      guard: supervised ? guardCircuit(connectionState) : Effect8.void,
+      onSuccess: supervised ? undefined : SubscriptionRef4.update(connectionState, (current) => ConnectionState.$is("Down")(current) ? ConnectionState.Connected() : current),
       report
     };
+    const makeOperations = Effect8.fnUntraced(function* (unitId) {
+      const t = yield* ensureOpen();
+      let client = clientSet.get(unitId);
+      if (!client) {
+        client = yield* Effect8.try({
+          try: () => t.createClient({ unitId }),
+          catch: (cause) => toModbusError(cause instanceof Error ? cause : new Error(String(cause)))
+        });
+        clientSet.set(unitId, client);
+      }
+      return createEffectModbusClient(client);
+    });
+    const makeClient = Effect8.fnUntraced(function* (unitId, clientOptions) {
+      const operations = yield* makeOperations(unitId);
+      return withResilience(operations, {
+        ...resilience,
+        policy: clientOptions?.retry ?? transportRetry
+      });
+    });
+    const batching = createBatchingRegistry({
+      withClient: makeClient,
+      connectionState,
+      scope: serviceScope
+    });
+    const withClient = Effect8.fnUntraced(function* (unitId, clientOptions) {
+      const operations = yield* makeOperations(unitId);
+      return withResilience(batching.guardRawWrites(unitId, operations), {
+        ...resilience,
+        policy: clientOptions?.retry ?? transportRetry
+      });
+    });
     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) {
+      withClient,
+      setRequestTimeout: Effect8.fnUntraced(function* (timeoutMs) {
         const t = transport;
         if (!t || closed) {
           return yield* new ModbusNotConnectedError({
@@ -604,7 +1418,7 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
         }
         t.setRequestTimeout(timeoutMs);
       }),
-      clearRequestTimeout: Effect5.fnUntraced(function* () {
+      clearRequestTimeout: Effect8.fnUntraced(function* () {
         const t = transport;
         if (!t || closed) {
           return yield* new ModbusNotConnectedError({
@@ -614,7 +1428,7 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
         }
         t.clearRequestTimeout();
       }),
-      reconnect: Effect5.fnUntraced(function* () {
+      reconnect: Effect8.fnUntraced(function* () {
         if (closed)
           return yield* transportClosed();
         const t = transport;
@@ -622,29 +1436,22 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
           yield* ensureOpen();
           return;
         }
-        yield* singleFlight(reconnecting, Effect5.tryPromise({
-          try: () => t.reconnect(),
-          catch: (error) => toModbusError(error)
-        }).pipe(Effect5.tap(() => closed ? closeOrphan(t) : Effect5.void)));
+        yield* reconnectTransport(t);
         if (closed)
           return yield* transportClosed();
-        yield* SubscriptionRef3.set(connectionState, ConnectionState.Connected());
+        yield* SubscriptionRef4.set(connectionState, ConnectionState.Connected());
       }),
-      close: Effect5.fnUntraced(function* () {
+      close: Effect8.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);
+        const scope = yield* Effect8.scope;
+        yield* Scope3.close(scope, Exit4.void).pipe(Effect8.onExit(() => closeTransport));
       }),
+      withBatchingClient: batching.withBatchingClient,
+      batchingClient: batching.batchingClient,
+      get touchedUnits() {
+        return new Set(clientSet.keys());
+      },
       hasPendingRequests: () => {
         if (closed)
           return false;
@@ -659,10 +1466,12 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
 
 // src/AsciiTransportService.ts
 class AsciiTransportService extends Context.Service()("AsciiTransportService") {
-  static makeScoped = makeTransportScoped("AsyncAsciiTransport", (TC, options) => TC.open(options), "AsciiTransportService");
+  static makeScoped = createTransportScoped("AsyncAsciiTransport", (transportConstructor, options) => {
+    return transportConstructor.open(options);
+  }, "AsciiTransportService");
   static make = (options) => Layer.effect(AsciiTransportService, AsciiTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer.effect(AsciiTransportService, factory(options));
   };
 }
@@ -672,10 +1481,12 @@ import { Context as Context3, Layer as Layer3 } from "effect";
 // src/RtuTransportService.ts
 import { Context as Context2, Layer as Layer2 } from "effect";
 class RtuTransportService extends Context2.Service()("RtuTransportService") {
-  static makeScoped = makeTransportScoped("AsyncRtuTransport", (TC, options) => TC.open(options), "RtuTransportService");
+  static makeScoped = createTransportScoped("AsyncRtuTransport", (transportConstructor, options) => {
+    return transportConstructor.open(options);
+  }, "RtuTransportService");
   static make = (options) => Layer2.effect(RtuTransportService, RtuTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer2.effect(RtuTransportService, factory(options));
   };
 }
@@ -689,17 +1500,19 @@ class SerialTransportService extends Context3.Service()("SerialTransportService"
     return Layer3.flatMap(RtuTransportService.make(options), (context) => Layer3.succeed(SerialTransportService, Context3.get(context, RtuTransportService)));
   }
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer3.effect(SerialTransportService, factory(options));
   };
 }
 // src/TcpTransportService.ts
 import { Context as Context4, Layer as Layer4 } from "effect";
 class TcpTransportService extends Context4.Service()("TcpTransportService") {
-  static makeScoped = makeTransportScoped("AsyncTcpTransport", (TC, options) => TC.connect(options), "TcpTransportService");
+  static makeScoped = createTransportScoped("AsyncTcpTransport", (transportConstructor, options) => {
+    return transportConstructor.connect(options);
+  }, "TcpTransportService");
   static make = (options) => Layer4.effect(TcpTransportService, TcpTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer4.effect(TcpTransportService, factory(options));
   };
 }
@@ -709,24 +1522,24 @@ var serialRtuServerLayer = (options, handlers) => Layer5.effectDiscard(Effect9.g
   const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
   const server = yield* Effect9.tryPromise({
     try: () => AsyncSerialModbusServer.bindRtu(options, handlers),
-    catch: (error) => toModbusError(error)
+    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({
     try: () => server.shutdown(),
-    catch: (error) => toModbusError(error)
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   })), Effect9.catch(() => Effect9.void)));
 }));
 var serialAsciiServerLayer = (options, handlers) => Layer5.effectDiscard(Effect9.gen(function* () {
   const { AsyncSerialModbusServer } = yield* Effect9.promise(() => import("modbus-rs"));
   const server = yield* Effect9.tryPromise({
     try: () => AsyncSerialModbusServer.bindAscii(options, handlers),
-    catch: (error) => toModbusError(error)
+    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({
     try: () => server.shutdown(),
-    catch: (error) => toModbusError(error)
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   })), Effect9.catch(() => Effect9.void)));
 }));
 // src/TcpModbusServerService.ts
@@ -735,12 +1548,12 @@ var tcpServerLayer = (options, handlers) => Layer6.effectDiscard(Effect10.gen(fu
   const { AsyncTcpModbusServer } = yield* Effect10.promise(() => import("modbus-rs"));
   const server = yield* Effect10.tryPromise({
     try: () => AsyncTcpModbusServer.bind(options, handlers),
-    catch: (error) => toModbusError(error)
+    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({
     try: () => server.shutdown(),
-    catch: (error) => toModbusError(error)
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   })), Effect10.catch(() => Effect10.void)));
 }));
 // src/TcpGatewayService.ts
@@ -749,41 +1562,47 @@ var tcpGatewayLayer = (options, gatewayConfig) => Layer7.effectDiscard(Effect11.
   const { AsyncTcpGateway } = yield* Effect11.promise(() => import("modbus-rs"));
   const gateway = yield* Effect11.tryPromise({
     try: () => AsyncTcpGateway.bind(options, gatewayConfig),
-    catch: (error) => toModbusError(error)
+    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({
     try: () => gateway.shutdown(),
-    catch: (error) => toModbusError(error)
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   })), Effect11.catch(() => Effect11.void)));
 }));
 // src/WasmWsTransportService.ts
 import { Context as Context5, Layer as Layer8 } from "effect";
 class WasmWsTransportService extends Context5.Service()("WasmWsTransportService") {
-  static makeScoped = makeTransportScoped("WasmWsTransport", (TC, options) => TC.connect(options), "WasmWsTransportService", { moduleSpecifier: "modbus-rs/web" });
+  static makeScoped = createTransportScoped("WasmWsTransport", (transportConstructor, options) => {
+    return transportConstructor.connect(options);
+  }, "WasmWsTransportService", { moduleSpecifier: "modbus-rs/web" });
   static make = (options) => Layer8.effect(WasmWsTransportService, WasmWsTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer8.effect(WasmWsTransportService, factory(options));
   };
 }
 // src/WasmRtuTransportService.ts
 import { Context as Context6, Layer as Layer9 } from "effect";
 class WasmRtuTransportService extends Context6.Service()("WasmRtuTransportService") {
-  static makeScoped = makeTransportScoped("WasmRtuTransport", (TC, { port, ...rest }) => TC.open(port, rest), "WasmRtuTransportService", { moduleSpecifier: "modbus-rs/web" });
+  static makeScoped = createTransportScoped("WasmRtuTransport", (transportConstructor, { port, ...rest }) => {
+    return transportConstructor.open(port, rest);
+  }, "WasmRtuTransportService", { moduleSpecifier: "modbus-rs/web" });
   static make = (options) => Layer9.effect(WasmRtuTransportService, WasmRtuTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer9.effect(WasmRtuTransportService, factory(options));
   };
 }
 // src/WasmAsciiTransportService.ts
 import { Context as Context7, Layer as Layer10 } from "effect";
 class WasmAsciiTransportService extends Context7.Service()("WasmAsciiTransportService") {
-  static makeScoped = makeTransportScoped("WasmAsciiTransport", (TC, { port, ...rest }) => TC.open(port, rest), "WasmAsciiTransportService", { moduleSpecifier: "modbus-rs/web" });
+  static makeScoped = createTransportScoped("WasmAsciiTransport", (transportConstructor, { port, ...rest }) => {
+    return transportConstructor.open(port, rest);
+  }, "WasmAsciiTransportService", { moduleSpecifier: "modbus-rs/web" });
   static make = (options) => Layer10.effect(WasmAsciiTransportService, WasmAsciiTransportService.makeScoped(options));
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer10.effect(WasmAsciiTransportService, factory(options));
   };
 }
@@ -797,74 +1616,76 @@ class WasmSerialTransportService extends Context8.Service()("WasmSerialTransport
     return Layer11.flatMap(WasmRtuTransportService.make(options), (context) => Layer11.succeed(WasmSerialTransportService, Context8.get(context, WasmRtuTransportService)));
   }
   static makeMockTransport = (devices) => {
-    const factory = makeMockTransport(devices);
+    const factory = createMockTransport(devices);
     return (options) => Layer11.effect(WasmSerialTransportService, factory(options));
   };
 }
 // src/WasmSerialPort.ts
-import { Effect as Effect15 } from "effect";
-var requestSerialPort = () => Effect15.tryPromise({
+import { Effect as Effect12 } from "effect";
+var requestSerialPort = () => Effect12.tryPromise({
   try: async () => {
     const mod = await import("modbus-rs/web");
     return mod.requestSerialPort();
   },
-  catch: (error) => toModbusError(error)
+  catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
 });
 // src/WasmTcpServerService.ts
-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({
+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({
     try: () => WasmWsModbusServer.bind(options, handlers),
-    catch: (error) => toModbusError(error)
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  yield* Effect16.logDebug(`WASM WS server bound to ${options.wsUrl}`);
-  yield* Effect16.forkScoped(Effect16.tryPromise({
+  yield* Effect13.logDebug(`WASM WS server bound to ${options.wsUrl}`);
+  yield* Effect13.forkScoped(Effect13.tryPromise({
     try: () => server.serve(),
-    catch: (error) => toModbusError(error)
-  }).pipe(Effect16.catch((error) => Effect16.logError("WASM WS server loop ended", error))));
-  yield* Effect16.addFinalizer(() => Effect16.logDebug("WASM WS server shutting down").pipe(Effect16.andThen(Effect16.tryPromise({
+    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({
     try: () => server.shutdown(),
-    catch: (error) => toModbusError(error)
-  })), Effect16.catch(() => Effect16.void)));
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
+  })), Effect13.catch(() => Effect13.void)));
 }));
 // src/WasmSerialModbusServerService.ts
-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({
+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({
     try: () => WasmSerialModbusServer.bindRtu(options, handlers),
-    catch: (error) => toModbusError(error)
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  yield* Effect17.logDebug("WASM serial RTU server bound");
-  yield* Effect17.forkScoped(Effect17.tryPromise({
+  yield* Effect14.logDebug("WASM serial RTU server bound");
+  yield* Effect14.forkScoped(Effect14.tryPromise({
     try: () => server.serve(),
-    catch: (error) => toModbusError(error)
-  }).pipe(Effect17.catch((error) => Effect17.logError("WASM serial RTU server loop ended", error))));
-  yield* Effect17.addFinalizer(() => Effect17.logDebug("WASM serial RTU server shutting down").pipe(Effect17.andThen(Effect17.tryPromise({
+    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({
     try: () => server.shutdown(),
-    catch: (error) => toModbusError(error)
-  })), Effect17.catch(() => Effect17.void)));
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
+  })), Effect14.catch(() => Effect14.void)));
 }));
-var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.effectDiscard(Effect17.gen(function* () {
-  const { WasmSerialModbusServer } = yield* Effect17.promise(() => import("modbus-rs/web"));
-  const server = yield* Effect17.tryPromise({
+var wasmSerialAsciiServerLayer = (options, handlers) => Layer13.effectDiscard(Effect14.gen(function* () {
+  const { WasmSerialModbusServer } = yield* Effect14.promise(() => import("modbus-rs/web"));
+  const server = yield* Effect14.tryPromise({
     try: () => WasmSerialModbusServer.bindAscii(options, handlers),
-    catch: (error) => toModbusError(error)
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
   });
-  yield* Effect17.logDebug("WASM serial ASCII server bound");
-  yield* Effect17.forkScoped(Effect17.tryPromise({
+  yield* Effect14.logDebug("WASM serial ASCII server bound");
+  yield* Effect14.forkScoped(Effect14.tryPromise({
     try: () => server.serve(),
-    catch: (error) => toModbusError(error)
-  }).pipe(Effect17.catch((error) => Effect17.logError("WASM serial ASCII server loop ended", error))));
-  yield* Effect17.addFinalizer(() => Effect17.logDebug("WASM serial ASCII server shutting down").pipe(Effect17.andThen(Effect17.tryPromise({
+    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({
     try: () => server.shutdown(),
-    catch: (error) => toModbusError(error)
-  })), Effect17.catch(() => Effect17.void)));
+    catch: (error) => toModbusError(error instanceof Error ? error : new Error(String(error)))
+  })), Effect14.catch(() => Effect14.void)));
 }));
 export {
   AsciiTransportService,
   ConnectionState,
+  MODBUS_MAX_READ_REGISTERS,
+  MODBUS_MAX_WRITE_REGISTERS,
   ModbusCircuitOpenError,
   ModbusConnectionClosedError,
   ModbusExceptionError,
@@ -881,7 +1702,16 @@ export {
   WasmRtuTransportService,
   WasmSerialTransportService,
   WasmWsTransportService,
-  makeRetryPolicy,
+  createBatchingRegistry,
+  createReadDebouncer,
+  createRegisterCache,
+  createRetryPolicy,
+  createWriteDebouncer,
+  encodeRegisterValue,
+  makeBatchingClient,
+  mergeSpanAttributes,
+  planReads,
+  planWrites,
   requestSerialPort,
   retryModbus,
   retryableExceptionCodes,