@rotorsoft/act 1.31.7 → 1.31.9

package/dist/index.js

@@ -1403,6 +1403,15 @@ function resolveFoldConfig(options) {
 
 // src/internal/correlate-cycle.ts
 import { createHash, randomUUID } from "crypto";
+
+// src/internal/report-once.ts
+function report_once(seen, key, message) {
+  if (seen.has(key)) return;
+  seen.add(key);
+  log().error(new Error(message));
+}
+
+// src/internal/correlate-cycle.ts
 var DEFAULT_COLD_START_BACK_SCAN = 1e4;
 var DEFAULT_CORRELATION_LEASE_MS = 5e3;
 var registry_key = (events) => {
@@ -1410,6 +1419,20 @@ 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) {
+  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.`
+  );
+}
+function report_lane_conflict(seen, 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.`
+  );
+}
 var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
@@ -1493,11 +1516,20 @@ var CorrelateCycle = class {
    * public option) so tests can shrink it; defaults otherwise.
    */
   _cold_start_back_scan;
+  /** Lanes a controller exists for. See {@link CorrelateCycleDeps}. */
+  _declared_lanes;
+  /**
+   * Offending declarations already reported, so a resolver firing for every
+   * matching event reports once. Owned by the instance rather than the
+   * module: `internal/` holds no module-level state.
+   */
+  _reported = /* @__PURE__ */ new Set();
   constructor({
     registry,
     static_targets,
     cd,
     max_subscribed_streams,
+    declared_lanes,
     run_scoped,
     on_init,
     on_init_async,
@@ -1508,6 +1540,7 @@ var CorrelateCycle = class {
     this._key = registry_key(registry.events);
     this._subscribed = new LruMap(max_subscribed_streams);
     this._registry = registry;
+    this._declared_lanes = declared_lanes;
     this._static_targets = static_targets;
     this._cd = cd;
     this._on_init = on_init;
@@ -1646,10 +1679,20 @@ var CorrelateCycle = class {
           for (const reaction of register.reactions.values()) {
             const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
             if (!resolved) continue;
+            let lane = resolved.lane;
+            if (lane !== void 0 && !this._declared_lanes.has(lane)) {
+              report_undeclared_lane(
+                this._reported,
+                resolved.target,
+                lane,
+                this._declared_lanes
+              );
+              lane = void 0;
+            }
             const recorded = this._subscribed.get(resolved.target);
             const priority = resolved.priority ?? 0;
             const upgraded = !recorded || priority > recorded.floor;
-            const carried = upgraded ? { priority, lane: resolved.lane } : { priority: recorded.priority, lane: recorded.lane };
+            const carried = upgraded ? { priority, lane } : { priority: recorded.priority, lane: recorded.lane };
             const entry = correlated.get(resolved.target) || {
               source: resolved.source,
               priority: carried.priority,
@@ -1657,6 +1700,9 @@ var CorrelateCycle = class {
               upgraded,
               correlated_at: void 0
             };
+            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);
             if (carried.priority > entry.priority) {
               entry.priority = carried.priority;
               entry.lane = carried.lane;
@@ -1760,7 +1806,9 @@ var CorrelateCycle = class {
         millis: 0
       });
     } catch (error) {
-      log().error(error);
+      log().warn(
+        `Could not hand back the correlation lease during shutdown; it expires on its own within ${this._lease_millis}ms and correlation resumes normally after that. On a single-writer store this usually means another connection holds the database. Cause: ${String(error)}`
+      );
     }
   }
   stop_polling() {
@@ -2536,7 +2584,14 @@ function budget_exhausted(lease, options) {
   log().error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
-async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
+function warn_misrouted(seen, stream, handler, event) {
+  report_once(
+    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) {
   const leased = await ops.claim(
     lagging,
     leading,
@@ -2557,8 +2612,18 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
       const register = registry.events[event.name];
       if (!register) return [];
       return [...register.reactions.values()].filter((reaction) => {
-        const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
-        return resolved && resolved.target === stream;
+        const resolver = reaction.resolver;
+        const dynamic = typeof resolver === "function";
+        const resolved = dynamic ? resolver(event) : resolver;
+        if (!resolved || resolved.target !== stream) return false;
+        if (!dynamic || !batch_handlers.has(stream)) return true;
+        warn_misrouted(
+          misrouted,
+          stream,
+          reaction.handler.name,
+          String(event.name)
+        );
+        return false;
       }).map((reaction) => ({ ...reaction, event }));
     });
     fetch_map.set(stream, { fetch: f, payloads });
@@ -2619,6 +2684,12 @@ var DrainController = class {
   });
   /** Worker timer (ACT-1103). Set when `start()` is active, undefined otherwise. */
   _worker;
+  /**
+   * Misroutings this controller has reported (#1563). A resolver returning a
+   * projection's target does so for every matching event; one line per event
+   * would bury the signal it exists to raise.
+   */
+  _misrouted = /* @__PURE__ */ new Set();
   _stopped = false;
   /**
    * Resolves when the cycle currently in flight finishes; `undefined` when
@@ -2735,6 +2806,7 @@ var DrainController = class {
         this._deps.ops,
         this._deps.registry,
         this._deps.batch_handlers,
+        this._misrouted,
         this._deps.handle,
         this._deps.handle_batch,
         lagging,
@@ -3500,6 +3572,14 @@ var Act = class {
       static_targets: classification.static_targets,
       cd: this._cd,
       max_subscribed_streams: options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
+      // Every lane a controller can exist for, so correlate can reroute a
+      // dynamic resolution that names one that doesn't (#1564). Declared,
+      // not active: `onlyLanes` shrinks this process's controllers, but a
+      // lane another process claims is still a valid destination.
+      declared_lanes: /* @__PURE__ */ new Set([
+        "default",
+        ...this._lanes.map((l) => l.name)
+      ]),
       on_init: () => {
         if (this._drain && this._reactive_events.size > 0) this._arm_all();
       },