@rotorsoft/act 1.30.0 → 1.31.1

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-H2IDTW6B.js";
+} from "./chunk-YUJ7ACSP.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -1607,11 +1607,46 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
 }
 
 // src/internal/correlate-cycle.ts
+import { createHash, randomUUID } from "crypto";
 var DEFAULT_COLD_START_BACK_SCAN = 1e4;
+var DEFAULT_CORRELATION_LEASE_MS = 5e3;
+var registry_key = (events) => {
+  const shape = Object.keys(events).filter((name) => events[name].reactions.size > 0).sort().map((name) => [name, [...events[name].reactions.keys()].sort()]);
+  return createHash("sha256").update(JSON.stringify(shape)).digest("hex").slice(0, 32);
+};
 var PATTERN_CACHE_SIZE = 32;
 var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
+  /**
+   * This worker's identity for the correlation lease (#1532). A per-instance
+   * UUID, matching the drain's convention, so a renewal is recognised as the
+   * same holder and a restarted process never inherits a stale claim.
+   */
+  _by = randomUUID();
+  /** How long the correlation lease is taken for. */
+  _lease_millis;
+  /**
+   * Which correlator this is. Computed once from the registry so identical
+   * workers share a lease and unrelated applications never do.
+   */
+  _key;
+  /**
+   * When this worker's correlation lease runs out, as a local clock reading,
+   * or 0 when it holds none.
+   *
+   * Asking the store on every pass costs a round trip that the holder — which
+   * is the *only* worker in a single-node deployment, and the steady-state
+   * one everywhere else — gains nothing from: it already knows the answer.
+   * The act-sqlite perf gate caught that as a 1.5x regression on
+   * correlate+drain, which is the shape an embedded app runs constantly.
+   *
+   * Believing this while the store disagrees is safe in the one direction it
+   * can fail. A worker that scans without really holding the lease produces
+   * the duplicate scan that existed before the lease, and the marks are
+   * idempotent — so a stale belief costs work, never correctness.
+   */
+  _lease_until = 0;
   /**
    * Whether a scan might find anything. The drain has carried the same flag
    * since it was written — a commit raises it, an empty claim lowers it, and
@@ -1671,8 +1706,11 @@ var CorrelateCycle = class {
     run_scoped,
     on_init,
     on_init_async,
-    cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN
+    cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN,
+    lease_millis = DEFAULT_CORRELATION_LEASE_MS
   }) {
+    this._lease_millis = lease_millis;
+    this._key = registry_key(registry.events);
     this._subscribed = new LruMap(max_subscribed_streams);
     this._registry = registry;
     this._static_targets = static_targets;
@@ -1777,7 +1815,7 @@ var CorrelateCycle = class {
    * at init, but marking it is what makes it claimable without probing the
    * event log, so the scan runs for every app.
    */
-  async correlate(query = { after: -1, limit: 10 }) {
+  async correlate(query = { after: -1, limit: 10 }, lease = false) {
     await this.init();
     if (!this._armed)
       return {
@@ -1786,6 +1824,22 @@ var CorrelateCycle = class {
         marked: 0,
         scanned: false
       };
+    const now = Date.now();
+    if (lease && now >= this._lease_until - this._lease_millis / 2) {
+      const { correlating } = await this._cd.subscribe([], void 0, {
+        key: this._key,
+        by: this._by,
+        millis: this._lease_millis
+      });
+      this._lease_until = correlating ? now + this._lease_millis : 0;
+      if (correlating === false)
+        return {
+          subscribed: 0,
+          last_id: this._checkpoint,
+          marked: 0,
+          scanned: false
+        };
+    }
     const after = Math.max(this._checkpoint, query.after || -1);
     const correlated = /* @__PURE__ */ new Map();
     let last_id = after;
@@ -1833,7 +1887,14 @@ var CorrelateCycle = class {
         });
     }
     if (streams.length) {
-      const { subscribed } = await this._cd.subscribe(streams, last_id);
+      const renewed_at = Date.now();
+      const { subscribed, correlating } = await this._cd.subscribe(
+        streams,
+        last_id,
+        lease ? { key: this._key, by: this._by, millis: this._lease_millis } : void 0
+      );
+      if (lease && correlating !== false)
+        this._lease_until = renewed_at + this._lease_millis;
       const marked = streams.filter(
         (entry) => entry.correlated_at !== void 0
       ).length;
@@ -1863,11 +1924,14 @@ var CorrelateCycle = class {
     this._timer = setInterval(
       () => this._run_scoped(() => {
         this.arm();
-        return this.correlate({
-          ...query,
-          after: this._checkpoint,
-          limit
-        });
+        return this.correlate(
+          {
+            ...query,
+            after: this._checkpoint,
+            limit
+          },
+          true
+        );
       }).then((result) => {
         if (callback && result.subscribed) callback(result.subscribed);
       }).catch((err) => log().error(err)),
@@ -1876,6 +1940,34 @@ var CorrelateCycle = class {
     return true;
   }
   /** Stop the periodic correlation worker. Idempotent. */
+  /**
+   * Hand the correlation lease back early.
+   *
+   * There is no release verb on the port, deliberately — expiry is the only
+   * path, which keeps a crash and a clean stop on the same code path. A
+   * holder can still shorten its own lease, because re-acquiring as the same
+   * holder renews, and renewing to a millisecond is a release in all but
+   * name.
+   *
+   * Without this a worker that stops cleanly still blocks discovery for the
+   * rest of its lease — invisible in a long-lived deployment, very visible
+   * anywhere Acts are created and dropped inside one process.
+   *
+   * Best-effort: failing here costs the lease's remaining lifetime, which is
+   * what would have happened had the process died instead.
+   */
+  async release_correlation() {
+    try {
+      this._lease_until = 0;
+      await this._cd.subscribe([], void 0, {
+        key: this._key,
+        by: this._by,
+        millis: 0
+      });
+    } catch (error) {
+      log().error(error);
+    }
+  }
   stop_polling() {
     if (this._timer) {
       clearInterval(this._timer);
@@ -1909,7 +2001,7 @@ function close_correlation(correlator, actor) {
 }
 
 // src/internal/drain-cycle.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/internal/defer-timer.ts
 var MAX_TIMER_DELAY_MS = 2147483647;
@@ -2031,7 +2123,7 @@ async function fetch(leased, eventLimit) {
 }
 var ack = (leases) => store().ack(leases);
 var block = (leases) => store().block(leases);
-var subscribe = (streams, correlated_at) => store().subscribe(streams, correlated_at);
+var subscribe = (streams, correlated_at, correlator) => store().subscribe(streams, correlated_at, correlator);
 
 // src/internal/event-sourcing.ts
 import { patch } from "@rotorsoft/act-patch";
@@ -2061,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) => {
@@ -2318,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];
@@ -2385,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) {
@@ -2639,7 +2739,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
   const leased = await ops.claim(
     lagging,
     leading,
-    randomUUID(),
+    randomUUID2(),
     leaseMillis,
     lane
   );
@@ -3015,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++;
@@ -3655,7 +3754,7 @@ var Act = class {
         // the scoped store and `_initialized` then blocks a retry (#1191).
         init: () => this._scoped(() => this._correlate.init()),
         checkpoint: () => this._correlate.checkpoint,
-        correlate: (q) => this._correlate_scanned(q),
+        correlate: (q) => this._correlate_scanned(q, true),
         drain: (o) => this.drain(o),
         on_settled: (drain) => this.emit("settled", drain),
         breaker: this._breaker
@@ -3698,6 +3797,7 @@ var Act = class {
       resolveShutdownConfig(options);
       this._shutdown_promise = (async () => {
         this.stop_correlations();
+        await this._scoped(() => this._correlate.release_correlation());
         this.stop_settling();
         this._breaker.stop();
         for (const c of this._drain_controllers.values()) c.stop();
@@ -4177,10 +4277,10 @@ var Act = class {
    * internal rather than widening the public `correlate` return, which is
    * charter-covered and has no use for it.
    */
-  async _correlate_scanned(query) {
+  async _correlate_scanned(query, lease = false) {
     if (!this._drain) return { subscribed: 0, last_id: -1, scanned: false };
     return this._scoped(async () => {
-      const { subscribed, last_id, marked, scanned } = await this._correlate.correlate(query);
+      const { subscribed, last_id, marked, scanned } = await this._correlate.correlate(query, lease);
       if ((subscribed > 0 || marked > 0) && this._reactive_events.size > 0)
         this._arm_all();
       return { subscribed, last_id, scanned };
@@ -4263,6 +4363,7 @@ var Act = class {
    */
   stop_correlations() {
     this._correlate.stop_polling();
+    void this._scoped(() => this._correlate.release_correlation());
   }
   /**
    * Cancels any pending or active settle cycle.