@dudousxd/nestjs-durable-core 0.84.1 → 0.85.1

package/dist/index.cjs

@@ -47,6 +47,7 @@ __export(index_exports, {
   GatherError: () => GatherError,
   HANDOFF_SEQ_BASE: () => HANDOFF_SEQ_BASE,
   InMemoryAdmissionBackend: () => InMemoryAdmissionBackend,
+  InMemoryRunQueue: () => InMemoryRunQueue,
   InMemoryStateStore: () => InMemoryStateStore,
   InMemoryTransport: () => InMemoryTransport,
   LEGACY_V1_CAPABILITIES: () => LEGACY_V1_CAPABILITIES,
@@ -131,6 +132,7 @@ __export(index_exports, {
   fanPageEtag: () => fanPageEtag,
   findStalledRuns: () => findStalledRuns,
   foldedCount: () => foldedCount,
+  getRunsByIds: () => getRunsByIds,
   handoffHandlerId: () => handoffHandlerId,
   handoffName: () => handoffName,
   hasDurableExecutionWrappers: () => hasDurableExecutionWrappers,
@@ -168,6 +170,7 @@ __export(index_exports, {
   poolNamespace: () => poolNamespace,
   prevCronFireMs: () => prevCronFireMs,
   queryCheckpointsOf: () => queryCheckpointsOf,
+  readRunsByIds: () => readRunsByIds,
   readSearchAttributes: () => readSearchAttributes,
   requiredCapabilities: () => requiredCapabilities,
   resolveConcurrency: () => resolveConcurrency,
@@ -780,6 +783,82 @@ function backoffDelay(attempt, options) {
 }
 __name(backoffDelay, "backoffDelay");
 
+// src/bounded-runner.ts
+var BoundedRunner = class {
+  static {
+    __name(this, "BoundedRunner");
+  }
+  limit;
+  active = 0;
+  waiting = /* @__PURE__ */ new Map();
+  seq = 0;
+  constructor(limit) {
+    this.limit = limit;
+  }
+  /** Tasks running now plus tasks waiting for a slot. */
+  get size() {
+    return this.active + this.waiting.size;
+  }
+  /** Tasks running now. */
+  get running() {
+    return this.active;
+  }
+  submit(key, task) {
+    if (this.active < this.limit) {
+      this.active += 1;
+      queueMicrotask(() => this.execute(task));
+      return;
+    }
+    if (!this.waiting.has(key)) this.waiting.set(key, {
+      task
+    });
+  }
+  /**
+  * Run `task` under the bound and resolve once it settled, or once it was dropped by
+  * {@link clear} before it got a slot. Never deduplicated.
+  */
+  run(task) {
+    return new Promise((resolve) => {
+      const done = /* @__PURE__ */ __name(() => resolve(), "done");
+      const wrapped = /* @__PURE__ */ __name(() => task().then(done, done), "wrapped");
+      if (this.active < this.limit) {
+        this.active += 1;
+        queueMicrotask(() => this.execute(wrapped));
+        return;
+      }
+      this.seq += 1;
+      this.waiting.set(`\0run:${this.seq}`, {
+        task: wrapped,
+        dropped: done
+      });
+    });
+  }
+  /** Forget every task still waiting for a slot. */
+  clear() {
+    for (const { dropped } of this.waiting.values()) dropped?.();
+    this.waiting.clear();
+  }
+  execute(task) {
+    let settled;
+    try {
+      settled = task();
+    } catch {
+      settled = Promise.resolve();
+    }
+    void settled.catch(() => void 0).then(() => {
+      const next = this.waiting.entries().next();
+      if (next.done) {
+        this.active -= 1;
+        return;
+      }
+      const [key, waiting] = next.value;
+      this.waiting.delete(key);
+      this.execute(waiting.task);
+    });
+  }
+};
+var LOCAL_RUN_CONCURRENCY = 256;
+
 // src/execution-hooks.ts
 var wrappers = [];
 function useDurableExecution(wrapper) {
@@ -2340,6 +2419,61 @@ var RemoteWorkflowExecutor = class {
   }
 };
 
+// src/run-dispatch-batcher.ts
+var RUN_DISPATCH_BATCH = 500;
+var RUN_DISPATCH_WINDOW_MS = 5;
+var RunDispatchBatcher = class {
+  static {
+    __name(this, "RunDispatchBatcher");
+  }
+  send;
+  onError;
+  buffer = /* @__PURE__ */ new Map();
+  timer;
+  sending = /* @__PURE__ */ new Set();
+  constructor(send, onError) {
+    this.send = send;
+    this.onError = onError;
+  }
+  /** Nothing buffered and nothing being sent. */
+  get idle() {
+    return this.buffer.size === 0 && this.sending.size === 0;
+  }
+  /** Buffer `run`. A wake for a run already buffered replaces its start: a wake also runs a `pending` run. */
+  add(run) {
+    const prior = this.buffer.get(run.runId);
+    if (prior && run.reason !== "wake") return;
+    this.buffer.set(run.runId, run);
+    if (this.buffer.size >= RUN_DISPATCH_BATCH) {
+      this.flush();
+      return;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => this.flush(), RUN_DISPATCH_WINDOW_MS);
+      this.timer.unref?.();
+    }
+  }
+  /** Send what is buffered now. */
+  flush() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    if (this.buffer.size === 0) return;
+    const runs = [
+      ...this.buffer.values()
+    ];
+    this.buffer = /* @__PURE__ */ new Map();
+    const sent = this.send(runs).catch((err) => this.onError(runs, err)).finally(() => this.sending.delete(sent));
+    this.sending.add(sent);
+  }
+  /** Send what is buffered and wait for every send in flight. */
+  async settle() {
+    this.flush();
+    await Promise.allSettled([
+      ...this.sending
+    ]);
+  }
+};
+
 // src/run-waiting.ts
 var WEBHOOK_PREFIX = "wh:";
 var CHILD_PREFIX = "child:";
@@ -2410,6 +2544,51 @@ function indexWaitersByRun(waiters) {
   return byRun;
 }
 __name(indexWaitersByRun, "indexWaitersByRun");
+var GET_RUN_FALLBACK_PARALLEL = 50;
+async function getRunsByIds(store, runIds) {
+  const { runs, unread, error: error2 } = await readRunsByIds(store, runIds);
+  if (unread.length > 0) throw error2;
+  return runs;
+}
+__name(getRunsByIds, "getRunsByIds");
+async function readRunsByIds(store, runIds) {
+  const unique = [
+    ...new Set(runIds)
+  ];
+  const runs = /* @__PURE__ */ new Map();
+  const unread = [];
+  let error2;
+  const batch = store.getRuns ? RUN_ID_BATCH : GET_RUN_FALLBACK_PARALLEL;
+  for (let at = 0; at < unique.length; at += batch) {
+    const ids = unique.slice(at, at + batch);
+    if (store.getRuns) {
+      try {
+        for (const run of await store.getRuns(ids)) runs.set(run.id, run);
+      } catch (err) {
+        error2 ??= err;
+        unread.push(...ids);
+      }
+      continue;
+    }
+    const reads = await Promise.allSettled(ids.map((id) => store.getRun(id)));
+    reads.forEach((read, k) => {
+      if (read.status === "fulfilled") {
+        if (read.value) runs.set(read.value.id, read.value);
+        return;
+      }
+      error2 ??= read.reason;
+      unread.push(ids[k]);
+    });
+  }
+  return {
+    runs,
+    unread,
+    ...unread.length > 0 ? {
+      error: error2
+    } : {}
+  };
+}
+__name(readRunsByIds, "readRunsByIds");
 
 // src/scheduler.ts
 var import_node_module = require("module");
@@ -2451,7 +2630,31 @@ __name(resolveCronParse, "resolveCronParse");
 
 // src/scheduler.ts
 var nodeRequire = (0, import_node_module.createRequire)(__importMetaUrl);
-var defaultSleep = /* @__PURE__ */ __name((ms) => new Promise((r) => setTimeout(r, ms)), "defaultSleep");
+var jitterFireAt = /* @__PURE__ */ new WeakMap();
+function deferredWindows(engine, key) {
+  return [
+    ...jitterFireAt.get(engine)?.get(key)?.keys() ?? []
+  ];
+}
+__name(deferredWindows, "deferredWindows");
+function jitterDue(engine, s, candidates, nowMs, random) {
+  let byKey = jitterFireAt.get(engine);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    jitterFireAt.set(engine, byKey);
+  }
+  const previous = byKey.get(s.key);
+  const current = /* @__PURE__ */ new Map();
+  const due = [];
+  for (const runId of candidates) {
+    const at = previous?.get(runId) ?? nowMs + Math.floor(random() * s.jitter);
+    if (nowMs >= at) due.push(runId);
+    else current.set(runId, at);
+  }
+  byKey.set(s.key, current);
+  return due;
+}
+__name(jitterDue, "jitterDue");
 function scheduledRunId(key, everyMs, nowMs) {
   return `sched:${key}:${Math.floor(nowMs / everyMs)}`;
 }
@@ -2521,13 +2724,19 @@ function scheduleRunIdsAt(s, nowMs) {
 __name(scheduleRunIdsAt, "scheduleRunIdsAt");
 async function runSchedules(engine, schedules, nowMs, opts) {
   const random = opts?.random ?? Math.random;
-  const sleep = opts?.sleep ?? defaultSleep;
   const settled = settledIdsFor(engine);
   const ids = [];
   for (const s of schedules) {
     if (engine.isDraining?.()) break;
     if (s.paused) continue;
-    const candidates = scheduleRunIdsAt(s, nowMs).filter((id) => !settled.get(s.key)?.has(id));
+    const due = scheduleRunIdsAt(s, nowMs);
+    const windows = s.jitter && s.jitter > 0 ? [
+      .../* @__PURE__ */ new Set([
+        ...deferredWindows(engine, s.key),
+        ...due
+      ])
+    ] : due;
+    const candidates = windows.filter((id) => !settled.get(s.key)?.has(id));
     if (candidates.length === 0) continue;
     if (s.overlap === "skip" && s.everyMs) {
       const prevBucket = Math.floor(nowMs / s.everyMs) - 1;
@@ -2536,8 +2745,9 @@ async function runSchedules(engine, schedules, nowMs, opts) {
         if (prev && (prev.status === "running" || prev.status === "suspended")) continue;
       }
     }
-    if (s.jitter && s.jitter > 0) await sleep(Math.floor(random() * s.jitter));
-    for (const runId of candidates) {
+    const firing = s.jitter && s.jitter > 0 ? jitterDue(engine, s, candidates, nowMs, random) : candidates;
+    if (firing.length === 0) continue;
+    for (const runId of firing) {
       if (engine.isDraining?.()) break;
       const existing = await engine.getRun(runId);
       remember(settled, s.key, runId);
@@ -3302,6 +3512,39 @@ var TransportPool = class {
       transport.onStartRun?.(handler);
     }
   }
+  /** Does any transport here carry a run queue ({@link Transport.dispatchRuns} + `onDispatchedRun`)? */
+  get dispatchesRuns() {
+    return this.transports.some(({ transport }) => transport.dispatchRuns && transport.onDispatchedRun);
+  }
+  /**
+  * Queue `runs` on the first transport that carries a run queue, failing over to the next on an
+  * error, like {@link dispatch}. Throws if none accepted them.
+  */
+  async dispatchRuns(runs, opts) {
+    let lastErr;
+    for (const { transport } of this.transports) {
+      if (!transport.dispatchRuns || !transport.onDispatchedRun) continue;
+      try {
+        await transport.dispatchRuns(runs, opts);
+        return;
+      } catch (err) {
+        lastErr = err;
+      }
+    }
+    throw lastErr ?? new Error("no transport carries a run queue");
+  }
+  /**
+  * Consume the run queue of every transport that carries one (a run may have been queued on any of
+  * them after a failover). Returns one stop function per consumer.
+  */
+  onDispatchedRun(handler, opts) {
+    const stops = [];
+    for (const { transport } of this.transports) {
+      if (!transport.dispatchRuns || !transport.onDispatchedRun) continue;
+      stops.push(transport.onDispatchedRun(handler, opts));
+    }
+    return stops;
+  }
   /**
   * The live handshake descriptors advertised for `group` (design §7.2), merged across every transport
   * that can report them. Returns `[]` when NO transport implements
@@ -3834,21 +4077,28 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
       return inputs.map((_, i) => i).slice(from, from + waves.waveSize);
     }, "waveItems");
     if (mode === "failFast") {
-      for (let i = 0; i < inputs.length; i += 1) {
-        const cp = existing[i];
-        const c = cp?.status === "completed" ? cp.output : null;
-        if (c && c.ok === false) {
-          for (let j = 0; j < inputs.length; j += 1) {
-            if (j !== i && existing[j]?.status !== "completed") host.cancelChild?.(id(j));
-          }
-          throw new GatherError([
-            {
-              index: i,
-              id: id(i),
-              error: c.error ?? "unknown"
-            }
-          ], inputs.length);
+      const failure = /* @__PURE__ */ __name((i2) => {
+        const cp = existing[i2];
+        const c2 = cp?.status === "completed" ? cp.output : null;
+        return c2 && c2.ok === false ? c2 : null;
+      }, "failure");
+      const first = /* @__PURE__ */ __name((cancelled) => inputs.findIndex((_, i2) => {
+        const c2 = failure(i2);
+        return c2 !== null && c2.code === "cancelled" === cancelled;
+      }), "first");
+      const i = first(false) !== -1 ? first(false) : first(true);
+      const c = i === -1 ? null : failure(i);
+      if (c) {
+        for (let j = 0; j < inputs.length; j += 1) {
+          if (j !== i && existing[j]?.status !== "completed") host.cancelChild?.(id(j));
         }
+        throw new GatherError([
+          {
+            index: i,
+            id: id(i),
+            error: c.error ?? "unknown"
+          }
+        ], inputs.length);
       }
     }
     if (store.compactCheckpoints && inputs.length >= FOLD_MIN_FAN) {
@@ -3927,10 +4177,12 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         await registerChildWaits(entries);
         for (const i of chunk) host.startChild(name, inputs[i], id(i));
       }
-      for (let at = 0; at < toEnsure.length; at += FAN_CHUNK) {
-        await Promise.all(toEnsure.slice(at, at + FAN_CHUNK).map(async (i) => {
-          if (!await store.getRun(id(i))) host.startChild(name, inputs[i], id(i));
-        }));
+      if (toEnsure.length > 0) {
+        const { runs: started, unread } = await readRunsByIds(store, toEnsure.map((i) => id(i)));
+        const skip = new Set(unread);
+        for (const i of toEnsure) {
+          if (!started.has(id(i)) && !skip.has(id(i))) host.startChild(name, inputs[i], id(i));
+        }
       }
     }
     if (active.length > 0) {
@@ -4390,6 +4642,56 @@ var ANNOUNCED_ROUTES_TTL_MS = 5e3;
 var VERSION_UNDECLARED_TAG = "version:undeclared";
 var versionKey = /* @__PURE__ */ __name((name, version) => `${name}@${version}`, "versionKey");
 var STEP_FAN_CHUNK = 200;
+var PARENT_NOTIFY_ATTEMPTS = 4;
+var PARENT_NOTIFY_BACKOFF_MS = 250;
+var LEASE_RECHECK_MAX_MS = 2e3;
+var LEASE_RECHECK_SLACK_MS = 100;
+var LEASE_RECHECK_ATTEMPTS = 30;
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  promise.catch(() => void 0);
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+__name(deferred, "deferred");
+var pendingStateKey = /* @__PURE__ */ __name((at) => String(new Date(at).getTime()), "pendingStateKey");
+var freshPendingKey = /* @__PURE__ */ __name(() => `${Date.now()}-${globalThis.crypto.randomUUID().slice(0, 8)}`, "freshPendingKey");
+var CHILD_SIGNAL_PREFIX = "signal:child:";
+var DELIVER_CHUNK = 50;
+function childCompletion(child) {
+  if (child.status === "completed") return {
+    ok: true,
+    value: child.output
+  };
+  if (child.status === "failed") return failedCompletion(child.error ?? {
+    message: "failed"
+  });
+  if (child.status === "dead") return failedCompletion(child.error ?? {
+    message: "dead"
+  });
+  if (child.status === "cancelled") return cancelledCompletion(child.error);
+  return void 0;
+}
+__name(childCompletion, "childCompletion");
+var CHILD_CANCELLED = "cancelled";
+function cancelledCompletion(error2) {
+  const base = error2 ?? {
+    message: "cancelled"
+  };
+  return failedCompletion({
+    ...base,
+    code: base.code ?? CHILD_CANCELLED
+  });
+}
+__name(cancelledCompletion, "cancelledCompletion");
 var RESULT_BATCH_MAX = 256;
 function shuffle(items) {
   for (let i = items.length - 1; i > 0; i -= 1) {
@@ -4566,6 +4868,35 @@ var WorkflowEngine = class {
   /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
   inflight = /* @__PURE__ */ new Set();
   /**
+  * Work a settled turn leaves running in the background (a parent notification, a post-release
+  * re-drive), so a graceful shutdown waits for it too: dropping one on exit strands the run until
+  * its reconcile timer.
+  */
+  background = /* @__PURE__ */ new Set();
+  /**
+  * Runs with an implicit wake executing on this instance, and whether another wake arrived for the
+  * run meanwhile (see {@link resumeImplicit}).
+  */
+  wakeTurns = /* @__PURE__ */ new Map();
+  /** Re-checks scheduled for runs whose wake found another instance's lease (see {@link execute}). */
+  leaseRetries = /* @__PURE__ */ new Map();
+  /**
+  * Every run turn and child start this instance takes on itself, under one budget of
+  * {@link LOCAL_RUN_CONCURRENCY}: the runs it dispatches to itself, a fan's deferred child starts,
+  * enqueued pickups and the runs it takes off the transport's run queue.
+  */
+  localWork;
+  /** The dispatcher the caller supplied, if any; without one the engine picks (see {@link dispatchRun}). */
+  customDispatcher;
+  /** Runs on their way to the transport's run queue (see {@link consumeRuns}). */
+  runBatcher;
+  /** Set while this engine consumes a transport's run queue, and so dispatches its runs to it. */
+  dispatchesOverTransport = false;
+  /** Stops for the run-queue consumers started by {@link consumeRuns}. */
+  runConsumerStops = [];
+  /** The consumers being stopped, so {@link drain} waits for their runs in flight. */
+  runConsumersStopping;
+  /**
   * The run lease of each execution in flight on THIS instance, by run id — renewed while it runs
   * and checked by every settle (the zombie fence, see {@link ExecutionLease}). Also what `drain()`
   * releases when its budget runs out.
@@ -4621,15 +4952,27 @@ var WorkflowEngine = class {
     this.rehydrate = deps.rehydrate ?? ((_carrier, fn) => fn());
     this.compensationRetries = Math.max(1, deps.compensationRetries ?? 1);
     this.trackStepStart = deps.trackStepStart ?? true;
-    this.runDispatcher = deps.runDispatcher ?? {
-      dispatch: /* @__PURE__ */ __name((runId) => queueMicrotask(() => void this.runOne(runId).catch(() => {
-      })), "dispatch")
+    this.localWork = new BoundedRunner(LOCAL_RUN_CONCURRENCY);
+    this.customDispatcher = deps.runDispatcher;
+    this.runBatcher = new RunDispatchBatcher((runs) => this.pool.dispatchRuns(runs, {
+      namespace: this.namespace
+    }), (runs, err) => {
+      for (const run of runs) {
+        if (run.reason === "wake" && !this.draining) {
+          this.inBackground(this.resumeImplicit(run.runId));
+        }
+      }
+      console.error(`[nestjs-durable] could not queue ${runs.length} run(s) on the transport; starts stay pending for the next poll, wakes resume here:`, err);
+    });
+    this.runDispatcher = {
+      dispatch: /* @__PURE__ */ __name((runId) => this.dispatchRun(runId), "dispatch")
     };
     this.singletons = new SingletonGate({
       store: this.store,
       clock: this.clock,
       dispatch: /* @__PURE__ */ __name((runId) => {
-        this.runDispatcher.dispatch(runId);
+        if (this.queuesRunsOverTransport) void this.wake(runId);
+        else this.runDispatcher.dispatch(runId);
       }, "dispatch"),
       configFor: /* @__PURE__ */ __name((run) => (this.workflows.get(versionKey(run.workflow, run.workflowVersion)) ?? this.latest.get(run.workflow))?.singleton, "configFor")
     });
@@ -4754,13 +5097,224 @@ var WorkflowEngine = class {
   }
   /**
   * Be notified when a run is enqueued on ANOTHER instance (via the control plane), so a worker can
-  * pick it up at once — e.g. `engine.onEnqueued((runId) => engine.runOne(runId))`. Returns an
+  * pick it up at once — e.g. `engine.onEnqueued((runId) => engine.runEnqueued(runId))`. Returns an
   * unsubscribe function. Only wire this on instances that should execute runs (workers).
   */
   onEnqueued(listener) {
     this.enqueuedListeners.add(listener);
     return () => this.enqueuedListeners.delete(listener);
   }
+  /**
+  * Pick up a run another instance announced as enqueued: run it here if it is still `pending`.
+  * Bounded by {@link LOCAL_RUN_CONCURRENCY}, and a run another instance already took is skipped
+  * after one read, instead of being leased and replayed here once more.
+  */
+  runEnqueued(runId) {
+    this.localWork.submit(`run:${runId}`, () => this.runIfPending(runId));
+  }
+  /**
+  * Consume the run queue of every transport that carries one ({@link Transport.dispatchRuns} and
+  * {@link Transport.onDispatchedRun}), and from then on dispatch the runs this engine starts there
+  * rather than executing them in-process: a run, a `ctx.all` fan's children included, executes on
+  * whichever consuming instance takes it, at most {@link LOCAL_RUN_CONCURRENCY} at once per
+  * instance. Call it on every instance that drives runs; the Nest module does on a driving operator.
+  *
+  * Returns a function that stops consuming and resolves once the runs in flight settled, after
+  * which runs are executed in-process again; {@link beginDrain} stops consuming too. Undefined
+  * when no transport carries a run queue: runs keep executing in-process.
+  */
+  consumeRuns() {
+    if (!this.pool.dispatchesRuns) return void 0;
+    if (this.runConsumerStops.length === 0) {
+      this.runConsumerStops = this.pool.onDispatchedRun((run) => this.localWork.run(() => this.runFromQueue(run)), {
+        concurrency: LOCAL_RUN_CONCURRENCY,
+        namespace: this.namespace
+      });
+    }
+    this.dispatchesOverTransport = true;
+    return async () => {
+      this.dispatchesOverTransport = false;
+      await this.runBatcher.settle();
+      await this.stopRunConsumers();
+    };
+  }
+  /** Stop every run-queue consumer; resolves once their runs in flight settled. */
+  stopRunConsumers() {
+    if (this.runConsumerStops.length > 0) {
+      const stops = this.runConsumerStops;
+      this.runConsumerStops = [];
+      this.runConsumersStopping = Promise.allSettled(stops.map((stop) => stop()));
+    }
+    return this.runConsumersStopping ?? Promise.resolve();
+  }
+  /** Whether {@link dispatchRun} queues runs on the transport (see {@link consumeRuns}). */
+  get queuesRunsOverTransport() {
+    return this.customDispatcher === void 0 && this.dispatchesOverTransport;
+  }
+  /**
+  * Hand a `pending` run to whatever executes it: the caller's {@link WorkflowEngineDeps.runDispatcher};
+  * else the transport's run queue while this engine consumes it, batched; else this instance,
+  * bounded by {@link LOCAL_RUN_CONCURRENCY}. A run whose queueing fails stays `pending` for a
+  * `runPending` poll.
+  */
+  dispatchRun(runId, priority, key) {
+    if (this.customDispatcher) return this.customDispatcher.dispatch(runId);
+    if (this.dispatchesOverTransport) {
+      this.runBatcher.add({
+        runId,
+        reason: "start",
+        ...priority !== void 0 ? {
+          priority
+        } : {},
+        ...key !== void 0 ? {
+          key
+        } : {}
+      });
+      return;
+    }
+    this.localWork.submit(`run:${runId}`, () => this.runOne(runId));
+  }
+  /**
+  * Wake a suspended run that has something new to see (a delivered signal or child completion, a
+  * lease that came free, a freed slot): while this engine consumes the transport's run queue, on
+  * whichever instance takes the wake (the result then only says it was handed over); otherwise
+  * here, now.
+  */
+  wake(runId) {
+    if (this.queuesRunsOverTransport) {
+      this.runBatcher.add({
+        runId,
+        reason: "wake"
+      });
+      return Promise.resolve({
+        runId,
+        status: "suspended"
+      });
+    }
+    return this.resumeImplicit(runId);
+  }
+  /**
+  * Take a turn of a run taken off the transport's run queue. A `start` runs only while the run is
+  * still `pending` (or `cancelling`, a recovered cancel): any other state means another instance
+  * already took it. A `wake` leases and resumes the run unless it is finished. The run lease admits
+  * one executor either way. Never rejects.
+  */
+  async runFromQueue(dispatch) {
+    if (this.draining) return;
+    const { runId } = dispatch;
+    try {
+      const run = await this.store.getRun(runId);
+      if (!run) return;
+      if (run.status === "pending" || run.status === "cancelling") {
+        await this.runOne(runId);
+        return;
+      }
+      if (dispatch.reason !== "wake" || TERMINAL_RUN_STATUSES.includes(run.status)) return;
+      const nowMs = this.clock();
+      if (run.wakeAt !== void 0 && run.wakeAt <= nowMs) {
+        const waiters = indexWaitersByRun(await listSignalWaitersOfRuns(this.store, [
+          runId
+        ]));
+        const resumed = await this.resumeLeased([
+          run
+        ], nowMs, (locked) => this.reconcileSignalWaiter(locked, waiters.get(locked.id)));
+        if (resumed.length === 0) this.recheckAfterLease(runId, run.lockedUntil);
+        return;
+      }
+      await this.resumeImplicit(runId).catch((err) => {
+        if (!(err instanceof NamespaceMismatch)) throw err;
+      });
+    } catch (error2) {
+      console.error(`[nestjs-durable] could not run queued run ${runId}:`, error2);
+    }
+  }
+  /**
+  * Hand due runs (timers, blocked runs due for a fleet re-check) to whichever instance takes them
+  * off the run queue. Each is claimed first, under its lease, by pushing its `wakeAt` one lease
+  * period out, so the next poll (here or elsewhere) does not queue it again while it waits; a wake
+  * that is lost brings it back due after that period. False when the transport refused the wakes,
+  * so the caller resumes them itself.
+  */
+  async handOffDue(runs, nowMs) {
+    const claimed = [];
+    for (const run of runs) {
+      if (this.draining) break;
+      if (!await this.store.tryLockRun(run.id, this.instanceId, nowMs + this.leaseMs, nowMs)) {
+        continue;
+      }
+      try {
+        const patch = {
+          wakeAt: nowMs + this.leaseMs
+        };
+        if (this.store.updateRunIf) {
+          if (await this.store.updateRunIf(run.id, [
+            run.status
+          ], patch)) claimed.push(run);
+        } else {
+          await this.store.updateRun(run.id, patch);
+          claimed.push(run);
+        }
+      } finally {
+        await this.store.releaseRunLock(run.id);
+      }
+    }
+    try {
+      for (let at = 0; at < claimed.length; at += RUN_DISPATCH_BATCH) {
+        await this.pool.dispatchRuns(claimed.slice(at, at + RUN_DISPATCH_BATCH).map((run) => ({
+          runId: run.id,
+          reason: "wake",
+          ...run.priority !== void 0 ? {
+            priority: run.priority
+          } : {}
+        })), {
+          namespace: this.namespace
+        });
+      }
+      return true;
+    } catch (error2) {
+      console.error("[nestjs-durable] could not queue due runs on the transport:", error2);
+      return false;
+    }
+  }
+  /**
+  * Queue `runs` on the transport for whichever consuming instance takes them, in batches. False
+  * when the transport refused them, so the caller executes them itself instead.
+  */
+  async queueOnTransport(runs) {
+    try {
+      for (let at = 0; at < runs.length; at += RUN_DISPATCH_BATCH) {
+        await this.pool.dispatchRuns(runs.slice(at, at + RUN_DISPATCH_BATCH).map((run) => ({
+          runId: run.id,
+          reason: "start",
+          key: pendingStateKey(run.updatedAt),
+          ...run.priority !== void 0 ? {
+            priority: run.priority
+          } : {}
+        })), {
+          namespace: this.namespace
+        });
+      }
+      return true;
+    } catch (error2) {
+      console.error("[nestjs-durable] could not queue runs on the transport; running them here:", error2);
+      return false;
+    }
+  }
+  /**
+  * Execute a run announced by another instance, if it is still `pending`: a
+  * run another instance already took is skipped after one read instead of being leased and
+  * replayed here once more. Never rejects.
+  */
+  async runIfPending(runId) {
+    if (this.draining) return;
+    try {
+      const run = await this.store.getRun(runId);
+      if (run?.status !== "pending") return;
+      await this.runOne(runId);
+    } catch (error2) {
+      console.error(`[nestjs-durable] could not run enqueued run ${runId}:`, error2);
+    }
+  }
   /** Fire cooperative-cancellation listeners for `runId` (a worker bridge aborts in-flight work). */
   notifyCancelled(runId) {
     for (const fn of this.cancelListeners) {
@@ -5156,8 +5710,8 @@ var WorkflowEngine = class {
         status: "suspended"
       };
     }
-    await this.runDispatcher.dispatch(runId);
-    if (this.controlPlane) {
+    await this.dispatchRun(runId, run.priority, pendingStateKey(run.updatedAt));
+    if (this.controlPlane && !this.queuesRunsOverTransport) {
       void this.controlPlane.publishControl({
         kind: "enqueued",
         runId,
@@ -5196,7 +5750,43 @@ var WorkflowEngine = class {
   * stale waiter or a late result left behind by a failed run silently re-executes its body.
   */
   resumeImplicit(runId) {
-    return this.resumeRun(runId, false);
+    const turn = this.wakeTurns.get(runId);
+    if (turn) {
+      turn.again ??= deferred();
+      if (currentWorkflowCtx()?.runId === runId) {
+        return Promise.resolve({
+          runId,
+          status: "running"
+        });
+      }
+      return turn.again.promise;
+    }
+    const mine = {};
+    this.wakeTurns.set(runId, mine);
+    const finish = /* @__PURE__ */ __name(() => {
+      if (this.wakeTurns.get(runId) === mine) this.wakeTurns.delete(runId);
+      const again = mine.again;
+      if (!again) return;
+      if (this.draining) {
+        again.resolve({
+          runId,
+          status: "running"
+        });
+        return;
+      }
+      const next = this.resumeImplicit(runId);
+      next.then(again.resolve, again.reject);
+      this.inBackground(next);
+    }, "finish");
+    const result = this.resumeRun(runId, false);
+    void result.then(finish, finish);
+    return result;
+  }
+  /** Keep `work` in {@link background} until it settles; its failure is swallowed. */
+  inBackground(work) {
+    const tracked = work.catch(() => void 0);
+    this.background.add(tracked);
+    void tracked.then(() => this.background.delete(tracked));
   }
   /**
   * One execution of a run at a time in this process. A resume that lands while the run executes
@@ -5483,6 +6073,10 @@ var WorkflowEngine = class {
   */
   beginDrain(spentMs = 0) {
     this.draining = true;
+    if (this.runConsumerStops.length > 0) {
+      this.runBatcher.flush();
+      void this.stopRunConsumers();
+    }
     if (Number.isFinite(spentMs) && spentMs > 0) {
       this.drainSpentMs += spentMs;
       for (const rearm of this.drainRearms) rearm();
@@ -5503,7 +6097,14 @@ var WorkflowEngine = class {
   */
   async drain(timeoutMs = 1e4) {
     this.beginDrain();
-    if (this.inflight.size === 0) return;
+    this.localWork.clear();
+    for (const timer2 of this.leaseRetries.values()) clearTimeout(timer2);
+    this.leaseRetries.clear();
+    const consumers = this.runConsumersStopping;
+    if (this.inflight.size === 0 && this.background.size === 0 && !consumers && this.runBatcher.idle) {
+      return;
+    }
+    const queued = this.runBatcher.settle();
     const start = Date.now();
     let rearm = /* @__PURE__ */ __name(() => {
     }, "rearm");
@@ -5522,7 +6123,10 @@ var WorkflowEngine = class {
     try {
       await Promise.race([
         Promise.allSettled([
-          ...this.inflight
+          ...this.inflight,
+          ...this.background,
+          queued,
+          consumers
         ]).then(() => {
           settled = true;
         }),
@@ -5629,6 +6233,7 @@ var WorkflowEngine = class {
           error: error2
         });
         await this.cancelChildren(run.id).catch(() => void 0);
+        this.notifyParent(run.id, cancelledCompletion(error2));
       }
     }
   }
@@ -5643,7 +6248,9 @@ var WorkflowEngine = class {
       if (this.draining) break;
       const outcome = this.isOwnLiveLease(listed, nowMs) ? await this.reclaimOwnLease(listed, nowMs) : await this.recoverOrphan(listed, nowMs);
       if (!outcome) continue;
-      if (outcome.dispatch) await this.runDispatcher.dispatch(outcome.result.runId);
+      if (outcome.dispatch) {
+        await this.dispatchRun(outcome.result.runId, listed.priority, freshPendingKey());
+      }
       results.push(outcome.result);
     }
     return results;
@@ -5835,6 +6442,18 @@ var WorkflowEngine = class {
     const due = shuffle(await this.store.listDueTimers(nowMs, this.namespace, this.timerBatchSize));
     const blocked = await this.dueBlockedRuns(nowMs);
     if (due.length === 0 && blocked.length === 0) return [];
+    if (this.queuesRunsOverTransport && !this.draining) {
+      const runs = [
+        ...due,
+        ...blocked
+      ];
+      if (await this.handOffDue(runs, nowMs)) {
+        return runs.map((run) => ({
+          runId: run.id,
+          status: run.status
+        }));
+      }
+    }
     const waiterByRun = indexWaitersByRun(await listSignalWaitersOfRuns(this.store, [
       ...due,
       ...blocked
@@ -5868,7 +6487,7 @@ var WorkflowEngine = class {
     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);
+    const settled = await this.deliverSignal(waiter, buffered.payload, true);
     return settled ?? {
       runId: run.id,
       status: run.status
@@ -5894,7 +6513,7 @@ var WorkflowEngine = class {
       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);
+      const settled = await this.deliverSignal(waiter, candidate.payload, true);
       return settled ?? {
         runId: run.id,
         status: run.status
@@ -6014,7 +6633,7 @@ var WorkflowEngine = class {
       } : {},
       updatedAt: /* @__PURE__ */ new Date()
     });
-    await this.runDispatcher.dispatch(runId);
+    await this.dispatchRun(runId, run.priority, freshPendingKey());
     return {
       runId,
       status: "pending"
@@ -6089,7 +6708,16 @@ var WorkflowEngine = class {
   * {@link resumeDueTimers}.
   */
   async runPending(nowMs = this.clock()) {
-    return this.resumeLeased(await this.store.listPendingRuns(100, this.namespace), nowMs);
+    const pending = await this.store.listPendingRuns(100, this.namespace);
+    if (this.queuesRunsOverTransport && !this.draining && pending.length > 0) {
+      if (await this.queueOnTransport(pending)) {
+        return pending.map((run) => ({
+          runId: run.id,
+          status: run.status
+        }));
+      }
+    }
+    return this.resumeLeased(pending, nowMs);
   }
   /**
   * Resolve once `runId` reaches a settled state — terminal (completed/failed/cancelled/dead) or
@@ -6266,7 +6894,7 @@ var WorkflowEngine = class {
   * due-timer reconcile sweep ({@link reconcileSignalWaiter}) — all three resolve a waiter the exact
   * same way.
   */
-  async deliverSignal(waiter, payload) {
+  async deliverSignal(waiter, payload, resumeHere = false) {
     await this.store.saveCheckpoint(instantCheckpoint({
       runId: waiter.runId,
       seq: waiter.seq,
@@ -6285,7 +6913,7 @@ var WorkflowEngine = class {
         status: "suspended"
       };
     }
-    return this.resumeImplicit(waiter.runId).catch((err) => {
+    return (resumeHere ? this.resumeImplicit(waiter.runId) : this.wake(waiter.runId)).catch((err) => {
       if (err instanceof NamespaceMismatch) return null;
       throw err;
     });
@@ -6372,6 +7000,101 @@ var WorkflowEngine = class {
       return;
     }
   }
+  /**
+  * Deliver the outcome of every awaited child that already finished but whose completion never
+  * reached this run, into `checkpoints` (this turn's snapshot) and the store.
+  *
+  * A child persists its terminal status first and tells its parent after ({@link notifyParent}). A
+  * crash, a scale-down or a store error between the two leaves the parent's `running` placeholder
+  * and `child:<id>` waiter behind for a child that is done, and nothing else would ever settle
+  * them: the parent's reconcile wake replays straight back to the same wait. So each turn looks up
+  * the children of its `running` placeholders (one batched read per 500) and settles the finished
+  * ones exactly as the child's own notification would have: the `signal:child:<id>` checkpoint
+  * with the child's completion, then the waiter removed. A notification arriving late writes the
+  * same checkpoint and finds no waiter. Best effort: a store error leaves the rest to the next turn.
+  */
+  async deliverFinishedChildren(runId, checkpoints) {
+    const awaited = [];
+    for (const cp of checkpoints) {
+      if (cp.kind !== "signal" || cp.status !== "running") continue;
+      if (!cp.name.startsWith(CHILD_SIGNAL_PREFIX)) continue;
+      awaited.push({
+        childId: cp.name.slice(CHILD_SIGNAL_PREFIX.length),
+        seq: cp.seq,
+        parallelGroup: cp.parallelGroup
+      });
+    }
+    await this.settleFinishedChildren(runId, awaited, checkpoints);
+  }
+  /**
+  * {@link deliverFinishedChildren} for a remote workflow, whose awaited children (`startChild`
+  * commands) leave a `child:<id>` waiter but no placeholder checkpoint: the run's own waiters say
+  * which children it is waiting on. One indexed read per turn of a remote run.
+  */
+  async deliverFinishedChildWaiters(runId, checkpoints) {
+    let waiters;
+    try {
+      waiters = await listSignalWaitersOfRuns(this.store, [
+        runId
+      ]);
+    } catch {
+      return;
+    }
+    const settled = new Set(checkpoints.filter((cp) => cp.status === "completed").map((cp) => cp.seq));
+    const awaited = waiters.filter((w) => w.token.startsWith("child:") && !settled.has(w.seq)).map((w) => ({
+      childId: w.token.slice("child:".length),
+      seq: w.seq,
+      parallelGroup: w.parallelGroup
+    }));
+    await this.settleFinishedChildren(runId, awaited, checkpoints);
+  }
+  /**
+  * Settle every child in `awaited` that has finished: its `signal:child:<id>` checkpoint with the
+  * child's completion, then its waiter removed, exactly as the child's own notification does, and
+  * the checkpoint put into `checkpoints`. Children are read in batches of 500.
+  */
+  async settleFinishedChildren(runId, awaited, checkpoints) {
+    if (awaited.length === 0) return;
+    try {
+      const { runs: children } = await readRunsByIds(this.store, awaited.map((a) => a.childId));
+      const finished = awaited.flatMap((a) => {
+        const child = children.get(a.childId);
+        const completion = child ? childCompletion(child) : void 0;
+        return completion ? [
+          {
+            ...a,
+            completion
+          }
+        ] : [];
+      });
+      for (let at = 0; at < finished.length; at += DELIVER_CHUNK) {
+        await Promise.all(finished.slice(at, at + DELIVER_CHUNK).map(async (a) => {
+          const settled = instantCheckpoint({
+            runId,
+            seq: a.seq,
+            name: `${CHILD_SIGNAL_PREFIX}${a.childId}`,
+            kind: "signal",
+            output: a.completion,
+            parallelGroup: a.parallelGroup
+          });
+          await this.store.saveCheckpoint(settled);
+          await this.store.removeSignalWaiter({
+            token: `child:${a.childId}`,
+            runId,
+            seq: a.seq,
+            ...a.parallelGroup !== void 0 ? {
+              parallelGroup: a.parallelGroup
+            } : {}
+          });
+          const index = checkpoints.findIndex((cp) => cp.seq === a.seq);
+          if (index === -1) checkpoints.push(settled);
+          else checkpoints[index] = settled;
+        }));
+      }
+      checkpoints.sort((a, b) => a.seq - b.seq);
+    } catch {
+    }
+  }
   async redriveSettledChildren(runId, fan) {
     if (!this.store.hasSignalWaiter) return;
     for (const wait of fan.waits) {
@@ -6470,13 +7193,63 @@ var WorkflowEngine = class {
   * knowing about the child feature.
   */
   notifyParent(runId, completion) {
-    void this.signal(`child:${runId}`, completion).catch(() => void 0);
+    this.inBackground(this.deliverToParent(`child:${runId}`, completion));
     const at = runId.lastIndexOf("~retry~");
     if (at !== -1 && completion.ok) {
-      void this.signal(`child:${runId.slice(0, at)}`, completion).catch(() => void 0);
+      this.inBackground(this.deliverToParent(`child:${runId.slice(0, at)}`, completion));
     }
   }
   /**
+  * {@link signal} a child's completion to its parent, retrying a store error a few times. The child
+  * is already persisted terminal, so a failure here would leave the parent waiting on a child that
+  * finished; the parent's own turns reconcile that ({@link deliverFinishedChildren}), but only on
+  * its next wake. A waiter already taken is delivered to directly on a retry, so the completion is
+  * not buffered for a waiter that no longer exists.
+  */
+  async deliverToParent(token, completion) {
+    let waiter;
+    const cancelled = !completion.ok && completion.code === CHILD_CANCELLED;
+    for (let attempt = 1; ; attempt += 1) {
+      try {
+        if (waiter === void 0) waiter = await this.store.takeSignalWaiter(token);
+        if (waiter) {
+          const parent = cancelled ? await this.store.getRun(waiter.runId) : void 0;
+          if (parent && TERMINAL_RUN_STATUSES.includes(parent.status)) return;
+          await this.deliverSignal(waiter, completion);
+          return;
+        }
+        if (cancelled || await this.parentHoldsCompletion(token, completion)) return;
+        await this.signal(token, completion);
+        return;
+      } catch (err) {
+        if (err instanceof NamespaceMismatch) return;
+        if (attempt >= PARENT_NOTIFY_ATTEMPTS || this.draining) return;
+        await new Promise((resolve) => {
+          const timer = setTimeout(resolve, PARENT_NOTIFY_BACKOFF_MS * 4 ** (attempt - 1));
+          timer.unref?.();
+        });
+      }
+    }
+  }
+  /**
+  * Whether the parent of the child behind `token` (`child:<id>`) already holds `completion` as that
+  * child's settled `signal:child:<id>` checkpoint: its own turn settled the child from the child's
+  * row, so this notification is a duplicate. A different completion (a fix-and-replay run's success
+  * for a child the parent saw fail) is not, and is buffered for the parent's retry. Only for a child
+  * whose id the engine minted (its parent is derivable from it).
+  */
+  async parentHoldsCompletion(token, completion) {
+    const childId = token.slice("child:".length);
+    const parentId = parentRunIdOf(childId);
+    if (!parentId) return false;
+    const name = `${CHILD_SIGNAL_PREFIX}${childId}`;
+    const checkpoints = this.store.listCheckpointsByNamePrefix ? await this.store.listCheckpointsByNamePrefix(parentId, [
+      name
+    ]) : await this.store.listCheckpoints(parentId);
+    const expected = JSON.stringify(completion);
+    return checkpoints.some((cp) => cp.name === name && cp.status === "completed" && JSON.stringify(cp.output) === expected);
+  }
+  /**
   * Deferred child start shared by the in-process ctx host and the remote `startChild` command.
   * Deferred (microtask) so a fast child can't reentrantly resume a still-suspending parent. A start
   * that THROWS (unregistered/unroutable workflow, input validation, singleton back-pressure, store
@@ -6489,13 +7262,16 @@ var WorkflowEngine = class {
   * correctly observes the failed start.
   */
   startChildDeferred(workflow, input, childId, opts) {
-    queueMicrotask(() => void this.start(workflow, input, childId, opts).catch((err) => {
-      const message = err instanceof Error ? err.message : String(err);
-      this.notifyParent(childId, {
-        ok: false,
-        error: `child workflow "${workflow}" failed to start: ${message}`
+    this.localWork.submit(`start:${childId}`, async () => {
+      if (this.draining) return;
+      await this.start(workflow, input, childId, opts).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        this.notifyParent(childId, {
+          ok: false,
+          error: `child workflow "${workflow}" failed to start: ${message}`
+        });
       });
-    }));
+    });
   }
   /**
   * Cancel a run (e.g. from the dashboard). Returns null if the run does not exist. Pass
@@ -6559,6 +7335,7 @@ var WorkflowEngine = class {
       error: error2
     });
     await this.cancelChildren(runId, opts);
+    this.notifyParent(runId, cancelledCompletion(error2));
     this.notifyCancelled(runId);
     if (this.controlPlane) {
       void this.controlPlane.publishControl({
@@ -7073,6 +7850,7 @@ var WorkflowEngine = class {
     const lockNow = this.clock();
     if (run.lockedBy !== this.instanceId || (run.lockedUntil ?? 0) <= lockNow) {
       if (!await this.store.tryLockRun(run.id, this.instanceId, lockNow + this.leaseMs, lockNow)) {
+        this.recheckAfterLease(run.id, run.lockedUntil);
         return {
           runId: run.id,
           status: run.status
@@ -7091,6 +7869,51 @@ var WorkflowEngine = class {
     }
   }
   /**
+  * A wake that found the run leased by another instance is dropped, and normally that is fine: the
+  * holder's turn either sees what the wake wrote, or re-checks once it releases the lease
+  * ({@link redriveSettledSteps}, {@link redriveSettledChildren}). Not if the holder goes down first
+  * (a scale-down mid-turn, an OOM): its lease lapses with the run `suspended` on a step that has
+  * finished, and nothing wakes it before its timer.
+  *
+  * So the dropped wake is kept here: once the lease is free (looked at every
+  * {@link LEASE_RECHECK_MAX_MS} at most, for a bounded number of times), a run still `suspended` is
+  * leased and resumed. A holder that already moved the run on makes this one spare replay that
+  * re-parks. Best effort; the run's timer remains the fallback if this instance goes down too.
+  */
+  recheckAfterLease(runId, lockedUntil, attempt = 1) {
+    if (this.draining || this.leaseRetries.has(runId)) return;
+    const remaining = Math.max(0, (lockedUntil ?? this.clock()) - this.clock());
+    const timer = setTimeout(() => {
+      this.leaseRetries.delete(runId);
+      this.inBackground(this.retryDroppedWake(runId, attempt));
+    }, Math.min(remaining, LEASE_RECHECK_MAX_MS) + LEASE_RECHECK_SLACK_MS);
+    timer.unref?.();
+    this.leaseRetries.set(runId, timer);
+  }
+  async retryDroppedWake(runId, attempt) {
+    if (this.draining) return;
+    const run = await this.store.getRun(runId);
+    if (run?.status !== "suspended") return;
+    const nowMs = this.clock();
+    if (run.lockedUntil !== void 0 && run.lockedUntil > nowMs) {
+      if (attempt < LEASE_RECHECK_ATTEMPTS) this.recheckAfterLease(runId, run.lockedUntil, attempt + 1);
+      return;
+    }
+    if (this.queuesRunsOverTransport) {
+      await this.wake(runId);
+      return;
+    }
+    if (!await this.store.tryLockRun(runId, this.instanceId, nowMs + this.leaseMs, nowMs)) return;
+    const fresh = await this.store.getRun(runId);
+    if (fresh?.status !== "suspended") {
+      await this.store.releaseRunLock(runId);
+      return;
+    }
+    await this.resumeImplicit(runId).catch((err) => {
+      if (!(err instanceof NamespaceMismatch)) throw err;
+    });
+  }
+  /**
   * Renew `runId`'s lease for as long as this execution holds it, and register it in
   * {@link executionLeases} so settles can check the zombie fence and `drain()` can release it.
   *
@@ -7454,6 +8277,7 @@ ${run.workflowVersion}`;
         namespace: run.namespace,
         error: error2
       });
+      this.notifyParent(run.id, cancelledCompletion(error2));
       this.notifyCancelled(run.id);
       if (this.controlPlane) {
         void this.controlPlane.publishControl({
@@ -7485,6 +8309,8 @@ ${run.workflowVersion}`;
     const wfPlan = await this.planRoute(tenantGroup(sanitizeQueueToken(remote.group), void 0), registered.requires);
     if (wfPlan?.status === "blocked") return this.parkBlocked(run, wfPlan);
     const checkpoints = await this.store.listCheckpoints(run.id);
+    await this.deliverFinishedChildren(run.id, checkpoints);
+    await this.deliverFinishedChildWaiters(run.id, checkpoints);
     const handoff = liveHandoff(run.id, checkpoints);
     if (handoff) {
       const result = await this.settleRun(run, await this.followHandoff(run, handoff));
@@ -8059,6 +8885,7 @@ ${run.workflowVersion}`;
       namespace: run.namespace,
       error: error2
     });
+    this.notifyParent(run.id, cancelledCompletion(error2));
     return {
       runId: run.id,
       status: "cancelled",
@@ -8105,6 +8932,7 @@ ${run.workflowVersion}`;
     }
     const compensations = [];
     const snapshot = await this.store.listCheckpoints(run.id);
+    await this.deliverFinishedChildren(run.id, snapshot);
     const replay = /* @__PURE__ */ new Map();
     for (const cp of snapshot) replay.set(cp.seq, cp);
     let suspendedOnFan;
@@ -8201,13 +9029,13 @@ ${run.workflowVersion}`;
       if (this.awaitedStepFans.get(run.id) === awaitedFans) this.awaitedStepFans.delete(run.id);
       await this.releaseLeaseBestEffort(run.id);
       if (suspendedOnFan) {
-        void this.redriveSettledChildren(run.id, suspendedOnFan).catch(() => void 0);
+        this.inBackground(this.redriveSettledChildren(run.id, suspendedOnFan));
       }
       if (suspendedOnSteps && awaitedSteps.size > 0) {
-        void this.redriveSettledSteps(run.id, awaitedSteps).catch(() => void 0);
+        this.inBackground(this.redriveSettledSteps(run.id, awaitedSteps));
       }
       if (suspendedOnSteps && awaitedFans.length > 0) {
-        void this.redriveSettledStepFans(run.id, awaitedFans).catch(() => void 0);
+        this.inBackground(this.redriveSettledStepFans(run.id, awaitedFans));
       }
     }
   }
@@ -8647,9 +9475,11 @@ ${run.workflowVersion}`;
         })) {
           return this.callRemote(runId, seq, step, input, queue, transport, void 0, admission, routing);
         }
-        throw new WorkflowSuspended(wakeAt);
+        throw new WorkflowSuspended(this.stepLeaseWakeAt(wakeAt));
+      }
+      if (this.clock() < existing.wakeAt) {
+        throw new WorkflowSuspended(this.stepLeaseWakeAt(existing.wakeAt));
       }
-      if (this.clock() < existing.wakeAt) throw new WorkflowSuspended(existing.wakeAt);
       if (existing.attempts >= this.remoteRedispatchMax) {
         throw new RemoteStepError({
           message: `remote step "${step.name}" lost \u2014 no result after ${existing.attempts} re-dispatch(es)`,
@@ -8695,7 +9525,7 @@ ${run.workflowVersion}`;
         kind: "remote",
         redispatched: true
       });
-      throw new WorkflowSuspended(nextDeadline);
+      throw new WorkflowSuspended(this.stepLeaseWakeAt(nextDeadline));
     }
     let attempt = 1;
     if (existing?.status === "failed") {
@@ -9058,6 +9888,7 @@ ${run.workflowVersion}`;
     });
     const reads = await Promise.allSettled(live.map((i) => this.store.getCheckpoint(runId, results[i].seq)));
     const pending = [];
+    const resettled = [];
     reads.forEach((read, k) => {
       const index = live[k];
       if (read.status === "rejected") outcomes[index] = {
@@ -9067,8 +9898,17 @@ ${run.workflowVersion}`;
         index,
         cp: read.value
       });
+      else if (read.value?.status === "completed" || read.value?.status === "failed") {
+        resettled.push({
+          index,
+          cp: read.value
+        });
+      }
     });
-    if (pending.length === 0) return outcomes;
+    if (pending.length === 0) {
+      if (resettled.length === 0) return outcomes;
+      return this.resumeForRedelivered(runId, resettled, outcomes);
+    }
     for (const { cp } of pending) void this.releaseQueueSlot(cp.stepId).catch(() => void 0);
     const run = await this.store.getRun(runId);
     if (run && (run.status === "cancelled" || run.status === "completed")) return outcomes;
@@ -9120,6 +9960,29 @@ ${run.workflowVersion}`;
     return outcomes;
   }
   /**
+  * The outcomes for a batch of redelivered results (their steps already settled): one of them
+  * resumes the run if it is `suspended` and, for a step of a fan, the fan's barrier is open. A
+  * resume of a run that had in fact moved on replays to its current wait and re-parks.
+  */
+  async resumeForRedelivered(runId, resettled, outcomes) {
+    const run = await this.store.getRun(runId);
+    if (run?.status !== "suspended") return outcomes;
+    const barriers = /* @__PURE__ */ new Map();
+    for (const { index, cp } of resettled) {
+      const asResult = {
+        runId,
+        seq: cp.seq,
+        stepId: cp.stepId ?? stepId(runId, cp.seq),
+        status: cp.status === "failed" ? "failed" : "completed"
+      };
+      if (!await this.stepFanStillRunning(cp, asResult, barriers)) {
+        outcomes[index] = true;
+        break;
+      }
+    }
+    return outcomes;
+  }
+  /**
   * The join barrier of a step fan: a result for one of its steps resumes the parent only once no
   * step of the fan is still `pending` (a settled wave), or on a failure (failFast surfaces it, and a
   * retry needs the parent to schedule it). Without it every result would replay the whole parent,
@@ -9243,7 +10106,7 @@ ${run.workflowVersion}`;
       ...waiters
     ];
     waiters.clear();
-    for (const runId of runIds) void this.resumeImplicit(runId).catch(() => void 0);
+    for (const runId of runIds) void this.wake(runId).catch(() => void 0);
   }
   /** Release the flow-control slot a dispatched step held (if any), by its stepId. */
   async releaseQueueSlot(id) {
@@ -9985,6 +10848,8 @@ var CodecStateStore = class {
   registerChildWaits;
   /** The folded checkpoint carries the children's outputs, so it is encoded. */
   compactCheckpoints;
+  /** Decodes each run like {@link getRun}. Bound only when the inner store has it. */
+  getRuns;
   /** Forwarded verbatim — a waiter carries no payload. */
   listSignalWaitersByRun;
   /** Forwarded verbatim — a waiter carries no payload. */
@@ -10028,6 +10893,8 @@ var CodecStateStore = class {
     })));
     const compact = inner.compactCheckpoints;
     if (compact) this.compactCheckpoints = (runId, fromSeq, toSeq, into) => compact.call(inner, runId, fromSeq, toSeq, this.encCp(into));
+    const getRuns = inner.getRuns;
+    if (getRuns) this.getRuns = async (runIds) => (await getRuns.call(inner, runIds)).map((r) => this.decRun(r));
     const byRun = inner.listSignalWaitersByRun;
     if (byRun) this.listSignalWaitersByRun = (runIds) => byRun.call(inner, runIds);
     const hasWaiter = inner.hasSignalWaiter;
@@ -10580,6 +11447,16 @@ var InMemoryStateStore = class {
       ...run
     } : null;
   }
+  async getRuns(runIds) {
+    const out = [];
+    for (const id of new Set(runIds)) {
+      const run = this.runs.get(id);
+      if (run) out.push({
+        ...run
+      });
+    }
+    return out;
+  }
   async deleteRun(runId) {
     this.runs.delete(runId);
     for (const [key, cp] of this.checkpoints) {
@@ -11031,6 +11908,99 @@ var InMemoryTransport = class {
     this.controlHandlers.add(handler);
   }
 };
+
+// src/testing/in-memory-run-queue.ts
+var InMemoryRunQueue = class {
+  static {
+    __name(this, "InMemoryRunQueue");
+  }
+  lanes = /* @__PURE__ */ new Map();
+  /** A transport on this queue. */
+  transport() {
+    return {
+      dispatch: /* @__PURE__ */ __name(async (_task) => {
+        throw new Error("InMemoryRunQueue carries no remote steps");
+      }, "dispatch"),
+      onResult: /* @__PURE__ */ __name((_handler) => {
+      }, "onResult"),
+      onHeartbeat: /* @__PURE__ */ __name((_handler) => {
+      }, "onHeartbeat"),
+      dispatchRuns: /* @__PURE__ */ __name(async (runs, opts) => this.add(runs, opts), "dispatchRuns"),
+      onDispatchedRun: /* @__PURE__ */ __name((handler, opts) => this.consume(handler, opts), "onDispatchedRun")
+    };
+  }
+  /** Runs waiting in the queue of `namespace`. */
+  waiting(namespace) {
+    return (this.lanes.get(namespace ?? "")?.waiting ?? []).map((r) => r.runId);
+  }
+  lane(namespace) {
+    const key = namespace ?? "";
+    let lane = this.lanes.get(key);
+    if (!lane) {
+      lane = {
+        waiting: [],
+        queued: /* @__PURE__ */ new Map(),
+        consumers: [],
+        next: 0
+      };
+      this.lanes.set(key, lane);
+    }
+    return lane;
+  }
+  add(runs, opts) {
+    const lane = this.lane(opts?.namespace);
+    for (const run of runs) {
+      const waiting = lane.queued.get(run.runId);
+      if (waiting) {
+        if (run.reason === "wake") waiting.reason = "wake";
+        continue;
+      }
+      const entry = {
+        ...run
+      };
+      lane.queued.set(run.runId, entry);
+      lane.waiting.push(entry);
+    }
+    lane.waiting.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    setImmediate(() => this.pump(lane));
+  }
+  consume(handler, opts) {
+    const lane = this.lane(opts.namespace);
+    const consumer = {
+      handler,
+      concurrency: Math.max(1, opts.concurrency),
+      active: 0,
+      stopped: false,
+      idle: []
+    };
+    lane.consumers.push(consumer);
+    setImmediate(() => this.pump(lane));
+    return () => {
+      consumer.stopped = true;
+      lane.consumers = lane.consumers.filter((c) => c !== consumer);
+      if (consumer.active === 0) return Promise.resolve();
+      return new Promise((resolve) => consumer.idle.push(resolve));
+    };
+  }
+  pump(lane) {
+    while (lane.waiting.length > 0) {
+      const free = lane.consumers.filter((c) => !c.stopped && c.active < c.concurrency);
+      if (free.length === 0) return;
+      const consumer = free[lane.next % free.length];
+      lane.next += 1;
+      const run = lane.waiting.shift();
+      lane.queued.delete(run.runId);
+      consumer.active += 1;
+      void consumer.handler(run).catch(() => void 0).then(() => {
+        consumer.active -= 1;
+        if (consumer.active === 0 && consumer.stopped) {
+          for (const resolve of consumer.idle.splice(0)) resolve();
+        }
+        this.pump(lane);
+      });
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CHILD_EDGE_PREFIXES,
@@ -11058,6 +12028,7 @@ var InMemoryTransport = class {
   GatherError,
   HANDOFF_SEQ_BASE,
   InMemoryAdmissionBackend,
+  InMemoryRunQueue,
   InMemoryStateStore,
   InMemoryTransport,
   LEGACY_V1_CAPABILITIES,
@@ -11142,6 +12113,7 @@ var InMemoryTransport = class {
   fanPageEtag,
   findStalledRuns,
   foldedCount,
+  getRunsByIds,
   handoffHandlerId,
   handoffName,
   hasDurableExecutionWrappers,
@@ -11179,6 +12151,7 @@ var InMemoryTransport = class {
   poolNamespace,
   prevCronFireMs,
   queryCheckpointsOf,
+  readRunsByIds,
   readSearchAttributes,
   requiredCapabilities,
   resolveConcurrency,