@rotorsoft/act 0.39.0 → 0.41.0

package/dist/index.cjs

@@ -190,7 +190,7 @@ var ConsoleLogger = class _ConsoleLogger {
   }
 };
 
-// src/lru-map.ts
+// src/internal/lru-map.ts
 var LruMap = class {
   constructor(_maxSize) {
     this._maxSize = _maxSize;
@@ -644,7 +644,7 @@ var InMemoryStore = class {
     if (query.stream) {
       if (query.stream_exact) {
         if (e.stream !== query.stream) return false;
-      } else if (!RegExp(`^${query.stream}$`).test(e.stream)) return false;
+      } else if (!RegExp(query.stream).test(e.stream)) return false;
     }
     if (query.names && !query.names.includes(e.name)) return false;
     if (query.correlation && e.meta?.correlation !== query.correlation)
@@ -860,8 +860,8 @@ var InMemoryStore = class {
    */
   async prioritize(filter, priority) {
     await sleep();
-    const streamRe = filter.stream && !filter.stream_exact ? new RegExp(`^${filter.stream}$`) : void 0;
-    const sourceRe = filter.source && !filter.source_exact ? new RegExp(`^${filter.source}$`) : void 0;
+    const streamRe = filter.stream && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
+    const sourceRe = filter.source && !filter.source_exact ? new RegExp(filter.source) : void 0;
     let count = 0;
     for (const s of this._streams.values()) {
       if (filter.stream !== void 0) {
@@ -892,8 +892,8 @@ var InMemoryStore = class {
     const limit = query?.limit ?? 100;
     const after = query?.after;
     const blocked = query?.blocked;
-    const streamRe = query?.stream && !query.stream_exact ? new RegExp(`^${query.stream}$`) : void 0;
-    const sourceRe = query?.source && !query.source_exact ? new RegExp(`^${query.source}$`) : void 0;
+    const streamRe = query?.stream && !query.stream_exact ? new RegExp(query.stream) : void 0;
+    const sourceRe = query?.source && !query.source_exact ? new RegExp(query.source) : void 0;
     const sorted = [...this._streams.values()].sort(
       (a, b) => a.stream.localeCompare(b.stream)
     );
@@ -1387,10 +1387,20 @@ function computeLagLeadRatio(handled, lagging, leading) {
 }
 
 // src/internal/drain-cycle.ts
-async function runDrainCycle(ops, registry, batchHandlers, handle, handleBatch, lagging, leading, eventLimit, leaseMillis) {
+async function runDrainCycle(ops, registry, batchHandlers, handle, handleBatch, lagging, leading, eventLimit, leaseMillis, isDeferred) {
   const leased = await ops.claim(lagging, leading, (0, import_node_crypto2.randomUUID)(), leaseMillis);
   if (!leased.length) return void 0;
-  const fetched = await ops.fetch(leased, eventLimit);
+  const active = isDeferred ? leased.filter((l) => !isDeferred(l.stream)) : leased;
+  if (!active.length) {
+    return {
+      leased,
+      fetched: [],
+      handled: [],
+      acked: [],
+      blocked: []
+    };
+  }
+  const fetched = await ops.fetch(active, eventLimit);
   const fetchMap = /* @__PURE__ */ new Map();
   const fetch_window_at = fetched.reduce(
     (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
@@ -1409,7 +1419,7 @@ async function runDrainCycle(ops, registry, batchHandlers, handle, handleBatch,
     fetchMap.set(stream, { fetch: f, payloads });
   }
   const handled = await Promise.all(
-    leased.map((lease) => {
+    active.map((lease) => {
       const entry = fetchMap.get(lease.stream);
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
@@ -1441,6 +1451,15 @@ var DrainController = class {
   _armed = false;
   _locked = false;
   _ratio = 0.5;
+  /**
+   * Per-stream backoff: `stream → nextAttemptAt` (ms since epoch). Set by
+   * `_finalize` via `HandleResult.nextAttemptAt`; cleared on successful
+   * ack or terminal block. Lives in process memory — per-worker pacing
+   * by design (see {@link BackoffOptions} for the multi-worker trade-off).
+   */
+  _backoff = /* @__PURE__ */ new Map();
+  /** Timer re-arming drain at the earliest pending `nextAttemptAt`. */
+  _backoffTimer;
   /**
    * Signal that a commit (or reset / cold-start) may have produced work.
    * Subsequent `drain()` calls will run the pipeline; once the pipeline
@@ -1453,6 +1472,32 @@ var DrainController = class {
   get armed() {
     return this._armed;
   }
+  /** Returns true when `stream` is currently within a backoff window. */
+  isDeferred = (stream) => {
+    const next = this._backoff.get(stream);
+    return next !== void 0 && next > Date.now();
+  };
+  /**
+   * Schedule the next drain re-arm at the earliest pending backoff
+   * expiry. Called only when the backoff map is non-empty (caller guard).
+   * Idempotent — collapses many simultaneously deferred streams into a
+   * single timer.
+   */
+  scheduleBackoffWake() {
+    if (this._backoffTimer) clearTimeout(this._backoffTimer);
+    let earliest = Number.POSITIVE_INFINITY;
+    for (const t of this._backoff.values()) if (t < earliest) earliest = t;
+    const delay = Math.max(0, earliest - Date.now());
+    this._backoffTimer = setTimeout(() => {
+      this._backoffTimer = void 0;
+      const now = Date.now();
+      for (const [stream, at] of this._backoff) {
+        if (at <= now) this._backoff.delete(stream);
+      }
+      this._armed = true;
+    }, delay);
+    this._backoffTimer.unref();
+  }
   /** Run one drain pass. Short-circuits when not armed or already running. */
   async drain({
     streamLimit = 10,
@@ -1474,7 +1519,8 @@ var DrainController = class {
         lagging,
         leading,
         eventLimit,
-        leaseMillis
+        leaseMillis,
+        this._backoff.size > 0 ? this.isDeferred : void 0
       );
       if (!cycle) {
         this._armed = false;
@@ -1482,6 +1528,14 @@ var DrainController = class {
       }
       const { leased, fetched, handled, acked, blocked } = cycle;
       this._ratio = computeLagLeadRatio(handled, lagging, leading);
+      for (const lease of acked) this._backoff.delete(lease.stream);
+      for (const lease of blocked) this._backoff.delete(lease.stream);
+      for (const h of handled) {
+        if (h.nextAttemptAt !== void 0 && !h.block) {
+          this._backoff.set(h.lease.stream, h.nextAttemptAt);
+        }
+      }
+      if (this._backoff.size > 0) this.scheduleBackoffWake();
       if (acked.length) this.deps.onAcked(acked);
       if (blocked.length) this.deps.onBlocked(blocked);
       const hasErrors = handled.some(({ error }) => error);
@@ -1676,6 +1730,27 @@ var _this_ = ({ stream }) => ({
   target: stream
 });
 
+// src/internal/backoff.ts
+function computeBackoffDelay(retry, opts) {
+  if (!opts || opts.baseMs <= 0) return 0;
+  const r = Math.max(0, retry);
+  let delay;
+  switch (opts.strategy) {
+    case "fixed":
+      delay = opts.baseMs;
+      break;
+    case "linear":
+      delay = opts.baseMs * (r + 1);
+      break;
+    case "exponential":
+      delay = opts.baseMs * 2 ** r;
+      if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
+      break;
+  }
+  if (opts.jitter) delay = delay * (0.5 + Math.random());
+  return Math.max(0, Math.floor(delay));
+}
+
 // src/internal/reactions.ts
 function finalize(lease, handled, at, error, options, logger) {
   if (!error) return { lease, handled, at };
@@ -1683,12 +1758,14 @@ function finalize(lease, handled, at, error, options, logger) {
   const block2 = lease.retry >= options.maxRetries && options.blockOnError;
   if (block2)
     logger.error(`Blocking ${lease.stream} after ${lease.retry} retries.`);
+  const nextAttemptAt = !block2 && options.backoff ? Date.now() + computeBackoffDelay(lease.retry, options.backoff) : void 0;
   return {
     lease,
     handled,
     at,
     error: handled === 0 ? error.message : void 0,
-    block: block2
+    block: block2,
+    nextAttemptAt
   };
 }
 function buildHandle(deps) {
@@ -3008,7 +3085,8 @@ function act() {
           resolver: _this_,
           options: {
             blockOnError: options?.blockOnError ?? true,
-            maxRetries: options?.maxRetries ?? 3
+            maxRetries: options?.maxRetries ?? 3,
+            backoff: options?.backoff
           }
         };
         if (!handler.name)
@@ -3134,7 +3212,8 @@ function slice() {
           resolver: _this_,
           options: {
             blockOnError: options?.blockOnError ?? true,
-            maxRetries: options?.maxRetries ?? 3
+            maxRetries: options?.maxRetries ?? 3,
+            backoff: options?.backoff
           }
         };
         if (!handler.name)