@rotorsoft/act 1.34.1 → 1.34.3

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-5F2TQ4PT.js";
+} from "./chunk-IEM2NS6J.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -1911,32 +1911,25 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
       if (snapshot.event?.name === TOMBSTONE_EVENT)
         throw new StreamClosedError(stream);
       const expected = expectedVersion ?? (snapshot.version >= 0 ? snapshot.version : void 0);
-      if (me.given) {
-        const invariants = me.given[action2] || [];
-        invariants.forEach(({ valid: valid2, description }) => {
-          if (!valid2(snapshot.state, actor))
-            throw new InvariantError(
-              action2,
-              validated,
-              target,
-              snapshot,
-              description
-            );
-        });
-      }
-      if (me.requires) {
-        const preconditions = me.requires[action2] || [];
-        for (const { holds, description } of preconditions)
-          if (!holds(validated, snapshot.state, actor))
-            throw new InvariantError(
-              action2,
-              validated,
-              target,
-              snapshot,
-              description,
-              "precondition"
-            );
-      }
+      for (const { valid: valid2, description } of me.given?.[action2] ?? [])
+        if (!valid2(snapshot.state, actor))
+          throw new InvariantError(
+            action2,
+            validated,
+            target,
+            snapshot,
+            description
+          );
+      for (const { holds, description } of me.requires?.[action2] ?? [])
+        if (!holds(validated, snapshot.state, actor))
+          throw new InvariantError(
+            action2,
+            validated,
+            target,
+            snapshot,
+            description,
+            "precondition"
+          );
       const result = me.on[action2](validated, snapshot, target);
       if (!result) return [snapshot];
       if (Array.isArray(result) && result.length === 0) {
@@ -3561,8 +3554,9 @@ var Act = class {
    * the event), and marks their work so the next drain can claim it.
    *
    * @param query - Only `limit` is used: the most events the pass reads
-   *   (default 10). The scan always starts at the correlation checkpoint,
-   *   which every reaction shares, so filters and `after` are ignored.
+   *   (10 when the query has none; `0` reads everything). The scan always
+   *   starts at the correlation checkpoint, which every reaction shares, so
+   *   filters and `after` are ignored.
    * @returns The number of newly subscribed streams and the last scanned event id
    *
    * @example Manual correlation
@@ -3572,8 +3566,8 @@ var Act = class {
    *
    * @see {@link start_correlations} for automatic periodic correlation
    */
-  async correlate(query = { limit: 10 }) {
-    const pass = await this._correlate_pass(query);
+  async correlate(query = {}) {
+    const pass = await this._correlate_pass({ limit: query.limit ?? 10 });
     return {
       subscribed: pass.kind === "scanned" ? pass.subscribed : 0,
       last_id: pass.last_id
@@ -4230,7 +4224,7 @@ function autoclose_of(existing, state2) {
 }
 function merge_into_existing(state2, existing, states, actions, events) {
   for (const name of Object.keys(state2.actions)) {
-    if (existing.actions[name] === state2.actions[name]) continue;
+    if (existing.on[name] === state2.on[name]) continue;
     if (actions[name]) throw new Error(`Duplicate action "${name}"`);
   }
   for (const name of Object.keys(state2.events)) {
@@ -5018,13 +5012,11 @@ function action_builder(state2) {
         internal.options[action2] = options;
       }
       function given(rules) {
-        internal.given ??= {};
-        internal.given[action2] = rules;
+        (internal.given ??= {})[action2] = rules;
         return { requires, emit };
       }
       function requires(rules) {
-        internal.requires ??= {};
-        internal.requires[action2] = rules;
+        (internal.requires ??= {})[action2] = rules;
         return { emit };
       }
       function emit(handler) {