@rotorsoft/act 1.23.23 → 1.23.25

package/dist/index.cjs

@@ -248,27 +248,6 @@ var LruMap = class {
     return this._entries.size;
   }
 };
-var LruSet = class {
-  _map;
-  constructor(maxSize) {
-    this._map = new LruMap(maxSize);
-  }
-  has(value) {
-    return this._map.has(value);
-  }
-  add(value) {
-    this._map.set(value, true);
-  }
-  delete(value) {
-    return this._map.delete(value);
-  }
-  clear() {
-    this._map.clear();
-  }
-  get size() {
-    return this._map.size;
-  }
-};
 
 // src/adapters/in-memory-cache.ts
 var InMemoryCache = class {
@@ -3055,6 +3034,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;
@@ -3096,7 +3080,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;
@@ -3136,7 +3120,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?.();
   }
@@ -3160,7 +3144,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,
@@ -3196,8 +3180,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 };
@@ -4033,6 +4017,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;
@@ -4158,9 +4156,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 };