@dudousxd/nestjs-durable-core 0.72.1 → 0.74.0

package/dist/index.d.ts

@@ -919,6 +919,17 @@ interface StateStore {
      * module's `autoSchema` is on. Optional: stores that need no setup (in-memory) omit it.
      */
     ensureSchema?(): Promise<void>;
+    /**
+     * Atomically read active runs sharing workflow/tag in this store's read scope, preserve durable
+     * admitted holders, and claim a free slot for an eligible FIFO waiter. The claim persists the
+     * reserved SINGLETON_ADMITTED_TAG in tags. Execution lease expiry never releases a slot; terminal
+     * status does. Optional for general stores, required when using singleton workflows. Implement
+     * with a database transaction that serializes competing claims BEFORE reading; list/update alone
+     * is unsafe across engine instances. If retryWakeAt is supplied, denial must atomically suspend
+     * the still-active candidate with that wakeAt while the same locks are held. Never overwrite a
+     * cancelling or terminal run on denial. Return false for missing/terminal/out-of-scope runs.
+     */
+    tryAdmitSingleton?(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
     updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
     getRun(runId: string): Promise<WorkflowRun | null>;
@@ -984,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
@@ -1410,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;
@@ -2276,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
@@ -2405,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 {
@@ -3441,8 +3507,8 @@ interface StartOptions {
 /**
  * Serialize runs of a workflow that share a key — a durable, FIFO mutex (e.g. one pipeline per base).
  * Excess runs are admitted in creation order, `limit` at a time; the rest wait (suspended) and retry
- * admission on a timer until a slot frees. Race-free on a consistent store (admission order is the
- * same `(createdAt, id)` view for every instance).
+ * admission on a timer until a slot frees. The store atomically reserves durable slots before
+ * ordering unadmitted waiters by `(createdAt, id)`, so later starts cannot displace a holder.
  */
 interface SingletonConfig {
     /** Derive the serialization key from the workflow input. */
@@ -3453,7 +3519,7 @@ interface SingletonConfig {
      * Max GATED (waiting-for-admission) runs allowed to queue behind the `limit` in-flight ones. When
      * set, `start` rejects with {@link SingletonQueueFullError} once in-flight + gated reaches
      * `limit + maxQueueDepth` — back-pressure against an unbounded same-key backlog. Omit for the
-     * default unbounded queue. Counts `pending`/`running`/`suspended` runs sharing the key.
+     * default unbounded queue. Counts pending/running/suspended/blocked/cancelling runs sharing the key.
      */
     maxQueueDepth?: number;
 }
@@ -4188,6 +4254,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.
@@ -4344,8 +4436,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`
@@ -4427,6 +4522,8 @@ declare class WorkflowEngine {
     private completeStep;
     /** Checkpoint a step that failed terminally, so the failure point is visible (not just the run). */
     private failStep;
+    /** Admission persists the wait atomically; never overwrite a cancellation after it returns. */
+    private singletonWaitResult;
     private execute;
     /**
      * Advance a remote (cross-SDK) workflow one turn: hand its history to the executor (which dispatches
@@ -4966,9 +5063,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
@@ -5302,10 +5414,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
@@ -5328,6 +5453,8 @@ interface PayloadCodec {
 declare class CodecStateStore implements StateStore {
     private readonly inner;
     private readonly codec;
+    /** Atomic claims touch only searchable metadata and bypass payload encoding. */
+    readonly tryAdmitSingleton?: (runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number) => Promise<boolean>;
     /**
      * Forwarded verbatim — a facet cell counts `status`/`origin`, neither of which the codec touches
      * (it encodes payloads: input/output/error). Bound as a PROPERTY, and only when the inner store
@@ -5350,6 +5477,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>;
@@ -5796,8 +5931,9 @@ declare class InMemoryStateStore implements StateStore {
     private key;
     /** Drop then re-add a run's normalized attribute rows so the index tracks its current attributes. */
     private reindexAttributes;
+    tryAdmitSingleton(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
-    updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
+    updateRun(runId: string, inputPatch: Partial<WorkflowRun>): Promise<void>;
     getRun(runId: string): Promise<WorkflowRun | null>;
     deleteRun(runId: string): Promise<void>;
     deleteRuns(runIds: string[]): Promise<void>;
@@ -5813,6 +5949,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;
@@ -5891,4 +6031,18 @@ declare class InMemoryTransport implements Transport, ControlPlane {
     onControl(handler: (msg: ControlMessage) => void): void;
 }
 
-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, 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, 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, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, tenantGroup, useDurableExecution, warn, workflowName };
+/** Reserved engine metadata: a durable singleton slot, independent of the execution lease. */
+declare const SINGLETON_ADMITTED_TAG = "durable:singleton:admitted";
+declare const SINGLETON_ACTIVE_STATUSES: RunStatus[];
+/** Call only inside a store's atomic admission transaction/critical section. */
+declare function singletonAdmissionTags(runs: WorkflowRun[], runId: string, tag: string, workflow: string, limit: number): string[] | null;
+/** Terminal runs release admission, including when later resumed directly rather than requeued. */
+declare function clearTerminalSingletonAdmission(runId: string, patch: Partial<WorkflowRun>, getRun: (id: string) => Promise<WorkflowRun | null>): Promise<Partial<WorkflowRun>>;
+/** Persist denial while admission locks are held; a cancelling/terminal run must never revive. */
+declare function singletonAdmissionDenialPatch(runs: WorkflowRun[], runId: string, tag: string, workflow: string, retryWakeAt?: number): {
+    status: 'suspended';
+    wakeAt: number;
+    updatedAt: Date;
+} | undefined;
+
+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 };