@rotorsoft/act 0.30.0 → 0.31.0

package/dist/index.js

@@ -323,6 +323,21 @@ var InMemoryStream = class {
   get at() {
     return this._at;
   }
+  get retry() {
+    return this._retry;
+  }
+  get blocked() {
+    return this._blocked;
+  }
+  get error() {
+    return this._error;
+  }
+  get leased_by() {
+    return this._leased_by;
+  }
+  get leased_until() {
+    return this._leased_until;
+  }
   /**
    * Attempt to lease this stream for processing.
    * @param lease - The lease request.
@@ -603,6 +618,49 @@ var InMemoryStore = class {
     }
     return count;
   }
+  /**
+   * Streams registered subscription positions to the callback, ordered by
+   * stream name. Returns the highest event id in the store and the count
+   * of positions emitted.
+   */
+  async query_streams(callback, query) {
+    await sleep();
+    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 sorted = [...this._streams.values()].sort(
+      (a, b) => a.stream.localeCompare(b.stream)
+    );
+    let count = 0;
+    for (const s of sorted) {
+      if (after !== void 0 && s.stream <= after) continue;
+      if (query?.stream !== void 0) {
+        if (query.stream_exact ? s.stream !== query.stream : !streamRe.test(s.stream))
+          continue;
+      }
+      if (query?.source !== void 0) {
+        if (s.source === void 0) continue;
+        if (query.source_exact ? s.source !== query.source : !sourceRe.test(s.source))
+          continue;
+      }
+      if (blocked !== void 0 && s.blocked !== blocked) continue;
+      callback({
+        stream: s.stream,
+        source: s.source,
+        at: s.at,
+        retry: s.retry,
+        blocked: s.blocked,
+        error: s.error,
+        leased_by: s.leased_by,
+        leased_until: s.leased_until
+      });
+      count++;
+      if (count >= limit) break;
+    }
+    return { maxEventId: this._events.length - 1, count };
+  }
   /**
    * Atomically truncates streams and seeds each with a snapshot or tombstone.
    * @param targets - Streams to truncate with optional snapshot state and meta.
@@ -1622,6 +1680,46 @@ var Act = class {
       this._settle_timer = void 0;
     }
   }
+  /**
+   * Reset reaction stream watermarks and request a drain on the next
+   * `drain()` / `settle()` cycle.
+   *
+   * Use this to replay events through projections (or other reaction targets)
+   * after changing handler logic. Equivalent to calling `store().reset(streams)`
+   * directly, but also raises the orchestrator's internal "needs drain" flag —
+   * `store().reset(...)` alone leaves the flag untouched, so a settled app
+   * would short-circuit and skip the replay.
+   *
+   * Pair with `app.settle()` (or a single `app.drain()` for small streams).
+   * `settle()` loops correlate→drain until no progress is made, so one call
+   * fully catches up paginated streams without forcing callers to roll
+   * their own loop.
+   *
+   * @param streams - Reaction target streams (e.g., projection names) to reset
+   * @returns Count of streams that were actually reset
+   *
+   * @example Rebuild a projection (production)
+   * ```typescript
+   * await app.reset(["my-projection"]);
+   * app.settle({ eventLimit: 1000 });   // emits "settled" when fully replayed
+   * ```
+   *
+   * @example Rebuild a projection (tests / scripts)
+   * ```typescript
+   * await app.reset(["my-projection"]);
+   * await app.drain({ eventLimit: 1000 });   // small streams: one pass is enough
+   * ```
+   *
+   * @see {@link Store.reset} for the underlying store primitive
+   * @see {@link settle} for the debounced full-catch-up loop
+   */
+  async reset(streams) {
+    const count = await store().reset(streams);
+    if (count > 0 && this._reactive_events.size > 0) {
+      this._needs_drain = true;
+    }
+    return count;
+  }
   /**
    * Close the books — guard, archive, truncate, and optionally restart streams.
    *
@@ -1789,15 +1887,19 @@ var Act = class {
   /**
    * Debounced, non-blocking correlate→drain cycle.
    *
-   * Call this after `app.do()` to schedule a background drain. Multiple rapid
-   * calls within the debounce window are coalesced into a single cycle. Runs
-   * correlate→drain in a loop until the system reaches a consistent state,
-   * then emits the `"settled"` lifecycle event.
+   * Call this after `app.do()` (or `app.reset()`) to schedule a background
+   * drain. Multiple rapid calls within the debounce window are coalesced
+   * into a single cycle. Runs correlate→drain in a loop until a pass makes
+   * no progress — no new subscriptions, no acks, no blocks — then emits
+   * the `"settled"` lifecycle event. This means a single `settle()` call
+   * fully catches up paginated streams (e.g. after `reset()` on a long
+   * projection) without forcing callers to loop.
    *
    * @param options - Settle configuration options
    * @param options.debounceMs - Debounce window in milliseconds (default: 10)
    * @param options.correlate - Query filter for correlation scans (default: `{ after: -1, limit: 100 }`)
-   * @param options.maxPasses - Maximum correlate→drain loops (default: 1)
+   * @param options.maxPasses - Cap on correlate→drain loops (default: `Infinity`).
+   *   Early-exit on no-progress means the cap only matters in pathological cases.
    * @param options.streamLimit - Maximum streams per drain cycle (default: 10)
    * @param options.eventLimit - Maximum events per stream (default: 10)
    * @param options.leaseMillis - Lease duration in milliseconds (default: 10000)
@@ -1819,7 +1921,7 @@ var Act = class {
     const {
       debounceMs = 10,
       correlate: correlateQuery = { after: -1, limit: 100 },
-      maxPasses = 1,
+      maxPasses = Infinity,
       ...drainOptions
     } = options;
     if (this._settle_timer) clearTimeout(this._settle_timer);
@@ -1835,9 +1937,9 @@ var Act = class {
             ...correlateQuery,
             after: this._correlation_checkpoint
           });
-          if (subscribed === 0 && i > 0) break;
           lastDrain = await this.drain(drainOptions);
-          if (!lastDrain.acked.length && !lastDrain.blocked.length) break;
+          const made_progress = subscribed > 0 || lastDrain.acked.length > 0 || lastDrain.blocked.length > 0;
+          if (!made_progress) break;
         }
         if (lastDrain) this.emit("settled", lastDrain);
       })().catch((err) => logger3.error(err)).finally(() => {