@rotorsoft/act 1.32.16 → 1.32.17

package/dist/index.js

@@ -1199,6 +1199,31 @@ var CircuitBreaker = class {
 };
 
 // src/internal/close-cycle.ts
+var CLOSE_CATCH_UP_LIMIT = 1e3;
+var CLOSE_CATCH_UP_PASSES = 20;
+async function catch_up_correlation(cursor, correlate, until) {
+  for (let pass = 0; pass < CLOSE_CATCH_UP_PASSES && cursor.checkpoint < until; pass++) {
+    const before = cursor.checkpoint;
+    cursor.arm();
+    await correlate(CLOSE_CATCH_UP_LIMIT);
+    if (cursor.checkpoint <= before) break;
+  }
+  return cursor.checkpoint;
+}
+var CloseLock = class {
+  _tails = /* @__PURE__ */ new Map();
+  /** Run `work` after every earlier close of `stream` has settled. */
+  run(stream, work) {
+    const prev = this._tails.get(stream) ?? Promise.resolve();
+    const next = prev.then(work, work);
+    this._tails.set(stream, next);
+    const cleanup = () => {
+      if (this._tails.get(stream) === next) this._tails.delete(stream);
+    };
+    next.then(cleanup, cleanup);
+    return next;
+  }
+};
 var SAFETY_PROBE_PAGE_SIZE = 1e3;
 async function run_close_cycle(targets, deps) {
   const target_map = new Map(targets.map((t) => [t.stream, t]));
@@ -1220,6 +1245,8 @@ async function run_close_cycle(targets, deps) {
     deps,
     () => run_full_closes(full, target_map, deps, skipped)
   );
+  const retired = [...truncated.entries()].filter(([, r]) => r.committed.name === TOMBSTONE_EVENT).map(([stream]) => stream);
+  if (retired.length) deps.forget_subscribed?.(retired);
   for (const [stream, entry] of windowed_result) truncated.set(stream, entry);
   return { truncated, skipped };
 }
@@ -1378,12 +1405,12 @@ async function scan_stream_heads(streams) {
   }
   return out;
 }
-async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size, catch_up_correlation) {
+async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size, catch_up_correlation2) {
   if (reactive_events_size === 0) return [...stream_info.keys()];
   let needed = -1;
   for (const info of stream_info.values())
     needed = Math.max(needed, info.max_id);
-  const checkpoint = await catch_up_correlation(needed);
+  const checkpoint = await catch_up_correlation2(needed);
   const uncorrelated = /* @__PURE__ */ new Set();
   for (const [stream, info] of stream_info) {
     if (checkpoint < info.max_id) uncorrelated.add(stream);
@@ -3314,8 +3341,6 @@ function build_handle_batch(logger) {
 }
 
 // src/act.ts
-var CLOSE_CATCH_UP_LIMIT = 1e3;
-var CLOSE_CATCH_UP_PASSES = 20;
 function validate_only_lanes(options, lanes) {
   if (!options.onlyLanes || options.onlyLanes.length === 0) return;
   const declared = /* @__PURE__ */ new Set(["default", ...lanes.map((l) => l.name)]);
@@ -3468,28 +3493,10 @@ var Act = class {
   _handle_batch;
   /** Declared drain lanes. */
   _lanes;
-  /**
-   * Per-stream close serialization tails, so a manual close and an
-   * autoclose of the same stream never prune concurrently (the manual path
-   * has no drain lease to exclude it). Entries are dropped once settled.
-   */
-  _close_locks = /* @__PURE__ */ new Map();
-  /**
-   * Run `work` under the per-stream close lock. Serializes close
-   * critical sections for the same stream (windowed prunes and full
-   * closes) 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;
-  }
+  /** Serializes close critical sections per stream. */
+  _close_lock = new CloseLock();
+  /** Every lane a controller can exist for: `"default"` plus each declared one. */
+  _declared_lanes;
   /** Drain lanes declared via `.withLane(...)`. Implicit default not included. */
   get lanes() {
     return this._lanes;
@@ -3519,6 +3526,7 @@ var Act = class {
     this._states = states;
     this._batch_handlers = batch_handlers;
     this._lanes = lanes;
+    this._declared_lanes = ["default", ...lanes.map((l) => l.name)];
     validate_only_lanes(options, lanes);
     this._ports = options.scoped ?? default_scope();
     const ports = this._ports;
@@ -3556,7 +3564,7 @@ var Act = class {
     this._drain = options.drain !== false;
     this._breaker = this._build_breaker(options);
     this._drain_controllers = this._build_drain_controllers(options, lanes);
-    this._advise_orphaned_lanes(options, lanes);
+    this._advise_orphaned_lanes(options);
     this._audit_deps = this._build_audit_deps();
     this._correlate = this._build_correlate(options, classification);
     this._settle = this._build_settle(options);
@@ -3587,7 +3595,7 @@ var Act = class {
    * to `claim`.
    */
   _build_drain_controllers(options, lanes) {
-    const all_lanes = ["default", ...lanes.map((l) => l.name)];
+    const all_lanes = this._declared_lanes;
     const only_set = options.onlyLanes && options.onlyLanes.length > 0 ? new Set(options.onlyLanes) : void 0;
     const active_lanes = only_set ? all_lanes.filter((n) => only_set.has(n)) : all_lanes;
     const single_default_lane = lanes.length === 0;
@@ -3605,19 +3613,7 @@ var Act = class {
         on_blocked: (blocked) => this.emit("blocked", blocked),
         // Reaction-requested close: the same machinery as `app.close`.
         on_close: async (targets) => {
-          const close_actor = { id: "$close", name: "close" };
-          const result = await run_close_cycle(targets, {
-            reactive_events_size: this._reactive_events.size,
-            catch_up_correlation: (until) => this._catch_up_correlation(until),
-            event_to_state: this._event_to_state,
-            load: this._es.load,
-            tombstone: this._es.tombstone,
-            logger: this._logger,
-            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);
+          await this._run_close(targets);
         },
         breaker: this._breaker,
         run_scoped: this._scoped,
@@ -3638,12 +3634,10 @@ var Act = class {
    * controller here. One process can't check that the cluster covers every
    * lane, so it reports its own gaps.
    */
-  _advise_orphaned_lanes(options, lanes) {
+  _advise_orphaned_lanes(options) {
     if (!options.onlyLanes || options.onlyLanes.length === 0) return;
     const active = new Set(this._drain_controllers.keys());
-    const orphaned = ["default", ...lanes.map((l) => l.name)].filter(
-      (name) => !active.has(name)
-    );
+    const orphaned = this._declared_lanes.filter((name) => !active.has(name));
     if (orphaned.length === 0) return;
     const list = orphaned.map((name) => `"${name}"`).join(", ");
     this._logger.info(
@@ -3659,7 +3653,7 @@ var Act = class {
       states: this._states,
       // Declared lanes, not this process's controllers: a lane another
       // worker drains is not `unknown-lane`.
-      declared_lanes: /* @__PURE__ */ new Set(["default", ...this._lanes.map((l) => l.name)]),
+      declared_lanes: new Set(this._declared_lanes),
       routed_events: new Set(this._event_to_lanes.keys())
     };
   }
@@ -3676,10 +3670,7 @@ var Act = class {
       max_subscribed_streams: options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
       // Declared lanes (not active ones): a lane another process claims is
       // still a valid destination.
-      declared_lanes: /* @__PURE__ */ new Set([
-        "default",
-        ...this._lanes.map((l) => l.name)
-      ]),
+      declared_lanes: new Set(this._declared_lanes),
       on_init: () => {
         if (this._drain && this._reactive_events.size > 0) this._arm_all();
       },
@@ -4569,6 +4560,31 @@ var Act = class {
   async prioritize(filter, priority) {
     return this._scoped(() => store().prioritize(filter, priority));
   }
+  /**
+   * Run one close: the cycle with this Act's ports, then emit `closed`. Shared by `close()` and the drain's
+   * reaction-requested closes. The close actor lets a custom correlator
+   * still tag tenant context or trace ids.
+   */
+  async _run_close(targets) {
+    const close_actor = { id: "$close", name: "close" };
+    const result = await run_close_cycle(targets, {
+      reactive_events_size: this._reactive_events.size,
+      catch_up_correlation: (until) => catch_up_correlation(
+        this._correlate,
+        (limit) => this.correlate({ limit }),
+        until
+      ),
+      event_to_state: this._event_to_state,
+      load: this._es.load,
+      tombstone: this._es.tombstone,
+      logger: this._logger,
+      correlation: close_correlation(this._correlator, close_actor),
+      with_stream_lock: (stream, work) => this._close_lock.run(stream, work),
+      forget_subscribed: (streams) => this._correlate.forget_subscribed(streams)
+    });
+    this.emit("closed", result);
+    return result;
+  }
   /**
    * Close the books — guard, archive, truncate, and optionally restart streams.
    *
@@ -4627,69 +4643,11 @@ var Act = class {
    * ]);
    * ```
    */
-  /**
-   * After a close, forget any target whose subscription row the truncate
-   * removed, so a later correlate can re-subscribe it. Restart
-   * targets keep their row, so only fully-retired streams are forgotten.
-   */
-  /**
-   * Advance correlation until the read cursor reaches `until`, and report
-   * where it landed. Used by the close cycle's safety probe, which
-   * cannot judge a subscription's pending work over events correlate has
-   * not resolved yet.
-   *
-   * Bounded on both ends: it stops as soon as a pass makes no progress (the
-   * log has no more to give), and after {@link CLOSE_CATCH_UP_PASSES}
-   * windows, so a close behind an enormous backlog degrades to skipping the
-   * stream — the documented retryable outcome — instead of scanning the
-   * whole log inside an operator call.
-   */
-  async _catch_up_correlation(until) {
-    for (let pass = 0; pass < CLOSE_CATCH_UP_PASSES && this._correlate.checkpoint < until; pass++) {
-      const before = this._correlate.checkpoint;
-      this._correlate.arm();
-      await this.correlate({ limit: CLOSE_CATCH_UP_LIMIT });
-      if (this._correlate.checkpoint <= before) break;
-    }
-    return this._correlate.checkpoint;
-  }
-  /**
-   * Drop retired streams from correlate's in-process "already subscribed"
-   * set, so a later scan re-issues `subscribe()` for them.
-   *
-   * A tombstone seed means the stream was retired; a snapshot seed means it
-   * was restarted and is still consuming.
-   *
-   * `truncate` no longer removes the subscription row, so this is no
-   * longer repairing damage the close itself did. It still matters, because
-   * the row can disappear later: reclaiming retired subscriptions is an
-   * operator job now, and that `DELETE` can land while this process is
-   * running. Forgetting here keeps the in-process view from outliving a row
-   * an operator removed, which is a silent-no-delivery failure — a reaction whose target is named after the stream would never
-   * be re-registered.
-   */
-  _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 () => {
-      await this.correlate({ limit: 1e3 });
-      const close_actor = { id: "$close", name: "close" };
-      const result = await run_close_cycle(targets, {
-        reactive_events_size: this._reactive_events.size,
-        catch_up_correlation: (until) => this._catch_up_correlation(until),
-        event_to_state: this._event_to_state,
-        load: this._es.load,
-        tombstone: this._es.tombstone,
-        logger: this._logger,
-        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;
+      await this.correlate({ limit: CLOSE_CATCH_UP_LIMIT });
+      return this._run_close(targets);
     });
   }
   /**