@rotorsoft/act 1.28.1 → 1.29.1

package/dist/index.cjs

@@ -1028,19 +1028,7 @@ var InMemoryStore = class {
    */
   async claim(lagging, leading, by, millis, lane) {
     await sleep();
-    const has_work = (s) => {
-      if (s.correlated_at !== void 0) return s.at < s.correlated_at;
-      if (!s.source) return s.at < this._max_non_snap_event_id;
-      if (is_literal_source(s.source)) {
-        const max_id = this._max_event_id_by_stream.get(s.source);
-        return max_id !== void 0 && max_id > s.at;
-      }
-      const re = new RegExp(s.source);
-      for (const [stream_name, max_id] of this._max_event_id_by_stream) {
-        if (max_id > s.at && re.test(stream_name)) return true;
-      }
-      return false;
-    };
+    const has_work = (s) => s.correlated_at !== void 0 && s.at < s.correlated_at;
     const available = [...this._streams.values()].filter(
       (s) => s.is_available && has_work(s) && (lane === void 0 || s.lane === lane)
     );
@@ -2972,9 +2960,11 @@ async function run_close_cycle(targets, deps) {
   return { truncated, skipped };
 }
 async function run_windowed_closes(windowed, deps, skipped) {
+  const checkpoint = deps.reactive_events_size > 0 ? await deps.catch_up_correlation(Number.MAX_SAFE_INTEGER) : -1;
   const min_at = deps.reactive_events_size > 0 ? await probe_min_watermarks(
     windowed.map((t) => t.stream),
-    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
+    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE,
+    checkpoint
   ) : /* @__PURE__ */ new Map();
   const with_lock = deps.with_stream_lock ?? ((_stream, work) => work());
   const truncated = /* @__PURE__ */ new Map();
@@ -3007,7 +2997,7 @@ async function windowed_prune_pending(stream, before, max_id) {
   );
   return boundary_id !== void 0 && min_id < boundary_id;
 }
-async function probe_min_watermarks(streams, page_size) {
+async function probe_min_watermarks(streams, page_size, checkpoint) {
   const min_at = /* @__PURE__ */ new Map();
   const source_regex = /* @__PURE__ */ new Map();
   const get_regex = (source) => {
@@ -3025,11 +3015,12 @@ async function probe_min_watermarks(streams, page_size) {
       (position) => {
         last = position.stream;
         const source_re = position.source ? get_regex(position.source) : void 0;
+        const pending = position.correlated_at === void 0 || position.at < position.correlated_at;
+        const cap = pending ? position.at : Math.max(position.at, checkpoint);
         for (const stream of streams) {
           if (!source_re || source_re.test(stream)) {
             const prev = min_at.get(stream);
-            if (prev === void 0 || position.at < prev)
-              min_at.set(stream, position.at);
+            if (prev === void 0 || cap < prev) min_at.set(stream, cap);
           }
         }
       },
@@ -3089,7 +3080,7 @@ async function partition_by_safety(stream_info, reactive_events_size, skipped, p
       (position) => {
         last = position.stream;
         const source_re = position.source ? get_regex(position.source) : void 0;
-        const has_work = position.correlated_at === void 0 || position.at < position.correlated_at;
+        const has_work = position.correlated_at !== void 0 && position.at < position.correlated_at;
         if (!has_work) return;
         for (const [stream, info] of stream_info) {
           if ((!source_re || source_re.test(stream)) && position.at < info.max_id) {
@@ -3199,6 +3190,17 @@ var PATTERN_CACHE_SIZE = 32;
 var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
+  /**
+   * 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
+   * a disarmed drain returns without touching the store. Correlate had no
+   * equivalent, so a settle pass always scanned, including the final pass
+   * whose only job is to confirm nothing changed (#1510).
+   *
+   * Starts armed: the log may already hold events this process has never
+   * correlated, and only a scan can find out.
+   */
+  _armed = true;
   /** In-flight init, memoized for single-flight and cleared on failure. */
   _init_promise;
   _timer = void 0;
@@ -3262,6 +3264,14 @@ var CorrelateCycle = class {
   get checkpoint() {
     return this._checkpoint;
   }
+  /**
+   * Signal that a commit (local or remote) may have produced events this
+   * process has not correlated. Cheap and idempotent — the orchestrator calls
+   * it on every commit and every notification.
+   */
+  arm() {
+    this._armed = true;
+  }
   /**
    * Initialize correlation state on first call.
    * - Reads the durable correlate checkpoint (and max(at)) from the store,
@@ -3347,6 +3357,13 @@ var CorrelateCycle = class {
    */
   async correlate(query = { after: -1, limit: 10 }) {
     await this.init();
+    if (!this._armed)
+      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;
@@ -3395,6 +3412,9 @@ var CorrelateCycle = class {
     }
     if (streams.length) {
       const { subscribed } = await this._cd.subscribe(streams, last_id);
+      const marked = streams.filter(
+        (entry) => entry.correlated_at !== void 0
+      ).length;
       this._checkpoint = last_id;
       for (const { stream, priority, lane } of streams) {
         if (correlated.get(stream)?.upgraded)
@@ -3404,10 +3424,11 @@ var CorrelateCycle = class {
             lane
           });
       }
-      return { subscribed, last_id };
+      return { subscribed, last_id, marked, scanned: true };
     }
     this._checkpoint = last_id;
-    return { subscribed: 0, last_id };
+    this._armed = false;
+    return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
   /**
    * Start a periodic correlation worker. Returns false if one is already
@@ -3418,9 +3439,14 @@ var CorrelateCycle = class {
     if (this._timer) return false;
     const limit = query.limit || 100;
     this._timer = setInterval(
-      () => this._run_scoped(
-        () => this.correlate({ ...query, after: this._checkpoint, limit })
-      ).then((result) => {
+      () => this._run_scoped(() => {
+        this.arm();
+        return this.correlate({
+          ...query,
+          after: this._checkpoint,
+          limit
+        });
+      }).then((result) => {
         if (callback && result.subscribed) callback(result.subscribed);
       }).catch((err) => log().error(err)),
       frequency
@@ -4706,11 +4732,11 @@ var SettleLoop = class {
         let settled_drain;
         for (let i = 0; i < maxPasses; i++) {
           const after_before = this._deps.checkpoint();
-          const { subscribed, last_id } = await this._deps.correlate({
+          const { subscribed, last_id, scanned } = await this._deps.correlate({
             ...correlate_query,
             after: after_before
           });
-          this._deps.breaker.passed();
+          if (scanned) this._deps.breaker.passed();
           const drain = await this._deps.drain(drain_options);
           settled_drain = settled_drain ? {
             fetched: [...settled_drain.fetched, ...drain.fetched],
@@ -5207,7 +5233,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(q),
+        correlate: (q) => this._correlate_scanned(q),
         drain: (o) => this.drain(o),
         on_settled: (drain) => this.emit("settled", drain),
         breaker: this._breaker
@@ -5620,6 +5646,7 @@ var Act = class {
   }
   /** Arm every active lane controller (ACT-1103). */
   _arm_all() {
+    this._correlate.arm();
     for (const c of this._drain_controllers.values()) c.arm();
   }
   /**
@@ -5643,6 +5670,7 @@ var Act = class {
       for (const lane of set) to_arm.add(lane);
     }
     if (to_arm.size === 0) return false;
+    this._correlate.arm();
     for (const lane of to_arm) this._drain_controllers.get(lane)?.arm();
     return true;
   }
@@ -5716,12 +5744,24 @@ var Act = class {
    * @see {@link stop_correlations} to stop automatic correlation
    */
   async correlate(query = { after: -1, limit: 10 }) {
-    if (!this._drain) return { subscribed: 0, last_id: -1 };
+    const { subscribed, last_id } = await this._correlate_scanned(query);
+    return { subscribed, last_id };
+  }
+  /**
+   * `correlate` plus whether the pass actually read the store (#1510).
+   *
+   * The settle loop needs that extra bit to decide whether the pass carries a
+   * circuit-breaker health signal, and a disarmed pass carries none. It stays
+   * internal rather than widening the public `correlate` return, which is
+   * charter-covered and has no use for it.
+   */
+  async _correlate_scanned(query) {
+    if (!this._drain) return { subscribed: 0, last_id: -1, scanned: false };
     return this._scoped(async () => {
-      const result = await this._correlate.correlate(query);
-      if (result.subscribed > 0 && this._reactive_events.size > 0)
+      const { subscribed, last_id, marked, scanned } = await this._correlate.correlate(query);
+      if ((subscribed > 0 || marked > 0) && this._reactive_events.size > 0)
         this._arm_all();
-      return result;
+      return { subscribed, last_id, scanned };
     });
   }
   /**
@@ -6154,6 +6194,7 @@ var Act = class {
   async _catch_up_correlation(until) {
     for (let pass = 0; pass < CLOSE_CATCH_UP_PASSES && this._correlate.checkpoint < until; pass++) {
       const before = this._correlate.checkpoint;
+      this._correlate.arm();
       await this.correlate({ limit: CLOSE_CATCH_UP_LIMIT });
       if (this._correlate.checkpoint <= before) break;
     }