@dudousxd/nestjs-durable-core 0.46.1 → 0.48.0

package/dist/index.d.ts

@@ -161,12 +161,6 @@ declare class InMemoryAdmissionBackend implements AdmissionBackend {
     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'`.
- */
-declare function parseDuration(duration: string | number): number;
-
 /**
  * Cross-package step-name stamp. The `@Step` decorator (`@dudousxd/nestjs-durable`) writes a
  * method's derived routing name under this key; core's `ctx.step` reads it (via {@link stepNameOf})
@@ -697,6 +691,8 @@ type RunRequestKind = {
 } | {
     kind: 'listRuns';
     query: RunQuery;
+} | {
+    kind: 'workerHealth';
 } | {
     kind: 'cancel';
     runId: string;
@@ -1221,8 +1217,16 @@ interface DurableWebhook<TPayload = unknown> {
      * build your own).
      */
     readonly url?: string | undefined;
-    /** Suspend until the callback arrives, then resume with its payload. */
-    wait(): Promise<TPayload>;
+    /**
+     * Suspend until the callback arrives, then resume with its payload. Waits indefinitely by default —
+     * no compute consumed. Pass `{ timeoutMs }` to bound the wait: if the deadline passes first the call
+     * throws a `SignalTimeoutError` (catch it in the workflow to branch) — same timeout semantics as
+     * {@link WorkflowCtx.waitForSignal}. The deadline is computed once (on the first call) and persisted,
+     * so a replay reuses the recorded deadline rather than recomputing it from the current clock.
+     */
+    wait(opts?: {
+        timeoutMs?: number;
+    }): Promise<TPayload>;
 }
 /**
  * Options for a dispatched {@link WorkflowCtx.step} call. `retries`/`backoff`/`backoffMs`/
@@ -1263,6 +1267,25 @@ interface StepDispatchOpts {
      *  `retries`). Omit to wait indefinitely. Overrides the `@Step`-declared value. */
     timeoutMs?: number;
 }
+/** What a saga undo handler receives: the compensated step's original input and its result — the
+ *  ONE argument a compensation `@Step` is called with, so it's self-describing on the wire (a
+ *  Python worker sees `{ input, output }` with no side-channel lookup needed). */
+interface StepUndo<TInput, TOutput> {
+    input: TInput;
+    output: TOutput;
+}
+/**
+ * Derive a `ctx.step` compensation handler's expected argument from the ORIGINAL step's method
+ * type, so the ref form is compile-checked against the step it undoes:
+ *
+ * ```ts
+ * async cancelBooking(undo: UndoOf<FlightService['book']>) { ... }
+ * ```
+ *
+ * `...rest: never[]` pins this to a single-argument method (the shape every `@Step` handler has —
+ * see {@link StepRef}); `Awaited<R>` unwraps a `Promise<TOutput>` return down to `TOutput`.
+ */
+type UndoOf<H> = H extends (input: infer I, ...rest: never[]) => infer R ? StepUndo<I, Awaited<R>> : never;
 /**
  * The context handed to a workflow function. Every interaction with the outside world goes
  * through it so the engine can checkpoint — the workflow body itself stays deterministic.
@@ -1286,9 +1309,20 @@ interface WorkflowCtx {
      *
      * Both forms dispatch identically — a step runs on whatever worker serves that name and the run
      * suspends (zero compute) until the result lands, then resumes with it (durable, replay-safe).
-     */
-    step<TInput, TOutput>(handler: StepRef<TInput, TOutput>, input: TInput, opts?: StepDispatchOpts): Promise<TOutput>;
-    step<TOutput = unknown>(name: string, input: unknown, opts?: StepDispatchOpts): Promise<TOutput>;
+     *
+     * `opts.compensate` registers a SAGA UNDO for this call, dispatched (durably, in reverse order
+     * with every other registered undo) if the run later fails or is cancelled with
+     * `{ compensate: true }`. The undo is itself a normal `@Step` — pass its reference (compile-time
+     * checked: it must accept `StepUndo<TInput, TOutput>` of THIS call, see {@link UndoOf}) or its
+     * name for a cross-runtime undo handler. It runs on whatever worker serves that name, called with
+     * the ONE `{ input, output }` envelope — never the original handler re-invoked in-process.
+     */
+    step<TInput, TOutput>(handler: StepRef<TInput, TOutput>, input: TInput, opts?: StepDispatchOpts & {
+        compensate?: StepRef<StepUndo<TInput, TOutput>, unknown> | string;
+    }): Promise<TOutput>;
+    step<TOutput = unknown, TInput = unknown>(name: string, input: TInput, opts?: StepDispatchOpts & {
+        compensate?: StepRef<StepUndo<TInput, TOutput>, unknown> | string;
+    }): Promise<TOutput>;
     /**
      * **Exactly-once** durable step for DB work: runs `fn` and writes the step's checkpoint in ONE
      * store transaction, so the business write and the "done" marker commit atomically — a crash can
@@ -1380,9 +1414,12 @@ interface WorkflowCtx {
      * placeholders share a `parallelGroup` tag so the dashboard renders the fan-out as one group.
      *
      * `mode` (default `waitAll`): `waitAll` waits for all then throws an aggregate {@link GatherError}
-     * if any failed; `failFast` throws as soon as a failed child is seen (siblings are not cancelled in
-     * v1 — their eventual results are ignored). Empty `inputs` returns `[]` with no side effects. The
-     * wait-all / fan-out counterpart to {@link child}; parity with the Python SDK's `gather_children`.
+     * if any failed; `failFast` throws as soon as a failed child is seen, and requests cancellation of
+     * every sibling that hasn't completed yet (best-effort, plain cancel — no saga undo; a sibling
+     * mid-step only observes it at its next checkpoint, it isn't force-killed mid-synchronous-execution,
+     * so a fast sibling can still slip through and complete). Empty `inputs` returns `[]` with no side
+     * effects. The wait-all / fan-out counterpart to {@link child}; parity with the Python SDK's
+     * `gather_children`.
      */
     all<C extends WorkflowClass>(workflow: C, inputs: WorkflowInputOf<C>[], opts?: {
         mode?: 'waitAll' | 'failFast';
@@ -1462,6 +1499,16 @@ interface WorkflowCtx {
      * `ctx.upsertSearchAttributes(…)`).
      */
     upsertSearchAttributes(attrs: SearchAttributes): Promise<void>;
+    /**
+     * Run a checkpointed step **in-process** — the escape hatch from the always-dispatched {@link step}
+     * for work that must run inline in the workflow body. Like `step`, its result is a durable checkpoint
+     * (returned, not re-run, on replay); unlike `step`, the body `fn` executes here rather than on a
+     * worker, so it can carry an in-memory `compensate` callback for **sagas** — an undo the engine runs
+     * in reverse if the run later fails (see [Sagas & compensation](/docs/reliability/sagas)). `fn`
+     * receives a {@link StepLogger} for sub-process events. Prefer {@link step} for ordinary work; reach
+     * for `localStep` when you need in-process execution or a compensation.
+     */
+    localStep<TOutput>(name: string, fn: (log: StepLogger) => Promise<TOutput>, options?: StepOptions): Promise<TOutput>;
 }
 /** Result of executing or resuming a workflow run. */
 interface RunResult {
@@ -1533,15 +1580,24 @@ interface StepInvocation {
 type StepInterceptor = (invocation: StepInvocation, next: () => Promise<unknown>) => Promise<unknown>;
 
 /**
- * {@link WorkflowCtx} plus the internal in-process local-step primitive — used ONLY by the library's
- * own built-in workflows (the durable-entity runner) that need a checkpointed, in-process step the
- * public `ctx.step` (always-dispatched, no in-process placement) no longer provides. Every
- * `createWorkflowCtx` result actually carries `localStep` at runtime; this type just names the wider
- * shape for the internal consumers that need it, without widening the public {@link WorkflowCtx}.
+ * Run `fn` with `ctx` as the ambient workflow context. Engine-internal: wraps every execution of a
+ * workflow body (first run and every replay), so ambient reads inside the body see the SAME ctx the
+ * body received.
  */
-interface InternalWorkflowCtx extends WorkflowCtx {
-    localStep<TOutput>(name: string, fn: (log: StepLogger) => Promise<TOutput>, options?: StepOptions): Promise<TOutput>;
-}
+declare function runInWorkflowCtx<T>(ctx: WorkflowCtx, fn: () => T): T;
+/**
+ * The {@link WorkflowCtx} of the workflow body currently executing on this async path — or
+ * `undefined` outside one. Note a `@Step` HANDLER runs on a worker, off the body's path: it has no
+ * ambient workflow context (by design — a handler is not the workflow body).
+ */
+declare function currentWorkflowCtx(): WorkflowCtx | undefined;
+
+/**
+ * Back-compat alias of {@link WorkflowCtx}. `localStep` — the checkpointed in-process step primitive
+ * used for saga compensation — is now part of the public {@link WorkflowCtx}, so this type adds
+ * nothing; it is kept only so internal consumers (the durable-entity runner) keep compiling.
+ */
+type InternalWorkflowCtx = WorkflowCtx;
 
 /** One operation on a durable entity: mutate `state` in place and/or return a result. */
 type EntityHandler<S = unknown> = (state: S, arg: unknown) => unknown | Promise<unknown>;
@@ -2107,6 +2163,7 @@ declare class WorkflowEngine {
      */
     waitForRun(runId: string, opts?: {
         timeoutMs?: number;
+        until?: 'settled' | 'terminal';
     }): Promise<RunResult>;
     /**
      * Resume each run only if this instance can acquire its recovery lease — so when several
@@ -2275,17 +2332,80 @@ declare class WorkflowEngine {
      * Undo the registered saga compensations in reverse and settle the run `cancelled`. Shared by EVERY
      * exit path of a run with a compensating cancel in flight — whether the resumed replay returned,
      * suspended, hit continue-as-new, or threw — so a cancel is never lost just because the body didn't
-     * stop at a suspension point. Clears the in-memory cancel flag.
+     * stop at a suspension point.
+     *
+     * A dispatched compensation still in flight (or backing off a retry) needs the run to keep waiting:
+     * unlike the failure path (which is fine going `suspended` — a resumable state no different from an
+     * ordinary in-flight `ctx.step`), THIS run must stay `cancelling` — `engine.cancel`'s idempotent
+     * re-check, `waitForRun`'s non-terminal treatment, and crash recovery (`recoverIncomplete` only
+     * re-drives `running`/`cancelling` runs — a `cancelling` one with a free lease, whatever it's
+     * internally waiting on) all key off that status. So on a pending unwind this returns WITHOUT
+     * touching `status` (already `cancelling`, untouched since `engine.cancel` set it) — the in-memory
+     * cancel flag stays too, re-derived from the status on any later re-drive regardless.
      */
     private compensateAndCancel;
     /** The run body, lease held + renewed by {@link execute}. */
     private runExecution;
     /**
-     * Run one saga compensation, retried up to `compensationRetries`, emitting a `compensate:<step>`
-     * step event for its outcome so a stranded undo is visible. Never throws — a permanently-failing
-     * compensation is skipped so it can't mask the original failure.
+     * Undo every registered saga compensation in strict reverse order — the shared unwind both the
+     * run-failure path (`runExecution`'s catch) and the compensating-cancel path
+     * (`compensateAndCancel`) drive. Every entry, LOCAL or DISPATCHED, gets a NEGATIVE checkpoint seq
+     * `-(k + 1)` for its position `k` (0, 1, 2… walking the stack in reverse) — reserved space that can
+     * never collide with a body position (those start at 0), so a saga's undo trail composes onto the
+     * run's ordinary checkpoint history with no store-schema change, and shows up in run detail exactly
+     * like any other step. Deterministic because `compensations` is rebuilt identically on every replay
+     * (see `workflow-ctx.ts`), so the same comp always lands on the same negative seq across a crash +
+     * re-drive — the crash-safety this whole scheme rests on.
+     *
+     * A LOCAL entry runs in-process (`runCompensation`), which checkpoints its own outcome — completed,
+     * or failed once `compensationRetries` are exhausted — so a crash mid-unwind SKIPS an
+     * already-resolved one on the next pass instead of re-running it (and re-spending its retry budget)
+     * from attempt 1. A DISPATCHED entry is an ordinary remote-step dispatch under the hood
+     * (`dispatchCompensation`): when it needs the run to WAIT — freshly dispatched, still in flight, or
+     * backing off a durable retry — this function returns that wait signal immediately (skipping every
+     * comp after it in this pass); the CALLER decides how to represent "still unwinding" (see
+     * `compensateAndCancel`'s doc comment for why that differs between the two callers). Either way, the
+     * run resumes later exactly like any other dispatched step: `completeRemoteResult` completes the
+     * negative-seq checkpoint and re-drives, the body replays and deterministically re-throws the same
+     * exit it took before (the original failure, or the suspension `compensateAndCancel` resumed from),
+     * this function runs again, the now-resolved comp is skipped, and the unwind continues from there.
+     *
+     * Returns `undefined` once every compensation has resolved — the caller then finalizes the run
+     * (`failed` with the ORIGINAL body error, never masked by a comp outcome; or `cancelled`).
+     */
+    private unwindCompensations;
+    /**
+     * Run one LOCAL saga compensation, retried up to `compensationRetries`, emitting a
+     * `compensate:<step>` step event for its outcome so a stranded undo is visible. Never throws — a
+     * permanently-failing compensation is skipped so it can't mask the original failure. Checkpoints
+     * its outcome at `seq` (a negative unwind position reserved by {@link unwindCompensations}) so a
+     * crash mid-unwind skips an already-resolved undo on a later pass instead of re-running it (and
+     * re-spending its retry budget) from attempt 1 — the checkpoint is durability/visibility only; the
+     * runtime retry-in-process-back-to-back semantics of `comp.fn()` are unchanged.
      */
     private runCompensation;
+    /**
+     * Resolve (or advance) ONE dispatched saga compensation at its reserved negative `seq` — the undo
+     * handler is an ordinary remote `@Step`, so this mirrors `callRemote`'s pending/failed/absent
+     * branches (engine.ts's `callRemote`), minus the queue/admission and in-memory-`timeoutMs` paths
+     * (V1: dispatch direct by name, always durable). Returns the wait signal when the run must pause for
+     * this compensation (freshly dispatched, still in flight, or backing off before a durable retry);
+     * `undefined` once it's resolved — completed (crash-safe skip), or retries exhausted/non-retryable
+     * (already visible: `completeRemoteResult` emitted `step.failed` for `compensate:<name>` when that
+     * checkpoint landed — never re-emitted here, and never allowed to block the rest of the unwind or
+     * mask the run's original failure).
+     */
+    private dispatchCompensation;
+    /**
+     * Dispatch (or re-dispatch, on a durable retry) one compensation's undo handler — mirrors
+     * `callRemote`'s dispatch block (persist the `pending` checkpoint BEFORE handing off to the
+     * transport, so a fast result always finds it to complete). Two DIFFERENT names are in play: the
+     * checkpoint's `name` is `compensate:<originalStepName>` (what makes this undo show up on the run's
+     * timeline, and what `completeRemoteResult` emits `step.completed`/`step.failed` under); the WIRE
+     * task's `name` is the undo handler's OWN routing name (`def.name`) — a worker dispatches to the
+     * `@Step` it registered, not to this saga-visibility label.
+     */
+    private dispatchCompensationAttempt;
     /** The seam handed to {@link createWorkflowCtx}: the authoring API reaches durability + lifecycle
      *  (checkpointing, dispatch, child start) through this, so the ctx primitives live in their own
      *  module and the engine stays the orchestrator. */
@@ -2365,6 +2485,79 @@ declare class RemoteStepError extends Error {
     constructor(stepError?: StepError);
 }
 
+/**
+ * What the class-first statics need from whoever registered the workflow class: the engine, or a
+ * store-less start facade (a tenant's `DurableStartClient`). `waitForRun` is optional — a facade
+ * without a store cannot wait, so `execute` outside a workflow throws a clear error there.
+ */
+interface WorkflowStartClient {
+    start(workflow: string, input: unknown, runId: string, opts?: StartOptions): Promise<RunResult>;
+    waitForRun?(runId: string, opts?: {
+        timeoutMs?: number;
+        until?: 'settled' | 'terminal';
+    }): Promise<RunResult>;
+}
+/**
+ * Bind a `@Workflow` class to the client that can start it — called by the registrar for every
+ * discovered workflow at boot. This is what lets `MyWorkflow.start()` resolve THE engine that
+ * registered it, with no global engine singleton (two engines in one process each bind their own
+ * classes).
+ */
+declare function bindWorkflowClass(ctor: Function, client: WorkflowStartClient): void;
+/**
+ * Optional base class giving a `@Workflow` a **class-first API** — start it from anywhere without
+ * injecting the engine or `WorkflowService`:
+ *
+ * ```ts
+ * @Workflow({ name: 'checkout', version: '1' })
+ * export class CheckoutWorkflow extends DurableWorkflow {
+ *   async run(ctx: WorkflowCtx, order: Order) { ... }
+ * }
+ *
+ * const { runId } = await CheckoutWorkflow.start(order);   // fire-and-forget, typed input
+ * const result = await CheckoutWorkflow.execute(order);    // run-and-await, typed output
+ * ```
+ *
+ * Each method means the same thing everywhere; only the mechanism adapts to where you call it:
+ *
+ * - {@link DurableWorkflow.start | `start`} — **fire-and-forget**. Outside a workflow it is exactly
+ *   `engine.start` (enqueue, return `{ runId, status }` immediately). Inside a workflow body it
+ *   becomes `ctx.startChild` — checkpointed, replay-safe, parent-linked — same contract.
+ * - {@link DurableWorkflow.execute | `execute`} — **run-and-await the typed output**. Inside a
+ *   workflow it is `ctx.child` (the parent suspends with zero compute and resumes with the result).
+ *   Outside it starts the run and waits until it settles terminally, resolving the output or
+ *   throwing `FatalError` when the run failed/cancelled/dead.
+ *
+ * Inside-ness is detected via the ambient workflow context the engine installs around every body
+ * execution (see `ambient-ctx.ts`). A `@Step` handler runs on a worker, off the body's path — the
+ * statics there start a TOP-LEVEL run, which is correct: a handler is not the workflow body.
+ */
+declare class DurableWorkflow {
+    /**
+     * Fire-and-forget start — `engine.start` outside a workflow, `ctx.startChild` (parent-linked)
+     * inside one. `opts.id` pins the run id (outside) / child id (inside) for idempotent starts.
+     */
+    static start<C extends WorkflowClass>(this: C, input: WorkflowInputOf<C>, opts?: {
+        id?: string;
+    } & StartOptions): Promise<RunResult>;
+    /**
+     * Run-and-await the typed output — `ctx.child` inside a workflow (suspends the parent, zero
+     * compute); outside, starts the run and waits until it settles terminally. Throws `FatalError`
+     * when the run does not complete. `opts.timeoutMs` bounds the OUTSIDE wait only (inside, a
+     * suspended parent costs nothing — bound the child itself with `executionTimeout` instead).
+     */
+    static execute<C extends WorkflowClass>(this: C, input: WorkflowInputOf<C>, opts?: {
+        id?: string;
+        timeoutMs?: number;
+    } & StartOptions): Promise<WorkflowOutputOf<C>>;
+}
+
+/**
+ * Parse a human duration to milliseconds. Accepts a number (already ms) or a string like
+ * `'500ms'`, `'30s'`, `'15m'`, `'2h'`, `'7d'`, `'7 days'`.
+ */
+declare function parseDuration(duration: string | number): number;
+
 /**
  * Thrown inside a step to signal an unrecoverable failure: the engine will NOT retry it,
  * regardless of the step's `retries` setting, and fails the run immediately. Use it for
@@ -2541,11 +2734,15 @@ interface RunDetail {
  * The bounded read/control/stream surface a consumer (e.g. a controller) needs, satisfied by BOTH
  * topologies: the control plane binds a store-backed impl (reuses `DashboardService`); a tenant binds
  * a `ProxyRunGateway` that round-trips over the transport. Deliberately smaller than the full dashboard
- * (no metrics/bulk/workerHealth/update/signal) — those stay control-plane-only.
+ * (no metrics/bulk/update/signal) — those stay control-plane-only. `workerHealth` IS on the port: the
+ * operator answers it scoped to the requester's own groups, so a tenant's Workers panel works too.
  */
 interface RunGateway {
     getRunDetail(runId: string): Promise<RunDetail | null>;
     listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    /** Per-group worker health (queue backlog + live worker heartbeats). On the control plane this is
+     *  every group; over a tenant proxy the operator scopes it to the tenant's own groups. */
+    workerHealth(): Promise<GroupHealth[]>;
     cancel(runId: string, opts?: {
         compensate?: boolean;
     }): Promise<RunResult | null>;
@@ -2935,4 +3132,4 @@ declare class InMemoryTransport implements Transport, ControlPlane {
     onControl(handler: (msg: ControlMessage) => void): void;
 }
 
-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, DURABLE_OPTIONS_CANONICAL, DURABLE_STEP_CONFIG, DURABLE_STEP_NAME, type DurableWebhook, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, GatherError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, RemoteWorkflowTimeout, type RetentionPolicy, type RunAttributeRow, type RunDetail, type RunDispatcher, type RunGateway, type RunQuery, type RunReply, type RunReplyResult, type RunRequest, type RunRequestKind, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, STATE_STORE_CANONICAL, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StartRunMessage, type StateStore, type StepCheckpoint, type StepConfig, type StepDef, type StepDispatchOpts, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepRef, type StepResult, type StoreTransaction, type SubProcessHandle, TERMINAL_RUN_STATUSES, TRANSPORT, TRANSPORT_CANONICAL, type TenantEvent, type Transport, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerAdjust, type WorkerConcurrencyStatus, type WorkerHeartbeat, type WorkerStatus, 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, createStepLogger, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, runSchedules, runStepHandler, sanitizeQueueToken, scheduledRunId, sqlComparator, stepConfigOf, stepId, stepNameOf, tenantGroup, 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, DURABLE_OPTIONS_CANONICAL, DURABLE_STEP_CONFIG, DURABLE_STEP_NAME, type DurableWebhook, DurableWorkflow, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, GatherError, type GroupHealth, type Heartbeat, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type MetricsCollector, type MetricsSnapshot, type NamedTransport, NonDeterminismError, type PayloadCodec, type QueueConfig, QueueController, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, RemoteWorkflowTimeout, type RetentionPolicy, type RunAttributeRow, type RunDetail, type RunDispatcher, type RunGateway, type RunQuery, type RunReply, type RunReplyResult, type RunRequest, type RunRequestKind, type RunResult, type RunSchedulesOptions, type RunStatus, STATE_STORE, STATE_STORE_CANONICAL, type ScheduledWorkflow, type SearchAttributes, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StartOptions, type StartRunMessage, type StateStore, type StepCheckpoint, type StepConfig, type StepDef, type StepDispatchOpts, type StepError, type StepEvent, type StepHandler, type StepInterceptor, type StepInvocation, type StepKind, type StepLogger, type StepOptions, type StepRef, type StepResult, type StepUndo, type StoreTransaction, type SubProcessHandle, TERMINAL_RUN_STATUSES, TRANSPORT, TRANSPORT_CANONICAL, type TenantEvent, type Transport, type UndoOf, type UpdateResult, type UpdateValidator, WORKFLOW_NAME_KEY, type WorkerAdjust, type WorkerConcurrencyStatus, type WorkerHeartbeat, type WorkerStatus, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRun, type WorkflowStartClient, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, applyAttributeQuery, attributeColumnFor, attributeOperand, bindWorkflowClass, breakpointToken, collectMetrics, createStepLogger, currentWorkflowCtx, eventMatchOf, eventMatches, eventPrefix, eventToken, matchesAttributes, normalizeAttributeRows, parseDuration, prevCronFireMs, runInWorkflowCtx, runSchedules, runStepHandler, sanitizeQueueToken, scheduledRunId, sqlComparator, stepConfigOf, stepId, stepNameOf, tenantGroup, workflowName };