@rotorsoft/act 1.33.7 → 1.33.9

package/dist/index.js

@@ -1162,8 +1162,14 @@ var CorrelateCycle = class {
   _key;
   /** Local expiry of the held lease (0 = none); stale only costs a duplicate scan. */
   _lease_until = 0;
-  /** Raised by a commit or notification, lowered by a short page. Starts armed. */
-  _armed = true;
+  /**
+   * Armed while `_raised` (bumped by a commit or notification) is ahead of
+   * `_lowered` (the raise count the last short page saw). Starts armed.
+   */
+  _raised = 1;
+  _lowered = 0;
+  /** Counts releases, so a lease reply that lands after one is dropped. */
+  _releases = 0;
   _init_promise;
   // Bounded by `maxSubscribedStreams`; static records live apart so eviction
   // never drops their +Infinity floor.
@@ -1174,8 +1180,6 @@ var CorrelateCycle = class {
   _static_targets;
   _cd;
   _on_init;
-  /** Runs once after `on_init`; re-seeds defer timers across a restart. */
-  _on_init_async;
   _declared_lanes;
   /** Report-once keys; per instance because `internal/` holds no module state. */
   _reported = /* @__PURE__ */ new Set();
@@ -1186,8 +1190,7 @@ var CorrelateCycle = class {
     max_subscribed_streams,
     declared_lanes,
     shard,
-    on_init,
-    on_init_async
+    on_init
   }) {
     this._key = shard ? `${registry_key(registry.events)}:${[...shard].sort().join(",")}` : registry_key(registry.events);
     this._dynamic_subscriptions = new LruMap(max_subscribed_streams);
@@ -1196,14 +1199,13 @@ var CorrelateCycle = class {
     this._static_targets = static_targets;
     this._cd = cd;
     this._on_init = on_init;
-    this._on_init_async = on_init_async;
   }
   get checkpoint() {
     return this._checkpoint;
   }
   /** A commit (local or remote) may have produced uncorrelated events. */
   arm() {
-    this._armed = true;
+    this._raised++;
   }
   async init() {
     if (this._initialized) return;
@@ -1221,7 +1223,6 @@ var CorrelateCycle = class {
       ...this._static_targets
     ]);
     this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - COLD_START_BACK_SCAN);
-    this._on_init?.();
     for (const { stream, priority = 0, lane } of this._static_targets) {
       this._static_subscriptions.set(stream, {
         floor: Number.POSITIVE_INFINITY,
@@ -1229,7 +1230,7 @@ var CorrelateCycle = class {
         lane
       });
     }
-    await this._on_init_async?.();
+    await this._on_init?.();
   }
   /** After `restore` replaced the log: forget everything and cold-start again. */
   restart() {
@@ -1238,7 +1239,7 @@ var CorrelateCycle = class {
     this._checkpoint = -1;
     this._dynamic_subscriptions.clear();
     this._static_subscriptions.clear();
-    this._armed = true;
+    this._raised++;
   }
   /** Forget dynamic targets whose rows a full close deleted, so they re-subscribe. */
   forget_subscribed(streams) {
@@ -1258,22 +1259,26 @@ var CorrelateCycle = class {
   /** Scan past the checkpoint, subscribe new targets and raise their work marks. */
   async correlate(query = { after: -1, limit: 10 }, lease = false) {
     await this.init();
-    if (!this._armed)
+    if (this._raised === this._lowered)
       return {
         subscribed: 0,
         last_id: this._checkpoint,
         marked: 0,
         scanned: false
       };
+    const raised = this._raised;
     const now = Date.now();
     if (lease && now >= this._lease_until - CORRELATION_LEASE_MS / 2) {
+      const releases = this._releases;
       const { correlating } = await this._cd.subscribe([], void 0, {
         key: this._key,
         by: this._by,
         millis: CORRELATION_LEASE_MS
       });
-      this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
-      if (correlating === false)
+      const released = this._releases !== releases;
+      if (!released)
+        this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
+      if (correlating === false || released)
         return {
           subscribed: 0,
           last_id: this._checkpoint,
@@ -1394,7 +1399,7 @@ var CorrelateCycle = class {
       return { subscribed, last_id, marked, scanned: true };
     }
     this._checkpoint = last_id;
-    this._armed = stopped || found === query.limit;
+    if (!stopped && found !== query.limit) this._lowered = raised;
     return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
   /**
@@ -1440,6 +1445,7 @@ var CorrelateCycle = class {
   async release_correlation() {
     try {
       this._lease_until = 0;
+      this._releases++;
       await this._cd.subscribe([], void 0, {
         key: this._key,
         by: this._by,
@@ -2353,8 +2359,13 @@ var EMPTY_DRAIN = {
 };
 var RETRY = "";
 var DrainController = class {
-  _armed = false;
-  _locked = false;
+  /**
+   * Armed while `_raised` is ahead of `_lowered` (the raise count the last
+   * empty claim saw), so a claim never lowers over a raise that landed
+   * during it.
+   */
+  _raised = 0;
+  _lowered = 0;
   _ratio = 0.5;
   /**
    * Local wake at the earliest parked (backoff or defer) visit, or at the
@@ -2364,7 +2375,7 @@ var DrainController = class {
    * stays until handled or until a later pass claims nothing.
    */
   _defer = new DeferTimer(() => {
-    this._armed = true;
+    this.arm();
     void this._deps.run_scoped(async () => {
       while ((await this.drain()).leased.length > 0) ;
     });
@@ -2380,7 +2391,7 @@ var DrainController = class {
     this._deps = deps;
   }
   arm() {
-    this._armed = true;
+    this._raised++;
   }
   /** Cold start: re-seed a persisted `deferred_at` into the local wake. */
   seed_defer(stream, at) {
@@ -2388,7 +2399,7 @@ var DrainController = class {
     this._defer.schedule();
   }
   get armed() {
-    return this._armed;
+    return this._raised !== this._lowered;
   }
   get inflight() {
     return this._inflight;
@@ -2405,7 +2416,7 @@ var DrainController = class {
     if (this._worker || this._stopped) return;
     const run = this._deps.run_scoped;
     const tick = async () => {
-      if (this._armed) await run(() => this.drain());
+      if (this.armed) await run(() => this.drain());
       if (this._stopped) return;
       this._worker = setTimeout(tick, cycleMs);
       this._worker.unref();
@@ -2422,8 +2433,8 @@ var DrainController = class {
     this._defer.stop();
   }
   async drain(options = {}) {
-    if (!this._armed || this._stopped) return EMPTY_DRAIN;
-    if (this._locked) return EMPTY_DRAIN;
+    if (!this.armed || this._stopped || this._inflight)
+      return EMPTY_DRAIN;
     const d = this._deps.defaults ?? {};
     const streamLimit = d.streamLimit ?? options.streamLimit ?? DEFAULT_STREAM_LIMIT;
     const eventLimit = options.eventLimit ?? DEFAULT_EVENT_LIMIT;
@@ -2431,13 +2442,13 @@ var DrainController = class {
     if (this._deps.breaker.state(Date.now()) === "open")
       return EMPTY_DRAIN;
     try {
-      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 raised = this._raised;
       const cycle = await run_drain_cycle(this._deps, {
         lagging,
         leading,
@@ -2449,7 +2460,7 @@ var DrainController = class {
       if (!cycle) {
         this._defer.prune(started);
         this._deps.breaker.passed();
-        this._armed = false;
+        this._lowered = raised;
         return EMPTY_DRAIN;
       }
       const { leased, fetched, handled, acked, blocked, closeable } = cycle;
@@ -2474,7 +2485,6 @@ var DrainController = class {
       return EMPTY_DRAIN;
     } finally {
       if (!this._stopped) this._defer.schedule();
-      this._locked = false;
       this._inflight = void 0;
       this._inflight_done?.();
       this._inflight_done = void 0;
@@ -2716,13 +2726,23 @@ function build_handle(deps) {
           handled++;
         }
       } catch (error) {
-        if (error instanceof DeferSignal)
-          return {
-            lease,
-            handled,
-            acked_at: at,
-            defer: resolve_defer_at(error.when, event)
-          };
+        if (error instanceof DeferSignal) {
+          let defer;
+          try {
+            defer = resolve_defer_at(error.when, event);
+          } catch (invalid) {
+            return finalize(
+              lease,
+              handled,
+              at,
+              invalid,
+              payload.options,
+              logger,
+              event.id
+            );
+          }
+          return { lease, handled, acked_at: at, defer };
+        }
         if (error instanceof CloseSignal)
           return {
             lease,
@@ -2908,7 +2928,6 @@ function validate_only_lanes(options, lanes) {
 var Act = class {
   _emitter = new EventEmitter();
   _breaker;
-  _listen;
   _drain;
   _auto_settle;
   /** Whether any event has a reaction; nothing arms without one. */
@@ -2989,14 +3008,6 @@ var Act = class {
   /** Runs a body so internal `store()`/`cache()` calls resolve to `_ports`. */
   _scoped;
   _correlator;
-  // Bound once, reused by every reaction payload.
-  _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);
-  _bound_forget = this.forget.bind(this);
-  _handle;
-  _handle_batch;
   _lanes;
   _close_lock = new CloseLock();
   /** Every lane a controller can exist for: `"default"` plus each declared one. */
@@ -3030,31 +3041,38 @@ var Act = class {
     this._correlator = options.correlator ?? default_correlator;
     this._es = build_es(this._logger, this._correlator, patch_fn);
     this._cd = build_drain(this._logger);
-    this._handle = build_handle({
+    const handle = build_handle({
       logger: this._logger,
       reaction_scope: make_reaction_scope({
-        do: this._bound_do,
-        load: this._bound_load,
-        query: this._bound_query,
-        query_array: this._bound_query_array,
-        forget: this._bound_forget
+        do: this.do.bind(this),
+        load: this.load.bind(this),
+        query: this.query.bind(this),
+        query_array: this.query_array.bind(this),
+        forget: this.forget.bind(this)
       })
     });
-    this._handle_batch = build_handle_batch(this._logger);
+    const handle_batch = build_handle_batch(this._logger);
     const classification = classify_registry(this.registry, this._states);
     this._reactive = classification.event_to_lanes.size > 0;
     this._event_to_state = classification.event_to_state;
     this._event_to_lanes = classification.event_to_lanes;
-    this._listen = options.listen !== false;
     this._drain = options.drain !== false;
     this._auto_settle = options.autoSettle !== false;
     this._breaker = this._build_breaker(options);
-    this._drain_controllers = this._build_drain_controllers(options, lanes);
+    this._drain_controllers = this._build_drain_controllers(
+      options,
+      lanes,
+      handle,
+      handle_batch
+    );
     this._advise_orphaned_lanes(options);
     this._audit_deps = this._build_audit_deps();
     this._correlate = this._build_correlate(options, classification);
     this._settle = this._build_settle(options);
-    this._notify_disposer = this._wire_notify(this._ports.store);
+    this._notify_disposer = this._wire_notify(
+      this._ports.store,
+      options.listen !== false
+    );
     register_weak_disposer(new WeakRef(this), (self) => self.shutdown());
   }
   /** Shared by drain, settle and autoclose; bad knobs throw at build. */
@@ -3070,7 +3088,7 @@ var Act = class {
     );
   }
   /** Apps that declare no lanes pass no lane filter to `claim`. */
-  _build_drain_controllers(options, lanes) {
+  _build_drain_controllers(options, lanes, handle, handle_batch) {
     const all_lanes = this._declared_lanes;
     const only_set = options.onlyLanes && options.onlyLanes.length > 0 ? new Set(options.onlyLanes) : void 0;
     const active_lanes = only_set ? all_lanes.filter((n) => only_set.has(n)) : all_lanes;
@@ -3083,8 +3101,8 @@ var Act = class {
         ops: this._cd,
         registry: this.registry,
         batch_handlers: this._batch_handlers,
-        handle: this._handle,
-        handle_batch: this._handle_batch,
+        handle,
+        handle_batch,
         on_acked: (acked) => this.emit("acked", acked),
         on_blocked: (blocked) => this.emit("blocked", blocked),
         // Reaction-requested close: the same machinery as `app.close`.
@@ -3149,8 +3167,10 @@ var Act = class {
       // 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,
       // Only reached on a draining app: writer-only ones never correlate.
-      on_init: () => this._arm_all(),
-      on_init_async: this._drain ? () => this._seed_persisted_defers() : void 0
+      on_init: async () => {
+        this._arm_all();
+        await this._seed_persisted_defers();
+      }
     });
   }
   /** Cold start: an idle deferred stream still fires on time after a restart. */
@@ -3243,10 +3263,10 @@ var Act = class {
     }
   }
   /** Failures are logged, never thrown: `notify` is a hint. */
-  async _wire_notify(s) {
+  async _wire_notify(s, listen) {
     if (!this._reactive) return void 0;
     if (!s.notify) return void 0;
-    if (!this._listen) return void 0;
+    if (!listen) return void 0;
     try {
       return await s.notify((notification) => {
         try {
@@ -4483,7 +4503,7 @@ function build_events(registry, states, lanes, owners) {
         throw new Error(
           `Reaction on target "${resolver.target}" conflicts with the projection that already serves it \u2014 a target is served by one batch handler or one state projection, and a reaction to it would never run`
         );
-      if (resolver.lane && !declared.has(resolver.lane))
+      if (resolver.lane !== void 0 && !declared.has(resolver.lane))
         lane_errors.push(
           `Reaction "${handler_name}" on "${event_name}" targets undeclared lane "${resolver.lane}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. Add \`.withLane({ name: "${resolver.lane}", ... })\` to act() or correct the .to() declaration.`
         );