@dudousxd/nestjs-durable-core 0.73.0 → 0.75.0

package/dist/index.d.cts

@@ -995,6 +995,45 @@ interface StateStore {
     takeSignalWaiter(token: string): Promise<SignalWaiter | null>;
     /** List waiters whose `token` starts with `prefix` — used to fan out an event to its subscribers. */
     listSignalWaiters(prefix: string): Promise<SignalWaiter[]>;
+    /**
+     * Whether run `runId` still has at least one waiter whose `token` starts with `tokenPrefix` (an
+     * exact prefix: `%`/`_` in the prefix are literal characters, not wildcards). The `ctx.all` join
+     * barrier asks this after each child settles, so it must stay O(1)-ish however many siblings are
+     * still waiting — answer it with a bounded lookup, never by listing the whole group.
+     *
+     * Optional: a store without it keeps `ctx.all` correct, but the parent replays once per settled
+     * child instead of once per fan.
+     */
+    hasSignalWaiter?(runId: string, tokenPrefix: string): Promise<boolean>;
+    /**
+     * The waiters of the given runs. Lets the engine and the dashboard read what a page of runs (or
+     * one run's children) is waiting on without scanning every waiter in the store, which a wide fan
+     * fills with one row per running child. Callers pass ids in bounded batches.
+     *
+     * Optional: without it those reads fall back to {@link listSignalWaiters} over every waiter.
+     */
+    listSignalWaitersByRun?(runIds: string[]): Promise<SignalWaiter[]>;
+    /**
+     * Register a batch of awaited children: for each entry, put `waiter` and upsert `checkpoint` (the
+     * parent's `running` placeholder for that child). `ctx.all` calls it once per chunk of a fan, so a
+     * wide fan costs a handful of round trips instead of two per child.
+     *
+     * Every entry's waiter must be durable no later than its checkpoint: the engine reads an existing
+     * placeholder as proof the waiter was put, and never re-puts it. Writing both in one transaction
+     * satisfies that.
+     *
+     * Optional: without it the engine puts each waiter, then saves each checkpoint.
+     */
+    registerChildWaits?(entries: ChildWait[]): Promise<void>;
+    /**
+     * Atomically replace run `runId`'s checkpoints with `seq` in `[fromSeq, toSeq]` by the single
+     * checkpoint `into`, whose `seq` lies in that range. `ctx.all` folds a settled group of children
+     * into one checkpoint this way, so every later turn of the parent loads one row instead of one per
+     * child. A delete over a contiguous seq range, served by the `(runId, seq)` primary key.
+     *
+     * Optional: without it a settled fan keeps one checkpoint per child.
+     */
+    compactCheckpoints?(runId: string, fromSeq: number, toSeq: number, into: StepCheckpoint): Promise<void>;
     /**
      * Delete the EXACT waiter row — `token` AND `runId` AND `seq` must all match — no-op if absent.
      * Unlike {@link takeSignalWaiter}, which deletes ANY row for `token` (fine when the caller just won
@@ -1421,6 +1460,26 @@ interface StoreTransaction {
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
 }
 /** Binds an external signal `token` to the suspended run/step position waiting for it. */
+/** Options for {@link WorkflowCtx.all}. */
+interface AllOptions {
+    /** `waitAll` (default) or `failFast` — see {@link WorkflowCtx.all}. */
+    mode?: 'waitAll' | 'failFast';
+    /**
+     * The most children running at once. Unset sends the whole fan immediately. When set, children go
+     * out in waves of `floor(concurrency / 2)`, two at a time (an odd limit runs one child under it):
+     * a new wave starts as soon as an earlier one settles, so one slow child does not idle the rest of
+     * the window. Each settled wave costs the parent one turn.
+     *
+     * Part of the fan's identity: child ids carry the wave, so changing it for an in-flight run is a
+     * non-deterministic change like changing `inputs`.
+     */
+    concurrency?: number;
+}
+/** One child of a fan as {@link StateStore.registerChildWaits} writes it. */
+interface ChildWait {
+    waiter: SignalWaiter;
+    checkpoint: StepCheckpoint;
+}
 interface SignalWaiter {
     token: string;
     runId: string;
@@ -2287,13 +2346,11 @@ interface WorkflowCtx<A extends SearchAttributes = SearchAttributes> {
      * 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`.
+     *
+     * `concurrency` caps how many children run at once (see {@link AllOptions.concurrency}).
      */
-    all<C extends WorkflowClass>(workflow: C, inputs: WorkflowInputOf<C>[], opts?: {
-        mode?: 'waitAll' | 'failFast';
-    }): Promise<WorkflowOutputOf<C>[]>;
-    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: {
-        mode?: 'waitAll' | 'failFast';
-    }): Promise<TOutput[]>;
+    all<C extends WorkflowClass>(workflow: C, inputs: WorkflowInputOf<C>[], opts?: AllOptions): Promise<WorkflowOutputOf<C>[]>;
+    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: AllOptions): Promise<TOutput[]>;
     /**
      * 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
@@ -2416,9 +2473,7 @@ interface DynamicWorkflowCtx<A extends SearchAttributes = SearchAttributes> exte
     /** {@link WorkflowCtx.startChild} by workflow name. */
     startChild(workflow: string, input: unknown, options?: string | ChildCallOptions): Promise<string>;
     /** {@link WorkflowCtx.all} by workflow name. */
-    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: {
-        mode?: 'waitAll' | 'failFast';
-    }): Promise<TOutput[]>;
+    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: AllOptions): Promise<TOutput[]>;
 }
 /** Result of executing or resuming a workflow run. */
 interface RunResult {
@@ -3330,6 +3385,8 @@ declare class ScheduleNotFoundError extends Error {
 interface ScheduleHost {
     start(workflow: string, input: unknown, runId: string, opts?: StartOptions): Promise<RunResult>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    /** True once the engine has begun shutting down; `tick` fires nothing more after that. */
+    isDraining?(): boolean;
 }
 /** Engine-level knobs for the client. */
 interface ScheduleClientOptions {
@@ -3742,6 +3799,8 @@ declare class WorkflowEngine {
     /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
     private readonly inflight;
     private draining;
+    /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
+    private drainSpentMs;
     constructor(deps: WorkflowEngineDeps);
     /**
      * Register a **durable entity** (a virtual object): a keyed actor whose `handlers` run **serialized
@@ -3995,10 +4054,25 @@ declare class WorkflowEngine {
     private findParentRunId;
     /** Track an in-flight execution so {@link drain} can wait for it. */
     private track;
+    /**
+     * Stop picking up new work without waiting: recovery, timer, schedule and timeout sweeps (and
+     * their per-run lock loops) start nothing once this is called, and {@link runOne} returns null. A
+     * poller calls it on its own shutdown so an in-flight sweep stops locking runs before it is awaited.
+     *
+     * `spentMs` is wait time ALREADY spent on this shutdown (the poller awaiting its in-flight sweep).
+     * It is deducted from the budget of a later {@link drain}, so that wait plus the drain stay within
+     * one `shutdownTimeoutMs`. Only time actually spent waiting is charged: time that merely passes
+     * between this call and `drain()` (other hooks, the HTTP server closing) never is. Calls add up.
+     */
+    beginDrain(spentMs?: number): void;
     /**
      * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
      * in-flight executions to settle, up to `timeoutMs`. Call from your app's shutdown hook so a
      * deploy hands off cleanly instead of leaving runs to the lease timeout.
+     *
+     * `timeoutMs` is the total budget for waiting on in-flight runs; any wait already reported through
+     * {@link beginDrain} (`spentMs`) is deducted, so a shutdown that already waited on the timer poll
+     * for part of it waits only for the remainder. With nothing reported, the full `timeoutMs` applies.
      */
     drain(timeoutMs?: number): Promise<void>;
     /**
@@ -4199,6 +4273,32 @@ declare class WorkflowEngine {
      * same way.
      */
     private deliverSignal;
+    /**
+     * The `ctx.all` join barrier: true when `waiter` was one child of a fan (or of one wave of it)
+     * whose siblings are still out, so waking the parent now would only replay the fan and re-suspend.
+     * Skipping that wake is what keeps a fan of N children at O(N) work instead of N replays of N items.
+     *
+     * Safe because the LAST sibling to settle always wakes the parent: each child consumes its own
+     * waiter before it asks, so whichever asks last sees none left. A failed child of a failFast fan
+     * always wakes it. Anything that is not a `ctx.all` waiter, or a store that cannot answer the
+     * question cheaply, wakes the parent as before.
+     */
+    private fanStillWaiting;
+    /**
+     * Re-drive a run that just suspended on awaited children (a `ctx.all` fan or wave, a `ctx.child`)
+     * which, by now, have settled.
+     *
+     * {@link execute} drops a wake that finds the run's lease held. So if a child settles while the
+     * parent is still executing (the turn that dispatched it, or one woken by an earlier child), that
+     * wake is spent, and the turn suspends on a snapshot that predates the child. With the `ctx.all`
+     * barrier that wake was the only one the fan would get. Nothing would wake the run until the
+     * `reconcileMs` sweep, minutes later.
+     *
+     * Called after the turn released its lease, so any child that settles from here on wakes the run
+     * itself. Only re-drives for a group with no waiter left whose checkpoints are all settled, which
+     * the next turn is then guaranteed to see — so it cannot loop.
+     */
+    private redriveSettledChildren;
     /**
      * Deliver an external signal to the run waiting on `token`, resume it with `payload`, and return
      * the run result — or null if no run is (or ends up) waiting for it.
@@ -4355,8 +4455,11 @@ declare class WorkflowEngine {
      * so a completed parent (or a completed awaited child) would otherwise drop out of the tree. The
      * `signal:child:<id>` checkpoint (the placeholder written when the parent first awaits the child,
      * overwritten as completed/failed when it settles) persists across completion, so we read both and
-     * dedupe — the edge stays stable for a finished run, not just a live one.
+     * dedupe — the edge stays stable for a finished run, not just a live one. A settled `ctx.all`
+     * group folded into one `fan:` checkpoint stands for every child in it.
      */
+    /** The children `parentRunId` is awaiting right now, read off its own live `child:` waiters. */
+    private awaitedChildIds;
     getRunChildren(parentRunId: string): Promise<string[]>;
     /** The worker groups this engine dispatches to: every registered remote workflow's group, plus any
      *  `extra` the caller declares. Local-step groups (a group consumed by in-process `@DurableStep`
@@ -4979,9 +5082,24 @@ declare class GatherError extends Error {
 declare class WorkflowSuspended extends Error {
     /** Epoch ms to auto-resume (durable sleep), or undefined when waiting on an external signal. */
     readonly wakeAt?: number | undefined;
+    /** Set when awaited children are what the run is waiting on — see {@link FanJoin}. */
+    readonly fan?: FanJoin | undefined;
     /** Marks this as a control-flow signal — see {@link isWorkflowControlFlowSignal}. */
     readonly [CONTROL_FLOW_SIGNAL] = true;
-    constructor(wakeAt?: number);
+    constructor(wakeAt?: number, fan?: FanJoin);
+}
+/**
+ * What a run suspended on when it awaits children (`ctx.all`, `ctx.child`). For each group of
+ * children, every waiter token starts with `waiterPrefix` and every `signal:child:` checkpoint name
+ * with `checkpointPrefix`, so the engine can tell whether the group has settled without knowing the
+ * children's ids.
+ */
+interface FanJoin {
+    waits: FanWait[];
+}
+interface FanWait {
+    waiterPrefix: string;
+    checkpointPrefix: string;
 }
 /**
  * Thrown by `ctx.continueAsNew(input)` to end the current run and hand off to a fresh execution of
@@ -5315,10 +5433,23 @@ declare function classifyWaiterToken(token: string): RunWaiting;
  * state (no-worker, singleton, running) on top — none of which can be told apart from `wakeAt` alone.
  */
 declare function resolveRunWaiting(run: WorkflowRun, waiterByRun: ReadonlyMap<string, SignalWaiter>): RunWaiting | undefined;
+/**
+ * The signal waiters of `runIds`: through the store's {@link StateStore.listSignalWaitersByRun} in
+ * bounded batches, or, for a store without it, one scan of every waiter filtered to those runs.
+ */
+declare function listSignalWaitersOfRuns(store: StateStore, runIds: readonly string[]): Promise<SignalWaiter[]>;
 /** 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 parent of a child run whose id the engine minted: a `ctx.all` child
+ * (`<parent>.all.<seq>.<i>`, or `.w<k>.<i>` under a `concurrency` limit) or a `ctx.child` /
+ * `ctx.startChild` child without an explicit id (`<parent>.child.<seq>`). Undefined for any other
+ * run, including a child started with a caller-chosen id.
+ */
+declare function parentRunIdOf(runId: string): string | undefined;
+
 /**
  * Transforms a payload value as it crosses the store boundary — e.g. encrypt-at-rest, compress, or
  * redact PII. `decode` must be the exact inverse of `encode`. Both are synchronous (use a local
@@ -5365,6 +5496,14 @@ declare class CodecStateStore implements StateStore {
     /** Forwarded verbatim — a count reads no payload. Bound only when the inner store counts, so the
      *  engine's facet/listing fallback still applies through the wrapper. */
     readonly countRuns?: (query: Omit<RunQuery, 'limit' | 'offset'>) => Promise<number>;
+    /** The placeholder checkpoints are encoded like any other checkpoint. */
+    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>;
+    /** Forwarded verbatim — a waiter carries no payload. */
+    readonly listSignalWaitersByRun?: (runIds: string[]) => Promise<SignalWaiter[]>;
+    /** Forwarded verbatim — a waiter carries no payload. */
+    readonly hasSignalWaiter?: (runId: string, tokenPrefix: string) => Promise<boolean>;
     /** Schedules persist their run `input` inside `spec` — encoded like any other payload. Bound only
      *  when the inner store persists schedules, so `engine.schedules` reports absence faithfully. */
     readonly saveSchedule?: (record: ScheduleRecord) => Promise<void>;
@@ -5829,6 +5968,10 @@ declare class InMemoryStateStore implements StateStore {
     putSignalWaiter(waiter: SignalWaiter): Promise<void>;
     takeSignalWaiter(token: string): Promise<SignalWaiter | null>;
     listSignalWaiters(prefix: string): Promise<SignalWaiter[]>;
+    registerChildWaits(entries: ChildWait[]): Promise<void>;
+    compactCheckpoints(runId: string, fromSeq: number, toSeq: number, into: StepCheckpoint): Promise<void>;
+    listSignalWaitersByRun(runIds: string[]): Promise<SignalWaiter[]>;
+    hasSignalWaiter(runId: string, tokenPrefix: string): Promise<boolean>;
     removeSignalWaiter(waiter: SignalWaiter): Promise<void>;
     transaction<T>(work: (tx: {
         raw: unknown;
@@ -5921,4 +6064,4 @@ declare function singletonAdmissionDenialPatch(runs: WorkflowRun[], runId: strin
     updatedAt: Date;
 } | undefined;
 
-export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AnnouncedWorkflow, type AnnouncementEvidence, type AttributeFilter, type AttributeOp, type AttributePredicateOperand, type AttributeValue, type BackoffStrategy, type BlockedDispatch, type BlockedResolution, CONTROL_FLOW_SIGNAL, CURRENT_PROTOCOL_VERSION, type CapabilityRequirement, type ChildCallOptions, CodecStateStore, type ConcurrencyConfig, ConcurrencyLimitError, type ConcurrencyQuota, ContinueAsNew, type ControlMessage, type ControlPlane, DEFAULT_CONCURRENCY_STATUSES, DEFAULT_PARTITION, 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, EVENT_BUFFER_SCAN_LIMIT, EVENT_TOKEN_PREFIX, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, GatherError, type GroupHealth, type Heartbeat, type HeartbeatSighting, type HeartbeatStatus, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type InferSearchAttributes, LEGACY_V1_CAPABILITIES, LEGACY_V1_PROTOCOL, type MetricsCollector, type MetricsSnapshot, type NamedTransport, type NegotiateOptions, type NegotiationOutcome, type NegotiationReason, type NegotiationResult, NestedWorkflowCallError, NonDeterminismError, type PartitionSighting, type PayloadCodec, type QueueConfig, QueueController, 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 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, STATE_STORE, STATE_STORE_CANONICAL, type ScalarAttributeFilter, ScheduleAlreadyExistsError, ScheduleClient, type ScheduleClientOptions, type ScheduleDescription, type ScheduleHost, type ScheduleListQuery, ScheduleNotFoundError, type ScheduleOptions, type ScheduleQuery, type ScheduleRecord, type ScheduledWorkflow, type SearchAttributes, type SearchAttributesSchema, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, 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 Transport, type UndoOf, type UpdateResult, type UpdateValidator, VERSION_UNDECLARED_TAG, 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, announcementsOf, applyAttributeQuery, assertConcurrency, attributeColumnFor, attributeOperand, attributePredicateOperands, axisIsRunColumn, bindWorkflowClass, breakpointToken, buildWorkflowDirectory, canRoute, capableWorkers, classifyWaiterToken, clearDurableExecutionWrappers, clearTerminalSingletonAdmission, collectMetrics, concurrencyTag, controlPlaneDescriptor, countRuns, coveredTokens, createStepLogger, currentStep, currentStepScope, currentWorkflowCtx, debug, describeWorker, descriptorHash, error, eventMatchOf, eventMatches, eventNameOf, eventPrefix, eventToken, facetOrigin, hasDurableExecutionWrappers, heartbeatStatus, indexWaitersByRun, info, isEngineMintedTag, isEventToken, isLegacyDescriptor, isNonEmptyRunScope, isWorkflowControlFlowSignal, log, matchesAttributes, mergeRunFacetRows, mergeRunValueFacetRows, missingCapabilities, negotiate, nextCronFireMs, normalizeAttributeRows, normalizeDescriptor, observedAnnouncements, parseDuration, partitionOfToken, planDispatch, prevCronFireMs, readSearchAttributes, requiredCapabilities, resolveConcurrency, resolveRouting, resolveRunWaiting, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduledRunId, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, tenantGroup, useDurableExecution, warn, workflowName };
+export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AllOptions, type AnnouncedWorkflow, type AnnouncementEvidence, type AttributeFilter, type AttributeOp, type AttributePredicateOperand, type AttributeValue, type BackoffStrategy, type BlockedDispatch, type BlockedResolution, CONTROL_FLOW_SIGNAL, CURRENT_PROTOCOL_VERSION, type CapabilityRequirement, type ChildCallOptions, type ChildWait, CodecStateStore, type ConcurrencyConfig, ConcurrencyLimitError, type ConcurrencyQuota, ContinueAsNew, type ControlMessage, type ControlPlane, DEFAULT_CONCURRENCY_STATUSES, DEFAULT_PARTITION, 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, EVENT_BUFFER_SCAN_LIMIT, EVENT_TOKEN_PREFIX, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, type FanJoin, type FanWait, FatalError, GatherError, type GroupHealth, type Heartbeat, type HeartbeatSighting, type HeartbeatStatus, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type InferSearchAttributes, LEGACY_V1_CAPABILITIES, LEGACY_V1_PROTOCOL, type MetricsCollector, type MetricsSnapshot, type NamedTransport, type NegotiateOptions, type NegotiationOutcome, type NegotiationReason, type NegotiationResult, NestedWorkflowCallError, NonDeterminismError, type PartitionSighting, type PayloadCodec, type QueueConfig, QueueController, 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 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, STATE_STORE, STATE_STORE_CANONICAL, type ScalarAttributeFilter, ScheduleAlreadyExistsError, ScheduleClient, type ScheduleClientOptions, type ScheduleDescription, type ScheduleHost, type ScheduleListQuery, ScheduleNotFoundError, type ScheduleOptions, type ScheduleQuery, type ScheduleRecord, type ScheduledWorkflow, type SearchAttributes, type SearchAttributesSchema, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, 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 Transport, type UndoOf, type UpdateResult, type UpdateValidator, VERSION_UNDECLARED_TAG, 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, announcementsOf, applyAttributeQuery, assertConcurrency, attributeColumnFor, attributeOperand, attributePredicateOperands, axisIsRunColumn, bindWorkflowClass, breakpointToken, buildWorkflowDirectory, canRoute, capableWorkers, classifyWaiterToken, clearDurableExecutionWrappers, clearTerminalSingletonAdmission, collectMetrics, concurrencyTag, controlPlaneDescriptor, countRuns, coveredTokens, createStepLogger, currentStep, currentStepScope, currentWorkflowCtx, debug, describeWorker, descriptorHash, error, eventMatchOf, eventMatches, eventNameOf, eventPrefix, eventToken, facetOrigin, hasDurableExecutionWrappers, heartbeatStatus, indexWaitersByRun, info, isEngineMintedTag, isEventToken, isLegacyDescriptor, isNonEmptyRunScope, isWorkflowControlFlowSignal, listSignalWaitersOfRuns, log, matchesAttributes, mergeRunFacetRows, mergeRunValueFacetRows, missingCapabilities, negotiate, nextCronFireMs, normalizeAttributeRows, normalizeDescriptor, observedAnnouncements, parentRunIdOf, parseDuration, partitionOfToken, planDispatch, prevCronFireMs, readSearchAttributes, requiredCapabilities, resolveConcurrency, resolveRouting, resolveRunWaiting, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduledRunId, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, tenantGroup, useDurableExecution, warn, workflowName };

package/dist/index.d.ts

@@ -995,6 +995,45 @@ interface StateStore {
     takeSignalWaiter(token: string): Promise<SignalWaiter | null>;
     /** List waiters whose `token` starts with `prefix` — used to fan out an event to its subscribers. */
     listSignalWaiters(prefix: string): Promise<SignalWaiter[]>;
+    /**
+     * Whether run `runId` still has at least one waiter whose `token` starts with `tokenPrefix` (an
+     * exact prefix: `%`/`_` in the prefix are literal characters, not wildcards). The `ctx.all` join
+     * barrier asks this after each child settles, so it must stay O(1)-ish however many siblings are
+     * still waiting — answer it with a bounded lookup, never by listing the whole group.
+     *
+     * Optional: a store without it keeps `ctx.all` correct, but the parent replays once per settled
+     * child instead of once per fan.
+     */
+    hasSignalWaiter?(runId: string, tokenPrefix: string): Promise<boolean>;
+    /**
+     * The waiters of the given runs. Lets the engine and the dashboard read what a page of runs (or
+     * one run's children) is waiting on without scanning every waiter in the store, which a wide fan
+     * fills with one row per running child. Callers pass ids in bounded batches.
+     *
+     * Optional: without it those reads fall back to {@link listSignalWaiters} over every waiter.
+     */
+    listSignalWaitersByRun?(runIds: string[]): Promise<SignalWaiter[]>;
+    /**
+     * Register a batch of awaited children: for each entry, put `waiter` and upsert `checkpoint` (the
+     * parent's `running` placeholder for that child). `ctx.all` calls it once per chunk of a fan, so a
+     * wide fan costs a handful of round trips instead of two per child.
+     *
+     * Every entry's waiter must be durable no later than its checkpoint: the engine reads an existing
+     * placeholder as proof the waiter was put, and never re-puts it. Writing both in one transaction
+     * satisfies that.
+     *
+     * Optional: without it the engine puts each waiter, then saves each checkpoint.
+     */
+    registerChildWaits?(entries: ChildWait[]): Promise<void>;
+    /**
+     * Atomically replace run `runId`'s checkpoints with `seq` in `[fromSeq, toSeq]` by the single
+     * checkpoint `into`, whose `seq` lies in that range. `ctx.all` folds a settled group of children
+     * into one checkpoint this way, so every later turn of the parent loads one row instead of one per
+     * child. A delete over a contiguous seq range, served by the `(runId, seq)` primary key.
+     *
+     * Optional: without it a settled fan keeps one checkpoint per child.
+     */
+    compactCheckpoints?(runId: string, fromSeq: number, toSeq: number, into: StepCheckpoint): Promise<void>;
     /**
      * Delete the EXACT waiter row — `token` AND `runId` AND `seq` must all match — no-op if absent.
      * Unlike {@link takeSignalWaiter}, which deletes ANY row for `token` (fine when the caller just won
@@ -1421,6 +1460,26 @@ interface StoreTransaction {
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
 }
 /** Binds an external signal `token` to the suspended run/step position waiting for it. */
+/** Options for {@link WorkflowCtx.all}. */
+interface AllOptions {
+    /** `waitAll` (default) or `failFast` — see {@link WorkflowCtx.all}. */
+    mode?: 'waitAll' | 'failFast';
+    /**
+     * The most children running at once. Unset sends the whole fan immediately. When set, children go
+     * out in waves of `floor(concurrency / 2)`, two at a time (an odd limit runs one child under it):
+     * a new wave starts as soon as an earlier one settles, so one slow child does not idle the rest of
+     * the window. Each settled wave costs the parent one turn.
+     *
+     * Part of the fan's identity: child ids carry the wave, so changing it for an in-flight run is a
+     * non-deterministic change like changing `inputs`.
+     */
+    concurrency?: number;
+}
+/** One child of a fan as {@link StateStore.registerChildWaits} writes it. */
+interface ChildWait {
+    waiter: SignalWaiter;
+    checkpoint: StepCheckpoint;
+}
 interface SignalWaiter {
     token: string;
     runId: string;
@@ -2287,13 +2346,11 @@ interface WorkflowCtx<A extends SearchAttributes = SearchAttributes> {
      * 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`.
+     *
+     * `concurrency` caps how many children run at once (see {@link AllOptions.concurrency}).
      */
-    all<C extends WorkflowClass>(workflow: C, inputs: WorkflowInputOf<C>[], opts?: {
-        mode?: 'waitAll' | 'failFast';
-    }): Promise<WorkflowOutputOf<C>[]>;
-    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: {
-        mode?: 'waitAll' | 'failFast';
-    }): Promise<TOutput[]>;
+    all<C extends WorkflowClass>(workflow: C, inputs: WorkflowInputOf<C>[], opts?: AllOptions): Promise<WorkflowOutputOf<C>[]>;
+    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: AllOptions): Promise<TOutput[]>;
     /**
      * 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
@@ -2416,9 +2473,7 @@ interface DynamicWorkflowCtx<A extends SearchAttributes = SearchAttributes> exte
     /** {@link WorkflowCtx.startChild} by workflow name. */
     startChild(workflow: string, input: unknown, options?: string | ChildCallOptions): Promise<string>;
     /** {@link WorkflowCtx.all} by workflow name. */
-    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: {
-        mode?: 'waitAll' | 'failFast';
-    }): Promise<TOutput[]>;
+    all<TOutput = unknown>(workflow: string, inputs: unknown[], opts?: AllOptions): Promise<TOutput[]>;
 }
 /** Result of executing or resuming a workflow run. */
 interface RunResult {
@@ -3330,6 +3385,8 @@ declare class ScheduleNotFoundError extends Error {
 interface ScheduleHost {
     start(workflow: string, input: unknown, runId: string, opts?: StartOptions): Promise<RunResult>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    /** True once the engine has begun shutting down; `tick` fires nothing more after that. */
+    isDraining?(): boolean;
 }
 /** Engine-level knobs for the client. */
 interface ScheduleClientOptions {
@@ -3742,6 +3799,8 @@ declare class WorkflowEngine {
     /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
     private readonly inflight;
     private draining;
+    /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
+    private drainSpentMs;
     constructor(deps: WorkflowEngineDeps);
     /**
      * Register a **durable entity** (a virtual object): a keyed actor whose `handlers` run **serialized
@@ -3995,10 +4054,25 @@ declare class WorkflowEngine {
     private findParentRunId;
     /** Track an in-flight execution so {@link drain} can wait for it. */
     private track;
+    /**
+     * Stop picking up new work without waiting: recovery, timer, schedule and timeout sweeps (and
+     * their per-run lock loops) start nothing once this is called, and {@link runOne} returns null. A
+     * poller calls it on its own shutdown so an in-flight sweep stops locking runs before it is awaited.
+     *
+     * `spentMs` is wait time ALREADY spent on this shutdown (the poller awaiting its in-flight sweep).
+     * It is deducted from the budget of a later {@link drain}, so that wait plus the drain stay within
+     * one `shutdownTimeoutMs`. Only time actually spent waiting is charged: time that merely passes
+     * between this call and `drain()` (other hooks, the HTTP server closing) never is. Calls add up.
+     */
+    beginDrain(spentMs?: number): void;
     /**
      * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
      * in-flight executions to settle, up to `timeoutMs`. Call from your app's shutdown hook so a
      * deploy hands off cleanly instead of leaving runs to the lease timeout.
+     *
+     * `timeoutMs` is the total budget for waiting on in-flight runs; any wait already reported through
+     * {@link beginDrain} (`spentMs`) is deducted, so a shutdown that already waited on the timer poll
+     * for part of it waits only for the remainder. With nothing reported, the full `timeoutMs` applies.
      */
     drain(timeoutMs?: number): Promise<void>;
     /**
@@ -4199,6 +4273,32 @@ declare class WorkflowEngine {
      * same way.
      */
     private deliverSignal;
+    /**
+     * The `ctx.all` join barrier: true when `waiter` was one child of a fan (or of one wave of it)
+     * whose siblings are still out, so waking the parent now would only replay the fan and re-suspend.
+     * Skipping that wake is what keeps a fan of N children at O(N) work instead of N replays of N items.
+     *
+     * Safe because the LAST sibling to settle always wakes the parent: each child consumes its own
+     * waiter before it asks, so whichever asks last sees none left. A failed child of a failFast fan
+     * always wakes it. Anything that is not a `ctx.all` waiter, or a store that cannot answer the
+     * question cheaply, wakes the parent as before.
+     */
+    private fanStillWaiting;
+    /**
+     * Re-drive a run that just suspended on awaited children (a `ctx.all` fan or wave, a `ctx.child`)
+     * which, by now, have settled.
+     *
+     * {@link execute} drops a wake that finds the run's lease held. So if a child settles while the
+     * parent is still executing (the turn that dispatched it, or one woken by an earlier child), that
+     * wake is spent, and the turn suspends on a snapshot that predates the child. With the `ctx.all`
+     * barrier that wake was the only one the fan would get. Nothing would wake the run until the
+     * `reconcileMs` sweep, minutes later.
+     *
+     * Called after the turn released its lease, so any child that settles from here on wakes the run
+     * itself. Only re-drives for a group with no waiter left whose checkpoints are all settled, which
+     * the next turn is then guaranteed to see — so it cannot loop.
+     */
+    private redriveSettledChildren;
     /**
      * Deliver an external signal to the run waiting on `token`, resume it with `payload`, and return
      * the run result — or null if no run is (or ends up) waiting for it.
@@ -4355,8 +4455,11 @@ declare class WorkflowEngine {
      * so a completed parent (or a completed awaited child) would otherwise drop out of the tree. The
      * `signal:child:<id>` checkpoint (the placeholder written when the parent first awaits the child,
      * overwritten as completed/failed when it settles) persists across completion, so we read both and
-     * dedupe — the edge stays stable for a finished run, not just a live one.
+     * dedupe — the edge stays stable for a finished run, not just a live one. A settled `ctx.all`
+     * group folded into one `fan:` checkpoint stands for every child in it.
      */
+    /** The children `parentRunId` is awaiting right now, read off its own live `child:` waiters. */
+    private awaitedChildIds;
     getRunChildren(parentRunId: string): Promise<string[]>;
     /** The worker groups this engine dispatches to: every registered remote workflow's group, plus any
      *  `extra` the caller declares. Local-step groups (a group consumed by in-process `@DurableStep`
@@ -4979,9 +5082,24 @@ declare class GatherError extends Error {
 declare class WorkflowSuspended extends Error {
     /** Epoch ms to auto-resume (durable sleep), or undefined when waiting on an external signal. */
     readonly wakeAt?: number | undefined;
+    /** Set when awaited children are what the run is waiting on — see {@link FanJoin}. */
+    readonly fan?: FanJoin | undefined;
     /** Marks this as a control-flow signal — see {@link isWorkflowControlFlowSignal}. */
     readonly [CONTROL_FLOW_SIGNAL] = true;
-    constructor(wakeAt?: number);
+    constructor(wakeAt?: number, fan?: FanJoin);
+}
+/**
+ * What a run suspended on when it awaits children (`ctx.all`, `ctx.child`). For each group of
+ * children, every waiter token starts with `waiterPrefix` and every `signal:child:` checkpoint name
+ * with `checkpointPrefix`, so the engine can tell whether the group has settled without knowing the
+ * children's ids.
+ */
+interface FanJoin {
+    waits: FanWait[];
+}
+interface FanWait {
+    waiterPrefix: string;
+    checkpointPrefix: string;
 }
 /**
  * Thrown by `ctx.continueAsNew(input)` to end the current run and hand off to a fresh execution of
@@ -5315,10 +5433,23 @@ declare function classifyWaiterToken(token: string): RunWaiting;
  * state (no-worker, singleton, running) on top — none of which can be told apart from `wakeAt` alone.
  */
 declare function resolveRunWaiting(run: WorkflowRun, waiterByRun: ReadonlyMap<string, SignalWaiter>): RunWaiting | undefined;
+/**
+ * The signal waiters of `runIds`: through the store's {@link StateStore.listSignalWaitersByRun} in
+ * bounded batches, or, for a store without it, one scan of every waiter filtered to those runs.
+ */
+declare function listSignalWaitersOfRuns(store: StateStore, runIds: readonly string[]): Promise<SignalWaiter[]>;
 /** 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 parent of a child run whose id the engine minted: a `ctx.all` child
+ * (`<parent>.all.<seq>.<i>`, or `.w<k>.<i>` under a `concurrency` limit) or a `ctx.child` /
+ * `ctx.startChild` child without an explicit id (`<parent>.child.<seq>`). Undefined for any other
+ * run, including a child started with a caller-chosen id.
+ */
+declare function parentRunIdOf(runId: string): string | undefined;
+
 /**
  * Transforms a payload value as it crosses the store boundary — e.g. encrypt-at-rest, compress, or
  * redact PII. `decode` must be the exact inverse of `encode`. Both are synchronous (use a local
@@ -5365,6 +5496,14 @@ declare class CodecStateStore implements StateStore {
     /** Forwarded verbatim — a count reads no payload. Bound only when the inner store counts, so the
      *  engine's facet/listing fallback still applies through the wrapper. */
     readonly countRuns?: (query: Omit<RunQuery, 'limit' | 'offset'>) => Promise<number>;
+    /** The placeholder checkpoints are encoded like any other checkpoint. */
+    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>;
+    /** Forwarded verbatim — a waiter carries no payload. */
+    readonly listSignalWaitersByRun?: (runIds: string[]) => Promise<SignalWaiter[]>;
+    /** Forwarded verbatim — a waiter carries no payload. */
+    readonly hasSignalWaiter?: (runId: string, tokenPrefix: string) => Promise<boolean>;
     /** Schedules persist their run `input` inside `spec` — encoded like any other payload. Bound only
      *  when the inner store persists schedules, so `engine.schedules` reports absence faithfully. */
     readonly saveSchedule?: (record: ScheduleRecord) => Promise<void>;
@@ -5829,6 +5968,10 @@ declare class InMemoryStateStore implements StateStore {
     putSignalWaiter(waiter: SignalWaiter): Promise<void>;
     takeSignalWaiter(token: string): Promise<SignalWaiter | null>;
     listSignalWaiters(prefix: string): Promise<SignalWaiter[]>;
+    registerChildWaits(entries: ChildWait[]): Promise<void>;
+    compactCheckpoints(runId: string, fromSeq: number, toSeq: number, into: StepCheckpoint): Promise<void>;
+    listSignalWaitersByRun(runIds: string[]): Promise<SignalWaiter[]>;
+    hasSignalWaiter(runId: string, tokenPrefix: string): Promise<boolean>;
     removeSignalWaiter(waiter: SignalWaiter): Promise<void>;
     transaction<T>(work: (tx: {
         raw: unknown;
@@ -5921,4 +6064,4 @@ declare function singletonAdmissionDenialPatch(runs: WorkflowRun[], runId: strin
     updatedAt: Date;
 } | undefined;
 
-export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AnnouncedWorkflow, type AnnouncementEvidence, type AttributeFilter, type AttributeOp, type AttributePredicateOperand, type AttributeValue, type BackoffStrategy, type BlockedDispatch, type BlockedResolution, CONTROL_FLOW_SIGNAL, CURRENT_PROTOCOL_VERSION, type CapabilityRequirement, type ChildCallOptions, CodecStateStore, type ConcurrencyConfig, ConcurrencyLimitError, type ConcurrencyQuota, ContinueAsNew, type ControlMessage, type ControlPlane, DEFAULT_CONCURRENCY_STATUSES, DEFAULT_PARTITION, 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, EVENT_BUFFER_SCAN_LIMIT, EVENT_TOKEN_PREFIX, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, FatalError, GatherError, type GroupHealth, type Heartbeat, type HeartbeatSighting, type HeartbeatStatus, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type InferSearchAttributes, LEGACY_V1_CAPABILITIES, LEGACY_V1_PROTOCOL, type MetricsCollector, type MetricsSnapshot, type NamedTransport, type NegotiateOptions, type NegotiationOutcome, type NegotiationReason, type NegotiationResult, NestedWorkflowCallError, NonDeterminismError, type PartitionSighting, type PayloadCodec, type QueueConfig, QueueController, 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 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, STATE_STORE, STATE_STORE_CANONICAL, type ScalarAttributeFilter, ScheduleAlreadyExistsError, ScheduleClient, type ScheduleClientOptions, type ScheduleDescription, type ScheduleHost, type ScheduleListQuery, ScheduleNotFoundError, type ScheduleOptions, type ScheduleQuery, type ScheduleRecord, type ScheduledWorkflow, type SearchAttributes, type SearchAttributesSchema, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, 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 Transport, type UndoOf, type UpdateResult, type UpdateValidator, VERSION_UNDECLARED_TAG, 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, announcementsOf, applyAttributeQuery, assertConcurrency, attributeColumnFor, attributeOperand, attributePredicateOperands, axisIsRunColumn, bindWorkflowClass, breakpointToken, buildWorkflowDirectory, canRoute, capableWorkers, classifyWaiterToken, clearDurableExecutionWrappers, clearTerminalSingletonAdmission, collectMetrics, concurrencyTag, controlPlaneDescriptor, countRuns, coveredTokens, createStepLogger, currentStep, currentStepScope, currentWorkflowCtx, debug, describeWorker, descriptorHash, error, eventMatchOf, eventMatches, eventNameOf, eventPrefix, eventToken, facetOrigin, hasDurableExecutionWrappers, heartbeatStatus, indexWaitersByRun, info, isEngineMintedTag, isEventToken, isLegacyDescriptor, isNonEmptyRunScope, isWorkflowControlFlowSignal, log, matchesAttributes, mergeRunFacetRows, mergeRunValueFacetRows, missingCapabilities, negotiate, nextCronFireMs, normalizeAttributeRows, normalizeDescriptor, observedAnnouncements, parseDuration, partitionOfToken, planDispatch, prevCronFireMs, readSearchAttributes, requiredCapabilities, resolveConcurrency, resolveRouting, resolveRunWaiting, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduledRunId, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, tenantGroup, useDurableExecution, warn, workflowName };
+export { type AccumulatorHost, type Admission, type AdmissionBackend, type AdmissionItem, type AllOptions, type AnnouncedWorkflow, type AnnouncementEvidence, type AttributeFilter, type AttributeOp, type AttributePredicateOperand, type AttributeValue, type BackoffStrategy, type BlockedDispatch, type BlockedResolution, CONTROL_FLOW_SIGNAL, CURRENT_PROTOCOL_VERSION, type CapabilityRequirement, type ChildCallOptions, type ChildWait, CodecStateStore, type ConcurrencyConfig, ConcurrencyLimitError, type ConcurrencyQuota, ContinueAsNew, type ControlMessage, type ControlPlane, DEFAULT_CONCURRENCY_STATUSES, DEFAULT_PARTITION, 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, EVENT_BUFFER_SCAN_LIMIT, EVENT_TOKEN_PREFIX, type EngineEvent, type EngineEventType, type EngineListener, Entities, type EntityConfig, type EntityHandler, type EntityHost, EventAccumulators, type EventBatchConfig, type FanJoin, type FanWait, FatalError, GatherError, type GroupHealth, type Heartbeat, type HeartbeatSighting, type HeartbeatStatus, type HistoryEvent, InMemoryAdmissionBackend, InMemoryStateStore, InMemoryTransport, type InferSearchAttributes, LEGACY_V1_CAPABILITIES, LEGACY_V1_PROTOCOL, type MetricsCollector, type MetricsSnapshot, type NamedTransport, type NegotiateOptions, type NegotiationOutcome, type NegotiationReason, type NegotiationResult, NestedWorkflowCallError, NonDeterminismError, type PartitionSighting, type PayloadCodec, type QueueConfig, QueueController, 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 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, STATE_STORE, STATE_STORE_CANONICAL, type ScalarAttributeFilter, ScheduleAlreadyExistsError, ScheduleClient, type ScheduleClientOptions, type ScheduleDescription, type ScheduleHost, type ScheduleListQuery, ScheduleNotFoundError, type ScheduleOptions, type ScheduleQuery, type ScheduleRecord, type ScheduledWorkflow, type SearchAttributes, type SearchAttributesSchema, SignalTimeoutError, type SignalWaiter, type SingletonConfig, SingletonQueueFullError, 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 Transport, type UndoOf, type UpdateResult, type UpdateValidator, VERSION_UNDECLARED_TAG, 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, announcementsOf, applyAttributeQuery, assertConcurrency, attributeColumnFor, attributeOperand, attributePredicateOperands, axisIsRunColumn, bindWorkflowClass, breakpointToken, buildWorkflowDirectory, canRoute, capableWorkers, classifyWaiterToken, clearDurableExecutionWrappers, clearTerminalSingletonAdmission, collectMetrics, concurrencyTag, controlPlaneDescriptor, countRuns, coveredTokens, createStepLogger, currentStep, currentStepScope, currentWorkflowCtx, debug, describeWorker, descriptorHash, error, eventMatchOf, eventMatches, eventNameOf, eventPrefix, eventToken, facetOrigin, hasDurableExecutionWrappers, heartbeatStatus, indexWaitersByRun, info, isEngineMintedTag, isEventToken, isLegacyDescriptor, isNonEmptyRunScope, isWorkflowControlFlowSignal, listSignalWaitersOfRuns, log, matchesAttributes, mergeRunFacetRows, mergeRunValueFacetRows, missingCapabilities, negotiate, nextCronFireMs, normalizeAttributeRows, normalizeDescriptor, observedAnnouncements, parentRunIdOf, parseDuration, partitionOfToken, planDispatch, prevCronFireMs, readSearchAttributes, requiredCapabilities, resolveConcurrency, resolveRouting, resolveRunWaiting, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduledRunId, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, tenantGroup, useDurableExecution, warn, workflowName };