@rotorsoft/act 1.32.11 → 1.32.13

package/dist/index.cjs

@@ -912,17 +912,34 @@ var InMemoryStore = class {
     this._streams = /* @__PURE__ */ new Map();
   }
   in_query(query, e) {
-    if (query.stream) {
-      if (query.stream_exact) {
-        if (e.stream !== query.stream) return false;
-      } else if (!RegExp(query.stream).test(e.stream)) return false;
-    }
+    if (query.stream && !this._stream_matches(query.stream, query, e.stream))
+      return false;
     if (query.names && !query.names.includes(e.name)) return false;
     if (query.correlation && e.meta?.correlation !== query.correlation)
       return false;
     if (e.name === SNAP_EVENT && !query.with_snaps) return false;
+    if (query.created_after && e.created <= query.created_after) return false;
+    if (query.created_before && e.created >= query.created_before) return false;
     return true;
   }
+  _stream_matches(pattern, query, stream) {
+    return query.stream_exact ? stream === pattern : RegExp(pattern).test(stream);
+  }
+  /**
+   * Index of the latest snapshot of the queried stream, or -1. `with_snaps`
+   * on an exact single stream resumes there, so earlier events aren't read.
+   * The orchestrator asks only for unbounded current-state loads, so the
+   * floor applies whenever asked; an explicit `after` wins over it.
+   */
+  _snap_floor(query) {
+    if (!query?.with_snaps || !query.stream_exact || query.stream === void 0 || query.after !== void 0)
+      return -1;
+    for (let j = this._events.length - 1; j >= 0; j--) {
+      const e = this._events[j];
+      if (e.stream === query.stream && e.name === SNAP_EVENT) return j;
+    }
+    return -1;
+  }
   /**
    * Query events in the store, optionally filtered by query options.
    * @param callback - Function to call for each event.
@@ -931,59 +948,19 @@ var InMemoryStore = class {
    */
   async query(callback, query) {
     await sleep();
+    const floor = this._snap_floor(query);
+    const lo = floor >= 0 ? floor : this._first_index_after(query?.after ?? -1);
+    const hi = query?.before !== void 0 ? this._first_index_after(query.before - 1) : this._events.length;
+    const with_pii = query?.with_pii !== false;
     let count = 0;
-    let floor_index = -1;
-    if (query?.with_snaps && query.stream_exact && query.stream !== void 0 && query.after === void 0) {
-      for (let j = this._events.length - 1; j >= 0; j--) {
-        const e = this._events[j];
-        if (e.stream === query.stream && e.name === SNAP_EVENT) {
-          floor_index = j;
-          break;
-        }
-      }
-    }
-    if (query?.backward) {
-      const floor_id = floor_index >= 0 ? this._events[floor_index].id : -1;
-      let i = (query?.before !== void 0 ? this._first_index_after(query.before - 1) : this._events.length) - 1;
-      while (i >= 0) {
-        const e = this._events[i--];
-        if (query && !this.in_query(query, e)) continue;
-        if (query?.created_before && e.created >= query.created_before)
-          continue;
-        if (query.after !== void 0 && e.id <= query.after) break;
-        if (floor_id >= 0 && e.id < floor_id) break;
-        if (query.created_after && e.created <= query.created_after) continue;
-        await Promise.resolve(
-          callback(
-            this._with_pii(
-              e,
-              query?.with_pii !== false
-            )
-          )
-        );
-        count++;
-        if (query?.limit && count >= query.limit) break;
-      }
-    } else {
-      let i = floor_index >= 0 ? floor_index : this._first_index_after(query?.after ?? -1);
-      while (i < this._events.length) {
-        const e = this._events[i++];
-        if (query && !this.in_query(query, e)) continue;
-        if (query?.created_after && e.created <= query.created_after) continue;
-        if (query?.before !== void 0 && e.id >= query.before) break;
-        if (query?.created_before && e.created >= query.created_before)
-          continue;
-        await Promise.resolve(
-          callback(
-            this._with_pii(
-              e,
-              query?.with_pii !== false
-            )
-          )
-        );
-        count++;
-        if (query?.limit && count >= query.limit) break;
-      }
+    for (let k = 0; k < hi - lo; k++) {
+      const e = this._events[query?.backward ? hi - 1 - k : lo + k];
+      if (query && !this.in_query(query, e)) continue;
+      await Promise.resolve(
+        callback(this._with_pii(e, with_pii))
+      );
+      count++;
+      if (query?.limit && count >= query.limit) break;
     }
     return count;
   }
@@ -2509,6 +2486,151 @@ var CloseSignal = class extends Error {
   }
 };
 
+// src/internal/config.ts
+var import_zod6 = require("zod");
+var BackoffOptionsSchema = import_zod6.z.object({
+  strategy: import_zod6.z.enum(["fixed", "linear", "exponential"]),
+  baseMs: import_zod6.z.number().min(0),
+  maxMs: import_zod6.z.number().gt(0).optional(),
+  jitter: import_zod6.z.boolean().optional()
+});
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BLOCK_ON_ERROR = true;
+var ReactionOptionsSchema = import_zod6.z.object({
+  blockOnError: import_zod6.z.boolean(),
+  maxRetries: import_zod6.z.number().int().min(0),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveReactionConfig(options) {
+  return ReactionOptionsSchema.parse(options);
+}
+var ActionOptionsSchema = import_zod6.z.object({
+  maxRetries: import_zod6.z.number().int().min(0).optional(),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveActionConfig(options) {
+  return ActionOptionsSchema.parse(options);
+}
+var LaneConfigSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  leaseMillis: import_zod6.z.number().min(0).optional(),
+  streamLimit: import_zod6.z.number().int().min(0).optional(),
+  cycleMs: import_zod6.z.number().min(0).optional()
+});
+function resolveLaneConfig(options) {
+  LaneConfigSchema.parse(options);
+  return options;
+}
+var DEFAULT_STREAM_LIMIT = 10;
+var DEFAULT_EVENT_LIMIT = 10;
+var DEFAULT_LEASE_MILLIS = 1e4;
+var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
+var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
+var DrainOptionsSchema = import_zod6.z.object({
+  streamLimit: import_zod6.z.number().int().min(0).optional(),
+  eventLimit: import_zod6.z.number().int().min(0).optional(),
+  leaseMillis: import_zod6.z.number().min(0).optional()
+});
+function resolveDrainConfig(options) {
+  if (options === void 0) return void 0;
+  DrainOptionsSchema.parse(options);
+  return options;
+}
+var SettleOptionsSchema = DrainOptionsSchema.extend({
+  debounceMs: import_zod6.z.number().min(0).optional(),
+  // `maxPasses` defaults to Infinity (no cap) when omitted; a present value is
+  // a non-negative integer — `0` is legal and means "run no passes".
+  //
+  // `Infinity` is accepted explicitly. It is the documented default
+  // (`Act.settle`'s doc-comment and `SettleOptions.maxPasses` both name it),
+  // and `settle.ts` destructures `maxPasses = Infinity`, so the one value the
+  // docs advertise was the one value `z.number().int()` refused — Zod 4
+  // rejects `±Infinity`, and an integer check cannot pass it either. Wrapper
+  // code normalizing an optional cap (`maxPasses: opts.maxPasses ?? Infinity`)
+  // is the natural way to hit it. Accepting it also honors this module's own
+  // rule that a value which works today is never newly rejected (#1711).
+  maxPasses: import_zod6.z.union([import_zod6.z.number().int().min(0), import_zod6.z.literal(Number.POSITIVE_INFINITY)]).optional()
+}).loose();
+function resolveSettleConfig(options) {
+  if (options === void 0) return void 0;
+  SettleOptionsSchema.parse(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.
+  graceMs: import_zod6.z.number().min(0).optional()
+}).loose();
+function resolveShutdownConfig(options) {
+  if (options === void 0) return void 0;
+  ShutdownOptionsSchema.parse(options);
+  return options;
+}
+var ActOptionsSchema = import_zod6.z.object({
+  maxSubscribedStreams: import_zod6.z.number().int().min(1).optional(),
+  settleDebounceMs: import_zod6.z.number().int().min(0).optional()
+}).loose();
+function resolveActConfig(options) {
+  if (options === void 0) return void 0;
+  ActOptionsSchema.parse(options);
+  return options;
+}
+var DEFAULT_AUTOCLOSE_CYCLE_MINUTES = 720;
+var DEFAULT_CLOSE_BATCH_SIZE = 64;
+var DEFAULT_CLOSE_YIELD_MS = 0;
+var DEFAULT_AUTOCLOSE_WINDOW_TZ = "UTC";
+function is_valid_time_zone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var AutocloseWindowSchema = import_zod6.z.object({
+  start: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
+  end: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
+  timeZone: import_zod6.z.string().refine(is_valid_time_zone, {
+    message: "autocloseWindow.timeZone must be a valid IANA time zone"
+  }).default(DEFAULT_AUTOCLOSE_WINDOW_TZ)
+}).refine((w) => w.start !== w.end, {
+  message: "autocloseWindow.start and end must differ \u2014 an empty window disables autoclose"
+});
+var AutocloseOptionsSchema = import_zod6.z.object({
+  autocloseCycleMinutes: import_zod6.z.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
+  closeBatchSize: import_zod6.z.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
+  closeYieldMs: import_zod6.z.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
+  closeOnError: import_zod6.z.boolean().default(false),
+  autocloseWindow: AutocloseWindowSchema.optional()
+});
+function resolveAutocloseConfig(options) {
+  return AutocloseOptionsSchema.parse({
+    autocloseCycleMinutes: options?.autocloseCycleMinutes,
+    closeBatchSize: options?.closeBatchSize,
+    closeYieldMs: options?.closeYieldMs,
+    closeOnError: options?.closeOnError,
+    autocloseWindow: options?.autocloseWindow
+  });
+}
+var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
+var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
+var CircuitBreakerOptionsSchema = import_zod6.z.object({
+  failureThreshold: import_zod6.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
+  cooldownMs: import_zod6.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
+});
+var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
+var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
+var DEFAULT_MAX_CACHED_STATES = 1e4;
+var FoldOptionsSchema = import_zod6.z.object({
+  flushEvery: import_zod6.z.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: import_zod6.z.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
+});
+function resolveFoldConfig(options) {
+  return FoldOptionsSchema.parse(options);
+}
+
 // src/internal/defer-signal.ts
 var DeferSignal = class extends Error {
   /**
@@ -2545,7 +2667,7 @@ function synthesize_autoclose_reactions(registry, states, read_window) {
       }),
       // Never block on autoclose: a transient query/store error should retry,
       // not quarantine the synthetic stream.
-      options: { blockOnError: false, maxRetries: 3 },
+      options: { blockOnError: false, maxRetries: DEFAULT_MAX_RETRIES },
       handler: async (event) => {
         const aggregate = event.stream;
         const window = read_window();
@@ -3032,144 +3154,6 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
   return truncated;
 }
 
-// src/internal/config.ts
-var import_zod6 = require("zod");
-var BackoffOptionsSchema = import_zod6.z.object({
-  strategy: import_zod6.z.enum(["fixed", "linear", "exponential"]),
-  baseMs: import_zod6.z.number().min(0),
-  maxMs: import_zod6.z.number().gt(0).optional(),
-  jitter: import_zod6.z.boolean().optional()
-});
-var ReactionOptionsSchema = import_zod6.z.object({
-  blockOnError: import_zod6.z.boolean(),
-  maxRetries: import_zod6.z.number().int().min(0),
-  backoff: BackoffOptionsSchema.optional()
-});
-function resolveReactionConfig(options) {
-  return ReactionOptionsSchema.parse(options);
-}
-var ActionOptionsSchema = import_zod6.z.object({
-  maxRetries: import_zod6.z.number().int().min(0).optional(),
-  backoff: BackoffOptionsSchema.optional()
-});
-function resolveActionConfig(options) {
-  return ActionOptionsSchema.parse(options);
-}
-var LaneConfigSchema = import_zod6.z.object({
-  name: import_zod6.z.string().min(1),
-  leaseMillis: import_zod6.z.number().min(0).optional(),
-  streamLimit: import_zod6.z.number().int().min(0).optional(),
-  cycleMs: import_zod6.z.number().min(0).optional()
-});
-function resolveLaneConfig(options) {
-  LaneConfigSchema.parse(options);
-  return options;
-}
-var DrainOptionsSchema = import_zod6.z.object({
-  streamLimit: import_zod6.z.number().int().min(0).optional(),
-  eventLimit: import_zod6.z.number().int().min(0).optional(),
-  leaseMillis: import_zod6.z.number().min(0).optional()
-});
-function resolveDrainConfig(options) {
-  if (options === void 0) return void 0;
-  DrainOptionsSchema.parse(options);
-  return options;
-}
-var SettleOptionsSchema = DrainOptionsSchema.extend({
-  debounceMs: import_zod6.z.number().min(0).optional(),
-  // `maxPasses` defaults to Infinity (no cap) when omitted; a present value is
-  // a non-negative integer — `0` is legal and means "run no passes".
-  //
-  // `Infinity` is accepted explicitly. It is the documented default
-  // (`Act.settle`'s doc-comment and `SettleOptions.maxPasses` both name it),
-  // and `settle.ts` destructures `maxPasses = Infinity`, so the one value the
-  // docs advertise was the one value `z.number().int()` refused — Zod 4
-  // rejects `±Infinity`, and an integer check cannot pass it either. Wrapper
-  // code normalizing an optional cap (`maxPasses: opts.maxPasses ?? Infinity`)
-  // is the natural way to hit it. Accepting it also honors this module's own
-  // rule that a value which works today is never newly rejected (#1711).
-  maxPasses: import_zod6.z.union([import_zod6.z.number().int().min(0), import_zod6.z.literal(Number.POSITIVE_INFINITY)]).optional()
-}).loose();
-function resolveSettleConfig(options) {
-  if (options === void 0) return void 0;
-  SettleOptionsSchema.parse(options);
-  return options;
-}
-var MAX_SHUTDOWN_GRACE_MS = 3e4;
-var DEFAULT_SHUTDOWN_GRACE_MS = 1e4;
-var ShutdownOptionsSchema = import_zod6.z.object({
-  // `0` is legal and is exactly today's behavior: stop scheduling and
-  // return without waiting.
-  graceMs: import_zod6.z.number().min(0).optional()
-}).loose();
-function resolveShutdownConfig(options) {
-  if (options === void 0) return void 0;
-  ShutdownOptionsSchema.parse(options);
-  return options;
-}
-var ActOptionsSchema = import_zod6.z.object({
-  maxSubscribedStreams: import_zod6.z.number().int().min(1).optional(),
-  settleDebounceMs: import_zod6.z.number().int().min(0).optional()
-}).loose();
-function resolveActConfig(options) {
-  if (options === void 0) return void 0;
-  ActOptionsSchema.parse(options);
-  return options;
-}
-var DEFAULT_AUTOCLOSE_CYCLE_MINUTES = 720;
-var DEFAULT_CLOSE_BATCH_SIZE = 64;
-var DEFAULT_CLOSE_YIELD_MS = 0;
-var DEFAULT_AUTOCLOSE_WINDOW_TZ = "UTC";
-function is_valid_time_zone(tz) {
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: tz });
-    return true;
-  } catch {
-    return false;
-  }
-}
-var AutocloseWindowSchema = import_zod6.z.object({
-  start: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
-  end: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
-  timeZone: import_zod6.z.string().refine(is_valid_time_zone, {
-    message: "autocloseWindow.timeZone must be a valid IANA time zone"
-  }).default(DEFAULT_AUTOCLOSE_WINDOW_TZ)
-}).refine((w) => w.start !== w.end, {
-  message: "autocloseWindow.start and end must differ \u2014 an empty window disables autoclose"
-});
-var AutocloseOptionsSchema = import_zod6.z.object({
-  autocloseCycleMinutes: import_zod6.z.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
-  closeBatchSize: import_zod6.z.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
-  closeYieldMs: import_zod6.z.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
-  closeOnError: import_zod6.z.boolean().default(false),
-  autocloseWindow: AutocloseWindowSchema.optional()
-});
-function resolveAutocloseConfig(options) {
-  return AutocloseOptionsSchema.parse({
-    autocloseCycleMinutes: options?.autocloseCycleMinutes,
-    closeBatchSize: options?.closeBatchSize,
-    closeYieldMs: options?.closeYieldMs,
-    closeOnError: options?.closeOnError,
-    autocloseWindow: options?.autocloseWindow
-  });
-}
-var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
-var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
-var CircuitBreakerOptionsSchema = import_zod6.z.object({
-  failureThreshold: import_zod6.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
-  cooldownMs: import_zod6.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
-});
-var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
-var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
-var DEFAULT_MAX_CACHED_STATES = 1e4;
-var FoldOptionsSchema = import_zod6.z.object({
-  flushEvery: import_zod6.z.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
-  maxCachedStates: import_zod6.z.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
-});
-function resolveFoldConfig(options) {
-  return FoldOptionsSchema.parse(options);
-}
-
 // src/internal/correlate-cycle.ts
 var import_node_crypto = require("crypto");
 
@@ -3247,7 +3231,6 @@ var CorrelateCycle = class {
   _armed = true;
   /** In-flight init, memoized for single-flight and cleared on failure. */
   _init_promise;
-  _timer = void 0;
   // Dynamically discovered targets → what each was last subscribed at,
   // bounded by `maxSubscribedStreams`. The static half lives in
   // `_static_subscriptions` below, which is deliberately not evictable.
@@ -3291,14 +3274,6 @@ var CorrelateCycle = class {
    * guarantee without a second gate on the Act side.
    */
   _on_init_async;
-  /**
-   * Scope runner (#1191). The periodic `start_polling` timer fires
-   * outside any caller frame, so its `correlate()` must be re-wrapped in
-   * the Act's `_scoped` bag or `store()`/`cache()` resolve to the
-   * singleton for a scoped Act. The orchestrator always threads its
-   * `_scoped` (identity for a non-scoped Act), so it's required.
-   */
-  _run_scoped;
   /**
    * Tail re-scan window applied to the cold-start checkpoint (ACT-1207).
    * See {@link DEFAULT_COLD_START_BACK_SCAN}. Constructor arg (not a
@@ -3319,7 +3294,6 @@ var CorrelateCycle = class {
     cd,
     max_subscribed_streams,
     declared_lanes,
-    run_scoped,
     on_init,
     on_init_async,
     cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN,
@@ -3333,7 +3307,6 @@ var CorrelateCycle = class {
     this._static_targets = static_targets;
     this._cd = cd;
     this._on_init = on_init;
-    this._run_scoped = run_scoped;
     this._on_init_async = on_init_async;
     this._cold_start_back_scan = cold_start_back_scan;
   }
@@ -3581,33 +3554,6 @@ var CorrelateCycle = class {
     this._armed = found === query.limit;
     return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
-  /**
-   * Start a periodic correlation worker. Returns false if one is already
-   * running. Errors from `correlate()` are routed through `log()` so they
-   * land in the configured logger (the timer keeps running on failure).
-   */
-  start_polling(query = {}, frequency = 1e4, callback) {
-    if (this._timer) return false;
-    const limit = query.limit || 100;
-    this._timer = setInterval(
-      () => this._run_scoped(() => {
-        this.arm();
-        return this.correlate(
-          {
-            ...query,
-            after: this._checkpoint,
-            limit
-          },
-          true
-        );
-      }).then((result) => {
-        if (callback && result.subscribed) callback(result.subscribed);
-      }).catch((err) => log().error(err)),
-      frequency
-    );
-    return true;
-  }
-  /** Stop the periodic correlation worker. Idempotent. */
   /**
    * Hand the correlation lease back early.
    *
@@ -3638,12 +3584,6 @@ var CorrelateCycle = class {
       );
     }
   }
-  stop_polling() {
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = void 0;
-    }
-  }
 };
 
 // src/internal/correlator.ts
@@ -4741,9 +4681,9 @@ var DrainController = class {
     if (this._deps.breaker.state(Date.now()) === "open")
       return EMPTY_DRAIN;
     const d = this._deps.defaults ?? {};
-    const streamLimit = d.streamLimit ?? options.streamLimit ?? 10;
-    const eventLimit = d.eventLimit ?? options.eventLimit ?? 10;
-    const leaseMillis = d.leaseMillis ?? options.leaseMillis ?? 1e4;
+    const streamLimit = d.streamLimit ?? options.streamLimit ?? DEFAULT_STREAM_LIMIT;
+    const eventLimit = d.eventLimit ?? options.eventLimit ?? DEFAULT_EVENT_LIMIT;
+    const leaseMillis = d.leaseMillis ?? options.leaseMillis ?? DEFAULT_LEASE_MILLIS;
     try {
       this._locked = true;
       this._inflight = new Promise((done) => {
@@ -5117,10 +5057,8 @@ function build_handle_batch(logger) {
 }
 
 // src/act.ts
-var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
 var CLOSE_CATCH_UP_LIMIT = 1e3;
 var CLOSE_CATCH_UP_PASSES = 20;
-var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
 function validate_only_lanes(options, lanes) {
   if (!options.onlyLanes || options.onlyLanes.length === 0) return;
   const declared = /* @__PURE__ */ new Set(["default", ...lanes.map((l) => l.name)]);
@@ -5146,6 +5084,10 @@ var Act = class {
   _correlate;
   /** Debounced correlate→drain catch-up loop. */
   _settle;
+  /** Timer behind {@link start_correlations}. */
+  _poll;
+  /** The deprecated `start_correlations` callback, while the poll runs. */
+  _on_discovered;
   /**
    * Disposer for the cross-process notify subscription, set up eagerly
    * during construction. Held as a promise because the subscription
@@ -5555,9 +5497,6 @@ var Act = class {
       on_init: () => {
         if (this._drain && this._reactive_events.size > 0) this._arm_all();
       },
-      // Re-scope the background `start_correlations` timer so its
-      // correlate resolves the scoped ports, not the singleton (#1191).
-      run_scoped: this._scoped,
       // Cold-start defer re-seed (#1221). Skipped on writer-only instances
       // (`drain: false`) — they run no local controllers to re-arm.
       on_init_async: this._drain ? () => this._seed_persisted_defers() : void 0
@@ -6147,86 +6086,63 @@ var Act = class {
       const { subscribed, last_id, marked, scanned } = await this._correlate.correlate(query, lease);
       if ((subscribed > 0 || marked > 0) && this._reactive_events.size > 0)
         this._arm_all();
+      if (subscribed > 0) this._on_discovered?.(subscribed);
       return { subscribed, last_id, scanned };
     });
   }
   /**
-   * Starts automatic periodic correlation worker for discovering new streams.
-   *
-   * The correlation worker runs in the background, scanning for new events and identifying
-   * new target streams based on reaction resolvers. It maintains a sliding window that
-   * advances with each scan, ensuring all events are eventually correlated.
-   *
-   * This is useful for dynamic stream creation patterns where you don't know all streams
-   * upfront - they're discovered as events arrive.
+   * Starts a background poll that settles on a timer: each tick looks for
+   * new events, subscribes the streams their reactions target, and drains
+   * them.
+   *
+   * Use it when this process can miss commits — another process writes to a
+   * store without `notify`, or a notification is lost. It is the safety net
+   * under `notify`: a missed wakeup costs at most one `frequency` of latency.
+   *
+   * Only one poll runs per Act instance. On a writer-only instance
+   * (`drain: false`) each tick is a no-op, like `settle()`.
+   *
+   * @param query - Only `limit` is used: the most events each correlate pass
+   *   reads (default 100). The scan always starts at the correlation
+   *   checkpoint, so `after` is ignored.
+   * @param frequency - Milliseconds between ticks (default: 10000)
+   * @param callback - Called with the number of newly subscribed streams
+   *   after each correlate pass that found some.
+   *   @deprecated Listen to the `"settled"` lifecycle event instead.
+   * @returns `true` if the poll started, `false` if one is already running
    *
-   * **Note:** Only one correlation worker can run at a time per Act instance.
-   *
-   * @param query - Query filter for correlation scans — see {@link Query}
-   *   (typically `{ after: -1, limit: 100 }`)
-   * @param frequency - Correlation frequency in milliseconds (default: 10000)
-   * @param callback - Optional callback invoked with newly discovered streams
-   * @returns `true` if worker started, `false` if already running
-   *
-   * @example Start automatic correlation
+   * @example
    * ```typescript
-   * // Start correlation worker scanning every 5 seconds
-   * app.start_correlations(
-   *   { after: 0, limit: 100 },
-   *   5000,
-   *   (leased) => {
-   *     console.log(`Discovered ${leased.length} new streams`);
-   *   }
-   * );
-   *
-   * // Later, stop it
+   * app.start_correlations({ limit: 100 }, 5000);
+   * // later
    * app.stop_correlations();
    * ```
    *
-   * @example With checkpoint persistence
-   * ```typescript
-   * // Load last checkpoint
-   * const lastId = await loadCheckpoint();
-   *
-   * app.start_correlations(
-   *   { after: lastId, limit: 100 },
-   *   10000,
-   *   async (leased) => {
-   *     // Save checkpoint for next restart
-   *     if (leased.length) {
-   *       const maxId = Math.max(...leased.map(l => l.at));
-   *       await saveCheckpoint(maxId);
-   *     }
-   *   }
-   * );
-   * ```
-   *
-   * @see {@link correlate} for manual one-time correlation
-   * @see {@link stop_correlations} to stop the worker
+   * @see {@link settle} for what each tick runs
+   * @see {@link stop_correlations} to stop the poll
    */
   start_correlations(query = {}, frequency = 1e4, callback) {
-    const started = this._correlate.start_polling(query, frequency, callback);
-    return started;
+    if (this._poll) return false;
+    this._on_discovered = callback;
+    const correlate = { limit: query.limit || 100 };
+    this._poll = setInterval(() => {
+      this._correlate.arm();
+      this.settle({ debounceMs: 0, correlate });
+    }, frequency);
+    return true;
   }
   /**
-   * Stops the automatic correlation worker.
-   *
-   * Call this to stop the background correlation worker started by {@link start_correlations}.
-   * This is automatically called when the Act instance is disposed.
-   *
-   * @example
-   * ```typescript
-   * // Start correlation
-   * app.start_correlations();
-   *
-   * // Later, stop it
-   * app.stop_correlations();
-   * ```
+   * Stops the poll started by {@link start_correlations}. Idempotent, and
+   * called by `shutdown()`.
    *
    * @see {@link start_correlations}
    */
   stop_correlations() {
-    this._correlate.stop_polling();
+    if (this._poll) {
+      clearInterval(this._poll);
+      this._poll = void 0;
+    }
+    this._on_discovered = void 0;
     void this._scoped(() => this._correlate.release_correlation());
   }
   /**
@@ -6883,8 +6799,8 @@ function reaction_on(event, events, builder) {
       // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
       // not a NaN gate on the first retry.
       options: resolveReactionConfig({
-        blockOnError: options?.blockOnError ?? true,
-        maxRetries: options?.maxRetries ?? 3,
+        blockOnError: options?.blockOnError ?? DEFAULT_BLOCK_ON_ERROR,
+        maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
         backoff: options?.backoff
       })
     };
@@ -7275,8 +7191,8 @@ function _projection(target) {
             handler,
             resolver: default_resolver ?? _this_,
             options: {
-              blockOnError: true,
-              maxRetries: 3
+              blockOnError: DEFAULT_BLOCK_ON_ERROR,
+              maxRetries: DEFAULT_MAX_RETRIES
             }
           };
           const register = events[event];
@@ -7349,7 +7265,10 @@ function _projection(target) {
                   {
                     handler: noop2,
                     resolver: { target },
-                    options: { blockOnError: true, maxRetries: 3 }
+                    options: {
+                      blockOnError: DEFAULT_BLOCK_ON_ERROR,
+                      maxRetries: DEFAULT_MAX_RETRIES
+                    }
                   }
                 ]
               ])