@rotorsoft/act 1.23.4 → 1.23.6

package/dist/index.cjs

@@ -740,11 +740,12 @@ var InMemoryStream = class {
     if (this._leased_by === lease.by) {
       this._leased_by = void 0;
       this._leased_until = void 0;
-      this._retry = -1;
       if (lease.due !== void 0) {
+        this._retry = lease.retry;
         this._deferred_at = lease.due;
         return void 0;
       }
+      this._retry = -1;
       this._at = lease.at;
       this._deferred_at = void 0;
       return {
@@ -906,7 +907,18 @@ var InMemoryStore = class {
   async query(callback, query) {
     await sleep();
     let count = 0;
+    let floor_index = -1;
+    if (query?.with_snaps && query.stream_exact && query.stream !== void 0 && query.after === void 0) {
+      for (let j = this._events.length - 1; j >= 0; j--) {
+        const e = this._events[j];
+        if (e.stream === query.stream && e.name === SNAP_EVENT) {
+          floor_index = j;
+          break;
+        }
+      }
+    }
     if (query?.backward) {
+      const floor_id = floor_index >= 0 ? this._events[floor_index].id : -1;
       let i = (query?.before !== void 0 ? this._first_index_after(query.before - 1) : this._events.length) - 1;
       while (i >= 0) {
         const e = this._events[i--];
@@ -914,6 +926,7 @@ var InMemoryStore = class {
         if (query?.created_before && e.created >= query.created_before)
           continue;
         if (query.after !== void 0 && e.id <= query.after) break;
+        if (floor_id >= 0 && e.id < floor_id) break;
         if (query.created_after && e.created <= query.created_after) continue;
         await Promise.resolve(
           callback(this._with_pii(e))
@@ -922,16 +935,7 @@ var InMemoryStore = class {
         if (query?.limit && count >= query.limit) break;
       }
     } else {
-      let i = this._first_index_after(query?.after ?? -1);
-      if (query?.with_snaps && query.stream_exact && query.stream !== void 0 && query.after === void 0 && query.created_before === void 0 && query.created_after === void 0) {
-        for (let j = this._events.length - 1; j >= 0; j--) {
-          const e = this._events[j];
-          if (e.stream === query.stream && e.name === SNAP_EVENT) {
-            i = j;
-            break;
-          }
-        }
-      }
+      let i = floor_index >= 0 ? floor_index : this._first_index_after(query?.after ?? -1);
       while (i < this._events.length) {
         const e = this._events[i++];
         if (query && !this.in_query(query, e)) continue;
@@ -3502,7 +3506,14 @@ async function load(me, target, callback, patch_fn = bare_patch) {
     {
       stream,
       stream_exact: true,
-      ...cached ? { after: cached.event_id } : { with_snaps: true, ...asOf }
+      // The snapshot resume floor is a current-state optimization: it only
+      // holds when the load has no window of its own. `time_travel` already
+      // captures that (any `asOf` bound set), so request `with_snaps` only for
+      // a non-time-travel cold load — a bounded load full-scans real events
+      // under its `asOf` filter. This is the single floor-eligibility decision
+      // for the whole system; the stores apply the floor whenever asked and
+      // never re-derive it (RFC 1274). The warm path resumes from `after`.
+      ...cached ? { after: cached.event_id } : { ...time_travel ? {} : { with_snaps: true }, ...asOf }
     }
   );
   const head_is_tombstone = event?.name === TOMBSTONE_EVENT;
@@ -3844,7 +3855,7 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 }
 
 // src/internal/drain-cycle.ts
-async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, is_deferred, lane) {
+async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, lane) {
   const leased = await ops.claim(
     lagging,
     leading,
@@ -3853,18 +3864,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
     lane
   );
   if (!leased.length) return void 0;
-  const active = is_deferred ? leased.filter((l) => !is_deferred(l.stream)) : leased;
-  if (!active.length) {
-    return {
-      leased,
-      fetched: [],
-      handled: [],
-      acked: [],
-      blocked: [],
-      closeable: []
-    };
-  }
-  const fetched = await ops.fetch(active, eventLimit);
+  const fetched = await ops.fetch(leased, eventLimit);
   const fetch_map = /* @__PURE__ */ new Map();
   const fetch_window_at = fetched.reduce(
     (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
@@ -3883,7 +3883,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
     fetch_map.set(stream, { fetch: f, payloads });
   }
   const handled = await Promise.all(
-    active.map((lease) => {
+    leased.map((lease) => {
       const entry = fetch_map.get(lease.stream);
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
@@ -3896,7 +3896,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
   );
   const acked = await ops.ack(
     handled.flatMap(
-      (h) => h.defer !== void 0 ? { ...h.lease, due: h.defer } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : []
+      (h) => h.defer !== void 0 ? { ...h.lease, due: h.defer, retry: -1 } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : h.next_attempt_at !== void 0 ? { ...h.lease, due: h.next_attempt_at } : []
     )
   );
   const blocked = await ops.block(
@@ -4019,7 +4019,6 @@ var DrainController = class {
         leading,
         eventLimit,
         leaseMillis,
-        this._defer.size > 0 ? this._defer.is_deferred : void 0,
         this._deps.lane
       );
       this._deps.breaker.passed();