@rotorsoft/act 1.22.3 → 1.22.5

package/dist/index.js

@@ -13,13 +13,14 @@ import {
   dispose,
   disposeAndExit,
   extend,
+  is_literal_source,
   log,
   port,
   scoped,
   sleep,
   store,
   validate
-} from "./chunk-2FN4RFBQ.js";
+} from "./chunk-CWBI4NQD.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -1381,13 +1382,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() {
@@ -1482,7 +1492,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
@@ -1627,8 +1639,10 @@ async function fetch(leased, eventLimit) {
   return Promise.all(
     leased.map(async ({ stream, source, at, lagging }) => {
       const events = [];
+      const stream_exact = source !== void 0 && is_literal_source(source) ? true : void 0;
       await store().query((e) => events.push(e), {
         stream: source,
+        stream_exact,
         after: at,
         limit: eventLimit
       });
@@ -1787,12 +1801,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
+                  }
                 }
               }
             };
@@ -1859,7 +1876,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 cache().set(stream, {
       stream,
       state: state2,
@@ -2293,8 +2311,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();
@@ -2895,6 +2914,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.
@@ -2941,14 +2963,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),
@@ -4560,6 +4589,7 @@ export {
   dispose,
   disposeAndExit,
   extend,
+  is_literal_source,
   log,
   port,
   projection,