@dudousxd/nestjs-durable-core 0.29.0 → 0.30.0

package/dist/index.cjs

@@ -275,6 +275,31 @@ async function runStepHandler(task, handler) {
 __name(runStepHandler, "runStepHandler");
 
 // src/checkpoints.ts
+function nonEmptyEvents(events) {
+  return events && events.length > 0 ? events : void 0;
+}
+__name(nonEmptyEvents, "nonEmptyEvents");
+function stepCheckpoint(p) {
+  return {
+    runId: p.runId,
+    seq: p.seq,
+    name: p.name,
+    kind: p.kind,
+    stepId: stepId(p.runId, p.seq),
+    status: p.status,
+    input: p.input,
+    output: p.output,
+    error: p.error,
+    events: nonEmptyEvents(p.events),
+    attempts: p.attempts,
+    workerGroup: p.workerGroup,
+    wakeAt: p.wakeAt,
+    enqueuedAt: p.enqueuedAt,
+    startedAt: p.startedAt,
+    finishedAt: p.finishedAt
+  };
+}
+__name(stepCheckpoint, "stepCheckpoint");
 function instantCheckpoint(p) {
   const at = /* @__PURE__ */ new Date();
   return {
@@ -683,6 +708,93 @@ var QueueController = class {
   }
 };
 
+// src/singleton-gate.ts
+var SINGLETON_RETRY_MS = 1e3;
+var SINGLETON_RETRY_JITTER_MS = 250;
+var SingletonGate = class {
+  static {
+    __name(this, "SingletonGate");
+  }
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** The tag a singleton run carries, so the gate can find others sharing its key. */
+  tag(cfg, input) {
+    return `singleton:${cfg.key(input)}`;
+  }
+  /** Next wake time for a gated run: the base retry delay jittered to avoid a wakeup stampede. */
+  retryWakeAt() {
+    return this.deps.clock() + SINGLETON_RETRY_MS + Math.floor((Math.random() * 2 - 1) * SINGLETON_RETRY_JITTER_MS);
+  }
+  /**
+  * Reject a start that would grow the same-key backlog past `limit + maxQueueDepth` (counting
+  * `pending`/`running`/`suspended` runs sharing the key in one scan). No-op when no `maxQueueDepth`
+  * is configured.
+  */
+  async assertCapacity(workflow, cfg, input) {
+    if (cfg.maxQueueDepth == null) return;
+    const cap = (cfg.limit ?? 1) + cfg.maxQueueDepth;
+    const queued = await this.deps.store.listRuns({
+      tag: this.tag(cfg, input),
+      workflow,
+      statuses: [
+        "pending",
+        "running",
+        "suspended"
+      ]
+    });
+    if (queued.length >= cap) {
+      throw new SingletonQueueFullError(workflow, cfg.key(input), cfg.maxQueueDepth);
+    }
+  }
+  /**
+  * Whether `run` may run now under its key: it's among the `limit` oldest in-flight (running or
+  * suspended) runs sharing the key, by `(createdAt, id)` order. A consistent store gives every
+  * instance the same ordering, so admission is race-free + FIFO.
+  */
+  async admit(run, cfg) {
+    const inflight = (await this.deps.store.listRuns({
+      tag: this.tag(cfg, run.input),
+      workflow: run.workflow,
+      statuses: [
+        "running",
+        "suspended"
+      ]
+    })).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
+    const idx = inflight.findIndex((r) => r.id === run.id);
+    return idx >= 0 && idx < (cfg.limit ?? 1);
+  }
+  /**
+  * Notify-on-release: a singleton run settled (freeing a slot), so dispatch the oldest gated
+  * (`suspended` + same tag) waiters now instead of waiting for their ~1s retry timer. Each re-checks
+  * admission in the executor and runs only if it actually wins a slot, so FIFO/race-free guarantees
+  * hold; the durable timer remains the cross-instance/crash fallback.
+  */
+  async wakeNext(settled) {
+    const cfg = this.deps.configFor(settled);
+    if (!cfg) return;
+    const tag = settled.tags?.find((t) => t.startsWith("singleton:"));
+    if (!tag) return;
+    const gated = (await this.deps.store.listRuns({
+      tag,
+      workflow: settled.workflow,
+      statuses: [
+        "suspended"
+      ]
+    })).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
+    for (const next of gated.slice(0, cfg.limit ?? 1)) {
+      if (next.wakeAt != null) {
+        await this.deps.store.updateRun(next.id, {
+          wakeAt: void 0,
+          updatedAt: /* @__PURE__ */ new Date()
+        }).catch(() => void 0);
+      }
+      this.deps.dispatch(next.id);
+    }
+  }
+};
+
 // src/transport-pool.ts
 var TransportPool = class {
   static {
@@ -1213,10 +1325,6 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
 __name(createWorkflowCtx, "createWorkflowCtx");
 
 // src/engine.ts
-var SINGLETON_RETRY_MS = 1e3;
-var SINGLETON_RETRY_JITTER_MS = 250;
-var singletonRetryWakeAt = /* @__PURE__ */ __name((nowMs) => nowMs + SINGLETON_RETRY_MS + Math.floor((Math.random() * 2 - 1) * SINGLETON_RETRY_JITTER_MS), "singletonRetryWakeAt");
-var singletonTag = /* @__PURE__ */ __name((cfg, input) => `singleton:${cfg.key(input)}`, "singletonTag");
 function mergeTags(staticTags, runTags) {
   if (!staticTags?.length && !runTags?.length) return void 0;
   return [
@@ -1266,6 +1374,8 @@ var WorkflowEngine = class {
   trackStepStart;
   /** Where a freshly-started run executes — in-process by default (see {@link RunDispatcher}). */
   runDispatcher;
+  /** Per-key serialization for singleton workflows (admission, back-pressure, notify-on-release). */
+  singletons;
   /** Every registered workflow, keyed by `name@version` — so old versions stay runnable. */
   workflows = /* @__PURE__ */ new Map();
   /** The newest registered version per workflow name — used to `start` new runs. */
@@ -1323,6 +1433,14 @@ var WorkflowEngine = class {
       dispatch: /* @__PURE__ */ __name((runId) => queueMicrotask(() => void this.runOne(runId).catch(() => {
       })), "dispatch")
     };
+    this.singletons = new SingletonGate({
+      store: this.store,
+      clock: this.clock,
+      dispatch: /* @__PURE__ */ __name((runId) => {
+        this.runDispatcher.dispatch(runId);
+      }, "dispatch"),
+      configFor: /* @__PURE__ */ __name((run) => (this.workflows.get(versionKey(run.workflow, run.workflowVersion)) ?? this.latest.get(run.workflow))?.singleton, "configFor")
+    });
     this.pool.bind(
       async (result) => {
         const waiter = this.pending.get(result.stepId);
@@ -1573,25 +1691,10 @@ var WorkflowEngine = class {
     const now = /* @__PURE__ */ new Date();
     const tags = mergeTags(registered.tags, registered.singleton ? [
       ...opts?.tags ?? [],
-      singletonTag(registered.singleton, input)
+      this.singletons.tag(registered.singleton, input)
     ] : opts?.tags);
-    const maxQueueDepth = registered.singleton?.maxQueueDepth;
-    if (registered.singleton && maxQueueDepth != null) {
-      const cfg = registered.singleton;
-      const key = cfg.key(input);
-      const cap = (cfg.limit ?? 1) + maxQueueDepth;
-      const queued = await this.store.listRuns({
-        tag: singletonTag(cfg, input),
-        workflow: name,
-        statuses: [
-          "pending",
-          "running",
-          "suspended"
-        ]
-      });
-      if (queued.length >= cap) {
-        throw new SingletonQueueFullError(name, key, maxQueueDepth);
-      }
+    if (registered.singleton) {
+      await this.singletons.assertCapacity(name, registered.singleton, input);
     }
     const run = {
       id: runId,
@@ -2050,7 +2153,7 @@ var WorkflowEngine = class {
         from: this.instanceId
       }).catch(() => void 0);
     }
-    void this.wakeNextSingletons(run).catch(() => void 0);
+    void this.singletons.wakeNext(run).catch(() => void 0);
     return {
       runId,
       status: "cancelled",
@@ -2076,6 +2179,26 @@ var WorkflowEngine = class {
     return results;
   }
   /**
+  * Hard-delete a run and its entire subtree. Unlike {@link cancel} (which marks a run `cancelled`
+  * but keeps it as history), delete REMOVES the run and all its rows (checkpoints, signal waiters,
+  * search-attribute rows) — it vanishes from {@link getRun} and {@link listRuns}. Use it to purge a
+  * finished run whose data is being deleted (e.g. a pipeline run whose result rows are cleared).
+  *
+  * Cascades depth-first via {@link getRunChildren} so children are gone before the parent (no
+  * orphaned child runs). Prefer {@link cancel} first for a live run — deleting one mid-flight orphans
+  * its worker (its next checkpoint write fails). Returns the number of runs deleted (0 if absent).
+  */
+  async deleteRun(runId) {
+    const run = await this.store.getRun(runId);
+    if (!run) return 0;
+    let deleted = 0;
+    for (const childId of await this.getRunChildren(runId)) {
+      deleted += await this.deleteRun(childId);
+    }
+    await this.store.deleteRun(runId);
+    return deleted + 1;
+  }
+  /**
   * Cascade cancellation to a run's children — both awaited (`ctx.child`, found via its live
   * `child:<id>` waiter) and fire-and-forget (`ctx.startChild`, found via its `spawn:<id>`
   * checkpoint). Recursive, so a whole subtree is cancelled; the terminal guard in `cancel` stops it
@@ -2157,21 +2280,19 @@ var WorkflowEngine = class {
   */
   async persistStepEvent(event) {
     const startedAt = new Date(event.startedAt);
-    const events = event.events && event.events.length > 0 ? event.events : void 0;
     if (event.phase === "running") {
-      await this.store.saveCheckpoint({
+      await this.store.saveCheckpoint(stepCheckpoint({
         runId: event.runId,
         seq: event.seq,
         name: event.name,
         kind: "local",
-        stepId: stepId(event.runId, event.seq),
         status: "running",
-        events,
+        events: event.events,
         attempts: 1,
         enqueuedAt: startedAt,
         startedAt,
         finishedAt: startedAt
-      });
+      }));
       this.emit({
         type: "step.started",
         runId: event.runId,
@@ -2182,21 +2303,20 @@ var WorkflowEngine = class {
       return;
     }
     const failed = event.phase === "failed";
-    await this.store.saveCheckpoint({
+    await this.store.saveCheckpoint(stepCheckpoint({
       runId: event.runId,
       seq: event.seq,
       name: event.name,
       kind: "local",
-      stepId: stepId(event.runId, event.seq),
       status: failed ? "failed" : "completed",
       output: failed ? void 0 : event.output,
       error: failed ? event.error : void 0,
-      events,
+      events: event.events,
       attempts: 1,
       enqueuedAt: startedAt,
       startedAt,
       finishedAt: event.finishedAt != null ? new Date(event.finishedAt) : /* @__PURE__ */ new Date()
-    });
+    }));
     this.emit({
       type: failed ? "step.failed" : "step.completed",
       runId: event.runId,
@@ -2216,21 +2336,20 @@ var WorkflowEngine = class {
   */
   async startStep(step) {
     if (this.trackStepStart) {
-      await this.store.saveCheckpoint({
+      await this.store.saveCheckpoint(stepCheckpoint({
         runId: step.runId,
         seq: step.seq,
         name: step.name,
         kind: step.kind,
-        stepId: stepId(step.runId, step.seq),
         status: "running",
         input: step.input,
-        events: step.events && step.events.length > 0 ? step.events : void 0,
+        events: step.events,
         attempts: step.attempts,
         workerGroup: step.workerGroup,
         enqueuedAt: step.enqueuedAt,
         startedAt: step.startedAt,
         finishedAt: step.startedAt
-      });
+      }));
     }
     this.emit({
       type: "step.started",
@@ -2242,22 +2361,21 @@ var WorkflowEngine = class {
   }
   /** Checkpoint a finished step and announce it — the two things that must always happen together. */
   async completeStep(step) {
-    await this.store.saveCheckpoint({
+    await this.store.saveCheckpoint(stepCheckpoint({
       runId: step.runId,
       seq: step.seq,
       name: step.name,
       kind: step.kind,
-      stepId: stepId(step.runId, step.seq),
       status: "completed",
       input: step.input,
       output: step.output,
-      events: step.events && step.events.length > 0 ? step.events : void 0,
+      events: step.events,
       attempts: step.attempts,
       workerGroup: step.workerGroup,
       enqueuedAt: step.enqueuedAt,
       startedAt: step.startedAt,
       finishedAt: /* @__PURE__ */ new Date()
-    });
+    }));
     this.emit({
       type: "step.completed",
       runId: step.runId,
@@ -2271,22 +2389,21 @@ var WorkflowEngine = class {
   }
   /** Checkpoint a step that failed terminally, so the failure point is visible (not just the run). */
   async failStep(step) {
-    await this.store.saveCheckpoint({
+    await this.store.saveCheckpoint(stepCheckpoint({
       runId: step.runId,
       seq: step.seq,
       name: step.name,
       kind: step.kind,
-      stepId: stepId(step.runId, step.seq),
       status: "failed",
       input: step.input,
       error: step.error,
-      events: step.events && step.events.length > 0 ? step.events : void 0,
+      events: step.events,
       attempts: step.attempts,
       workerGroup: step.workerGroup,
       enqueuedAt: step.enqueuedAt,
       startedAt: step.startedAt,
       finishedAt: /* @__PURE__ */ new Date()
-    });
+    }));
     this.emit({
       type: "step.failed",
       runId: step.runId,
@@ -2298,55 +2415,6 @@ var WorkflowEngine = class {
       durationMs: Date.now() - step.startedAt.getTime()
     });
   }
-  /**
-  * Whether `run` may run now under its singleton key: it's among the `limit` oldest in-flight runs
-  * (running or suspended) sharing the key, by `(createdAt, id)` order. A consistent store gives every
-  * instance the same ordering, so admission is race-free + FIFO.
-  */
-  async admitSingleton(run, cfg) {
-    const tag = singletonTag(cfg, run.input);
-    const inflight = (await this.store.listRuns({
-      tag,
-      workflow: run.workflow,
-      statuses: [
-        "running",
-        "suspended"
-      ]
-    })).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
-    const idx = inflight.findIndex((r) => r.id === run.id);
-    return idx >= 0 && idx < (cfg.limit ?? 1);
-  }
-  /**
-  * Notify-on-release: a singleton run just settled (freeing a slot), so wake the gated waiters that
-  * can now be admitted — immediately, instead of letting them sleep until their ~1s retry timer.
-  * Dispatches up to `limit` of the oldest gated (`suspended` + same singleton tag) waiters by
-  * `(createdAt, id)`; each re-checks admission in `runExecution` and runs only if it actually wins a
-  * slot, so this never breaks the FIFO + race-free guarantees (the durable timer remains the
-  * cross-instance / crash fallback — this just removes the poll latency on the happy path).
-  */
-  async wakeNextSingletons(settled) {
-    const registered = this.workflows.get(versionKey(settled.workflow, settled.workflowVersion)) ?? this.latest.get(settled.workflow);
-    const cfg = registered?.singleton;
-    if (!cfg) return;
-    const tag = settled.tags?.find((t) => t.startsWith("singleton:"));
-    if (!tag) return;
-    const gated = (await this.store.listRuns({
-      tag,
-      workflow: settled.workflow,
-      statuses: [
-        "suspended"
-      ]
-    })).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
-    for (const next of gated.slice(0, cfg.limit ?? 1)) {
-      if (next.wakeAt != null) {
-        await this.store.updateRun(next.id, {
-          wakeAt: void 0,
-          updatedAt: /* @__PURE__ */ new Date()
-        }).catch(() => void 0);
-      }
-      this.runDispatcher.dispatch(next.id);
-    }
-  }
   async execute(run, fn) {
     const registered = this.workflows.get(versionKey(run.workflow, run.workflowVersion));
     const lockNow = this.clock();
@@ -2365,7 +2433,7 @@ var WorkflowEngine = class {
     try {
       const result = registered?.remote ? await this.runRemoteExecution(run, registered) : await this.runExecution(run, fn, registered);
       if (registered?.singleton && (result.status === "completed" || result.status === "failed" || result.status === "cancelled" || result.status === "dead")) {
-        void this.wakeNextSingletons(run).catch(() => void 0);
+        void this.singletons.wakeNext(run).catch(() => void 0);
       }
       return result;
     } finally {
@@ -2378,6 +2446,75 @@ var WorkflowEngine = class {
   * {@link runExecution}'s settle/suspend; the lease is held by {@link execute}. The result that lands
   * us back here (a remote step finished, a timer fired) goes through `resume` like any TS workflow.
   */
+  /**
+  * Apply a terminal/suspended transition once: persist the new run status, emit the matching
+  * lifecycle event, and (on completion/failure) wake a waiting parent. Both the TS and remote
+  * executors funnel their completed/failed/suspended outcomes through here so a status update can
+  * never drift from its event or `notifyParent` call. Does NOT touch the run lock — each executor
+  * keeps its own lease handling (the TS executor's `finally`, the remote path's caller).
+  */
+  async settleRun(run, outcome) {
+    const updatedAt = /* @__PURE__ */ new Date();
+    if (outcome.kind === "completed") {
+      await this.store.updateRun(run.id, {
+        status: "completed",
+        output: outcome.output,
+        error: void 0,
+        updatedAt
+      });
+      this.emit({
+        type: "run.completed",
+        runId: run.id,
+        workflow: run.workflow,
+        output: outcome.output
+      });
+      void this.notifyParent(run.id, {
+        ok: true,
+        value: outcome.output
+      });
+      return {
+        runId: run.id,
+        status: "completed",
+        output: outcome.output
+      };
+    }
+    if (outcome.kind === "failed") {
+      await this.store.updateRun(run.id, {
+        status: "failed",
+        error: outcome.error,
+        updatedAt
+      });
+      this.emit({
+        type: "run.failed",
+        runId: run.id,
+        workflow: run.workflow,
+        error: outcome.error
+      });
+      void this.notifyParent(run.id, {
+        ok: false,
+        error: outcome.error.message
+      });
+      return {
+        runId: run.id,
+        status: "failed",
+        error: outcome.error
+      };
+    }
+    await this.store.updateRun(run.id, {
+      status: "suspended",
+      wakeAt: outcome.wakeAt,
+      updatedAt
+    });
+    this.emit({
+      type: "run.suspended",
+      runId: run.id,
+      workflow: run.workflow
+    });
+    return {
+      runId: run.id,
+      status: "suspended"
+    };
+  }
   async runRemoteExecution(run, registered) {
     const remote = registered.remote;
     if (run.status === "pending") {
@@ -2392,8 +2529,8 @@ var WorkflowEngine = class {
         workflow: run.workflow
       });
     }
-    if (registered.singleton && !await this.admitSingleton(run, registered.singleton)) {
-      const wakeAt2 = singletonRetryWakeAt(this.clock());
+    if (registered.singleton && !await this.singletons.admit(run, registered.singleton)) {
+      const wakeAt2 = this.singletons.retryWakeAt();
       await this.store.updateRun(run.id, {
         status: "suspended",
         wakeAt: wakeAt2,
@@ -2438,53 +2575,19 @@ var WorkflowEngine = class {
     }
     if (decision.status === "completed") {
       await this.applyCommands(run, decision.commands);
-      await this.store.updateRun(run.id, {
-        status: "completed",
-        output: decision.output,
-        error: void 0,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-      this.emit({
-        type: "run.completed",
-        runId: run.id,
-        workflow: run.workflow,
+      return this.settleRun(run, {
+        kind: "completed",
         output: decision.output
       });
-      void this.notifyParent(run.id, {
-        ok: true,
-        value: decision.output
-      });
-      return {
-        runId: run.id,
-        status: "completed",
-        output: decision.output
-      };
     }
     if (decision.status === "failed") {
       await this.applyCommands(run, decision.commands);
-      const error = decision.error ?? {
-        message: "workflow failed"
-      };
-      await this.store.updateRun(run.id, {
-        status: "failed",
-        error,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-      this.emit({
-        type: "run.failed",
-        runId: run.id,
-        workflow: run.workflow,
-        error
-      });
-      void this.notifyParent(run.id, {
-        ok: false,
-        error: error.message
+      return this.settleRun(run, {
+        kind: "failed",
+        error: decision.error ?? {
+          message: "workflow failed"
+        }
       });
-      return {
-        runId: run.id,
-        status: "failed",
-        error
-      };
     }
     if (decision.status === "cancelled") {
       await this.applyCommands(run, decision.commands);
@@ -2498,20 +2601,10 @@ var WorkflowEngine = class {
       };
     }
     const wakeAt = await this.applyCommands(run, decision.commands);
-    await this.store.updateRun(run.id, {
-      status: "suspended",
-      wakeAt,
-      updatedAt: /* @__PURE__ */ new Date()
+    return this.settleRun(run, {
+      kind: "suspended",
+      wakeAt
     });
-    this.emit({
-      type: "run.suspended",
-      runId: run.id,
-      workflow: run.workflow
-    });
-    return {
-      runId: run.id,
-      status: "suspended"
-    };
   }
   /** The run's resolved durable ops as replay inputs: completed/failed steps + elapsed timers. */
   async remoteHistory(runId) {
@@ -2566,21 +2659,20 @@ var WorkflowEngine = class {
       if (cmd.kind === "recordStep") {
         const startedAt = cmd.startedAt != null ? new Date(cmd.startedAt) : at;
         const finishedAt = cmd.finishedAt != null ? new Date(cmd.finishedAt) : at;
-        await this.store.saveCheckpoint({
+        await this.store.saveCheckpoint(stepCheckpoint({
           runId: run.id,
           seq: cmd.seq,
           name: cmd.name,
           kind: "local",
-          stepId: id,
           status: cmd.error ? "failed" : "completed",
           output: cmd.output,
           error: cmd.error,
-          events: cmd.events && cmd.events.length > 0 ? cmd.events : void 0,
+          events: cmd.events,
           attempts: 1,
           enqueuedAt: startedAt,
           startedAt,
           finishedAt
-        });
+        }));
         this.emit({
           type: cmd.error ? "step.failed" : "step.completed",
           runId: run.id,
@@ -2591,12 +2683,11 @@ var WorkflowEngine = class {
           error: cmd.error
         });
       } else if (cmd.kind === "call") {
-        await this.store.saveCheckpoint({
+        await this.store.saveCheckpoint(stepCheckpoint({
           runId: run.id,
           seq: cmd.seq,
           name: cmd.name,
           kind: "remote",
-          stepId: id,
           status: "pending",
           input: cmd.input,
           attempts: 1,
@@ -2604,7 +2695,7 @@ var WorkflowEngine = class {
           enqueuedAt: at,
           startedAt: at,
           finishedAt: at
-        });
+        }));
         await this.pool.dispatch({
           runId: run.id,
           seq: cmd.seq,
@@ -2625,19 +2716,18 @@ var WorkflowEngine = class {
         });
       } else if (cmd.kind === "sleep") {
         const deadline = this.clock() + cmd.ms;
-        await this.store.saveCheckpoint({
+        await this.store.saveCheckpoint(stepCheckpoint({
           runId: run.id,
           seq: cmd.seq,
           name: `sleep:${cmd.seq}`,
           kind: "sleep",
-          stepId: id,
           status: "pending",
           attempts: 1,
           wakeAt: deadline,
           enqueuedAt: at,
           startedAt: at,
           finishedAt: at
-        });
+        }));
         wakeAt = wakeAt == null ? deadline : Math.min(wakeAt, deadline);
       } else if (cmd.kind === "waitSignal") {
         const buffered = await this.store.takeBufferedSignal(cmd.signal);
@@ -2687,8 +2777,8 @@ var WorkflowEngine = class {
         workflow: run.workflow
       });
     }
-    if (registered?.singleton && !await this.admitSingleton(run, registered.singleton)) {
-      const wakeAt = singletonRetryWakeAt(this.clock());
+    if (registered?.singleton && !await this.singletons.admit(run, registered.singleton)) {
+      const wakeAt = this.singletons.retryWakeAt();
       await this.store.updateRun(run.id, {
         status: "suspended",
         wakeAt,
@@ -2712,27 +2802,10 @@ var WorkflowEngine = class {
     const ctx = createWorkflowCtx(this.ctxHostFor(replay), run.id, compensations, run.workflow);
     try {
       const output = await fn(ctx, run.input);
-      await this.store.updateRun(run.id, {
-        status: "completed",
-        output,
-        error: void 0,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-      this.emit({
-        type: "run.completed",
-        runId: run.id,
-        workflow: run.workflow,
+      return this.settleRun(run, {
+        kind: "completed",
         output
       });
-      void this.notifyParent(run.id, {
-        ok: true,
-        value: output
-      });
-      return {
-        runId: run.id,
-        status: "completed",
-        output
-      };
     } catch (err) {
       if (err instanceof ContinueAsNew) {
         await this.store.updateRun(run.id, {
@@ -2784,20 +2857,10 @@ var WorkflowEngine = class {
             error: error2
           };
         }
-        await this.store.updateRun(run.id, {
-          status: "suspended",
-          wakeAt: err.wakeAt,
-          updatedAt: /* @__PURE__ */ new Date()
-        });
-        this.emit({
-          type: "run.suspended",
-          runId: run.id,
-          workflow: run.workflow
+        return this.settleRun(run, {
+          kind: "suspended",
+          wakeAt: err.wakeAt
         });
-        return {
-          runId: run.id,
-          status: "suspended"
-        };
       }
       const error = {
         message: err instanceof Error ? err.message : String(err),
@@ -2808,26 +2871,10 @@ var WorkflowEngine = class {
         if (!comp) continue;
         await this.runCompensation(run, comp);
       }
-      await this.store.updateRun(run.id, {
-        status: "failed",
-        error,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-      this.emit({
-        type: "run.failed",
-        runId: run.id,
-        workflow: run.workflow,
+      return this.settleRun(run, {
+        kind: "failed",
         error
       });
-      void this.notifyParent(run.id, {
-        ok: false,
-        error: error.message
-      });
-      return {
-        runId: run.id,
-        status: "failed",
-        error
-      };
     } finally {
       await this.store.releaseRunLock(run.id);
     }
@@ -3311,6 +3358,9 @@ var CodecStateStore = class {
   async getRun(runId) {
     return this.decRun(await this.inner.getRun(runId));
   }
+  deleteRun(runId) {
+    return this.inner.deleteRun(runId);
+  }
   async getCheckpoint(runId, seq) {
     return this.decCp(await this.inner.getCheckpoint(runId, seq));
   }
@@ -3705,6 +3755,16 @@ var InMemoryStateStore = class {
       ...run
     } : null;
   }
+  async deleteRun(runId) {
+    this.runs.delete(runId);
+    for (const [key, cp] of this.checkpoints) {
+      if (cp.runId === runId) this.checkpoints.delete(key);
+    }
+    for (const [token, waiter] of this.signalWaiters) {
+      if (waiter.runId === runId) this.signalWaiters.delete(token);
+    }
+    this.reindexAttributes(runId, void 0);
+  }
   async getCheckpoint(runId, seq) {
     const cp = this.checkpoints.get(this.key(runId, seq));
     return cp ? {