@rotorsoft/act 1.23.31 → 1.23.33

package/dist/index.js

@@ -1311,6 +1311,19 @@ async function run_close_cycle(targets, deps) {
   if (!full.length) return { truncated: windowed_result, skipped };
   const streams = full.map((t) => t.stream);
   const stream_info = await scan_stream_heads(streams);
+  for (const target of full) {
+    if (!target.restart) continue;
+    const info = stream_info.get(target.stream);
+    if (!info) continue;
+    const owner = deps.event_to_state.get(info.last_event_name);
+    if (owner?.pii_aware) {
+      deps.logger.error(
+        `Refusing to close "${target.stream}" with restart: state "${owner.name}" carries sensitive fields, so a restart seed would persist redacted values while deleting the originals. Close it without restart to retire the stream, or leave it open.`
+      );
+      skipped.push(target.stream);
+      stream_info.delete(target.stream);
+    }
+  }
   const safe = await partition_by_safety(
     stream_info,
     deps.reactive_events_size,
@@ -1417,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;
@@ -1473,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);
@@ -2542,13 +2565,6 @@ var contain = (logger, sink, fn) => {
     logger.error(error, `${sink} listener threw`);
   }
 };
-var contain_async = async (logger, sink, fn) => {
-  try {
-    await fn();
-  } catch (error) {
-    logger.error(error, `${sink} listener threw`);
-  }
-};
 var DrainController = class {
   _armed = false;
   _locked = false;
@@ -2660,8 +2676,8 @@ var DrainController = class {
         (b) => contain(this._deps.logger, "blocked", () => this._deps.on_blocked(b)),
         this._deps.lane
       );
-      this._deps.breaker.passed();
       if (!cycle) {
+        this._deps.breaker.passed();
         this._armed = false;
         return EMPTY_DRAIN;
       }
@@ -2677,12 +2693,8 @@ var DrainController = class {
       if (this._defer.size > 0) this._defer.schedule();
       if (acked.length)
         contain(this._deps.logger, "acked", () => this._deps.on_acked(acked));
-      if (closeable.length)
-        await contain_async(
-          this._deps.logger,
-          "close",
-          () => this._deps.on_close(closeable)
-        );
+      if (closeable.length) await this._deps.on_close(closeable);
+      this._deps.breaker.passed();
       const has_errors = handled.some(({ error }) => error);
       if (!acked.length && !blocked.length && !has_errors) this._armed = false;
       return { fetched, leased, acked, blocked };
@@ -3274,7 +3286,11 @@ var Act = class {
             correlation: close_correlation(this._correlator, close_actor),
             with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
           });
-          this.emit("closed", result);
+          try {
+            this.emit("closed", result);
+          } catch (err) {
+            this._logger.error(err, "closed listener threw");
+          }
         },
         breaker: this._breaker,
         // Re-scope the per-lane worker's auto-start ticks so their drain