@rotorsoft/act 1.32.20 → 1.32.22

package/dist/index.js

@@ -26,7 +26,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-QOSQI3CA.js";
+} from "./chunk-T3CWXVGT.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -926,7 +926,6 @@ function resolveSettleConfig(options) {
   return options;
 }
 var MAX_SHUTDOWN_GRACE_MS = 3e4;
-var DEFAULT_SHUTDOWN_GRACE_MS = DEFAULT_LEASE_MILLIS;
 var ShutdownOptionsSchema = z2.object({
   // `0` is legal and is exactly today's behavior: stop scheduling and
   // return without waiting.
@@ -1561,8 +1560,8 @@ function report_once(seen, key, message) {
 }
 
 // src/internal/correlate-cycle.ts
-var DEFAULT_COLD_START_BACK_SCAN = 1e4;
-var DEFAULT_CORRELATION_LEASE_MS = 5e3;
+var COLD_START_BACK_SCAN = 1e4;
+var CORRELATION_LEASE_MS = 5e3;
 var registry_key = (events) => {
   const shape = Object.keys(events).filter((name) => events[name].reactions.size > 0).sort().map((name) => [name, [...events[name].reactions.keys()].sort()]);
   return createHash("sha256").update(JSON.stringify(shape)).digest("hex").slice(0, 32);
@@ -1591,8 +1590,6 @@ var CorrelateCycle = class {
    * same holder and a restarted process never inherits a stale claim.
    */
   _by = randomUUID();
-  /** How long the correlation lease is taken for. */
-  _lease_millis;
   /**
    * Which correlator this is. Computed once from the registry so identical
    * workers share a lease and unrelated applications never do.
@@ -1645,12 +1642,6 @@ var CorrelateCycle = class {
    * here, so an idle deferred stream re-arms across a restart.
    */
   _on_init_async;
-  /**
-   * Tail re-scan window applied to the cold-start checkpoint.
-   * See {@link DEFAULT_COLD_START_BACK_SCAN}. Constructor arg (not a
-   * public option) so tests can shrink it; defaults otherwise.
-   */
-  _cold_start_back_scan;
   /** Lanes a controller exists for. See {@link CorrelateCycleDeps}. */
   _declared_lanes;
   /**
@@ -1667,11 +1658,8 @@ var CorrelateCycle = class {
     declared_lanes,
     shard,
     on_init,
-    on_init_async,
-    cold_start_back_scan = DEFAULT_COLD_START_BACK_SCAN,
-    lease_millis = DEFAULT_CORRELATION_LEASE_MS
+    on_init_async
   }) {
-    this._lease_millis = lease_millis;
     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;
@@ -1680,7 +1668,6 @@ var CorrelateCycle = class {
     this._cd = cd;
     this._on_init = on_init;
     this._on_init_async = on_init_async;
-    this._cold_start_back_scan = cold_start_back_scan;
   }
   /** Last correlated event id. */
   get checkpoint() {
@@ -1719,7 +1706,7 @@ var CorrelateCycle = class {
     const { watermark, correlated_at } = await this._cd.subscribe([
       ...this._static_targets
     ]);
-    this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - this._cold_start_back_scan);
+    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, {
@@ -1793,13 +1780,13 @@ var CorrelateCycle = class {
         scanned: false
       };
     const now = Date.now();
-    if (lease && now >= this._lease_until - this._lease_millis / 2) {
+    if (lease && now >= this._lease_until - CORRELATION_LEASE_MS / 2) {
       const { correlating } = await this._cd.subscribe([], void 0, {
         key: this._key,
         by: this._by,
-        millis: this._lease_millis
+        millis: CORRELATION_LEASE_MS
       });
-      this._lease_until = correlating ? now + this._lease_millis : 0;
+      this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
       if (correlating === false)
         return {
           subscribed: 0,
@@ -1839,6 +1826,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);
@@ -1857,6 +1846,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;
@@ -1870,6 +1860,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)
@@ -1886,10 +1877,10 @@ var CorrelateCycle = class {
       const { subscribed, correlating } = await this._cd.subscribe(
         streams,
         last_id,
-        lease ? { key: this._key, by: this._by, millis: this._lease_millis } : void 0
+        lease ? { key: this._key, by: this._by, millis: CORRELATION_LEASE_MS } : void 0
       );
       if (lease && correlating !== false)
-        this._lease_until = renewed_at + this._lease_millis;
+        this._lease_until = renewed_at + CORRELATION_LEASE_MS;
       const marked = streams.filter(
         (entry) => entry.correlated_at !== void 0
       ).length;
@@ -1908,6 +1899,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.
    *
@@ -1925,7 +1960,7 @@ var CorrelateCycle = class {
       });
     } catch (error) {
       log().warn(
-        `Could not hand back the correlation lease during shutdown; it expires on its own within ${this._lease_millis}ms and correlation resumes normally after that. On a single-writer store this usually means another connection holds the database. Cause: ${String(error)}`
+        `Could not hand back the correlation lease during shutdown; it expires on its own within ${CORRELATION_LEASE_MS}ms and correlation resumes normally after that. On a single-writer store this usually means another connection holds the database. Cause: ${String(error)}`
       );
     }
   }
@@ -2067,9 +2102,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;
@@ -2078,14 +2112,6 @@ var DeferTimer = class {
   get size() {
     return this._due.size;
   }
-  /**
-   * True while `stream` is parked with a due-time still in the future.
-   * Consumers skip work for deferred streams until their window elapses.
-   */
-  is_deferred = (stream) => {
-    const next = this._due.get(stream);
-    return next !== void 0 && next > Date.now();
-  };
   /**
    * Park `stream` for a re-visit at `at` (ms since epoch). A plain
    * overwrite: the caller computes the authoritative next-visit for the
@@ -2099,6 +2125,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
@@ -2121,9 +2157,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();
@@ -2761,7 +2794,7 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 function budget_exhausted(lease, options, store_failing) {
   if (store_failing || !options?.blockOnError || lease.retry <= options.maxRetries)
     return void 0;
-  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. That means every attempt lost its lease before it could ack: raise leaseMillis for this handler, then unblock the stream.`;
+  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. That means every attempt lost its lease before it could ack: move the reaction to a lane whose leaseMillis covers the handler, then unblock the stream.`;
   log().error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
@@ -2841,7 +2874,9 @@ async function run_drain_cycle(deps, cycle) {
           handled: 0,
           acked_at: lease.at,
           error,
-          ...block2 ? { block: true } : { next_attempt_at: Date.now() + DEFAULT_BACKOFF.baseMs }
+          ...block2 ? { block: true } : {
+            next_attempt_at: Date.now() + compute_backoff_delay(lease.retry, DEFAULT_BACKOFF)
+          }
         };
         return Promise.resolve(failed);
       }
@@ -2892,6 +2927,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.
    */
@@ -2987,17 +3025,18 @@ var DrainController = class {
     if (this._locked) 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 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,
@@ -3007,6 +3046,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;
@@ -3649,9 +3689,7 @@ var Act = class {
   _build_audit_deps() {
     return {
       store,
-      logger: this._logger,
       event_to_state: this._event_to_state,
-      states: this._states,
       // Declared lanes, not this process's controllers: a lane another
       // worker drains is not `unknown-lane`.
       declared_lanes: new Set(this._declared_lanes),
@@ -3758,9 +3796,9 @@ var Act = class {
    * fallback, capped at the maximum. Idle lanes don't count.
    */
   _derive_grace_ms(running, settling) {
-    let max = settling ? DEFAULT_SHUTDOWN_GRACE_MS : 0;
+    let max = settling ? DEFAULT_LEASE_MILLIS : 0;
     for (const c of running)
-      max = Math.max(max, c.lease_millis || DEFAULT_SHUTDOWN_GRACE_MS);
+      max = Math.max(max, c.lease_millis || DEFAULT_LEASE_MILLIS);
     return Math.min(max, MAX_SHUTDOWN_GRACE_MS);
   }
   async _await_inflight(grace_ms) {
@@ -4070,8 +4108,7 @@ var Act = class {
    * Call `correlate()` before `drain()`. It is not only how dynamic targets
    * are discovered: a stream is claimable while `at < correlated_at`, and
    * `correlate` is the only component that raises that mark, so a
-   * commit no correlate has seen is not drainable — including for static
-   * targets, which were served by a probe of the event log before. For a
+   * commit no correlate has seen is not drainable, static targets included. For a
    * higher-level API that handles debouncing, correlation, and signaling
    * automatically, use {@link settle}.
    *
@@ -5077,6 +5114,12 @@ function act() {
   };
   const fold_projections = [];
   const batch_handlers = /* @__PURE__ */ new Map();
+  const add_projection = (proj) => {
+    record_projection_reactions(proj);
+    merge_projection(proj, registry.events);
+    register_batch_handler(proj, batch_handlers);
+    if (proj.fold) fold_projections.push(proj);
+  };
   const fold_specs = [];
   const lanes = [];
   let _built = false;
@@ -5176,11 +5219,7 @@ function act() {
     },
     withProjection: (proj) => {
       if (_built) closed("withProjection");
-      record_projection_reactions(proj);
-      merge_projection(proj, registry.events);
-      register_batch_handler(proj, batch_handlers);
-      if (proj.fold)
-        fold_projections.push(proj);
+      add_projection(proj);
       return builder;
     },
     withActor: () => builder,
@@ -5197,12 +5236,7 @@ function act() {
       resolveActConfig(options);
       const patch_fn = options?.validateFoldedState === true ? validating_patch : bare_patch;
       if (!_built) {
-        for (const proj of pending_projections) {
-          record_projection_reactions(proj);
-          merge_projection(proj, registry.events);
-          register_batch_handler(proj, batch_handlers);
-          if (proj.fold) fold_projections.push(proj);
-        }
+        for (const proj of pending_projections) add_projection(proj);
         for (const proj of fold_projections) {
           const fold = proj.fold;
           const merged = states.get(fold.name);