@rotorsoft/act 1.31.11 → 1.31.12

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 {
@@ -1684,6 +1684,7 @@ 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
@@ -1703,7 +1704,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;