@rotorsoft/act 1.25.2 → 1.26.0

package/dist/index.cjs

@@ -815,6 +815,8 @@ var InMemoryStore = class {
   _next_id = 0;
   // stored stream positions and other metadata
   _streams = /* @__PURE__ */ new Map();
+  /** Correlate checkpoint (#1484): how far the log has been READ. */
+  _correlated_at = -1;
   // last committed version per stream — O(1) replacement for filter-on-commit
   _stream_versions = /* @__PURE__ */ new Map();
   // max non-snapshot event id per stream — drives the has-work probe in
@@ -832,6 +834,7 @@ var InMemoryStore = class {
   _reset_indexes() {
     this._events.length = 0;
     this._next_id = 0;
+    this._correlated_at = -1;
     this._stream_versions.clear();
     this._max_event_id_by_stream.clear();
     this._max_non_snap_event_id = -1;
@@ -1063,7 +1066,9 @@ var InMemoryStore = class {
    * @param streams - Streams to register with optional source + priority.
    * @returns subscribed count and current max watermark.
    */
-  async subscribe(streams) {
+  async subscribe(streams, correlated_at) {
+    if (correlated_at !== void 0 && correlated_at > this._correlated_at)
+      this._correlated_at = correlated_at;
     await sleep();
     let subscribed = 0;
     for (const {
@@ -1088,7 +1093,7 @@ var InMemoryStore = class {
     for (const s of this._streams.values()) {
       if (s.at > watermark) watermark = s.at;
     }
-    return { subscribed, watermark };
+    return { subscribed, watermark, correlated_at: this._correlated_at };
   }
   /**
    * Acknowledge completion of processing for leased streams.
@@ -3260,8 +3265,10 @@ var CorrelateCycle = class {
     this._initialized = true;
   }
   async _run_init() {
-    const { watermark } = await store2().subscribe([...this._static_targets]);
-    this._checkpoint = this._has_dynamic_resolvers ? Math.max(-1, watermark - this._cold_start_back_scan) : watermark;
+    const { watermark, correlated_at } = await store2().subscribe([
+      ...this._static_targets
+    ]);
+    this._checkpoint = !this._has_dynamic_resolvers ? watermark : correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - this._cold_start_back_scan);
     this._on_init?.();
     for (const { stream } of this._static_targets) {
       this._subscribed.set(stream, Number.POSITIVE_INFINITY);
@@ -3341,7 +3348,7 @@ var CorrelateCycle = class {
           lane
         })
       );
-      const { subscribed } = await this._cd.subscribe(streams);
+      const { subscribed } = await this._cd.subscribe(streams, last_id);
       this._checkpoint = last_id;
       if (subscribed) {
         for (const { stream, priority } of streams) {
@@ -3527,7 +3534,7 @@ async function fetch(leased, eventLimit) {
 }
 var ack = (leases) => store2().ack(leases);
 var block = (leases) => store2().block(leases);
-var subscribe = (streams) => store2().subscribe(streams);
+var subscribe = (streams, correlated_at) => store2().subscribe(streams, correlated_at);
 
 // src/internal/event-sourcing.ts
 var import_act_patch = require("@rotorsoft/act-patch");
@@ -4589,6 +4596,19 @@ function build_handle_batch(logger) {
 var SettleLoop = class {
   _timer = void 0;
   _running = false;
+  /**
+   * Resolves when the cycle currently in flight finishes; `undefined` when
+   * idle (#1468). `_running` answers "is a cycle running?" for the
+   * re-arm bookkeeping; this answers "tell me when it is done" for a
+   * graceful shutdown.
+   *
+   * `stop()` only cancels *scheduling* — a cycle already inside its
+   * correlate → drain loop keeps going, and because `DrainController.drain`
+   * does not consult `_stopped`, it can claim a stream after teardown
+   * returned and after the store adapter was disposed. Never rejects: the
+   * cycle's own `catch` contains its errors, so awaiting this is safe.
+   */
+  _inflight;
   /**
    * 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
@@ -4628,6 +4648,10 @@ var SettleLoop = class {
         return;
       }
       this._running = true;
+      let settle_done;
+      this._inflight = new Promise((done) => {
+        settle_done = done;
+      });
       (async () => {
         await this._deps.init();
         let settled_drain;
@@ -4653,6 +4677,8 @@ var SettleLoop = class {
         this._deps.breaker.failed(Date.now(), err);
       }).finally(() => {
         this._running = false;
+        this._inflight = void 0;
+        settle_done();
         const pending = this._pending;
         if (pending !== void 0) {
           this._pending = void 0;
@@ -4661,6 +4687,14 @@ var SettleLoop = class {
       });
     }, debounceMs);
   }
+  /**
+   * The cycle currently in flight, or `undefined` when idle (#1468). A
+   * graceful shutdown awaits this alongside the drain controllers so a
+   * settle parked in `correlate` does not resume after teardown.
+   */
+  get inflight() {
+    return this._inflight;
+  }
   /** Cancel any pending or active settle cycle. Idempotent. */
   stop() {
     this._pending = void 0;
@@ -5203,10 +5237,12 @@ var Act = class {
     const running = [...this._drain_controllers.values()].filter(
       (c) => c.inflight !== void 0
     );
-    if (running.length === 0) return;
+    const settling = this._settle.inflight;
+    if (running.length === 0 && !settling) return;
     const grace = grace_ms ?? this._derive_grace_ms(running);
     if (grace <= 0) return;
     const inflight = running.map((c) => c.inflight);
+    if (settling) inflight.push(settling);
     let timer;
     const budget = new Promise((resolve) => {
       timer = setTimeout(resolve, grace);
@@ -6158,6 +6194,14 @@ function act() {
     autoclose_archiver: (state_name) => _aa.get(state_name) ?? null
   };
   const pending_projections = [];
+  const projection_reactions = /* @__PURE__ */ new Set();
+  const record_projection_reactions = (proj) => {
+    for (const register of Object.values(
+      proj.events
+    ))
+      for (const reaction of register.reactions.values())
+        projection_reactions.add(reaction);
+  };
   const fold_projections = [];
   const batch_handlers = /* @__PURE__ */ new Map();
   const fold_specs = [];
@@ -6254,6 +6298,7 @@ function act() {
       return builder;
     },
     withProjection: (proj) => {
+      record_projection_reactions(proj);
       merge_projection(proj, registry.events);
       register_batch_handler(proj, batch_handlers);
       if (proj.fold)
@@ -6271,6 +6316,7 @@ function act() {
       const patch_fn = options?.validateFoldedState === true ? validating_patch : bare_patch;
       if (!_built) {
         for (const proj of pending_projections) {
+          record_projection_reactions(proj);
           merge_projection(proj, registry.events);
           register_batch_handler(proj, batch_handlers);
           if (proj.fold) fold_projections.push(proj);
@@ -6289,17 +6335,31 @@ function act() {
             throw new Error(
               `State projection "${proj.target}" of "${fold.name}" is missing events ${missing.join(", ")} \u2014 pass every partial of the state to .of()`
             );
-          if (batch_handlers.has(proj.target) || fold_specs.some((s) => s.target === proj.target))
+          const claimed = fold_specs.find((s) => s.target === proj.target);
+          if (claimed?.projection === proj) continue;
+          if (batch_handlers.has(proj.target) || claimed)
             throw new Error(
               `Duplicate projection target "${proj.target}" \u2014 a target is served by one batch handler or one state projection, never both`
             );
           fold_specs.push({
             target: proj.target,
+            projection: proj,
             merged,
             flush: fold.flush,
             config: fold.config
           });
         }
+        for (const register of Object.values(registry.events)) {
+          for (const reaction of register.reactions.values()) {
+            if (typeof reaction.resolver === "function") continue;
+            const target = reaction.resolver.target;
+            const claimed = batch_handlers.has(target) || fold_specs.some((f) => f.target === target);
+            if (claimed && !projection_reactions.has(reaction))
+              throw new Error(
+                `Reaction on target "${target}" conflicts with the projection that already serves it \u2014 a target is served by one batch handler or one state projection, and a reaction to it would never run`
+              );
+          }
+        }
         finalize_deprecations();
         validate_lane_references(registry, lanes);
         for (const [event_name, reg] of Object.entries(