@rotorsoft/act 1.32.19 → 1.32.21

package/dist/index.js

@@ -1665,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;
@@ -1838,6 +1839,8 @@ var CorrelateCycle = class {
               priority: carried.priority,
               lane: carried.lane,
               upgraded,
+              missed: !recorded,
+              handler: reaction.handler.name,
               correlated_at: void 0
             };
             const seen_in_scan = correlated.has(resolved.target);
@@ -1856,6 +1859,7 @@ var CorrelateCycle = class {
               entry.priority = carried.priority;
               entry.lane = carried.lane;
               entry.upgraded = upgraded;
+              entry.handler = reaction.handler.name;
             }
             if (this._in_fetch_window(resolved.source, event.stream))
               entry.correlated_at = event.id;
@@ -1869,6 +1873,7 @@ var CorrelateCycle = class {
       // actor-less, so plaintext here would be un-gated disclosure.
       { ...query, after, with_pii: false }
     );
+    if (this._declared_lanes.size > 1) await this._recall(correlated);
     const streams = [];
     for (const [stream, entry] of correlated) {
       if (entry.upgraded || entry.correlated_at !== void 0)
@@ -1907,6 +1912,50 @@ var CorrelateCycle = class {
     this._armed = found === query.limit;
     return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
+  /**
+   * Give each target this scan had no record of the record its row holds.
+   *
+   * A target with no record is either new or forgotten. Its row, when it
+   * has one, says what lane and priority it was subscribed at; a resolution
+   * that doesn't beat that priority carries the row's values, exactly as if
+   * the record had never been evicted. One read per target with no record,
+   * and only when more than one lane is declared: with one lane there is no
+   * lane to lose, and the store already keeps the higher priority.
+   */
+  async _recall(correlated) {
+    const missed = [...correlated].filter(([, entry]) => entry.missed);
+    await Promise.all(
+      missed.map(async ([stream, entry]) => {
+        let row;
+        await store().query_streams(
+          (position) => {
+            row = position;
+          },
+          { stream, stream_exact: true, limit: 1 }
+        );
+        if (!row) return;
+        this._dynamic_subscriptions.set(stream, {
+          floor: row.priority,
+          priority: row.priority,
+          lane: row.lane
+        });
+        if (entry.priority > row.priority) return;
+        const held_lane = row.lane ?? DEFAULT_LANE;
+        const resolved_lane = entry.lane ?? DEFAULT_LANE;
+        if (entry.priority === row.priority && held_lane !== resolved_lane)
+          report_lane_conflict(
+            this._reported,
+            entry.handler,
+            stream,
+            held_lane,
+            resolved_lane
+          );
+        entry.priority = row.priority;
+        entry.lane = row.lane;
+        entry.upgraded = false;
+      })
+    );
+  }
   /**
    * Hand the correlation lease back early.
    *
@@ -2066,9 +2115,8 @@ var DeferTimer = class {
   _timer;
   _on_wake;
   /**
-   * @param on_wake - invoked once each time the earliest due-time elapses,
-   *   after the come-due entries have been removed. The consumer re-schedules
-   *   for whatever is still parked.
+   * @param on_wake - invoked once each time the earliest due-time elapses.
+   *   The consumer re-schedules for whatever is still parked.
    */
   constructor(on_wake) {
     this._on_wake = on_wake;
@@ -2098,6 +2146,16 @@ var DeferTimer = class {
   delete(stream) {
     this._due.delete(stream);
   }
+  /**
+   * Drop every entry due at or before `before`. The drain calls it when a
+   * pass that started at `before` claimed nothing: whatever was due by then
+   * was handled elsewhere (another worker) or has no work left, so waking
+   * for it again would spin.
+   */
+  prune(before) {
+    for (const [stream, at] of this._due)
+      if (at <= before) this._due.delete(stream);
+  }
   /**
    * (Re)schedule the wake timer at the earliest pending due-time. Idempotent
    * — collapses many parked streams into a single timer. A no-op clears any
@@ -2120,9 +2178,6 @@ var DeferTimer = class {
     );
     this._timer = setTimeout(() => {
       this._timer = void 0;
-      const now = Date.now();
-      for (const [stream, at] of this._due)
-        if (at <= now) this._due.delete(stream);
       this._on_wake();
     }, delay);
     this._timer.unref();
@@ -2891,6 +2946,9 @@ var DrainController = class {
    * 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.
+   * Every drain re-aims it when it ends, and a due entry stays until a pass
+   * handles it or a pass that started after it came due claims nothing, so
+   * the wake keeps draining until every due stream is reached.
    * `stop()` cancels the timer and a stopped drain never re-schedules it,
    * so a wake never runs after a stop.
    */
@@ -2988,15 +3046,16 @@ var DrainController = class {
     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;
+    if (this._deps.breaker.state(Date.now()) === "open")
+      return EMPTY_DRAIN;
     try {
-      if (this._deps.breaker.state(Date.now()) === "open")
-        return EMPTY_DRAIN;
       this._locked = true;
       this._inflight = new Promise((done) => {
         this._inflight_done = done;
       });
       const lagging = Math.ceil(streamLimit * this._ratio);
       const leading = streamLimit - lagging;
+      const started = Date.now();
       const cycle = await run_drain_cycle(this._deps, {
         lagging,
         leading,
@@ -3006,6 +3065,7 @@ var DrainController = class {
         store_failing: this._deps.breaker.failing
       });
       if (!cycle) {
+        this._defer.prune(started);
         this._deps.breaker.passed();
         this._armed = false;
         return EMPTY_DRAIN;
@@ -3671,6 +3731,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 +4429,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 +4441,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) {