@rotorsoft/act 1.23.33 → 1.23.34

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-5B45U2IS.js";
+} from "./chunk-TTOT5CRM.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -1573,6 +1573,8 @@ var DEFAULT_COLD_START_BACK_SCAN = 1e4;
 var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
+  /** In-flight init, memoized for single-flight and cleared on failure. */
+  _init_promise;
   _timer = void 0;
   // target → the priority it was last subscribed at. A dynamic target is
   // re-subscribed (so the store's `GREATEST` upsert runs) only when a later
@@ -1655,7 +1657,16 @@ var CorrelateCycle = class {
    */
   async init() {
     if (this._initialized) return;
+    if (!this._init_promise) {
+      this._init_promise = this._run_init().catch((error) => {
+        this._init_promise = void 0;
+        throw error;
+      });
+    }
+    await this._init_promise;
     this._initialized = true;
+  }
+  async _run_init() {
     const { watermark } = await store().subscribe([...this._static_targets]);
     this._checkpoint = this._has_dynamic_resolvers ? Math.max(-1, watermark - this._cold_start_back_scan) : watermark;
     this._on_init?.();
@@ -1664,6 +1675,26 @@ var CorrelateCycle = class {
     }
     await this._on_init_async?.();
   }
+  /**
+   * Forget targets whose subscription rows no longer exist, so a later
+   * scan can re-subscribe them.
+   *
+   * A full close deletes the closed stream's subscription row. The
+   * in-process dedup would otherwise still believe the target is
+   * subscribed and never re-issue `subscribe()`, silently stopping
+   * delivery for any reaction whose target is named after the stream —
+   * the documented per-aggregate shape `.to(e => ({target: e.stream}))`
+   * makes those two namespaces collide by construction (#1398).
+   *
+   * Static targets are left alone: they are subscribed once at init and
+   * recorded at +Infinity so the dynamic path never re-opens them.
+   */
+  forget_subscribed(streams) {
+    const statics = new Set(this._static_targets.map((t) => t.stream));
+    for (const stream of streams) {
+      if (!statics.has(stream)) this._subscribed.delete(stream);
+    }
+  }
   /**
    * Discover dynamic-resolver targets in the events past the checkpoint
    * and register any new streams via `cd.subscribe`. Static targets are
@@ -3286,6 +3317,7 @@ var Act = class {
             correlation: close_correlation(this._correlator, close_actor),
             with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
           });
+          this._forget_closed_subscriptions(result);
           try {
             this.emit("closed", result);
           } catch (err) {
@@ -4280,6 +4312,15 @@ var Act = class {
    * ]);
    * ```
    */
+  /**
+   * After a close, forget any target whose subscription row the truncate
+   * removed, so a later correlate can re-subscribe it (#1398). Restart
+   * targets keep their row, so only fully-retired streams are forgotten.
+   */
+  _forget_closed_subscriptions(result) {
+    const retired = [...result.truncated.entries()].filter(([, r]) => r.committed.name === TOMBSTONE_EVENT).map(([stream]) => stream);
+    if (retired.length) this._correlate.forget_subscribed(retired);
+  }
   async close(targets) {
     if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
     return this._scoped(async () => {
@@ -4294,6 +4335,7 @@ var Act = class {
         correlation: close_correlation(this._correlator, close_actor),
         with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
       });
+      this._forget_closed_subscriptions(result);
       this.emit("closed", result);
       return result;
     });