@rotorsoft/act 1.25.1 → 1.25.3

package/dist/index.js

@@ -2806,6 +2806,7 @@ var DrainController = class {
 };
 
 // src/internal/projection-fold.ts
+var FOLD_RESET = /* @__PURE__ */ Symbol("act.fold.reset");
 function make_fold_handler(me, flush, config2, patch_fn = bare_patch, sensitive_fields) {
   const load_me = {
     ...me,
@@ -2829,7 +2830,27 @@ function make_fold_handler(me, flush, config2, patch_fn = bare_patch, sensitive_
     await flush(rows);
     for (const f of flushed) f.dirty = false;
   };
-  return async (events) => {
+  const first_sight = async (stream) => {
+    if (cache2.size >= config2.maxCachedStates) {
+      const oldest = cache2.keys().next().value;
+      const evictee = cache2.get(oldest);
+      if (evictee.dirty) await flush([row(evictee)]);
+      cache2.delete(oldest);
+    }
+    const snapshot = await load(load_me, { stream }, void 0, patch_fn);
+    const seated = {
+      stream,
+      state: snapshot.state,
+      version: snapshot.version,
+      event_id: snapshot.id,
+      patches: snapshot.patches,
+      snaps: snapshot.snaps,
+      dirty: true
+    };
+    cache2.set(stream, seated);
+    return seated;
+  };
+  const handler = async (events) => {
     let folded_since_flush = 0;
     for (const event of events) {
       const stream = event.stream;
@@ -2838,23 +2859,12 @@ function make_fold_handler(me, flush, config2, patch_fn = bare_patch, sensitive_
         cache2.delete(stream);
         cache2.set(stream, fold);
       } else {
-        if (cache2.size >= config2.maxCachedStates) {
-          const oldest = cache2.keys().next().value;
-          const evictee = cache2.get(oldest);
-          if (evictee.dirty) await flush([row(evictee)]);
-          cache2.delete(oldest);
-        }
-        const snapshot = await load(load_me, { stream }, void 0, patch_fn);
-        fold = {
-          stream,
-          state: snapshot.state,
-          version: snapshot.version,
-          event_id: snapshot.id,
-          patches: snapshot.patches,
-          snaps: snapshot.snaps,
-          dirty: true
-        };
-        cache2.set(stream, fold);
+        fold = await first_sight(stream);
+      }
+      const contiguous = event.version === fold.version + 1;
+      if (event.id > fold.event_id && !contiguous) {
+        cache2.delete(stream);
+        fold = await first_sight(stream);
       }
       if (event.id > fold.event_id) {
         const reducer = me.patch[event.name];
@@ -2878,6 +2888,8 @@ function make_fold_handler(me, flush, config2, patch_fn = bare_patch, sensitive_
     }
     await flush_dirty();
   };
+  Object.defineProperty(handler, FOLD_RESET, { value: () => cache2.clear() });
+  return handler;
 }
 
 // src/internal/reactions.ts
@@ -3010,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
@@ -3049,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;
@@ -3074,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;
@@ -3082,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;
@@ -3624,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);
@@ -4179,6 +4220,8 @@ var Act = class {
   async reset(input) {
     return this._scoped(async () => {
       const count = await store().reset(input);
+      for (const handler of this._batch_handlers.values())
+        handler[FOLD_RESET]?.();
       if (count > 0 && this._reactive_events.size > 0) this._arm_all();
       return count;
     });
@@ -4577,17 +4620,30 @@ 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 = [];
   const lanes = [];
   let _built = false;
-  const pii_wrap = (original) => async (events, stream) => {
-    const stripped = events.map((e) => {
-      const f = _sf.get(e.name);
-      return f ? pii_strip(e, f) : e;
-    });
-    return original(stripped, stream);
+  const pii_wrap = (original) => {
+    const wrapped = async (events, stream) => {
+      const stripped = events.map((e) => {
+        const f = _sf.get(e.name);
+        return f ? pii_strip(e, f) : e;
+      });
+      return original(stripped, stream);
+    };
+    const reset = original[FOLD_RESET];
+    if (reset) Object.defineProperty(wrapped, FOLD_RESET, { value: reset });
+    return wrapped;
   };
   const make_batch_handlers = (patch_fn) => {
     const handlers = new Map(batch_handlers);
@@ -4668,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)
@@ -4685,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);
@@ -4703,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(