@rotorsoft/act 1.25.2 → 1.25.3

package/dist/index.js

@@ -3022,6 +3022,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
@@ -3061,6 +3074,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;
@@ -3086,6 +3103,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;
@@ -3094,6 +3113,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;
@@ -3636,10 +3663,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);
@@ -4591,6 +4620,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 = [];
@@ -4687,6 +4724,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)
@@ -4704,6 +4742,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);
@@ -4722,17 +4761,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(