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

package/dist/index.js

@@ -198,6 +198,14 @@ var superviseReconnect = (reconnect, state, resolved) => Effect2.gen(function* (
       return;
   }
 });
+var claimReconnect = (reconnect, state, resolved, scope, onClaim) => Effect2.gen(function* () {
+  const claimed = yield* SubscriptionRef.modify(state, (current) => ConnectionState.$is("Connected")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
+  if (!claimed)
+    return;
+  if (onClaim)
+    yield* onClaim;
+  yield* Effect2.forkIn(superviseReconnect(reconnect, state, resolved), scope);
+});
 // src/AsciiTransportService.ts
 import { Context, Layer } from "effect";
 
@@ -461,12 +469,7 @@ var makeMockTransport = (devices) => {
     const report = (error) => {
       if (!supervised || !supervised.triggers(error))
         return Effect4.void;
-      return Effect4.gen(function* () {
-        const claimed = yield* SubscriptionRef2.modify(connectionState, (current) => ConnectionState.$is("Connected")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
-        if (!claimed)
-          return;
-        yield* Effect4.forkIn(superviseReconnect(reconnectOnce, connectionState, supervised), serviceScope);
-      });
+      return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope);
     };
     const guard = Effect4.andThen(supervised ? guardCircuit(connectionState) : Effect4.void, Effect4.suspend(() => {
       const injected = options.fault?.();
@@ -568,13 +571,7 @@ function makeTransportScoped(transportKey, openMethod, serviceName, config) {
     const report = (error) => {
       if (!supervised || closed || !supervised.triggers(error))
         return Effect5.void;
-      return Effect5.gen(function* () {
-        const claimed = yield* SubscriptionRef3.modify(connectionState, (current) => ConnectionState.$is("Connected")(current) ? [true, ConnectionState.Reconnecting({ attempt: 0 })] : [false, current]);
-        if (!claimed)
-          return;
-        yield* Effect5.logDebug(`${serviceName}: reconnecting after ${error.message}`);
-        yield* Effect5.forkIn(superviseReconnect(reconnectOnce, connectionState, supervised), serviceScope);
-      });
+      return claimReconnect(reconnectOnce, connectionState, supervised, serviceScope, Effect5.logDebug(`${serviceName}: reconnecting after ${error.message}`));
     };
     const resilience = {
       guard: supervised ? guardCircuit(connectionState) : Effect5.void,

package/dist/src/connection.d.ts

@@ -1,4 +1,4 @@
-import { Data, Duration, Effect, SubscriptionRef } from 'effect';
+import { Data, Duration, Effect, type Scope, SubscriptionRef } from 'effect';
 import { ModbusCircuitOpenError, type ModbusError } from './errors';
 import { type ModbusErrorTag, type ModbusRetryPolicy } from './retry';
 /**
@@ -168,3 +168,27 @@ export declare const guardCircuit: (state: SubscriptionRef.SubscriptionRef<Conne
  * @returns An Effect that runs until the link is restored.
  */
 export declare const superviseReconnect: (reconnect: Effect.Effect<void, ModbusError>, state: SubscriptionRef.SubscriptionRef<ConnectionState>, resolved: ResolvedReconnect) => Effect.Effect<void>;
+/**
+ * Claims the `Connected` → `Reconnecting` transition and starts the supervisor.
+ *
+ * The transition is claimed atomically, so of the fibers that fail together
+ * exactly one starts the supervisor and the rest simply carry on failing — one
+ * reconnect for the whole transport, not one per call site. Fibers that lose
+ * the claim do nothing at all; `onClaim` runs in the winner only, after the
+ * transition is published and before the supervisor is forked.
+ *
+ * Callers decide *whether* a failure is worth reporting (the supervisor's
+ * `triggers` predicate, plus whatever local state means "no longer eligible");
+ * this owns *how* the transition is made, so the claim protocol has one
+ * implementation.
+ *
+ * @param reconnect - The transport's own reconnect operation.
+ * @param state - The state cell the transition is claimed on.
+ * @param resolved - Reconnect configuration with defaults applied.
+ * @param scope - Scope the supervisor fiber is forked into; it is interrupted
+ *   when the scope closes.
+ * @param onClaim - Optional effect run by the claiming fiber only.
+ * @returns An Effect that completes once the supervisor is forked, or
+ *   immediately when another fiber already holds the claim.
+ */
+export declare const claimReconnect: (reconnect: Effect.Effect<void, ModbusError>, state: SubscriptionRef.SubscriptionRef<ConnectionState>, resolved: ResolvedReconnect, scope: Scope.Scope, onClaim?: Effect.Effect<void>) => Effect.Effect<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flux-control/effect-modbus-rs",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Type-safe Modbus communication via Effect-TS, wrapping the modbus-rs npm bindings.",
   "license": "GPL-3.0",
   "repository": {
@@ -30,6 +30,7 @@
     "format:fix": "oxfmt",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
+    "lock": "bash tools/refresh-lockfile.sh",
     "prepare": "husky",
     "release": "changeset publish",
     "test": "bun test ./src/ ./examples/",