@rotorsoft/act 1.27.0 → 1.29.0

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-66PTM4QB.js";
+} from "./chunk-PX3IBVLW.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -829,12 +829,10 @@ function classify_registry(registry, states) {
   const target_lanes = /* @__PURE__ */ new Map();
   const reactive_events = /* @__PURE__ */ new Set();
   const event_to_lanes = /* @__PURE__ */ new Map();
-  let has_dynamic_resolvers = false;
   for (const [name, register] of Object.entries(registry.events)) {
     if (register.reactions.size > 0) reactive_events.add(name);
     for (const reaction of register.reactions.values()) {
       if (typeof reaction.resolver === "function") {
-        has_dynamic_resolvers = true;
         event_to_lanes.set(name, ALL_LANES);
       } else {
         const { target, source, priority = 0, lane } = reaction.resolver;
@@ -870,7 +868,6 @@ function classify_registry(registry, states) {
   }
   return {
     static_targets: [...statics.values()],
-    has_dynamic_resolvers,
     reactive_events,
     event_to_state,
     event_to_lanes
@@ -1354,7 +1351,8 @@ async function run_close_cycle(targets, deps) {
     stream_info,
     deps.reactive_events_size,
     skipped,
-    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
+    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE,
+    deps.catch_up_correlation
   );
   if (!safe.length) return { truncated: windowed_result, skipped };
   const { guarded, guard_events } = await guard_with_tombstones(
@@ -1473,8 +1471,16 @@ async function scan_stream_heads(streams) {
   }
   return out;
 }
-async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size) {
+async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size, catch_up_correlation) {
   if (reactive_events_size === 0) return [...stream_info.keys()];
+  let needed = -1;
+  for (const info of stream_info.values())
+    needed = Math.max(needed, info.max_id);
+  const checkpoint = await catch_up_correlation(needed);
+  const uncorrelated = /* @__PURE__ */ new Set();
+  for (const [stream, info] of stream_info) {
+    if (checkpoint < info.max_id) uncorrelated.add(stream);
+  }
   const pending_set = /* @__PURE__ */ new Set();
   const source_regex = /* @__PURE__ */ new Map();
   const get_regex = (source) => {
@@ -1493,6 +1499,8 @@ async function partition_by_safety(stream_info, reactive_events_size, skipped, p
       (position) => {
         last = position.stream;
         const source_re = position.source ? get_regex(position.source) : void 0;
+        const has_work = position.correlated_at !== void 0 && position.at < position.correlated_at;
+        if (!has_work) return;
         for (const [stream, info] of stream_info) {
           if ((!source_re || source_re.test(stream)) && position.at < info.max_id) {
             pending_set.add(stream);
@@ -1506,7 +1514,8 @@ async function partition_by_safety(stream_info, reactive_events_size, skipped, p
   }
   const safe = [];
   for (const [stream] of stream_info) {
-    if (pending_set.has(stream)) skipped.push(stream);
+    if (pending_set.has(stream) || uncorrelated.has(stream))
+      skipped.push(stream);
     else safe.push(stream);
   }
   return safe;
@@ -1596,21 +1605,24 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
 
 // src/internal/correlate-cycle.ts
 var DEFAULT_COLD_START_BACK_SCAN = 1e4;
+var PATTERN_CACHE_SIZE = 32;
 var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
   /** In-flight init, memoized for single-flight and cleared on failure. */
   _init_promise;
   _timer = void 0;
-  // target → the priority it was last subscribed at. A dynamic target is
-  // re-subscribed (so the store's `GREATEST` upsert runs) only when a later
-  // scan resolves a *higher* priority for it — the runtime `max()` invariant
-  // (#1363). Static targets are recorded at +Infinity so a dynamic resolution
-  // never re-opens them (their priority is owned by the build-time subscribe).
+  // target → what it was last subscribed at. Every scan re-subscribes the
+  // targets it resolved (that is how the work mark lands), so this no longer
+  // decides *whether* a target is sent — it decides *what* is sent with it:
+  // a resolution raises priority/lane only when it beats the recorded floor,
+  // and otherwise re-sends the row's own values so the mark changes nothing
+  // else. See {@link Subscription}.
   _subscribed;
+  /** Compiled pattern sources, bounded by {@link PATTERN_CACHE_SIZE}. */
+  _patterns = new LruMap(PATTERN_CACHE_SIZE);
   _registry;
   _static_targets;
-  _has_dynamic_resolvers;
   _cd;
   _on_init;
   /**
@@ -1640,7 +1652,6 @@ var CorrelateCycle = class {
   constructor({
     registry,
     static_targets,
-    has_dynamic_resolvers,
     cd,
     max_subscribed_streams,
     run_scoped,
@@ -1651,7 +1662,6 @@ var CorrelateCycle = class {
     this._subscribed = new LruMap(max_subscribed_streams);
     this._registry = registry;
     this._static_targets = static_targets;
-    this._has_dynamic_resolvers = has_dynamic_resolvers;
     this._cd = cd;
     this._on_init = on_init;
     this._run_scoped = run_scoped;
@@ -1662,19 +1672,10 @@ var CorrelateCycle = class {
   get checkpoint() {
     return this._checkpoint;
   }
-  /**
-   * Whether any reaction uses a dynamic resolver — i.e. whether `correlate`
-   * performs a store scan rather than the static no-op early-return. The
-   * settle loop reads this to avoid recording a fictitious circuit-breaker
-   * success on a static app whose correlate never touches the store (#1329).
-   */
-  get has_dynamic_resolvers() {
-    return this._has_dynamic_resolvers;
-  }
   /**
    * Initialize correlation state on first call.
-   * - Reads max(at) from store, then floors the cold-start checkpoint at
-   *   `watermark - back_scan` when dynamic resolvers exist, so an event
+   * - Reads the durable correlate checkpoint (and max(at)) from the store,
+   *   flooring a first boot at `watermark - back_scan` so an event
    *   committed-but-not-correlated before a crash is re-scanned on
    *   restart instead of skipped (ACT-1207)
    * - Subscribes static resolver targets (idempotent upsert)
@@ -1696,10 +1697,14 @@ var CorrelateCycle = class {
     const { watermark, correlated_at } = await store().subscribe([
       ...this._static_targets
     ]);
-    this._checkpoint = !this._has_dynamic_resolvers ? watermark : 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 - this._cold_start_back_scan);
     this._on_init?.();
-    for (const { stream } of this._static_targets) {
-      this._subscribed.set(stream, Number.POSITIVE_INFINITY);
+    for (const { stream, priority = 0, lane } of this._static_targets) {
+      this._subscribed.set(stream, {
+        floor: Number.POSITIVE_INFINITY,
+        priority,
+        lane
+      });
     }
     await this._on_init_async?.();
   }
@@ -1724,14 +1729,34 @@ var CorrelateCycle = class {
     }
   }
   /**
-   * Discover dynamic-resolver targets in the events past the checkpoint
-   * and register any new streams via `cd.subscribe`. Static targets are
-   * subscribed at init time, so this only walks dynamic resolvers.
+   * Would an event from `stream` be fetched for a target subscribed with
+   * `source`? The subscription's source is the filter `fetch` queries with
+   * — literal names by equality, patterns compiled as a `RegExp` — so an
+   * event outside it is not work for that target and must not mark it.
+   * No source means the target consumes every stream.
+   */
+  _in_fetch_window(source, stream) {
+    if (source === void 0 || source === stream) return true;
+    if (is_literal_source(source)) return false;
+    let pattern = this._patterns.get(source);
+    if (!pattern) {
+      pattern = new RegExp(source);
+      this._patterns.set(source, pattern);
+    }
+    return pattern.test(stream);
+  }
+  /**
+   * Scan the events past the checkpoint, resolve each to its target
+   * streams, and record what it found through `cd.subscribe` — new dynamic
+   * targets get registered, and every target an event resolved to gets its
+   * **work mark** raised to that event's id (#1487).
+   *
+   * Both resolver kinds are walked. A static target is already subscribed
+   * at init, but marking it is what makes it claimable without probing the
+   * event log, so the scan runs for every app.
    */
   async correlate(query = { after: -1, limit: 10 }) {
     await this.init();
-    if (!this._has_dynamic_resolvers)
-      return { subscribed: 0, last_id: this._checkpoint };
     const after = Math.max(this._checkpoint, query.after || -1);
     const correlated = /* @__PURE__ */ new Map();
     let last_id = after;
@@ -1741,52 +1766,61 @@ var CorrelateCycle = class {
         const register = this._registry.events[event.name];
         if (register) {
           for (const reaction of register.reactions.values()) {
-            if (typeof reaction.resolver !== "function") continue;
-            const resolved = reaction.resolver(event);
-            if (resolved && (resolved.priority ?? 0) > (this._subscribed.get(resolved.target) ?? Number.NEGATIVE_INFINITY)) {
-              const incoming_priority = resolved.priority ?? 0;
-              const entry = correlated.get(resolved.target) || {
-                source: resolved.source,
-                priority: incoming_priority,
-                lane: resolved.lane,
-                payloads: []
-              };
-              if (incoming_priority > entry.priority) {
-                entry.priority = incoming_priority;
-                entry.lane = resolved.lane;
-              }
-              entry.payloads.push({
-                ...reaction,
-                source: resolved.source,
-                event
-              });
-              correlated.set(resolved.target, entry);
+            const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+            if (!resolved) continue;
+            const recorded = this._subscribed.get(resolved.target);
+            const priority = resolved.priority ?? 0;
+            const upgraded = !recorded || priority > recorded.floor;
+            const carried = upgraded ? { priority, lane: resolved.lane } : { priority: recorded.priority, lane: recorded.lane };
+            const entry = correlated.get(resolved.target) || {
+              source: resolved.source,
+              priority: carried.priority,
+              lane: carried.lane,
+              upgraded,
+              correlated_at: void 0
+            };
+            if (carried.priority > entry.priority) {
+              entry.priority = carried.priority;
+              entry.lane = carried.lane;
+              entry.upgraded = upgraded;
             }
+            if (this._in_fetch_window(resolved.source, event.stream))
+              entry.correlated_at = event.id;
+            correlated.set(resolved.target, entry);
           }
         }
       },
       { ...query, after }
     );
-    if (correlated.size) {
-      const streams = [...correlated.entries()].map(
-        ([stream, { source, priority, lane }]) => ({
+    const streams = [];
+    for (const [stream, entry] of correlated) {
+      if (entry.upgraded || entry.correlated_at !== void 0)
+        streams.push({
           stream,
-          source,
-          priority,
-          lane
-        })
-      );
+          source: entry.source,
+          priority: entry.priority,
+          lane: entry.lane,
+          correlated_at: entry.correlated_at
+        });
+    }
+    if (streams.length) {
       const { subscribed } = await this._cd.subscribe(streams, last_id);
+      const marked = streams.filter(
+        (entry) => entry.correlated_at !== void 0
+      ).length;
       this._checkpoint = last_id;
-      if (subscribed) {
-        for (const { stream, priority } of streams) {
-          this._subscribed.set(stream, priority);
-        }
+      for (const { stream, priority, lane } of streams) {
+        if (correlated.get(stream)?.upgraded)
+          this._subscribed.set(stream, {
+            floor: priority,
+            priority,
+            lane
+          });
       }
-      return { subscribed, last_id };
+      return { subscribed, last_id, marked };
     }
     this._checkpoint = last_id;
-    return { subscribed: 0, last_id };
+    return { subscribed: 0, last_id, marked: 0 };
   }
   /**
    * Start a periodic correlation worker. Returns false if one is already
@@ -3089,7 +3123,7 @@ var SettleLoop = class {
             ...correlate_query,
             after: after_before
           });
-          if (this._deps.correlate_probes_store) this._deps.breaker.passed();
+          this._deps.breaker.passed();
           const drain = await this._deps.drain(drain_options);
           settled_drain = settled_drain ? {
             fetched: [...settled_drain.fetched, ...drain.fetched],
@@ -3135,6 +3169,8 @@ var SettleLoop = class {
 
 // src/act.ts
 var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
+var CLOSE_CATCH_UP_LIMIT = 1e3;
+var CLOSE_CATCH_UP_PASSES = 20;
 var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
 function validate_only_lanes(options, lanes) {
   if (!options.onlyLanes || options.onlyLanes.length === 0) return;
@@ -3450,6 +3486,7 @@ var Act = class {
           const close_actor = { id: "$close", name: "close" };
           const result = await run_close_cycle(targets, {
             reactive_events_size: this._reactive_events.size,
+            catch_up_correlation: (until) => this._catch_up_correlation(until),
             event_to_state: this._event_to_state,
             load: this._es.load,
             tombstone: this._es.tombstone,
@@ -3536,7 +3573,6 @@ var Act = class {
     return new CorrelateCycle({
       registry: this.registry,
       static_targets: classification.static_targets,
-      has_dynamic_resolvers: classification.has_dynamic_resolvers,
       cd: this._cd,
       max_subscribed_streams: options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
       on_init: () => {
@@ -3587,11 +3623,7 @@ var Act = class {
         correlate: (q) => this.correlate(q),
         drain: (o) => this.drain(o),
         on_settled: (drain) => this.emit("settled", drain),
-        breaker: this._breaker,
-        // Static-reaction apps' correlate is a no-op (no store call), so a
-        // settle pass carries no store-health signal — don't let it record a
-        // breaker success (#1329).
-        correlate_probes_store: this._correlate.has_dynamic_resolvers
+        breaker: this._breaker
       },
       options.settleDebounceMs ?? DEFAULT_SETTLE_DEBOUNCE_MS
     );
@@ -3964,8 +3996,13 @@ var Act = class {
    * Drain uses a dual-frontier strategy to balance processing of new streams (lagging)
    * vs active streams (leading). The ratio adapts based on event pressure.
    *
-   * Call `correlate()` before `drain()` to discover target streams. For a higher-level
-   * API that handles debouncing, correlation, and signaling automatically, use {@link settle}.
+   * 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 (#1487), 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
+   * higher-level API that handles debouncing, correlation, and signaling
+   * automatically, use {@link settle}.
    *
    * @param options - Drain configuration — see {@link DrainOptions} for fields
    *   (`streamLimit`, `eventLimit`, `leaseMillis`).
@@ -4094,10 +4131,10 @@ var Act = class {
   async correlate(query = { after: -1, limit: 10 }) {
     if (!this._drain) return { subscribed: 0, last_id: -1 };
     return this._scoped(async () => {
-      const result = await this._correlate.correlate(query);
-      if (result.subscribed > 0 && this._reactive_events.size > 0)
+      const { subscribed, last_id, marked } = await this._correlate.correlate(query);
+      if ((subscribed > 0 || marked > 0) && this._reactive_events.size > 0)
         this._arm_all();
-      return result;
+      return { subscribed, last_id };
     });
   }
   /**
@@ -4515,6 +4552,26 @@ var Act = class {
    * removed, so a later correlate can re-subscribe it (#1398). Restart
    * targets keep their row, so only fully-retired streams are forgotten.
    */
+  /**
+   * Advance correlation until the read cursor reaches `until`, and report
+   * where it landed (#1487). Used by the close cycle's safety probe, which
+   * cannot judge a subscription's pending work over events correlate has
+   * not resolved yet.
+   *
+   * Bounded on both ends: it stops as soon as a pass makes no progress (the
+   * log has no more to give), and after {@link CLOSE_CATCH_UP_PASSES}
+   * windows, so a close behind an enormous backlog degrades to skipping the
+   * stream — the documented retryable outcome — instead of scanning the
+   * whole log inside an operator call.
+   */
+  async _catch_up_correlation(until) {
+    for (let pass = 0; pass < CLOSE_CATCH_UP_PASSES && this._correlate.checkpoint < until; pass++) {
+      const before = this._correlate.checkpoint;
+      await this.correlate({ limit: CLOSE_CATCH_UP_LIMIT });
+      if (this._correlate.checkpoint <= before) break;
+    }
+    return this._correlate.checkpoint;
+  }
   _forget_closed_subscriptions(result) {
     const retired = [...result.truncated.entries()].filter(([, r]) => r.committed.name === TOMBSTONE_EVENT).map(([stream]) => stream);
     if (retired.length) this._correlate.forget_subscribed(retired);
@@ -4526,6 +4583,7 @@ var Act = class {
       const close_actor = { id: "$close", name: "close" };
       const result = await run_close_cycle(targets, {
         reactive_events_size: this._reactive_events.size,
+        catch_up_correlation: (until) => this._catch_up_correlation(until),
         event_to_state: this._event_to_state,
         load: this._es.load,
         tombstone: this._es.tombstone,