@rotorsoft/act 1.32.25 → 1.32.26

package/dist/index.js

@@ -1692,13 +1692,25 @@ var CorrelateCycle = class {
     const after = Math.max(this._checkpoint, query.after || -1);
     const correlated = /* @__PURE__ */ new Map();
     let last_id = after;
+    let stopped = false;
     const found = await store().query(
       (event) => {
-        last_id = event.id;
+        if (stopped) return;
         const register = this._registry.events[event.name];
         if (register) {
           for (const reaction of register.reactions.values()) {
-            const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+            let resolved;
+            try {
+              resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+            } catch (error) {
+              stopped = true;
+              report_once(
+                this._reported,
+                `resolver|${reaction.handler.name}|${event.id}`,
+                `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}. Correlation stops before this event until the resolver stops throwing; work already found keeps draining.`
+              );
+              return;
+            }
             if (!resolved) continue;
             let lane = resolved.lane;
             if (lane !== void 0 && !this._declared_lanes.has(lane)) {
@@ -1747,6 +1759,7 @@ var CorrelateCycle = class {
             correlated.set(resolved.target, entry);
           }
         }
+        last_id = event.id;
       },
       // Resolvers see `pii: null`: correlate runs actor-less, and one
       // undecryptable row would otherwise stop every stream's reactions.
@@ -1788,7 +1801,7 @@ var CorrelateCycle = class {
       return { subscribed, last_id, marked, scanned: true };
     }
     this._checkpoint = last_id;
-    this._armed = found === query.limit;
+    this._armed = stopped || found === query.limit;
     return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
   /**
@@ -2672,6 +2685,22 @@ 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;
+  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
+      )
+    }
+  };
+}
 function warn_misrouted(seen, stream, handler, event) {
   report_once(
     seen,
@@ -2705,13 +2734,23 @@ async function run_drain_cycle(deps, cycle) {
   );
   for (const f of fetched) {
     const { stream, events } = f;
+    let failed;
     const payloads = events.flatMap((event) => {
       const register = registry.events[event.name];
       if (!register) return [];
       return [...register.reactions.values()].filter((reaction) => {
         const resolver = reaction.resolver;
         const dynamic = typeof resolver === "function";
-        const resolved = dynamic ? resolver(event) : resolver;
+        let resolved;
+        try {
+          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)}`,
+            options: reaction.options
+          };
+          return false;
+        }
         if (!resolved || resolved.target !== stream) return false;
         if (!dynamic || !batch_handlers.has(stream)) return true;
         warn_misrouted(
@@ -2723,7 +2762,7 @@ async function run_drain_cycle(deps, cycle) {
         return false;
       }).map((reaction) => ({ ...reaction, event }));
     });
-    fetch_map.set(stream, { fetch: f, payloads });
+    fetch_map.set(stream, { fetch: f, payloads, failed });
   }
   const handled = await Promise.all(
     leased.map((lease) => {
@@ -2744,6 +2783,8 @@ async function run_drain_cycle(deps, cycle) {
         };
         return Promise.resolve(failed);
       }
+      if (entry.failed)
+        return Promise.resolve(resolver_failed(lease, entry.failed));
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
       const exhausted = budget_exhausted(
@@ -3400,8 +3441,18 @@ var Act = class {
         on_acked: (acked) => this.emit("acked", acked),
         on_blocked: (blocked) => this.emit("blocked", blocked),
         // Reaction-requested close: the same machinery as `app.close`.
+        // A store failure reaches the breaker; anything else (the archive
+        // callback is app code) is logged here, never counted.
         on_close: async (targets) => {
-          await this._run_close(targets);
+          try {
+            await this._run_close(targets);
+          } catch (error) {
+            if (error instanceof StoreError) throw error;
+            this._logger.error(
+              error,
+              `Reaction-requested close of ${targets.map((t) => `"${t.stream}"`).join(", ")} failed and was not retried; close it with app.close(...) once the cause is fixed.`
+            );
+          }
         },
         breaker: this._breaker,
         run_scoped: this._scoped,