@rotorsoft/act 0.20.0 → 0.21.0

package/dist/index.js

@@ -391,41 +391,54 @@ 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 Number of newly registered streams.
    */
-  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 count = 0;
+    for (const { stream, source } of streams) {
+      if (!this._streams.has(stream)) {
+        this._streams.set(stream, new InMemoryStream(stream, source));
+        count++;
       }
-      return this._streams.get(l.stream)?.lease(l, millis);
-    }).filter((l) => !!l);
+    }
+    return count;
   }
   /**
    * Acknowledge completion of processing for leased streams.
@@ -509,8 +522,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) => {
@@ -1029,9 +1042,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 +1060,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 {
@@ -1167,26 +1176,31 @@ var Act = class {
       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 });
+          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);
+          }
         }
       }
     }, query);
     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);
+      subscribed && tracer.correlated(streams);
+      return { subscribed, last_id };
     }
-    return { leased: [], last_id };
+    return { subscribed: 0, last_id };
   }
   /**
    * Starts automatic periodic correlation worker for discovering new streams.
@@ -1250,7 +1264,7 @@ var Act = class {
     this._correlation_timer = setInterval(
       () => this.correlate({ ...query, after, limit }).then((result) => {
         after = result.last_id;
-        if (callback && result.leased.length) callback(result.leased);
+        if (callback && result.subscribed) callback(result.subscribed);
       }).catch(console.error),
       frequency
     );
@@ -1334,8 +1348,8 @@ var Act = class {
       (async () => {
         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);
+          if (subscribed === 0 && i > 0) break;
           lastDrain = await this.drain(drainOptions);
           if (!lastDrain.acked.length && !lastDrain.blocked.length) break;
         }