@rotorsoft/act 1.23.30 → 1.23.32

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,
@@ -2477,7 +2490,7 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 }
 
 // src/internal/drain-cycle.ts
-async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, lane) {
+async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
   const leased = await ops.claim(
     lagging,
     leading,
@@ -2519,6 +2532,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
   const blocked = await ops.block(
     handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }))
   );
+  if (blocked.length) on_blocked(blocked);
   const acked = await ops.ack(
     handled.flatMap((h, i) => {
       const advance = h.handled > 0 ? h.acked_at : leased[i].at;
@@ -2541,13 +2555,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;
@@ -2656,10 +2663,11 @@ var DrainController = class {
         leading,
         eventLimit,
         leaseMillis,
+        (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;
       }
@@ -2675,18 +2683,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 (blocked.length)
-        contain(
-          this._deps.logger,
-          "blocked",
-          () => this._deps.on_blocked(blocked)
-        );
-      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 };
@@ -3278,7 +3276,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