@dudousxd/nestjs-durable-core 0.84.1 → 0.85.1

package/dist/index.d.cts

@@ -1195,6 +1195,14 @@ interface StateStore {
      */
     updateRunIf?(runId: string, expectedStatuses: RunStatus[], patch: Partial<WorkflowRun>): Promise<boolean>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    /**
+     * The runs with these ids, in any order; an id with no run is left out. One `IN (...)` read: the
+     * engine looks up a fan's children with it (which to start, which already finished) instead of
+     * one {@link getRun} per child. Callers pass ids in bounded batches.
+     *
+     * Optional: without it the engine reads each run with {@link getRun}.
+     */
+    getRuns?(runIds: string[]): Promise<WorkflowRun[]>;
     /**
      * 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
@@ -2262,6 +2270,43 @@ interface NamedTransport {
 interface RunDispatcher {
     dispatch(runId: string): void | Promise<void>;
 }
+/**
+ * One run handed to a transport's run queue ({@link Transport.dispatchRuns}), for whichever driving
+ * instance takes it.
+ *
+ * - `start` (the default): a freshly created or re-queued `pending` run. The consumer runs it only
+ *   while it is still `pending`; any other state means another instance already took it.
+ * - `wake`: a suspended run with something new to see (a delivered signal or child completion, a
+ *   due timer, a freed singleton or queue slot, a lease that came free). The consumer leases and
+ *   resumes it unless it is finished.
+ */
+interface RunDispatch {
+    runId: string;
+    /** The run's admission priority (higher = more urgent), for a queue that orders by priority. */
+    priority?: number | undefined;
+    reason?: 'start' | 'wake' | undefined;
+    /**
+     * Which `pending` state of the run a `start` is for: the same for every dispatch of one pending
+     * state (a start re-sent by the poll), different once the run went `pending` again (a retry, a
+     * recovery). A transport that deduplicates may drop a start whose `runId` and `key` match one it
+     * still holds; it must not drop one with a new key, even while the earlier one is being handled,
+     * nor a wake. Absent on a wake.
+     */
+    key?: string | undefined;
+}
+/**
+ * Which run queue {@link Transport.dispatchRuns} and {@link Transport.onDispatchedRun} use. Runs are
+ * queued per engine `namespace` (undefined for an engine that drives every namespace), so engines
+ * scoped to different namespaces on one broker never execute each other's runs.
+ */
+interface RunQueueOptions {
+    namespace?: string | undefined;
+}
+/** Options for {@link Transport.onDispatchedRun}. */
+interface RunConsumerOptions extends RunQueueOptions {
+    /** Most runs this consumer hands to its handler at once. */
+    concurrency: number;
+}
 interface Transport {
     /** engine → worker */
     dispatch(task: RemoteTask): Promise<void>;
@@ -2348,6 +2393,21 @@ interface Transport {
     dispatchRunRequest?(msg: RunRequest): Promise<void>;
     /** control plane ← tenant worker: consume {@link RunRequest}s. Pair with {@link dispatchRunRequest}. */
     onRunRequest?(handler: (msg: RunRequest) => Promise<void>): void;
+    /**
+     * engine → engine: queue `pending` runs for whichever driving instance takes them first, one entry
+     * per run id (a run already queued is not queued twice). The engine sends a wide fan's children in
+     * batches. Optional, together with {@link onDispatchedRun}: an engine that consumes the run queue
+     * dispatches the runs it starts here instead of executing them in-process. A rejection leaves the
+     * runs `pending` in the store for a `runPending` poll.
+     */
+    dispatchRuns?(runs: readonly RunDispatch[], opts?: RunQueueOptions): Promise<void>;
+    /**
+     * engine ← engine: consume the run queue, at most `opts.concurrency` runs at once on this
+     * instance, handing each {@link RunDispatch} to `handler` as dispatched (its `reason` included);
+     * `handler` resolves when its turn of the run settles. Returns a stop function that stops
+     * taking runs and resolves once the runs in flight have settled. Pair with {@link dispatchRuns}.
+     */
+    onDispatchedRun?(handler: (run: RunDispatch) => Promise<void>, opts: RunConsumerOptions): () => Promise<void>;
     /** control plane → tenant worker: publish a correlated {@link RunReply} on `<effectivePrefix>-run-reply`
      *  (pub/sub; every tenant subscribes and filters by `requestId`). */
     publishRunReply?(reply: RunReply): Promise<void>;
@@ -4442,8 +4502,10 @@ interface WorkflowEngineDeps {
      */
     trackStepStart?: boolean | undefined;
     /**
-     * Where a freshly-`start`ed run executes (see {@link RunDispatcher}). Defaults to in-process: the
-     * run executes on this instance asynchronously (a microtask), so `start` returns without blocking.
+     * Where a freshly-`start`ed run executes (see {@link RunDispatcher}). By default the run executes
+     * on this instance asynchronously, so `start` returns without blocking; once the engine consumes a
+     * transport's run queue ({@link WorkflowEngine.consumeRuns}) it queues the run there instead, for
+     * whichever driving instance takes it.
      * Pass a no-op dispatcher on a caller that must NOT run workflows (e.g. an API/dashboard pod), and
      * run `runPending` on a worker pod to pick those up; or a broker-backed one for a worker pool.
      */
@@ -4582,6 +4644,35 @@ declare class WorkflowEngine {
     private readonly stepQueue;
     /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
     private readonly inflight;
+    /**
+     * Work a settled turn leaves running in the background (a parent notification, a post-release
+     * re-drive), so a graceful shutdown waits for it too: dropping one on exit strands the run until
+     * its reconcile timer.
+     */
+    private readonly background;
+    /**
+     * Runs with an implicit wake executing on this instance, and whether another wake arrived for the
+     * run meanwhile (see {@link resumeImplicit}).
+     */
+    private readonly wakeTurns;
+    /** Re-checks scheduled for runs whose wake found another instance's lease (see {@link execute}). */
+    private readonly leaseRetries;
+    /**
+     * Every run turn and child start this instance takes on itself, under one budget of
+     * {@link LOCAL_RUN_CONCURRENCY}: the runs it dispatches to itself, a fan's deferred child starts,
+     * enqueued pickups and the runs it takes off the transport's run queue.
+     */
+    private readonly localWork;
+    /** The dispatcher the caller supplied, if any; without one the engine picks (see {@link dispatchRun}). */
+    private readonly customDispatcher;
+    /** Runs on their way to the transport's run queue (see {@link consumeRuns}). */
+    private readonly runBatcher;
+    /** Set while this engine consumes a transport's run queue, and so dispatches its runs to it. */
+    private dispatchesOverTransport;
+    /** Stops for the run-queue consumers started by {@link consumeRuns}. */
+    private runConsumerStops;
+    /** The consumers being stopped, so {@link drain} waits for their runs in flight. */
+    private runConsumersStopping;
     /**
      * The run lease of each execution in flight on THIS instance, by run id — renewed while it runs
      * and checked by every settle (the zombie fence, see {@link ExecutionLease}). Also what `drain()`
@@ -4612,10 +4703,72 @@ declare class WorkflowEngine {
     getEntityState<S = unknown>(name: string, key: string): Promise<S | undefined>;
     /**
      * Be notified when a run is enqueued on ANOTHER instance (via the control plane), so a worker can
-     * pick it up at once — e.g. `engine.onEnqueued((runId) => engine.runOne(runId))`. Returns an
+     * pick it up at once — e.g. `engine.onEnqueued((runId) => engine.runEnqueued(runId))`. Returns an
      * unsubscribe function. Only wire this on instances that should execute runs (workers).
      */
     onEnqueued(listener: (runId: string) => void): () => void;
+    /**
+     * Pick up a run another instance announced as enqueued: run it here if it is still `pending`.
+     * Bounded by {@link LOCAL_RUN_CONCURRENCY}, and a run another instance already took is skipped
+     * after one read, instead of being leased and replayed here once more.
+     */
+    runEnqueued(runId: string): void;
+    /**
+     * Consume the run queue of every transport that carries one ({@link Transport.dispatchRuns} and
+     * {@link Transport.onDispatchedRun}), and from then on dispatch the runs this engine starts there
+     * rather than executing them in-process: a run, a `ctx.all` fan's children included, executes on
+     * whichever consuming instance takes it, at most {@link LOCAL_RUN_CONCURRENCY} at once per
+     * instance. Call it on every instance that drives runs; the Nest module does on a driving operator.
+     *
+     * Returns a function that stops consuming and resolves once the runs in flight settled, after
+     * which runs are executed in-process again; {@link beginDrain} stops consuming too. Undefined
+     * when no transport carries a run queue: runs keep executing in-process.
+     */
+    consumeRuns(): (() => Promise<void>) | undefined;
+    /** Stop every run-queue consumer; resolves once their runs in flight settled. */
+    private stopRunConsumers;
+    /** Whether {@link dispatchRun} queues runs on the transport (see {@link consumeRuns}). */
+    private get queuesRunsOverTransport();
+    /**
+     * Hand a `pending` run to whatever executes it: the caller's {@link WorkflowEngineDeps.runDispatcher};
+     * else the transport's run queue while this engine consumes it, batched; else this instance,
+     * bounded by {@link LOCAL_RUN_CONCURRENCY}. A run whose queueing fails stays `pending` for a
+     * `runPending` poll.
+     */
+    private dispatchRun;
+    /**
+     * Wake a suspended run that has something new to see (a delivered signal or child completion, a
+     * lease that came free, a freed slot): while this engine consumes the transport's run queue, on
+     * whichever instance takes the wake (the result then only says it was handed over); otherwise
+     * here, now.
+     */
+    private wake;
+    /**
+     * Take a turn of a run taken off the transport's run queue. A `start` runs only while the run is
+     * still `pending` (or `cancelling`, a recovered cancel): any other state means another instance
+     * already took it. A `wake` leases and resumes the run unless it is finished. The run lease admits
+     * one executor either way. Never rejects.
+     */
+    private runFromQueue;
+    /**
+     * Hand due runs (timers, blocked runs due for a fleet re-check) to whichever instance takes them
+     * off the run queue. Each is claimed first, under its lease, by pushing its `wakeAt` one lease
+     * period out, so the next poll (here or elsewhere) does not queue it again while it waits; a wake
+     * that is lost brings it back due after that period. False when the transport refused the wakes,
+     * so the caller resumes them itself.
+     */
+    private handOffDue;
+    /**
+     * Queue `runs` on the transport for whichever consuming instance takes them, in batches. False
+     * when the transport refused them, so the caller executes them itself instead.
+     */
+    private queueOnTransport;
+    /**
+     * Execute a run announced by another instance, if it is still `pending`: a
+     * run another instance already took is skipped after one read instead of being leased and
+     * replayed here once more. Never rejects.
+     */
+    private runIfPending;
     /** Fire cooperative-cancellation listeners for `runId` (a worker bridge aborts in-flight work). */
     private notifyCancelled;
     /**
@@ -4816,6 +4969,8 @@ declare class WorkflowEngine {
      * stale waiter or a late result left behind by a failed run silently re-executes its body.
      */
     private resumeImplicit;
+    /** Keep `work` in {@link background} until it settles; its failure is swallowed. */
+    private inBackground;
     /**
      * One execution of a run at a time in this process. A resume that lands while the run executes
      * here neither joins that execution (the double-run) nor no-ops against its held lease (a lost
@@ -5247,6 +5402,32 @@ declare class WorkflowEngine {
      * instance opened is skipped, for the reason {@link settledHere} gives.
      */
     private redriveSettledStepFans;
+    /**
+     * Deliver the outcome of every awaited child that already finished but whose completion never
+     * reached this run, into `checkpoints` (this turn's snapshot) and the store.
+     *
+     * A child persists its terminal status first and tells its parent after ({@link notifyParent}). A
+     * crash, a scale-down or a store error between the two leaves the parent's `running` placeholder
+     * and `child:<id>` waiter behind for a child that is done, and nothing else would ever settle
+     * them: the parent's reconcile wake replays straight back to the same wait. So each turn looks up
+     * the children of its `running` placeholders (one batched read per 500) and settles the finished
+     * ones exactly as the child's own notification would have: the `signal:child:<id>` checkpoint
+     * with the child's completion, then the waiter removed. A notification arriving late writes the
+     * same checkpoint and finds no waiter. Best effort: a store error leaves the rest to the next turn.
+     */
+    private deliverFinishedChildren;
+    /**
+     * {@link deliverFinishedChildren} for a remote workflow, whose awaited children (`startChild`
+     * commands) leave a `child:<id>` waiter but no placeholder checkpoint: the run's own waiters say
+     * which children it is waiting on. One indexed read per turn of a remote run.
+     */
+    private deliverFinishedChildWaiters;
+    /**
+     * Settle every child in `awaited` that has finished: its `signal:child:<id>` checkpoint with the
+     * child's completion, then its waiter removed, exactly as the child's own notification does, and
+     * the checkpoint put into `checkpoints`. Children are read in batches of 500.
+     */
+    private settleFinishedChildren;
     private redriveSettledChildren;
     /**
      * Deliver an external signal to the run waiting on `token`, resume it with `payload`, and return
@@ -5308,6 +5489,22 @@ declare class WorkflowEngine {
      * knowing about the child feature.
      */
     private notifyParent;
+    /**
+     * {@link signal} a child's completion to its parent, retrying a store error a few times. The child
+     * is already persisted terminal, so a failure here would leave the parent waiting on a child that
+     * finished; the parent's own turns reconcile that ({@link deliverFinishedChildren}), but only on
+     * its next wake. A waiter already taken is delivered to directly on a retry, so the completion is
+     * not buffered for a waiter that no longer exists.
+     */
+    private deliverToParent;
+    /**
+     * 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).
+     */
+    private parentHoldsCompletion;
     /**
      * 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
@@ -5507,6 +5704,20 @@ declare class WorkflowEngine {
     private markStarted;
     private singletonWaitResult;
     private execute;
+    /**
+     * A wake that found the run leased by another instance is dropped, and normally that is fine: the
+     * holder's turn either sees what the wake wrote, or re-checks once it releases the lease
+     * ({@link redriveSettledSteps}, {@link redriveSettledChildren}). Not if the holder goes down first
+     * (a scale-down mid-turn, an OOM): its lease lapses with the run `suspended` on a step that has
+     * finished, and nothing wakes it before its timer.
+     *
+     * So the dropped wake is kept here: once the lease is free (looked at every
+     * {@link LEASE_RECHECK_MAX_MS} at most, for a bounded number of times), a run still `suspended` is
+     * leased and resumed. A holder that already moved the run on makes this one spare replay that
+     * re-parks. Best effort; the run's timer remains the fallback if this instance goes down too.
+     */
+    private recheckAfterLease;
+    private retryDroppedWake;
     /**
      * Renew `runId`'s lease for as long as this execution holds it, and register it in
      * {@link executionLeases} so settles can check the zombie fence and `drain()` can release it.
@@ -5898,6 +6109,12 @@ declare class WorkflowEngine {
      * whose read or write failed resolves its error, and the transport redelivers just that one.
      */
     private completeRemoteResults;
+    /**
+     * The outcomes for a batch of redelivered results (their steps already settled): one of them
+     * resumes the run if it is `suspended` and, for a step of a fan, the fan's barrier is open. A
+     * resume of a run that had in fact moved on replays to its current wait and re-parks.
+     */
+    private resumeForRedelivered;
     /**
      * The join barrier of a step fan: a result for one of its steps resumes the parent only once no
      * step of the fan is still `pending` (a settled wave), or on a failure (failFast surfaces it, and a
@@ -6529,6 +6746,22 @@ declare function listSignalWaitersOfRuns(store: StateStore, runIds: readonly str
 /** Index signal waiters by `runId`, keeping the first seen per run (a run parks on one waiter at a
  *  time in the sequential case; the earliest is the one it's blocked on). */
 declare function indexWaitersByRun(waiters: readonly SignalWaiter[]): Map<string, SignalWaiter>;
+/**
+ * The runs with these ids that exist: through the store's {@link StateStore.getRuns} in bounded
+ * batches, or, for a store without it, one {@link StateStore.getRun} per id, a few at a time.
+ * Throws if any read failed; see {@link readRunsByIds} to keep what was read.
+ */
+declare function getRunsByIds(store: StateStore, runIds: readonly string[]): Promise<Map<string, WorkflowRun>>;
+/**
+ * {@link getRunsByIds}, keeping what could be read: `runs` holds the existing runs among the ids
+ * that were read, `unread` the ids whose read failed (with the first `error`). A failed read costs
+ * only its own ids: one failing {@link StateStore.getRun} does not discard the rest of its batch.
+ */
+declare function readRunsByIds(store: StateStore, runIds: readonly string[]): Promise<{
+    runs: Map<string, WorkflowRun>;
+    unread: string[];
+    error?: unknown;
+}>;
 
 /**
  * The parent of a child run whose id the engine minted: a `ctx.all` child
@@ -6629,6 +6862,8 @@ declare class CodecStateStore implements StateStore {
     readonly registerChildWaits?: (entries: ChildWait[]) => Promise<void>;
     /** The folded checkpoint carries the children's outputs, so it is encoded. */
     readonly compactCheckpoints?: (runId: string, fromSeq: number, toSeq: number, into: StepCheckpoint) => Promise<void>;
+    /** Decodes each run like {@link getRun}. Bound only when the inner store has it. */
+    readonly getRuns?: (runIds: string[]) => Promise<WorkflowRun[]>;
     /** Forwarded verbatim — a waiter carries no payload. */
     readonly listSignalWaitersByRun?: (runIds: string[]) => Promise<SignalWaiter[]>;
     /** Forwarded verbatim — a waiter carries no payload. */
@@ -6803,6 +7038,8 @@ interface ScheduledWorkflow<W extends WorkflowRef = WorkflowRef> {
     /**
      * Randomly delay the dispatch by up to this many ms BEFORE firing, to spread load when many
      * instances tick on the same boundary (avoids a thundering herd). Opt-in; absent = fire immediately.
+     * The window is deferred to a later tick, never waited for inside one, so a jittered schedule does
+     * not hold up any other schedule or the rest of the timer poll.
      *
      * This is dispatch-path jitter only — it does NOT affect the run id (still the time bucket), so
      * idempotency is unchanged: two instances jittering the same window still start it exactly once.
@@ -6831,9 +7068,13 @@ interface ScheduledWorkflow<W extends WorkflowRef = WorkflowRef> {
     namespace?: string;
 }
 /** Injectable dispatch-path effects (kept out of the deterministic run-id logic). Defaults to real
- *  `Math.random` + `setTimeout`; overridden in tests so jitter is deterministic and instant. */
+ *  `Math.random`; overridden in tests so jitter is deterministic. */
 interface RunSchedulesOptions {
     random?: () => number;
+    /**
+     * @deprecated No longer called: jitter defers a window to a later tick instead of sleeping inside
+     * this one. Kept so existing callers still type-check.
+     */
     sleep?: (ms: number) => Promise<void>;
 }
 /** Deterministic run id for a fixed-interval schedule's current time window. */
@@ -6863,8 +7104,8 @@ declare function scheduleRunIdAt(s: ScheduledWorkflow, nowMs: number): string;
  * racing two instances on the same tick — starts **each window exactly once**. Wire it to a
  * `setInterval`, the durable timer poller, or `@nestjs/schedule`. Returns the run ids this call
  * started: a window that already has a run is not started or returned again, and once this process
- * has seen a window's run exist, later calls in that window skip it without a store read or a
- * jitter sleep.
+ * has seen a window's run exist, later calls in that window skip it without a store read. A
+ * jittered window is deferred to a later call, never slept on.
  */
 declare function runSchedules(engine: Pick<WorkflowEngine, 'start' | 'getRun'> & Partial<Pick<WorkflowEngine, 'isDraining'>>, schedules: readonly ScheduledWorkflow[], nowMs: number, opts?: RunSchedulesOptions): Promise<string[]>;
 
@@ -7124,6 +7365,7 @@ declare class InMemoryStateStore implements StateStore {
     updateRunIf(runId: string, expectedStatuses: RunStatus[], patch: Partial<WorkflowRun>): Promise<boolean>;
     private applyRunPatch;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    getRuns(runIds: string[]): Promise<WorkflowRun[]>;
     deleteRun(runId: string): Promise<void>;
     deleteRuns(runIds: string[]): Promise<void>;
     pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
@@ -7229,6 +7471,25 @@ declare class InMemoryTransport implements Transport, ControlPlane {
     onControl(handler: (msg: ControlMessage) => void): void;
 }
 
+/**
+ * An in-process run queue shared by several {@link Transport}s, for tests: each
+ * {@link InMemoryRunQueue.transport} is one instance of a deployment, and a run queued by any of
+ * them goes to whichever consumer has a free slot, round-robin. A run waiting in the queue is not
+ * queued twice (a wake turns a waiting start into a wake); one being handled is queued again.
+ * Higher priority goes first. The transports carry no remote steps.
+ */
+declare class InMemoryRunQueue {
+    private readonly lanes;
+    /** A transport on this queue. */
+    transport(): Transport;
+    /** Runs waiting in the queue of `namespace`. */
+    waiting(namespace?: string): string[];
+    private lane;
+    private add;
+    private consume;
+    private pump;
+}
+
 /** Reserved engine metadata: a durable singleton slot, independent of the execution lease. */
 declare const SINGLETON_ADMITTED_TAG = "durable:singleton:admitted";
 /**
@@ -7279,4 +7540,4 @@ declare function singletonAdmissionDenialPatch(runs: WorkflowRun[], runId: strin
     updatedAt: Date;
 } | undefined;
 
-export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AllOptions, type AllSettledOptions, type AllStepsOptions, type AllStepsSettledOptions, type AnnouncedWorkflow, type AnnouncementEvidence, type AttributeFilter, type AttributeOp, type AttributePredicateOperand, type AttributeValue, type BackoffStrategy, type BlockedDispatch, type BlockedResolution, CHILD_EDGE_PREFIXES, CONTROL_FLOW_SIGNAL, CURRENT_PROTOCOL_VERSION, type CapabilityRequirement, type CheckpointAggregatingStore, type CheckpointNameKind, type CheckpointQuery, type CheckpointStat, type ChildCallOptions, type ChildWait, CodecStateStore, type CodecStateStoreOptions, type ConcurrencyConfig, ConcurrencyLimitError, type ConcurrencyQuota, ContinueAsNew, type ControlMessage, type ControlPlane, DEFAULT_CONCURRENCY_STATUSES, DEFAULT_PARTITION, DEFAULT_STALLED_AFTER_MS, DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL, DURABLE_STEP_CONFIG, DURABLE_STEP_NAME, type Disagreement, type DispatchDiagnostics, type DispatchPlan, type DurableExecution, type DurableExecutionWrapper, type DurableTopology, type DurableWebhook, DurableWorkflow, type DynamicWorkflowCtx, ENGINE_MINTED_TAG_PREFIXES, ENTITY_WORKFLOW, EVENT_BUFFER_SCAN_LIMIT, EVENT_TOKEN_PREFIX, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, type EntityWorkflowHost, EventAccumulators, type EventBatchConfig, FAN_SUMMARY_FAILURES, type FanJoin, type FanPage, type FanPageQuery, type FanSummary, type FanWait, FatalError, type FindStalledRunsOptions, GatherError, type GatherItemFailure, type GroupHealth, HANDOFF_SEQ_BASE, type Heartbeat, type HeartbeatSighting, type HeartbeatStatus, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type InferSearchAttributes, LEGACY_V1_CAPABILITIES, LEGACY_V1_PROTOCOL, type ListStalledRunsOptions, type MetricsCollector, type MetricsSnapshot, type NamedTransport, type NegotiateOptions, type NegotiationOutcome, type NegotiationReason, type NegotiationResult, NestedWorkflowCallError, NonDeterminismError, type OnErrorInput, type OnErrorRoute, type OwnedLeaseReclaim, type PartitionSighting, type PayloadCodec, type QueueConfig, QueueController, RUN_HISTORY_FIXTURE_VERSION, RUN_VALUE_FACET_LIMIT, RUN_VALUE_FACET_SCAN, type RawWorkerDescriptor, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, RemoteWorkflowTimeout, type RetentionPolicy, type RoutableDispatch, type RoutableResolution, type RoutingResolution, type RunAttributeRow, type RunDetail, type RunDetailOptions, type RunDispatcher, type RunFacetQuery, type RunFacetRow, RunGateway, type RunListItem, type RunQuery, type RunReply, type RunReplyResult, type RunRequest, type RunRequestKind, type RunResult, type RunSchedulesOptions, type RunScope, type RunStatus, type RunValueAxis, type RunValueFacetOptions, type RunValueFacetOrder, type RunValueFacetRow, type RunWaiting, SINGLETON_ACTIVE_STATUSES, SINGLETON_ADMITTED_TAG, SINGLETON_RESERVED_TAGS, SINGLETON_TRACKED_TAG, STATE_STORE, STATE_STORE_CANONICAL, SUMMARY_CHILD_LIMIT, type ScalarAttributeFilter, ScheduleAlreadyExistsError, ScheduleClient, type ScheduleClientOptions, type ScheduleDescription, type ScheduleHost, type ScheduleListQuery, ScheduleNotFoundError, type ScheduleOptions, type ScheduleQuery, type ScheduleRecord, type ScheduledWorkflow, type SchemaIssue, type SchemaValidationCode, SchemaValidationError, type SearchAttributes, type SearchAttributesSchema, type Settled, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StalePendingStep, type StalledRunInfo, StandardSchemaV1, 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 StepScope, type StepUndo, type StoreTransaction, type SubProcessHandle, TERMINAL_RUN_STATUSES, TRANSPORT, TRANSPORT_CANONICAL, type TenantEvent, type TenantTokenSource, type TenantVerifier, type Transport, type UndoOf, type UpdateResult, type UpdateValidator, VERSION_UNDECLARED_TAG, type VerifiedTenant, WORKFLOW_NAME_KEY, type WireDates, type WorkerAdjust, type WorkerConcurrencyStatus, type WorkerDescriptor, type WorkerHeartbeat, type WorkerLifecycle, type WorkerStatus, type WorkflowAnnouncement, WorkflowBlocked, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, type WorkflowDirectory, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowHandler, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRegistration, type WorkflowRun, type WorkflowStartClient, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, aggregateAnnouncements, aggregatesCheckpoints, announcementsOf, applyAttributeQuery, assertConcurrency, assertRoutes, attributeColumnFor, attributeOperand, attributePredicateOperands, axisIsRunColumn, bindWorkflowClass, breakpointToken, buildWorkflowDirectory, canRoute, capableWorkers, checkpointNameKind, checkpointStatsOf, childIdsOf, classifyWaiterToken, clearDurableExecutionWrappers, clearTerminalSingletonAdmission, codeAndDetails, codeOf, collectMetrics, concurrencyTag, controlPlaneDescriptor, countRuns, coveredTokens, createStepLogger, currentStep, currentStepScope, currentWorkflowCtx, debug, describeWorker, descriptorHash, detailsOf, error, etagMatches, eventMatchOf, eventMatches, eventNameOf, eventPrefix, eventToken, facetOrigin, fanPageBounds, fanPageEtag, findStalledRuns, foldedCount, handoffHandlerId, handoffName, hasDurableExecutionWrappers, heartbeatStatus, hmacTenantVerifier, indexWaitersByRun, info, isEngineMintedTag, isEventToken, isFailedMember, isLegacyDescriptor, isNonEmptyRunScope, isWorkflowControlFlowSignal, legacySingletonHolders, listSignalWaitersOfRuns, liveHandoff, log, matchesAttributes, mergeRunFacetRows, mergeRunValueFacetRows, missingCapabilities, negotiate, nextCronFireMs, normalizeAttributeRows, normalizeDescriptor, observedAnnouncements, onErrorRunId, pageFan, pageFanFromStore, parentRunIdOf, parseDuration, parseWebhookToken, partitionOfToken, planDispatch, poolNamespace, prevCronFireMs, queryCheckpointsOf, readSearchAttributes, requiredCapabilities, resolveConcurrency, resolveRouting, resolveRunWaiting, resolveTenantToken, resolveWireTenant, retiredHandoffName, routeFor, runDetailEtag, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduleRunIdAt, scheduledRunId, signTenantToken, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, summarizeFan, summarizeRunFromStore, summarizeTimeline, tenantGroup, useDurableExecution, warn, withSingletonTracked, withoutSingletonMarkers, workflowName };
+export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AllOptions, type AllSettledOptions, type AllStepsOptions, type AllStepsSettledOptions, type AnnouncedWorkflow, type AnnouncementEvidence, type AttributeFilter, type AttributeOp, type AttributePredicateOperand, type AttributeValue, type BackoffStrategy, type BlockedDispatch, type BlockedResolution, CHILD_EDGE_PREFIXES, CONTROL_FLOW_SIGNAL, CURRENT_PROTOCOL_VERSION, type CapabilityRequirement, type CheckpointAggregatingStore, type CheckpointNameKind, type CheckpointQuery, type CheckpointStat, type ChildCallOptions, type ChildWait, CodecStateStore, type CodecStateStoreOptions, type ConcurrencyConfig, ConcurrencyLimitError, type ConcurrencyQuota, ContinueAsNew, type ControlMessage, type ControlPlane, DEFAULT_CONCURRENCY_STATUSES, DEFAULT_PARTITION, DEFAULT_STALLED_AFTER_MS, DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL, DURABLE_STEP_CONFIG, DURABLE_STEP_NAME, type Disagreement, type DispatchDiagnostics, type DispatchPlan, type DurableExecution, type DurableExecutionWrapper, type DurableTopology, type DurableWebhook, DurableWorkflow, type DynamicWorkflowCtx, ENGINE_MINTED_TAG_PREFIXES, ENTITY_WORKFLOW, EVENT_BUFFER_SCAN_LIMIT, EVENT_TOKEN_PREFIX, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, type EntityWorkflowHost, EventAccumulators, type EventBatchConfig, FAN_SUMMARY_FAILURES, type FanJoin, type FanPage, type FanPageQuery, type FanSummary, type FanWait, FatalError, type FindStalledRunsOptions, GatherError, type GatherItemFailure, type GroupHealth, HANDOFF_SEQ_BASE, type Heartbeat, type HeartbeatSighting, type HeartbeatStatus, type HistoryEvent, InMemoryAdmissionBackend, InMemoryRunQueue, InMemoryStateStore, InMemoryTransport, type InferSearchAttributes, LEGACY_V1_CAPABILITIES, LEGACY_V1_PROTOCOL, type ListStalledRunsOptions, type MetricsCollector, type MetricsSnapshot, type NamedTransport, type NegotiateOptions, type NegotiationOutcome, type NegotiationReason, type NegotiationResult, NestedWorkflowCallError, NonDeterminismError, type OnErrorInput, type OnErrorRoute, type OwnedLeaseReclaim, type PartitionSighting, type PayloadCodec, type QueueConfig, QueueController, RUN_HISTORY_FIXTURE_VERSION, RUN_VALUE_FACET_LIMIT, RUN_VALUE_FACET_SCAN, type RawWorkerDescriptor, RemoteStepError, RemoteStepTimeout, type RemoteTask, RemoteWorkflowExecutor, RemoteWorkflowTimeout, type RetentionPolicy, type RoutableDispatch, type RoutableResolution, type RoutingResolution, type RunAttributeRow, type RunConsumerOptions, type RunDetail, type RunDetailOptions, type RunDispatch, type RunDispatcher, type RunFacetQuery, type RunFacetRow, RunGateway, type RunListItem, type RunQuery, type RunQueueOptions, type RunReply, type RunReplyResult, type RunRequest, type RunRequestKind, type RunResult, type RunSchedulesOptions, type RunScope, type RunStatus, type RunValueAxis, type RunValueFacetOptions, type RunValueFacetOrder, type RunValueFacetRow, type RunWaiting, SINGLETON_ACTIVE_STATUSES, SINGLETON_ADMITTED_TAG, SINGLETON_RESERVED_TAGS, SINGLETON_TRACKED_TAG, STATE_STORE, STATE_STORE_CANONICAL, SUMMARY_CHILD_LIMIT, type ScalarAttributeFilter, ScheduleAlreadyExistsError, ScheduleClient, type ScheduleClientOptions, type ScheduleDescription, type ScheduleHost, type ScheduleListQuery, ScheduleNotFoundError, type ScheduleOptions, type ScheduleQuery, type ScheduleRecord, type ScheduledWorkflow, type SchemaIssue, type SchemaValidationCode, SchemaValidationError, type SearchAttributes, type SearchAttributesSchema, type Settled, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, type StalePendingStep, type StalledRunInfo, StandardSchemaV1, 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 StepScope, type StepUndo, type StoreTransaction, type SubProcessHandle, TERMINAL_RUN_STATUSES, TRANSPORT, TRANSPORT_CANONICAL, type TenantEvent, type TenantTokenSource, type TenantVerifier, type Transport, type UndoOf, type UpdateResult, type UpdateValidator, VERSION_UNDECLARED_TAG, type VerifiedTenant, WORKFLOW_NAME_KEY, type WireDates, type WorkerAdjust, type WorkerConcurrencyStatus, type WorkerDescriptor, type WorkerHeartbeat, type WorkerLifecycle, type WorkerStatus, type WorkflowAnnouncement, WorkflowBlocked, type WorkflowClass, type WorkflowCommand, type WorkflowCtx, type WorkflowDecision, type WorkflowDirectory, WorkflowEngine, type WorkflowEngineDeps, type WorkflowExecutor, type WorkflowHandler, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef, type WorkflowRegistration, type WorkflowRun, type WorkflowStartClient, type WorkflowStepEvent, WorkflowSuspended, type WorkflowTask, aggregateAnnouncements, aggregatesCheckpoints, announcementsOf, applyAttributeQuery, assertConcurrency, assertRoutes, attributeColumnFor, attributeOperand, attributePredicateOperands, axisIsRunColumn, bindWorkflowClass, breakpointToken, buildWorkflowDirectory, canRoute, capableWorkers, checkpointNameKind, checkpointStatsOf, childIdsOf, classifyWaiterToken, clearDurableExecutionWrappers, clearTerminalSingletonAdmission, codeAndDetails, codeOf, collectMetrics, concurrencyTag, controlPlaneDescriptor, countRuns, coveredTokens, createStepLogger, currentStep, currentStepScope, currentWorkflowCtx, debug, describeWorker, descriptorHash, detailsOf, error, etagMatches, eventMatchOf, eventMatches, eventNameOf, eventPrefix, eventToken, facetOrigin, fanPageBounds, fanPageEtag, findStalledRuns, foldedCount, getRunsByIds, handoffHandlerId, handoffName, hasDurableExecutionWrappers, heartbeatStatus, hmacTenantVerifier, indexWaitersByRun, info, isEngineMintedTag, isEventToken, isFailedMember, isLegacyDescriptor, isNonEmptyRunScope, isWorkflowControlFlowSignal, legacySingletonHolders, listSignalWaitersOfRuns, liveHandoff, log, matchesAttributes, mergeRunFacetRows, mergeRunValueFacetRows, missingCapabilities, negotiate, nextCronFireMs, normalizeAttributeRows, normalizeDescriptor, observedAnnouncements, onErrorRunId, pageFan, pageFanFromStore, parentRunIdOf, parseDuration, parseWebhookToken, partitionOfToken, planDispatch, poolNamespace, prevCronFireMs, queryCheckpointsOf, readRunsByIds, readSearchAttributes, requiredCapabilities, resolveConcurrency, resolveRouting, resolveRunWaiting, resolveTenantToken, resolveWireTenant, retiredHandoffName, routeFor, runDetailEtag, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduleRunIdAt, scheduledRunId, signTenantToken, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, summarizeFan, summarizeRunFromStore, summarizeTimeline, tenantGroup, useDurableExecution, warn, withSingletonTracked, withoutSingletonMarkers, workflowName };