@fluidgrids/workflows 2026.1028.2 → 2026.1029.1

package/dist/testing/index.d.cts

@@ -1,12 +1,12 @@
-import { h as DurableWorkflow, O as Operation, j as Duration, l as SignalDefinition } from '../workflow-J-yYixny.cjs';
-import { i as HistoryFile, m as RunState } from '../file-BOoHZgoQ.cjs';
-import { a6 as WorkflowInfoSnapshot, a7 as WorkflowTaskRequest, a8 as WorkflowTaskResult, U as RunEventRecord, F as Failure, V as RunEventType } from '../types-CpBBjaGX.cjs';
-import { a as Json, b as WorkflowDefinition, m as WorkflowNode } from '../types-BGoPzgcl.cjs';
-import { x as Tier1Workflow } from '../workflow-FXUkpIBc.cjs';
+import { j as Duration, t as WorkflowRetryOptions, h as DurableWorkflow, O as Operation, n as SignalDefinition } from '../workflow-O6e64ZcG.cjs';
+import { C as CommandGate, o as HistoryFile, t as RunState } from '../file-cgL9l9l8.cjs';
+import { ai as WorkflowInfoSnapshot, ah as WorkflowIdReusePolicy, ag as WorkflowIdConflictPolicy, ac as VersioningBehavior, aj as WorkflowTaskRequest, ak as WorkflowTaskResult, Z as RunEventRecord, a8 as UnfinishedHandler, F as Failure, _ as RunEventType } from '../types-CQKOhPTa.cjs';
+import { J as Json, a as JsonObject, W as WorkflowDefinition, m as WorkflowNode } from '../types-Bb2wRnJ5.cjs';
+import { x as Tier1Workflow } from '../workflow-CZOXUlQ5.cjs';
 import { E as EsbuildApi } from '../lower-types-DQNBfWQn.cjs';
 import { WorkflowRegistry } from '../runtime/index.cjs';
 import 'esbuild';
-import '../activation-BBh1p82z.cjs';
+import '../activation-CESehfYi.cjs';
 
 /**
  * `TestWorkflowEnvironment` (spec 10 §1): an in-process engine for tier-2
@@ -18,24 +18,41 @@ import '../activation-BBh1p82z.cjs';
  * the conformance fixtures are recorded with it and then replayed in QuickJS
  * and in `vm`.
  *
+ * R2 adds local activities (run through `mock`, retried inside the task),
+ * start delay, run and execution timeouts and run-level retry on the fake
+ * clock, workflow-id policies and workflow-id targets, held activity queues
+ * for schedule-to-start timeouts, heartbeat details on retry, and the handler
+ * drain check (`failOnUnfinishedHandlers`, default true).
+ *
  * Divergences from the service (documented, accepted for Phase B):
  * - Workflow tasks run in this process without the determinism shims.
  * - A failed workflow task is not retried forever: the run stops, and
  *   `result()` rejects with {@link WorkflowTaskFailedError}.
  * - Every task is a first attempt (no transient attempts), and activity
  *   start-to-close and heartbeat timeouts are not timed; a mock may throw a
- *   `TimeoutFailure` to simulate one. Schedule-to-close is honoured.
+ *   `TimeoutFailure` to simulate one. Schedule-to-close is honoured, and
+ *   schedule-to-start while a node type is held (`holdActivities`).
+ * - Local-activity retries do not wait for their backoff: the task's clock
+ *   is its start time, as in the worker, and the fake clock does not move.
+ * - The workflow-task timeout is recorded, not enforced.
  * - Graph child runs are mocks (`mockChild`).
  */
 
 /** What a mock receives besides the activity's args. */
 interface ActivityMockInfo {
     runId: string;
+    /** `a<n>` for an activity, `l<n>` for a local activity. */
     activityId: string;
     attempt: number;
     nodeType: string;
     operation: string;
     connection?: string;
+    /** True when the call is a local activity (`ctx.localActivity`). */
+    local?: boolean;
+    /** Details the previous attempt recorded with `heartbeat` (11 §2.4); activities only. */
+    heartbeatDetails?: Json;
+    /** Record heartbeat details for the next attempt (activities only). */
+    heartbeat?: (details?: unknown) => void;
 }
 type ActivityMock = (args: Json, info: ActivityMockInfo) => unknown;
 type ChildMock = (input: Json, info: {
@@ -49,8 +66,21 @@ interface TestEnvironmentOptions {
     startTime?: number | string | Date;
     /** Tier-2 functions by export name, for `ctx.child(fn)` and by-name starts. */
     workflows?: Readonly<Record<string, DurableWorkflow<never, unknown>>>;
-    /** Command set the environment accepts; default `parity`. */
-    enabled?: 'core' | 'parity';
+    /** Command set the environment accepts: a feature set or a release level; default `parity`. */
+    enabled?: CommandGate;
+    /**
+     * Turn the drain warning (a workflow that finishes while a signal handler
+     * with policy `WARN_AND_ABANDON` still runs, 11 §2.18) into a failure of
+     * `result()` (`UnfinishedHandlersError`). Default true.
+     */
+    failOnUnfinishedHandlers?: boolean;
+    /**
+     * The runtime release whose history fields the environment writes (default
+     * {@link RUNTIME_RELEASE}). Release 1 omits the R2 start fields that the
+     * Phase B core service never wrote (`lastCompletionResult` on a
+     * continue-as-new), so R1 conformance histories record unchanged.
+     */
+    historyRelease?: number;
     /** Workspace id written into run info. */
     workspaceId?: string;
     /**
@@ -71,6 +101,43 @@ interface StartOptions {
         payload?: unknown;
     }>;
     info?: Partial<WorkflowInfoSnapshot>;
+    /** The workflow key for workflow-id policies and targets; default the declaration's name. */
+    workflowKey?: string;
+    /** The business id (11 §2.1); unique among the open runs of the workflow key. */
+    workflowId?: string;
+    /** Default `ALLOW_DUPLICATE`. */
+    idReusePolicy?: WorkflowIdReusePolicy;
+    /** Default `FAIL`. */
+    idConflictPolicy?: WorkflowIdConflictPolicy;
+    /** Delay the first workflow task (11 §2.23); a signal ends the delay. */
+    startDelay?: Duration;
+    /** Bounds the whole chain; default the declaration's `executionTimeout`. */
+    executionTimeout?: Duration;
+    /** Bounds one run; default the declaration's `runTimeout`. */
+    runTimeout?: Duration;
+    /** Recorded only; default the declaration's `workflowTaskTimeout`. */
+    workflowTaskTimeout?: Duration;
+    /** Run-level retry; default the declaration's `retry`. */
+    retry?: WorkflowRetryOptions;
+    summary?: string;
+    details?: string;
+    /** The run's memo (`ctx.info.context`). */
+    memo?: JsonObject;
+    /** Default the declaration's `versioningBehavior`. */
+    versioningBehavior?: VersioningBehavior;
+}
+/** A start found an open run with the same workflow id (`idConflictPolicy: FAIL`) or a refused closed one. */
+declare class WorkflowAlreadyStartedError extends Error {
+    readonly workflowKey: string;
+    readonly workflowId: string;
+    readonly existingRunId: string;
+    constructor(workflowKey: string, workflowId: string, existingRunId: string);
+}
+/** The workflow finished while signal handlers still ran (`failOnUnfinishedHandlers`). */
+declare class UnfinishedHandlersError extends Error {
+    readonly runId: string;
+    readonly handlers: UnfinishedHandler[];
+    constructor(runId: string, handlers: UnfinishedHandler[]);
 }
 /** A run's workflow failed (`WORKFLOW_FAILED`). */
 declare class WorkflowFailedError extends Error {
@@ -114,6 +181,10 @@ declare class TestWorkflowEnvironment {
     private clock;
     private readonly timeSkipping;
     private readonly enabled;
+    private readonly failOnUnfinishedHandlers;
+    private readonly historyRelease;
+    private dues;
+    private readonly held;
     private readonly workspaceId;
     private readonly runs;
     private readonly runOrder;
@@ -134,10 +205,26 @@ declare class TestWorkflowEnvironment {
     now(): number;
     /** Mock a node operation (by node type, and operation when given). */
     mock<In, Out>(operation: Operation<In, Out> | string, impl: (args: In, info: ActivityMockInfo) => Out | Promise<Out>, operationName?: string): void;
+    /**
+     * Hold the activity queue of a node type (every node type when omitted):
+     * attempts wait instead of starting, and a `scheduleToStartTimeout` expires
+     * (`ACTIVITY_TIMED_OUT { timeoutType: SCHEDULE_TO_START }`, not retried).
+     */
+    holdActivities(nodeType?: string): void;
+    /** Release held activity queues (all when no node type is given). */
+    releaseActivities(nodeType?: string): void;
+    private isHeld;
     /** Mock a child workflow started by key (graph or durable). */
     mockChild(workflowKey: string, impl: ChildMock): void;
     /** Start a run of a tier-2 function (by declaration, or by export name with a task executor). */
     start<In, Out>(definition: DurableWorkflow<In, Out> | string, options?: StartOptions): Promise<TestRunHandle<Out>>;
+    private durationConfig;
+    /**
+     * The workflow-id policies of a start (11 §2.1): the open run to use, or
+     * undefined to start a new run (after terminating the open one for
+     * `TERMINATE_EXISTING`). Throws {@link WorkflowAlreadyStartedError}.
+     */
+    private useExisting;
     /** Advance the clock by `duration`, firing timers and running work as it comes due. */
     sleep(duration: Duration): Promise<void>;
     /** Every run, in start order. */
@@ -150,20 +237,50 @@ declare class TestWorkflowEnvironment {
     private ensureRegistered;
     private run;
     private createRun;
+    /** The R2 fields of `WORKFLOW_STARTED`, each written only when it is set. */
+    private startedFields;
     private append;
+    /** End a start delay: the first workflow task is scheduled now. */
+    private endDelay;
     deliverSignal(runId: string, name: string, payload: unknown): boolean;
     requestCancel(runId: string, reason?: string): boolean;
     terminate(runId: string, reason: string): void;
     /** Run every runnable task and activity; skip time when allowed and idle. */
     runUntilIdle(skipTime: boolean): Promise<void>;
+    /** When a held attempt's schedule-to-start timeout expires, if it has one. */
+    private heldDeadline;
     private nextDue;
+    /** Expire held attempts whose schedule-to-start timeout passed (not retried, 11 §2.3). */
+    private expireHeld;
+    /** Fire run-level deadlines: the end of a start delay, run and execution timeouts. */
+    private fireRunDues;
     private fireDue;
     private runTask;
+    private execute;
+    /**
+     * Run a workflow task as the worker does (11 §2.12): while it asks for
+     * local activities, run each through its mock and run the same task again
+     * with the outcomes, up to 1,000 rounds.
+     */
+    private executeWithLocalActivities;
+    private runLocalActivity;
     private afterCommand;
+    /** What a successor of a run inherits (continue-as-new, run retry). */
+    private chainConfig;
+    /** Start the next run of a chain; the closed run's parent and handles follow it. */
+    private startSuccessor;
     private resolveTarget;
+    /** The open run of a workflow id, else its latest run (11 §2.1). */
+    private resolveWorkflowId;
     private startChild;
     private runMockedChild;
     private runAttempt;
+    /**
+     * Run-level retry (11 §2.17): a failed or run-timed-out run whose policy
+     * allows another attempt is followed by a new run of the chain after the
+     * backoff, with `runAttempt + 1` and the failure as `lastFailure`.
+     */
+    private retryRun;
     private onClosed;
     resultOf(runId: string): Promise<Json>;
     /** Every tier-2 function registered, by export name. */
@@ -302,4 +419,4 @@ declare function registryOf(workflows: Readonly<Record<string, DurableWorkflow<n
 /** Run one workflow task in process. */
 declare function runWorkflowTaskInProcess(registry: WorkflowRegistry, request: WorkflowTaskRequest): Promise<WorkflowTaskResult>;
 
-export { type ActivityMock, type ActivityMockInfo, type ChildMock, type ExpectedEvent, HistoryAssertionError, type IRSnapshot, type NodeMock, type NodeMockResult, ReplayError, type ReplayInput, RunBlockedError, type SimulateOptions, type SimulatedStep, type SimulationResult, type StartOptions, type TestEnvironmentOptions, TestRunHandle, TestWorkflowEnvironment, WorkflowFailedError, WorkflowTaskFailedError, assertHistory, bundleToScript, drainJobs, expectIR, jsonCopy, registryOf, replay, replayRequest, runWorkflowTaskInProcess, runWorkflowTaskInVm, simulate };
+export { type ActivityMock, type ActivityMockInfo, type ChildMock, type ExpectedEvent, HistoryAssertionError, type IRSnapshot, type NodeMock, type NodeMockResult, ReplayError, type ReplayInput, RunBlockedError, type SimulateOptions, type SimulatedStep, type SimulationResult, type StartOptions, type TestEnvironmentOptions, TestRunHandle, TestWorkflowEnvironment, UnfinishedHandlersError, WorkflowAlreadyStartedError, WorkflowFailedError, WorkflowTaskFailedError, assertHistory, bundleToScript, drainJobs, expectIR, jsonCopy, registryOf, replay, replayRequest, runWorkflowTaskInProcess, runWorkflowTaskInVm, simulate };

package/dist/testing/index.d.ts

@@ -1,12 +1,12 @@
-import { h as DurableWorkflow, O as Operation, j as Duration, l as SignalDefinition } from '../workflow-C2a05WUJ.js';
-import { i as HistoryFile, m as RunState } from '../file-yuPCFU5b.js';
-import { a6 as WorkflowInfoSnapshot, a7 as WorkflowTaskRequest, a8 as WorkflowTaskResult, U as RunEventRecord, F as Failure, V as RunEventType } from '../types-DV-HX_Gt.js';
-import { a as Json, b as WorkflowDefinition, m as WorkflowNode } from '../types-BGoPzgcl.js';
-import { x as Tier1Workflow } from '../workflow-Bpr3vnA_.js';
+import { j as Duration, t as WorkflowRetryOptions, h as DurableWorkflow, O as Operation, n as SignalDefinition } from '../workflow-DWTPHFbt.js';
+import { C as CommandGate, o as HistoryFile, t as RunState } from '../file-olQudcx5.js';
+import { ai as WorkflowInfoSnapshot, ah as WorkflowIdReusePolicy, ag as WorkflowIdConflictPolicy, ac as VersioningBehavior, aj as WorkflowTaskRequest, ak as WorkflowTaskResult, Z as RunEventRecord, a8 as UnfinishedHandler, F as Failure, _ as RunEventType } from '../types-CnIOinoz.js';
+import { J as Json, a as JsonObject, W as WorkflowDefinition, m as WorkflowNode } from '../types-Bb2wRnJ5.js';
+import { x as Tier1Workflow } from '../workflow-8uRU9rhL.js';
 import { E as EsbuildApi } from '../lower-types-DQNBfWQn.js';
 import { WorkflowRegistry } from '../runtime/index.js';
 import 'esbuild';
-import '../activation-DnhG7SmF.js';
+import '../activation-BnVQMv9y.js';
 
 /**
  * `TestWorkflowEnvironment` (spec 10 §1): an in-process engine for tier-2
@@ -18,24 +18,41 @@ import '../activation-DnhG7SmF.js';
  * the conformance fixtures are recorded with it and then replayed in QuickJS
  * and in `vm`.
  *
+ * R2 adds local activities (run through `mock`, retried inside the task),
+ * start delay, run and execution timeouts and run-level retry on the fake
+ * clock, workflow-id policies and workflow-id targets, held activity queues
+ * for schedule-to-start timeouts, heartbeat details on retry, and the handler
+ * drain check (`failOnUnfinishedHandlers`, default true).
+ *
  * Divergences from the service (documented, accepted for Phase B):
  * - Workflow tasks run in this process without the determinism shims.
  * - A failed workflow task is not retried forever: the run stops, and
  *   `result()` rejects with {@link WorkflowTaskFailedError}.
  * - Every task is a first attempt (no transient attempts), and activity
  *   start-to-close and heartbeat timeouts are not timed; a mock may throw a
- *   `TimeoutFailure` to simulate one. Schedule-to-close is honoured.
+ *   `TimeoutFailure` to simulate one. Schedule-to-close is honoured, and
+ *   schedule-to-start while a node type is held (`holdActivities`).
+ * - Local-activity retries do not wait for their backoff: the task's clock
+ *   is its start time, as in the worker, and the fake clock does not move.
+ * - The workflow-task timeout is recorded, not enforced.
  * - Graph child runs are mocks (`mockChild`).
  */
 
 /** What a mock receives besides the activity's args. */
 interface ActivityMockInfo {
     runId: string;
+    /** `a<n>` for an activity, `l<n>` for a local activity. */
     activityId: string;
     attempt: number;
     nodeType: string;
     operation: string;
     connection?: string;
+    /** True when the call is a local activity (`ctx.localActivity`). */
+    local?: boolean;
+    /** Details the previous attempt recorded with `heartbeat` (11 §2.4); activities only. */
+    heartbeatDetails?: Json;
+    /** Record heartbeat details for the next attempt (activities only). */
+    heartbeat?: (details?: unknown) => void;
 }
 type ActivityMock = (args: Json, info: ActivityMockInfo) => unknown;
 type ChildMock = (input: Json, info: {
@@ -49,8 +66,21 @@ interface TestEnvironmentOptions {
     startTime?: number | string | Date;
     /** Tier-2 functions by export name, for `ctx.child(fn)` and by-name starts. */
     workflows?: Readonly<Record<string, DurableWorkflow<never, unknown>>>;
-    /** Command set the environment accepts; default `parity`. */
-    enabled?: 'core' | 'parity';
+    /** Command set the environment accepts: a feature set or a release level; default `parity`. */
+    enabled?: CommandGate;
+    /**
+     * Turn the drain warning (a workflow that finishes while a signal handler
+     * with policy `WARN_AND_ABANDON` still runs, 11 §2.18) into a failure of
+     * `result()` (`UnfinishedHandlersError`). Default true.
+     */
+    failOnUnfinishedHandlers?: boolean;
+    /**
+     * The runtime release whose history fields the environment writes (default
+     * {@link RUNTIME_RELEASE}). Release 1 omits the R2 start fields that the
+     * Phase B core service never wrote (`lastCompletionResult` on a
+     * continue-as-new), so R1 conformance histories record unchanged.
+     */
+    historyRelease?: number;
     /** Workspace id written into run info. */
     workspaceId?: string;
     /**
@@ -71,6 +101,43 @@ interface StartOptions {
         payload?: unknown;
     }>;
     info?: Partial<WorkflowInfoSnapshot>;
+    /** The workflow key for workflow-id policies and targets; default the declaration's name. */
+    workflowKey?: string;
+    /** The business id (11 §2.1); unique among the open runs of the workflow key. */
+    workflowId?: string;
+    /** Default `ALLOW_DUPLICATE`. */
+    idReusePolicy?: WorkflowIdReusePolicy;
+    /** Default `FAIL`. */
+    idConflictPolicy?: WorkflowIdConflictPolicy;
+    /** Delay the first workflow task (11 §2.23); a signal ends the delay. */
+    startDelay?: Duration;
+    /** Bounds the whole chain; default the declaration's `executionTimeout`. */
+    executionTimeout?: Duration;
+    /** Bounds one run; default the declaration's `runTimeout`. */
+    runTimeout?: Duration;
+    /** Recorded only; default the declaration's `workflowTaskTimeout`. */
+    workflowTaskTimeout?: Duration;
+    /** Run-level retry; default the declaration's `retry`. */
+    retry?: WorkflowRetryOptions;
+    summary?: string;
+    details?: string;
+    /** The run's memo (`ctx.info.context`). */
+    memo?: JsonObject;
+    /** Default the declaration's `versioningBehavior`. */
+    versioningBehavior?: VersioningBehavior;
+}
+/** A start found an open run with the same workflow id (`idConflictPolicy: FAIL`) or a refused closed one. */
+declare class WorkflowAlreadyStartedError extends Error {
+    readonly workflowKey: string;
+    readonly workflowId: string;
+    readonly existingRunId: string;
+    constructor(workflowKey: string, workflowId: string, existingRunId: string);
+}
+/** The workflow finished while signal handlers still ran (`failOnUnfinishedHandlers`). */
+declare class UnfinishedHandlersError extends Error {
+    readonly runId: string;
+    readonly handlers: UnfinishedHandler[];
+    constructor(runId: string, handlers: UnfinishedHandler[]);
 }
 /** A run's workflow failed (`WORKFLOW_FAILED`). */
 declare class WorkflowFailedError extends Error {
@@ -114,6 +181,10 @@ declare class TestWorkflowEnvironment {
     private clock;
     private readonly timeSkipping;
     private readonly enabled;
+    private readonly failOnUnfinishedHandlers;
+    private readonly historyRelease;
+    private dues;
+    private readonly held;
     private readonly workspaceId;
     private readonly runs;
     private readonly runOrder;
@@ -134,10 +205,26 @@ declare class TestWorkflowEnvironment {
     now(): number;
     /** Mock a node operation (by node type, and operation when given). */
     mock<In, Out>(operation: Operation<In, Out> | string, impl: (args: In, info: ActivityMockInfo) => Out | Promise<Out>, operationName?: string): void;
+    /**
+     * Hold the activity queue of a node type (every node type when omitted):
+     * attempts wait instead of starting, and a `scheduleToStartTimeout` expires
+     * (`ACTIVITY_TIMED_OUT { timeoutType: SCHEDULE_TO_START }`, not retried).
+     */
+    holdActivities(nodeType?: string): void;
+    /** Release held activity queues (all when no node type is given). */
+    releaseActivities(nodeType?: string): void;
+    private isHeld;
     /** Mock a child workflow started by key (graph or durable). */
     mockChild(workflowKey: string, impl: ChildMock): void;
     /** Start a run of a tier-2 function (by declaration, or by export name with a task executor). */
     start<In, Out>(definition: DurableWorkflow<In, Out> | string, options?: StartOptions): Promise<TestRunHandle<Out>>;
+    private durationConfig;
+    /**
+     * The workflow-id policies of a start (11 §2.1): the open run to use, or
+     * undefined to start a new run (after terminating the open one for
+     * `TERMINATE_EXISTING`). Throws {@link WorkflowAlreadyStartedError}.
+     */
+    private useExisting;
     /** Advance the clock by `duration`, firing timers and running work as it comes due. */
     sleep(duration: Duration): Promise<void>;
     /** Every run, in start order. */
@@ -150,20 +237,50 @@ declare class TestWorkflowEnvironment {
     private ensureRegistered;
     private run;
     private createRun;
+    /** The R2 fields of `WORKFLOW_STARTED`, each written only when it is set. */
+    private startedFields;
     private append;
+    /** End a start delay: the first workflow task is scheduled now. */
+    private endDelay;
     deliverSignal(runId: string, name: string, payload: unknown): boolean;
     requestCancel(runId: string, reason?: string): boolean;
     terminate(runId: string, reason: string): void;
     /** Run every runnable task and activity; skip time when allowed and idle. */
     runUntilIdle(skipTime: boolean): Promise<void>;
+    /** When a held attempt's schedule-to-start timeout expires, if it has one. */
+    private heldDeadline;
     private nextDue;
+    /** Expire held attempts whose schedule-to-start timeout passed (not retried, 11 §2.3). */
+    private expireHeld;
+    /** Fire run-level deadlines: the end of a start delay, run and execution timeouts. */
+    private fireRunDues;
     private fireDue;
     private runTask;
+    private execute;
+    /**
+     * Run a workflow task as the worker does (11 §2.12): while it asks for
+     * local activities, run each through its mock and run the same task again
+     * with the outcomes, up to 1,000 rounds.
+     */
+    private executeWithLocalActivities;
+    private runLocalActivity;
     private afterCommand;
+    /** What a successor of a run inherits (continue-as-new, run retry). */
+    private chainConfig;
+    /** Start the next run of a chain; the closed run's parent and handles follow it. */
+    private startSuccessor;
     private resolveTarget;
+    /** The open run of a workflow id, else its latest run (11 §2.1). */
+    private resolveWorkflowId;
     private startChild;
     private runMockedChild;
     private runAttempt;
+    /**
+     * Run-level retry (11 §2.17): a failed or run-timed-out run whose policy
+     * allows another attempt is followed by a new run of the chain after the
+     * backoff, with `runAttempt + 1` and the failure as `lastFailure`.
+     */
+    private retryRun;
     private onClosed;
     resultOf(runId: string): Promise<Json>;
     /** Every tier-2 function registered, by export name. */
@@ -302,4 +419,4 @@ declare function registryOf(workflows: Readonly<Record<string, DurableWorkflow<n
 /** Run one workflow task in process. */
 declare function runWorkflowTaskInProcess(registry: WorkflowRegistry, request: WorkflowTaskRequest): Promise<WorkflowTaskResult>;
 
-export { type ActivityMock, type ActivityMockInfo, type ChildMock, type ExpectedEvent, HistoryAssertionError, type IRSnapshot, type NodeMock, type NodeMockResult, ReplayError, type ReplayInput, RunBlockedError, type SimulateOptions, type SimulatedStep, type SimulationResult, type StartOptions, type TestEnvironmentOptions, TestRunHandle, TestWorkflowEnvironment, WorkflowFailedError, WorkflowTaskFailedError, assertHistory, bundleToScript, drainJobs, expectIR, jsonCopy, registryOf, replay, replayRequest, runWorkflowTaskInProcess, runWorkflowTaskInVm, simulate };
+export { type ActivityMock, type ActivityMockInfo, type ChildMock, type ExpectedEvent, HistoryAssertionError, type IRSnapshot, type NodeMock, type NodeMockResult, ReplayError, type ReplayInput, RunBlockedError, type SimulateOptions, type SimulatedStep, type SimulationResult, type StartOptions, type TestEnvironmentOptions, TestRunHandle, TestWorkflowEnvironment, UnfinishedHandlersError, WorkflowAlreadyStartedError, WorkflowFailedError, WorkflowTaskFailedError, assertHistory, bundleToScript, drainJobs, expectIR, jsonCopy, registryOf, replay, replayRequest, runWorkflowTaskInProcess, runWorkflowTaskInVm, simulate };