@rotorsoft/act 1.31.11 → 1.31.13

package/dist/index.js

@@ -1420,18 +1420,18 @@ var registry_key = (events) => {
   return createHash("sha256").update(JSON.stringify(shape)).digest("hex").slice(0, 32);
 };
 var PATTERN_CACHE_SIZE = 32;
-function report_undeclared_lane(seen, target, lane, declared) {
+function report_undeclared_lane(seen, handler, target, lane, declared) {
   report_once(
     seen,
-    `lane|${target}|${lane}`,
-    `Reaction resolved target "${target}" onto undeclared lane "${lane}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. No controller claims it, so the stream would never drain \u2014 running it on "default" instead. The equivalent static \`.to({ lane })\` is rejected at build; a dynamic resolver's lane is only knowable here.`
+    `lane|${handler}|${lane}`,
+    `Reaction "${handler}" resolved onto undeclared lane "${lane}" \u2014 for example target "${target}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. No controller claims it, so the stream would never drain \u2014 running it on "default" instead. The equivalent static \`.to({ lane })\` is rejected at build; a dynamic resolver's lane is only knowable here.`
   );
 }
-function report_lane_conflict(seen, target, kept, dropped) {
+function report_lane_conflict(seen, handler, target, kept, dropped) {
   report_once(
     seen,
-    `conflict|${target}|${kept}|${dropped}`,
-    `Stream "${target}" has conflicting lane assignments ("${kept}" vs "${dropped}") from two dynamic resolutions at equal priority. Keeping "${kept}", the lane it was first discovered on \u2014 re-laning a live stream would move it out from under a worker holding its lease. The reaction resolving "${dropped}" runs inside the "${kept}" lane's budget, and a process restricted to "${dropped}" via onlyLanes never runs it. The equivalent static declaration is rejected at build; align the resolvers, or split the target.`
+    `conflict|${handler}|${kept}|${dropped}`,
+    `Reaction "${handler}" resolved lane "${dropped}" for a stream already on "${kept}" \u2014 for example "${target}". These are conflicting lane assignments from two dynamic resolutions at equal priority. Keeping "${kept}", the lane it was first discovered on \u2014 re-laning a live stream would move it out from under a worker holding its lease. The reaction resolving "${dropped}" runs inside the "${kept}" lane's budget, and a process restricted to "${dropped}" via onlyLanes never runs it. The equivalent static declaration is rejected at build; align the resolvers, or split the target.`
   );
 }
 var CorrelateCycle = class {
@@ -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
@@ -1684,13 +1702,14 @@ var CorrelateCycle = class {
             if (lane !== void 0 && !this._declared_lanes.has(lane)) {
               report_undeclared_lane(
                 this._reported,
+                reaction.handler.name,
                 resolved.target,
                 lane,
                 this._declared_lanes
               );
               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 };
@@ -1703,7 +1722,13 @@ var CorrelateCycle = class {
             };
             const held = correlated.has(resolved.target) ? entry.lane : recorded?.lane;
             if (held !== void 0 && lane !== void 0 && held !== lane && priority === entry.priority)
-              report_lane_conflict(this._reported, resolved.target, held, lane);
+              report_lane_conflict(
+                this._reported,
+                reaction.handler.name,
+                resolved.target,
+                held,
+                lane
+              );
             if (carried.priority > entry.priority) {
               entry.priority = carried.priority;
               entry.lane = carried.lane;
@@ -1743,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