@rotorsoft/act 1.23.32 → 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,
@@ -1430,14 +1430,19 @@ async function scan_stream_heads(streams) {
   const stats = await store().query_stats(streams, {
     exclude: [SNAP_EVENT]
   });
+  const domain_heads = await store().query_stats(streams, {
+    exclude: [SNAP_EVENT, TOMBSTONE_EVENT]
+  });
   const true_heads = await store().query_stats(streams, {});
   const out = /* @__PURE__ */ new Map();
-  for (const [stream, { head }] of stats) {
-    if (head.name === TOMBSTONE_EVENT) continue;
+  for (const [stream, { head }] of domain_heads) {
+    const marker_head = stats.get(stream)?.head;
+    const interrupted = marker_head?.name === TOMBSTONE_EVENT;
     out.set(stream, {
       max_id: head.id,
       version: true_heads.get(stream).head.version,
-      last_event_name: head.name
+      last_event_name: head.name,
+      ...interrupted ? { resumed_guard: { id: marker_head.id } } : {}
     });
   }
   return out;
@@ -1486,6 +1491,11 @@ async function guard_with_tombstones(safe, stream_info, correlation, tombstone2,
   await Promise.all(
     safe.map(async (stream) => {
       const info = stream_info.get(stream);
+      if (info.resumed_guard) {
+        guarded.push(stream);
+        guard_events.set(stream, { id: info.resumed_guard.id, stream });
+        return;
+      }
       const committed = await tombstone2(stream, info.version, correlation);
       if (committed) {
         guarded.push(stream);
@@ -1563,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
@@ -1645,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?.();
@@ -1654,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
@@ -3276,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) {
@@ -4270,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 () => {
@@ -4284,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;
     });