@rotorsoft/act 1.32.15 → 1.32.17

package/dist/index.cjs

@@ -2834,6 +2834,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]));
@@ -2855,6 +2880,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 };
 }
@@ -3013,12 +3040,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);
@@ -3319,7 +3346,7 @@ var CorrelateCycle = class {
     this._initialized = true;
   }
   async _run_init() {
-    const { watermark, correlated_at } = await store2().subscribe([
+    const { watermark, correlated_at } = await this._cd.subscribe([
       ...this._static_targets
     ]);
     this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - this._cold_start_back_scan);
@@ -4391,7 +4418,16 @@ function warn_misrouted(seen, stream, handler, event) {
     `Reaction "${handler}" on "${event}" resolved to target "${stream}", which a projection already serves. A target is served by one batch handler or one state projection, so this reaction can never run \u2014 and delivering to it would hand the projection an aggregate from another stream. Skipping it. The equivalent static \`.to({ target })\` is rejected at build; a dynamic resolver's target is only knowable here.`
   );
 }
-async function run_drain_cycle(ops, registry, batch_handlers, misrouted, store_failing, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
+async function run_drain_cycle(deps, cycle) {
+  const { ops, registry, batch_handlers, handle, handle_batch, lane } = deps;
+  const {
+    lagging,
+    leading,
+    eventLimit,
+    leaseMillis,
+    misrouted,
+    store_failing
+  } = cycle;
   const leased = await ops.claim(
     lagging,
     leading,
@@ -4463,7 +4499,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, misrouted, store_f
   const blocked = await ops.block(
     handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }))
   );
-  if (blocked.length) on_blocked(blocked);
+  if (blocked.length) deps.on_blocked(blocked);
   const submitted = handled.flatMap((h, i) => {
     const advance = h.handled > 0 ? h.acked_at : leased[i].at;
     return h.defer !== void 0 ? { ...h.lease, at: advance, due: h.defer, retry: -1 } : h.next_attempt_at !== void 0 ? { ...h.lease, at: advance, due: h.next_attempt_at } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : [];
@@ -4594,21 +4630,14 @@ var DrainController = class {
       });
       const lagging = Math.ceil(streamLimit * this._ratio);
       const leading = streamLimit - lagging;
-      const cycle = await run_drain_cycle(
-        this._deps.ops,
-        this._deps.registry,
-        this._deps.batch_handlers,
-        this._misrouted,
-        this._deps.breaker.failing,
-        this._deps.handle,
-        this._deps.handle_batch,
+      const cycle = await run_drain_cycle(this._deps, {
         lagging,
         leading,
         eventLimit,
         leaseMillis,
-        (b) => this._deps.on_blocked(b),
-        this._deps.lane
-      );
+        misrouted: this._misrouted,
+        store_failing: this._deps.breaker.failing
+      });
       if (!cycle) {
         this._deps.breaker.passed();
         this._armed = false;
@@ -4947,8 +4976,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)]);
@@ -5101,28 +5128,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;
@@ -5152,6 +5161,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;
@@ -5189,7 +5199,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);
@@ -5220,7 +5230,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;
@@ -5238,19 +5248,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,
@@ -5271,12 +5269,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(
@@ -5292,7 +5288,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())
     };
   }
@@ -5309,10 +5305,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();
       },
@@ -6202,6 +6195,31 @@ var Act = class {
   async prioritize(filter, priority) {
     return this._scoped(() => store2().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.
    *
@@ -6260,69 +6278,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);
     });
   }
   /**