@rotorsoft/act 1.31.0 → 1.31.2

package/dist/index.js

@@ -2153,6 +2153,10 @@ function compute_backoff_delay(retry, opts) {
   return Math.max(0, Math.floor(delay));
 }
 
+// src/internal/reacting.ts
+import { AsyncLocalStorage } from "async_hooks";
+var reacting = new AsyncLocalStorage();
+
 // src/internal/event-sourcing.ts
 var bare_patch = (_me, state2, partial) => patch(state2, partial);
 var validating_patch = (me, state2, partial, event) => {
@@ -2410,7 +2414,7 @@ async function load(me, target, callback, patch_fn = bare_patch) {
 async function action(me, action2, target, payload, options, patch_fn = bare_patch) {
   const { stream, expectedVersion, actor } = target;
   if (!stream) throw new Error("Missing target stream");
-  const reactingTo = options?.reactingTo;
+  const reactingTo = options?.reactingTo ?? reacting.getStore();
   const correlator = options?.correlator ?? default_correlator;
   const validated = validate(action2, payload, me.actions[action2]);
   const opts = me.options?.[action2];
@@ -2477,11 +2481,15 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
           stream,
           emitted,
           meta,
-          // Reactions skip optimistic concurrency: they always append against the
+          // Reactions skip the INFERRED guard: they always append against the
           // current head. Stream leasing already serializes concurrent reactions,
           // and forcing version checks here would turn ordinary catch-up into
-          // spurious retries.
-          reactingTo ? void 0 : expected
+          // spurious retries. An expectedVersion the caller passed explicitly is
+          // still honored — dropping a guard the caller asked for is silent data
+          // loss, and the reaction context can reach further than the handler
+          // (detached timers, settle cycles) where the caller never intended a
+          // reaction's semantics at all.
+          reactingTo ? expectedVersion : expected
         );
       } catch (error) {
         if (error instanceof ConcurrencyError) {
@@ -3107,12 +3115,11 @@ function build_handle(deps) {
     for (let i = 0; i < payloads.length; i++) {
       const payload = payloads[i];
       const { event, handler } = payload;
-      scoped_app.do = (action2, target, action_payload, options) => bound_do(action2, target, action_payload, {
-        ...options,
-        reactingTo: options?.reactingTo ?? event
-      });
       try {
-        await handler(event, stream, scoped_app);
+        await reacting.run(
+          event,
+          () => handler(event, stream, scoped_app)
+        );
         if (last_index_of.get(event.id) === i) {
           at = event.id;
           handled++;
@@ -3583,15 +3590,15 @@ var Act = class {
    * One DrainController per active lane. The implicit "default" lane is
    * always present unless onlyLanes excludes it. Each controller filters
    * its claim() by its lane name; the legacy single-controller path is the
-   * active set === { "default" } case with `lane: undefined` deps so
-   * claim() doesn't filter (preserves the single-lane SQL planner shape
-   * for apps that never call withLane).
+   * no-lane-declared case with `lane: undefined` deps so claim() doesn't
+   * filter (preserves the single-lane SQL planner shape for apps that never
+   * call withLane).
    */
   _build_drain_controllers(options, lanes) {
     const all_lanes = ["default", ...lanes.map((l) => l.name)];
     const only_set = options.onlyLanes && options.onlyLanes.length > 0 ? new Set(options.onlyLanes) : void 0;
     const active_lanes = only_set ? all_lanes.filter((n) => only_set.has(n)) : all_lanes;
-    const single_default_lane = active_lanes.length === 1 && active_lanes[0] === "default";
+    const single_default_lane = lanes.length === 0;
     const controllers = /* @__PURE__ */ new Map();
     for (const name of active_lanes) {
       const cfg = lanes.find((l) => l.name === name);