@rotorsoft/act 0.21.0 → 0.23.0

package/dist/index.js

@@ -401,7 +401,11 @@ var InMemoryStore = class {
    */
   async claim(lagging, leading, by, millis) {
     await sleep();
-    const available = [...this._streams.values()].filter((s) => s.is_avaliable);
+    const available = [...this._streams.values()].filter(
+      (s) => s.is_avaliable && (s.at < 0 || this._events.some(
+        (e) => e.id > s.at && e.name !== SNAP_EVENT && (!s.source || RegExp(s.source).test(e.stream))
+      ))
+    );
     const lag = available.sort((a, b) => a.at - b.at).slice(0, lagging).map((s) => ({
       stream: s.stream,
       source: s.source,
@@ -427,18 +431,22 @@ var InMemoryStore = class {
   /**
    * Registers streams for event processing.
    * @param streams - Streams to register with optional source.
-   * @returns Number of newly registered streams.
+   * @returns subscribed count and current max watermark.
    */
   async subscribe(streams) {
     await sleep();
-    let count = 0;
+    let subscribed = 0;
     for (const { stream, source } of streams) {
       if (!this._streams.has(stream)) {
         this._streams.set(stream, new InMemoryStream(stream, source));
-        count++;
+        subscribed++;
       }
     }
-    return count;
+    let watermark = -1;
+    for (const s of this._streams.values()) {
+      if (s.at > watermark) watermark = s.at;
+    }
+    return { subscribed, watermark };
   }
   /**
    * Acknowledge completion of processing for leased streams.
@@ -725,15 +733,21 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
 // src/act.ts
 var tracer = build_tracer(config().logLevel);
 var Act = class {
-  /**
-   * Create a new Act orchestrator.
-   *
-   * @param registry The registry of state, event, and action schemas
-   * @param states Map of state names to their (potentially merged) state definitions
-   */
   constructor(registry, _states = /* @__PURE__ */ new Map()) {
     this.registry = registry;
     this._states = _states;
+    const statics = [];
+    for (const register of Object.values(this.registry.events)) {
+      for (const reaction of register.reactions.values()) {
+        if (typeof reaction.resolver === "function") {
+          this._has_dynamic_resolvers = true;
+        } else if (reaction.resolver) {
+          const r = reaction.resolver;
+          statics.push({ stream: r.target, source: r.source });
+        }
+      }
+    }
+    this._static_targets = statics;
     dispose(() => {
       this._emitter.removeAllListeners();
       this.stop_correlations();
@@ -747,6 +761,10 @@ var Act = class {
   _correlation_timer = void 0;
   _settle_timer = void 0;
   _settling = false;
+  _correlation_checkpoint = -1;
+  _subscribed_statics = /* @__PURE__ */ new Set();
+  _has_dynamic_resolvers = false;
+  _correlation_initialized = false;
   emit(event, args) {
     return this._emitter.emit(event, args);
   }
@@ -758,6 +776,14 @@ var Act = class {
     this._emitter.off(event, listener);
     return this;
   }
+  /**
+   * Create a new Act orchestrator.
+   *
+   * @param registry The registry of state, event, and action schemas
+   * @param states Map of state names to their (potentially merged) state definitions
+   */
+  /** Static resolver targets collected at build time */
+  _static_targets;
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1167,37 +1193,67 @@ var Act = class {
    * @see {@link start_correlations} for automatic periodic correlation
    * @see {@link stop_correlations} to stop automatic correlation
    */
+  /**
+   * Initialize correlation state on first call.
+   * - Reads max(at) from store as cold-start checkpoint
+   * - Subscribes static resolver targets (idempotent upsert)
+   * - Populates the subscribed statics set
+   * @internal
+   */
+  async _init_correlation() {
+    if (this._correlation_initialized) return;
+    this._correlation_initialized = true;
+    const { watermark } = await store().subscribe(this._static_targets);
+    this._correlation_checkpoint = watermark;
+    for (const { stream } of this._static_targets) {
+      this._subscribed_statics.add(stream);
+    }
+  }
   async correlate(query = { after: -1, limit: 10 }) {
+    await this._init_correlation();
+    if (!this._has_dynamic_resolvers)
+      return { subscribed: 0, last_id: this._correlation_checkpoint };
+    const after = Math.max(this._correlation_checkpoint, query.after || -1);
     const correlated = /* @__PURE__ */ new Map();
-    let last_id = query.after || -1;
-    await store().query((event) => {
-      last_id = event.id;
-      const register = this.registry.events[event.name];
-      if (register) {
-        for (const reaction of register.reactions.values()) {
-          const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
-          if (resolved) {
-            const entry = correlated.get(resolved.target) || {
-              source: resolved.source,
-              payloads: []
-            };
-            entry.payloads.push({
-              ...reaction,
-              source: resolved.source,
-              event
-            });
-            correlated.set(resolved.target, entry);
+    let last_id = after;
+    await store().query(
+      (event) => {
+        last_id = event.id;
+        const register = this.registry.events[event.name];
+        if (register) {
+          for (const reaction of register.reactions.values()) {
+            if (typeof reaction.resolver !== "function") continue;
+            const resolved = reaction.resolver(event);
+            if (resolved && !this._subscribed_statics.has(resolved.target)) {
+              const entry = correlated.get(resolved.target) || {
+                source: resolved.source,
+                payloads: []
+              };
+              entry.payloads.push({
+                ...reaction,
+                source: resolved.source,
+                event
+              });
+              correlated.set(resolved.target, entry);
+            }
           }
         }
-      }
-    }, query);
+      },
+      { ...query, after }
+    );
+    this._correlation_checkpoint = last_id;
     if (correlated.size) {
       const streams = [...correlated.entries()].map(([stream, { source }]) => ({
         stream,
         source
       }));
-      const subscribed = await store().subscribe(streams);
-      subscribed && tracer.correlated(streams);
+      const { subscribed } = await store().subscribe(streams);
+      if (subscribed) {
+        tracer.correlated(streams);
+        for (const { stream } of streams) {
+          this._subscribed_statics.add(stream);
+        }
+      }
       return { subscribed, last_id };
     }
     return { subscribed: 0, last_id };
@@ -1260,10 +1316,8 @@ var Act = class {
   start_correlations(query = {}, frequency = 1e4, callback) {
     if (this._correlation_timer) return false;
     const limit = query.limit || 100;
-    let after = query.after || -1;
     this._correlation_timer = setInterval(
-      () => this.correlate({ ...query, after, limit }).then((result) => {
-        after = result.last_id;
+      () => this.correlate({ ...query, after: this._correlation_checkpoint, limit }).then((result) => {
         if (callback && result.subscribed) callback(result.subscribed);
       }).catch(console.error),
       frequency
@@ -1346,9 +1400,13 @@ var Act = class {
       if (this._settling) return;
       this._settling = true;
       (async () => {
+        await this._init_correlation();
         let lastDrain;
         for (let i = 0; i < maxPasses; i++) {
-          const { subscribed } = await this.correlate(correlateQuery);
+          const { subscribed } = await this.correlate({
+            ...correlateQuery,
+            after: this._correlation_checkpoint
+          });
           if (subscribed === 0 && i > 0) break;
           lastDrain = await this.drain(drainOptions);
           if (!lastDrain.acked.length && !lastDrain.blocked.length) break;