@dudousxd/nestjs-durable-core 0.73.0 → 0.75.0

package/dist/index.cjs

@@ -117,6 +117,7 @@ __export(index_exports, {
   isLegacyDescriptor: () => isLegacyDescriptor,
   isNonEmptyRunScope: () => isNonEmptyRunScope,
   isWorkflowControlFlowSignal: () => isWorkflowControlFlowSignal,
+  listSignalWaitersOfRuns: () => listSignalWaitersOfRuns,
   log: () => log,
   matchesAttributes: () => matchesAttributes,
   mergeRunFacetRows: () => mergeRunFacetRows,
@@ -127,6 +128,7 @@ __export(index_exports, {
   normalizeAttributeRows: () => normalizeAttributeRows,
   normalizeDescriptor: () => normalizeDescriptor,
   observedAnnouncements: () => observedAnnouncements,
+  parentRunIdOf: () => parentRunIdOf,
   parseDuration: () => parseDuration,
   partitionOfToken: () => partitionOfToken,
   planDispatch: () => planDispatch,
@@ -550,12 +552,15 @@ var WorkflowSuspended = class extends Error {
   }
   /** Epoch ms to auto-resume (durable sleep), or undefined when waiting on an external signal. */
   wakeAt;
+  /** Set when awaited children are what the run is waiting on — see {@link FanJoin}. */
+  fan;
   /** Marks this as a control-flow signal — see {@link isWorkflowControlFlowSignal}. */
   [CONTROL_FLOW_SIGNAL] = true;
-  constructor(wakeAt) {
+  constructor(wakeAt, fan) {
     super("workflow suspended");
     this.name = "WorkflowSuspended";
     this.wakeAt = wakeAt;
+    this.fan = fan;
   }
 };
 var ContinueAsNew = class extends Error {
@@ -982,6 +987,21 @@ function instantCheckpoint(p) {
 }
 __name(instantCheckpoint, "instantCheckpoint");
 
+// src/completion.ts
+function isFailedCompletion(payload) {
+  const c = payload;
+  return !!c && typeof c === "object" && "ok" in c && c.ok === false;
+}
+__name(isFailedCompletion, "isFailedCompletion");
+function unwrapCompletion(payload, label) {
+  const c = payload;
+  if (c && typeof c === "object" && "ok" in c && c.ok === false) {
+    throw new FatalError(`${label} failed: ${c.error}`);
+  }
+  return c?.value;
+}
+__name(unwrapCompletion, "unwrapCompletion");
+
 // src/concurrency.ts
 var DEFAULT_CONCURRENCY_STATUSES = [
   "pending",
@@ -1221,6 +1241,81 @@ function eventMatches(payload, match) {
 }
 __name(eventMatches, "eventMatches");
 
+// src/fan-join.ts
+function allChildId(runId, firstSeq, index, wave) {
+  return `${allBase(runId, firstSeq, wave)}${index}`;
+}
+__name(allChildId, "allChildId");
+function allGroup(firstSeq, mode) {
+  return mode === "failFast" ? `all:${firstSeq}:failFast` : `all:${firstSeq}`;
+}
+__name(allGroup, "allGroup");
+function allWait(runId, firstSeq, wave) {
+  const base = allBase(runId, firstSeq, wave);
+  return {
+    waiterPrefix: `child:${base}`,
+    checkpointPrefix: `signal:child:${base}`
+  };
+}
+__name(allWait, "allWait");
+function fanJoin(waits) {
+  return {
+    waits
+  };
+}
+__name(fanJoin, "fanJoin");
+var FOLDED_PREFIX = "fan:";
+function allFoldedName(runId, firstSeq, wave) {
+  return `${FOLDED_PREFIX}${allBase(runId, firstSeq, wave)}`;
+}
+__name(allFoldedName, "allFoldedName");
+function foldedChildIds(checkpoint) {
+  const base = checkpoint.name.slice(FOLDED_PREFIX.length);
+  const { from, values } = checkpoint.output;
+  return values.map((_, j) => `${base}${from + j}`);
+}
+__name(foldedChildIds, "foldedChildIds");
+function allBase(runId, firstSeq, wave) {
+  return wave === void 0 ? `${runId}.all.${firstSeq}.` : `${runId}.all.${firstSeq}.w${wave}.`;
+}
+__name(allBase, "allBase");
+function allWaves(size, concurrency) {
+  if (concurrency === void 0 || concurrency >= size) return void 0;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new Error(`ctx.all: concurrency must be a positive integer, got ${concurrency}`);
+  }
+  if (concurrency === 1) return {
+    waveSize: 1,
+    maxWaves: 1
+  };
+  return {
+    waveSize: Math.floor(concurrency / 2),
+    maxWaves: 2
+  };
+}
+__name(allWaves, "allWaves");
+var ENGINE_CHILD_ID = /^(.+)\.(?:all\.\d+\.(?:w\d+\.)?\d+|child\.\d+)$/;
+function parentRunIdOf(runId) {
+  return ENGINE_CHILD_ID.exec(runId)?.[1];
+}
+__name(parentRunIdOf, "parentRunIdOf");
+var GROUP = /^all:(\d+)(:failFast)?$/;
+var REST = /^(?:w(\d+)\.)?\d+$/;
+function fanOfWaiter(waiter) {
+  const group = waiter.parallelGroup ? GROUP.exec(waiter.parallelGroup) : null;
+  if (!group) return void 0;
+  const base = `child:${waiter.runId}.all.${group[1]}.`;
+  if (!waiter.token.startsWith(base)) return void 0;
+  const rest = REST.exec(waiter.token.slice(base.length));
+  if (!rest) return void 0;
+  const waiterPrefix = rest[1] === void 0 ? base : `${base}w${rest[1]}.`;
+  return {
+    waiterPrefix,
+    failFast: group[2] !== void 0
+  };
+}
+__name(fanOfWaiter, "fanOfWaiter");
+
 // src/handshake/descriptor.ts
 var CURRENT_PROTOCOL_VERSION = 1;
 var LEGACY_V1_PROTOCOL = {
@@ -1962,6 +2057,23 @@ function resolveRunWaiting(run, waiterByRun) {
   return waiter ? classifyWaiterToken(waiter.token) : void 0;
 }
 __name(resolveRunWaiting, "resolveRunWaiting");
+var RUN_ID_BATCH = 500;
+async function listSignalWaitersOfRuns(store, runIds) {
+  const unique = [
+    ...new Set(runIds)
+  ];
+  if (unique.length === 0) return [];
+  if (!store.listSignalWaitersByRun) {
+    const ids = new Set(unique);
+    return (await store.listSignalWaiters("")).filter((w) => ids.has(w.runId));
+  }
+  const out = [];
+  for (let at = 0; at < unique.length; at += RUN_ID_BATCH) {
+    out.push(...await store.listSignalWaitersByRun(unique.slice(at, at + RUN_ID_BATCH)));
+  }
+  return out;
+}
+__name(listSignalWaitersOfRuns, "listSignalWaitersOfRuns");
 function indexWaitersByRun(waiters) {
   const byRun = /* @__PURE__ */ new Map();
   for (const w of waiters) if (!byRun.has(w.runId)) byRun.set(w.runId, w);
@@ -2238,12 +2350,14 @@ var ScheduleClient = class {
     const store = this.requireStore();
     const started = [];
     for (let round = 0; round < 50; round++) {
+      if (this.host.isDraining?.()) break;
       const due = await store.listSchedules({
         dueBy: nowMs,
         namespace: this.options.namespace,
         limit: TICK_BATCH
       });
       for (const record of due) {
+        if (this.host.isDraining?.()) return started;
         const runId = await this.fire(record, nowMs);
         if (runId) started.push(runId);
       }
@@ -2772,16 +2886,6 @@ var TransportPool = class {
   }
 };
 
-// src/completion.ts
-function unwrapCompletion(payload, label) {
-  const c = payload;
-  if (c && typeof c === "object" && "ok" in c && c.ok === false) {
-    throw new FatalError(`${label} failed: ${c.error}`);
-  }
-  return c?.value;
-}
-__name(unwrapCompletion, "unwrapCompletion");
-
 // src/step-name-symbol.ts
 var DURABLE_STEP_NAME = Symbol.for("durable.step.name");
 var DURABLE_STEP_CONFIG = Symbol.for("durable.step.config");
@@ -2803,6 +2907,8 @@ function stepConfigOf(ref) {
 __name(stepConfigOf, "stepConfigOf");
 
 // src/workflow-ctx.ts
+var FAN_CHUNK = 500;
+var FOLD_MIN_FAN = 100;
 function normalizeChildOptions(options) {
   return typeof options === "string" ? {
     childId: options
@@ -3145,7 +3251,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
     if (existing && existing.status === "completed") {
       return unwrapCompletion(existing.output, `child "${id}"`);
     }
-    await store.putSignalWaiter({
+    if (!existing) await store.putSignalWaiter({
       token: `child:${id}`,
       runId,
       seq: current
@@ -3176,16 +3282,33 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         status: "running"
       }));
     }
-    throw new WorkflowSuspended();
+    throw new WorkflowSuspended(void 0, fanJoin([
+      {
+        waiterPrefix: `child:${id}`,
+        checkpointPrefix: `signal:child:${id}`
+      }
+    ]));
   }, "child");
   const all = /* @__PURE__ */ __name(async (workflow2, inputs, opts) => {
     if (inputs.length === 0) return [];
     const mode = opts?.mode ?? "waitAll";
     const name = workflowName(workflow2);
+    const waves = allWaves(inputs.length, opts?.concurrency);
     const positions = inputs.map(() => pos.next());
-    const group = `all:${positions[0]}`;
-    const id = /* @__PURE__ */ __name((i) => `${runId}.all.${positions[0]}.${i}`, "id");
-    const existing = await Promise.all(positions.map((seq) => readCheckpoint(seq)));
+    const firstSeq = positions[0];
+    const group = allGroup(firstSeq, mode);
+    const waveOf = /* @__PURE__ */ __name((i) => waves ? Math.floor(i / waves.waveSize) : void 0, "waveOf");
+    const id = /* @__PURE__ */ __name((i) => allChildId(runId, firstSeq, i, waveOf(i)), "id");
+    const { checkpoints: existing, folded } = await readFan(positions, [
+      allWait(runId, firstSeq).checkpointPrefix,
+      allFoldedName(runId, firstSeq)
+    ]);
+    const waveCount = waves ? Math.ceil(inputs.length / waves.waveSize) : 1;
+    const waveItems = /* @__PURE__ */ __name((k) => {
+      if (!waves) return inputs.map((_, i) => i);
+      const from = k * waves.waveSize;
+      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];
@@ -3204,32 +3327,91 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         }
       }
     }
-    let pending = false;
-    for (let i = 0; i < inputs.length; i += 1) {
-      const cp = existing[i];
-      if (cp?.status === "completed") continue;
-      pending = true;
-      const seq = positions[i];
-      const childId = id(i);
-      await store.putSignalWaiter({
-        token: `child:${childId}`,
-        runId,
-        seq,
-        parallelGroup: group
-      });
-      if (!await store.getRun(childId)) host.startChild(name, inputs[i], childId);
-      if (!cp) {
-        await writeCheckpoint(instantCheckpoint({
+    if (store.compactCheckpoints && inputs.length >= FOLD_MIN_FAN) {
+      for (let k = 0; k < waveCount; k += 1) {
+        const items = waveItems(k);
+        const first = items[0];
+        const last = items[items.length - 1];
+        if (folded[first]) continue;
+        const values = [];
+        for (const i of items) {
+          const c = existing[i]?.status === "completed" ? existing[i]?.output : void 0;
+          if (!c || typeof c !== "object" || c.ok !== true) break;
+          values.push(c.value);
+        }
+        if (values.length < items.length) continue;
+        const into = instantCheckpoint({
           runId,
-          seq,
-          name: `signal:child:${childId}`,
+          seq: positions[first],
+          name: allFoldedName(runId, firstSeq, waves ? k : void 0),
           kind: "signal",
-          status: "running",
+          output: {
+            from: first,
+            values
+          },
           parallelGroup: group
+        });
+        await store.compactCheckpoints(runId, positions[first], positions[last], into);
+        for (const i of items) replay?.delete(positions[i]);
+        replay?.set(into.seq, into);
+      }
+    }
+    const sent = /* @__PURE__ */ __name((k) => waveItems(k).some((i) => existing[i]), "sent");
+    const settled = /* @__PURE__ */ __name((k) => waveItems(k).every((i) => existing[i]?.status === "completed"), "settled");
+    const active = [];
+    let unsettled = 0;
+    for (let k = 0; k < waveCount; k += 1) {
+      if (settled(k)) continue;
+      if (sent(k) || unsettled < (waves?.maxWaves ?? 1)) {
+        active.push(k);
+        unsettled += 1;
+      }
+    }
+    if (active.length > 0) {
+      const toRegister = [];
+      const toEnsure = [];
+      for (const k of active) {
+        for (const i of waveItems(k)) {
+          const cp = existing[i];
+          if (cp?.status === "completed") continue;
+          (cp ? toEnsure : toRegister).push(i);
+        }
+      }
+      for (let at = 0; at < toRegister.length; at += FAN_CHUNK) {
+        const chunk = toRegister.slice(at, at + FAN_CHUNK);
+        const entries = chunk.map((i) => ({
+          // Carry the fan `group` onto the waiter too: the child's terminal `signal:child:`
+          // checkpoint is (re)written by engine.signal when the child notifies the parent,
+          // OVERWRITING the running placeholder at the same seq — so without this the resolved
+          // checkpoint would lose the group and the dashboard would render the resolved fan as a
+          // sequential chain.
+          waiter: {
+            token: `child:${id(i)}`,
+            runId,
+            seq: positions[i],
+            parallelGroup: group
+          },
+          checkpoint: instantCheckpoint({
+            runId,
+            seq: positions[i],
+            name: `signal:child:${id(i)}`,
+            kind: "signal",
+            status: "running",
+            parallelGroup: group
+          })
+        }));
+        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 (pending) throw new WorkflowSuspended();
+    if (active.length > 0) {
+      throw new WorkflowSuspended(void 0, fanJoin(active.map((k) => allWait(runId, firstSeq, waves ? k : void 0))));
+    }
     const outputs = [];
     const failures = [];
     for (let i = 0; i < inputs.length; i += 1) {
@@ -3248,6 +3430,67 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
     if (failures.length > 0) throw new GatherError(failures, inputs.length);
     return outputs;
   }, "all");
+  const readFan = /* @__PURE__ */ __name(async (positions, prefixes) => {
+    const checkpoints = positions.map((seq) => replay?.get(seq) ?? null);
+    const folded = positions.map(() => false);
+    const expand = /* @__PURE__ */ __name(() => {
+      for (let i = 0; i < checkpoints.length; i += 1) {
+        const cp = checkpoints[i];
+        if (!cp?.name.startsWith(FOLDED_PREFIX) || folded[i]) continue;
+        const fold = cp.output;
+        if (!fold || typeof fold.from !== "number" || !Array.isArray(fold.values)) {
+          throw new Error(`ctx.all: folded checkpoint "${cp.name}" at seq ${cp.seq} is malformed`);
+        }
+        const { from, values } = fold;
+        values.forEach((value, j) => {
+          checkpoints[from + j] = {
+            ...cp,
+            seq: positions[from + j],
+            output: {
+              ok: true,
+              value
+            }
+          };
+          folded[from + j] = true;
+        });
+      }
+    }, "expand");
+    expand();
+    const missing = positions.filter((_, i) => !checkpoints[i]);
+    if (missing.length === 0) return {
+      checkpoints,
+      folded
+    };
+    if (missing.length > 1 && store.listCheckpointsByNamePrefix) {
+      const bySeq = /* @__PURE__ */ new Map();
+      for (const cp of await store.listCheckpointsByNamePrefix(runId, prefixes)) {
+        bySeq.set(cp.seq, cp);
+      }
+      positions.forEach((seq, i) => {
+        checkpoints[i] ??= bySeq.get(seq) ?? null;
+      });
+    } else {
+      await Promise.all(positions.map(async (seq, i) => {
+        checkpoints[i] ??= await readCheckpoint(seq);
+      }));
+    }
+    expand();
+    return {
+      checkpoints,
+      folded
+    };
+  }, "readFan");
+  const registerChildWaits = /* @__PURE__ */ __name(async (entries) => {
+    if (store.registerChildWaits) {
+      await store.registerChildWaits(entries);
+    } else {
+      await Promise.all(entries.map(async (e) => {
+        await store.putSignalWaiter(e.waiter);
+        await store.saveCheckpoint(e.checkpoint);
+      }));
+    }
+    for (const e of entries) replay?.set(e.checkpoint.seq, e.checkpoint);
+  }, "registerChildWaits");
   const startChild = /* @__PURE__ */ __name(async (workflow2, input, options) => {
     const { childId, priority, version } = normalizeChildOptions(options);
     const current = pos.next();
@@ -3627,6 +3870,8 @@ var WorkflowEngine = class {
   /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
   inflight = /* @__PURE__ */ new Set();
   draining = false;
+  /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
+  drainSpentMs = 0;
   constructor(deps) {
     this.store = deps.store;
     this.pool = new TransportPool(deps.transports ?? (deps.transport ? [
@@ -3675,7 +3920,8 @@ var WorkflowEngine = class {
     });
     this.schedules = new ScheduleClient(this.store, {
       start: /* @__PURE__ */ __name((workflow, input, runId, opts) => this.start(workflow, input, runId, opts), "start"),
-      getRun: /* @__PURE__ */ __name((runId) => this.store.getRun(runId), "getRun")
+      getRun: /* @__PURE__ */ __name((runId) => this.store.getRun(runId), "getRun"),
+      isDraining: /* @__PURE__ */ __name(() => this.draining, "isDraining")
     }, {
       namespace: this.namespace,
       clock: this.clock
@@ -4287,10 +4533,8 @@ var WorkflowEngine = class {
   */
   async findParentRunId(childRunId) {
     const token = `child:${childRunId}`;
-    for (const waiter of await this.store.listSignalWaiters("child:")) {
-      if (waiter.token === token) return waiter.runId;
-    }
-    return void 0;
+    const waiters = await this.store.listSignalWaiters(token);
+    return waiters.find((waiter) => waiter.token === token)?.runId;
   }
   /** Track an in-flight execution so {@link drain} can wait for it. */
   track(p) {
@@ -4302,15 +4546,34 @@ var WorkflowEngine = class {
     return p;
   }
   /**
+  * Stop picking up new work without waiting: recovery, timer, schedule and timeout sweeps (and
+  * their per-run lock loops) start nothing once this is called, and {@link runOne} returns null. A
+  * poller calls it on its own shutdown so an in-flight sweep stops locking runs before it is awaited.
+  *
+  * `spentMs` is wait time ALREADY spent on this shutdown (the poller awaiting its in-flight sweep).
+  * It is deducted from the budget of a later {@link drain}, so that wait plus the drain stay within
+  * one `shutdownTimeoutMs`. Only time actually spent waiting is charged: time that merely passes
+  * between this call and `drain()` (other hooks, the HTTP server closing) never is. Calls add up.
+  */
+  beginDrain(spentMs = 0) {
+    this.draining = true;
+    this.drainSpentMs += Math.max(0, spentMs);
+  }
+  /**
   * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
   * in-flight executions to settle, up to `timeoutMs`. Call from your app's shutdown hook so a
   * deploy hands off cleanly instead of leaving runs to the lease timeout.
+  *
+  * `timeoutMs` is the total budget for waiting on in-flight runs; any wait already reported through
+  * {@link beginDrain} (`spentMs`) is deducted, so a shutdown that already waited on the timer poll
+  * for part of it waits only for the remainder. With nothing reported, the full `timeoutMs` applies.
   */
   async drain(timeoutMs = 1e4) {
-    this.draining = true;
+    this.beginDrain();
+    const budget = Math.max(0, timeoutMs - this.drainSpentMs);
     if (this.inflight.size === 0) return;
     const timer = new Promise((resolve) => {
-      const t = setTimeout(resolve, timeoutMs);
+      const t = setTimeout(resolve, budget);
       t.unref?.();
     });
     await Promise.race([
@@ -4352,6 +4615,7 @@ var WorkflowEngine = class {
   */
   async sweepTimeouts(now = this.clock()) {
     for (const reg of new Set(this.latest.values())) {
+      if (this.draining) return;
       if (reg.executionTimeoutMs == null) continue;
       const deadline = now - reg.executionTimeoutMs;
       const inflight = [
@@ -4367,6 +4631,7 @@ var WorkflowEngine = class {
         })
       ];
       for (const run of inflight) {
+        if (this.draining) return;
         if (run.createdAt.getTime() > deadline) continue;
         const error2 = {
           message: "execution timeout",
@@ -4396,6 +4661,7 @@ var WorkflowEngine = class {
     if (this.draining) return [];
     const results = [];
     for (const listed of await this.store.listIncompleteRuns(this.namespace)) {
+      if (this.draining) break;
       const acquired = await this.store.tryLockRun(listed.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
       const run = await this.store.getRun(listed.id);
@@ -4511,7 +4777,10 @@ var WorkflowEngine = class {
     const due = await this.store.listDueTimers(nowMs, this.namespace);
     const blocked = await this.dueBlockedRuns(nowMs);
     if (due.length === 0 && blocked.length === 0) return [];
-    const waiterByRun = indexWaitersByRun(await this.store.listSignalWaiters(""));
+    const waiterByRun = indexWaitersByRun(await listSignalWaitersOfRuns(this.store, [
+      ...due,
+      ...blocked
+    ].map((run) => run.id)));
     return this.resumeLeased([
       ...due,
       ...blocked
@@ -4621,11 +4890,6 @@ var WorkflowEngine = class {
             } : {}
           });
         } else if (cp.kind === "signal" && cp.name.startsWith("signal:child:") && cp.status === "completed" && isFailureCompletion(cp.output)) {
-          await this.store.saveCheckpoint({
-            ...cp,
-            status: "running",
-            output: void 0
-          });
           const childId = cp.name.slice("signal:child:".length);
           const parked = [];
           for (; ; ) {
@@ -4633,8 +4897,28 @@ var WorkflowEngine = class {
             if (!buffered) break;
             parked.push(buffered.payload);
           }
+          const successAt = parked.findIndex((payload) => typeof payload === "object" && payload !== null && payload.ok === true);
+          const success = successAt === -1 ? void 0 : parked.splice(successAt, 1)[0];
           for (const payload of parked) await this.store.bufferSignal(`child:${childId}`, payload);
-          const bufferedSuccess = parked.some((payload) => typeof payload === "object" && payload !== null && payload.ok === true);
+          const bufferedSuccess = success !== void 0;
+          if (bufferedSuccess) {
+            await this.store.saveCheckpoint({
+              ...cp,
+              output: success
+            });
+          } else {
+            await this.store.putSignalWaiter({
+              token: `child:${childId}`,
+              runId,
+              seq: cp.seq,
+              parallelGroup: cp.parallelGroup
+            });
+            await this.store.saveCheckpoint({
+              ...cp,
+              status: "running",
+              output: void 0
+            });
+          }
           if (!bufferedSuccess) {
             const child = await this.store.getRun(childId);
             if (child && (child.status === "failed" || child.status === "dead")) {
@@ -4813,8 +5097,13 @@ var WorkflowEngine = class {
     if (this.draining) return [];
     const results = [];
     for (const run of runs) {
+      if (this.draining) break;
       const acquired = await this.store.tryLockRun(run.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
+      if (this.draining) {
+        await this.store.releaseRunLock(run.id);
+        break;
+      }
       try {
         const settled = onLocked ? await onLocked(run) : void 0;
         results.push(settled ?? await this.resumeImplicit(run.id));
@@ -4914,12 +5203,62 @@ var WorkflowEngine = class {
       // for an ordinary (non-fan) signal/child await.
       parallelGroup: waiter.parallelGroup
     }));
+    if (await this.fanStillWaiting(waiter, payload)) {
+      return {
+        runId: waiter.runId,
+        status: "suspended"
+      };
+    }
     return this.resumeImplicit(waiter.runId).catch((err) => {
       if (err instanceof NamespaceMismatch) return null;
       throw err;
     });
   }
   /**
+  * The `ctx.all` join barrier: true when `waiter` was one child of a fan (or of one wave of it)
+  * whose siblings are still out, so waking the parent now would only replay the fan and re-suspend.
+  * Skipping that wake is what keeps a fan of N children at O(N) work instead of N replays of N items.
+  *
+  * Safe because the LAST sibling to settle always wakes the parent: each child consumes its own
+  * waiter before it asks, so whichever asks last sees none left. A failed child of a failFast fan
+  * always wakes it. Anything that is not a `ctx.all` waiter, or a store that cannot answer the
+  * question cheaply, wakes the parent as before.
+  */
+  async fanStillWaiting(waiter, payload) {
+    if (!this.store.hasSignalWaiter) return false;
+    const fan = fanOfWaiter(waiter);
+    if (!fan) return false;
+    if (fan.failFast && isFailedCompletion(payload)) return false;
+    return this.store.hasSignalWaiter(waiter.runId, fan.waiterPrefix);
+  }
+  /**
+  * Re-drive a run that just suspended on awaited children (a `ctx.all` fan or wave, a `ctx.child`)
+  * which, by now, have settled.
+  *
+  * {@link execute} drops a wake that finds the run's lease held. So if a child settles while the
+  * parent is still executing (the turn that dispatched it, or one woken by an earlier child), that
+  * wake is spent, and the turn suspends on a snapshot that predates the child. With the `ctx.all`
+  * barrier that wake was the only one the fan would get. Nothing would wake the run until the
+  * `reconcileMs` sweep, minutes later.
+  *
+  * Called after the turn released its lease, so any child that settles from here on wakes the run
+  * itself. Only re-drives for a group with no waiter left whose checkpoints are all settled, which
+  * the next turn is then guaranteed to see — so it cannot loop.
+  */
+  async redriveSettledChildren(runId, fan) {
+    if (!this.store.hasSignalWaiter) return;
+    for (const wait of fan.waits) {
+      if (await this.store.hasSignalWaiter(runId, wait.waiterPrefix)) continue;
+      const checkpoints = this.store.listCheckpointsByNamePrefix ? await this.store.listCheckpointsByNamePrefix(runId, [
+        wait.checkpointPrefix
+      ]) : (await this.store.listCheckpoints(runId)).filter((cp) => cp.name.startsWith(wait.checkpointPrefix));
+      if (checkpoints.length > 0 && checkpoints.every((cp) => cp.status === "completed")) {
+        await this.resumeImplicit(runId);
+        return;
+      }
+    }
+  }
+  /**
   * 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.
   *
@@ -5212,23 +5551,11 @@ var WorkflowEngine = class {
   }
   /** The given runs plus every descendant, children before parents. One waiter scan for the batch. */
   async collectSubtrees(rootIds) {
-    const waitersByParent = /* @__PURE__ */ new Map();
-    for (const w of await this.store.listSignalWaiters("child:")) {
-      const list = waitersByParent.get(w.runId) ?? [];
-      list.push(w.token.slice("child:".length));
-      waitersByParent.set(w.runId, list);
-    }
-    const prefixes = [
-      "signal:child:",
-      "spawn:"
-    ];
+    const prefixes = CHILD_EDGE_PREFIXES;
     const childrenOf = /* @__PURE__ */ __name(async (parent) => {
-      const ids = new Set(waitersByParent.get(parent) ?? []);
+      const ids = new Set(await this.awaitedChildIds(parent));
       const cps = this.store.listCheckpointsByNamePrefix ? await this.store.listCheckpointsByNamePrefix(parent, prefixes) : (await this.store.listCheckpoints(parent)).filter((cp) => prefixes.some((p) => cp.name.startsWith(p)));
-      for (const cp of cps) {
-        if (cp.name.startsWith("signal:child:")) ids.add(cp.name.slice("signal:child:".length));
-        if (cp.name.startsWith("spawn:") && typeof cp.output === "string") ids.add(cp.output);
-      }
+      for (const id of childIdsOf(cps)) ids.add(id);
       return [
         ...ids
       ];
@@ -5278,22 +5605,20 @@ var WorkflowEngine = class {
   * so a completed parent (or a completed awaited child) would otherwise drop out of the tree. The
   * `signal:child:<id>` checkpoint (the placeholder written when the parent first awaits the child,
   * overwritten as completed/failed when it settles) persists across completion, so we read both and
-  * dedupe — the edge stays stable for a finished run, not just a live one.
+  * dedupe — the edge stays stable for a finished run, not just a live one. A settled `ctx.all`
+  * group folded into one `fan:` checkpoint stands for every child in it.
   */
+  /** The children `parentRunId` is awaiting right now, read off its own live `child:` waiters. */
+  async awaitedChildIds(parentRunId) {
+    return (await listSignalWaitersOfRuns(this.store, [
+      parentRunId
+    ])).filter((w) => w.token.startsWith("child:")).map((w) => w.token.slice("child:".length));
+  }
   async getRunChildren(parentRunId) {
-    const childIds = /* @__PURE__ */ new Set();
-    for (const w of await this.store.listSignalWaiters("child:")) {
-      if (w.runId === parentRunId) childIds.add(w.token.slice("child:".length));
-    }
-    const prefixes = [
-      "signal:child:",
-      "spawn:"
-    ];
+    const childIds = new Set(await this.awaitedChildIds(parentRunId));
+    const prefixes = CHILD_EDGE_PREFIXES;
     const childCheckpoints = this.store.listCheckpointsByNamePrefix ? await this.store.listCheckpointsByNamePrefix(parentRunId, prefixes) : (await this.store.listCheckpoints(parentRunId)).filter((cp) => prefixes.some((p) => cp.name.startsWith(p)));
-    for (const cp of childCheckpoints) {
-      if (cp.name.startsWith("signal:child:")) childIds.add(cp.name.slice("signal:child:".length));
-      if (cp.name.startsWith("spawn:") && typeof cp.output === "string") childIds.add(cp.output);
-    }
+    for (const id of childIdsOf(childCheckpoints)) childIds.add(id);
     return [
       ...childIds
     ];
@@ -6373,6 +6698,7 @@ var WorkflowEngine = class {
     const snapshot = await this.store.listCheckpoints(run.id);
     const replay = /* @__PURE__ */ new Map();
     for (const cp of snapshot) replay.set(cp.seq, cp);
+    let suspendedOnFan;
     const ctx = createWorkflowCtx(this.ctxHostFor(replay, run.namespace), run.id, compensations, run.workflow, registered?.searchAttributesSchema);
     try {
       const output = await runInWorkflowCtx(ctx, () => fn(ctx, run.input));
@@ -6424,10 +6750,12 @@ var WorkflowEngine = class {
         if (this.cancelRequested.has(run.id)) {
           return await this.compensateAndCancel(run, compensations, replay);
         }
-        return await this.settleRun(run, {
+        const suspended = await this.settleRun(run, {
           kind: "suspended",
           wakeAt: err.wakeAt
         });
+        suspendedOnFan = err.fan;
+        return suspended;
       }
       if (this.cancelRequested.has(run.id)) {
         return await this.compensateAndCancel(run, compensations, replay);
@@ -6447,6 +6775,9 @@ var WorkflowEngine = class {
       });
     } finally {
       await this.store.releaseRunLock(run.id);
+      if (suspendedOnFan) {
+        void this.redriveSettledChildren(run.id, suspendedOnFan).catch(() => void 0);
+      }
     }
   }
   /**
@@ -7261,6 +7592,21 @@ var RemoteStepError = class extends Error {
     this.stepError = stepError;
   }
 };
+var CHILD_EDGE_PREFIXES = [
+  "signal:child:",
+  FOLDED_PREFIX,
+  "spawn:"
+];
+function childIdsOf(checkpoints) {
+  const ids = [];
+  for (const cp of checkpoints) {
+    if (cp.name.startsWith("signal:child:")) ids.push(cp.name.slice("signal:child:".length));
+    if (cp.name.startsWith(FOLDED_PREFIX)) ids.push(...foldedChildIds(cp));
+    if (cp.name.startsWith("spawn:") && typeof cp.output === "string") ids.push(cp.output);
+  }
+  return ids;
+}
+__name(childIdsOf, "childIdsOf");
 
 // src/run-facets.ts
 function facetOrigin(origin) {
@@ -7410,6 +7756,14 @@ var CodecStateStore = class {
   /** Forwarded verbatim — a count reads no payload. Bound only when the inner store counts, so the
   *  engine's facet/listing fallback still applies through the wrapper. */
   countRuns;
+  /** The placeholder checkpoints are encoded like any other checkpoint. */
+  registerChildWaits;
+  /** The folded checkpoint carries the children's outputs, so it is encoded. */
+  compactCheckpoints;
+  /** Forwarded verbatim — a waiter carries no payload. */
+  listSignalWaitersByRun;
+  /** Forwarded verbatim — a waiter carries no payload. */
+  hasSignalWaiter;
   /** Schedules persist their run `input` inside `spec` — encoded like any other payload. Bound only
   *  when the inner store persists schedules, so `engine.schedules` reports absence faithfully. */
   saveSchedule;
@@ -7427,6 +7781,17 @@ var CodecStateStore = class {
     if (prune) this.pruneTerminalRuns = (policy, now, limit) => prune.call(inner, policy, now, limit);
     const count = inner.countRuns;
     if (count) this.countRuns = (query) => count.call(inner, query);
+    const registerChildWaits = inner.registerChildWaits;
+    if (registerChildWaits) this.registerChildWaits = (entries) => registerChildWaits.call(inner, entries.map((e) => ({
+      waiter: e.waiter,
+      checkpoint: this.encCp(e.checkpoint)
+    })));
+    const compact = inner.compactCheckpoints;
+    if (compact) this.compactCheckpoints = (runId, fromSeq, toSeq, into) => compact.call(inner, runId, fromSeq, toSeq, this.encCp(into));
+    const byRun = inner.listSignalWaitersByRun;
+    if (byRun) this.listSignalWaitersByRun = (runIds) => byRun.call(inner, runIds);
+    const hasWaiter = inner.hasSignalWaiter;
+    if (hasWaiter) this.hasSignalWaiter = (runId, tokenPrefix) => hasWaiter.call(inner, runId, tokenPrefix);
     const { saveSchedule, getSchedule, updateSchedule, deleteSchedule, listSchedules } = inner;
     if (saveSchedule && getSchedule && updateSchedule && deleteSchedule && listSchedules) {
       this.saveSchedule = (r) => saveSchedule.call(inner, this.encSchedule(r));
@@ -8037,6 +8402,33 @@ var InMemoryStateStore = class {
       ...w
     }));
   }
+  async registerChildWaits(entries) {
+    for (const { waiter } of entries) this.signalWaiters.set(waiter.token, {
+      ...waiter
+    });
+    for (const { checkpoint } of entries) await this.saveCheckpoint(checkpoint);
+  }
+  async compactCheckpoints(runId, fromSeq, toSeq, into) {
+    for (let seq = fromSeq; seq <= toSeq; seq += 1) this.checkpoints.delete(this.key(runId, seq));
+    this.checkpoints.set(this.key(runId, into.seq), {
+      ...into,
+      runId
+    });
+  }
+  async listSignalWaitersByRun(runIds) {
+    const ids = new Set(runIds);
+    return [
+      ...this.signalWaiters.values()
+    ].filter((w) => ids.has(w.runId)).map((w) => ({
+      ...w
+    }));
+  }
+  async hasSignalWaiter(runId, tokenPrefix) {
+    for (const w of this.signalWaiters.values()) {
+      if (w.runId === runId && w.token.startsWith(tokenPrefix)) return true;
+    }
+    return false;
+  }
   async removeSignalWaiter(waiter) {
     const current = this.signalWaiters.get(waiter.token);
     if (current && current.runId === waiter.runId && current.seq === waiter.seq) {
@@ -8392,6 +8784,7 @@ var InMemoryTransport = class {
   isLegacyDescriptor,
   isNonEmptyRunScope,
   isWorkflowControlFlowSignal,
+  listSignalWaitersOfRuns,
   log,
   matchesAttributes,
   mergeRunFacetRows,
@@ -8402,6 +8795,7 @@ var InMemoryTransport = class {
   normalizeAttributeRows,
   normalizeDescriptor,
   observedAnnouncements,
+  parentRunIdOf,
   parseDuration,
   partitionOfToken,
   planDispatch,