@rotorsoft/act 1.32.11 → 1.32.13

package/dist/index.js

@@ -26,7 +26,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-UVFP2BQ3.js";
+} from "./chunk-FLAGQMWE.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -851,6 +851,151 @@ var CloseSignal = class extends Error {
   }
 };
 
+// src/internal/config.ts
+import { z as z2 } from "zod";
+var BackoffOptionsSchema = z2.object({
+  strategy: z2.enum(["fixed", "linear", "exponential"]),
+  baseMs: z2.number().min(0),
+  maxMs: z2.number().gt(0).optional(),
+  jitter: z2.boolean().optional()
+});
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BLOCK_ON_ERROR = true;
+var ReactionOptionsSchema = z2.object({
+  blockOnError: z2.boolean(),
+  maxRetries: z2.number().int().min(0),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveReactionConfig(options) {
+  return ReactionOptionsSchema.parse(options);
+}
+var ActionOptionsSchema = z2.object({
+  maxRetries: z2.number().int().min(0).optional(),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveActionConfig(options) {
+  return ActionOptionsSchema.parse(options);
+}
+var LaneConfigSchema = z2.object({
+  name: z2.string().min(1),
+  leaseMillis: z2.number().min(0).optional(),
+  streamLimit: z2.number().int().min(0).optional(),
+  cycleMs: z2.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 = z2.object({
+  streamLimit: z2.number().int().min(0).optional(),
+  eventLimit: z2.number().int().min(0).optional(),
+  leaseMillis: z2.number().min(0).optional()
+});
+function resolveDrainConfig(options) {
+  if (options === void 0) return void 0;
+  DrainOptionsSchema.parse(options);
+  return options;
+}
+var SettleOptionsSchema = DrainOptionsSchema.extend({
+  debounceMs: z2.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: z2.union([z2.number().int().min(0), z2.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 = z2.object({
+  // `0` is legal and is exactly today's behavior: stop scheduling and
+  // return without waiting.
+  graceMs: z2.number().min(0).optional()
+}).loose();
+function resolveShutdownConfig(options) {
+  if (options === void 0) return void 0;
+  ShutdownOptionsSchema.parse(options);
+  return options;
+}
+var ActOptionsSchema = z2.object({
+  maxSubscribedStreams: z2.number().int().min(1).optional(),
+  settleDebounceMs: z2.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 = z2.object({
+  start: z2.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
+  end: z2.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
+  timeZone: z2.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 = z2.object({
+  autocloseCycleMinutes: z2.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
+  closeBatchSize: z2.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
+  closeYieldMs: z2.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
+  closeOnError: z2.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 = z2.object({
+  failureThreshold: z2.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
+  cooldownMs: z2.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 = z2.object({
+  flushEvery: z2.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: z2.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 {
   /**
@@ -887,7 +1032,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();
@@ -1374,144 +1519,6 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
   return truncated;
 }
 
-// src/internal/config.ts
-import { z as z2 } from "zod";
-var BackoffOptionsSchema = z2.object({
-  strategy: z2.enum(["fixed", "linear", "exponential"]),
-  baseMs: z2.number().min(0),
-  maxMs: z2.number().gt(0).optional(),
-  jitter: z2.boolean().optional()
-});
-var ReactionOptionsSchema = z2.object({
-  blockOnError: z2.boolean(),
-  maxRetries: z2.number().int().min(0),
-  backoff: BackoffOptionsSchema.optional()
-});
-function resolveReactionConfig(options) {
-  return ReactionOptionsSchema.parse(options);
-}
-var ActionOptionsSchema = z2.object({
-  maxRetries: z2.number().int().min(0).optional(),
-  backoff: BackoffOptionsSchema.optional()
-});
-function resolveActionConfig(options) {
-  return ActionOptionsSchema.parse(options);
-}
-var LaneConfigSchema = z2.object({
-  name: z2.string().min(1),
-  leaseMillis: z2.number().min(0).optional(),
-  streamLimit: z2.number().int().min(0).optional(),
-  cycleMs: z2.number().min(0).optional()
-});
-function resolveLaneConfig(options) {
-  LaneConfigSchema.parse(options);
-  return options;
-}
-var DrainOptionsSchema = z2.object({
-  streamLimit: z2.number().int().min(0).optional(),
-  eventLimit: z2.number().int().min(0).optional(),
-  leaseMillis: z2.number().min(0).optional()
-});
-function resolveDrainConfig(options) {
-  if (options === void 0) return void 0;
-  DrainOptionsSchema.parse(options);
-  return options;
-}
-var SettleOptionsSchema = DrainOptionsSchema.extend({
-  debounceMs: z2.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: z2.union([z2.number().int().min(0), z2.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 = z2.object({
-  // `0` is legal and is exactly today's behavior: stop scheduling and
-  // return without waiting.
-  graceMs: z2.number().min(0).optional()
-}).loose();
-function resolveShutdownConfig(options) {
-  if (options === void 0) return void 0;
-  ShutdownOptionsSchema.parse(options);
-  return options;
-}
-var ActOptionsSchema = z2.object({
-  maxSubscribedStreams: z2.number().int().min(1).optional(),
-  settleDebounceMs: z2.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 = z2.object({
-  start: z2.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
-  end: z2.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
-  timeZone: z2.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 = z2.object({
-  autocloseCycleMinutes: z2.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
-  closeBatchSize: z2.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
-  closeYieldMs: z2.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
-  closeOnError: z2.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 = z2.object({
-  failureThreshold: z2.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
-  cooldownMs: z2.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 = z2.object({
-  flushEvery: z2.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
-  maxCachedStates: z2.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
-});
-function resolveFoldConfig(options) {
-  return FoldOptionsSchema.parse(options);
-}
-
 // src/internal/correlate-cycle.ts
 import { createHash, randomUUID } from "crypto";
 
@@ -1589,7 +1596,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.
@@ -1633,14 +1639,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
@@ -1661,7 +1659,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,
@@ -1675,7 +1672,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;
   }
@@ -1923,33 +1919,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.
    *
@@ -1980,12 +1949,6 @@ var CorrelateCycle = class {
       );
     }
   }
-  stop_polling() {
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = void 0;
-    }
-  }
 };
 
 // src/internal/correlator.ts
@@ -3083,9 +3046,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) => {
@@ -3459,10 +3422,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)]);
@@ -3488,6 +3449,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
@@ -3897,9 +3862,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
@@ -4489,86 +4451,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.
+   * 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
    *
-   * 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.
-   *
-   * **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());
   }
   /**
@@ -5225,8 +5164,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
       })
     };
@@ -5617,8 +5556,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];
@@ -5691,7 +5630,10 @@ function _projection(target) {
                   {
                     handler: noop,
                     resolver: { target },
-                    options: { blockOnError: true, maxRetries: 3 }
+                    options: {
+                      blockOnError: DEFAULT_BLOCK_ON_ERROR,
+                      maxRetries: DEFAULT_MAX_RETRIES
+                    }
                   }
                 ]
               ])