@rotorsoft/act 1.22.2 → 1.22.4

package/dist/index.cjs

@@ -811,7 +811,7 @@ var InMemoryStore = class {
   _streams = /* @__PURE__ */ new Map();
   // last committed version per stream — O(1) replacement for filter-on-commit
   _stream_versions = /* @__PURE__ */ new Map();
-  // max non-snapshot event id per stream — drives the source-pattern probe in claim()
+  // max non-snapshot event id per stream — drives the exact-source probe in claim()
   // without scanning the full event log.
   _max_event_id_by_stream = /* @__PURE__ */ new Map();
   // global max non-snapshot event id — fast pre-check for source-less streams in claim()
@@ -999,23 +999,11 @@ var InMemoryStore = class {
    */
   async claim(lagging, leading, by, millis, lane) {
     await sleep();
-    const source_regex = /* @__PURE__ */ new Map();
-    const get_regex = (source) => {
-      let re = source_regex.get(source);
-      if (!re) {
-        re = new RegExp(source);
-        source_regex.set(source, re);
-      }
-      return re;
-    };
     const has_work = (s) => {
       if (s.at < 0) return true;
       if (!s.source) return s.at < this._max_non_snap_event_id;
-      const re = get_regex(s.source);
-      for (const [stream_name, maxId] of this._max_event_id_by_stream) {
-        if (maxId > s.at && re.test(stream_name)) return true;
-      }
-      return false;
+      const max_id = this._max_event_id_by_stream.get(s.source);
+      return max_id !== void 0 && max_id > s.at;
     };
     const available = [...this._streams.values()].filter(
       (s) => s.is_available && has_work(s) && (lane === void 0 || s.lane === lane)
@@ -2899,13 +2887,22 @@ var CorrelateCycle = class {
   _has_dynamic_resolvers;
   _cd;
   _on_init;
-  constructor(registry, static_targets, has_dynamic_resolvers, cd, maxSubscribedStreams, on_init) {
+  /**
+   * Scope runner (#1191). The periodic `start_polling` timer fires
+   * outside any caller frame, so its `correlate()` must be re-wrapped in
+   * the Act's `_scoped` bag or `store()`/`cache()` resolve to the
+   * singleton for a scoped Act. The orchestrator always threads its
+   * `_scoped` (identity for a non-scoped Act), so it's required.
+   */
+  _run_scoped;
+  constructor(registry, static_targets, has_dynamic_resolvers, cd, maxSubscribedStreams, on_init, run_scoped) {
     this._subscribed = new LruSet(maxSubscribedStreams);
     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;
   }
   /** Last correlated event id. */
   get checkpoint() {
@@ -3000,7 +2997,9 @@ var CorrelateCycle = class {
     if (this._timer) return false;
     const limit = query.limit || 100;
     this._timer = setInterval(
-      () => this.correlate({ ...query, after: this._checkpoint, limit }).then((result) => {
+      () => this._run_scoped(
+        () => this.correlate({ ...query, after: this._checkpoint, limit })
+      ).then((result) => {
         if (callback && result.subscribed) callback(result.subscribed);
       }).catch((err) => log().error(err)),
       frequency
@@ -3305,12 +3304,15 @@ async function scan(source, opts = {}, callback) {
           const new_caused_by = id_map.get(caused_by);
           if (new_caused_by !== void 0 && new_caused_by !== caused_by) {
             remapped = {
-              ...event,
+              ...migrated,
               meta: {
-                ...event.meta,
+                ...migrated.meta,
                 causation: {
-                  ...event.meta.causation,
-                  event: { ...event.meta.causation.event, id: new_caused_by }
+                  ...migrated.meta.causation,
+                  event: {
+                    ...migrated.meta.causation.event,
+                    id: new_caused_by
+                  }
                 }
               }
             };
@@ -3377,7 +3379,8 @@ async function load(me, target, callback) {
       ...cached ? { after: cached.event_id } : { with_snaps: true, ...asOf }
     }
   );
-  if (replayed > 0 && !time_travel && event && !me.pii_aware) {
+  const head_is_tombstone = event?.name === TOMBSTONE_EVENT;
+  if (replayed > 0 && !time_travel && event && !me.pii_aware && !head_is_tombstone) {
     await cache2().set(stream, {
       stream,
       state: state2,
@@ -3811,8 +3814,9 @@ var DrainController = class {
    */
   start(cycleMs) {
     if (this._worker || this._stopped) return;
+    const run = this._deps.run_scoped;
     const tick = async () => {
-      if (this._armed) await this.drain();
+      if (this._armed) await run(() => this.drain());
       if (this._stopped) return;
       this._worker = setTimeout(tick, cycleMs);
       this._worker.unref();
@@ -4413,6 +4417,9 @@ var Act = class {
           this.emit("closed", result);
         },
         breaker: this._breaker,
+        // Re-scope the per-lane worker's auto-start ticks so their drain
+        // resolves the scoped ports, not the singleton (#1191).
+        run_scoped: this._scoped,
         // Pass lane only when a true per-lane controller is active.
         // The all-lanes (single default) case keeps lane=undefined so
         // adapter SQL collapses to the single-lane shape.
@@ -4459,14 +4466,21 @@ var Act = class {
       options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
       () => {
         if (this._drain && this._reactive_events.size > 0) this._arm_all();
-      }
+      },
+      // Re-scope the background `start_correlations` timer so its
+      // correlate resolves the scoped ports, not the singleton (#1191).
+      this._scoped
     );
   }
   /** Settle loop driving correlate + drain to quiescence. */
   _build_settle(options) {
     return new SettleLoop(
       {
-        init: () => this._correlate.init(),
+        // Scope the init like every other store-touching path — a bare
+        // `this._correlate.init()` runs `store().subscribe(...)` against
+        // the singleton for a scoped Act, so static targets never land on
+        // the scoped store and `_initialized` then blocks a retry (#1191).
+        init: () => this._scoped(() => this._correlate.init()),
         checkpoint: () => this._correlate.checkpoint,
         correlate: (q) => this.correlate(q),
         drain: (o) => this.drain(o),