@rotorsoft/act 1.23.33 → 1.23.34

package/dist/index.cjs

@@ -1418,8 +1418,11 @@ var InMemoryStore = class {
       }
     }
     this._events = this._events.filter((e) => !stream_set.has(e.stream));
+    const restarted = new Set(
+      full.filter((t) => t.snapshot !== void 0).map((t) => t.stream)
+    );
     for (const stream of stream_set) {
-      this._streams.delete(stream);
+      if (!restarted.has(stream)) this._streams.delete(stream);
       this._stream_versions.delete(stream);
       this._max_event_id_by_stream.delete(stream);
       this._pii.delete(stream);
@@ -3095,6 +3098,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
@@ -3177,7 +3182,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 store2().subscribe([...this._static_targets]);
     this._checkpoint = this._has_dynamic_resolvers ? Math.max(-1, watermark - this._cold_start_back_scan) : watermark;
     this._on_init?.();
@@ -3186,6 +3200,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
@@ -4808,6 +4842,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) {
@@ -5802,6 +5837,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 () => {
@@ -5816,6 +5860,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;
     });