@rotorsoft/act 1.23.1 → 1.23.3

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-4HYYZOEH.js";
+} from "./chunk-5YIRFU4Y.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -1216,21 +1216,37 @@ async function run_windowed_closes(windowed, deps, skipped) {
     windowed.map((t) => t.stream),
     deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
   ) : /* @__PURE__ */ new Map();
+  const with_lock = deps.with_stream_lock ?? ((_stream, work) => work());
+  const truncated = /* @__PURE__ */ new Map();
   for (const t of windowed) {
-    if (t.archive) await t.archive();
-  }
-  const truncated = await store().truncate(
-    windowed.map((t) => ({
-      stream: t.stream,
-      before: t.before,
-      max_id: min_at.get(t.stream)
-    }))
-  );
-  for (const t of windowed) {
-    if (!truncated.has(t.stream)) skipped.push(t.stream);
+    const entry = await with_lock(t.stream, async () => {
+      const max_id = min_at.get(t.stream);
+      if (!await windowed_prune_pending(t.stream, t.before, max_id))
+        return void 0;
+      if (t.archive) await t.archive();
+      const result = await store().truncate([
+        { stream: t.stream, before: t.before, max_id }
+      ]);
+      return result.get(t.stream);
+    });
+    if (entry) truncated.set(t.stream, entry);
+    else skipped.push(t.stream);
   }
   return truncated;
 }
+async function windowed_prune_pending(stream, before, max_id) {
+  let boundary_id;
+  let min_id;
+  await store().query(
+    (event) => {
+      if (min_id === void 0 || event.id < min_id) min_id = event.id;
+      if (event.name === SNAP_EVENT && event.created < before && (max_id === void 0 || event.id <= max_id) && (boundary_id === void 0 || event.id > boundary_id))
+        boundary_id = event.id;
+    },
+    { stream, stream_exact: true, with_snaps: true, after: -1 }
+  );
+  return boundary_id !== void 0 && min_id < boundary_id;
+}
 async function probe_min_watermarks(streams, page_size) {
   const min_at = /* @__PURE__ */ new Map();
   const source_regex = /* @__PURE__ */ new Map();
@@ -1505,8 +1521,10 @@ var CorrelateCycle = class {
                 lane: resolved.lane,
                 payloads: []
               };
-              if (incoming_priority > entry.priority)
+              if (incoming_priority > entry.priority) {
                 entry.priority = incoming_priority;
+                entry.lane = resolved.lane;
+              }
               entry.payloads.push({
                 ...reaction,
                 source: resolved.source,
@@ -2911,6 +2929,34 @@ var Act = class {
   _handle_batch;
   /** Declared drain lanes (ACT-1103). */
   _lanes;
+  /**
+   * Per-stream close serialization tails (#1222). Chains each stream's
+   * windowed-close work behind the previous one so a manual
+   * `app.close([{stream, before}])` and an autoclose windowed close for
+   * the same stream never run their guard-free prune concurrently — the
+   * manual path bypasses the `__autoclose__:X` drain lease that would
+   * otherwise exclude them, so without this both closers archive the
+   * same prefix. Process-local: both racers run on the same Act
+   * instance. Entries are dropped once their tail resolves so the map
+   * doesn't grow with distinct stream names.
+   */
+  _close_locks = /* @__PURE__ */ new Map();
+  /**
+   * Run `work` under the per-stream close lock (#1222). Serializes
+   * windowed-close critical sections for the same stream while letting
+   * different streams proceed in parallel.
+   */
+  _with_close_lock(stream, work) {
+    const prev = this._close_locks.get(stream) ?? Promise.resolve();
+    const next = prev.then(work, work);
+    this._close_locks.set(stream, next);
+    const cleanup = () => {
+      if (this._close_locks.get(stream) === next)
+        this._close_locks.delete(stream);
+    };
+    next.then(cleanup, cleanup);
+    return next;
+  }
   /** Drain lanes declared via `.withLane(...)`. Implicit default not included. */
   get lanes() {
     return this._lanes;
@@ -3032,7 +3078,8 @@ var Act = class {
             load: this._es.load,
             tombstone: this._es.tombstone,
             logger: this._logger,
-            correlation: close_correlation(this._correlator, close_actor)
+            correlation: close_correlation(this._correlator, close_actor),
+            with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
           });
           this.emit("closed", result);
         },
@@ -4022,7 +4069,8 @@ var Act = class {
         load: this._es.load,
         tombstone: this._es.tombstone,
         logger: this._logger,
-        correlation: close_correlation(this._correlator, close_actor)
+        correlation: close_correlation(this._correlator, close_actor),
+        with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
       });
       this.emit("closed", result);
       return result;