@rotorsoft/act 1.32.18 → 1.32.20

package/dist/index.js

@@ -859,6 +859,10 @@ var BackoffOptionsSchema = z2.object({
   maxMs: z2.number().gt(0).optional(),
   jitter: z2.boolean().optional()
 });
+var DEFAULT_BACKOFF = {
+  strategy: "fixed",
+  baseMs: 1e4
+};
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_BLOCK_ON_ERROR = true;
 var ReactionOptionsSchema = z2.object({
@@ -1661,13 +1665,14 @@ var CorrelateCycle = class {
     cd,
     max_subscribed_streams,
     declared_lanes,
+    shard,
     on_init,
     on_init_async,
     cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN,
     lease_millis = DEFAULT_CORRELATION_LEASE_MS
   }) {
     this._lease_millis = lease_millis;
-    this._key = registry_key(registry.events);
+    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;
     this._declared_lanes = declared_lanes;
@@ -2063,9 +2068,8 @@ var DeferTimer = class {
   _on_wake;
   /**
    * @param on_wake - invoked once each time the earliest due-time elapses,
-   *   after the come-due entries have been removed. Consumers use it to
-   *   re-arm their loop (the drain sets its `armed` flag; autoclose runs a
-   *   tick).
+   *   after the come-due entries have been removed. The consumer re-schedules
+   *   for whatever is still parked.
    */
   constructor(on_wake) {
     this._on_wake = on_wake;
@@ -2118,14 +2122,9 @@ var DeferTimer = class {
     this._timer = setTimeout(() => {
       this._timer = void 0;
       const now = Date.now();
-      let came_due = false;
       for (const [stream, at] of this._due)
-        if (at <= now) {
-          this._due.delete(stream);
-          came_due = true;
-        }
+        if (at <= now) this._due.delete(stream);
       this._on_wake();
-      if (!came_due && this._due.size > 0) this.schedule();
     }, delay);
     this._timer.unref();
   }
@@ -2842,7 +2841,7 @@ async function run_drain_cycle(deps, cycle) {
           handled: 0,
           acked_at: lease.at,
           error,
-          ...block2 ? { block: true } : {}
+          ...block2 ? { block: true } : { next_attempt_at: Date.now() + DEFAULT_BACKOFF.baseMs }
         };
         return Promise.resolve(failed);
       }
@@ -2890,11 +2889,15 @@ var DrainController = class {
   _ratio = 0.5;
   /**
    * Local wake for streams this worker parked (backoff or defer). The
-   * schedule itself is persisted in the store; this only re-arms the drain
-   * at the earliest pending visit.
+   * schedule itself is persisted in the store; this runs the drain at the
+   * earliest pending visit. A parked stream already carries its mark, so
+   * the drain alone finds it, and on an idle app nothing else would.
+   * `stop()` cancels the timer and a stopped drain never re-schedules it,
+   * so a wake never runs after a stop.
    */
   _defer = new DeferTimer(() => {
     this._armed = true;
+    void this._deps.run_scoped(() => this.drain());
   });
   /** Worker timer. Set when `start()` is active, undefined otherwise. */
   _worker;
@@ -2982,13 +2985,13 @@ var DrainController = class {
   async drain(options = {}) {
     if (!this._armed) return EMPTY_DRAIN;
     if (this._locked) return EMPTY_DRAIN;
-    if (this._deps.breaker.state(Date.now()) === "open")
-      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 leaseMillis = d.leaseMillis ?? options.leaseMillis ?? DEFAULT_LEASE_MILLIS;
     try {
+      if (this._deps.breaker.state(Date.now()) === "open")
+        return EMPTY_DRAIN;
       this._locked = true;
       this._inflight = new Promise((done) => {
         this._inflight_done = done;
@@ -3006,7 +3009,6 @@ var DrainController = class {
       if (!cycle) {
         this._deps.breaker.passed();
         this._armed = false;
-        if (this._defer.size > 0) this._defer.schedule();
         return EMPTY_DRAIN;
       }
       const { leased, fetched, handled, acked, blocked, closeable } = cycle;
@@ -3015,11 +3017,9 @@ var DrainController = class {
       for (const lease of acked) this._defer.delete(lease.stream);
       for (const lease of blocked) this._defer.delete(lease.stream);
       for (const h of handled) {
-        const retry_at = h.error && !h.block ? h.next_attempt_at ?? Date.now() + leaseMillis : void 0;
-        const next = h.defer ?? retry_at;
+        const next = h.defer ?? h.next_attempt_at;
         if (next !== void 0) this._defer.set(h.lease.stream, next);
       }
-      if (this._defer.size > 0) this._defer.schedule();
       if (acked.length) this._deps.on_acked(acked);
       if (closeable.length) await this._deps.on_close(closeable);
       this._deps.breaker.passed();
@@ -3030,6 +3030,7 @@ var DrainController = class {
       this._deps.breaker.failed(Date.now(), error);
       return EMPTY_DRAIN;
     } finally {
+      if (!this._stopped) this._defer.schedule();
       this._locked = false;
       this._inflight = void 0;
       this._inflight_done?.();
@@ -3235,7 +3236,7 @@ function finalize(lease, handled, at, error, options, logger, failed_at) {
     logger.error(
       non_retryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
     );
-  const next_attempt_at = !block2 && options.backoff ? Date.now() + compute_backoff_delay(lease.retry, options.backoff) : void 0;
+  const next_attempt_at = block2 ? void 0 : Date.now() + compute_backoff_delay(lease.retry, options.backoff ?? DEFAULT_BACKOFF);
   return {
     lease,
     handled,
@@ -3671,6 +3672,8 @@ var Act = class {
       // Declared lanes (not active ones): a lane another process claims is
       // still a valid destination.
       declared_lanes: new Set(this._declared_lanes),
+      // Built after the controllers, so their keys are the active lanes.
+      shard: this._drain_controllers.size < this._declared_lanes.length ? [...this._drain_controllers.keys()] : void 0,
       on_init: () => {
         if (this._drain && this._reactive_events.size > 0) this._arm_all();
       },
@@ -4367,11 +4370,11 @@ var Act = class {
     });
   }
   /**
-   * Atomically wipe the store and rebuild it from an async stream of
-   * committed events. The framework owns iteration, validation,
-   * `drop_snapshots` filtering, `on_progress`, and the per-call
-   * `old → new` causation remap; the adapter's {@link Store.restore}
-   * driver supplies the transaction lifecycle and per-event insert.
+   * Atomically wipe the store and rebuild it from an event source. The
+   * framework owns iteration, validation, `drop_snapshots` filtering,
+   * `on_progress`, and the per-call `old → new` causation remap; the
+   * adapter's {@link Store.restore} driver supplies the transaction
+   * lifecycle and per-event insert.
    *
    * Throws if the adapter has no restore capability. Throws on the
    * first invalid event (negative version, malformed `created`) with
@@ -4379,33 +4382,30 @@ var Act = class {
    * the adapter means a failing restore leaves the store byte-for-byte
    * unchanged.
    *
-   * @param source - Async stream of events in target order. Streamed
-   *   rather than buffered so multi-million-event backups don't OOM.
-   *   Each event's original `id` is used as a causation lookup key but
-   *   never written through — adapters renumber densely.
+   * @param source - Any {@link EventSource}: a `CsvFile` backup or
+   *   another store. Read in batches rather than buffered, so
+   *   multi-million-event backups don't OOM. Each event's original `id`
+   *   is used as a causation lookup key but never written through —
+   *   adapters renumber densely.
    * @param opts - {@link ScanOptions}. `drop_snapshots` skips
    *   `__snapshot__` events (counted in the result); `on_progress`
    *   fires once per event.
+   * @param sink - Where the events land. Defaults to this Act's store.
    * @returns {@link ScanResult} with `kept`, `duration_ms`, and
    *   `dropped` per-category counters.
    *
-   * @example Round-trip a CSV backup
+   * @example Restore a CSV backup into the connected store
    * ```typescript
-   * async function* parseCsv(blob: string) {
-   *   for (const line of blob.split("\n").slice(1)) {
-   *     const [id, name, data, stream, version, created, meta] = parse(line);
-   *     yield {
-   *       id: +id, name, data: JSON.parse(data), stream,
-   *       version: +version, created: new Date(created),
-   *       meta: JSON.parse(meta),
-   *     };
-   *   }
-   * }
-   * const result = await app.restore(parseCsv(csvBlob), {});
+   * const result = await app.restore(new CsvFile({ path: "./backup.csv" }));
    * console.log(`Restored ${result.kept} events in ${result.duration_ms}ms`);
    * await cache().clear();   // operator's responsibility
    * ```
    *
+   * @example Copy one store into another
+   * ```typescript
+   * await app.restore(pg, {}, sqlite);
+   * ```
+   *
    * @see {@link Store.restore} for the underlying driver-pattern primitive.
    */
   async restore(source, opts = {}, sink) {