@rotorsoft/act 1.29.0 → 1.29.2

package/dist/index.js

@@ -1382,9 +1382,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();
@@ -1417,7 +1419,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) => {
@@ -1435,11 +1437,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);
           }
         }
       },
@@ -1609,6 +1612,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;
@@ -1672,6 +1686,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,
@@ -1757,6 +1779,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;
@@ -1817,10 +1846,11 @@ var CorrelateCycle = class {
             lane
           });
       }
-      return { subscribed, last_id, marked };
+      return { subscribed, last_id, marked, scanned: true };
     }
     this._checkpoint = last_id;
-    return { subscribed: 0, last_id, marked: 0 };
+    this._armed = false;
+    return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
   /**
    * Start a periodic correlation worker. Returns false if one is already
@@ -1831,9 +1861,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
@@ -3119,11 +3154,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],
@@ -3620,7 +3655,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
@@ -4033,6 +4068,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();
   }
   /**
@@ -4056,6 +4092,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;
   }
@@ -4129,12 +4166,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 { subscribed, last_id, marked } = await this._correlate.correlate(query);
+      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 { subscribed, last_id };
+      return { subscribed, last_id, scanned };
     });
   }
   /**
@@ -4567,6 +4616,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;
     }