@rotorsoft/act 0.26.0 → 0.27.0

package/dist/index.js

@@ -309,7 +309,7 @@ var InMemoryStream = class {
   _error = "";
   _leased_by = void 0;
   _leased_until = void 0;
-  get is_avaliable() {
+  get is_available() {
     return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date());
   }
   get at() {
@@ -376,6 +376,17 @@ var InMemoryStream = class {
       };
     }
   }
+  /**
+   * Reset this stream's watermark and state for replay.
+   */
+  reset() {
+    this._at = -1;
+    this._retry = 0;
+    this._blocked = false;
+    this._error = "";
+    this._leased_by = void 0;
+    this._leased_until = void 0;
+  }
 };
 var InMemoryStore = class {
   // stored events
@@ -503,7 +514,7 @@ var InMemoryStore = class {
   async claim(lagging, leading, by, millis) {
     await sleep();
     const available = [...this._streams.values()].filter(
-      (s) => s.is_avaliable && (s.at < 0 || this._events.some(
+      (s) => s.is_available && (s.at < 0 || this._events.some(
         (e) => e.id > s.at && e.name !== SNAP_EVENT && (!s.source || RegExp(s.source).test(e.stream))
       ))
     );
@@ -566,6 +577,24 @@ var InMemoryStore = class {
     await sleep();
     return leases.map((l) => this._streams.get(l.stream)?.block(l, l.error)).filter((l) => !!l);
   }
+  /**
+   * Reset watermarks for the given streams to -1, clearing retry, blocked,
+   * error, and lease state so they can be replayed from the beginning.
+   * @param streams - Stream names to reset.
+   * @returns Count of streams that were actually reset.
+   */
+  async reset(streams) {
+    await sleep();
+    let count = 0;
+    for (const name of streams) {
+      const s = this._streams.get(name);
+      if (s) {
+        s.reset();
+        count++;
+      }
+    }
+    return count;
+  }
 };
 
 // src/ports.ts
@@ -747,7 +776,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   if (!stream) throw new Error("Missing target stream");
   payload = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
   const snapshot = await load(me, stream);
-  const expected = expectedVersion || snapshot.event?.version;
+  const expected = expectedVersion ?? snapshot.event?.version;
   logger2.trace(
     payload,
     `\u{1F535} ${stream}.${action2}${typeof expected === "number" ? `.${expected}` : ""}`
@@ -806,7 +835,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
     );
   } catch (error) {
     if (error.name === "ERR_CONCURRENCY") {
-      void cache().invalidate(stream);
+      await cache().invalidate(stream);
     }
     throw error;
   }
@@ -1657,7 +1686,11 @@ function registerState(state2, states, actions, events) {
       patch: mergedPatch,
       on: { ...existing.on, ...state2.on },
       given: { ...existing.given, ...state2.given },
-      snap: state2.snap || existing.snap
+      snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
+        throw new Error(
+          `Duplicate snap strategy for state "${state2.name}"`
+        );
+      })() : state2.snap || existing.snap
     };
     states.set(state2.name, merged);
     for (const name of Object.keys(merged.actions)) {
@@ -1772,19 +1805,22 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
             maxRetries: options?.maxRetries ?? 3
           }
         };
-        const name = handler.name || `${String(event)}_${registry.events[event].reactions.size}`;
-        registry.events[event].reactions.set(name, reaction);
+        if (!handler.name)
+          throw new Error(
+            `Reaction handler for "${String(event)}" must be a named function`
+          );
+        registry.events[event].reactions.set(handler.name, reaction);
         return {
           ...builder,
           to(resolver) {
-            registry.events[event].reactions.set(name, {
+            registry.events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
           },
           void() {
-            registry.events[event].reactions.set(name, {
+            registry.events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: _void_
             });
@@ -1837,20 +1873,23 @@ function _projection(target, events) {
             }
           };
           const register = events[event];
-          const name = handler.name || `${event}_${register.reactions.size}`;
-          register.reactions.set(name, reaction);
+          if (!handler.name)
+            throw new Error(
+              `Projection handler for "${event}" must be a named function`
+            );
+          register.reactions.set(handler.name, reaction);
           const nextBuilder = _projection(target, events);
           return {
             ...nextBuilder,
             to(resolver) {
-              register.reactions.set(name, {
+              register.reactions.set(handler.name, {
                 ...reaction,
                 resolver: typeof resolver === "string" ? { target: resolver } : resolver
               });
               return nextBuilder;
             },
             void() {
-              register.reactions.set(name, {
+              register.reactions.set(handler.name, {
                 ...reaction,
                 resolver: _void_
               });
@@ -1917,19 +1956,22 @@ function slice(states = /* @__PURE__ */ new Map(), actions = {}, events = {}, pr
             maxRetries: options?.maxRetries ?? 3
           }
         };
-        const name = handler.name || `${String(event)}_${events[event].reactions.size}`;
-        events[event].reactions.set(name, reaction);
+        if (!handler.name)
+          throw new Error(
+            `Reaction handler for "${String(event)}" must be a named function`
+          );
+        events[event].reactions.set(handler.name, reaction);
         return {
           ...builder,
           to(resolver) {
-            events[event].reactions.set(name, {
+            events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
           },
           void() {
-            events[event].reactions.set(name, {
+            events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: _void_
             });