@rotorsoft/act 1.31.12 → 1.31.13

package/dist/index.js

@@ -1480,13 +1480,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 +1559,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 +1609,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 +1628,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 +1709,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 +1768,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