@dudousxd/nestjs-durable-core 0.52.0 → 0.54.0

package/dist/index.js

@@ -783,10 +783,16 @@ var EventAccumulators = class {
 // src/events.ts
 var enc = /* @__PURE__ */ __name((s) => Buffer.from(s, "utf8").toString("base64"), "enc");
 var dec = /* @__PURE__ */ __name((s) => Buffer.from(s, "base64").toString("utf8"), "dec");
+var EVENT_BUFFER_SCAN_LIMIT = 50;
+var EVENT_TOKEN_PREFIX = "event:";
 function eventPrefix(name) {
-  return `event:${enc(name)}:`;
+  return `${EVENT_TOKEN_PREFIX}${enc(name)}:`;
 }
 __name(eventPrefix, "eventPrefix");
+function isEventToken(token) {
+  return token.startsWith(EVENT_TOKEN_PREFIX);
+}
+__name(isEventToken, "isEventToken");
 function eventToken(name, match, runId, seq) {
   return `${eventPrefix(name)}${enc(JSON.stringify(match ?? {}))}:${runId}#${seq}`;
 }
@@ -865,6 +871,47 @@ var RemoteWorkflowExecutor = class {
   }
 };
 
+// src/run-waiting.ts
+var WEBHOOK_PREFIX = "wh:";
+var CHILD_PREFIX = "child:";
+var BREAKPOINT_PREFIX = "bp:";
+var EVENT_PREFIX = EVENT_TOKEN_PREFIX;
+function classifyWaiterToken(token) {
+  if (token.startsWith(WEBHOOK_PREFIX)) return {
+    on: "webhook",
+    name: token
+  };
+  if (token.startsWith(BREAKPOINT_PREFIX)) return {
+    on: "breakpoint",
+    name: "breakpoint"
+  };
+  if (token.startsWith(CHILD_PREFIX)) return {
+    on: "child",
+    name: token.slice(CHILD_PREFIX.length)
+  };
+  if (token.startsWith(EVENT_PREFIX)) return {
+    on: "signal",
+    name: eventNameOf(token)
+  };
+  return {
+    on: "signal",
+    name: token
+  };
+}
+__name(classifyWaiterToken, "classifyWaiterToken");
+function resolveRunWaiting(run, waiterByRun) {
+  if (run.status !== "suspended") return void 0;
+  const waiter = waiterByRun.get(run.id);
+  return waiter ? classifyWaiterToken(waiter.token) : void 0;
+}
+__name(resolveRunWaiting, "resolveRunWaiting");
+function indexWaitersByRun(waiters) {
+  const byRun = /* @__PURE__ */ new Map();
+  for (const w of waiters) if (!byRun.has(w.runId)) byRun.set(w.runId, w);
+  return byRun;
+}
+__name(indexWaitersByRun, "indexWaitersByRun");
+
 // src/singleton-gate.ts
 var SINGLETON_RETRY_MS = 1e3;
 var SINGLETON_RETRY_JITTER_MS = 250;
@@ -1294,6 +1341,29 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
       value: buffered.payload
     };
   }, "consumeBuffered");
+  const consumeBufferedEvent = /* @__PURE__ */ __name(async (name, match, token, seq) => {
+    const candidates = await store.listBufferedEvents(name, EVENT_BUFFER_SCAN_LIMIT);
+    for (const candidate of candidates) {
+      if (!eventMatches(candidate.payload, match ?? {})) continue;
+      if (!await store.removeBufferedEvent(candidate.id)) continue;
+      await store.removeSignalWaiter({
+        token,
+        runId,
+        seq
+      });
+      await writeCheckpoint(instantCheckpoint({
+        runId,
+        seq,
+        name: `signal:${token}`,
+        kind: "signal",
+        output: candidate.payload
+      }));
+      return {
+        value: candidate.payload
+      };
+    }
+    return null;
+  }, "consumeBufferedEvent");
   const stampDeadline = /* @__PURE__ */ __name(async (deadlineSeq, label, timeoutMs) => {
     const recorded = await readCheckpoint(deadlineSeq);
     const deadline = recorded?.wakeAt ?? host.clock() + timeoutMs;
@@ -1320,6 +1390,15 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         runId,
         seq: current
       });
+      const lateBuffered2 = await consumeBuffered(token, current);
+      if (lateBuffered2) {
+        await store.removeSignalWaiter({
+          token,
+          runId,
+          seq: current
+        });
+        return lateBuffered2.value;
+      }
       throw new WorkflowSuspended();
     }
     const timeoutMs = opts.timeoutMs;
@@ -1331,7 +1410,11 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
     const buffered = await consumeBuffered(token, waitSeq);
     if (buffered) return buffered.value;
     if (host.clock() >= deadline) {
-      await store.takeSignalWaiter(token).catch(() => void 0);
+      await store.removeSignalWaiter({
+        token,
+        runId,
+        seq: waitSeq
+      }).catch(() => void 0);
       throw new SignalTimeoutError(token, timeoutMs);
     }
     await store.putSignalWaiter({
@@ -1339,6 +1422,15 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
       runId,
       seq: waitSeq
     });
+    const lateBuffered = await consumeBuffered(token, waitSeq);
+    if (lateBuffered) {
+      await store.removeSignalWaiter({
+        token,
+        runId,
+        seq: waitSeq
+      });
+      return lateBuffered.value;
+    }
     throw new WorkflowSuspended(deadline);
   }, "waitForSignal");
   const waitForEvent = /* @__PURE__ */ __name(async (name, opts) => {
@@ -1352,6 +1444,8 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         runId,
         seq: current
       });
+      const bufferedHit2 = await consumeBufferedEvent(name, opts?.match, token2, current);
+      if (bufferedHit2) return bufferedHit2.value;
       throw new WorkflowSuspended();
     }
     const timeoutMs = opts.timeoutMs;
@@ -1362,7 +1456,11 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
     const waited = await readCheckpoint(waitSeq);
     if (waited && waited.status === "completed") return waited.output;
     if (host.clock() >= deadline) {
-      await store.takeSignalWaiter(token).catch(() => void 0);
+      await store.removeSignalWaiter({
+        token,
+        runId,
+        seq: waitSeq
+      }).catch(() => void 0);
       throw new SignalTimeoutError(`event:${name}`, timeoutMs);
     }
     await store.putSignalWaiter({
@@ -1370,6 +1468,8 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
       runId,
       seq: waitSeq
     });
+    const bufferedHit = await consumeBufferedEvent(name, opts.match, token, waitSeq);
+    if (bufferedHit) return bufferedHit.value;
     throw new WorkflowSuspended(deadline);
   }, "waitForEvent");
   const task = /* @__PURE__ */ __name(async (name, dispatch, options) => {
@@ -1763,6 +1863,7 @@ var WorkflowEngine = class {
   maxRecoveryAttempts;
   remoteAdvanceSilenceMs;
   reconcileMs;
+  eventBufferTtlMs;
   remoteRedispatchMs;
   remoteRedispatchMax;
   webhookUrl;
@@ -1836,6 +1937,7 @@ var WorkflowEngine = class {
     this.maxRecoveryAttempts = deps.maxRecoveryAttempts;
     this.remoteAdvanceSilenceMs = deps.remoteAdvanceSilenceMs;
     this.reconcileMs = deps.reconcileMs === void 0 ? 3e5 : deps.reconcileMs || void 0;
+    this.eventBufferTtlMs = deps.eventBufferTtlMs || void 0;
     this.remoteRedispatchMs = deps.remoteRedispatchMs || void 0;
     this.remoteRedispatchMax = Math.max(1, deps.remoteRedispatchMax ?? 10);
     this.webhookUrl = deps.webhookUrl;
@@ -2508,9 +2610,81 @@ var WorkflowEngine = class {
   /**
   * Resume every suspended run whose durable timer is due. Call periodically (a poller) and on
   * boot. A run still not due re-suspends cheaply without running new work.
+  *
+  * Piggy-backs the signal/event-waiter reconcile safety net (see {@link reconcileSignalWaiter}): a
+  * crash between the waiter/buffer pairing ops on EITHER side (this run's own `putSignalWaiter` →
+  * `takeBufferedSignal`/`listBufferedEvents`, or the other side's `takeSignalWaiter`/fan-out →
+  * `bufferSignal`/`bufferEvent` → re-check — see `signal`'s interleaving proof, which `publishEvent`
+  * mirrors for events) can leave both rows stranded with nothing left to pair them: the waiter's turn
+  * already suspended, the other side that buffered it already returned. Event-wait suspends already
+  * carry a `reconcileMs` fallback `wakeAt` (see {@link reconcileWakeAt}) precisely so they show up
+  * HERE — that's what makes this due-timer pass the natural place for the sweep (and, for events, also
+  * where an `eventBufferTtlMs` prune piggy-backs — see {@link reconcileBufferedEvent}). One bulk waiter
+  * scan, filtered to just this tick's batch, keeps it cheap regardless of store size.
   */
   async resumeDueTimers(nowMs = this.clock()) {
-    return this.resumeLeased(await this.store.listDueTimers(nowMs, this.namespace), nowMs);
+    const due = await this.store.listDueTimers(nowMs, this.namespace);
+    if (due.length === 0) return [];
+    const waiterByRun = indexWaitersByRun(await this.store.listSignalWaiters(""));
+    return this.resumeLeased(due, nowMs, (run) => this.reconcileSignalWaiter(run, waiterByRun.get(run.id)));
+  }
+  /**
+  * The reconcile safety net's per-run check (see {@link resumeDueTimers}): if this suspended run has
+  * a registered signal OR event waiter and a matching payload is already buffered, pair and deliver
+  * them directly instead of falling through to a full replay. Child/breakpoint waiter tokens are
+  * never buffered (a child/breakpoint notifies via `signal` only once its counterpart is already
+  * registered) — `takeBufferedSignal` on those is a guaranteed miss, so this only ever does real work
+  * for a plain signal or an event waiter (classified via {@link isEventToken}).
+  *
+  * Also opportunistically prunes expired buffered EVENTS for this waiter's name when
+  * {@link eventBufferTtlMs} is set (see its doc — scoped to names a registered waiter references in
+  * this tick's batch, piggy-backing the SAME scan rather than a separate pass), even on a miss.
+  *
+  * Returns `undefined` (not settled — `resumeLeased` proceeds with its normal `resume`) when there's
+  * no waiter or no buffered hit. Deliberately never returns `null`: a delivered signal always resumes
+  * via {@link deliverSignal}, and even a `NamespaceMismatch` there is reported as a real (non-nullish)
+  * result — returning `null` would read as "not settled" to `resumeLeased`'s `??` fallback and
+  * trigger a second, redundant `resume` call on the same run.
+  */
+  async reconcileSignalWaiter(run, waiter) {
+    if (!waiter) return void 0;
+    if (isEventToken(waiter.token)) return this.reconcileBufferedEvent(run, waiter);
+    const buffered = await this.store.takeBufferedSignal(waiter.token);
+    if (!buffered) return void 0;
+    await this.store.removeSignalWaiter(waiter);
+    const settled = await this.deliverSignal(waiter, buffered.payload);
+    return settled ?? {
+      runId: run.id,
+      status: run.status
+    };
+  }
+  /**
+  * The EVENT half of {@link reconcileSignalWaiter}: scan this waiter's name for a matching buffered
+  * event (same list+evaluate+claim shape as `waitForEvent`'s own consumption — the match predicate
+  * belongs to the waiter, never the store), pruning any expired candidates it encounters along the
+  * way when {@link eventBufferTtlMs} is configured. A pruned-but-non-matching candidate does not stop
+  * the scan; only a MATCHING hit (or exhausting the scan window) does.
+  */
+  async reconcileBufferedEvent(run, waiter) {
+    const name = eventNameOf(waiter.token);
+    const match = eventMatchOf(waiter.token);
+    const candidates = await this.store.listBufferedEvents(name, EVENT_BUFFER_SCAN_LIMIT);
+    const nowMs = this.clock();
+    for (const candidate of candidates) {
+      if (this.eventBufferTtlMs != null && nowMs - candidate.publishedAt > this.eventBufferTtlMs) {
+        await this.store.removeBufferedEvent(candidate.id);
+        continue;
+      }
+      if (!eventMatches(candidate.payload, match)) continue;
+      if (!await this.store.removeBufferedEvent(candidate.id)) continue;
+      await this.store.removeSignalWaiter(waiter);
+      const settled = await this.deliverSignal(waiter, candidate.payload);
+      return settled ?? {
+        runId: run.id,
+        status: run.status
+      };
+    }
+    return void 0;
   }
   /**
   * Lease and execute one run by id — the worker side of dispatch. Acquires the recovery lease (so
@@ -2700,6 +2874,21 @@ var WorkflowEngine = class {
   *  2. **Starts** a fresh run of every workflow registered with `onEvent: [name]`, passing the
   *     payload as input. Idempotent by `evt:<id>:<workflow>` — pass `opts.id` to dedupe redeliveries
   *     of the same logical event (default: a fresh uuid, so each publish triggers once).
+  *
+  * Semantics (deliberate — mirrors `signalWithStart`'s reliability contract, so document it exactly):
+  * a publish that resumes ≥1 live waiter, OR routes into an `eventBatch` accumulator / starts ≥1
+  * subscriber, behaves exactly as above and is NOT buffered — fan-out stays live-only, same as
+  * today. A publish that touches NEITHER — no live waiter matched, no subscriber exists/started —
+  * buffers ONE copy (via {@link StateStore.bufferEvent}) unless `opts.buffer === false`, so it isn't
+  * silently dropped just because nobody happened to be listening yet. That buffered copy is consumed
+  * by the FIRST future `ctx.waitForEvent(name, { match })` whose match accepts its payload —
+  * point-to-point on redelivery, by design (only one waiter ever gets it, even though the LIVE path
+  * above is fan-out) — never by a second, later-registered onEvent subscriber (subscriber starts stay
+  * live-only; `opts.id` dedupe applies to those only, unchanged). Right after buffering, this re-checks
+  * `listSignalWaiters` ONCE — sandwich parity with `signal`'s own take → buffer → re-check — so a
+  * waiter that registers in the sliver between the initial miss and the buffer write is still paired
+  * instead of leaving both rows stranded (see `signal`'s interleaving proof; `waitForEvent`'s own
+  * post-registration buffer scan is the mirror-image half of this same race).
   */
   async publishEvent(name, payload, opts) {
     let touched = 0;
@@ -2726,18 +2915,36 @@ var WorkflowEngine = class {
         }
       }
     }
+    if (touched > 0 || opts?.buffer === false) return touched;
+    const bufferedId = globalThis.crypto.randomUUID();
+    await this.store.bufferEvent({
+      name,
+      payload,
+      id: bufferedId,
+      publishedAt: this.clock()
+    });
+    const lateWaiters = await this.store.listSignalWaiters(eventPrefix(name));
+    const lateWaiter = lateWaiters.find((w) => eventMatches(payload, eventMatchOf(w.token)));
+    if (!lateWaiter) return touched;
+    if (!await this.store.removeBufferedEvent(bufferedId)) return touched;
+    const waiter = await this.store.takeSignalWaiter(lateWaiter.token);
+    if (waiter) {
+      const settled = await this.deliverSignal(waiter, payload);
+      if (settled) touched += 1;
+    }
     return touched;
   }
-  async signal(token, payload) {
-    const waiter = await this.store.takeSignalWaiter(token);
-    if (!waiter) {
-      await this.store.bufferSignal(token, payload);
-      return null;
-    }
+  /**
+  * Deliver a signal to an already-known waiter: write its resolving `signal:<token>` checkpoint and
+  * resume the run. Shared by {@link signal}'s direct hit, its post-buffer re-check reclaim, and the
+  * due-timer reconcile sweep ({@link reconcileSignalWaiter}) — all three resolve a waiter the exact
+  * same way.
+  */
+  async deliverSignal(waiter, payload) {
     await this.store.saveCheckpoint(instantCheckpoint({
       runId: waiter.runId,
       seq: waiter.seq,
-      name: `signal:${token}`,
+      name: `signal:${waiter.token}`,
       kind: "signal",
       output: payload,
       // Carry the awaiting command's fan group (set when a `ctx.gather_children`/`ctx.all` fan-out
@@ -2752,6 +2959,42 @@ var WorkflowEngine = class {
     });
   }
   /**
+  * Deliver an external signal to the run waiting on `token`, resume it with `payload`, and return
+  * the run result — or null if no run is (or ends up) waiting for it.
+  *
+  * Race with the waiter side (`waitForSignal`'s check → `putSignalWaiter` → re-check, same shape in
+  * the remote `waitSignal` command): a waiter can register in the sliver between this method's
+  * initial `takeSignalWaiter` miss and its `bufferSignal` write, and the naive old flow (buffer and
+  * return) would then leave BOTH a buffered payload and a registered waiter sitting in the store with
+  * nothing left to pair them — a lost wake, forever suspended.
+  *
+  * The interleaving proof: the waiter side does check → put → re-check, this side does take → buffer
+  * → re-check. Whichever side's SECOND look runs last is guaranteed to observe the other side's
+  * write, because it always follows that write in real time:
+  *  - If the waiter's `put` lands before this method's first `take`, the take just finds it directly
+  *    (the pre-existing, non-racy path).
+  *  - If the waiter's `put` lands after this method's `bufferSignal`, our re-check below either sees
+  *    it (if `put` also lands before the re-check) or the waiter's OWN post-put re-check sees our
+  *    buffer (if `put` lands after our re-check but the waiter hasn't re-checked yet either — its
+  *    re-check strictly follows its own put).
+  *  - If the waiter's `put` lands between this method's `take` and its re-`take`, the re-check below
+  *    catches it.
+  * Either way, the destructive `take*` ops (on the waiter row, on the buffer) arbitrate: whichever
+  * side actually removes the row is the one that delivers, so a signal is never delivered twice.
+  */
+  async signal(token, payload) {
+    const waiter = await this.store.takeSignalWaiter(token);
+    if (waiter) return this.deliverSignal(waiter, payload);
+    await this.store.bufferSignal(token, payload);
+    const lateWaiter = await this.store.takeSignalWaiter(token);
+    if (!lateWaiter) return null;
+    const reclaimed = await this.store.takeBufferedSignal(token);
+    if (!reclaimed) {
+      return null;
+    }
+    return this.deliverSignal(lateWaiter, reclaimed.payload);
+  }
+  /**
   * Ensure a run exists for `runId`, then deliver a signal to it — atomically race-free thanks to
   * signal buffering: if the run is new (or busy / not yet waiting), the signal is buffered and
   * consumed when it reaches `waitForSignal(token)`. The canonical **durable-entity / accumulator**
@@ -3224,6 +3467,14 @@ var WorkflowEngine = class {
         error: outcome.error
       };
     }
+    const latest = await this.store.getRun(run.id);
+    if (latest?.status === "cancelled") {
+      return {
+        runId: run.id,
+        status: "cancelled",
+        error: latest.error
+      };
+    }
     await this.store.updateRun(run.id, {
       status: "suspended",
       wakeAt: this.reconcileWakeAt(outcome.wakeAt),
@@ -3566,22 +3817,34 @@ var WorkflowEngine = class {
         }));
         wakeAt = wakeAt == null ? deadline : Math.min(wakeAt, deadline);
       } else if (cmd.kind === "waitSignal") {
-        const buffered = await this.store.takeBufferedSignal(cmd.signal);
-        if (buffered) {
+        const deliverBuffered = /* @__PURE__ */ __name(async (payload) => {
           await this.store.saveCheckpoint(instantCheckpoint({
             runId: run.id,
             seq: cmd.seq,
             name: `signal:${cmd.signal}`,
             kind: "signal",
-            output: buffered.payload
+            output: payload
           }));
           setTimeout(() => void this.resume(run.id).catch(() => void 0), 0);
+        }, "deliverBuffered");
+        const buffered = await this.store.takeBufferedSignal(cmd.signal);
+        if (buffered) {
+          await deliverBuffered(buffered.payload);
         } else {
           await this.store.putSignalWaiter({
             token: cmd.signal,
             runId: run.id,
             seq: cmd.seq
           });
+          const lateBuffered = await this.store.takeBufferedSignal(cmd.signal);
+          if (lateBuffered) {
+            await this.store.removeSignalWaiter({
+              token: cmd.signal,
+              runId: run.id,
+              seq: cmd.seq
+            });
+            await deliverBuffered(lateBuffered.payload);
+          }
         }
       } else if (cmd.kind === "startChild") {
         const childId = `${run.id}.child.${cmd.seq}`;
@@ -4441,47 +4704,6 @@ var TERMINAL_RUN_STATUSES = [
   "dead"
 ];
 
-// src/run-waiting.ts
-var WEBHOOK_PREFIX = "wh:";
-var CHILD_PREFIX = "child:";
-var BREAKPOINT_PREFIX = "bp:";
-var EVENT_PREFIX = "event:";
-function classifyWaiterToken(token) {
-  if (token.startsWith(WEBHOOK_PREFIX)) return {
-    on: "webhook",
-    name: token
-  };
-  if (token.startsWith(BREAKPOINT_PREFIX)) return {
-    on: "breakpoint",
-    name: "breakpoint"
-  };
-  if (token.startsWith(CHILD_PREFIX)) return {
-    on: "child",
-    name: token.slice(CHILD_PREFIX.length)
-  };
-  if (token.startsWith(EVENT_PREFIX)) return {
-    on: "signal",
-    name: eventNameOf(token)
-  };
-  return {
-    on: "signal",
-    name: token
-  };
-}
-__name(classifyWaiterToken, "classifyWaiterToken");
-function resolveRunWaiting(run, waiterByRun) {
-  if (run.status !== "suspended") return void 0;
-  const waiter = waiterByRun.get(run.id);
-  return waiter ? classifyWaiterToken(waiter.token) : void 0;
-}
-__name(resolveRunWaiting, "resolveRunWaiting");
-function indexWaitersByRun(waiters) {
-  const byRun = /* @__PURE__ */ new Map();
-  for (const w of waiters) if (!byRun.has(w.runId)) byRun.set(w.runId, w);
-  return byRun;
-}
-__name(indexWaitersByRun, "indexWaitersByRun");
-
 // src/codec-state-store.ts
 var CodecStateStore = class {
   static {
@@ -4589,6 +4811,9 @@ var CodecStateStore = class {
   listSignalWaiters(prefix) {
     return this.inner.listSignalWaiters(prefix);
   }
+  removeSignalWaiter(waiter) {
+    return this.inner.removeSignalWaiter(waiter);
+  }
   bufferSignal(token, payload) {
     return this.inner.bufferSignal(token, this.enc(payload));
   }
@@ -4598,6 +4823,22 @@ var CodecStateStore = class {
       payload: this.dec(buffered.payload)
     };
   }
+  bufferEvent(input) {
+    return this.inner.bufferEvent({
+      ...input,
+      payload: this.enc(input.payload)
+    });
+  }
+  async listBufferedEvents(name, limit) {
+    const events = await this.inner.listBufferedEvents(name, limit);
+    return events.map((e) => ({
+      ...e,
+      payload: this.dec(e.payload)
+    }));
+  }
+  removeBufferedEvent(id) {
+    return this.inner.removeBufferedEvent(id);
+  }
   async listRuns(query) {
     return (await this.inner.listRuns(query)).map((r) => this.decRun(r));
   }
@@ -5041,6 +5282,12 @@ var InMemoryStateStore = class {
       ...w
     }));
   }
+  async removeSignalWaiter(waiter) {
+    const current = this.signalWaiters.get(waiter.token);
+    if (current && current.runId === waiter.runId && current.seq === waiter.seq) {
+      this.signalWaiters.delete(waiter.token);
+    }
+  }
   // No real DB transaction (there's no DB) — run the work and save the checkpoint. Exactly-once
   // across a crash needs a SQL store; this keeps `ctx.transaction` usable in tests / local dev.
   async transaction(work) {
@@ -5064,6 +5311,28 @@ var InMemoryStateStore = class {
       payload
     };
   }
+  /** `id -> row`, so {@link removeBufferedEvent} can delete an exact row regardless of iteration
+  *  order — mirrors the SQL stores' PK-by-id delete. */
+  bufferedEvents = /* @__PURE__ */ new Map();
+  async bufferEvent(input) {
+    this.bufferedEvents.set(input.id, {
+      name: input.name,
+      payload: input.payload,
+      publishedAt: input.publishedAt
+    });
+  }
+  async listBufferedEvents(name, limit) {
+    return [
+      ...this.bufferedEvents.entries()
+    ].filter(([, e]) => e.name === name).sort((a, b) => a[1].publishedAt - b[1].publishedAt).slice(0, limit).map(([id, e]) => ({
+      id,
+      payload: e.payload,
+      publishedAt: e.publishedAt
+    }));
+  }
+  async removeBufferedEvent(id) {
+    return this.bufferedEvents.delete(id);
+  }
   /**
   * Candidate run ids satisfying ONE attribute predicate, served from {@link attributeIndex} — the
   * pushdown step. Numeric predicates scan only `numValue` rows under the key; string/boolean ones
@@ -5222,6 +5491,8 @@ export {
   DURABLE_STEP_CONFIG,
   DURABLE_STEP_NAME,
   DurableWorkflow,
+  EVENT_BUFFER_SCAN_LIMIT,
+  EVENT_TOKEN_PREFIX,
   Entities,
   EventAccumulators,
   FatalError,
@@ -5260,6 +5531,7 @@ export {
   eventPrefix,
   eventToken,
   indexWaitersByRun,
+  isEventToken,
   isWorkflowControlFlowSignal,
   matchesAttributes,
   normalizeAttributeRows,