@rotorsoft/act 1.23.23 → 1.23.25

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   ExitCodes,
   InMemoryCache,
   InMemoryStore,
-  LruSet,
+  LruMap,
   PackageSchema,
   SNAP_EVENT,
   TOMBSTONE_EVENT,
@@ -20,7 +20,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-4JK4QJIT.js";
+} from "./chunk-ORKHOSH2.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -1512,6 +1512,11 @@ var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
   _timer = void 0;
+  // target → the priority it was last subscribed at. A dynamic target is
+  // re-subscribed (so the store's `GREATEST` upsert runs) only when a later
+  // scan resolves a *higher* priority for it — the runtime `max()` invariant
+  // (#1363). Static targets are recorded at +Infinity so a dynamic resolution
+  // never re-opens them (their priority is owned by the build-time subscribe).
   _subscribed;
   _registry;
   _static_targets;
@@ -1553,7 +1558,7 @@ var CorrelateCycle = class {
     on_init_async,
     cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN
   }) {
-    this._subscribed = new LruSet(max_subscribed_streams);
+    this._subscribed = new LruMap(max_subscribed_streams);
     this._registry = registry;
     this._static_targets = static_targets;
     this._has_dynamic_resolvers = has_dynamic_resolvers;
@@ -1593,7 +1598,7 @@ var CorrelateCycle = class {
     this._checkpoint = this._has_dynamic_resolvers ? Math.max(-1, watermark - this._cold_start_back_scan) : watermark;
     this._on_init?.();
     for (const { stream } of this._static_targets) {
-      this._subscribed.add(stream);
+      this._subscribed.set(stream, Number.POSITIVE_INFINITY);
     }
     await this._on_init_async?.();
   }
@@ -1617,7 +1622,7 @@ var CorrelateCycle = class {
           for (const reaction of register.reactions.values()) {
             if (typeof reaction.resolver !== "function") continue;
             const resolved = reaction.resolver(event);
-            if (resolved && !this._subscribed.has(resolved.target)) {
+            if (resolved && (resolved.priority ?? 0) > (this._subscribed.get(resolved.target) ?? Number.NEGATIVE_INFINITY)) {
               const incoming_priority = resolved.priority ?? 0;
               const entry = correlated.get(resolved.target) || {
                 source: resolved.source,
@@ -1653,8 +1658,8 @@ var CorrelateCycle = class {
       const { subscribed } = await this._cd.subscribe(streams);
       this._checkpoint = last_id;
       if (subscribed) {
-        for (const { stream } of streams) {
-          this._subscribed.add(stream);
+        for (const { stream, priority } of streams) {
+          this._subscribed.set(stream, priority);
         }
       }
       return { subscribed, last_id };
@@ -2490,6 +2495,20 @@ var EMPTY_DRAIN = {
   acked: [],
   blocked: []
 };
+var contain = (logger, sink, fn) => {
+  try {
+    fn();
+  } catch (error) {
+    logger.error(error, `${sink} listener threw`);
+  }
+};
+var contain_async = async (logger, sink, fn) => {
+  try {
+    await fn();
+  } catch (error) {
+    logger.error(error, `${sink} listener threw`);
+  }
+};
 var DrainController = class {
   _armed = false;
   _locked = false;
@@ -2615,9 +2634,20 @@ var DrainController = class {
         if (next !== void 0) this._defer.set(h.lease.stream, next);
       }
       if (this._defer.size > 0) this._defer.schedule();
-      if (acked.length) this._deps.on_acked(acked);
-      if (blocked.length) this._deps.on_blocked(blocked);
-      if (closeable.length) await this._deps.on_close(closeable);
+      if (acked.length)
+        contain(this._deps.logger, "acked", () => this._deps.on_acked(acked));
+      if (blocked.length)
+        contain(
+          this._deps.logger,
+          "blocked",
+          () => this._deps.on_blocked(blocked)
+        );
+      if (closeable.length)
+        await contain_async(
+          this._deps.logger,
+          "close",
+          () => this._deps.on_close(closeable)
+        );
       const has_errors = handled.some(({ error }) => error);
       if (!acked.length && !blocked.length && !has_errors) this._armed = false;
       return { fetched, leased, acked, blocked };