@rotorsoft/act 1.22.8 → 1.22.9

package/dist/index.js

@@ -1396,6 +1396,7 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
 }
 
 // src/internal/correlate-cycle.ts
+var DEFAULT_COLD_START_BACK_SCAN = 1e4;
 var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
@@ -1424,8 +1425,24 @@ var CorrelateCycle = class {
    * `_scoped` (identity for a non-scoped Act), so it's required.
    */
   _run_scoped;
-  constructor(registry, static_targets, has_dynamic_resolvers, cd, maxSubscribedStreams, on_init, run_scoped, on_init_async) {
-    this._subscribed = new LruSet(maxSubscribedStreams);
+  /**
+   * Tail re-scan window applied to the cold-start checkpoint (ACT-1207).
+   * See {@link DEFAULT_COLD_START_BACK_SCAN}. Constructor arg (not a
+   * public option) so tests can shrink it; defaults otherwise.
+   */
+  _cold_start_back_scan;
+  constructor({
+    registry,
+    static_targets,
+    has_dynamic_resolvers,
+    cd,
+    max_subscribed_streams,
+    run_scoped,
+    on_init,
+    on_init_async,
+    cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN
+  }) {
+    this._subscribed = new LruSet(max_subscribed_streams);
     this._registry = registry;
     this._static_targets = static_targets;
     this._has_dynamic_resolvers = has_dynamic_resolvers;
@@ -1433,6 +1450,7 @@ var CorrelateCycle = class {
     this._on_init = on_init;
     this._run_scoped = run_scoped;
     this._on_init_async = on_init_async;
+    this._cold_start_back_scan = cold_start_back_scan;
   }
   /** Last correlated event id. */
   get checkpoint() {
@@ -1440,7 +1458,10 @@ var CorrelateCycle = class {
   }
   /**
    * Initialize correlation state on first call.
-   * - Reads max(at) from store as cold-start checkpoint
+   * - Reads max(at) from store, then floors the cold-start checkpoint at
+   *   `watermark - back_scan` when dynamic resolvers exist, so an event
+   *   committed-but-not-correlated before a crash is re-scanned on
+   *   restart instead of skipped (ACT-1207)
    * - Subscribes static resolver targets (idempotent upsert)
    * - Populates the subscribed-streams LRU
    * - Fires `on_init` once (Act uses this to flag a cold-start drain)
@@ -1449,7 +1470,7 @@ var CorrelateCycle = class {
     if (this._initialized) return;
     this._initialized = true;
     const { watermark } = await store().subscribe([...this._static_targets]);
-    this._checkpoint = watermark;
+    this._checkpoint = this._has_dynamic_resolvers ? Math.max(-1, watermark - this._cold_start_back_scan) : watermark;
     this._on_init?.();
     for (const { stream } of this._static_targets) {
       this._subscribed.add(stream);
@@ -1900,6 +1921,7 @@ async function load(me, target, callback) {
         event,
         state: state2,
         version: event.version,
+        id: event.id,
         patches,
         snaps,
         cache_hit,
@@ -1921,12 +1943,17 @@ async function load(me, target, callback) {
       event_id: event.id,
       patches,
       snaps
-    });
+    }).catch((err) => log().error(err));
   }
   return {
     event,
     state: state2,
     version: event?.version ?? cached?.version ?? -1,
+    // Head event id, captured atomically with `state`: the last replayed
+    // event's id on a cache miss, or the cached checkpoint's event_id on a
+    // warm hit with no new events. Consumers read this instead of a
+    // separate cache lookup that could race a concurrent commit (ACT-1204).
+    id: event?.id ?? cached?.event_id ?? -1,
     patches,
     snaps,
     cache_hit,
@@ -2020,6 +2047,7 @@ async function action(me, action2, target, payload, options) {
           event,
           state: state2,
           version: event.version,
+          id: event.id,
           patches,
           snaps: snapshot.snaps,
           patch: p,
@@ -2047,6 +2075,7 @@ async function action(me, action2, target, payload, options) {
       return snapshots;
     } catch (error) {
       if (!(error instanceof ConcurrencyError)) throw error;
+      if (expectedVersion !== void 0) throw error;
       if (attempt >= max_retries) throw error;
       if (opts?.backoff) {
         const delay_ms = compute_backoff_delay(attempt, opts.backoff);
@@ -2569,6 +2598,16 @@ function build_handle_batch(logger) {
 var SettleLoop = class {
   _timer = void 0;
   _running = false;
+  /**
+   * Set when a `schedule()` timer fires while a cycle is still running
+   * (ACT-1205). The in-flight cycle's `finally` re-arms one more pass so
+   * the wake-up isn't dropped — a commit landing during the final
+   * no-progress drain pass would otherwise leave armed controllers with
+   * nothing to re-drain on an instance with no lane `cycleMs` and no
+   * polling. Carries the options of the dropped call so the re-armed
+   * pass honors its `debounceMs`/`maxPasses`/drain overrides.
+   */
+  _pending = void 0;
   _deps;
   /** Debounce window applied when the caller doesn't override via `SettleOptions.debounceMs`. */
   _default_debounce_ms;
@@ -2593,7 +2632,10 @@ var SettleLoop = class {
     if (this._timer) clearTimeout(this._timer);
     this._timer = setTimeout(() => {
       this._timer = void 0;
-      if (this._running) return;
+      if (this._running) {
+        this._pending = options;
+        return;
+      }
       this._running = true;
       (async () => {
         await this._deps.init();
@@ -2613,11 +2655,17 @@ var SettleLoop = class {
         this._deps.breaker.failed(Date.now(), err);
       }).finally(() => {
         this._running = false;
+        const pending = this._pending;
+        if (pending !== void 0) {
+          this._pending = void 0;
+          this.schedule(pending);
+        }
       });
     }, debounceMs);
   }
   /** Cancel any pending or active settle cycle. Idempotent. */
   stop() {
+    this._pending = void 0;
     if (this._timer) {
       clearTimeout(this._timer);
       this._timer = void 0;
@@ -2668,20 +2716,13 @@ function make_fold_handler(me, flush, config2) {
           cache2.delete(oldest);
         }
         const snapshot = await load(me, { stream });
-        const entry = await cache().get(stream);
-        const frontier = entry ?? {
-          version: snapshot.event.version,
-          event_id: snapshot.event.id,
-          patches: snapshot.patches,
-          snaps: snapshot.snaps
-        };
         fold = {
           stream,
           state: snapshot.state,
-          version: frontier.version,
-          event_id: frontier.event_id,
-          patches: frontier.patches,
-          snaps: frontier.snaps,
+          version: snapshot.version,
+          event_id: snapshot.id,
+          patches: snapshot.patches,
+          snaps: snapshot.snaps,
           dirty: true
         };
         cache2.set(stream, fold);
@@ -3040,22 +3081,22 @@ var Act = class {
    * except on writer-only instances (`drain: false`).
    */
   _build_correlate(options, classification) {
-    return new CorrelateCycle(
-      this.registry,
-      classification.static_targets,
-      classification.has_dynamic_resolvers,
-      this._cd,
-      options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
-      () => {
+    return new CorrelateCycle({
+      registry: this.registry,
+      static_targets: classification.static_targets,
+      has_dynamic_resolvers: classification.has_dynamic_resolvers,
+      cd: this._cd,
+      max_subscribed_streams: options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
+      on_init: () => {
         if (this._drain && this._reactive_events.size > 0) this._arm_all();
       },
       // Re-scope the background `start_correlations` timer so its
       // correlate resolves the scoped ports, not the singleton (#1191).
-      this._scoped,
+      run_scoped: this._scoped,
       // Cold-start defer re-seed (#1221). Skipped on writer-only instances
       // (`drain: false`) — they run no local controllers to re-arm.
-      this._drain ? () => this._seed_persisted_defers() : void 0
-    );
+      on_init_async: this._drain ? () => this._seed_persisted_defers() : void 0
+    });
   }
   /**
    * Re-seed every active lane controller's process-local defer timer from