@rotorsoft/act 1.32.27 → 1.32.28

package/dist/index.js

@@ -1132,6 +1132,10 @@ var CircuitBreaker = class {
   get failing() {
     return this._failures > 0;
   }
+  /** How long the store is left alone after a failure before a retry. */
+  get cooldown_ms() {
+    return this._cooldown_ms;
+  }
   /** Current state given the wall-clock `now`. */
   state(now) {
     if (this._opened_at === void 0) return "closed";
@@ -2682,20 +2686,24 @@ function fetch_failure_policy(registry) {
     }
   return { blockOnError, maxRetries };
 }
-function resolver_failed(lease, { error, options }) {
-  log().error(error);
-  const block2 = options.blockOnError && lease.retry >= options.maxRetries;
+function finalize(lease, handled, at, error, options, logger, failed_at) {
+  if (!error) return { lease, handled, acked_at: at };
+  logger.error(error);
+  const non_retryable = error instanceof NonRetryableError;
+  const block2 = options.blockOnError && (non_retryable || lease.retry >= options.maxRetries);
+  if (block2)
+    logger.error(
+      non_retryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
+    );
+  const next_attempt_at = block2 ? void 0 : Date.now() + compute_backoff_delay(lease.retry, options.backoff ?? DEFAULT_BACKOFF);
   return {
     lease,
-    handled: 0,
-    acked_at: lease.at,
-    error,
-    ...block2 ? { block: true } : {
-      next_attempt_at: Date.now() + compute_backoff_delay(
-        lease.retry,
-        options.backoff ?? DEFAULT_BACKOFF
-      )
-    }
+    handled,
+    acked_at: at,
+    error: error.message,
+    block: block2,
+    next_attempt_at,
+    failed_at
   };
 }
 function warn_misrouted(seen, stream, handler, event) {
@@ -2743,7 +2751,9 @@ async function run_drain_cycle(deps, cycle) {
           resolved = dynamic ? resolver(event) : resolver;
         } catch (error) {
           failed ??= {
-            error: `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}`,
+            error: new Error(
+              `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}`
+            ),
             options: reaction.options
           };
           return false;
@@ -2765,23 +2775,29 @@ async function run_drain_cycle(deps, cycle) {
     leased.map((lease) => {
       const entry = fetch_map.get(lease.stream);
       if (entry.fetch.error !== void 0) {
-        const error = `Fetch failed for ${lease.stream}: ${entry.fetch.error}`;
-        log().error(error);
         const policy = fetch_failure_policy(registry);
-        const block2 = !store_failing && policy.blockOnError && lease.retry >= policy.maxRetries;
-        const failed = {
-          lease,
-          handled: 0,
-          acked_at: lease.at,
-          error,
-          ...block2 ? { block: true } : {
-            next_attempt_at: Date.now() + compute_backoff_delay(lease.retry, DEFAULT_BACKOFF)
-          }
-        };
-        return Promise.resolve(failed);
+        return Promise.resolve(
+          finalize(
+            lease,
+            0,
+            lease.at,
+            new Error(`Fetch failed for ${lease.stream}: ${entry.fetch.error}`),
+            store_failing ? { ...policy, blockOnError: false } : policy,
+            deps.logger
+          )
+        );
       }
       if (entry.failed)
-        return Promise.resolve(resolver_failed(lease, entry.failed));
+        return Promise.resolve(
+          finalize(
+            lease,
+            0,
+            lease.at,
+            entry.failed.error,
+            entry.failed.options,
+            deps.logger
+          )
+        );
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
       const exhausted = budget_exhausted(
@@ -2820,18 +2836,23 @@ var EMPTY_DRAIN = {
   acked: [],
   blocked: []
 };
+var RETRY = "";
 var DrainController = class {
   _armed = false;
   _locked = false;
   _ratio = 0.5;
   /**
-   * Local wake at the earliest parked (backoff or defer) visit; the schedule
-   * itself is persisted. On an idle app nothing else would drain it. A due
-   * entry stays until handled or until a later pass claims nothing.
+   * Local wake at the earliest parked (backoff or defer) visit, or at the
+   * lease expiry after a failed pass (the {@link RETRY} key); the schedule
+   * itself is persisted. On an idle app nothing else would drain it. It
+   * drains until a pass leases nothing, and an entry stays until handled or
+   * until a later pass claims nothing.
    */
   _defer = new DeferTimer(() => {
     this._armed = true;
-    void this._deps.run_scoped(() => this.drain());
+    void this._deps.run_scoped(async () => {
+      while ((await this.drain()).leased.length > 0) ;
+    });
   });
   _worker;
   _misrouted = /* @__PURE__ */ new Set();
@@ -2928,10 +2949,12 @@ var DrainController = class {
       if (acked.length) this._deps.on_acked(acked);
       if (closeable.length) await this._deps.on_close(closeable);
       this._deps.breaker.passed();
-      const has_errors = handled.some(({ error }) => error);
-      if (!acked.length && !blocked.length && !has_errors) this._armed = false;
       return { fetched, leased, acked, blocked };
     } catch (error) {
+      this._defer.set(
+        RETRY,
+        Date.now() + Math.max(leaseMillis, this._deps.breaker.cooldown_ms)
+      );
       this._deps.breaker.failed(Date.now(), error);
       return EMPTY_DRAIN;
     } finally {
@@ -3055,7 +3078,8 @@ var SettleLoop = class {
   /**
    * Schedule a settle pass. Multiple calls inside the debounce window
    * coalesce into one cycle. The cycle runs correlate→drain in a loop
-   * until no progress is made (no new subscriptions, no acks, no blocks)
+   * until no progress is made (no new subscriptions, no events read, no
+   * streams leased)
    * or `maxPasses` is reached, then emits the `"settled"` lifecycle event
    * via {@link SettleDeps.on_settled}.
    */
@@ -3095,7 +3119,7 @@ var SettleLoop = class {
             acked: [...settled_drain.acked, ...drain.acked],
             blocked: [...settled_drain.blocked, ...drain.blocked]
           } : drain;
-          const made_progress = subscribed > 0 || drain.acked.length > 0 || drain.blocked.length > 0 || last_id > after_before;
+          const made_progress = subscribed > 0 || drain.leased.length > 0 || last_id > after_before;
           if (!made_progress) break;
         }
         if (settled_drain) this._deps.on_settled(settled_drain);
@@ -3132,26 +3156,6 @@ var SettleLoop = class {
 };
 
 // src/builders/reaction-builder.ts
-function finalize(lease, handled, at, error, options, logger, failed_at) {
-  if (!error) return { lease, handled, acked_at: at };
-  logger.error(error);
-  const non_retryable = error instanceof NonRetryableError;
-  const block2 = options.blockOnError && (non_retryable || lease.retry >= options.maxRetries);
-  if (block2)
-    logger.error(
-      non_retryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
-    );
-  const next_attempt_at = block2 ? void 0 : Date.now() + compute_backoff_delay(lease.retry, options.backoff ?? DEFAULT_BACKOFF);
-  return {
-    lease,
-    handled,
-    acked_at: at,
-    error: error.message,
-    block: block2,
-    next_attempt_at,
-    failed_at
-  };
-}
 function build_handle(deps) {
   const { logger, reaction_scope } = deps;
   return async (lease, payloads) => {
@@ -4297,7 +4301,8 @@ var Act = class {
    * Call this after `app.do()` (or `app.reset()`) to schedule a background
    * drain. Multiple rapid calls within the debounce window are coalesced
    * into a single cycle. Runs correlate→drain in a loop until a pass makes
-   * no progress — no new subscriptions, no acks, no blocks — then emits
+   * no progress — no new subscriptions, no events read, no streams leased —
+   * then emits
    * the `"settled"` lifecycle event. This means a single `settle()` call
    * fully catches up paginated streams (e.g. after `reset()` on a long
    * projection) without forcing callers to loop.