@fluidgrids/workflows 2026.1027.1 → 2026.1028.2

package/dist/testing/index.js

@@ -0,0 +1,1037 @@
+import { failedTaskResult } from '../chunk-IISBRUWJ.js';
+import { isTier1Workflow, toIR } from '../chunk-HWJZVOG7.js';
+import { irHash, CODE_WORKFLOW_NODE_TYPE, normalizeDefinition } from '../chunk-BD7ZPG53.js';
+import '../chunk-5LUIDMF4.js';
+import '../chunk-JZ4TOOLN.js';
+import '../chunk-E2VK7J2C.js';
+import '../chunk-7AAZGVKD.js';
+import { createHistoryFile, validateCommands, parseHistoryFile } from '../chunk-VOKMAAJP.js';
+import { isRecord } from '../chunk-PMCM2OH4.js';
+import { buildWorkflowRegistry, createWorkflowRuntime } from '../chunk-VRHHBPT6.js';
+import { failureToError, signalName, toMs, errorToFailure, ApplicationError, CancelledFailure, DeterminismViolation } from '../chunk-C5OLWZ42.js';
+import '../chunk-LNUQE6D6.js';
+import { TASK_PRELUDE } from '../chunk-4LYSEANA.js';
+import { isDurableWorkflow } from '../chunk-N23SKIG4.js';
+import { initialRunState, applyEvent, eventsForCommands, isActivityOpen, computeRetryDelay, isChildOpen } from '../chunk-ABFZWYHT.js';
+import { isInputEvent, HISTORY_PROTOCOL, TERMINAL_COMMANDS } from '../chunk-DJYMDLV5.js';
+import '../chunk-BO6OVILK.js';
+import { createContext, Script } from 'vm';
+
+// src/testing/host.ts
+function drainJobs() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function registryOf(workflows) {
+  return buildWorkflowRegistry([["in-process", { ...workflows }]]);
+}
+async function hostLoop(abi, requestJson) {
+  abi.start(requestJson);
+  await drainJobs();
+  while (abi.step() === "more") await drainJobs();
+  await drainJobs();
+  return abi.complete();
+}
+async function runWorkflowTaskInProcess(registry, request) {
+  const abi = createWorkflowRuntime(registry);
+  const json = await hostLoop(abi, JSON.stringify(request));
+  return JSON.parse(json);
+}
+
+// src/testing/environment.ts
+var WorkflowFailedError = class extends Error {
+  constructor(runId, failure) {
+    super(`Run ${runId} failed: ${failure.message}`);
+    this.runId = runId;
+    this.failure = failure;
+    this.name = "WorkflowFailedError";
+    Object.defineProperty(this, "cause", { value: failureToError(failure), enumerable: false });
+  }
+  runId;
+  failure;
+};
+var WorkflowTaskFailedError = class extends Error {
+  constructor(runId, result) {
+    super(
+      `A workflow task of run ${runId} failed (${result.failure?.cause ?? "INTERNAL"}): ${result.failure?.message ?? ""}`
+    );
+    this.runId = runId;
+    this.result = result;
+    this.name = "WorkflowTaskFailedError";
+  }
+  runId;
+  result;
+};
+var RunBlockedError = class extends Error {
+  constructor(runId) {
+    super(`Run ${runId} is waiting (for a signal, a timer without time skipping, or a child)`);
+    this.runId = runId;
+    this.name = "RunBlockedError";
+  }
+  runId;
+};
+var TestRunHandle = class {
+  constructor(env, runId) {
+    this.env = env;
+    this.runId = runId;
+  }
+  env;
+  runId;
+  /** The run's history so far. */
+  history() {
+    return this.env.historyOf(this.runId);
+  }
+  /** The history as a history file. */
+  historyFile(extra = {}) {
+    return this.env.historyFileOf(this.runId, extra);
+  }
+  /** Deliver a signal and run until idle (without skipping time). */
+  async signal(signal, payload) {
+    this.env.deliverSignal(this.runId, signalName(signal), payload);
+    await this.env.runUntilIdle(false);
+  }
+  /** Request cancellation and run until idle (without skipping time). */
+  async cancel(reason) {
+    this.env.requestCancel(this.runId, reason);
+    await this.env.runUntilIdle(false);
+  }
+  /** Terminate the run without running code. */
+  async terminate(reason = "terminated") {
+    this.env.terminate(this.runId, reason);
+    await this.env.runUntilIdle(false);
+  }
+  /** Run until this run (or the last run of its continue-as-new chain) ends; its output. */
+  async result() {
+    return this.env.resultOf(this.runId);
+  }
+  /** The projected state of the run. */
+  state() {
+    return this.env.stateOf(this.runId);
+  }
+};
+function toDate(value) {
+  if (value === void 0) return Date.parse("2026-01-01T00:00:00.000Z");
+  if (value instanceof Date) return value.getTime();
+  return typeof value === "number" ? value : Date.parse(value);
+}
+function toJsonValue(value) {
+  if (value === void 0) return null;
+  const text = JSON.stringify(value);
+  return text === void 0 ? null : JSON.parse(text);
+}
+var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
+  clock;
+  timeSkipping;
+  enabled;
+  workspaceId;
+  runs = /* @__PURE__ */ new Map();
+  runOrder = [];
+  mocks = /* @__PURE__ */ new Map();
+  childMocks = /* @__PURE__ */ new Map();
+  workflows;
+  registry;
+  attempts = [];
+  timers = [];
+  mockedChildren = [];
+  runCounter = 0;
+  executor;
+  workflowKeys;
+  constructor(options) {
+    this.clock = toDate(options.startTime);
+    this.timeSkipping = options.timeSkipping !== false;
+    this.enabled = options.enabled ?? "parity";
+    this.workspaceId = options.workspaceId ?? "test-workspace";
+    this.workflows = { ...options.workflows ?? {} };
+    this.registry = registryOf(this.workflows);
+    this.executor = options.taskExecutor;
+    this.workflowKeys = { ...options.workflowKeys ?? {} };
+  }
+  /** Create an environment. */
+  static async create(options = {}) {
+    return new _TestWorkflowEnvironment(options);
+  }
+  /** The fake clock, in epoch milliseconds. */
+  now() {
+    return this.clock;
+  }
+  /** Mock a node operation (by node type, and operation when given). */
+  mock(operation, impl, operationName) {
+    const nodeType = typeof operation === "string" ? operation : operation.nodeType;
+    const op = operationName ?? (typeof operation === "string" ? void 0 : operation.operation);
+    this.mocks.set(
+      op === void 0 ? nodeType : `${nodeType}#${op}`,
+      impl
+    );
+  }
+  /** Mock a child workflow started by key (graph or durable). */
+  mockChild(workflowKey, impl) {
+    this.childMocks.set(workflowKey, impl);
+  }
+  /** Start a run of a tier-2 function (by declaration, or by export name with a task executor). */
+  async start(definition, options = {}) {
+    const workflowFn = typeof definition === "string" ? definition : (
+      // A declared workflow is stored by its declaration; its input type is the caller's.
+      this.ensureRegistered(definition)
+    );
+    const runId = this.createRun(
+      workflowFn,
+      toJsonValue(options.input),
+      { ...options.info, ...options.runId !== void 0 ? { runId: options.runId } : {} },
+      void 0
+    );
+    for (const signal of options.signals ?? [])
+      this.deliverSignal(runId, signal.name, signal.payload);
+    await this.runUntilIdle(false);
+    return new TestRunHandle(this, runId);
+  }
+  /** Advance the clock by `duration`, firing timers and running work as it comes due. */
+  async sleep(duration) {
+    const until = this.clock + toMs(duration, "sleep duration");
+    await this.runUntilIdle(false);
+    for (; ; ) {
+      const next = this.nextDue();
+      if (next === void 0 || next > until) break;
+      this.clock = Math.max(this.clock, next);
+      this.fireDue();
+      await this.runUntilIdle(false);
+    }
+    this.clock = until;
+    this.fireDue();
+    await this.runUntilIdle(false);
+  }
+  /** Every run, in start order. */
+  runIds() {
+    return [...this.runOrder];
+  }
+  historyOf(runId) {
+    return this.run(runId).history.map((event) => ({ ...event, payload: { ...event.payload } }));
+  }
+  historyFileOf(runId, extra = {}) {
+    const run = this.run(runId);
+    return createHistoryFile(run.workflowFn, this.historyOf(runId), {
+      info: { ...run.info },
+      ...extra
+    });
+  }
+  /** The failed workflow task that stopped a run, if one did. */
+  taskFailureOf(runId) {
+    return this.run(runId).taskFailure;
+  }
+  stateOf(runId) {
+    return this.run(runId).state;
+  }
+  // ---- runs -------------------------------------------------------------------
+  ensureRegistered(definition) {
+    for (const [name2, value] of Object.entries(this.workflows))
+      if (value === definition) return name2;
+    const name = Object.hasOwn(this.workflows, definition.name) ? `${definition.name}#${this.runCounter}` : definition.name;
+    this.workflows[name] = definition;
+    this.registry = registryOf(this.workflows);
+    return name;
+  }
+  run(runId) {
+    const run = this.runs.get(runId);
+    if (!run) throw new Error(`Unknown run ${runId}`);
+    return run;
+  }
+  createRun(workflowFn, input, info, parent, extraStarted = {}) {
+    this.runCounter += 1;
+    const runId = info.runId ?? `run-${this.runCounter}`;
+    const snapshot = {
+      workspaceId: this.workspaceId,
+      taskQueue: "managed",
+      attempt: 1,
+      startedAt: new Date(this.clock).toISOString(),
+      runStartedAt: new Date(this.clock).toISOString(),
+      ...info,
+      runId,
+      ...parent ? { parentRunId: parent.runId } : {}
+    };
+    const run = {
+      runId,
+      workflowFn,
+      history: [],
+      state: initialRunState(),
+      taskCounter: 0,
+      info: snapshot,
+      children: /* @__PURE__ */ new Map(),
+      ...parent ? { parent } : {}
+    };
+    this.runs.set(runId, run);
+    this.runOrder.push(runId);
+    this.append(run, {
+      type: "WORKFLOW_STARTED",
+      // The service writes the seed of ctx.random()/ctx.uuid() into the start
+      // event so the history replays on its own; it uses the run id.
+      payload: { workflowFn, input, taskQueue: "managed", randomnessSeed: runId, ...extraStarted }
+    });
+    return runId;
+  }
+  append(run, draft) {
+    const event = {
+      seq: run.history.length + 1,
+      type: draft.type,
+      payload: draft.payload,
+      createdAt: new Date(this.clock).toISOString(),
+      ...draft.taskId !== void 0 ? { taskId: draft.taskId } : {}
+    };
+    applyEvent(run.state, event);
+    run.history.push(event);
+    if (isInputEvent(event) && run.state.status === "RUNNING" && run.state.task.state === "NONE") {
+      run.taskCounter += 1;
+      const taskId = `${run.runId}-task-${run.taskCounter}`;
+      const scheduled = {
+        seq: run.history.length + 1,
+        type: "WORKFLOW_TASK_SCHEDULED",
+        payload: { taskId },
+        createdAt: event.createdAt
+      };
+      applyEvent(run.state, scheduled);
+      run.history.push(scheduled);
+    }
+    return event;
+  }
+  deliverSignal(runId, name, payload) {
+    const run = this.runs.get(runId);
+    if (!run || run.state.status !== "RUNNING") return false;
+    this.append(run, {
+      type: "SIGNAL_RECEIVED",
+      payload: {
+        name,
+        payload: toJsonValue(payload),
+        receivedAt: new Date(this.clock).toISOString()
+      }
+    });
+    return true;
+  }
+  requestCancel(runId, reason) {
+    const run = this.runs.get(runId);
+    if (!run || run.state.status !== "RUNNING") return false;
+    if (run.state.cancelRequested) return true;
+    this.append(run, {
+      type: "WORKFLOW_CANCEL_REQUESTED",
+      payload: reason !== void 0 ? { reason } : {}
+    });
+    return true;
+  }
+  terminate(runId, reason) {
+    const run = this.runs.get(runId);
+    if (!run || run.state.status !== "RUNNING") return;
+    this.append(run, { type: "WORKFLOW_TERMINATED", payload: { reason } });
+    this.onClosed(run);
+  }
+  // ---- the loop ---------------------------------------------------------------
+  /** Run every runnable task and activity; skip time when allowed and idle. */
+  async runUntilIdle(skipTime) {
+    for (let guard = 0; guard < 1e5; guard++) {
+      const task = this.runOrder.map((id) => this.runs.get(id)).find(
+        (run) => run !== void 0 && !run.taskFailure && run.state.status === "RUNNING" && run.state.task.state === "SCHEDULED"
+      );
+      if (task) {
+        await this.runTask(task);
+        continue;
+      }
+      const attempt = this.attempts.find((entry) => entry.dueAt <= this.clock);
+      if (attempt) {
+        this.attempts = this.attempts.filter((entry) => entry !== attempt);
+        await this.runAttempt(attempt);
+        continue;
+      }
+      const mocked = this.mockedChildren.shift();
+      if (mocked) {
+        await this.runMockedChild(mocked);
+        continue;
+      }
+      if (this.fireDue()) continue;
+      if (!skipTime) return;
+      const next = this.nextDue();
+      if (next === void 0) return;
+      this.clock = Math.max(this.clock, next);
+    }
+    throw new Error("The test environment did not settle after 100000 steps");
+  }
+  nextDue() {
+    const due = [
+      ...this.timers.map((timer) => timer.fireAt),
+      ...this.attempts.map((entry) => entry.dueAt)
+    ];
+    return due.length === 0 ? void 0 : Math.min(...due);
+  }
+  fireDue() {
+    const due = this.timers.filter((timer) => timer.fireAt <= this.clock).sort((a, b) => a.fireAt - b.fireAt);
+    if (due.length === 0) return false;
+    this.timers = this.timers.filter((timer) => !due.includes(timer));
+    for (const timer of due) {
+      const run = this.runs.get(timer.runId);
+      if (!run || run.state.status !== "RUNNING" || run.state.timers[timer.timerId]?.status !== "PENDING")
+        continue;
+      this.append(run, { type: "TIMER_FIRED", payload: { timerId: timer.timerId } });
+    }
+    return true;
+  }
+  async runTask(run) {
+    const taskId = run.state.task.taskId ?? `${run.runId}-task-${run.taskCounter}`;
+    this.append(run, { type: "WORKFLOW_TASK_STARTED", payload: { taskId, attempt: 1 } });
+    const request = {
+      protocol: HISTORY_PROTOCOL,
+      kind: "task",
+      workflowFn: run.workflowFn,
+      info: run.info,
+      history: run.history,
+      nowMs: this.clock
+    };
+    const result = this.executor ? await this.executor(request) : await runWorkflowTaskInProcess(this.registry, request);
+    const fail = (cause, message) => {
+      this.append(run, {
+        type: "WORKFLOW_TASK_FAILED",
+        payload: { taskId, attempt: 1, cause, message }
+      });
+      run.taskFailure = { ...result, outcome: "failed", commands: [], failure: { cause, message } };
+    };
+    if (result.outcome !== "commands") {
+      fail(result.failure?.cause ?? "INTERNAL", result.failure?.message ?? "The task failed");
+      run.taskFailure = result;
+      return;
+    }
+    const checked = validateCommands(result.commands, { enabled: this.enabled });
+    if (!checked.ok) {
+      fail(checked.cause, checked.issues.map((issue) => issue.message).join("; "));
+      return;
+    }
+    const drafts = eventsForCommands(run.state, checked.commands, {
+      taskId,
+      nowMs: this.clock,
+      enabled: this.enabled
+    });
+    if (!drafts.ok) {
+      fail(drafts.cause, drafts.issues.map((issue) => issue.message).join("; "));
+      return;
+    }
+    this.append(run, { type: "WORKFLOW_TASK_COMPLETED", taskId, payload: { taskId } });
+    for (const draft of drafts.events) this.append(run, draft);
+    for (const command of checked.commands)
+      if (run.state.status === "RUNNING" || TERMINAL_COMMANDS.has(command.type))
+        this.afterCommand(run, command);
+  }
+  afterCommand(run, command) {
+    switch (command.type) {
+      case "SCHEDULE_ACTIVITY": {
+        const attempt = {
+          runId: run.runId,
+          activityId: command.activityId,
+          attempt: 1,
+          dueAt: this.clock,
+          scheduledAt: this.clock,
+          args: command.args,
+          nodeType: command.nodeType,
+          operation: command.operation,
+          retry: command.retry,
+          cancelRequested: false,
+          ...command.connection !== void 0 ? { connection: command.connection } : {},
+          ...command.scheduleToCloseTimeout !== void 0 ? { scheduleToClose: command.scheduleToCloseTimeout } : {}
+        };
+        this.attempts.push(attempt);
+        return;
+      }
+      case "REQUEST_CANCEL_ACTIVITY": {
+        const pending = this.attempts.find(
+          (entry) => entry.runId === run.runId && entry.activityId === command.activityId
+        );
+        if (pending) {
+          this.attempts = this.attempts.filter((entry) => entry !== pending);
+          this.append(run, {
+            type: "ACTIVITY_CANCELLED",
+            payload: { activityId: command.activityId }
+          });
+        }
+        return;
+      }
+      case "START_TIMER":
+        this.timers.push({
+          runId: run.runId,
+          timerId: command.timerId,
+          fireAt: this.clock + command.durationMs
+        });
+        return;
+      case "CANCEL_TIMER":
+        this.timers = this.timers.filter(
+          (timer) => !(timer.runId === run.runId && timer.timerId === command.timerId)
+        );
+        return;
+      case "START_CHILD_RUN":
+        this.startChild(run, command);
+        return;
+      case "SIGNAL_RUN": {
+        const target = this.resolveTarget(run, command.target);
+        const ok = target !== void 0 && this.deliverSignal(target, command.name, command.payload);
+        this.append(run, {
+          type: "EXTERNAL_RUN_SIGNALED",
+          payload: {
+            externalId: command.externalId,
+            resolved: true,
+            ok,
+            ...target !== void 0 ? { targetRunId: target } : {},
+            ...ok ? {} : {
+              failure: {
+                errorType: "VALIDATION",
+                message: "The target run is not open",
+                type: "ServerFailure"
+              }
+            }
+          }
+        });
+        return;
+      }
+      case "REQUEST_CANCEL_EXTERNAL_RUN": {
+        const target = this.resolveTarget(run, command.target);
+        const ok = target !== void 0 && this.requestCancel(target);
+        this.append(run, {
+          type: "EXTERNAL_RUN_CANCEL_RESOLVED",
+          payload: {
+            externalId: command.externalId,
+            ok,
+            ...target !== void 0 ? { targetRunId: target } : {},
+            ...ok ? {} : {
+              failure: {
+                errorType: "VALIDATION",
+                message: "The target run is not open",
+                type: "ServerFailure"
+              }
+            }
+          }
+        });
+        return;
+      }
+      case "CONTINUE_AS_NEW": {
+        const next = this.createRun(
+          run.workflowFn,
+          command.input,
+          {
+            ...run.info,
+            runId: void 0,
+            continuedFromRunId: run.runId,
+            firstRunId: run.info.firstRunId ?? run.runId
+          },
+          run.parent
+        );
+        run.continuedTo = next;
+        this.onClosed(run);
+        return;
+      }
+      case "COMPLETE_WORKFLOW":
+      case "FAIL_WORKFLOW":
+      case "CANCEL_WORKFLOW":
+        this.onClosed(run);
+        return;
+      default:
+        return;
+    }
+  }
+  resolveTarget(run, target) {
+    if ("runId" in target) return target.runId;
+    if ("parent" in target) return run.parent?.runId ?? run.info.parentRunId ?? void 0;
+    if ("childId" in target) return run.children.get(target.childId);
+    return void 0;
+  }
+  startChild(run, command) {
+    const byFn = command.workflowFn !== void 0 && (this.executor !== void 0 || this.registry.byName.has(command.workflowFn));
+    const keyed = command.workflowKey === void 0 ? void 0 : this.workflowKeys[command.workflowKey] ?? Object.entries(this.workflows).find(
+      ([, definition]) => definition.name === command.workflowKey
+    )?.[0];
+    const mock = command.workflowKey !== void 0 ? this.childMocks.get(command.workflowKey) : void 0;
+    if (mock) {
+      run.children.set(command.childId, void 0);
+      this.mockedChildren.push({
+        parentRunId: run.runId,
+        childId: command.childId,
+        input: command.input,
+        key: command.workflowKey ?? ""
+      });
+      return;
+    }
+    const workflowFn = byFn ? command.workflowFn : keyed;
+    if (workflowFn === void 0) {
+      this.append(run, {
+        type: "CHILD_RUN_FAILED",
+        payload: {
+          childId: command.childId,
+          failure: {
+            errorType: "VALIDATION",
+            message: `No workflow "${command.workflowFn ?? command.workflowKey ?? ""}" in the test environment (register it or mockChild it)`,
+            type: "ServerFailure"
+          }
+        }
+      });
+      return;
+    }
+    const childRunId = this.createRun(
+      workflowFn,
+      command.input,
+      { rootRunId: run.info.rootRunId ?? run.runId },
+      { runId: run.runId, childId: command.childId },
+      {
+        parentRunId: run.runId,
+        parentClosePolicy: command.options.parentClosePolicy
+      }
+    );
+    run.children.set(command.childId, childRunId);
+    this.append(run, {
+      type: "CHILD_RUN_STARTED",
+      payload: { childId: command.childId, childRunId, executionKind: "DURABLE_FN" }
+    });
+  }
+  async runMockedChild(entry) {
+    const parent = this.runs.get(entry.parentRunId);
+    const mock = this.childMocks.get(entry.key);
+    if (!parent || !mock || parent.state.status !== "RUNNING") return;
+    const childRunId = `${entry.parentRunId}-${entry.childId}`;
+    this.append(parent, {
+      type: "CHILD_RUN_STARTED",
+      payload: { childId: entry.childId, childRunId, executionKind: "GRAPH" }
+    });
+    try {
+      const result = toJsonValue(
+        await mock(entry.input, { runId: entry.parentRunId, childId: entry.childId })
+      );
+      if (parent.state.status === "RUNNING")
+        this.append(parent, {
+          type: "CHILD_RUN_COMPLETED",
+          payload: { childId: entry.childId, childRunId, result }
+        });
+    } catch (error) {
+      if (parent.state.status === "RUNNING")
+        this.append(parent, {
+          type: "CHILD_RUN_FAILED",
+          payload: {
+            childId: entry.childId,
+            childRunId,
+            failure: toJsonValue(errorToFailure(error, "engine"))
+          }
+        });
+    }
+  }
+  async runAttempt(attempt) {
+    const run = this.runs.get(attempt.runId);
+    if (!run || run.state.status !== "RUNNING") return;
+    const activity = run.state.activities[attempt.activityId];
+    if (!activity || !isActivityOpen(activity)) return;
+    if (attempt.scheduleToClose !== void 0 && this.clock - attempt.scheduledAt > attempt.scheduleToClose) {
+      this.append(run, {
+        type: "ACTIVITY_TIMED_OUT",
+        payload: {
+          activityId: attempt.activityId,
+          attempt: Math.max(1, attempt.attempt - 1),
+          timeoutType: "SCHEDULE_TO_CLOSE"
+        }
+      });
+      return;
+    }
+    const mock = this.mocks.get(`${attempt.nodeType}#${attempt.operation}`) ?? this.mocks.get(attempt.nodeType);
+    let failure;
+    let result = null;
+    try {
+      if (!mock)
+        throw new ApplicationError(
+          `No mock for ${attempt.nodeType} ${attempt.operation} (use env.mock)`,
+          {
+            errorType: "VALIDATION",
+            nonRetryable: true,
+            type: "UnmockedActivity"
+          }
+        );
+      result = toJsonValue(
+        await mock(attempt.args, {
+          runId: attempt.runId,
+          activityId: attempt.activityId,
+          attempt: attempt.attempt,
+          nodeType: attempt.nodeType,
+          operation: attempt.operation,
+          ...attempt.connection !== void 0 ? { connection: attempt.connection } : {}
+        })
+      );
+    } catch (error) {
+      failure = errorToFailure(error, `node:${attempt.nodeType}`);
+      delete failure.stackTrace;
+    }
+    if (run.state.status !== "RUNNING" || !isActivityOpen(run.state.activities[attempt.activityId] ?? activity))
+      return;
+    const started = () => {
+      this.append(run, {
+        type: "ACTIVITY_STARTED",
+        payload: { activityId: attempt.activityId, attempt: attempt.attempt }
+      });
+    };
+    if (!failure) {
+      started();
+      this.append(run, {
+        type: "ACTIVITY_COMPLETED",
+        payload: { activityId: attempt.activityId, attempt: attempt.attempt, result }
+      });
+      return;
+    }
+    if (failure.timeoutType !== void 0 || failure.type === "TimeoutFailure") {
+      const decision2 = computeRetryDelay(attempt.retry, attempt.attempt, failure);
+      if (!decision2.retry) {
+        started();
+        this.append(run, {
+          type: "ACTIVITY_TIMED_OUT",
+          payload: {
+            activityId: attempt.activityId,
+            attempt: attempt.attempt,
+            timeoutType: failure.timeoutType ?? "START_TO_CLOSE",
+            failure: toJsonValue(failure)
+          }
+        });
+        return;
+      }
+      this.attempts.push({
+        ...attempt,
+        attempt: attempt.attempt + 1,
+        dueAt: this.clock + decision2.delayMs
+      });
+      return;
+    }
+    const decision = computeRetryDelay(attempt.retry, attempt.attempt, failure);
+    if (decision.retry) {
+      this.attempts.push({
+        ...attempt,
+        attempt: attempt.attempt + 1,
+        dueAt: this.clock + decision.delayMs
+      });
+      return;
+    }
+    started();
+    this.append(run, {
+      type: "ACTIVITY_FAILED",
+      payload: {
+        activityId: attempt.activityId,
+        attempt: attempt.attempt,
+        failure: toJsonValue(failure)
+      }
+    });
+  }
+  onClosed(run) {
+    this.timers = this.timers.filter((timer) => timer.runId !== run.runId);
+    this.attempts = this.attempts.filter((entry) => entry.runId !== run.runId);
+    for (const [childId2, childRunId] of run.children) {
+      const child = run.state.children[childId2];
+      if (!child || !isChildOpen(child) || childRunId === void 0) continue;
+      if (child.parentClosePolicy === "TERMINATE") this.terminate(childRunId, "parent closed");
+      else if (child.parentClosePolicy === "REQUEST_CANCEL")
+        this.requestCancel(childRunId, "parent closed");
+    }
+    if (!run.parent) return;
+    const parent = this.runs.get(run.parent.runId);
+    if (!parent || parent.state.status !== "RUNNING") return;
+    const childId = run.parent.childId;
+    if (!parent.state.children[childId] || !isChildOpen(parent.state.children[childId])) return;
+    const last = run.history[run.history.length - 1];
+    if (!last) return;
+    if (run.continuedTo !== void 0) {
+      const next = this.runs.get(run.continuedTo);
+      if (next) {
+        next.parent = run.parent;
+        parent.children.set(childId, next.runId);
+      }
+      return;
+    }
+    const base = { childId, childRunId: run.runId };
+    switch (last.type) {
+      case "WORKFLOW_COMPLETED":
+        this.append(parent, {
+          type: "CHILD_RUN_COMPLETED",
+          payload: { ...base, result: last.payload["output"] ?? null }
+        });
+        return;
+      case "WORKFLOW_FAILED":
+        this.append(parent, {
+          type: "CHILD_RUN_FAILED",
+          payload: {
+            ...base,
+            failure: last.payload["failure"] ?? { errorType: "UNKNOWN", message: "failed" }
+          }
+        });
+        return;
+      case "WORKFLOW_CANCELLED":
+        this.append(parent, { type: "CHILD_RUN_CANCELLED", payload: base });
+        return;
+      case "WORKFLOW_TERMINATED":
+        this.append(parent, {
+          type: "CHILD_RUN_TERMINATED",
+          payload: {
+            ...base,
+            reason: typeof last.payload["reason"] === "string" ? last.payload["reason"] : "terminated"
+          }
+        });
+        return;
+      default:
+        this.append(parent, {
+          type: "CHILD_RUN_TIMED_OUT",
+          payload: { ...base, timeoutType: "WORKFLOW_RUN" }
+        });
+    }
+  }
+  async resultOf(runId) {
+    await this.runUntilIdle(this.timeSkipping);
+    let run = this.run(runId);
+    while (run.continuedTo !== void 0) run = this.run(run.continuedTo);
+    if (run.taskFailure) throw new WorkflowTaskFailedError(run.runId, run.taskFailure);
+    const last = run.history[run.history.length - 1];
+    switch (run.state.status) {
+      case "COMPLETED":
+        return run.state.output ?? null;
+      case "FAILED":
+        throw new WorkflowFailedError(
+          run.runId,
+          run.state.failure ?? { errorType: "UNKNOWN", message: "failed" }
+        );
+      case "CANCELLED":
+        throw new CancelledFailure(`Run ${run.runId} was cancelled`);
+      case "TERMINATED":
+        throw new WorkflowFailedError(run.runId, {
+          errorType: "PERMANENT",
+          message: typeof last?.payload["reason"] === "string" ? last.payload["reason"] : "terminated",
+          type: "TerminatedFailure"
+        });
+      default:
+        throw new RunBlockedError(run.runId);
+    }
+  }
+  /** Every tier-2 function registered, by export name. */
+  registered() {
+    return { ...this.workflows };
+  }
+};
+
+// src/testing/replay.ts
+var ReplayError = class extends Error {
+  constructor(result) {
+    super(
+      `Replay failed (${result.failure?.cause ?? "INTERNAL"}): ${result.failure?.message ?? ""}`
+    );
+    this.result = result;
+    this.name = "ReplayError";
+  }
+  result;
+};
+function replayRequest(workflowFn, history, info = {}, nowMs) {
+  const last = history[history.length - 1];
+  return {
+    protocol: HISTORY_PROTOCOL,
+    kind: "verify",
+    workflowFn,
+    info: { runId: "replay", workspaceId: "replay", ...info },
+    history,
+    nowMs: nowMs ?? (last ? Date.parse(last.createdAt) : 0)
+  };
+}
+function eventsOf(input) {
+  if (Array.isArray(input)) return { events: input };
+  const file = typeof input === "string" ? parseHistoryFile(input) : input;
+  return { events: file.events, file };
+}
+async function replay(workflows, input, options = {}) {
+  const { events, file } = eventsOf(input);
+  const started = events[0]?.type === "WORKFLOW_STARTED" ? events[0].payload["workflowFn"] : void 0;
+  const recordedFn = options.workflowFn ?? file?.workflowFn ?? (typeof started === "string" ? started : void 0);
+  const map = isDurableWorkflow(workflows) ? { [recordedFn ?? workflows.name]: workflows } : { ...workflows };
+  const workflowFn = recordedFn ?? Object.keys(map)[0] ?? "";
+  const result = await runWorkflowTaskInProcess(
+    registryOf(map),
+    replayRequest(
+      workflowFn,
+      events,
+      { ...file?.info, ...options.info },
+      options.nowMs ?? file?.nowMs
+    )
+  );
+  if (result.outcome === "failed") {
+    if (result.failure?.cause === "NON_DETERMINISM")
+      throw new DeterminismViolation(result.failure.message);
+    throw new ReplayError(result);
+  }
+  return result;
+}
+
+// src/testing/assert.ts
+var HistoryAssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HistoryAssertionError";
+  }
+};
+function contains(actual, expected) {
+  if (isRecord(expected)) {
+    if (!isRecord(actual)) return false;
+    return Object.entries(expected).every(([key, value]) => contains(actual[key], value));
+  }
+  if (Array.isArray(expected)) {
+    return Array.isArray(actual) && actual.length === expected.length && expected.every((item, index) => contains(actual[index], item));
+  }
+  return Object.is(actual, expected);
+}
+function assertHistory(history, expected, options = {}) {
+  const ignored = new Set(options.ignore ?? []);
+  const events = (Array.isArray(history) ? history : history.history()).filter((event) => !ignored.has(event.type));
+  let position = 0;
+  for (const [index, want] of expected.entries()) {
+    let found = -1;
+    for (let cursor = position; cursor < events.length; cursor++) {
+      const event = events[cursor];
+      if (event && event.type === want.type && (want.payload === void 0 || contains(event.payload, want.payload))) {
+        found = cursor;
+        break;
+      }
+      if (options.exact) break;
+    }
+    if (found < 0)
+      throw new HistoryAssertionError(
+        `Expected event ${index + 1} (${want.type}${want.payload ? ` ${JSON.stringify(want.payload)}` : ""}) after seq ${events[position - 1]?.seq ?? 0}; the history has ${events.slice(position).map((event) => event.type).join(", ") || "nothing more"}`
+      );
+    position = found + 1;
+  }
+  if (options.exact && position !== events.length)
+    throw new HistoryAssertionError(
+      `The history has ${events.length - position} more events than expected`
+    );
+}
+function definitionOf(value) {
+  return normalizeDefinition(isTier1Workflow(value) ? toIR(value) : value);
+}
+function expectIR(value) {
+  const definition = definitionOf(value);
+  const hash = irHash(definition);
+  return {
+    definition,
+    irHash: hash,
+    toEqualIR(other) {
+      const otherHash = irHash(definitionOf(other));
+      if (otherHash !== hash)
+        throw new HistoryAssertionError(`The IR differs: ${hash} versus ${otherHash}`);
+    }
+  };
+}
+function jsonCopy(value) {
+  return JSON.parse(JSON.stringify(value ?? null));
+}
+
+// src/testing/simulate.ts
+function isHandleResult(value) {
+  return isRecord(value) && Object.hasOwn(value, "output") && Object.keys(value).every((key) => key === "output" || key === "handle");
+}
+async function simulate(definition, options = {}) {
+  const nodes = definition.data.nodes;
+  const edges = definition.data.edges;
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const incoming = new Set(edges.map((edge) => edge.target));
+  const maxVisits = options.maxVisits ?? 1;
+  const visits = /* @__PURE__ */ new Map();
+  const steps = [];
+  const outputs = {};
+  const queue = nodes.filter((node) => !incoming.has(node.id)).map((node) => ({ nodeId: node.id, input: options.trigger ?? {} }));
+  const mocks = options.mocks ?? {};
+  let env;
+  for (let guard = 0; queue.length > 0 && guard < 1e4; guard++) {
+    const next = queue.shift();
+    if (!next) break;
+    const node = byId.get(next.nodeId);
+    if (!node) continue;
+    const count = visits.get(node.id) ?? 0;
+    if (count >= maxVisits) continue;
+    visits.set(node.id, count + 1);
+    const mock = mocks[node.id] ?? mocks[node.type];
+    let output = next.input;
+    let handle;
+    if (mock) {
+      const produced = await mock(next.input, node);
+      if (isHandleResult(produced)) {
+        output = produced.output;
+        handle = produced.handle;
+      } else output = produced;
+    } else if (node.type === CODE_WORKFLOW_NODE_TYPE) {
+      const state = node.args?.state;
+      const workflowFn = isRecord(state) && typeof state["workflowFn"] === "string" ? state["workflowFn"] : "";
+      const fn = options.workflows?.[workflowFn];
+      if (!fn)
+        throw new Error(
+          `simulate: code-workflow node "${node.id}" runs "${workflowFn}"; pass it in workflows or mock the node`
+        );
+      env ??= await TestWorkflowEnvironment.create({ workflows: options.workflows ?? {} });
+      const handleRun = await env.start(fn, { input: next.input });
+      const result = jsonCopy(await handleRun.result());
+      output = result !== null && typeof result === "object" && !Array.isArray(result) ? result : { result };
+    }
+    outputs[node.id] = output;
+    steps.push({
+      nodeId: node.id,
+      type: node.type,
+      input: next.input,
+      output,
+      ...handle !== void 0 ? { handle } : {}
+    });
+    for (const edge of edges) {
+      if (edge.source !== node.id) continue;
+      if (handle !== void 0 && edge.sourceHandle !== void 0 && edge.sourceHandle !== handle)
+        continue;
+      queue.push({ nodeId: edge.target, input: output });
+    }
+  }
+  return { steps, outputs };
+}
+async function bundleToScript(bundle, esbuild) {
+  const api = esbuild ?? await import('esbuild');
+  const result = await api.transform(bundle, {
+    format: "iife",
+    globalName: "__fluidgridsBundle",
+    target: "es2023",
+    platform: "neutral",
+    charset: "utf8",
+    legalComments: "none",
+    logLevel: "silent"
+  });
+  return result.code;
+}
+function settle() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+async function runWorkflowTaskInVm(script, request, options = {}) {
+  const timeout = options.timeoutMs ?? 1e4;
+  const context = createContext(/* @__PURE__ */ Object.create(null), {
+    codeGeneration: { strings: false, wasm: false },
+    microtaskMode: "afterEvaluate",
+    name: "fluidgrids-workflow-task"
+  });
+  const run = (source, filename) => new Script(source, { filename }).runInContext(context, { timeout });
+  try {
+    run(TASK_PRELUDE, "fluidgrids-task-prelude.js");
+    run(script, "workflow-bundle.js");
+    run(
+      `globalThis.__fluidgridsRuntime.start(${JSON.stringify(JSON.stringify(request))})`,
+      "start.js"
+    );
+    await settle();
+    const deadline = Date.now() + timeout;
+    for (; ; ) {
+      const step = run("globalThis.__fluidgridsRuntime.step()", "step.js");
+      await settle();
+      if (step !== "more") break;
+      if (Date.now() > deadline)
+        return failedTaskResult(
+          "TASK_TIMEOUT",
+          `The workflow task ran past its ${timeout} ms budget`
+        );
+    }
+    const json = run("globalThis.__fluidgridsRuntime.complete()", "complete.js");
+    if (typeof json !== "string")
+      return failedTaskResult("INTERNAL", "The runtime returned no result");
+    return JSON.parse(json);
+  } catch (error) {
+    const fields = typeof error === "object" && error !== null ? error : {};
+    const message = typeof fields.message === "string" ? fields.message : String(error);
+    const name = typeof fields.name === "string" ? fields.name : "";
+    if (/timed out/i.test(message)) return failedTaskResult("TASK_TIMEOUT", message);
+    if (name === "DeterminismViolation") return failedTaskResult("NON_DETERMINISM", message);
+    return failedTaskResult("WORKFLOW_CODE_ERROR", `${name || "Error"}: ${message}`);
+  }
+}
+
+export { HistoryAssertionError, ReplayError, RunBlockedError, TestRunHandle, TestWorkflowEnvironment, WorkflowFailedError, WorkflowTaskFailedError, assertHistory, bundleToScript, drainJobs, expectIR, jsonCopy, registryOf, replay, replayRequest, runWorkflowTaskInProcess, runWorkflowTaskInVm, simulate };