@rotorsoft/act 0.42.0 → 0.44.0

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-M5YFKVRV.js";
+} from "./chunk-LKRNWD7C.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -29,12 +29,13 @@ import {
   EventMetaSchema,
   InvariantError,
   LogLevels,
+  NonRetryableError,
   QuerySchema,
   StreamClosedError,
   TargetSchema,
   ValidationError,
   ZodEmpty
-} from "./chunk-AGWZY6YT.js";
+} from "./chunk-VMX7RPTC.js";
 import "./chunk-5WRI5ZAA.js";
 
 // src/signals.ts
@@ -132,24 +133,18 @@ async function runCloseCycle(targets, deps) {
   return { truncated, skipped };
 }
 async function scanStreamHeads(streams) {
+  const stats = await store().query_stats(streams, {
+    exclude: [SNAP_EVENT]
+  });
   const out = /* @__PURE__ */ new Map();
-  await Promise.all(
-    streams.map(async (s) => {
-      let maxId = -1;
-      let version = -1;
-      let lastEventName = "";
-      await store().query(
-        (e) => {
-          if (e.name === TOMBSTONE_EVENT || maxId !== -1) return;
-          maxId = e.id;
-          version = e.version;
-          lastEventName = e.name;
-        },
-        { stream: s, stream_exact: true, backward: true, limit: 1 }
-      );
-      if (maxId >= 0) out.set(s, { maxId, version, lastEventName });
-    })
-  );
+  for (const [stream, { head }] of stats) {
+    if (head.name === TOMBSTONE_EVENT) continue;
+    out.set(stream, {
+      maxId: head.id,
+      version: head.version,
+      lastEventName: head.name
+    });
+  }
   return out;
 }
 async function partitionBySafety(streamInfo, reactiveEventsSize, skipped) {
@@ -782,9 +777,12 @@ function computeBackoffDelay(retry, opts) {
 function finalize(lease, handled, at, error, options, logger) {
   if (!error) return { lease, handled, at };
   logger.error(error);
-  const block2 = lease.retry >= options.maxRetries && options.blockOnError;
+  const nonRetryable = error instanceof NonRetryableError;
+  const block2 = options.blockOnError && (nonRetryable || lease.retry >= options.maxRetries);
   if (block2)
-    logger.error(`Blocking ${lease.stream} after ${lease.retry} retries.`);
+    logger.error(
+      nonRetryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
+    );
   const nextAttemptAt = !block2 && options.backoff ? Date.now() + computeBackoffDelay(lease.retry, options.backoff) : void 0;
   return {
     lease,
@@ -1924,13 +1922,81 @@ var Act = class {
    * @see {@link Store.reset} for the underlying store primitive
    * @see {@link settle} for the debounced full-catch-up loop
    */
-  async reset(streams) {
+  async reset(input) {
+    return this._scoped(async () => {
+      const count = await store().reset(input);
+      if (count > 0 && this._reactive_events.size > 0) this._drain.arm();
+      return count;
+    });
+  }
+  /**
+   * Clear the blocked flag on streams without replaying their history.
+   *
+   * Use this to recover from a poison message after fixing the
+   * underlying issue — the stream resumes from the next event after the
+   * last successful ack, not from the beginning. Compare with
+   * {@link reset}, which rebuilds from event 0 (suitable for projection
+   * rebuilds, wrong for "I fixed the bug, please retry").
+   *
+   * Wraps `store().unblock(streams)` and raises the orchestrator's
+   * internal "needs drain" flag so a settled app picks up the now-free
+   * streams on the next cycle. Equivalent to calling `store().unblock(...)`
+   * directly, but `store().unblock(...)` alone leaves the flag
+   * untouched.
+   *
+   * @param streams - Stream names to unblock
+   * @returns Count of streams that were actually flipped (were blocked)
+   *
+   * @example Recover from a 4xx webhook after fixing the bug
+   * ```typescript
+   * await app.unblock(["webhooks-out-customer-42"]);
+   * // The stream resumes from the next event, not from zero.
+   * ```
+   *
+   * @see {@link Store.unblock} for the underlying store primitive
+   * @see {@link reset} for the rebuild-from-zero alternative
+   */
+  async unblock(input) {
     return this._scoped(async () => {
-      const count = await store().reset(streams);
+      const count = await store().unblock(input);
       if (count > 0 && this._reactive_events.size > 0) this._drain.arm();
       return count;
     });
   }
+  /**
+   * Return every currently-blocked stream position. Convenience wrapper
+   * around `store().query_streams(cb, { blocked: true })` for the common
+   * "show me what's broken" operational query.
+   *
+   * Results are ordered by stream name, paginated by `limit` (default
+   * 100). Pass `after` to fetch the next page (keyset cursor on the
+   * stream name). For richer queries — including blocked + source
+   * filters, or full unblocked introspection — drop to
+   * `store().query_streams(...)` directly.
+   *
+   * @returns Array of {@link StreamPosition} for currently-blocked streams.
+   *
+   * @example Discover and recover
+   * ```typescript
+   * const blocked = await app.blocked_streams();
+   * console.table(blocked.map(({ stream, retry, error }) => ({ stream, retry, error })));
+   *
+   * // Operator investigates, then bulk-unblocks the family:
+   * await app.unblock({ stream: "^webhooks-out-" });
+   * ```
+   */
+  async blocked_streams(options) {
+    return this._scoped(async () => {
+      const positions = [];
+      await store().query_streams(
+        (p) => {
+          positions.push(p);
+        },
+        { blocked: true, after: options?.after, limit: options?.limit }
+      );
+      return positions;
+    });
+  }
   /**
    * Bulk-update scheduling priority for streams matching `filter`.
    *
@@ -2386,6 +2452,7 @@ export {
   InMemoryStore,
   InvariantError,
   LogLevels,
+  NonRetryableError,
   PackageSchema,
   QuerySchema,
   SNAP_EVENT,