@dudousxd/nestjs-durable-core 0.80.0 → 0.81.0

package/dist/index.d.ts

@@ -1150,6 +1150,16 @@ interface StepError {
     retryable?: boolean | undefined;
     stack?: string | undefined;
 }
+/**
+ * See {@link StateStore.listOrphanedRuns}: the live leases a rebooted engine instance may take back
+ * immediately, i.e. those its previous incarnation (same `instanceId`) held when it died.
+ */
+interface OwnedLeaseReclaim {
+    /** The engine instance id the lease must be held by. */
+    owner: string;
+    /** Only leases expiring strictly before this epoch ms (the caller's boot time + `leaseMs`). */
+    lockedBefore: number;
+}
 interface StateStore {
     /**
      * Provision the tables/collections this store needs, idempotently. Called on boot when the
@@ -1251,8 +1261,16 @@ interface StateStore {
      * Optional but recommended: without it the engine lists every incomplete run and filters the
      * leases in process, which on a busy fleet reads every healthy running run once per tick per
      * worker.
-     */
-    listOrphanedRuns?(nowMs: number, limit: number, namespace?: string): Promise<WorkflowRun[]>;
+     *
+     * When `ownedBy` is given, ALSO return the runs whose lease is still live but held by
+     * `ownedBy.owner` with `lockedUntil < ownedBy.lockedBefore` (strictly), under the same status,
+     * namespace, order and `limit`. The engine passes its own `instanceId` and its boot time plus
+     * `leaseMs`: a lease that expires before then was taken by a PREVIOUS process with the same stable
+     * `instanceId` (one killed without a graceful shutdown), never by this one, so it reclaims those
+     * at once instead of waiting out the lease. A store that ignores the argument keeps the plain
+     * behaviour: those runs are reclaimed once their lease expires.
+     */
+    listOrphanedRuns?(nowMs: number, limit: number, namespace?: string, ownedBy?: OwnedLeaseReclaim): Promise<WorkflowRun[]>;
     /** The oldest `pending` runs awaiting dispatch (FIFO, by `createdAt`), capped at `limit`. */
     listPendingRuns(limit: number, namespace?: string): Promise<WorkflowRun[]>;
     /**
@@ -1568,6 +1586,13 @@ interface ScheduleQuery {
 /** The terminal run statuses — a run in one of these is finished and will never change on its own.
  *  Only these are eligible for retention pruning (a {@link RetentionPolicy} targeting a non-terminal
  *  status would race the engine and delete live work). */
+/**
+ * Normalise a namespace to the worker pool it names: `''` is the default pool, exactly like
+ * `'default'` (the transport already maps both to the bare token), so it is stamped, polled and
+ * compared as `'default'`. `undefined` passes through untouched: an UNSET engine namespace is the
+ * operator (drives every namespace), and an unset run namespace belongs to everyone.
+ */
+declare function poolNamespace(namespace: string | undefined): string | undefined;
 declare const TERMINAL_RUN_STATUSES: readonly RunStatus[];
 /**
  * One retention rule for hard-pruning terminal run history. Within `statuses` (terminal only), a run
@@ -3218,6 +3243,20 @@ interface EntityHost {
     getEvent<T>(runId: string, key: string): Promise<T | undefined>;
     signal(token: string, payload: unknown): Promise<unknown>;
 }
+/**
+ * What a workflow-side send needs on top of {@link EntityHost}: a durable buffer write it can AWAIT
+ * inside its turn, and a way to wake an entity run that is parked on its wait. Optional so a bare
+ * {@link EntityHost} (tests, older hosts) still works through {@link Entities.dispatch}.
+ */
+interface EntityWorkflowHost {
+    /** Durably buffer `payload` on `token` (the store's `bufferSignal`). */
+    bufferSignal(token: string, payload: unknown): Promise<void>;
+    /** If a run is parked on `token`, wake it with `payload`; if none is, do nothing (no buffering). */
+    wakeWaiter(token: string, payload: unknown): Promise<unknown>;
+    /** Start `runId` of `workflow` if it doesn't exist yet (idempotent by run id). */
+    ensureStarted(workflow: string, input: unknown, runId: string): Promise<unknown>;
+}
+declare const ENTITY_WORKFLOW = "__entity";
 /**
  * Durable keyed **entities** (virtual objects): a keyed actor whose handlers run **serialized per
  * key** over **durable state**, exactly once. Each key is one long-lived run (`entity:<name>:<key>`)
@@ -3226,14 +3265,35 @@ interface EntityHost {
  */
 declare class Entities {
     private readonly host;
+    private readonly workflowHost?;
     private readonly configs;
-    constructor(host: EntityHost);
+    constructor(host: EntityHost, workflowHost?: EntityWorkflowHost | undefined);
     register<S>(name: string, config: EntityConfig<S>): void;
     /** Deliver an op to an entity's runner, starting it on first contact. `reply` (a signal token)
      *  receives the handler's result, for `ctx.callEntity`. */
     dispatch(name: string, key: string, op: string, arg: unknown, reply?: string): Promise<{
         runId: string;
     }>;
+    /**
+     * The durable half of a send from INSIDE a workflow (`ctx.callEntity` / `ctx.signalEntity`): write
+     * the op to the entity's signal buffer and return once it is stored, so the caller can checkpoint
+     * after it. The op carries `id`, the caller's stable `<runId>:<seq>`, so if the caller dies between
+     * this write and its checkpoint and sends again on replay, the entity skips the second copy. The
+     * entity's run is also ensured here, awaited (`start` only enqueues, it never runs the body
+     * inline), so an op sent on first contact can't be stranded in a buffer no run will ever read if
+     * the process dies right after. The wake-up ({@link kick}) is separate and may be lost: a busy
+     * entity reads the buffer at its next wait, and a parked one is paired with it by the engine's
+     * `reconcileMs` sweep. Returns `false` on a host without a workflow host.
+     */
+    enqueue(name: string, key: string, op: string, arg: unknown, id: string, reply?: string): Promise<boolean>;
+    /**
+     * Make the entity act on what {@link enqueue} buffered: wake its run if it is parked on its wait
+     * (the run itself was ensured by `enqueue`; ensured again here, idempotently, for a caller replay
+     * that only re-kicks). A run that is busy needs nothing: its next wait reads the buffer before
+     * suspending. The wake carries a no-op `nudge`, never the op itself, so the op stays in
+     * the buffer in arrival order and a lost or repeated kick costs at most one empty iteration.
+     */
+    kick(name: string, key: string): Promise<void>;
     signal(name: string, key: string, op: string, arg?: unknown): Promise<void>;
     getState<S = unknown>(name: string, key: string): Promise<S | undefined>;
     /** The built-in runner: one long-lived run per key, processing ops serially over state. */
@@ -4241,6 +4301,12 @@ declare class WorkflowEngine {
     private readonly instanceId;
     private readonly namespace;
     private readonly leaseMs;
+    /**
+     * Leases held by this `instanceId` that expire strictly before this epoch ms were taken by a
+     * PREVIOUS process with the same id (every lease this one takes or renews expires at
+     * `clock() + leaseMs`, so at or after it). See {@link orphanedRuns}.
+     */
+    private readonly ownLeaseCutoffMs;
     private readonly maxRecoveryAttempts?;
     private readonly remoteAdvanceSilenceMs?;
     private readonly reconcileMs;
@@ -4677,6 +4743,15 @@ declare class WorkflowEngine {
      * `execution_timeout` error (terminal, so a late step result can't resurrect it), AND its children
      * are cascaded exactly as an explicit {@link cancel} cascades them.
      *
+     * WHICH RUNS. Every run not yet finished, counted from `createdAt`: `pending` and `blocked` as well
+     * as `running` and `suspended`. A run nobody picks up (no worker on its queue) or nobody can run (no
+     * worker with its capabilities) is as stuck as one that hangs mid-body, and the cap is the backstop
+     * for exactly that — leaving them out meant a run that never started lived forever while one that
+     * started and hung was cut off. Cancelling one a worker is picking up at that moment is safe: the
+     * worker's settle only writes over a live status ({@link SETTLE_ELIGIBLE_STATUSES}), so it can't
+     * bring the run back. `cancelling` is left alone on purpose — a compensating cancel's saga undo is
+     * running, it ends `cancelled` by itself, and cutting it short would skip the undo.
+     *
      * WHY THE TERMINAL WRITE IS DIRECT, not a call to {@link cancel}. Two reasons, both still standing:
      * the run must land with the `execution_timeout` error `cancel` knows nothing about (`cancel` writes
      * a plain `cancelled`, and the code is what a dashboard/alert distinguishes a timeout by), and this
@@ -4689,8 +4764,8 @@ declare class WorkflowEngine {
      * children kept running with the parent gone and nothing pointing at them — a silent orphan you
      * could only find by reading the runs table by hand. {@link cancelChildren} is the SAME recursive
      * walk `cancel` uses, so children of children go too, and it inherits that path's two guards:
-     * `cancel` returns early on a run that is already `completed`/`cancelled`/`dead` (a child that beat
-     * the sweep to the finish is never clobbered, and a re-cancel is a no-op), and it writes the
+     * `cancel` returns early on a run that is already terminal (a child that beat the sweep to the
+     * finish is never clobbered, and a re-cancel is a no-op), and it writes the
      * parent's terminal status BEFORE recursing, so a cyclic parent→child graph terminates on the
      * second visit instead of looping. Two pollers sweeping the same run concurrently therefore write
      * the same terminal state twice and cascade into already-cancelled children — idempotent, not
@@ -4707,6 +4782,27 @@ declare class WorkflowEngine {
      * replay from their checkpoints, so only the work that had not finished runs again.
      */
     recoverIncomplete(nowMs?: number): Promise<RunResult[]>;
+    /** A run whose still-live lease is held by this very `instanceId` (see {@link reclaimOwnLease}). */
+    private isOwnLiveLease;
+    /**
+     * Recover a run whose lease is still live but held by THIS `instanceId` and predates this process
+     * (listed by {@link orphanedRuns}): the previous process with this stable id died without a
+     * graceful shutdown (OOM, SIGKILL), so nothing is renewing that lease and waiting for it to expire
+     * only delays the run. The lease is taken back with `renewRunLock` (a compare-and-set on the
+     * owner; `tryLockRun` refuses a live lease), so the lease alone cannot fence a live execution in
+     * THIS process from its own recovery: the in-process run gate does. A run with a
+     * gate is executing (or about to) here and is skipped; otherwise a gate is held while the run is
+     * recovered, so a resume landing meanwhile queues behind the recovery instead of running beside it.
+     * The gate is released before the re-dispatch, which may resume the run on this instance.
+     */
+    private reclaimOwnLease;
+    /**
+     * One run of a {@link recoverIncomplete} pass: take its lease and decide on it. Resolves the
+     * pass's result for it and whether it must be re-dispatched, or `undefined` when it was not ours.
+     * `ownLease`: the run's live lease is this instance id's own, left by a previous process (see
+     * {@link reclaimOwnLease}), so it is taken back by owner rather than acquired as a free one.
+     */
+    private recoverOrphan;
     /**
      * The runs {@link recoverIncomplete} should try to reclaim: incomplete runs whose lease is free or
      * expired, never the healthy ones a live turn is renewing. Every worker runs recovery on every
@@ -4715,6 +4811,10 @@ declare class WorkflowEngine {
      * ({@link StateStore.listOrphanedRuns}, bounded by {@link RECOVERY_BATCH}); else the full list is
      * filtered here, which still spares the probes. Shuffled, like the due-timer pass, so instances
      * recovering at once spread over the batch instead of contending for the same leases.
+     *
+     * Also listed: runs still leased by THIS `instanceId` with a lease taken before this process
+     * booted ({@link ownLeaseCutoffMs}). With a stable `instanceId` (pinned to the pod identity), that
+     * is the previous process, killed without a graceful shutdown; see {@link reclaimOwnLease}.
      */
     private orphanedRuns;
     /**
@@ -4947,6 +5047,13 @@ declare class WorkflowEngine {
      * side actually removes the row is the one that delivers, so a signal is never delivered twice.
      */
     signal(token: string, payload: unknown): Promise<RunResult | null>;
+    /**
+     * Wake the run parked on `token` with `payload`, if there is one; otherwise do nothing — unlike
+     * {@link signal}, it never buffers. For a wake-up whose real payload is ALREADY buffered on the
+     * token (an entity op, see `Entities.kick`): a run that isn't parked reads that buffer at its next
+     * wait, so there is nothing to keep.
+     */
+    private wakeSignalWaiter;
     /**
      * Ensure a run exists for `runId`, then deliver a signal to it — atomically race-free thanks to
      * signal buffering: if the run is new (or busy / not yet waiting), the signal is buffered and
@@ -5165,6 +5272,13 @@ declare class WorkflowEngine {
     /** 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. */
+    /**
+     * A run's first execution: `pending` -> `running`. A singleton run not yet admitted is stamped
+     * {@link SINGLETON_TRACKED_TAG} in the same write, BEFORE it competes for a slot, so a run this
+     * replica is about to admit or deny is never mistaken for a holder admitted by a replica older
+     * than 0.73 (see `legacySingletonHolders`).
+     */
+    private markStarted;
     private singletonWaitResult;
     private execute;
     /**
@@ -6086,6 +6200,15 @@ declare function fanPageEtag(group: string, stats: CheckpointStat[], query: FanP
 /** Whether an `If-None-Match` header value names `etag` (weak comparison, as RFC 9110 asks for). */
 declare function etagMatches(ifNoneMatch: string | undefined, etag: string): boolean;
 
+/**
+ * Split a `ctx.webhook()` token (`wh:<runId>:<seq>`) into its run id and logical position, or `null`
+ * for any other token. The run id may itself contain `:` (an entity run is `entity:<name>:<key>`), so
+ * the seq is the LAST segment.
+ */
+declare function parseWebhookToken(token: string): {
+    runId: string;
+    seq: number;
+} | null;
 /**
  * Resolve WHAT a suspended run is parked on from the token of the {@link SignalWaiter} it registered.
  * The token prefix carries the kind — no extra store lookup and no new persisted field. Used by the
@@ -6166,7 +6289,7 @@ declare class CodecStateStore implements StateStore {
     readonly deleteRuns?: (runIds: string[]) => Promise<void>;
     /** Decodes the runs like {@link listIncompleteRuns}. Bound only when the inner store has it, so
      *  the engine's list-and-filter fallback still kicks in through the wrapper. */
-    readonly listOrphanedRuns?: (nowMs: number, limit: number, namespace?: string) => Promise<WorkflowRun[]>;
+    readonly listOrphanedRuns?: (nowMs: number, limit: number, namespace?: string, ownedBy?: OwnedLeaseReclaim) => Promise<WorkflowRun[]>;
     /** Encodes the patch like {@link updateRun}. Bound only when the inner store has it, so the
      *  engine's read-then-write fallback still kicks in through the wrapper. */
     readonly updateRunIf?: (runId: string, expectedStatuses: RunStatus[], patch: Partial<WorkflowRun>) => Promise<boolean>;
@@ -6669,7 +6792,7 @@ declare class InMemoryStateStore implements StateStore {
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
     saveCheckpointIfPending(checkpoint: StepCheckpoint): Promise<boolean>;
     saveCheckpointsIfPending(checkpoints: StepCheckpoint[]): Promise<boolean[]>;
-    listOrphanedRuns(nowMs: number, limit: number, namespace?: string): Promise<WorkflowRun[]>;
+    listOrphanedRuns(nowMs: number, limit: number, namespace?: string, ownedBy?: OwnedLeaseReclaim): Promise<WorkflowRun[]>;
     listIncompleteRuns(namespace?: string): Promise<WorkflowRun[]>;
     listPendingRuns(limit: number, namespace?: string): Promise<WorkflowRun[]>;
     listDueTimers(nowMs: number, namespace?: string, limit?: number): Promise<WorkflowRun[]>;
@@ -6769,7 +6892,42 @@ declare class InMemoryTransport implements Transport, ControlPlane {
 
 /** Reserved engine metadata: a durable singleton slot, independent of the execution lease. */
 declare const SINGLETON_ADMITTED_TAG = "durable:singleton:admitted";
+/**
+ * Reserved engine metadata: this not-yet-admitted run's admission is decided by the tag scheme, so
+ * it holds no slot unless it carries {@link SINGLETON_ADMITTED_TAG}. Stamped on a run's first
+ * execution (`pending` -> `running`) and on every denial. An untagged run WITHOUT it that a
+ * replica has executed was executed by a replica older than 0.73: see
+ * {@link legacySingletonHolders}. Admission and terminal settlement remove it.
+ */
+declare const SINGLETON_TRACKED_TAG = "durable:singleton:tracked";
+/** Tags only the engine/store may write; stripped from user-supplied start tags. */
+declare const SINGLETON_RESERVED_TAGS: readonly string[];
 declare const SINGLETON_ACTIVE_STATUSES: RunStatus[];
+/** `tags` without the engine's singleton admission metadata. */
+declare function withoutSingletonMarkers(tags: string[] | undefined): string[] | undefined;
+/** `tags` carrying {@link SINGLETON_TRACKED_TAG} (unchanged when admitted or already tracked). */
+declare function withSingletonTracked(tags: string[] | undefined): string[];
+/**
+ * The runs other than `runId` that may hold a slot of this key WITHOUT carrying
+ * {@link SINGLETON_ADMITTED_TAG}: holders admitted by a replica older than 0.73, during a rolling
+ * upgrade that mixes old and new replicas.
+ *
+ * Old replicas admit by a scan: a run may execute when it is among the `limit` oldest
+ * `running`/`suspended`/`cancelling` runs sharing the key, by `(createdAt, id)`, and they write no
+ * tag. Among those statuses, an untagged run counts as a legacy holder when either:
+ *
+ * - it lacks {@link SINGLETON_TRACKED_TAG}. A new replica stamps that marker on a run's first
+ *   execution and on every denial, so an untagged executed run without it was executed (admitted)
+ *   by an old replica. A denial alone cannot be told apart from a holder (both old and new denials
+ *   park the run `suspended` with a retry `wakeAt`, exactly like a holder sleeping in `ctx.sleep`),
+ *   which is why the marker exists. Waiters an old replica parked count too until a new replica
+ *   re-checks them (one retry, ~1s), which only delays, never over-admits.
+ * - it sits inside the old scan's own window (the `limit` oldest of those runs). An old replica can
+ *   admit a run a new replica had marked, without clearing the marker; the window is what it
+ *   admitted it on. Without old replicas this never changes a `limit: 1` decision (a run inside the
+ *   window is the head of the FIFO, admitted next anyway); with a larger limit it can only delay one.
+ */
+declare function legacySingletonHolders(active: WorkflowRun[], runId: string, limit: number): WorkflowRun[];
 /** 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. */
@@ -6778,7 +6936,8 @@ declare function clearTerminalSingletonAdmission(runId: string, patch: Partial<W
 declare function singletonAdmissionDenialPatch(runs: WorkflowRun[], runId: string, tag: string, workflow: string, retryWakeAt?: number): {
     status: 'suspended';
     wakeAt: number;
+    tags: string[];
     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 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, FAN_SUMMARY_FAILURES, type FanJoin, type FanPage, type FanPageQuery, type FanSummary, type FanWait, FatalError, 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 MetricsCollector, type MetricsSnapshot, type NamedTransport, type NegotiateOptions, type NegotiationOutcome, type NegotiationReason, type NegotiationResult, NestedWorkflowCallError, NonDeterminismError, type OnErrorInput, type OnErrorRoute, 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 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, 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 SearchAttributes, type SearchAttributesSchema, type Settled, 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, 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, foldedCount, handoffHandlerId, handoffName, hasDurableExecutionWrappers, heartbeatStatus, indexWaitersByRun, info, isEngineMintedTag, isEventToken, isFailedMember, isLegacyDescriptor, isNonEmptyRunScope, isWorkflowControlFlowSignal, listSignalWaitersOfRuns, liveHandoff, log, matchesAttributes, mergeRunFacetRows, mergeRunValueFacetRows, missingCapabilities, negotiate, nextCronFireMs, normalizeAttributeRows, normalizeDescriptor, observedAnnouncements, onErrorRunId, pageFan, pageFanFromStore, parentRunIdOf, parseDuration, partitionOfToken, planDispatch, prevCronFireMs, queryCheckpointsOf, readSearchAttributes, requiredCapabilities, resolveConcurrency, resolveRouting, resolveRunWaiting, retiredHandoffName, routeFor, runDetailEtag, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduledRunId, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, summarizeFan, summarizeRunFromStore, summarizeTimeline, tenantGroup, useDurableExecution, warn, 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 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, 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, 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 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_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 SearchAttributes, type SearchAttributesSchema, type Settled, 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, 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, foldedCount, handoffHandlerId, handoffName, hasDurableExecutionWrappers, heartbeatStatus, 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, retiredHandoffName, routeFor, runDetailEtag, runDurableExecution, runInStepLogger, runInStepScope, runInWorkflowCtx, runOutsideWorkflowCtx, runSchedules, runStepHandler, runValueFacetsFromRuns, sanitizeQueueToken, scheduledRunId, singletonAdmissionDenialPatch, singletonAdmissionTags, sqlComparator, stepConfigOf, stepId, stepNameOf, sub, subEvent, subProcess, summarizeFan, summarizeRunFromStore, summarizeTimeline, tenantGroup, useDurableExecution, warn, withSingletonTracked, withoutSingletonMarkers, workflowName };