@rotorsoft/act 1.32.7 → 1.32.9

package/dist/index.cjs

@@ -1540,6 +1540,12 @@ var InMemoryStore = class {
     const prev_max_event_id_by_stream = this._max_event_id_by_stream;
     const prev_max_non_snap_event_id = this._max_non_snap_event_id;
     const prev_pii = this._pii;
+    const prev_correlated_at = this._correlated_at;
+    const prev_correlators = new Map(
+      [...this._correlators].map(([k, v]) => [k, { ...v }])
+    );
+    this._correlated_at = -1;
+    for (const c of this._correlators.values()) c.at = -1;
     this._events = [];
     this._next_id = 0;
     this._streams = /* @__PURE__ */ new Map();
@@ -1576,6 +1582,8 @@ var InMemoryStore = class {
       this._max_event_id_by_stream = prev_max_event_id_by_stream;
       this._max_non_snap_event_id = prev_max_non_snap_event_id;
       this._pii = prev_pii;
+      this._correlated_at = prev_correlated_at;
+      this._correlators = prev_correlators;
       throw err;
     }
   }
@@ -3392,6 +3400,24 @@ var CorrelateCycle = class {
    * `_static_subscriptions`, which this never touches, so they stay pinned
    * at +Infinity and the dynamic path never re-opens them.
    */
+  /**
+   * Start correlation over after the event log was replaced wholesale
+   * (`restore`). The restored log is renumbered from the start and its
+   * subscription rows are gone, so the in-memory scan position and both
+   * subscription records describe a log that no longer exists. Dropping them
+   * and the init latch makes the next pass run cold-start again: static
+   * targets are re-subscribed, the checkpoint is re-read from the store
+   * (which `restore` reset), and dynamic targets are rediscovered by the
+   * scan (#1772).
+   */
+  restart() {
+    this._initialized = false;
+    this._init_promise = void 0;
+    this._checkpoint = -1;
+    this._dynamic_subscriptions.clear();
+    this._static_subscriptions.clear();
+    this._armed = true;
+  }
   forget_subscribed(streams) {
     for (const stream of streams) this._dynamic_subscriptions.delete(stream);
   }
@@ -4481,6 +4507,16 @@ function budget_exhausted(lease, options, store_failing) {
   log().error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
+function fetch_failure_policy(registry) {
+  let blockOnError = true;
+  let maxRetries = 0;
+  for (const register of Object.values(registry.events))
+    for (const reaction of register.reactions.values()) {
+      blockOnError &&= reaction.options.blockOnError;
+      maxRetries = Math.max(maxRetries, reaction.options.maxRetries);
+    }
+  return { blockOnError, maxRetries };
+}
 function warn_misrouted(seen, stream, handler, event) {
   report_once(
     seen,
@@ -4531,11 +4567,14 @@ async function run_drain_cycle(ops, registry, batch_handlers, misrouted, store_f
       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
+          error,
+          ...block2 ? { block: true } : {}
         };
         return Promise.resolve(failed);
       }
@@ -6333,6 +6372,10 @@ var Act = class {
         migrated = partial.migrated;
         dropped = partial.dropped;
       });
+      if (!sink) {
+        this._correlate.restart();
+        this._arm_all();
+      }
       return { kept, migrated, dropped, duration_ms: Date.now() - started };
     });
   }
@@ -7002,6 +7045,7 @@ function act() {
   const pending_projections = [];
   const projection_reactions = /* @__PURE__ */ new Set();
   const record_projection_reactions = (proj) => {
+    if (!proj.batchHandler && !proj.fold) return;
     for (const register of Object.values(
       proj.events
     ))