@rotorsoft/act 1.32.21 → 1.32.23

package/dist/index.cjs

@@ -641,8 +641,7 @@ var InMemoryStream = class {
   // in-process backoff, this is durable store state shared across workers.
   _deferred_at = void 0;
   // Work mark: highest event id observed to resolve to this target.
-  // `undefined` means UNKNOWN — the row predates the mark, so `claim` falls
-  // back to the legacy has-work probe rather than treating it as "no work".
+  // `undefined` means the row was never correlated, so `claim` skips it.
   _correlated_at = void 0;
   constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
     this.stream = stream;
@@ -845,12 +844,6 @@ var InMemoryStore = class {
   _correlators = /* @__PURE__ */ new Map();
   // last committed version per stream — O(1) replacement for filter-on-commit
   _stream_versions = /* @__PURE__ */ new Map();
-  // max non-snapshot event id per stream — drives the has-work probe in
-  // claim(): an O(1) lookup for a literal source, and the per-stream max
-  // that a pattern source scans, without touching the full event log.
-  _max_event_id_by_stream = /* @__PURE__ */ new Map();
-  // global max non-snapshot event id — fast pre-check for source-less streams in claim()
-  _max_non_snap_event_id = -1;
   // stream → (event_id → cloned sensitive payload). Two-level so `forget_pii`
   // is O(1) — drop the inner Map for the stream and the wipe is done — mirroring
   // the `DELETE WHERE stream = ?` scope that durable adapters get from their
@@ -862,10 +855,17 @@ var InMemoryStore = class {
     this._next_id = 0;
     this._correlated_at = -1;
     this._stream_versions.clear();
-    this._max_event_id_by_stream.clear();
-    this._max_non_snap_event_id = -1;
     this._pii.clear();
   }
+  // Stores a cloned copy, so caller-side mutation can't reach it.
+  _put_pii(stream, id, pii) {
+    let per_stream = this._pii.get(stream);
+    if (!per_stream) {
+      per_stream = /* @__PURE__ */ new Map();
+      this._pii.set(stream, per_stream);
+    }
+    per_stream.set(id, structuredClone(pii));
+  }
   // First index whose event id is greater than `after`. `_events` stays
   // sorted ascending by id (append-only commits; deletions preserve
   // order), so id-bounded scans binary-search their start instead of
@@ -985,7 +985,6 @@ var InMemoryStore = class {
       );
     }
     let version = current_version + 1;
-    let last_non_snap_id = -1;
     const committed = msgs.map(({ name, data, pii }) => {
       const c = {
         id: this._next_id++,
@@ -997,23 +996,11 @@ var InMemoryStore = class {
         meta
       };
       this._events.push(c);
-      if (pii != null) {
-        let per_stream = this._pii.get(stream);
-        if (!per_stream) {
-          per_stream = /* @__PURE__ */ new Map();
-          this._pii.set(stream, per_stream);
-        }
-        per_stream.set(c.id, structuredClone(pii));
-      }
-      if (name !== SNAP_EVENT) last_non_snap_id = c.id;
+      if (pii != null) this._put_pii(stream, c.id, pii);
       version++;
       return this._with_pii(c);
     });
     this._stream_versions.set(stream, version - 1);
-    if (last_non_snap_id >= 0) {
-      this._max_event_id_by_stream.set(stream, last_non_snap_id);
-      this._max_non_snap_event_id = last_non_snap_id;
-    }
     return committed;
   }
   /**
@@ -1155,25 +1142,19 @@ var InMemoryStore = class {
    */
   async defer(input, deferred_at) {
     await sleep();
-    let count = 0;
-    if (Array.isArray(input)) {
-      for (const name of new Set(input)) {
-        const s = this._streams.get(name);
-        if (s) {
-          s.defer(deferred_at);
-          count++;
-        }
-      }
-    } else {
-      const matches = this._filter_predicate(input);
-      for (const s of this._streams.values()) {
-        if (matches(s)) {
-          s.defer(deferred_at);
-          count++;
-        }
-      }
-    }
-    return count;
+    const selected = this._select(input);
+    for (const s of selected) s.defer(deferred_at);
+    return selected.length;
+  }
+  /**
+   * The streams named by `input`: an explicit list (de-duplicated, so a
+   * repeated name counts once, matching the SQL adapters' set-based
+   * `stream = ANY(...)`; unknown names are skipped) or a {@link StreamFilter}.
+   */
+  _select(input) {
+    if (Array.isArray(input))
+      return [...new Set(input)].map((name) => this._streams.get(name)).filter((s) => s !== void 0);
+    return [...this._streams.values()].filter(this._filter_predicate(input));
   }
   /**
    * Build a predicate from a {@link StreamFilter}. Compiled regexes are
@@ -1209,37 +1190,10 @@ var InMemoryStore = class {
    */
   async reset(input) {
     await sleep();
-    let count = 0;
-    if (Array.isArray(input)) {
-      for (const name of new Set(input)) {
-        const s = this._streams.get(name);
-        if (s) {
-          s.reset();
-          count++;
-        }
-      }
-    } else {
-      const matches = this._filter_predicate(input);
-      for (const s of this._streams.values()) {
-        if (matches(s)) {
-          s.reset();
-          count++;
-        }
-      }
-    }
-    return count;
+    const selected = this._select(input);
+    for (const s of selected) s.reset();
+    return selected.length;
   }
-  /**
-   * Clear the blocked flag (and retry / error / lease) on the matched
-   * streams without touching the watermark. Streams that aren't blocked
-   * at call time are silently skipped. Accepts either an explicit list
-   * of names or a {@link StreamFilter}. The filter form always restricts
-   * to blocked streams — passing `blocked: false` matches nothing.
-   * See {@link Store.unblock}.
-   *
-   * @param input - Stream names or a filter selecting the streams to unblock.
-   * @returns Count of streams that were actually flipped (were blocked).
-   */
   /**
    * Wipe the sensitive-data payload for every event on the stream — see
    * {@link Store.forget_pii}. O(1) drop of the stream's inner Map; the size of
@@ -1255,21 +1209,23 @@ var InMemoryStore = class {
     this._pii.delete(stream);
     return count;
   }
+  /**
+   * Clear the blocked flag (and retry / error / lease) on the matched
+   * streams without touching the watermark. Streams that aren't blocked
+   * at call time are silently skipped. Accepts either an explicit list
+   * of names or a {@link StreamFilter}. The filter form always restricts
+   * to blocked streams — passing `blocked: false` matches nothing.
+   * See {@link Store.unblock}.
+   *
+   * @param input - Stream names or a filter selecting the streams to unblock.
+   * @returns Count of streams that were actually flipped (were blocked).
+   */
   async unblock(input) {
     await sleep();
-    let count = 0;
-    if (Array.isArray(input)) {
-      for (const name of input) {
-        const s = this._streams.get(name);
-        if (s?.unblock()) count++;
-      }
-    } else {
-      const matches = this._filter_predicate({ ...input, blocked: true });
-      for (const s of this._streams.values()) {
-        if (matches(s) && s.unblock()) count++;
-      }
-    }
-    return count;
+    const selected = this._select(
+      Array.isArray(input) ? input : { ...input, blocked: true }
+    );
+    return selected.filter((s) => s.unblock()).length;
   }
   /**
    * Bulk-update priority of streams matching `filter`. Mirrors
@@ -1282,16 +1238,9 @@ var InMemoryStore = class {
    */
   async prioritize(filter, priority) {
     await sleep();
-    const matches = this._filter_predicate(filter);
-    let count = 0;
-    for (const s of this._streams.values()) {
-      if (!matches(s)) continue;
-      if (s.priority !== priority) {
-        s.set_priority(priority);
-        count++;
-      }
-    }
-    return count;
+    const changed = this._select(filter).filter((s) => s.priority !== priority);
+    for (const s of changed) s.set_priority(priority);
+    return changed.length;
   }
   /**
    * Streams registered subscription positions to the callback, ordered by
@@ -1302,10 +1251,8 @@ var InMemoryStore = class {
     await sleep();
     const limit = query?.limit ?? 100;
     const after = query?.after;
-    const blocked = query?.blocked;
     const source_matches = query?.source_matches;
-    const stream_re = query?.stream !== void 0 && !query.stream_exact ? new RegExp(query.stream) : void 0;
-    const source_re = query?.source !== void 0 && !query.source_exact ? new RegExp(query.source) : void 0;
+    const matches = this._filter_predicate(query ?? {});
     const reverse_cache = /* @__PURE__ */ new Map();
     const reverse_match = (source) => {
       let re = reverse_cache.get(source);
@@ -1319,20 +1266,10 @@ var InMemoryStore = class {
     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 : !stream_re.test(s.stream))
-          continue;
-      }
-      if (query?.source !== void 0) {
-        if (s.source === void 0) continue;
-        if (query.source_exact ? s.source !== query.source : !source_re.test(s.source))
-          continue;
-      }
+      if (!matches(s)) continue;
       if (source_matches !== void 0) {
         if (s.source && !reverse_match(s.source)) continue;
       }
-      if (blocked !== void 0 && s.blocked !== blocked) continue;
-      if (query?.lane !== void 0 && s.lane !== query.lane) continue;
       if (count >= limit) break;
       callback({
         stream: s.stream,
@@ -1363,10 +1300,7 @@ var InMemoryStore = class {
    * Scope rules:
    * - Array `input` — explicit stream names, regardless of subscription.
    * - Filter `input` — `stream`/`stream_exact` match against event-bearing
-   *   stream names; `source`/`source_exact`/`blocked` require a
-   *   corresponding subscription in `_streams` (those are subscription
-   *   concepts, not event concepts). Empty filter `{}` matches every
-   *   event-bearing stream.
+   *   stream names. Empty filter `{}` matches every event-bearing stream.
    */
   async query_stats(input, options) {
     await sleep();
@@ -1472,7 +1406,6 @@ var InMemoryStore = class {
         return false;
       });
       this._stream_versions.delete(stream);
-      this._max_event_id_by_stream.delete(stream);
       this._pii.delete(stream);
       const event = {
         id: this._next_id++,
@@ -1485,15 +1418,8 @@ var InMemoryStore = class {
       };
       this._events.push(event);
       this._stream_versions.set(stream, 0);
-      if (event.name !== SNAP_EVENT) {
-        this._max_event_id_by_stream.set(stream, event.id);
-      }
       result.set(stream, { deleted, committed: event });
     }
-    let max = -1;
-    for (const id of this._max_event_id_by_stream.values())
-      if (id > max) max = id;
-    this._max_non_snap_event_id = max;
     return result;
   }
   /**
@@ -1514,8 +1440,6 @@ var InMemoryStore = class {
     const prev_next_id = this._next_id;
     const prev_streams = this._streams;
     const prev_stream_versions = this._stream_versions;
-    const prev_max_event_id_by_stream = this._max_event_id_by_stream;
-    const prev_max_non_snap_event_id = this._max_non_snap_event_id;
     const prev_pii = this._pii;
     const prev_correlated_at = this._correlated_at;
     const prev_correlators = new Map(
@@ -1527,8 +1451,6 @@ var InMemoryStore = class {
     this._next_id = 0;
     this._streams = /* @__PURE__ */ new Map();
     this._stream_versions = /* @__PURE__ */ new Map();
-    this._max_event_id_by_stream = /* @__PURE__ */ new Map();
-    this._max_non_snap_event_id = -1;
     this._pii = /* @__PURE__ */ new Map();
     try {
       await driver(async (event) => {
@@ -1536,19 +1458,8 @@ var InMemoryStore = class {
         const { pii, ...rest } = event;
         const committed = { ...rest, id };
         this._events.push(committed);
-        if (pii != null) {
-          let per_stream = this._pii.get(event.stream);
-          if (!per_stream) {
-            per_stream = /* @__PURE__ */ new Map();
-            this._pii.set(event.stream, per_stream);
-          }
-          per_stream.set(id, structuredClone(pii));
-        }
+        if (pii != null) this._put_pii(event.stream, id, pii);
         this._stream_versions.set(event.stream, event.version);
-        if (event.name !== SNAP_EVENT) {
-          this._max_event_id_by_stream.set(event.stream, id);
-          this._max_non_snap_event_id = id;
-        }
         return id;
       });
     } catch (err) {
@@ -1556,8 +1467,6 @@ var InMemoryStore = class {
       this._next_id = prev_next_id;
       this._streams = prev_streams;
       this._stream_versions = prev_stream_versions;
-      this._max_event_id_by_stream = prev_max_event_id_by_stream;
-      this._max_non_snap_event_id = prev_max_non_snap_event_id;
       this._pii = prev_pii;
       this._correlated_at = prev_correlated_at;
       this._correlators = prev_correlators;
@@ -2561,7 +2470,6 @@ function resolveSettleConfig(options) {
   return options;
 }
 var MAX_SHUTDOWN_GRACE_MS = 3e4;
-var DEFAULT_SHUTDOWN_GRACE_MS = DEFAULT_LEASE_MILLIS;
 var ShutdownOptionsSchema = import_zod6.z.object({
   // `0` is legal and is exactly today's behavior: stop scheduling and
   // return without waiting.
@@ -3196,8 +3104,8 @@ function report_once(seen, key, message) {
 }
 
 // src/internal/correlate-cycle.ts
-var DEFAULT_COLD_START_BACK_SCAN = 1e4;
-var DEFAULT_CORRELATION_LEASE_MS = 5e3;
+var COLD_START_BACK_SCAN = 1e4;
+var CORRELATION_LEASE_MS = 5e3;
 var registry_key = (events) => {
   const shape = Object.keys(events).filter((name) => events[name].reactions.size > 0).sort().map((name) => [name, [...events[name].reactions.keys()].sort()]);
   return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(shape)).digest("hex").slice(0, 32);
@@ -3226,8 +3134,6 @@ var CorrelateCycle = class {
    * same holder and a restarted process never inherits a stale claim.
    */
   _by = (0, import_node_crypto.randomUUID)();
-  /** How long the correlation lease is taken for. */
-  _lease_millis;
   /**
    * Which correlator this is. Computed once from the registry so identical
    * workers share a lease and unrelated applications never do.
@@ -3280,12 +3186,6 @@ var CorrelateCycle = class {
    * here, so an idle deferred stream re-arms across a restart.
    */
   _on_init_async;
-  /**
-   * Tail re-scan window applied to the cold-start checkpoint.
-   * See {@link DEFAULT_COLD_START_BACK_SCAN}. Constructor arg (not a
-   * public option) so tests can shrink it; defaults otherwise.
-   */
-  _cold_start_back_scan;
   /** Lanes a controller exists for. See {@link CorrelateCycleDeps}. */
   _declared_lanes;
   /**
@@ -3302,11 +3202,8 @@ var CorrelateCycle = class {
     declared_lanes,
     shard,
     on_init,
-    on_init_async,
-    cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN,
-    lease_millis = DEFAULT_CORRELATION_LEASE_MS
+    on_init_async
   }) {
-    this._lease_millis = lease_millis;
     this._key = shard ? `${registry_key(registry.events)}:${[...shard].sort().join(",")}` : registry_key(registry.events);
     this._dynamic_subscriptions = new LruMap(max_subscribed_streams);
     this._registry = registry;
@@ -3315,7 +3212,6 @@ var CorrelateCycle = class {
     this._cd = cd;
     this._on_init = on_init;
     this._on_init_async = on_init_async;
-    this._cold_start_back_scan = cold_start_back_scan;
   }
   /** Last correlated event id. */
   get checkpoint() {
@@ -3354,7 +3250,7 @@ var CorrelateCycle = class {
     const { watermark, correlated_at } = await this._cd.subscribe([
       ...this._static_targets
     ]);
-    this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - this._cold_start_back_scan);
+    this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - COLD_START_BACK_SCAN);
     this._on_init?.();
     for (const { stream, priority = 0, lane } of this._static_targets) {
       this._static_subscriptions.set(stream, {
@@ -3428,13 +3324,13 @@ var CorrelateCycle = class {
         scanned: false
       };
     const now = Date.now();
-    if (lease && now >= this._lease_until - this._lease_millis / 2) {
+    if (lease && now >= this._lease_until - CORRELATION_LEASE_MS / 2) {
       const { correlating } = await this._cd.subscribe([], void 0, {
         key: this._key,
         by: this._by,
-        millis: this._lease_millis
+        millis: CORRELATION_LEASE_MS
       });
-      this._lease_until = correlating ? now + this._lease_millis : 0;
+      this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
       if (correlating === false)
         return {
           subscribed: 0,
@@ -3525,10 +3421,10 @@ var CorrelateCycle = class {
       const { subscribed, correlating } = await this._cd.subscribe(
         streams,
         last_id,
-        lease ? { key: this._key, by: this._by, millis: this._lease_millis } : void 0
+        lease ? { key: this._key, by: this._by, millis: CORRELATION_LEASE_MS } : void 0
       );
       if (lease && correlating !== false)
-        this._lease_until = renewed_at + this._lease_millis;
+        this._lease_until = renewed_at + CORRELATION_LEASE_MS;
       const marked = streams.filter(
         (entry) => entry.correlated_at !== void 0
       ).length;
@@ -3608,7 +3504,7 @@ var CorrelateCycle = class {
       });
     } catch (error) {
       log().warn(
-        `Could not hand back the correlation lease during shutdown; it expires on its own within ${this._lease_millis}ms and correlation resumes normally after that. On a single-writer store this usually means another connection holds the database. Cause: ${String(error)}`
+        `Could not hand back the correlation lease during shutdown; it expires on its own within ${CORRELATION_LEASE_MS}ms and correlation resumes normally after that. On a single-writer store this usually means another connection holds the database. Cause: ${String(error)}`
       );
     }
   }
@@ -3760,14 +3656,6 @@ var DeferTimer = class {
   get size() {
     return this._due.size;
   }
-  /**
-   * True while `stream` is parked with a due-time still in the future.
-   * Consumers skip work for deferred streams until their window elapses.
-   */
-  is_deferred = (stream) => {
-    const next = this._due.get(stream);
-    return next !== void 0 && next > Date.now();
-  };
   /**
    * Park `stream` for a re-visit at `at` (ms since epoch). A plain
    * overwrite: the caller computes the authoritative next-visit for the
@@ -4450,7 +4338,7 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 function budget_exhausted(lease, options, store_failing) {
   if (store_failing || !options?.blockOnError || lease.retry <= options.maxRetries)
     return void 0;
-  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. That means every attempt lost its lease before it could ack: raise leaseMillis for this handler, then unblock the stream.`;
+  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. That means every attempt lost its lease before it could ack: move the reaction to a lane whose leaseMillis covers the handler, then unblock the stream.`;
   log().error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
@@ -4530,7 +4418,9 @@ async function run_drain_cycle(deps, cycle) {
           handled: 0,
           acked_at: lease.at,
           error,
-          ...block2 ? { block: true } : { next_attempt_at: Date.now() + DEFAULT_BACKOFF.baseMs }
+          ...block2 ? { block: true } : {
+            next_attempt_at: Date.now() + compute_backoff_delay(lease.retry, DEFAULT_BACKOFF)
+          }
         };
         return Promise.resolve(failed);
       }
@@ -4679,7 +4569,7 @@ var DrainController = class {
     if (this._locked) return EMPTY_DRAIN;
     const d = this._deps.defaults ?? {};
     const streamLimit = d.streamLimit ?? options.streamLimit ?? DEFAULT_STREAM_LIMIT;
-    const eventLimit = d.eventLimit ?? options.eventLimit ?? DEFAULT_EVENT_LIMIT;
+    const eventLimit = options.eventLimit ?? DEFAULT_EVENT_LIMIT;
     const leaseMillis = d.leaseMillis ?? options.leaseMillis ?? DEFAULT_LEASE_MILLIS;
     if (this._deps.breaker.state(Date.now()) === "open")
       return EMPTY_DRAIN;
@@ -5343,9 +5233,7 @@ var Act = class {
   _build_audit_deps() {
     return {
       store: store2,
-      logger: this._logger,
       event_to_state: this._event_to_state,
-      states: this._states,
       // Declared lanes, not this process's controllers: a lane another
       // worker drains is not `unknown-lane`.
       declared_lanes: new Set(this._declared_lanes),
@@ -5452,9 +5340,9 @@ var Act = class {
    * fallback, capped at the maximum. Idle lanes don't count.
    */
   _derive_grace_ms(running, settling) {
-    let max = settling ? DEFAULT_SHUTDOWN_GRACE_MS : 0;
+    let max = settling ? DEFAULT_LEASE_MILLIS : 0;
     for (const c of running)
-      max = Math.max(max, c.lease_millis || DEFAULT_SHUTDOWN_GRACE_MS);
+      max = Math.max(max, c.lease_millis || DEFAULT_LEASE_MILLIS);
     return Math.min(max, MAX_SHUTDOWN_GRACE_MS);
   }
   async _await_inflight(grace_ms) {
@@ -5764,8 +5652,7 @@ var Act = class {
    * Call `correlate()` before `drain()`. It is not only how dynamic targets
    * are discovered: a stream is claimable while `at < correlated_at`, and
    * `correlate` is the only component that raises that mark, so a
-   * commit no correlate has seen is not drainable — including for static
-   * targets, which were served by a probe of the event log before. For a
+   * commit no correlate has seen is not drainable, static targets included. For a
    * higher-level API that handles debouncing, correlation, and signaling
    * automatically, use {@link settle}.
    *
@@ -6771,6 +6658,12 @@ function act() {
   };
   const fold_projections = [];
   const batch_handlers = /* @__PURE__ */ new Map();
+  const add_projection = (proj) => {
+    record_projection_reactions(proj);
+    merge_projection(proj, registry.events);
+    register_batch_handler(proj, batch_handlers);
+    if (proj.fold) fold_projections.push(proj);
+  };
   const fold_specs = [];
   const lanes = [];
   let _built = false;
@@ -6870,11 +6763,7 @@ function act() {
     },
     withProjection: (proj) => {
       if (_built) closed("withProjection");
-      record_projection_reactions(proj);
-      merge_projection(proj, registry.events);
-      register_batch_handler(proj, batch_handlers);
-      if (proj.fold)
-        fold_projections.push(proj);
+      add_projection(proj);
       return builder;
     },
     withActor: () => builder,
@@ -6891,12 +6780,7 @@ function act() {
       resolveActConfig(options);
       const patch_fn = options?.validateFoldedState === true ? validating_patch : bare_patch;
       if (!_built) {
-        for (const proj of pending_projections) {
-          record_projection_reactions(proj);
-          merge_projection(proj, registry.events);
-          register_batch_handler(proj, batch_handlers);
-          if (proj.fold) fold_projections.push(proj);
-        }
+        for (const proj of pending_projections) add_projection(proj);
         for (const proj of fold_projections) {
           const fold = proj.fold;
           const merged = states.get(fold.name);