@rotorsoft/act 1.31.0 → 1.31.1

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++;