@lostgradient/weft 0.9.0 → 0.11.0

package/dist/core/engine/sleep-timer-acknowledgements.js

@@ -0,0 +1,144 @@
+export async function handleSleepTimerWithAcknowledgement(internals, entry, loadWorkflowState) {
+  const operationId = entry.id.replace("sleep:", "");
+  if (await shouldIgnoreUnclaimedSleepTimer(internals, entry, operationId, loadWorkflowState))
+    return;
+  const acknowledgement = internals.inlineStrategy === null ? null : createSleepTimerAcknowledgement(internals, entry.workflowId, operationId, entry.fireAt);
+  if (!resolveSleepTimer(internals, entry)) {
+    acknowledgement?.cancel();
+    return;
+  }
+  await acknowledgement?.promise;
+}
+async function shouldIgnoreUnclaimedSleepTimer(internals, entry, operationId, loadWorkflowState) {
+  const resolverKey = `${entry.workflowId}:${operationId}`;
+  if (internals.sleepResolvers.has(resolverKey) || internals.inlineStrategy === null)
+    return !1;
+  const durableOperation = internals.durableInlineOperations.get(entry.workflowId);
+  if (durableOperationBelongsToAnotherOperation(durableOperation, operationId))
+    return !0;
+  if (workflowReplayIsAdvancing(internals, entry.workflowId))
+    return !1;
+  if ((await loadWorkflowState(entry.workflowId))?.status !== "running")
+    return !0;
+  throw Error(`Sleep timer "${entry.id}" fired before workflow "${entry.workflowId}" was ready to consume it.`);
+}
+function durableOperationBelongsToAnotherOperation(durableOperation, operationId) {
+  if (durableOperation === void 0)
+    return !1;
+  if (durableOperation.type !== "sleep")
+    return !0;
+  return durableOperation.operationId !== operationId;
+}
+function workflowReplayIsAdvancing(internals, workflowId) {
+  const inlineStrategy = internals.inlineStrategy;
+  if (inlineStrategy === null)
+    return !1;
+  return inlineStrategy.waitForWorkflowAdvance(workflowId) !== void 0 || inlineStrategy.waitForWorkflowTurn(workflowId) !== void 0;
+}
+function removeWaiter(internals, workflowId, waiter) {
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  workflowWaiters.delete(waiter);
+  if (workflowWaiters.size === 0)
+    internals.sleepTimerAcknowledgementWaiters.delete(workflowId);
+}
+export function createSleepTimerAcknowledgement(internals, workflowId, operationId, fireAt) {
+  const { promise, reject, resolve } = Promise.withResolvers(), waiter = { fireAt, operationId, reject, resolve };
+  let workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters) {
+    workflowWaiters = new Set;
+    internals.sleepTimerAcknowledgementWaiters.set(workflowId, workflowWaiters);
+  }
+  workflowWaiters.add(waiter);
+  return {
+    promise,
+    cancel: () => {
+      removeWaiter(internals, workflowId, waiter);
+      resolve();
+    }
+  };
+}
+export function recordDurableInlineOperation(internals, workflowId, operation) {
+  const durableOperation = {
+    operationId: operation.operationId,
+    type: operation.type,
+    ...operation.type === "sleep" && { scheduledFireAt: operation.scheduledFireAt }
+  };
+  internals.durableInlineOperations.set(workflowId, durableOperation);
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  for (const waiter of workflowWaiters) {
+    const stillWaitingOnThisSleep = durableOperation.type === "sleep" && durableOperation.operationId === waiter.operationId, supersededByLaterDeadline = stillWaitingOnThisSleep && durableOperation.scheduledFireAt !== void 0 && waiter.fireAt < durableOperation.scheduledFireAt;
+    if (stillWaitingOnThisSleep && !supersededByLaterDeadline)
+      continue;
+    removeWaiter(internals, workflowId, waiter);
+    waiter.resolve();
+  }
+}
+export function settleSleepTimerAcknowledgements(internals, workflowId, disposition) {
+  internals.durableInlineOperations.delete(workflowId);
+  if (disposition === "suspended") {
+    rejectSleepTimerAcknowledgements(internals, workflowId, Error(`Workflow "${workflowId}" was suspended before its sleep timer was acknowledged.`));
+    return;
+  }
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  internals.sleepTimerAcknowledgementWaiters.delete(workflowId);
+  for (const waiter of workflowWaiters)
+    waiter.resolve();
+}
+export function acknowledgeSupersededSleepTimers(internals, workflowId, currentDeadline) {
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  for (const waiter of workflowWaiters) {
+    if (waiter.fireAt >= currentDeadline)
+      continue;
+    removeWaiter(internals, workflowId, waiter);
+    waiter.resolve();
+  }
+}
+export function rejectSleepTimerAcknowledgements(internals, workflowId, error) {
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  internals.sleepTimerAcknowledgementWaiters.delete(workflowId);
+  const rejection = error instanceof Error ? error : Error(String(error));
+  for (const waiter of workflowWaiters)
+    waiter.reject(rejection);
+}
+export function rejectAllSleepTimerAcknowledgements(internals, error) {
+  for (const workflowId of internals.sleepTimerAcknowledgementWaiters.keys())
+    rejectSleepTimerAcknowledgements(internals, workflowId, error);
+}
+export function resolveSleepTimer(internals, entry) {
+  const operationId = entry.id.replace("sleep:", ""), resolverKey = `${entry.workflowId}:${operationId}`, resolver = internals.sleepResolvers.get(resolverKey);
+  if (!resolver) {
+    let workflowMarkers = internals.sleepTimersFiredWithoutResolver.get(entry.workflowId);
+    if (!workflowMarkers) {
+      workflowMarkers = new Map;
+      internals.sleepTimersFiredWithoutResolver.set(entry.workflowId, workflowMarkers);
+    }
+    const existing = workflowMarkers.get(operationId);
+    if (existing === void 0 || entry.fireAt > existing)
+      workflowMarkers.set(operationId, entry.fireAt);
+    return !0;
+  }
+  if (entry.fireAt < resolver.fireAt)
+    return !1;
+  internals.sleepResolvers.delete(resolverKey);
+  untrackSleepResolver(internals, entry.workflowId, operationId);
+  resolver.resolve();
+  return !0;
+}
+function untrackSleepResolver(internals, workflowId, operationId) {
+  const workflowOperations = internals.sleepResolversByWorkflow.get(workflowId);
+  if (!workflowOperations)
+    return;
+  workflowOperations.delete(operationId);
+  if (workflowOperations.size === 0)
+    internals.sleepResolversByWorkflow.delete(workflowId);
+}

package/dist/core/engine/sub-operation.js

@@ -16,7 +16,10 @@ import {
   executeActivityOperationResult
 } from "./operations-activity.js";
 import {
-  executeRunAllOperationResult
+  assertValidRaceBranchNames,
+  executeRaceSubOperations,
+  executeRunAllOperationResult,
+  wrapRaceWinner
 } from "./operations-coordination.js";
 import { callMemoFunction } from "./state-utilities.js";
 export async function processWaitReviewOperation(_internals, workflowId, operation, callbacks) {
@@ -82,16 +85,6 @@ async function executeParallelSubOperation(internals, workflowId, operation, cal
 }
 async function executeRaceSubOperation(internals, workflowId, operation, callbacks, signal, speculativeState) {
   signal?.throwIfAborted();
-  const controller = new AbortController, abortNestedRace = () => {
-    controller.abort(signal?.reason);
-  };
-  signal?.addEventListener("abort", abortNestedRace, { once: !0 });
-  const subOperations = operation.operations.map((subOperation) => executeSubOperation(internals, workflowId, subOperation, callbacks, controller.signal, speculativeState));
-  Promise.allSettled(subOperations);
-  try {
-    return await Promise.race(subOperations);
-  } finally {
-    signal?.removeEventListener("abort", abortNestedRace);
-    controller.abort();
-  }
+  assertValidRaceBranchNames(operation);
+  return executeRaceSubOperations(internals, workflowId, operation.operations, (subOperation, branchSignal) => executeSubOperation(internals, workflowId, subOperation, callbacks, branchSignal, speculativeState), signal, (winnerIndex, value) => wrapRaceWinner(operation, winnerIndex, value));
 }

package/dist/core/engine/termination/cleanup.js

@@ -1,7 +1,8 @@
 import { KEYS, encodeStorageKeyComponent, storageHas } from "../../../storage/interface.js";
 import { CleanupWarningEvent } from "../../events.js";
-import { asyncActivityWorkflowPrefix } from "../async-activity-completion.js";
+import { asyncActivityWorkflowPrefix } from "../async-activity-records.js";
 import { forgetCommittedCheckpointBytes } from "../checkpoint-commit-snapshots.js";
+import { settleSleepTimerAcknowledgements } from "../sleep-timer-acknowledgements.js";
 import { parseTerminalCleanupTimerId, workflowFeedListenerKey } from "../state-utilities.js";
 import { releaseWorkflowConcurrencySlot } from "../workflow-concurrency.js";
 export const TERMINAL_WORKFLOW_STATUSES = new Set([
@@ -102,6 +103,7 @@ export function cleanupWaiters(internals, workflowId, callbacks) {
   internals.workflowTypeByWorkflowId.delete(workflowId);
 }
 export function evictSuspendedWorkflowWaiters(internals, workflowId, callbacks) {
+  settleSleepTimerAcknowledgements(internals, workflowId, "suspended");
   for (const kind of TRACKED_WAITER_KINDS)
     cleanupTrackedWaiter(internals, workflowId, kind);
   evictSleepResolversWithoutResolving(internals, workflowId);
@@ -148,6 +150,7 @@ export async function cleanupWorkflowStorage(internals, workflowId, includeOutpu
   await flush();
 }
 export function cleanupTerminalWorkflowMemory(internals, workflowId, callbacks) {
+  settleSleepTimerAcknowledgements(internals, workflowId, "terminal");
   internals.workflowsNeedingTerminalCleanup.delete(workflowId);
   forgetCommittedCheckpointBytes(internals, workflowId);
   internals.checkpoints.delete(workflowId);
@@ -194,7 +197,9 @@ export async function runDeferredTerminalCleanup(internals, workflowId, timerId,
   if (state.terminalCleanupToken !== parsedTimer.terminalCleanupToken)
     return;
   try {
+    await finalizeScheduledWorkflowTerminal(internals, workflowId, callbacks);
     await cleanupTerminalWorkflowDurableState(internals, workflowId, parsedTimer.includeOutputArtifacts, callbacks);
+    await internals.storage.delete(KEYS.scheduleRun(workflowId));
   } catch (error) {
     callbacks.handleCleanupError("cleanupTerminalWorkflowDurableState", error, workflowId);
     throw error;

package/dist/core/types/options.d.ts

@@ -218,6 +218,18 @@ export interface ForkOptions {
 export interface EngineOptions<TServices = unknown> {
     storage?: WeftStorage;
     development?: boolean;
+    /**
+     * Select how engine-owned periodic work is driven. The default `'automatic'`
+     * profile starts in-process intervals for update-response cleanup, configured
+     * retention sweeps, alert re-evaluation, and the durable-timer scheduler used
+     * by {@link Engine.create}. Use `'manual'` in runtimes such as Cloudflare
+     * Durable Objects where the host must wake the engine through alarms or Cron
+     * triggers, then call {@link Engine.runMaintenance} from each wake-up.
+     *
+     * Manual mode rejects interval-dependent ownership and second-instance
+     * detection options instead of silently starting background work.
+     */
+    backgroundTasks?: 'automatic' | 'manual';
     serializer?: Serializer;
     retention?: RetentionPolicy;
     retentionSweepInterval?: Duration;

package/dist/core/types/services-resolution.d.ts

@@ -50,7 +50,11 @@ export interface WorkflowServicesResolverLaunchOptions {
 }
 /**
  * Schedule context passed to {@link EngineOptions.resolveWorkflowServices} for
- * scheduled occurrences.
+ * scheduled occurrences. New scheduled runs persist this context with the
+ * workflow record, so a fresh-process recovery receives the same schedule id and
+ * known occurrence timestamp as the live launch path. Runs from older stores
+ * that predate the metadata may omit it, and queue-drained runs may omit
+ * `occurrence` because their original grid timestamp was not retained.
  *
  * @example
  * ```ts
@@ -72,8 +76,9 @@ export interface WorkflowServicesResolverScheduleInfo {
  * recovered workflow or scheduled occurrence. `input` is the original durable
  * launch input, available at resume time — typically enough to rebuild the run's
  * dependencies (tenant, model, tool registry) without a side table. When tags or
- * schedule identity are part of the durable launch context, they are exposed so
- * resolvers do not need parallel side channels for the same classification.
+ * schedule identity are part of the durable launch context, they are exposed on
+ * both live scheduled launches and recovery so resolvers do not need parallel
+ * side channels for the same classification.
  *
  * @example
  * ```ts

package/dist/core/types/workflow-builder.d.ts

@@ -50,8 +50,8 @@ export type WorkflowGenerator<TInput, TOutput, TActivities extends ActivityMap,
  * Bare-`WorkflowContext` callers (no declared activity/signal/etc. maps)
  * typecheck because the interface's generics all default to permissive shapes:
  * the typed overloads de-prioritise to `never` and the dynamic string-name /
- * callable overloads match instead. This permissive path is current API — it is
- * how untyped, ad-hoc-name authoring is supported, not a compatibility shim.
+ * callable overloads match instead. This permissive path is the current API for
+ * untyped, ad-hoc-name authoring.
  */
 export type WorkflowContextOf<TActivities extends ActivityMap = ActivityMap, TSignals extends SignalMap = SignalMap, TUpdates extends UpdateMap = UpdateMap, TQueries extends QueryMap = QueryMap, TSearchAttributes extends SearchAttributeSchema = SearchAttributeSchema, TServices = unknown> = WorkflowContext<TActivities, TSignals, TUpdates, TQueries, TSearchAttributes, TServices>;
 /**

package/dist/core/types/workflow-context.d.ts

@@ -15,6 +15,32 @@ export type WorkflowOperationResult<TOperation> = TOperation extends Generator<u
 export type WorkflowOperationTupleResult<TOperations extends readonly WorkflowOperation<unknown>[]> = {
     -readonly [TIndex in keyof TOperations]: WorkflowOperationResult<TOperations[TIndex]>;
 };
+/**
+ * Discriminated winner returned by {@link WorkflowContext.raceKeyed}. Checking
+ * `key` narrows `value` to the result type of that named workflow operation.
+ * Numeric object keys are returned as strings, matching JavaScript object
+ * enumeration; symbol keys are rejected at runtime.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowKeyedRaceResult, WorkflowOperation } from '@lostgradient/weft';
+ *
+ * type Winner = WorkflowKeyedRaceResult<{
+ *   event: WorkflowOperation<string>;
+ *   idle: WorkflowOperation<void>;
+ * }>;
+ *
+ * function handleWinner(winner: Winner): string {
+ *   return winner.key === 'event' ? winner.value : 'timed out';
+ * }
+ * ```
+ */
+export type WorkflowKeyedRaceResult<TOperations extends Readonly<Record<string, WorkflowOperation<unknown>>>> = {
+    [TKey in keyof TOperations]: {
+        key: TKey extends string | number ? `${TKey}` : never;
+        value: WorkflowOperationResult<TOperations[TKey]>;
+    };
+}[keyof TOperations];
 type RunAllBranchResult<TBranch> = TBranch extends readonly [
     execute: infer TExecute,
     ...rest: unknown[]
@@ -180,6 +206,7 @@ export interface WorkflowContext<TActivities extends ActivityMap = {}, TSignals
     review(options: HumanReviewOptions): WorkflowOperation<HumanReviewResult>;
     all<const TOperations extends readonly WorkflowOperation<unknown>[]>(operations: TOperations): WorkflowOperation<WorkflowOperationTupleResult<TOperations>>;
     race<const TOperations extends readonly WorkflowOperation<unknown>[]>(operations: TOperations): WorkflowOperation<WorkflowOperationTupleResult<TOperations>[number]>;
+    raceKeyed<const TOperations extends Readonly<Record<string, WorkflowOperation<unknown>>>>(operations: TOperations): WorkflowOperation<WorkflowKeyedRaceResult<TOperations>>;
     memo<T>(key: string, fn: () => T | Promise<T>): WorkflowOperation<T>;
     offload<T>(key: string, fn: () => Promise<T>): WorkflowOperation<OffloadReference>;
     stream(key: string, fn: (sink: StreamSink) => AsyncGenerator<unknown, void, unknown>): WorkflowOperation<StreamReference>;

package/dist/index.d.ts

@@ -22,9 +22,9 @@ export { FAULT_CODE_TO_FAILURE_CATEGORY, failureCategoryForFaultCode, isFaultCod
 export type { FaultCode } from './core/fault-code.ts';
 export { DurableActivityScopeError, DurableActivityUnsupportedError, durableActivity, } from './core/context/durable-activity.ts';
 export { ActivityReconciliationCapabilityError, ActivityReconciliationConflictError, ActivityReconciliationIndeterminateError, ActivityResolutionError, AsyncActivityTokenNotFoundError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, ENGINE_LEASE_LOST_WARNING_NAME, ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME, Engine, EngineCreateNameMismatchError, EngineDisposedError, EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, ScheduleHandle, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowHandle, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './core/engine';
-export type { EngineCreateOptions, EngineStateNamespace, RecoverAllOptions } from './core/engine';
+export type { EngineCreateOptions, EngineStateNamespace, RecoverAllOptions, RecoveredWorkflowInfo, } from './core/engine';
 export { DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD, DEFAULT_MAX_NESTING_DEPTH, DEFAULT_POLL_INTERVAL_MS, DEFAULT_RETRY_POLICY, DEFAULT_VISIBILITY_TIMEOUT_MS, HISTORY_CIRCUIT_BREAKER_REASON, WorkflowBuilderError, query, schedule, signal, update, workflow, } from './core/types';
-export type { ActivityArgsFor, ActivityCallOptions, ActivityCallable, ActivityContext, ActivityDefinition, ActivityEntryInput, ActivityFunction, ActivityMap, ActivityMapInput, ActivityObjectInput, ActivityResultFor, ActivityVerificationContext, ActivityVerificationPhase, ActivityVerificationResult, AnyActivityDefinition, AnyWorkflowDefinition, ArchiveAdapter, BuilderState, BuiltWorkflowDefinition, BulkCancelResult, BulkDeleteResult, BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationFilterSummary, BulkOperationOptions, BulkOperationPrincipal, BulkOperationScopeSummary, BulkRetryFailedResult, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalAllOptions, BulkSignalResult, BulkTagResult, Checkpoint, CheckpointState, CheckpointSummary, CompletedReviewEntry, CoordinatedUpdateResult, DefinitionSchema, Duration, EngineOptions, FailureCategory, ForkLineage, ForkOptions, HistoryPolicy, InferActivityEntries, InferActivityEntry, InferWorkflowEntries, InferWorkflowEntry, InitialBuilderState, LaunchMetadata, ListFilter, ListOptions, MarkBuilderState, NormalizeActivities, NormalizedActivityEntry, NormalizedRetentionPolicy, PaginatedResult, PayloadSizePolicy, PendingReviewEntry, PurgeResult, QueryDefinition, QueryMap, QueryShape, RegisteredWorkflowDefinition, RetentionOverview, RetentionPolicy, RetryPolicy, ReviewListEntry, ReviewListFilter, ReviewStatus, ScheduleDefinition, ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus, ScheduleSummary, SearchAttributeDefinition, SearchAttributeHandle, SearchAttributeSchema, SearchAttributeValue, Serializer, SignalDefinition, SignalDeliveryOptions, SignalMap, SignalPayload, StartOptions, StartOrSignalOptions, StartOrSignalSignal, SubmitReviewOptions, TerminationReason, UpdateDefinition, UpdateMap, UpdatePayload, WorkerReplayOperationFailure, WorkerReplayOperationSignature, WorkflowAlreadyRegistered, WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowBuilder, WorkflowBuilderOptions, WorkflowConcurrencyOptions, WorkflowContext, WorkflowDefinition, WorkflowEvent, WorkflowFunction, WorkflowGenerator, WorkflowId, WorkflowLogLevel, WorkflowLogRecord, WorkflowLogger, WorkflowRegistry, WorkflowReplay, WorkflowServicesResolution, WorkflowServicesResolverInfo, WorkflowServicesResolverLaunchOptions, WorkflowServicesResolverScheduleInfo, WorkflowSessionState, WorkflowSnapshot, WorkflowState, WorkflowStateNamespace, WorkflowStatus, WorkflowSummary, WorkflowTimelineEntry, WorkflowTimelineStatus, WorkflowTypeRetentionPolicy, } from './core/types';
+export type { ActivityArgsFor, ActivityCallOptions, ActivityCallable, ActivityContext, ActivityDefinition, ActivityEntryInput, ActivityFunction, ActivityMap, ActivityMapInput, ActivityObjectInput, ActivityResultFor, ActivityVerificationContext, ActivityVerificationPhase, ActivityVerificationResult, AnyActivityDefinition, AnyWorkflowDefinition, ArchiveAdapter, BuilderState, BuiltWorkflowDefinition, BulkCancelResult, BulkDeleteResult, BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationFilterSummary, BulkOperationOptions, BulkOperationPrincipal, BulkOperationScopeSummary, BulkRetryFailedResult, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalAllOptions, BulkSignalResult, BulkTagResult, Checkpoint, CheckpointState, CheckpointSummary, CompletedReviewEntry, CoordinatedUpdateResult, DefinitionSchema, Duration, EngineOptions, FailureCategory, ForkLineage, ForkOptions, HistoryPolicy, InferActivityEntries, InferActivityEntry, InferWorkflowEntries, InferWorkflowEntry, InitialBuilderState, LaunchMetadata, ListFilter, ListOptions, MarkBuilderState, NormalizeActivities, NormalizedActivityEntry, NormalizedRetentionPolicy, PaginatedResult, PayloadSizePolicy, PendingReviewEntry, PurgeResult, QueryDefinition, QueryMap, QueryShape, RegisteredWorkflowDefinition, RetentionOverview, RetentionPolicy, RetryPolicy, ReviewListEntry, ReviewListFilter, ReviewStatus, ScheduleDefinition, ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus, ScheduleSummary, SearchAttributeDefinition, SearchAttributeHandle, SearchAttributeSchema, SearchAttributeValue, Serializer, SignalDefinition, SignalDeliveryOptions, SignalMap, SignalPayload, StartOptions, StartOrSignalOptions, StartOrSignalSignal, SubmitReviewOptions, TerminationReason, UpdateDefinition, UpdateMap, UpdatePayload, WorkerReplayOperationFailure, WorkerReplayOperationSignature, WorkflowAlreadyRegistered, WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowBuilder, WorkflowBuilderOptions, WorkflowConcurrencyOptions, WorkflowContext, WorkflowDefinition, WorkflowEvent, WorkflowFunction, WorkflowGenerator, WorkflowId, WorkflowKeyedRaceResult, WorkflowLogLevel, WorkflowLogRecord, WorkflowLogger, WorkflowRegistry, WorkflowReplay, WorkflowServicesResolution, WorkflowServicesResolverInfo, WorkflowServicesResolverLaunchOptions, WorkflowServicesResolverScheduleInfo, WorkflowSessionState, WorkflowSnapshot, WorkflowState, WorkflowStateNamespace, WorkflowStatus, WorkflowSummary, WorkflowTimelineEntry, WorkflowTimelineStatus, WorkflowTypeRetentionPolicy, } from './core/types';
 export { AlertManager } from './alerting/index';
 export type { AlertAction, AlertMetric, AlertRule, AlertState, AlertStatus, AlertingOptions, WebhookTarget, } from './alerting/types';
 export { ActivityAsyncPendingEvent, ActivityCompletedEvent, ActivityFailedEvent, ActivityStartedEvent, AlertFiredEvent, AlertResolvedEvent, AttributesChangedEvent, CheckpointSizeWarningEvent, ConstraintViolatedEvent, DevelopmentWarningEvent, ScheduleFiredEvent, ScheduleMissedFireEvent, SignalDeliveredEvent, SignalReceivedEvent, StorageSizeReportedEvent, TaskResultDeadLetteredEvent, UpdateCompletedEvent, UpdateReceivedEvent, WorkflowCancelledEvent, WorkflowCompletedEvent, WorkflowDefinitionRegisteredEvent, WorkflowFailedEvent, WorkflowRecoverySkippedEvent, WorkflowResumedEvent, WorkflowStartedEvent, WorkflowSuspendedEvent, WorkflowTeardownEvent, WorkflowTimedOutEvent, } from './core/events';