@rotorsoft/act 1.4.0 → 1.5.1

package/dist/index.cjs

@@ -204,10 +204,11 @@ var ConsoleLogger = class _ConsoleLogger {
 
 // src/internal/lru-map.ts
 var LruMap = class {
-  constructor(_maxSize) {
-    this._maxSize = _maxSize;
-  }
   _entries = /* @__PURE__ */ new Map();
+  _max_size;
+  constructor(maxSize) {
+    this._max_size = maxSize;
+  }
   get(key) {
     const v = this._entries.get(key);
     if (v === void 0) return void 0;
@@ -220,7 +221,7 @@ var LruMap = class {
   }
   set(key, value) {
     this._entries.delete(key);
-    if (this._entries.size >= this._maxSize) {
+    if (this._entries.size >= this._max_size) {
       const oldest = this._entries.keys().next().value;
       this._entries.delete(oldest);
     }
@@ -302,44 +303,70 @@ var Errors = {
   NonRetryableError: "ERR_NON_RETRYABLE"
 };
 var ValidationError = class extends Error {
+  /** The type of target being validated (e.g., "action", "event") */
+  target;
+  /** The invalid payload that failed validation */
+  payload;
+  /** Zod validation error details */
+  details;
   constructor(target, payload, details) {
     super(`Invalid ${target} payload`);
+    this.name = Errors.ValidationError;
     this.target = target;
     this.payload = payload;
     this.details = details;
-    this.name = Errors.ValidationError;
   }
 };
 var InvariantError = class extends Error {
+  /** The action that was attempted */
+  action;
+  /** The action payload that was provided */
+  payload;
+  /** The target stream and actor context */
+  target;
+  /** The current state snapshot when invariant was checked */
+  snapshot;
+  /** Human-readable description of why the invariant failed */
+  description;
   constructor(action2, payload, target, snapshot, description) {
     super(`${action2} failed invariant: ${description}`);
+    this.name = Errors.InvariantError;
     this.action = action2;
     this.payload = payload;
     this.target = target;
     this.snapshot = snapshot;
     this.description = description;
-    this.name = Errors.InvariantError;
   }
 };
 var ConcurrencyError = class extends Error {
+  /** The stream that had the concurrent modification */
+  stream;
+  /** The actual current version in the store */
+  lastVersion;
+  /** The events that were being committed */
+  events;
+  /** The version number that was expected */
+  expectedVersion;
   constructor(stream, lastVersion, events, expectedVersion) {
     super(
       `Concurrency error committing "${events.map((e) => `${stream}.${e.name}`).join(
         ", "
       )}". Expected version ${expectedVersion} but found version ${lastVersion}.`
     );
+    this.name = Errors.ConcurrencyError;
     this.stream = stream;
     this.lastVersion = lastVersion;
     this.events = events;
     this.expectedVersion = expectedVersion;
-    this.name = Errors.ConcurrencyError;
   }
 };
 var StreamClosedError = class extends Error {
+  /** The stream that is closed */
+  stream;
   constructor(stream) {
     super(`Stream "${stream}" is closed (tombstoned)`);
-    this.stream = stream;
     this.name = Errors.StreamClosedError;
+    this.stream = stream;
   }
 };
 var NonRetryableError = class extends Error {
@@ -495,12 +522,8 @@ async function sleep(ms) {
 
 // src/adapters/in-memory-store.ts
 var InMemoryStream = class {
-  constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
-    this.stream = stream;
-    this.source = source;
-    this._priority = priority;
-    this._lane = lane;
-  }
+  stream;
+  source;
   _at = -1;
   _retry = -1;
   _blocked = false;
@@ -509,6 +532,12 @@ var InMemoryStream = class {
   _leased_until = void 0;
   _priority = 0;
   _lane = DEFAULT_LANE;
+  constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
+    this.stream = stream;
+    this.source = source;
+    this._priority = priority;
+    this._lane = lane;
+  }
   get priority() {
     return this._priority;
   }
@@ -1902,18 +1931,23 @@ async function truncateAndWarmCache(guarded, seedStates, guardEvents, correlatio
 
 // src/internal/correlate-cycle.ts
 var CorrelateCycle = class {
-  constructor(registry, staticTargets, hasDynamicResolvers, cd, maxSubscribedStreams, onInit) {
-    this.registry = registry;
-    this.staticTargets = staticTargets;
-    this.hasDynamicResolvers = hasDynamicResolvers;
-    this.cd = cd;
-    this.onInit = onInit;
-    this._subscribed = new LruSet(maxSubscribedStreams);
-  }
   _checkpoint = -1;
   _initialized = false;
   _timer = void 0;
   _subscribed;
+  _registry;
+  _static_targets;
+  _has_dynamic_resolvers;
+  _cd;
+  _on_init;
+  constructor(registry, staticTargets, hasDynamicResolvers, cd, maxSubscribedStreams, onInit) {
+    this._subscribed = new LruSet(maxSubscribedStreams);
+    this._registry = registry;
+    this._static_targets = staticTargets;
+    this._has_dynamic_resolvers = hasDynamicResolvers;
+    this._cd = cd;
+    this._on_init = onInit;
+  }
   /** Last correlated event id. */
   get checkpoint() {
     return this._checkpoint;
@@ -1928,10 +1962,10 @@ var CorrelateCycle = class {
   async init() {
     if (this._initialized) return;
     this._initialized = true;
-    const { watermark } = await store2().subscribe([...this.staticTargets]);
+    const { watermark } = await store2().subscribe([...this._static_targets]);
     this._checkpoint = watermark;
-    this.onInit?.();
-    for (const { stream } of this.staticTargets) {
+    this._on_init?.();
+    for (const { stream } of this._static_targets) {
       this._subscribed.add(stream);
     }
   }
@@ -1942,7 +1976,7 @@ var CorrelateCycle = class {
    */
   async correlate(query = { after: -1, limit: 10 }) {
     await this.init();
-    if (!this.hasDynamicResolvers)
+    if (!this._has_dynamic_resolvers)
       return { subscribed: 0, last_id: this._checkpoint };
     const after = Math.max(this._checkpoint, query.after || -1);
     const correlated = /* @__PURE__ */ new Map();
@@ -1950,7 +1984,7 @@ var CorrelateCycle = class {
     await store2().query(
       (event) => {
         last_id = event.id;
-        const register = this.registry.events[event.name];
+        const register = this._registry.events[event.name];
         if (register) {
           for (const reaction of register.reactions.values()) {
             if (typeof reaction.resolver !== "function") continue;
@@ -1986,7 +2020,7 @@ var CorrelateCycle = class {
           lane
         })
       );
-      const { subscribed } = await this.cd.subscribe(streams);
+      const { subscribed } = await this._cd.subscribe(streams);
       this._checkpoint = last_id;
       if (subscribed) {
         for (const { stream } of streams) {
@@ -2610,9 +2644,6 @@ var EMPTY_DRAIN = {
   blocked: []
 };
 var DrainController = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
   _armed = false;
   _locked = false;
   _ratio = 0.5;
@@ -2628,6 +2659,10 @@ var DrainController = class {
   /** Worker timer (ACT-1103). Set when `start()` is active, undefined otherwise. */
   _worker;
   _stopped = false;
+  _deps;
+  constructor(deps) {
+    this._deps = deps;
+  }
   /**
    * Signal that a commit (or reset / cold-start) may have produced work.
    * Subsequent `drain()` calls will run the pipeline; once the pipeline
@@ -2668,7 +2703,7 @@ var DrainController = class {
   }
   /** Lane this controller drains (undefined = legacy single-lane span). */
   get lane() {
-    return this.deps.lane;
+    return this._deps.lane;
   }
   /**
    * Start a per-lane worker that drains at the lane's `cycleMs`
@@ -2702,7 +2737,7 @@ var DrainController = class {
   async drain(options = {}) {
     if (!this._armed) return EMPTY_DRAIN;
     if (this._locked) return EMPTY_DRAIN;
-    const d = this.deps.defaults ?? {};
+    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;
@@ -2711,24 +2746,24 @@ var DrainController = class {
       const lagging = Math.ceil(streamLimit * this._ratio);
       const leading = streamLimit - lagging;
       const cycle = await runDrainCycle(
-        this.deps.ops,
-        this.deps.registry,
-        this.deps.batchHandlers,
-        this.deps.handle,
-        this.deps.handleBatch,
+        this._deps.ops,
+        this._deps.registry,
+        this._deps.batchHandlers,
+        this._deps.handle,
+        this._deps.handleBatch,
         lagging,
         leading,
         eventLimit,
         leaseMillis,
         this._backoff.size > 0 ? this.isDeferred : void 0,
-        this.deps.lane
+        this._deps.lane
       );
       if (!cycle) {
         this._armed = false;
         return EMPTY_DRAIN;
       }
       const { leased, fetched, handled, acked, blocked } = cycle;
-      traceCycle(this.deps.logger, leased, fetched, handled, acked, blocked);
+      traceCycle(this._deps.logger, leased, fetched, handled, acked, blocked);
       this._ratio = computeLagLeadRatio(handled, lagging, leading);
       for (const lease of acked) this._backoff.delete(lease.stream);
       for (const lease of blocked) this._backoff.delete(lease.stream);
@@ -2738,13 +2773,13 @@ var DrainController = class {
         }
       }
       if (this._backoff.size > 0) this.scheduleBackoffWake();
-      if (acked.length) this.deps.onAcked(acked);
-      if (blocked.length) this.deps.onBlocked(blocked);
+      if (acked.length) this._deps.onAcked(acked);
+      if (blocked.length) this._deps.onBlocked(blocked);
       const hasErrors = handled.some(({ error }) => error);
       if (!acked.length && !blocked.length && !hasErrors) this._armed = false;
       return { fetched, leased, acked, blocked };
     } catch (error) {
-      this.deps.logger.error(error);
+      this._deps.logger.error(error);
       return EMPTY_DRAIN;
     } finally {
       this._locked = false;
@@ -3005,12 +3040,15 @@ function buildHandleBatch(logger) {
 
 // src/internal/settle.ts
 var SettleLoop = class {
-  constructor(deps, defaultDebounceMs) {
-    this.deps = deps;
-    this.defaultDebounceMs = defaultDebounceMs;
-  }
   _timer = void 0;
   _running = false;
+  _deps;
+  /** Debounce window applied when the caller doesn't override via `SettleOptions.debounceMs`. */
+  _default_debounce_ms;
+  constructor(deps, defaultDebounceMs) {
+    this._deps = deps;
+    this._default_debounce_ms = defaultDebounceMs;
+  }
   /**
    * Schedule a settle pass. Multiple calls inside the debounce window
    * coalesce into one cycle. The cycle runs correlate→drain in a loop
@@ -3020,7 +3058,7 @@ var SettleLoop = class {
    */
   schedule(options = {}) {
     const {
-      debounceMs = this.defaultDebounceMs,
+      debounceMs = this._default_debounce_ms,
       correlate: correlateQuery = { after: -1, limit: 100 },
       maxPasses = Infinity,
       ...drainOptions
@@ -3031,19 +3069,19 @@ var SettleLoop = class {
       if (this._running) return;
       this._running = true;
       (async () => {
-        await this.deps.init();
+        await this._deps.init();
         let lastDrain;
         for (let i = 0; i < maxPasses; i++) {
-          const { subscribed } = await this.deps.correlate({
+          const { subscribed } = await this._deps.correlate({
             ...correlateQuery,
-            after: this.deps.checkpoint()
+            after: this._deps.checkpoint()
           });
-          lastDrain = await this.deps.drain(drainOptions);
+          lastDrain = await this._deps.drain(drainOptions);
           const made_progress = subscribed > 0 || lastDrain.acked.length > 0 || lastDrain.blocked.length > 0;
           if (!made_progress) break;
         }
-        if (lastDrain) this.deps.onSettled(lastDrain);
-      })().catch((err) => this.deps.logger.error(err)).finally(() => {
+        if (lastDrain) this._deps.onSettled(lastDrain);
+      })().catch((err) => this._deps.logger.error(err)).finally(() => {
         this._running = false;
       });
     }, debounceMs);
@@ -3061,6 +3099,117 @@ var SettleLoop = class {
 var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
 var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
 var Act = class {
+  _emitter = new import_node_events.default();
+  /** #803: gate the `Store.notify` subscription side. */
+  _listen;
+  /** #803: gate the local reaction pipeline (drain controllers, settle, correlate). */
+  _drain;
+  /** Event names with at least one registered reaction (computed at build time) */
+  _reactive_events;
+  /** One DrainController per active lane, keyed by lane name. */
+  _drain_controllers;
+  /** Correlation state machine: lazy init, dynamic-resolver scan, periodic worker. */
+  _correlate;
+  /** Debounced correlate→drain catch-up loop. */
+  _settle;
+  /**
+   * Disposer for the cross-process notify subscription, set up eagerly
+   * during construction. Held as a promise because the subscription
+   * itself may be async (the PG adapter checks out a dedicated client
+   * and runs `LISTEN` before resolving). Resolves to `undefined` when
+   * the store doesn't implement `notify` or there are no registered
+   * reactions.
+   *
+   * **Contract:** the configured store must be injected via
+   * {@link store}`(adapter)` *before* calling `act()...build()`. The
+   * orchestrator wires notify against whatever store is current at
+   * construction time — late injection after build is unsupported.
+   */
+  _notify_disposer;
+  /** Public registry — kept as-is per the no-prefix-on-public convention. */
+  registry;
+  /** Map of state name → state definition; populated by the builder. */
+  _states;
+  /**
+   * Emit a lifecycle event. The payload type is inferred from the event name
+   * via {@link ActLifecycleEvents}.
+   */
+  emit(event, args) {
+    return this._emitter.emit(event, args);
+  }
+  /**
+   * Register a listener for a lifecycle event. The listener receives the
+   * event-specific payload.
+   */
+  on(event, listener) {
+    this._emitter.on(event, listener);
+    return this;
+  }
+  /**
+   * Remove a previously registered lifecycle listener.
+   */
+  off(event, listener) {
+    this._emitter.off(event, listener);
+    return this;
+  }
+  /** Batch handlers for static-target projections (target → handler) */
+  _batch_handlers;
+  /** Event-sourcing handlers, optionally wrapped with trace decorators */
+  _es;
+  /** Correlate/drain pipeline ops, optionally wrapped with trace decorators */
+  _cd;
+  /**
+   * Event-name → owning state, computed at build time. The duplicate-event
+   * guard in merge.ts ensures one event name maps to at most one state, so
+   * this lookup is unambiguous. Used by `close()` to pick the right reducer
+   * set when seeding a `restart` snapshot in multi-state apps.
+   */
+  _event_to_state;
+  /**
+   * Event-name → lane fan-in for selective arming (ACT-1103). Built by
+   * `classifyRegistry` once per build. `"all"` means at least one of
+   * the event's reactions is a dynamic resolver (lane opaque until
+   * runtime); a `Set<string>` lists the static lanes only that event's
+   * reactions target.
+   */
+  _event_to_lanes;
+  /**
+   * Audit dependency bag (#723). Built once at construction; held as
+   * an immutable snapshot of the registry state the audit module
+   * needs. Lives in `internal/audit.ts` — this orchestrator never
+   * carries audit logic, only the deps + a one-liner that hands them
+   * over.
+   */
+  _audit_deps;
+  /** Logger resolved at construction time (after user port configuration) */
+  _logger = log();
+  /** Wraps a public-method body so internal `store()`/`cache()` resolve to the
+   * per-Act ports (ACT-501). No-op when the Act is unscoped — so the singleton
+   * path keeps reading fresh `store()`/`cache()` per call, which matters for
+   * tests that dispose and re-seed mid-suite. */
+  _scoped;
+  /**
+   * Correlation-id generator for originating actions. Bound at
+   * construction from `options.correlator ?? defaultCorrelator`. The
+   * `do()` path passes this into the `_es.action` closure; close-cycle
+   * uses it via {@link closeCorrelation}.
+   */
+  _correlator;
+  /** Pre-bound IAct methods reused across drain cycles. Only `do` varies per
+   * payload (it captures the triggering event for reactingTo auto-inject). */
+  _bound_do = this.do.bind(this);
+  _bound_load = this.load.bind(this);
+  _bound_query = this.query.bind(this);
+  _bound_query_array = this.query_array.bind(this);
+  /** Reaction dispatchers built once and handed to runDrainCycle each cycle. */
+  _handle;
+  _handle_batch;
+  /** Declared drain lanes (ACT-1103). */
+  _lanes;
+  /** Drain lanes declared via `.withLane(...)`. Implicit default not included. */
+  get lanes() {
+    return this._lanes;
+  }
   /**
    * Create a new Act orchestrator. Prefer the {@link act} builder over
    * direct construction — `act()...build()` wires the registry, merges
@@ -3068,16 +3217,16 @@ var Act = class {
    * and projections in one pass.
    *
    * @param registry  Schemas for every event and action across registered states
-   * @param _states   Merged map of state name → state definition
+   * @param states    Merged map of state name → state definition
    * @param batchHandlers Static-target projection batch handlers (target → handler)
    * @param options   Tuning knobs — see {@link ActOptions}
    * @param lanes     Declared drain lanes (ACT-1103). The builder collects
    *   these from `.withLane(...)` calls. Slice 1 records them on the
    *   instance; later slices fan out one `DrainController` per lane.
    */
-  constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map(), options = {}, lanes = []) {
+  constructor(registry, states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map(), options = {}, lanes = []) {
     this.registry = registry;
-    this._states = _states;
+    this._states = states;
     this._batch_handlers = batchHandlers;
     this._lanes = lanes;
     if (options.onlyLanes && options.onlyLanes.length > 0) {
@@ -3111,6 +3260,8 @@ var Act = class {
       eventToLanes
     } = classifyRegistry(this.registry, this._states);
     this._reactive_events = reactiveEvents;
+    this._listen = options.listen !== false;
+    this._drain = options.drain !== false;
     this._event_to_state = eventToState;
     this._event_to_lanes = eventToLanes;
     const allLanes = ["default", ...lanes.map((l) => l.name)];
@@ -3138,7 +3289,8 @@ var Act = class {
           leaseMillis: cfg.leaseMillis
         }
       });
-      if (cfg?.cycleMs !== void 0) controller.start(cfg.cycleMs);
+      if (cfg?.cycleMs !== void 0 && options.drain !== false)
+        controller.start(cfg.cycleMs);
       this._drain_controllers.set(name, controller);
     }
     this._audit_deps = {
@@ -3156,9 +3308,10 @@ var Act = class {
       hasDynamicResolvers,
       this._cd,
       options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
-      // Cold start: assume drain is needed (historical events may need processing)
+      // Cold start: assume drain is needed (historical events may need processing).
+      // #803: writer-only instances skip the cold-start arm.
       () => {
-        if (this._reactive_events.size > 0) this._armAll();
+        if (this._drain && this._reactive_events.size > 0) this._armAll();
       }
     );
     this._settle = new SettleLoop(
@@ -3175,109 +3328,6 @@ var Act = class {
     this._notify_disposer = this._wireNotify(options.scoped?.store ?? store2());
     dispose(() => this.shutdown());
   }
-  _emitter = new import_node_events.default();
-  /** Event names with at least one registered reaction (computed at build time) */
-  _reactive_events;
-  /** One DrainController per active lane, keyed by lane name. */
-  _drain_controllers;
-  /** Correlation state machine: lazy init, dynamic-resolver scan, periodic worker. */
-  _correlate;
-  /** Debounced correlate→drain catch-up loop. */
-  _settle;
-  /**
-   * Disposer for the cross-process notify subscription, set up eagerly
-   * during construction. Held as a promise because the subscription
-   * itself may be async (the PG adapter checks out a dedicated client
-   * and runs `LISTEN` before resolving). Resolves to `undefined` when
-   * the store doesn't implement `notify` or there are no registered
-   * reactions.
-   *
-   * **Contract:** the configured store must be injected via
-   * {@link store}`(adapter)` *before* calling `act()...build()`. The
-   * orchestrator wires notify against whatever store is current at
-   * construction time — late injection after build is unsupported.
-   */
-  _notify_disposer;
-  /**
-   * Emit a lifecycle event. The payload type is inferred from the event name
-   * via {@link ActLifecycleEvents}.
-   */
-  emit(event, args) {
-    return this._emitter.emit(event, args);
-  }
-  /**
-   * Register a listener for a lifecycle event. The listener receives the
-   * event-specific payload.
-   */
-  on(event, listener) {
-    this._emitter.on(event, listener);
-    return this;
-  }
-  /**
-   * Remove a previously registered lifecycle listener.
-   */
-  off(event, listener) {
-    this._emitter.off(event, listener);
-    return this;
-  }
-  /** Batch handlers for static-target projections (target → handler) */
-  _batch_handlers;
-  /** Event-sourcing handlers, optionally wrapped with trace decorators */
-  _es;
-  /** Correlate/drain pipeline ops, optionally wrapped with trace decorators */
-  _cd;
-  /**
-   * Event-name → owning state, computed at build time. The duplicate-event
-   * guard in merge.ts ensures one event name maps to at most one state, so
-   * this lookup is unambiguous. Used by `close()` to pick the right reducer
-   * set when seeding a `restart` snapshot in multi-state apps.
-   */
-  _event_to_state;
-  /**
-   * Event-name → lane fan-in for selective arming (ACT-1103). Built by
-   * `classifyRegistry` once per build. `"all"` means at least one of
-   * the event's reactions is a dynamic resolver (lane opaque until
-   * runtime); a `Set<string>` lists the static lanes only that event's
-   * reactions target.
-   */
-  _event_to_lanes;
-  /**
-   * Audit dependency bag (#723). Built once at construction; held as
-   * an immutable snapshot of the registry state the audit module
-   * needs. Lives in `internal/audit.ts` — this orchestrator never
-   * carries audit logic, only the deps + a one-liner that hands them
-   * over.
-   */
-  _audit_deps;
-  /** Logger resolved at construction time (after user port configuration) */
-  _logger = log();
-  /** Wraps a public-method body so internal `store()`/`cache()` resolve to the
-   * per-Act ports (ACT-501). No-op when the Act is unscoped — so the singleton
-   * path keeps reading fresh `store()`/`cache()` per call, which matters for
-   * tests that dispose and re-seed mid-suite. */
-  _scoped;
-  /**
-   * Correlation-id generator for originating actions. Bound at
-   * construction from `options.correlator ?? defaultCorrelator`. The
-   * `do()` path passes this into the `_es.action` closure; close-cycle
-   * uses it via {@link closeCorrelation}.
-   */
-  _correlator;
-  /** Pre-bound IAct methods reused across drain cycles. Only `do` varies per
-   * payload (it captures the triggering event for reactingTo auto-inject). */
-  _bound_do = this.do.bind(this);
-  _bound_load = this.load.bind(this);
-  _bound_query = this.query.bind(this);
-  _bound_query_array = this.query_array.bind(this);
-  /** Reaction dispatchers built once and handed to runDrainCycle each cycle. */
-  _handle;
-  _handle_batch;
-  /** Declared drain lanes (ACT-1103). */
-  _lanes;
-  /** Drain lanes declared via `.withLane(...)`. Implicit default not included. */
-  get lanes() {
-    return this._lanes;
-  }
   /** True after the first `shutdown()` call. Guards idempotency. */
   _shutdown_promise;
   /**
@@ -3312,14 +3362,17 @@ var Act = class {
   async _wireNotify(s) {
     if (this._reactive_events.size === 0) return void 0;
     if (!s.notify) return void 0;
+    if (!this._listen) return void 0;
     try {
       return await s.notify((notification) => {
         try {
           this.emit("notified", notification);
-          const armed = this._armForEventNames(
-            notification.events.map((e) => e.name)
-          );
-          if (armed) this._settle.schedule({ debounceMs: 0 });
+          if (this._drain) {
+            const armed = this._armForEventNames(
+              notification.events.map((e) => e.name)
+            );
+            if (armed) this._settle.schedule({ debounceMs: 0 });
+          }
         } catch (err) {
           this._logger.error(err, "notified handler threw");
         }
@@ -3570,6 +3623,8 @@ var Act = class {
    * @see {@link start_correlations} for automatic correlation
    */
   async drain(options = {}) {
+    if (!this._drain)
+      return { fetched: [], leased: [], acked: [], blocked: [] };
     return this._scoped(() => this._drainAll(options));
   }
   /** Arm every active lane controller (ACT-1103). */
@@ -3670,6 +3725,7 @@ var Act = class {
    * @see {@link stop_correlations} to stop automatic correlation
    */
   async correlate(query = { after: -1, limit: 10 }) {
+    if (!this._drain) return { subscribed: 0, last_id: -1 };
     return this._scoped(() => this._correlate.correlate(query));
   }
   /**
@@ -4095,6 +4151,7 @@ var Act = class {
    * @see {@link correlate} for manual correlation
    */
   settle(options = {}) {
+    if (!this._drain) return;
     this._settle.schedule(options);
   }
 };