@dudousxd/nestjs-durable-core 0.29.1 → 0.31.0

package/dist/index.d.ts

@@ -1,5 +1,166 @@
 import { z } from 'zod';
 
+/**
+ * Flow control for remote steps. A queue caps how much work `ctx.call(step, input, { queue })`
+ * admits at once — a concurrency limit and/or a fixed-window rate limit. When a call can't be
+ * admitted it doesn't dispatch: the run re-suspends with a near-future wake time, and the timer
+ * poller re-tries admission later — so flow control is durable (survives crashes) without holding
+ * the run in memory.
+ *
+ * Accounting is per engine instance (the DBOS `workerConcurrency` tier): correct for the common
+ * single-orchestrator deployment. Global, cross-instance limits would need a durable counter in the
+ * store — a deliberate follow-up, not built here.
+ *
+ * Beyond raw caps, the controller can admit contended slots by PRIORITY and by per-KEY FAIRNESS
+ * (round-robin), so a single noisy key/tenant can't monopolize the concurrency budget. This is the
+ * DISPATCH/admission layer — it never touches workflow replay (engine positional logic). Default
+ * behaviour is unchanged FIFO when neither priority nor fairness is configured/passed.
+ *
+ * Design (vs Temporal/Inngest/DBOS): Temporal task queues are FIFO with separate priority levels;
+ * Inngest concurrency keys + throttle give per-key fairness; DBOS queues are FIFO with a
+ * `workerConcurrency` cap. We fold both knobs into the same in-process admission gate: an optional
+ * per-call `priority` (higher first) and an optional queue-level `fairness: 'key'` (round-robin by
+ * the per-call `key`). Because blocked calls re-suspend durably and retry independently (there is no
+ * resident FIFO list to reorder), the controller remembers the set of WAITERS that asked-and-were-
+ * blocked, and on a later retry only admits the one that is rightful-next under the policy.
+ */
+interface QueueConfig {
+    /** Queue name, referenced by `ctx.call(step, input, { queue: name })`. */
+    name: string;
+    /** Max steps in flight at once for this queue (this instance). Omit for unlimited. */
+    concurrency?: number;
+    /** Fixed-window rate limit: at most `limit` admissions per `periodMs`. Omit for unlimited. */
+    rateLimit?: {
+        limit: number;
+        periodMs: number;
+    };
+    /** Delay (ms) before a concurrency-blocked call re-checks for a free slot. Default 1000. */
+    retryMs?: number;
+    /**
+     * Fairness policy for a contended concurrency slot. `'key'` round-robins across distinct per-call
+     * keys (the least-recently-served key wins the next slot), so one key can't monopolize the budget.
+     * Omit (or `'fifo'`) for plain first-come ordering. Priority always wins over fairness; fairness
+     * only breaks ties within the same priority.
+     */
+    fairness?: 'fifo' | 'key';
+    /**
+     * Arrival-order tiebreak among otherwise-equal waiters (same priority, same fairness rank).
+     * `'fifo'` (default) admits the earliest arrival; `'lifo'` admits the most recent (a stack). Orthogonal
+     * to `priority` and `fairness` — those still win first; this only breaks their ties.
+     */
+    order?: 'fifo' | 'lifo';
+}
+/**
+ * Per-call admission hints. All optional — omitting them keeps the legacy FIFO behaviour.
+ * - `priority`: higher is admitted first (default 0).
+ * - `key`: the fairness bucket (e.g. a tenant id) for `fairness: 'key'`.
+ * - `waiterId`: a stable id for THIS call across its retries (the engine passes the stepId), so the
+ *   controller can track it as one waiter instead of counting each retry as a new contender.
+ */
+interface AdmissionItem {
+    priority?: number | undefined;
+    key?: string | undefined;
+    waiterId?: string | undefined;
+}
+/** Admission decision: either admitted, or blocked until `retryAt` (epoch ms). */
+type Admission = {
+    ok: true;
+} | {
+    ok: false;
+    retryAt: number;
+};
+/** In-process admission controller for one {@link QueueConfig}. */
+declare class QueueController {
+    readonly config: QueueConfig;
+    private readonly clock;
+    private inFlight;
+    private windowStart;
+    private windowCount;
+    /** Registered waiters by id (only used when priority/fairness ordering is in play). */
+    private readonly waiters;
+    /** Monotonic counter stamping each newly-seen waiter for a stable FIFO tiebreak. */
+    private waiterSeq;
+    /** Per-key "last served" order for round-robin fairness — higher = more recently served. */
+    private readonly keyServed;
+    private servedTick;
+    constructor(config: QueueConfig, clock: () => number);
+    /** Whether this controller does any priority/fairness ordering (else it's a plain FIFO gate). */
+    private get ordered();
+    /**
+     * Try to admit one unit of work. On `ok`, the caller has taken a concurrency slot and must call
+     * {@link release} when the step settles. On block, `retryAt` is when admission may next succeed.
+     *
+     * `item` carries optional priority/fairness hints; omitting it is the legacy FIFO path. When
+     * ordering is configured (or a priority is given), a blocked call REGISTERS as a waiter and is only
+     * admitted on a later retry once it is the rightful next under (priority desc, fairness, FIFO).
+     */
+    tryAdmit(item?: AdmissionItem): Admission;
+    /** Release a concurrency slot taken by a successful {@link tryAdmit}. */
+    release(): void;
+    /** Track (or refresh) a blocked call as a waiter; its FIFO seq is stamped only on first sight. */
+    private register;
+    /**
+     * Is the calling item the best candidate among all registered waiters? Ordering, best first:
+     *   1. higher `priority`;
+     *   2. fairness: with `fairness: 'key'`, the least-recently-served key wins (round-robin);
+     *   3. earliest registration (FIFO) — stable tiebreak.
+     * A bare item (no waiterId) is compared on its hints directly.
+     */
+    private isNext;
+    /** Strict "a should be admitted before b" comparison under the active policy. */
+    private better;
+    /** Last-served tick for a key (0 = never served, so an unseen key is admitted before a busy one). */
+    private servedOf;
+}
+
+/**
+ * Pluggable backend for the remote-step flow-control gate (`ctx.call(step, input, { queue })`). The
+ * engine asks it whether a queued call may be admitted now (concurrency / rate / ordering) and tells
+ * it when an admitted slot is released.
+ *
+ * The default {@link InMemoryAdmissionBackend} keeps per-instance counts — correct for a single
+ * orchestrator. Swap in a store/Redis-backed backend to make the caps and ordering GLOBAL across
+ * engine replicas (so `concurrency: 5` means 5 in-flight across the whole fleet, not 5 per pod).
+ *
+ * `tryAdmit`/`release` are async so a global backend can do its atomic round-trip; the in-memory one
+ * resolves synchronously. An UNREGISTERED queue name is treated as ungated (admits immediately) — the
+ * engine only tracks/releases a slot for a registered queue.
+ */
+interface AdmissionBackend {
+    /** Register (or replace) a queue's config. Called from `engine.registerQueue`. */
+    register(config: QueueConfig): void;
+    /** Whether `queue` is registered (gated). The engine only tracks/releases a slot for a gated queue. */
+    handles(queue: string): boolean;
+    /** May a call on `queue` take a slot now? On `ok`, the caller holds a slot until {@link release}. */
+    tryAdmit(queue: string, item: AdmissionItem): Promise<Admission>;
+    /**
+     * Release the slot granted by {@link tryAdmit} for `queue`. `slotId` is the admitted item's
+     * `waiterId` (the engine's stepId), so a lease-based backend can drop the exact slot; an in-process
+     * counter ignores it.
+     */
+    release(queue: string, slotId: string): Promise<void>;
+    /**
+     * Optional: subscribe to "a slot just freed on `queue`" events (e.g. a fleet-wide pub/sub). The
+     * engine uses it to wake its admission-blocked runs early instead of waiting for their retry tick.
+     * A backend without it falls back to retry-tick polling. Fired best-effort across the fleet.
+     */
+    onFreed?(handler: (queue: string) => void): void;
+}
+/**
+ * Default admission backend: one in-process {@link QueueController} per registered queue. Caps and
+ * waiter ordering are per engine instance (see {@link QueueConfig}). Preserves the exact pre-backend
+ * behaviour — the engine used to hold these controllers directly.
+ */
+declare class InMemoryAdmissionBackend implements AdmissionBackend {
+    private readonly clock;
+    private readonly controllers;
+    constructor(clock: () => number);
+    register(config: QueueConfig): void;
+    handles(queue: string): boolean;
+    tryAdmit(queue: string, item: AdmissionItem): Promise<Admission>;
+    release(queue: string, _slotId: string): Promise<void>;
+}
+
 /**
  * Parse a human duration to milliseconds. Accepts a number (already ms) or a string like
  * `'500ms'`, `'30s'`, `'15m'`, `'2h'`, `'7d'`, `'7 days'`.
@@ -77,6 +238,13 @@ interface WorkflowRun {
     tags?: string[] | undefined;
     /** Typed, queryable run data (e.g. `{ amount: 200, tier: 'pro' }`) — see {@link RunQuery.attributes}. */
     searchAttributes?: SearchAttributes | undefined;
+    /**
+     * Dispatch priority for a REMOTE run (one advanced by a {@link WorkflowExecutor} over a broker):
+     * carried onto each {@link WorkflowTask} so an urgent child workflow can jump ahead of enqueued
+     * lower-priority ones at the worker. Higher wins; absent = unprioritised. Best-effort ordering, not
+     * durable state required for correctness — a transport without priority support ignores it.
+     */
+    priority?: number | undefined;
     createdAt: Date;
     updatedAt: Date;
 }
@@ -226,6 +394,14 @@ interface StateStore {
     createRun(run: WorkflowRun): Promise<void>;
     updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    /**
+     * Hard-delete a run and all of its rows — the run plus its checkpoints, signal waiters, and
+     * normalized search-attribute rows. Unlike a cancelled run (which stays as terminal history), a
+     * deleted run is GONE: it no longer appears in {@link getRun} or {@link listRuns}. This removes
+     * exactly the one run — the engine's {@link WorkflowEngine.deleteRun} handles the child cascade.
+     * No-op if the run doesn't exist. (Token-keyed buffered signals are transient and left alone.)
+     */
+    deleteRun(runId: string): Promise<void>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     /**
      * Persist a checkpoint and advance the run atomically. Durable semantics depend on this
@@ -370,6 +546,13 @@ interface RemoteTask {
      * so failover is symmetric without the worker choosing a transport. Absent for a single transport.
      */
     transport?: string | undefined;
+    /**
+     * Admission priority carried through to the broker (BullMQ job `priority`) so a transport that
+     * supports priority ordering lets an urgent task jump ahead of already-enqueued lower-priority
+     * ones at the worker. Mirrors the per-call `priority` from `ctx.call(..., { priority })`. Higher
+     * wins; absent means default/unprioritised. Transports without priority support ignore it.
+     */
+    priority?: number | undefined;
     attempt: number;
 }
 interface StepResult {
@@ -411,6 +594,12 @@ interface WorkflowTask {
     /** Id of the transport this task was dispatched on (pool failover) — see {@link NamedTransport}. */
     transport?: string;
     traceparent?: string;
+    /**
+     * Admission priority carried to the broker (BullMQ job `priority`) so an urgent child workflow can
+     * jump ahead of already-enqueued lower-priority ones at the worker. Higher wins; absent means
+     * default/unprioritised. Transports without priority support ignore it.
+     */
+    priority?: number | undefined;
     attempt: number;
 }
 /** One resolved durable op in a run's history — a superset of a completed {@link StepCheckpoint}. */
@@ -616,6 +805,21 @@ type ControlMessage = {
     runId: string;
 });
 type BackoffStrategy = 'fixed' | 'exp';
+/**
+ * Options for `ctx.child` / `ctx.startChild`. A bare string passed instead is shorthand for
+ * `{ childId }`, so the existing `ctx.child(ref, input, 'my-id')` form keeps working.
+ */
+interface ChildCallOptions {
+    /** Deterministic child run id; defaults to one derived from the parent run id + call position. */
+    childId?: string | undefined;
+    /**
+     * Dispatch priority for a REMOTE child workflow — stamped on the child run and carried onto every
+     * {@link WorkflowTask} dispatched to advance it, so an urgent child can jump ahead of enqueued
+     * lower-priority ones at the worker. Higher wins; absent = unprioritised. Ignored for an in-process
+     * (TS class) child, which runs in the engine and never hits a broker queue.
+     */
+    priority?: number | undefined;
+}
 interface StepOptions {
     /** Max attempts before the step (and run) fails. */
     retries?: number;
@@ -773,8 +977,8 @@ interface WorkflowCtx {
      * Pass the child's **class** (`ctx.child(ShippingWorkflow, input)`) for a typed input + result; pass
      * a **string** name for a cross-runtime child (e.g. a Python workflow) where there's no class.
      */
-    child<C extends WorkflowClass>(workflow: C, input: WorkflowInputOf<C>, childId?: string): Promise<WorkflowOutputOf<C>>;
-    child<TOutput>(workflow: string, input: unknown, childId?: string): Promise<TOutput>;
+    child<C extends WorkflowClass>(workflow: C, input: WorkflowInputOf<C>, options?: string | ChildCallOptions): Promise<WorkflowOutputOf<C>>;
+    child<TOutput>(workflow: string, input: unknown, options?: string | ChildCallOptions): Promise<TOutput>;
     /**
      * Start a child workflow **fire-and-forget**: dispatches it once (checkpointed, replay-safe) and
      * returns its run id immediately — the parent keeps running instead of suspending. Use it to kick
@@ -782,8 +986,8 @@ interface WorkflowCtx {
      * the ids, then later `await ctx.child(...)` each with the same id to join (the start is idempotent
      * by id, so the child runs exactly once). Class or string ref, like {@link child}.
      */
-    startChild<C extends WorkflowClass>(workflow: C, input: WorkflowInputOf<C>, childId?: string): Promise<string>;
-    startChild(workflow: string, input: unknown, childId?: string): Promise<string>;
+    startChild<C extends WorkflowClass>(workflow: C, input: WorkflowInputOf<C>, options?: string | ChildCallOptions): Promise<string>;
+    startChild(workflow: string, input: unknown, options?: string | ChildCallOptions): Promise<string>;
     /**
      * Pause the run at this point until a human resumes it from the dashboard (or
      * `engine.continue(runId)`). Records a visible `pending` checkpoint so the breakpoint shows up
@@ -987,113 +1191,6 @@ declare class EventAccumulators {
     private batch;
 }
 
-/**
- * Flow control for remote steps. A queue caps how much work `ctx.call(step, input, { queue })`
- * admits at once — a concurrency limit and/or a fixed-window rate limit. When a call can't be
- * admitted it doesn't dispatch: the run re-suspends with a near-future wake time, and the timer
- * poller re-tries admission later — so flow control is durable (survives crashes) without holding
- * the run in memory.
- *
- * Accounting is per engine instance (the DBOS `workerConcurrency` tier): correct for the common
- * single-orchestrator deployment. Global, cross-instance limits would need a durable counter in the
- * store — a deliberate follow-up, not built here.
- *
- * Beyond raw caps, the controller can admit contended slots by PRIORITY and by per-KEY FAIRNESS
- * (round-robin), so a single noisy key/tenant can't monopolize the concurrency budget. This is the
- * DISPATCH/admission layer — it never touches workflow replay (engine positional logic). Default
- * behaviour is unchanged FIFO when neither priority nor fairness is configured/passed.
- *
- * Design (vs Temporal/Inngest/DBOS): Temporal task queues are FIFO with separate priority levels;
- * Inngest concurrency keys + throttle give per-key fairness; DBOS queues are FIFO with a
- * `workerConcurrency` cap. We fold both knobs into the same in-process admission gate: an optional
- * per-call `priority` (higher first) and an optional queue-level `fairness: 'key'` (round-robin by
- * the per-call `key`). Because blocked calls re-suspend durably and retry independently (there is no
- * resident FIFO list to reorder), the controller remembers the set of WAITERS that asked-and-were-
- * blocked, and on a later retry only admits the one that is rightful-next under the policy.
- */
-interface QueueConfig {
-    /** Queue name, referenced by `ctx.call(step, input, { queue: name })`. */
-    name: string;
-    /** Max steps in flight at once for this queue (this instance). Omit for unlimited. */
-    concurrency?: number;
-    /** Fixed-window rate limit: at most `limit` admissions per `periodMs`. Omit for unlimited. */
-    rateLimit?: {
-        limit: number;
-        periodMs: number;
-    };
-    /** Delay (ms) before a concurrency-blocked call re-checks for a free slot. Default 1000. */
-    retryMs?: number;
-    /**
-     * Fairness policy for a contended concurrency slot. `'key'` round-robins across distinct per-call
-     * keys (the least-recently-served key wins the next slot), so one key can't monopolize the budget.
-     * Omit (or `'fifo'`) for plain first-come ordering. Priority always wins over fairness; fairness
-     * only breaks ties within the same priority.
-     */
-    fairness?: 'fifo' | 'key';
-}
-/**
- * Per-call admission hints. All optional — omitting them keeps the legacy FIFO behaviour.
- * - `priority`: higher is admitted first (default 0).
- * - `key`: the fairness bucket (e.g. a tenant id) for `fairness: 'key'`.
- * - `waiterId`: a stable id for THIS call across its retries (the engine passes the stepId), so the
- *   controller can track it as one waiter instead of counting each retry as a new contender.
- */
-interface AdmissionItem {
-    priority?: number | undefined;
-    key?: string | undefined;
-    waiterId?: string | undefined;
-}
-/** Admission decision: either admitted, or blocked until `retryAt` (epoch ms). */
-type Admission = {
-    ok: true;
-} | {
-    ok: false;
-    retryAt: number;
-};
-/** In-process admission controller for one {@link QueueConfig}. */
-declare class QueueController {
-    readonly config: QueueConfig;
-    private readonly clock;
-    private inFlight;
-    private windowStart;
-    private windowCount;
-    /** Registered waiters by id (only used when priority/fairness ordering is in play). */
-    private readonly waiters;
-    /** Monotonic counter stamping each newly-seen waiter for a stable FIFO tiebreak. */
-    private waiterSeq;
-    /** Per-key "last served" order for round-robin fairness — higher = more recently served. */
-    private readonly keyServed;
-    private servedTick;
-    constructor(config: QueueConfig, clock: () => number);
-    /** Whether this controller does any priority/fairness ordering (else it's a plain FIFO gate). */
-    private get ordered();
-    /**
-     * Try to admit one unit of work. On `ok`, the caller has taken a concurrency slot and must call
-     * {@link release} when the step settles. On block, `retryAt` is when admission may next succeed.
-     *
-     * `item` carries optional priority/fairness hints; omitting it is the legacy FIFO path. When
-     * ordering is configured (or a priority is given), a blocked call REGISTERS as a waiter and is only
-     * admitted on a later retry once it is the rightful next under (priority desc, fairness, FIFO).
-     */
-    tryAdmit(item?: AdmissionItem): Admission;
-    /** Release a concurrency slot taken by a successful {@link tryAdmit}. */
-    release(): void;
-    /** Track (or refresh) a blocked call as a waiter; its FIFO seq is stamped only on first sight. */
-    private register;
-    /**
-     * Is the calling item the best candidate among all registered waiters? Ordering, best first:
-     *   1. higher `priority`;
-     *   2. fairness: with `fairness: 'key'`, the least-recently-served key wins (round-robin);
-     *   3. earliest registration (FIFO) — stable tiebreak.
-     * A bare item (no waiterId) is compared on its hints directly.
-     */
-    private isNext;
-    /** Strict "a should be admitted before b" comparison under the active policy. */
-    private better;
-    /** Last-served tick for a key (0 = never served, so an unseen key is admitted before a busy one). */
-    private servedOf;
-}
-
 type WorkflowFn = (ctx: WorkflowCtx, input: unknown) => Promise<unknown>;
 /** Options for {@link WorkflowEngine.start}. */
 interface StartOptions {
@@ -1101,6 +1198,11 @@ interface StartOptions {
     tags?: string[] | undefined;
     /** Typed, queryable run data stamped on the run (e.g. `{ amount: 200, tier: 'pro' }`). */
     searchAttributes?: SearchAttributes | undefined;
+    /**
+     * Dispatch priority for a remote run — stamped on the run and carried onto every {@link WorkflowTask}
+     * the engine dispatches to advance it. Higher wins; absent = unprioritised. See {@link WorkflowRun.priority}.
+     */
+    priority?: number | undefined;
 }
 /**
  * Serialize runs of a workflow that share a key — a durable, FIFO mutex (e.g. one pipeline per base).
@@ -1139,6 +1241,12 @@ interface WorkflowEngineDeps {
     controlPlane?: ControlPlane | undefined;
     /** Epoch-ms clock; injectable for tests. Defaults to `Date.now`. */
     clock?: (() => number) | undefined;
+    /**
+     * Flow-control admission backend for `ctx.call(step, input, { queue })`. Defaults to an in-process
+     * {@link InMemoryAdmissionBackend} (per-instance caps). Inject a store/Redis-backed backend to make
+     * concurrency / rate-limit / ordering GLOBAL across engine replicas.
+     */
+    admission?: AdmissionBackend | undefined;
     /** Unique id for this engine instance, used for recovery leases. Defaults to a random id. */
     instanceId?: string | undefined;
     /** Recovery lease duration in ms — how long this instance owns a run it picked up. Default 30s. */
@@ -1261,8 +1369,10 @@ declare class WorkflowEngine {
     private readonly updateValidators;
     /** Runs being cancelled WITH saga compensation — see `cancel({ compensate: true })`. */
     private readonly cancelRequested;
-    /** Flow-control queues for remote steps, keyed by name (see {@link registerQueue}). */
-    private readonly queues;
+    /** Flow-control admission backend for remote steps (see {@link registerQueue}). */
+    private readonly admission;
+    /** Runs on THIS instance blocked on admission, by queue — woken early on a freed-slot signal. */
+    private readonly queueWaiters;
     /** Which queue a dispatched step took a slot from, by stepId — so the result can release it. */
     private readonly stepQueue;
     /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
@@ -1501,6 +1611,17 @@ declare class WorkflowEngine {
     cancelWhere(filter: Omit<RunQuery, 'limit' | 'offset'>, opts?: {
         compensate?: boolean;
     }): Promise<RunResult[]>;
+    /**
+     * 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).
+     */
+    deleteRun(runId: string): Promise<number>;
     /**
      * 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>`
@@ -1619,6 +1740,12 @@ declare class WorkflowEngine {
      * A no-op if the checkpoint isn't `pending` (a duplicate or late delivery).
      */
     private completeRemoteResult;
+    /**
+     * A slot freed on `queue` (a fleet-wide signal): resume this instance's runs blocked on it so they
+     * re-contend now instead of at their retry tick. Snapshot-and-clear — a run still blocked after the
+     * retry re-registers itself, and one that's gone (cancelled/admitted) is dropped. Best-effort.
+     */
+    private wakeQueueWaiters;
     /** Release the flow-control slot a dispatched step held (if any), by its stepId. */
     private releaseQueueSlot;
     /** In-memory await path for a remote step with a liveness `timeoutMs` (re-dispatch on timeout). */
@@ -1789,6 +1916,7 @@ declare class CodecStateStore implements StateStore {
     createRun(run: WorkflowRun): Promise<void>;
     updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    deleteRun(runId: string): Promise<void>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
     transaction<T>(work: (tx: {
@@ -2025,6 +2153,7 @@ declare class InMemoryStateStore implements StateStore {
     createRun(run: WorkflowRun): Promise<void>;
     updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    deleteRun(runId: string): Promise<void>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
     listIncompleteRuns(): Promise<WorkflowRun[]>;
@@ -2080,4 +2209,4 @@ declare class InMemoryTransport implements Transport, ControlPlane {
     onControl(handler: (msg: ControlMessage) => void): void;
 }
 
-export { type AccumulatorHost, type Admission, type AdmissionItem, type AttributeFilter, type AttributeOp, type BackoffStrategy, CodecStateStore, ContinueAsNew, type ControlMessage, type ControlPlane, DURABLE_OPTIONS, type DurableWebhook, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, type RemoteStepConfig, type RemoteStepDef, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, type RunAttributeRow, type RunDispatcher, type RunQuery, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StateStore, type StepCheckpoint, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepResult, type StoreTransaction, type SubProcessHandle, TRANSPORT, type Transport, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerHeartbeat, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRun, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, applyAttributeQuery, attributeColumnFor, attributeOperand, breakpointToken, collectMetrics, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, remoteStep, runSchedules, runStepHandler, scheduledRunId, sqlComparator, stepId, workflowName };
+export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AttributeFilter, type AttributeOp, type BackoffStrategy, type ChildCallOptions, CodecStateStore, ContinueAsNew, type ControlMessage, type ControlPlane, DURABLE_OPTIONS, type DurableWebhook, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, type RemoteStepConfig, type RemoteStepDef, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, type RunAttributeRow, type RunDispatcher, type RunQuery, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StateStore, type StepCheckpoint, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepResult, type StoreTransaction, type SubProcessHandle, TRANSPORT, type Transport, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerHeartbeat, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRun, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, applyAttributeQuery, attributeColumnFor, attributeOperand, breakpointToken, collectMetrics, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, remoteStep, runSchedules, runStepHandler, scheduledRunId, sqlComparator, stepId, workflowName };