@rotorsoft/act 1.33.5 → 1.33.7

package/dist/index.js

@@ -4298,43 +4298,59 @@ var _this_ = ({ stream }) => ({
 
 // src/builders/builder-utils.ts
 function register_lane(config2, lanes) {
+  resolveLaneConfig(config2);
   if (config2.name === DEFAULT_LANE)
     throw new Error(`Lane "${DEFAULT_LANE}" is reserved`);
-  if (lanes.some((l) => l.name === config2.name))
-    throw new Error(`Lane "${config2.name}" was already declared`);
-  lanes.push(config2);
+  const existing = lanes.find((l) => l.name === config2.name);
+  if (!existing) return void lanes.push(config2);
+  if (existing.leaseMillis !== config2.leaseMillis || existing.streamLimit !== config2.streamLimit || existing.cycleMs !== config2.cycleMs)
+    throw new Error(
+      `Lane "${config2.name}" was already declared with a different config`
+    );
+}
+function add_reaction(events, event, name, kind, make, builder) {
+  if (!name)
+    throw new Error(
+      `${kind} handler for "${String(event)}" must be a named function`
+    );
+  const label = kind === "Reaction" ? "reaction" : "projection handler";
+  if (events[event].reactions.has(name))
+    throw new Error(
+      `Duplicate ${label} "${name}" for event "${String(event)}". ${kind} handlers are keyed by function name; rename one of them.`
+    );
+  const reaction = make();
+  events[event].reactions.set(name, reaction);
+  return Object.assign(builder, {
+    to(resolver) {
+      reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
+      return builder;
+    }
+  });
 }
 function reaction_on(event, events, builder) {
-  const register = (handler, options, schedule) => {
-    if (!handler.name)
-      throw new Error(
-        `Reaction handler for "${String(event)}" must be a named function`
-      );
-    if (events[event].reactions.has(handler.name))
-      throw new Error(
-        `Duplicate reaction "${handler.name}" for event "${String(event)}". Reaction handlers are keyed by function name; rename one of them.`
-      );
-    if (schedule && typeof schedule !== "function") assert_defer_when(schedule);
-    const reaction = {
-      handler: schedule ? make_deferred(handler, schedule) : handler,
-      resolver: _this_,
-      // Validate the whole bag at the declaration site so a bad
-      // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
-      // not a NaN gate on the first retry.
-      options: resolveReactionConfig({
-        blockOnError: options?.blockOnError ?? DEFAULT_BLOCK_ON_ERROR,
-        maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
-        backoff: options?.backoff
-      })
-    };
-    events[event].reactions.set(handler.name, reaction);
-    return Object.assign(builder, {
-      to(resolver) {
-        reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-        return builder;
-      }
-    });
-  };
+  const register = (handler, options, schedule) => add_reaction(
+    events,
+    event,
+    handler.name,
+    "Reaction",
+    () => {
+      if (schedule && typeof schedule !== "function")
+        assert_defer_when(schedule);
+      return {
+        handler: schedule ? make_deferred(handler, schedule) : handler,
+        resolver: _this_,
+        // Validate the whole bag at the declaration site so a bad
+        // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
+        // not a NaN gate on the first retry.
+        options: resolveReactionConfig({
+          blockOnError: options?.blockOnError ?? DEFAULT_BLOCK_ON_ERROR,
+          maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+          backoff: options?.backoff
+        })
+      };
+    },
+    builder
+  );
   return {
     do: (handler, options) => register(handler, options),
     defer: (schedule) => ({
@@ -4653,18 +4669,7 @@ function act() {
       }
       merge_event_register(registry.events, input.events);
       pending_projections.push(...input.projections);
-      for (const slice_lane of input.lanes) {
-        const existing = lanes.find((l) => l.name === slice_lane.name);
-        if (!existing) {
-          lanes.push(slice_lane);
-          continue;
-        }
-        if (existing.leaseMillis !== slice_lane.leaseMillis || existing.streamLimit !== slice_lane.streamLimit || existing.cycleMs !== slice_lane.cycleMs) {
-          throw new Error(
-            `Lane "${slice_lane.name}" was already declared with a different config`
-          );
-        }
-      }
+      for (const lane of input.lanes) register_lane(lane, lanes);
       return builder;
     },
     withProjection: (proj) => {
@@ -4675,7 +4680,7 @@ function act() {
     withActor: () => builder,
     withLane: (config2) => {
       if (_built) closed("withLane");
-      register_lane(resolveLaneConfig(config2), lanes);
+      register_lane(config2, lanes);
       return builder;
     },
     on: (event) => {
@@ -4774,31 +4779,22 @@ function _projection(target) {
       }
       return {
         do: (handler) => {
-          const reaction = {
-            handler,
-            resolver: default_resolver ?? _this_,
-            options: {
-              blockOnError: DEFAULT_BLOCK_ON_ERROR,
-              maxRetries: DEFAULT_MAX_RETRIES
-            }
-          };
-          const register = events[event];
-          if (!handler.name)
-            throw new Error(
-              `Projection handler for "${event}" must be a named function`
-            );
-          if (register.reactions.has(handler.name))
-            throw new Error(
-              `Duplicate projection handler "${handler.name}" for event "${event}". Projection handlers are keyed by function name; rename one of them.`
-            );
-          register.reactions.set(handler.name, reaction);
           const widened = base;
-          return Object.assign(widened, {
-            to(resolver) {
-              reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-              return widened;
-            }
-          });
+          return add_reaction(
+            events,
+            event,
+            handler.name,
+            "Projection",
+            () => ({
+              handler,
+              resolver: default_resolver ?? _this_,
+              options: {
+                blockOnError: DEFAULT_BLOCK_ON_ERROR,
+                maxRetries: DEFAULT_MAX_RETRIES
+              }
+            }),
+            widened
+          );
         }
       };
     },
@@ -4897,7 +4893,7 @@ function slice() {
       return builder;
     },
     withLane: (config2) => {
-      register_lane(resolveLaneConfig(config2), lanes);
+      register_lane(config2, lanes);
       return builder;
     },
     on: (event) => reaction_on(event, events, builder),