@rotorsoft/act 1.29.2 → 1.31.0

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-PX3IBVLW.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";
@@ -2639,7 +2731,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
   const leased = await ops.claim(
     lagging,
     leading,
-    randomUUID(),
+    randomUUID2(),
     leaseMillis,
     lane
   );
@@ -3655,7 +3747,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 +3790,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 +4270,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 +4356,7 @@ var Act = class {
    */
   stop_correlations() {
     this._correlate.stop_polling();
+    void this._scoped(() => this._correlate.release_correlation());
   }
   /**
    * Cancels any pending or active settle cycle.
@@ -4622,6 +4716,22 @@ var Act = class {
     }
     return this._correlate.checkpoint;
   }
+  /**
+   * Drop retired streams from correlate's in-process "already subscribed"
+   * set, so a later scan re-issues `subscribe()` for them.
+   *
+   * A tombstone seed means the stream was retired; a snapshot seed means it
+   * was restarted and is still consuming.
+   *
+   * `truncate` no longer removes the subscription row (#1527), so this is no
+   * longer repairing damage the close itself did. It still matters, because
+   * the row can disappear later: reclaiming retired subscriptions is an
+   * operator job now, and that `DELETE` can land while this process is
+   * running. Forgetting here keeps the in-process view from outliving a row
+   * an operator removed, which is the same silent-no-delivery failure #1398
+   * described — a reaction whose target is named after the stream would never
+   * be re-registered.
+   */
   _forget_closed_subscriptions(result) {
     const retired = [...result.truncated.entries()].filter(([, r]) => r.committed.name === TOMBSTONE_EVENT).map(([stream]) => stream);
     if (retired.length) this._correlate.forget_subscribed(retired);