@rotorsoft/act 1.31.12 → 1.31.14

package/dist/index.js

@@ -916,6 +916,15 @@ var CircuitBreaker = class {
     this._cooldown_ms = config2.cooldownMs;
     this._hooks = hooks;
   }
+  /**
+   * True when the store has failed at least once since the last pass that
+   * went all the way through. The breaker can still read "closed" here: it
+   * only opens after several failures in a row, so this catches the first
+   * one, which `state()` cannot.
+   */
+  get failing() {
+    return this._failures > 0;
+  }
   /** Current state given the wall-clock `now`. */
   state(now) {
     if (this._opened_at === void 0) return "closed";
@@ -1480,13 +1489,33 @@ var CorrelateCycle = class {
   /** In-flight init, memoized for single-flight and cleared on failure. */
   _init_promise;
   _timer = void 0;
-  // target → what it was last subscribed at. Every scan re-subscribes the
+  // Dynamically discovered targets → what each was last subscribed at,
+  // bounded by `maxSubscribedStreams`. The static half lives in
+  // `_static_subscriptions` below, which is deliberately not evictable.
+  //
+  // Every scan re-subscribes the
   // targets it resolved (that is how the work mark lands), so this no longer
   // decides *whether* a target is sent — it decides *what* is sent with it:
   // a resolution raises priority/lane only when it beats the recorded floor,
   // and otherwise re-sends the row's own values so the mark changes nothing
   // else. See {@link Subscription}.
-  _subscribed;
+  _dynamic_subscriptions;
+  /**
+   * What each static target was subscribed at by `init`. A plain map, never
+   * evicted: the collection is the build-time `_static_targets` list, so it
+   * is already bounded by the registry and costs nothing the registry does
+   * not already hold.
+   *
+   * Keeping these out of the LRU is what makes the `+Infinity` floor an
+   * invariant rather than a race (#1582). Sharing the bounded map meant a
+   * churn of dynamic targets could evict a static record, and the next
+   * dynamic resolution to that target found no record, took the
+   * first-discovery branch, and re-subscribed the target with its own
+   * priority and lane — silently re-laning a stream whose lane the
+   * build-time subscribe owns, and starving it wherever `onlyLanes` had
+   * provisioned a worker for the declared lane.
+   */
+  _static_subscriptions = /* @__PURE__ */ new Map();
   /** Compiled pattern sources, bounded by {@link PATTERN_CACHE_SIZE}. */
   _patterns = new LruMap(PATTERN_CACHE_SIZE);
   _registry;
@@ -1539,7 +1568,7 @@ var CorrelateCycle = class {
   }) {
     this._lease_millis = lease_millis;
     this._key = registry_key(registry.events);
-    this._subscribed = new LruMap(max_subscribed_streams);
+    this._dynamic_subscriptions = new LruMap(max_subscribed_streams);
     this._registry = registry;
     this._declared_lanes = declared_lanes;
     this._static_targets = static_targets;
@@ -1589,7 +1618,7 @@ var CorrelateCycle = class {
     this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - this._cold_start_back_scan);
     this._on_init?.();
     for (const { stream, priority = 0, lane } of this._static_targets) {
-      this._subscribed.set(stream, {
+      this._static_subscriptions.set(stream, {
         floor: Number.POSITIVE_INFINITY,
         priority,
         lane
@@ -1608,14 +1637,12 @@ var CorrelateCycle = class {
    * the documented per-aggregate shape `.to(e => ({target: e.stream}))`
    * makes those two namespaces collide by construction (#1398).
    *
-   * Static targets are left alone: they are subscribed once at init and
-   * recorded at +Infinity so the dynamic path never re-opens them.
+   * Static targets are left alone: their record lives in
+   * `_static_subscriptions`, which this never touches, so they stay pinned
+   * at +Infinity and the dynamic path never re-opens them.
    */
   forget_subscribed(streams) {
-    const statics = new Set(this._static_targets.map((t) => t.stream));
-    for (const stream of streams) {
-      if (!statics.has(stream)) this._subscribed.delete(stream);
-    }
+    for (const stream of streams) this._dynamic_subscriptions.delete(stream);
   }
   /**
    * Would an event from `stream` be fetched for a target subscribed with
@@ -1691,7 +1718,7 @@ var CorrelateCycle = class {
               );
               lane = void 0;
             }
-            const recorded = this._subscribed.get(resolved.target);
+            const recorded = this._static_subscriptions.get(resolved.target) ?? this._dynamic_subscriptions.get(resolved.target);
             const priority = resolved.priority ?? 0;
             const upgraded = !recorded || priority > recorded.floor;
             const carried = upgraded ? { priority, lane } : { priority: recorded.priority, lane: recorded.lane };
@@ -1750,7 +1777,7 @@ var CorrelateCycle = class {
       this._checkpoint = last_id;
       for (const { stream, priority, lane } of streams) {
         if (correlated.get(stream)?.upgraded)
-          this._subscribed.set(stream, {
+          this._dynamic_subscriptions.set(stream, {
             floor: priority,
             priority,
             lane
@@ -2605,10 +2632,10 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 }
 
 // src/internal/drain-cycle.ts
-function budget_exhausted(lease, options) {
-  if (!options?.blockOnError || lease.retry <= options.maxRetries)
+function budget_exhausted(lease, options, store_failing) {
+  if (store_failing || !options?.blockOnError || lease.retry <= options.maxRetries)
     return void 0;
-  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the lease was lost on every attempt, so the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. Raise leaseMillis for this handler, then unblock the stream.`;
+  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. That means every attempt lost its lease before it could ack: raise leaseMillis for this handler, then unblock the stream.`;
   log().error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
@@ -2619,7 +2646,7 @@ 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, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
+async function run_drain_cycle(ops, registry, batch_handlers, misrouted, store_failing, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
   const leased = await ops.claim(
     lagging,
     leading,
@@ -2661,7 +2688,11 @@ async function run_drain_cycle(ops, registry, batch_handlers, misrouted, handle,
       const entry = fetch_map.get(lease.stream);
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
-      const exhausted = budget_exhausted(lease, payloads[0]?.options);
+      const exhausted = budget_exhausted(
+        lease,
+        payloads[0]?.options,
+        store_failing
+      );
       if (exhausted) return Promise.resolve(exhausted);
       const batchHandler = batch_handlers.get(lease.stream);
       if (batchHandler && payloads.length > 0) {
@@ -2833,6 +2864,7 @@ var DrainController = class {
         this._deps.registry,
         this._deps.batch_handlers,
         this._misrouted,
+        this._deps.breaker.failing,
         this._deps.handle,
         this._deps.handle_batch,
         lagging,