@rotorsoft/act 0.20.0 → 0.22.0

package/dist/index.js

@@ -391,41 +391,58 @@ var InMemoryStore = class {
     });
   }
   /**
-   * Polls the store for unblocked streams needing processing, ordered by lease watermark ascending.
-   * @param lagging - Max number of streams to poll in ascending order.
-   * @param leading - Max number of streams to poll in descending order.
-   * @returns The polled streams.
+   * Atomically discovers and leases streams for processing.
+   * Fuses poll + lease into a single operation.
+   * @param lagging - Max streams from lagging frontier.
+   * @param leading - Max streams from leading frontier.
+   * @param by - Lease holder identifier.
+   * @param millis - Lease duration in milliseconds.
+   * @returns Granted leases.
    */
-  async poll(lagging, leading) {
+  async claim(lagging, leading, by, millis) {
     await sleep();
-    const a = [...this._streams.values()].filter((s) => s.is_avaliable).sort((a2, b2) => a2.at - b2.at).slice(0, lagging).map(({ stream, source, at }) => ({
-      stream,
-      source,
-      at,
+    const available = [...this._streams.values()].filter((s) => s.is_avaliable);
+    const lag = available.sort((a, b) => a.at - b.at).slice(0, lagging).map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      at: s.at,
       lagging: true
     }));
-    const b = [...this._streams.values()].filter((s) => s.is_avaliable).sort((a2, b2) => b2.at - a2.at).slice(0, leading).map(({ stream, source, at }) => ({
-      stream,
-      source,
-      at,
+    const lead = available.sort((a, b) => b.at - a.at).slice(0, leading).map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      at: s.at,
       lagging: false
     }));
-    return [...a, ...b];
+    const seen = /* @__PURE__ */ new Set();
+    const combined = [...lag, ...lead].filter((p) => {
+      if (seen.has(p.stream)) return false;
+      seen.add(p.stream);
+      return true;
+    });
+    return combined.map(
+      (p) => this._streams.get(p.stream)?.lease({ ...p, by, retry: 0 }, millis)
+    ).filter((l) => !!l);
   }
   /**
-   * Lease streams for processing (e.g., for distributed consumers).
-   * @param leases - Lease requests for streams, including end-of-lease watermark, lease holder, and source stream.
-   * @param leaseMilis - Lease duration in milliseconds.
-   * @returns Granted leases.
+   * Registers streams for event processing.
+   * @param streams - Streams to register with optional source.
+   * @returns subscribed count and current max watermark.
    */
-  async lease(leases, millis) {
+  async subscribe(streams) {
     await sleep();
-    return leases.map((l) => {
-      if (!this._streams.has(l.stream)) {
-        this._streams.set(l.stream, new InMemoryStream(l.stream, l.source));
+    let subscribed = 0;
+    for (const { stream, source } of streams) {
+      if (!this._streams.has(stream)) {
+        this._streams.set(stream, new InMemoryStream(stream, source));
+        subscribed++;
       }
-      return this._streams.get(l.stream)?.lease(l, millis);
-    }).filter((l) => !!l);
+    }
+    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.
@@ -509,8 +526,8 @@ function build_tracer(logLevel2) {
         );
         logger.trace(data, "\u26A1\uFE0F fetch");
       },
-      correlated: (leases) => {
-        const data = leases.map(({ stream }) => stream).join(" ");
+      correlated: (streams) => {
+        const data = streams.map(({ stream }) => stream).join(" ");
         logger.trace(`\u26A1\uFE0F correlate ${data}`);
       },
       leased: (leases) => {
@@ -712,15 +729,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();
@@ -734,6 +757,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);
   }
@@ -745,6 +772,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.
    *
@@ -1029,9 +1064,16 @@ var Act = class {
         this._drain_locked = true;
         const lagging = Math.ceil(streamLimit * this._drain_lag2lead_ratio);
         const leading = streamLimit - lagging;
-        const polled = await store().poll(lagging, leading);
+        const leased = await store().claim(
+          lagging,
+          leading,
+          randomUUID2(),
+          leaseMillis
+        );
+        if (!leased.length)
+          return { fetched: [], leased: [], acked: [], blocked: [] };
         const fetched = await Promise.all(
-          polled.map(async ({ stream, source, at, lagging: lagging2 }) => {
+          leased.map(async ({ stream, source, at, lagging: lagging2 }) => {
             const events = await this.query_array({
               stream: source,
               after: at,
@@ -1040,71 +1082,60 @@ var Act = class {
             return { stream, source, at, lagging: lagging2, events };
           })
         );
-        if (fetched.length) {
-          tracer.fetched(fetched);
-          const leases = /* @__PURE__ */ new Map();
-          const fetch_window_at = fetched.reduce(
-            (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
-            0
-          );
-          fetched.forEach(({ stream, lagging: lagging2, events }) => {
-            const payloads = events.flatMap((event) => {
-              const register = this.registry.events[event.name];
-              if (!register) return [];
-              return [...register.reactions.values()].filter((reaction) => {
-                const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
-                return resolved && resolved.target === stream;
-              }).map((reaction) => ({ ...reaction, event }));
-            });
-            leases.set(stream, {
-              lease: {
-                stream,
-                by: randomUUID2(),
-                at: events.at(-1)?.id || fetch_window_at,
-                // ff when no matching events
-                retry: 0,
-                lagging: lagging2
-              },
-              payloads
-            });
+        tracer.fetched(fetched);
+        const payloadsMap = /* @__PURE__ */ new Map();
+        const fetch_window_at = fetched.reduce(
+          (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
+          0
+        );
+        fetched.forEach(({ stream, events }) => {
+          const payloads = events.flatMap((event) => {
+            const register = this.registry.events[event.name];
+            if (!register) return [];
+            return [...register.reactions.values()].filter((reaction) => {
+              const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+              return resolved && resolved.target === stream;
+            }).map((reaction) => ({ ...reaction, event }));
           });
-          const leased = await store().lease(
-            [...leases.values()].map(({ lease }) => lease),
-            leaseMillis
-          );
-          tracer.leased(leased);
-          const handled = await Promise.all(
-            leased.map(
-              (lease) => this.handle(lease, leases.get(lease.stream).payloads)
-            )
-          );
-          const [lagging_handled, leading_handled] = handled.reduce(
-            ([lagging_handled2, leading_handled2], { lease, handled: handled2 }) => [
-              lagging_handled2 + (lease.lagging ? handled2 : 0),
-              leading_handled2 + (lease.lagging ? 0 : handled2)
-            ],
-            [0, 0]
-          );
-          const lagging_avg = lagging > 0 ? lagging_handled / lagging : 0;
-          const leading_avg = leading > 0 ? leading_handled / leading : 0;
-          const total = lagging_avg + leading_avg;
-          this._drain_lag2lead_ratio = total > 0 ? Math.max(0.2, Math.min(0.8, lagging_avg / total)) : 0.5;
-          const acked = await store().ack(
-            handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
-          );
-          if (acked.length) {
-            tracer.acked(acked);
-            this.emit("acked", acked);
-          }
-          const blocked = await store().block(
-            handled.filter(({ block }) => block).map(({ lease, error }) => ({ ...lease, error }))
-          );
-          if (blocked.length) {
-            tracer.blocked(blocked);
-            this.emit("blocked", blocked);
-          }
-          return { fetched, leased, acked, blocked };
+          payloadsMap.set(stream, payloads);
+        });
+        tracer.leased(leased);
+        const handled = await Promise.all(
+          leased.map((lease) => {
+            const streamFetch = fetched.find((f) => f.stream === lease.stream);
+            const at = streamFetch?.events.at(-1)?.id || fetch_window_at;
+            return this.handle(
+              { ...lease, at },
+              payloadsMap.get(lease.stream) || []
+            );
+          })
+        );
+        const [lagging_handled, leading_handled] = handled.reduce(
+          ([lagging_handled2, leading_handled2], { lease, handled: handled2 }) => [
+            lagging_handled2 + (lease.lagging ? handled2 : 0),
+            leading_handled2 + (lease.lagging ? 0 : handled2)
+          ],
+          [0, 0]
+        );
+        const lagging_avg = lagging > 0 ? lagging_handled / lagging : 0;
+        const leading_avg = leading > 0 ? leading_handled / leading : 0;
+        const total = lagging_avg + leading_avg;
+        this._drain_lag2lead_ratio = total > 0 ? Math.max(0.2, Math.min(0.8, lagging_avg / total)) : 0.5;
+        const acked = await store().ack(
+          handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
+        );
+        if (acked.length) {
+          tracer.acked(acked);
+          this.emit("acked", acked);
         }
+        const blocked = await store().block(
+          handled.filter(({ block }) => block).map(({ lease, error }) => ({ ...lease, error }))
+        );
+        if (blocked.length) {
+          tracer.blocked(blocked);
+          this.emit("blocked", blocked);
+        }
+        return { fetched, leased, acked, blocked };
       } catch (error) {
         logger.error(error);
       } finally {
@@ -1158,35 +1189,70 @@ 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;
-          resolved && (correlated.get(resolved.target) || correlated.set(resolved.target, []).get(resolved.target)).push({ ...reaction, source: resolved.source, event });
+    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 leases = [...correlated.entries()].map(([stream, payloads]) => ({
+      const streams = [...correlated.entries()].map(([stream, { source }]) => ({
         stream,
-        // TODO: by convention, the first defined source wins (this can be tricky)
-        source: payloads.find((p) => p.source)?.source || void 0,
-        by: randomUUID2(),
-        at: 0,
-        retry: 0,
-        lagging: true,
-        payloads
+        source
       }));
-      const leased = await store().lease(leases, 0);
-      leased.length && tracer.correlated(leased);
-      return { leased, last_id };
+      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 { leased: [], last_id };
+    return { subscribed: 0, last_id };
   }
   /**
    * Starts automatic periodic correlation worker for discovering new streams.
@@ -1246,11 +1312,9 @@ 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;
-        if (callback && result.leased.length) callback(result.leased);
+      () => this.correlate({ ...query, after: this._correlation_checkpoint, limit }).then((result) => {
+        if (callback && result.subscribed) callback(result.subscribed);
       }).catch(console.error),
       frequency
     );
@@ -1332,10 +1396,14 @@ 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 { leased } = await this.correlate(correlateQuery);
-          if (leased.length === 0 && i > 0) break;
+          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;
         }