@dudousxd/nestjs-durable-core 0.85.5 → 0.85.6

package/dist/index.js

@@ -646,6 +646,386 @@ var BoundedRunner = class {
 };
 var LOCAL_RUN_CONCURRENCY = 256;
 
+// src/fan-join.ts
+function allChildId(runId, firstSeq, index, wave) {
+  return `${allBase(runId, firstSeq, wave)}${index}`;
+}
+__name(allChildId, "allChildId");
+function allGroup(firstSeq, size, mode) {
+  const group = `all:${firstSeq}:n${size}`;
+  return mode === "failFast" ? `${group}:failFast` : group;
+}
+__name(allGroup, "allGroup");
+function stepFanGroup(firstSeq, size, mode) {
+  const group = `steps:${firstSeq}:${size}`;
+  return mode === "failFast" ? `${group}:failFast` : group;
+}
+__name(stepFanGroup, "stepFanGroup");
+function parseStepFanGroup(group) {
+  const fan = parseFanGroup(group);
+  if (fan?.kind !== "steps" || fan.size === void 0) return void 0;
+  return {
+    firstSeq: fan.firstSeq,
+    size: fan.size
+  };
+}
+__name(parseStepFanGroup, "parseStepFanGroup");
+function parseFanGroup(group) {
+  const m = group ? /^(all|steps):(\d+)(?::n?(\d+))?(:failFast)?$/.exec(group) : null;
+  if (!m) return void 0;
+  if (m[1] === "steps" && m[3] === void 0) return void 0;
+  return {
+    kind: m[1],
+    firstSeq: Number(m[2]),
+    size: m[3] === void 0 ? void 0 : Number(m[3]),
+    failFast: m[4] !== void 0
+  };
+}
+__name(parseFanGroup, "parseFanGroup");
+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+|onError\.\d+)$/;
+function parentRunIdOf(runId) {
+  return ENGINE_CHILD_ID.exec(runId)?.[1];
+}
+__name(parentRunIdOf, "parentRunIdOf");
+var GROUP = /^all:(\d+)(?::n\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/interfaces.ts
+function checkpointNameKind(name) {
+  if (name.startsWith("signal:child:")) return "child";
+  if (name.startsWith("fan:")) return "folded";
+  if (name.startsWith("spawn:")) return "spawn";
+  return "step";
+}
+__name(checkpointNameKind, "checkpointNameKind");
+function poolNamespace(namespace) {
+  return namespace === "" ? "default" : namespace;
+}
+__name(poolNamespace, "poolNamespace");
+var TERMINAL_RUN_STATUSES = [
+  "completed",
+  "failed",
+  "cancelled",
+  "dead"
+];
+function isNonEmptyRunScope(scope) {
+  if (!scope) return false;
+  return scope.workflow !== void 0 || scope.workflows !== void 0 || scope.tag !== void 0 || scope.tags !== void 0 || scope.namespace !== void 0 || scope.namespaces !== void 0 || scope.attributes !== void 0 && scope.attributes.length > 0;
+}
+__name(isNonEmptyRunScope, "isNonEmptyRunScope");
+
+// src/events.ts
+var enc = /* @__PURE__ */ __name((s) => Buffer.from(s, "utf8").toString("base64"), "enc");
+var dec = /* @__PURE__ */ __name((s) => Buffer.from(s, "base64").toString("utf8"), "dec");
+var EVENT_BUFFER_SCAN_LIMIT = 50;
+var EVENT_TOKEN_PREFIX = "event:";
+function eventPrefix(name) {
+  return `${EVENT_TOKEN_PREFIX}${enc(name)}:`;
+}
+__name(eventPrefix, "eventPrefix");
+function isEventToken(token) {
+  return token.startsWith(EVENT_TOKEN_PREFIX);
+}
+__name(isEventToken, "isEventToken");
+function eventToken(name, match, runId, seq) {
+  return `${eventPrefix(name)}${enc(JSON.stringify(match ?? {}))}:${runId}#${seq}`;
+}
+__name(eventToken, "eventToken");
+function eventNameOf(token) {
+  try {
+    return dec(token.split(":")[1] ?? "");
+  } catch {
+    return token;
+  }
+}
+__name(eventNameOf, "eventNameOf");
+function eventMatchOf(token) {
+  try {
+    return JSON.parse(dec(token.split(":")[2] ?? ""));
+  } catch {
+    return {};
+  }
+}
+__name(eventMatchOf, "eventMatchOf");
+function eventMatches(payload, match) {
+  const keys = Object.keys(match);
+  if (keys.length === 0) return true;
+  if (!payload || typeof payload !== "object") return false;
+  const p = payload;
+  return keys.every((k) => JSON.stringify(p[k]) === JSON.stringify(match[k]));
+}
+__name(eventMatches, "eventMatches");
+
+// src/run-waiting.ts
+var WEBHOOK_PREFIX = "wh:";
+var CHILD_PREFIX = "child:";
+var BREAKPOINT_PREFIX = "bp:";
+var EVENT_PREFIX = EVENT_TOKEN_PREFIX;
+function parseWebhookToken(token) {
+  if (!token.startsWith(WEBHOOK_PREFIX)) return null;
+  const rest = token.slice(WEBHOOK_PREFIX.length);
+  const at = rest.lastIndexOf(":");
+  if (at <= 0) return null;
+  const seqText = rest.slice(at + 1);
+  if (!/^\d+$/.test(seqText)) return null;
+  return {
+    runId: rest.slice(0, at),
+    seq: Number(seqText)
+  };
+}
+__name(parseWebhookToken, "parseWebhookToken");
+function classifyWaiterToken(token) {
+  if (token.startsWith(WEBHOOK_PREFIX)) return {
+    on: "webhook",
+    name: token
+  };
+  if (token.startsWith(BREAKPOINT_PREFIX)) return {
+    on: "breakpoint",
+    name: "breakpoint"
+  };
+  if (token.startsWith(CHILD_PREFIX)) return {
+    on: "child",
+    name: token.slice(CHILD_PREFIX.length)
+  };
+  if (token.startsWith(EVENT_PREFIX)) return {
+    on: "signal",
+    name: eventNameOf(token)
+  };
+  return {
+    on: "signal",
+    name: token
+  };
+}
+__name(classifyWaiterToken, "classifyWaiterToken");
+function resolveRunWaiting(run, waiterByRun) {
+  if (run.status !== "suspended") return void 0;
+  const waiter = waiterByRun.get(run.id);
+  return waiter ? classifyWaiterToken(waiter.token) : void 0;
+}
+__name(resolveRunWaiting, "resolveRunWaiting");
+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);
+  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/buffered-child-signals.ts
+var CHILD_TOKEN_PREFIX = "child:";
+var CHILD_SIGNAL_NAME_PREFIX = "signal:child:";
+var RETRYABLE = /* @__PURE__ */ new Set([
+  "failed",
+  "dead"
+]);
+var FAN_CHILD = /^(.+\.all\.\d+\.(?:w\d+\.)?)(\d+)$/;
+function canonicalJson(value) {
+  const plain = JSON.stringify(value);
+  return plain === void 0 ? "null" : sortedJson(JSON.parse(plain));
+}
+__name(canonicalJson, "canonicalJson");
+function sortedJson(value) {
+  if (Array.isArray(value)) return `[${value.map(sortedJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${sortedJson(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+__name(sortedJson, "sortedJson");
+function settledNames(childId) {
+  const signal = `${CHILD_SIGNAL_NAME_PREFIX}${childId}`;
+  const fan = FAN_CHILD.exec(childId);
+  if (!fan) return {
+    signal
+  };
+  return {
+    signal,
+    fold: {
+      name: `${FOLDED_PREFIX}${fan[1]}`,
+      index: Number(fan[2])
+    }
+  };
+}
+__name(settledNames, "settledNames");
+function parentHoldsChild(checkpoints, childId, completion) {
+  const { signal, fold } = settledNames(childId);
+  const expected = canonicalJson(completion);
+  return checkpoints.some((cp) => {
+    if (cp.status !== "completed") return false;
+    if (cp.name === signal) return canonicalJson(cp.output) === expected;
+    if (fold && cp.name === fold.name) {
+      const { from, values } = cp.output ?? {};
+      return typeof from === "number" && Array.isArray(values) && fold.index >= from && fold.index < from + values.length;
+    }
+    return false;
+  });
+}
+__name(parentHoldsChild, "parentHoldsChild");
+async function parentCheckpoints(store, parentId, childId) {
+  const { signal, fold } = settledNames(childId);
+  const prefixes = fold ? [
+    signal,
+    fold.name
+  ] : [
+    signal
+  ];
+  return store.listCheckpointsByNamePrefix ? store.listCheckpointsByNamePrefix(parentId, prefixes) : store.listCheckpoints(parentId);
+}
+__name(parentCheckpoints, "parentCheckpoints");
+async function childCompletionNeedsBuffer(store, childId, completion, parent) {
+  const parentId = parentRunIdOf(childId);
+  if (!parentId) return false;
+  const run = parent === void 0 ? await store.getRun(parentId) : parent;
+  if (!run) return false;
+  if (TERMINAL_RUN_STATUSES.includes(run.status) && !RETRYABLE.has(run.status)) return false;
+  return !parentHoldsChild(await parentCheckpoints(store, parentId, childId), childId, completion);
+}
+__name(childCompletionNeedsBuffer, "childCompletionNeedsBuffer");
+async function unneededChildSignals(store, rows) {
+  const parentIds = rows.flatMap((row) => {
+    const parentId = parentRunIdOf(row.token.slice(CHILD_TOKEN_PREFIX.length));
+    return parentId ? [
+      parentId
+    ] : [];
+  });
+  const { runs, unread } = await readRunsByIds(store, parentIds);
+  const unreadable = new Set(unread);
+  const doomed = [];
+  for (const row of rows) {
+    if (!row.token.startsWith(CHILD_TOKEN_PREFIX)) continue;
+    const childId = row.token.slice(CHILD_TOKEN_PREFIX.length);
+    const parentId = parentRunIdOf(childId);
+    if (parentId && unreadable.has(parentId)) continue;
+    const parent = parentId ? runs.get(parentId) ?? null : null;
+    try {
+      if (!await childCompletionNeedsBuffer(store, childId, row.payload, parent)) doomed.push(row);
+    } catch {
+    }
+  }
+  return doomed;
+}
+__name(unneededChildSignals, "unneededChildSignals");
+
 // src/execution-hooks.ts
 var wrappers = [];
 function useDurableExecution(wrapper) {
@@ -975,6 +1355,32 @@ function completionError(c) {
   };
 }
 __name(completionError, "completionError");
+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");
 
 // src/concurrency.ts
 var DEFAULT_CONCURRENCY_STATUSES = [
@@ -1241,150 +1647,6 @@ var EventAccumulators = class {
   }
 };
 
-// src/events.ts
-var enc = /* @__PURE__ */ __name((s) => Buffer.from(s, "utf8").toString("base64"), "enc");
-var dec = /* @__PURE__ */ __name((s) => Buffer.from(s, "base64").toString("utf8"), "dec");
-var EVENT_BUFFER_SCAN_LIMIT = 50;
-var EVENT_TOKEN_PREFIX = "event:";
-function eventPrefix(name) {
-  return `${EVENT_TOKEN_PREFIX}${enc(name)}:`;
-}
-__name(eventPrefix, "eventPrefix");
-function isEventToken(token) {
-  return token.startsWith(EVENT_TOKEN_PREFIX);
-}
-__name(isEventToken, "isEventToken");
-function eventToken(name, match, runId, seq) {
-  return `${eventPrefix(name)}${enc(JSON.stringify(match ?? {}))}:${runId}#${seq}`;
-}
-__name(eventToken, "eventToken");
-function eventNameOf(token) {
-  try {
-    return dec(token.split(":")[1] ?? "");
-  } catch {
-    return token;
-  }
-}
-__name(eventNameOf, "eventNameOf");
-function eventMatchOf(token) {
-  try {
-    return JSON.parse(dec(token.split(":")[2] ?? ""));
-  } catch {
-    return {};
-  }
-}
-__name(eventMatchOf, "eventMatchOf");
-function eventMatches(payload, match) {
-  const keys = Object.keys(match);
-  if (keys.length === 0) return true;
-  if (!payload || typeof payload !== "object") return false;
-  const p = payload;
-  return keys.every((k) => JSON.stringify(p[k]) === JSON.stringify(match[k]));
-}
-__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, size, mode) {
-  const group = `all:${firstSeq}:n${size}`;
-  return mode === "failFast" ? `${group}:failFast` : group;
-}
-__name(allGroup, "allGroup");
-function stepFanGroup(firstSeq, size, mode) {
-  const group = `steps:${firstSeq}:${size}`;
-  return mode === "failFast" ? `${group}:failFast` : group;
-}
-__name(stepFanGroup, "stepFanGroup");
-function parseStepFanGroup(group) {
-  const fan = parseFanGroup(group);
-  if (fan?.kind !== "steps" || fan.size === void 0) return void 0;
-  return {
-    firstSeq: fan.firstSeq,
-    size: fan.size
-  };
-}
-__name(parseStepFanGroup, "parseStepFanGroup");
-function parseFanGroup(group) {
-  const m = group ? /^(all|steps):(\d+)(?::n?(\d+))?(:failFast)?$/.exec(group) : null;
-  if (!m) return void 0;
-  if (m[1] === "steps" && m[3] === void 0) return void 0;
-  return {
-    kind: m[1],
-    firstSeq: Number(m[2]),
-    size: m[3] === void 0 ? void 0 : Number(m[3]),
-    failFast: m[4] !== void 0
-  };
-}
-__name(parseFanGroup, "parseFanGroup");
-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+|onError\.\d+)$/;
-function parentRunIdOf(runId) {
-  return ENGINE_CHILD_ID.exec(runId)?.[1];
-}
-__name(parentRunIdOf, "parentRunIdOf");
-var GROUP = /^all:(\d+)(?::n\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 = {
@@ -2068,33 +2330,9 @@ function planDispatch(requires, liveDescriptors, cp, token) {
       controlPlane: cp,
       workers
     }
-  };
-}
-__name(planDispatch, "planDispatch");
-
-// src/interfaces.ts
-function checkpointNameKind(name) {
-  if (name.startsWith("signal:child:")) return "child";
-  if (name.startsWith("fan:")) return "folded";
-  if (name.startsWith("spawn:")) return "spawn";
-  return "step";
-}
-__name(checkpointNameKind, "checkpointNameKind");
-function poolNamespace(namespace) {
-  return namespace === "" ? "default" : namespace;
-}
-__name(poolNamespace, "poolNamespace");
-var TERMINAL_RUN_STATUSES = [
-  "completed",
-  "failed",
-  "cancelled",
-  "dead"
-];
-function isNonEmptyRunScope(scope) {
-  if (!scope) return false;
-  return scope.workflow !== void 0 || scope.workflows !== void 0 || scope.tag !== void 0 || scope.tags !== void 0 || scope.namespace !== void 0 || scope.namespaces !== void 0 || scope.attributes !== void 0 && scope.attributes.length > 0;
+  };
 }
-__name(isNonEmptyRunScope, "isNonEmptyRunScope");
+__name(planDispatch, "planDispatch");
 
 // src/on-error.ts
 var UNROUTABLE_CODES = /* @__PURE__ */ new Set([
@@ -2270,122 +2508,6 @@ var RunDispatchBatcher = class {
   }
 };
 
-// src/run-waiting.ts
-var WEBHOOK_PREFIX = "wh:";
-var CHILD_PREFIX = "child:";
-var BREAKPOINT_PREFIX = "bp:";
-var EVENT_PREFIX = EVENT_TOKEN_PREFIX;
-function parseWebhookToken(token) {
-  if (!token.startsWith(WEBHOOK_PREFIX)) return null;
-  const rest = token.slice(WEBHOOK_PREFIX.length);
-  const at = rest.lastIndexOf(":");
-  if (at <= 0) return null;
-  const seqText = rest.slice(at + 1);
-  if (!/^\d+$/.test(seqText)) return null;
-  return {
-    runId: rest.slice(0, at),
-    seq: Number(seqText)
-  };
-}
-__name(parseWebhookToken, "parseWebhookToken");
-function classifyWaiterToken(token) {
-  if (token.startsWith(WEBHOOK_PREFIX)) return {
-    on: "webhook",
-    name: token
-  };
-  if (token.startsWith(BREAKPOINT_PREFIX)) return {
-    on: "breakpoint",
-    name: "breakpoint"
-  };
-  if (token.startsWith(CHILD_PREFIX)) return {
-    on: "child",
-    name: token.slice(CHILD_PREFIX.length)
-  };
-  if (token.startsWith(EVENT_PREFIX)) return {
-    on: "signal",
-    name: eventNameOf(token)
-  };
-  return {
-    on: "signal",
-    name: token
-  };
-}
-__name(classifyWaiterToken, "classifyWaiterToken");
-function resolveRunWaiting(run, waiterByRun) {
-  if (run.status !== "suspended") return void 0;
-  const waiter = waiterByRun.get(run.id);
-  return waiter ? classifyWaiterToken(waiter.token) : void 0;
-}
-__name(resolveRunWaiting, "resolveRunWaiting");
-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);
-  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
 import { createRequire } from "node:module";
 
@@ -3842,7 +3964,23 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         status: "running"
       }));
     }
-    if (!await store.getRun(id)) host.startChild(workflowName(workflow2), input, id, priority, version);
+    const childRun = await store.getRun(id);
+    if (!childRun) {
+      host.startChild(workflowName(workflow2), input, id, priority, version);
+    } else {
+      const done = (await settleFinishedChildren([
+        {
+          id,
+          seq: current
+        }
+      ], /* @__PURE__ */ new Map([
+        [
+          id,
+          childRun
+        ]
+      ]))).get(id);
+      if (done) return unwrapCompletion(done, `child "${id}"`);
+    }
     throw new WorkflowSuspended(void 0, fanJoin([
       {
         waiterPrefix: `child:${id}`,
@@ -3863,164 +4001,174 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
     const group = allGroup(firstSeq, inputs.length, 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") {
-      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"
+    for (; ; ) {
+      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") {
+        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));
           }
-        ], inputs.length);
-      }
-    }
-    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: positions[first],
-          name: allFoldedName(runId, firstSeq, waves ? k : void 0),
-          kind: "signal",
-          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);
+          throw new GatherError([
+            {
+              index: i,
+              id: id(i),
+              error: c.error ?? "unknown"
+            }
+          ], inputs.length);
         }
       }
-      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({
+      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: positions[i],
-            name: `signal:child:${id(i)}`,
+            seq: positions[first],
+            name: allFoldedName(runId, firstSeq, waves ? k : void 0),
             kind: "signal",
-            status: "running",
+            output: {
+              from: first,
+              values
+            },
             parallelGroup: group
-          })
-        }));
-        await registerChildWaits(entries);
-        for (const i of chunk) 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));
+          });
+          await store.compactCheckpoints(runId, positions[first], positions[last], into);
+          for (const i of items) replay?.delete(positions[i]);
+          replay?.set(into.seq, into);
         }
       }
-    }
-    if (active.length > 0) {
-      throw new WorkflowSuspended(void 0, fanJoin(active.map((k) => allWait(runId, firstSeq, waves ? k : void 0))));
-    }
-    const outputs = [];
-    const results = [];
-    const failures = [];
-    for (let i = 0; i < inputs.length; i += 1) {
-      const c = existing[i]?.output;
-      if (c && typeof c === "object" && "ok" in c && c.ok === false) {
-        const { message, ...rest } = completionError({
-          ...c,
-          error: c.error ?? "unknown"
-        });
-        const failure = {
+      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;
+        }
+      }
+      let known;
+      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));
+        }
+        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));
+          }
+          known = started;
+        }
+        const now2 = await settleFinishedChildren(toEnsure.map((i) => ({
           id: id(i),
-          error: message,
-          ...rest
-        };
-        failures.push({
-          index: i,
-          ...failure
-        });
-        results.push({
-          status: "rejected",
-          ...failure
-        });
-        outputs.push(void 0);
-      } else {
-        const value = c?.value;
-        results.push({
-          status: "fulfilled",
-          value
-        });
-        outputs.push(value);
+          seq: positions[i],
+          parallelGroup: group
+        })), known);
+        if (now2.size > 0) continue;
+      }
+      if (active.length > 0) {
+        throw new WorkflowSuspended(void 0, fanJoin(active.map((k) => allWait(runId, firstSeq, waves ? k : void 0))));
+      }
+      const outputs = [];
+      const results = [];
+      const failures = [];
+      for (let i = 0; i < inputs.length; i += 1) {
+        const c = existing[i]?.output;
+        if (c && typeof c === "object" && "ok" in c && c.ok === false) {
+          const { message, ...rest } = completionError({
+            ...c,
+            error: c.error ?? "unknown"
+          });
+          const failure = {
+            id: id(i),
+            error: message,
+            ...rest
+          };
+          failures.push({
+            index: i,
+            ...failure
+          });
+          results.push({
+            status: "rejected",
+            ...failure
+          });
+          outputs.push(void 0);
+        } else {
+          const value = c?.value;
+          results.push({
+            status: "fulfilled",
+            value
+          });
+          outputs.push(value);
+        }
       }
+      if (settle) return results;
+      if (failures.length > 0) throw new GatherError(failures, inputs.length);
+      return outputs;
     }
-    if (settle) return results;
-    if (failures.length > 0) throw new GatherError(failures, inputs.length);
-    return outputs;
   }, "fan");
   const all = /* @__PURE__ */ __name((workflow2, inputs, opts) => fan(workflow2, inputs, opts, false), "all");
   const allSettled = /* @__PURE__ */ __name((workflow2, inputs, opts) => fan(workflow2, inputs, opts, true), "allSettled");
@@ -4106,6 +4254,39 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
     }
     for (const e of entries) replay?.set(e.checkpoint.seq, e.checkpoint);
   }, "registerChildWaits");
+  const settleFinishedChildren = /* @__PURE__ */ __name(async (awaited, known) => {
+    const settled = /* @__PURE__ */ new Map();
+    if (awaited.length === 0) return settled;
+    const runs = new Map(known ?? []);
+    const toRead = awaited.filter((a) => !runs.has(a.id)).map((a) => a.id);
+    if (toRead.length > 0) {
+      for (const [id, run] of (await readRunsByIds(store, toRead)).runs) runs.set(id, run);
+    }
+    for (const a of awaited) {
+      const child2 = runs.get(a.id);
+      const completion = child2 ? childCompletion(child2) : void 0;
+      if (!completion) continue;
+      const token = `child:${a.id}`;
+      const taken = await store.takeSignalWaiter(token);
+      if (!taken) continue;
+      if (taken.runId !== runId || taken.seq !== a.seq) {
+        await store.putSignalWaiter(taken);
+        continue;
+      }
+      await writeCheckpoint(instantCheckpoint({
+        runId,
+        seq: a.seq,
+        name: `signal:child:${a.id}`,
+        kind: "signal",
+        output: completion,
+        ...a.parallelGroup !== void 0 ? {
+          parallelGroup: a.parallelGroup
+        } : {}
+      }));
+      settled.set(a.id, completion);
+    }
+    return settled;
+  }, "settleFinishedChildren");
   const startChild = /* @__PURE__ */ __name(async (workflow2, input, options) => {
     const { childId, priority, version } = normalizeChildOptions(options);
     const current = pos.next();
@@ -4463,33 +4644,10 @@ var pendingStateKey = /* @__PURE__ */ __name((at) => String(new Date(at).getTime
 var freshPendingKey = /* @__PURE__ */ __name(() => `${Date.now()}-${globalThis.crypto.randomUUID().slice(0, 8)}`, "freshPendingKey");
 var wakeRequestToken = /* @__PURE__ */ __name((runId) => `durable:wake-after-turn:${runId}`, "wakeRequestToken");
 var CHILD_SIGNAL_PREFIX = "signal:child:";
+var BUFFERED_SWEEP_PAGE = 500;
+var BUFFERED_SWEEP_PAGES_PER_CALL = 4;
+var BUFFERED_SWEEP_REST_MS = 10 * 6e4;
 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) {
@@ -4705,6 +4863,10 @@ var WorkflowEngine = class {
   /** Runs already paged about, by id → the `updatedAt` of the paged episode (see {@link sweepStalled}). */
   notifiedStalled = /* @__PURE__ */ new Map();
   lastStalledSweepAt = Number.NEGATIVE_INFINITY;
+  /** {@link sweepBufferedSignals}: the id the pass in progress resumes after, `undefined` between passes. */
+  bufferedSweepCursor;
+  bufferedSweepActive = false;
+  lastBufferedSweepEndedAt = Number.NEGATIVE_INFINITY;
   stalledAfterMs;
   draining = false;
   /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
@@ -5310,6 +5472,50 @@ var WorkflowEngine = class {
     return () => this.deadListeners.delete(listener);
   }
   /**
+  * Delete buffered child completions no parent will ever consume (see
+  * `childCompletionNeedsBuffer`): those of root runs, of children whose parent already settled them
+  * or is gone, or terminal for good. Such rows were written by earlier versions, which buffered every
+  * completion that found no waiter, and nothing else ever removes them.
+  *
+  * Walks `durable_buffered_signals` by primary key, {@link BUFFERED_SWEEP_PAGE} rows at a time and
+  * at most {@link BUFFERED_SWEEP_PAGES_PER_CALL} pages per call, so a large backlog drains over a
+  * few timer ticks without a long query or a big delete. A pass that reaches the end of the table
+  * rests {@link BUFFERED_SWEEP_REST_MS} before the next one. Call it every tick (the NestJS timer
+  * poller does). Skipped while draining, on a namespaced engine (a buffered signal carries no
+  * namespace, and a scoped read would report another tenant's parent as gone), and on a store
+  * without `listBufferedSignals`/`deleteBufferedSignals`. Returns how many rows it deleted.
+  */
+  async sweepBufferedSignals(now = this.clock()) {
+    const { listBufferedSignals, deleteBufferedSignals } = this.store;
+    if (!listBufferedSignals || !deleteBufferedSignals) return 0;
+    if (this.draining || this.namespace !== void 0 || this.bufferedSweepActive) return 0;
+    if (this.bufferedSweepCursor === void 0 && now - this.lastBufferedSweepEndedAt < BUFFERED_SWEEP_REST_MS) {
+      return 0;
+    }
+    this.bufferedSweepActive = true;
+    let deleted = 0;
+    try {
+      for (let page = 0; page < BUFFERED_SWEEP_PAGES_PER_CALL; page++) {
+        const rows = await listBufferedSignals.call(this.store, CHILD_TOKEN_PREFIX, this.bufferedSweepCursor, BUFFERED_SWEEP_PAGE);
+        const doomed = await unneededChildSignals(this.store, rows);
+        if (doomed.length > 0) {
+          await deleteBufferedSignals.call(this.store, doomed.map((row) => row.id));
+          deleted += doomed.length;
+        }
+        const last = rows.at(-1);
+        if (rows.length < BUFFERED_SWEEP_PAGE || !last) {
+          this.bufferedSweepCursor = void 0;
+          this.lastBufferedSweepEndedAt = now;
+          break;
+        }
+        this.bufferedSweepCursor = last.id;
+      }
+    } finally {
+      this.bufferedSweepActive = false;
+    }
+    return deleted;
+  }
+  /**
   * Register a pager hook for STRANDED runs: an in-flight run untouched past `stalledAfterMs` that is
   * either suspended with NO wake timer (wake-forever: nothing will ever re-drive it) or parked on an
   * old pending remote step with no live lease (dispatched and, most likely, lost). The timer poller
@@ -7016,7 +7222,9 @@ var WorkflowEngine = class {
           await this.deliverSignal(waiter, completion);
           return;
         }
-        if (cancelled || await this.parentHoldsCompletion(token, completion)) return;
+        if (cancelled) return;
+        const childId = token.slice(CHILD_TOKEN_PREFIX.length);
+        if (!await childCompletionNeedsBuffer(this.store, childId, completion)) return;
         await this.signal(token, completion);
         return;
       } catch (err) {
@@ -7030,24 +7238,6 @@ var WorkflowEngine = class {
     }
   }
   /**
-  * 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
@@ -7062,15 +7252,22 @@ var WorkflowEngine = class {
   startChildDeferred(workflow, input, childId, opts) {
     this.localWork.submit(`start:${childId}`, async () => {
       if (this.draining) return;
-      await this.start(workflow, input, childId, opts).catch((err) => {
+      const started = 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}`
         });
+        return void 0;
       });
+      if (started) this.redeliverFinishedChild(childId, started);
     });
   }
+  /** {@link startChildDeferred}: re-deliver the completion of a child `start` found finished. */
+  redeliverFinishedChild(childId, run) {
+    const completion = childCompletion(run);
+    if (completion) this.inBackground(this.deliverToParent(`child:${childId}`, completion));
+  }
   /**
   * Cancel a run (e.g. from the dashboard). Returns null if the run does not exist. Pass
   * `{ compensate: true }` to undo the saga first: the suspended run is resumed so its completed
@@ -8675,10 +8872,13 @@ ${run.workflowVersion}`;
           // dashboard renders the fan as one parallel group. Undefined for a lone (non-fan) child.
           parallelGroup: cmd.parallelGroup
         });
-        if (!await this.store.getRun(childId)) {
+        const existingChild = await this.store.getRun(childId);
+        if (!existingChild) {
           this.startChildDeferred(cmd.workflow, cmd.input, childId, {
             namespace: run.namespace
           });
+        } else {
+          this.redeliverFinishedChild(childId, existingChild);
         }
       } else {
         throw new Error(`remote workflow command '${cmd.kind}' is not supported yet`);
@@ -10689,6 +10889,10 @@ var CodecStateStore = class {
   compactCheckpoints;
   /** Decodes each run like {@link getRun}. Bound only when the inner store has it. */
   getRuns;
+  /** Decodes each payload like {@link takeBufferedSignal}. Bound only when the inner store has it. */
+  listBufferedSignals;
+  /** Forwarded verbatim — deletes by row id. */
+  deleteBufferedSignals;
   /** Forwarded verbatim — a waiter carries no payload. */
   listSignalWaitersByRun;
   /** Forwarded verbatim — a waiter carries no payload. */
@@ -10734,6 +10938,13 @@ var CodecStateStore = class {
     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 listBuffered = inner.listBufferedSignals;
+    if (listBuffered) this.listBufferedSignals = async (tokenPrefix, afterId, limit) => (await listBuffered.call(inner, tokenPrefix, afterId, limit)).map((row) => ({
+      ...row,
+      payload: this.dec(row.payload)
+    }));
+    const deleteBuffered = inner.deleteBufferedSignals;
+    if (deleteBuffered) this.deleteBufferedSignals = (ids) => deleteBuffered.call(inner, ids);
     const byRun = inner.listSignalWaitersByRun;
     if (byRun) this.listSignalWaitersByRun = (runIds) => byRun.call(inner, runIds);
     const hasWaiter = inner.hasSignalWaiter;
@@ -11479,20 +11690,47 @@ var InMemoryStateStore = class {
     });
   }
   bufferedSignals = /* @__PURE__ */ new Map();
+  bufferedSignalSeq = 0;
   async bufferSignal(token, payload) {
     const queue = this.bufferedSignals.get(token) ?? [];
-    queue.push(payload);
+    queue.push({
+      id: ++this.bufferedSignalSeq,
+      payload
+    });
     this.bufferedSignals.set(token, queue);
   }
   async takeBufferedSignal(token) {
     const queue = this.bufferedSignals.get(token);
     if (!queue || queue.length === 0) return null;
-    const payload = queue.shift();
+    const head = queue.shift();
     if (queue.length === 0) this.bufferedSignals.delete(token);
     return {
-      payload
+      payload: head.payload
     };
   }
+  async listBufferedSignals(tokenPrefix, afterId, limit) {
+    const after = afterId === void 0 ? 0 : Number(afterId);
+    const rows = [];
+    for (const [token, queue] of this.bufferedSignals) {
+      if (!token.startsWith(tokenPrefix)) continue;
+      for (const { id, payload } of queue) {
+        if (id > after) rows.push({
+          id: String(id),
+          token,
+          payload
+        });
+      }
+    }
+    return rows.sort((a, b) => Number(a.id) - Number(b.id)).slice(0, limit);
+  }
+  async deleteBufferedSignals(ids) {
+    const doomed = new Set(ids.map(Number));
+    for (const [token, queue] of this.bufferedSignals) {
+      const kept = queue.filter((row) => !doomed.has(row.id));
+      if (kept.length === 0) this.bufferedSignals.delete(token);
+      else this.bufferedSignals.set(token, kept);
+    }
+  }
   /** `id -> row`, so {@link removeBufferedEvent} can delete an exact row regardless of iteration
   *  order — mirrors the SQL stores' PK-by-id delete. */
   bufferedEvents = /* @__PURE__ */ new Map();