@rotorsoft/act 1.33.16 → 1.33.18

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-E5H3NRCT.js";
+} from "./chunk-3OTABSIB.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -70,7 +70,7 @@ import {
   pii_fields,
   pii_schemas,
   sensitive
-} from "./chunk-CAL4XEVN.js";
+} from "./chunk-SD7SW47Z.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -1168,10 +1168,13 @@ var CorrelateCycle = class {
   _raised = 1;
   _lowered = 0;
   /**
-   * Bumped by a release (shutdown) and a restart (restore), so a scan or
-   * lease reply that was out across one writes nothing.
+   * Bumped by a release (shutdown), so a scan or lease reply that was out
+   * across one writes nothing.
    */
   _epoch = 0;
+  /** Passes in flight: a restore waits for them, and refuses new ones. */
+  _passes = /* @__PURE__ */ new Set();
+  _restoring = false;
   _init_promise;
   // Bounded by `maxSubscribedStreams`; static records live apart so eviction
   // never drops their +Infinity floor.
@@ -1230,14 +1233,22 @@ var CorrelateCycle = class {
     }
     await this._on_init?.();
   }
-  /** After `restore` replaced the log: forget everything and cold-start again. */
-  restart() {
+  /**
+   * Replace the log with no pass in flight, then cold-start: a pass that
+   * read the old log writes before the restore, never into the new one.
+   */
+  async restart(restore) {
+    this._restoring = true;
+    try {
+      await Promise.allSettled(this._passes);
+      await restore();
+    } finally {
+      this._restoring = false;
+    }
     this._init_promise = void 0;
     this._checkpoint = -1;
     this._dynamic_subscriptions.clear();
     this._static_subscriptions.clear();
-    this._raised++;
-    this._epoch++;
   }
   /** Forget dynamic targets whose rows a full close deleted, so they re-subscribe. */
   forget_subscribed(streams) {
@@ -1256,6 +1267,16 @@ var CorrelateCycle = class {
   }
   /** Scan past the checkpoint, subscribe new targets and raise their work marks. */
   async correlate(query, lease = false) {
+    if (this._restoring) return { kind: "idle", last_id: this._checkpoint };
+    const pass = this._scan(query, lease);
+    this._passes.add(pass);
+    try {
+      return await pass;
+    } finally {
+      this._passes.delete(pass);
+    }
+  }
+  async _scan(query, lease) {
     await this._init();
     const epoch = this._epoch;
     const idle = () => ({
@@ -1275,7 +1296,7 @@ var CorrelateCycle = class {
       this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
       if (correlating === false) return idle();
     }
-    const after = Math.max(this._checkpoint, query.after || -1);
+    const after = this._checkpoint;
     const correlated = /* @__PURE__ */ new Map();
     let last_id = after;
     let stopped = false;
@@ -1349,7 +1370,7 @@ var CorrelateCycle = class {
       },
       // Resolvers see `pii: null`: correlate runs actor-less, and one
       // undecryptable row would otherwise stop every stream's reactions.
-      { ...query, after, with_pii: false }
+      { after, limit: query.limit, with_pii: false }
     );
     if (this._declared_lanes.size > 1) await this._recall(correlated);
     const read = last_id > after;
@@ -2408,9 +2429,11 @@ var DrainController = class {
   get lane() {
     return this._deps.lane;
   }
-  /** Drains every `cycleMs` while armed; the unref'd timer never holds the process. */
+  /**
+   * Drains every `cycleMs` while armed; the unref'd timer never holds the
+   * process. Called once, when the controller is built.
+   */
   start(cycleMs) {
-    if (this._worker || this._stopped) return;
     const run = this._deps.run_scoped;
     const tick = async () => {
       if (this.armed) await run(() => this.drain());
@@ -2856,8 +2879,7 @@ var SettleLoop = class {
       this._timer = void 0;
       const {
         debounceMs: _,
-        // Every pass scans from correlation's own checkpoint.
-        correlate: { after: _after, ...correlate_query } = {},
+        correlate: correlate_query = {},
         maxPasses = Infinity,
         ...drain_options
       } = this._next ?? {};
@@ -2870,7 +2892,7 @@ var SettleLoop = class {
           if (scanned) this._deps.breaker.passed();
           const drain = await this._deps.drain(drain_options);
           passes.push(drain);
-          const made_progress = drain.leased.length > 0 || scanned && (pass.subscribed > 0 || pass.read);
+          const made_progress = drain.leased.length > 0 || scanned && pass.read;
           if (!made_progress) break;
         }
         if (passes.length) this._deps.on_settled(merge_drains(passes));
@@ -3529,8 +3551,9 @@ var Act = class {
    * target streams their reactions resolve to (static or computed from
    * the event), and marks their work so the next drain can claim it.
    *
-   * @param query - Scan filter — see {@link Query} for fields (typically
-   *   `{ limit: <count> }`; the scan starts at the checkpoint)
+   * @param query - Only `limit` is used: the most events the pass reads
+   *   (default 10). The scan always starts at the correlation checkpoint,
+   *   which every reaction shares, so filters and `after` are ignored.
    * @returns The number of newly subscribed streams and the last scanned event id
    *
    * @example Manual correlation
@@ -3540,7 +3563,7 @@ var Act = class {
    *
    * @see {@link start_correlations} for automatic periodic correlation
    */
-  async correlate(query = { after: -1, limit: 10 }) {
+  async correlate(query = { limit: 10 }) {
     const pass = await this._correlate_pass(query);
     return {
       subscribed: pass.kind === "scanned" ? pass.subscribed : 0,
@@ -3552,8 +3575,7 @@ var Act = class {
     if (!this._drain) return { kind: "idle", last_id: -1 };
     return this._scoped(async () => {
       const pass = await this._correlate.correlate(query, lease);
-      if (pass.kind === "scanned" && (pass.subscribed > 0 || pass.marked > 0))
-        this._arm_all();
+      if (pass.kind === "scanned" && pass.marked > 0) this._arm_all();
       return pass;
     });
   }
@@ -3694,6 +3716,12 @@ var Act = class {
    * adapter's {@link Store.restore} driver supplies the transaction
    * lifecycle and per-event insert.
    *
+   * Safe in a live process: restoring into this Act's own store waits
+   * for its correlate passes in flight, replaces the log, then restarts
+   * correlation and settles. A correlate pass that starts meanwhile
+   * reads nothing. Other processes on the same store keep their
+   * correlation state and must be restarted.
+   *
    * Throws if the adapter has no restore capability. Throws on the
    * first invalid event (negative version, malformed `created`) with
    * the running index in the message; atomic transaction rollback in
@@ -3736,14 +3764,15 @@ var Act = class {
       let kept = 0;
       let migrated = 0;
       let dropped = { closed_streams: 0, snapshots: 0 };
-      await target.restore(async (callback) => {
+      const run = () => target.restore(async (callback) => {
         const partial = await scan(source, opts, callback);
         kept = partial.kept;
         migrated = partial.migrated;
         dropped = partial.dropped;
       });
-      if (!sink) {
-        this._correlate.restart();
+      if (sink) await run();
+      else {
+        await this._correlate.restart(run);
         this._wake();
       }
       return { kept, migrated, dropped, duration_ms: Date.now() - started };