@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/testing/index.js

@@ -1,28 +1,32 @@
-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 { failedTaskResult } from '../chunk-G5H32GIG.js';
+import { isTier1Workflow, toIR } from '../chunk-SR7TR5KX.js';
+import { irHash, CODE_WORKFLOW_NODE_TYPE, normalizeDefinition } from '../chunk-NWQ5WRLE.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 { createHistoryFile, validateCommands, parseHistoryFile } from '../chunk-YEHR4NNE.js';
+import '../chunk-VU5S5A7V.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 { buildWorkflowRegistry, createWorkflowRuntime } from '../chunk-2D3MYIIF.js';
+import { failureToError, signalName, ApplicationError, errorToFailure, CancelledFailure, DeterminismViolation } from '../chunk-6A2FGSUS.js';
+import '../chunk-M272AHEX.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 { isActivityImplementation, isActivityDefinition, ACTIVITY_IMPL_MARKER, ACTIVITY_MARKER, runRetryPolicyOf, toMs, findActivityImplementation, executeActivity, isDurableWorkflow } from '../chunk-C4F5KJTI.js';
+import '../chunk-LNUQE6D6.js';
+import { COMMAND_FEATURES, codeFeaturesEnabledBy, applyEvent, projectRunState, isActivityOpen, hasUnprocessedInput, initialRunState, eventsForCommands, continueAsNewRetryShape, isChildOpen } from '../chunk-AE5Q6ZAJ.js';
+import '../chunk-AC6ZEXVR.js';
+import { RUNTIME_RELEASE, HISTORY_PROTOCOL, isCommandEvent, TERMINAL_EVENTS, isInputEvent, TERMINAL_COMMANDS, computeRetryDelay, computeRunRetryDelay } from '../chunk-5HIVIV53.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 }]]);
+function registryOf(workflows, interceptors) {
+  return buildWorkflowRegistry([
+    ["in-process", { ...workflows, ...interceptors !== void 0 ? { interceptors } : {} }]
+  ]);
 }
 async function hostLoop(abi, requestJson) {
   abi.start(requestJson);
@@ -38,6 +42,58 @@ async function runWorkflowTaskInProcess(registry, request) {
 }
 
 // src/testing/environment.ts
+var QueryRejectedError = class extends Error {
+  constructor(runId, queryName, message) {
+    super(message);
+    this.runId = runId;
+    this.queryName = queryName;
+    this.name = "QueryRejectedError";
+  }
+  runId;
+  queryName;
+};
+var QueryFailedError = class extends Error {
+  constructor(runId, queryName, message) {
+    super(message);
+    this.runId = runId;
+    this.queryName = queryName;
+    this.name = "QueryFailedError";
+  }
+  runId;
+  queryName;
+};
+var UpdateRefusedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UpdateRefusedError";
+  }
+};
+var WorkflowAlreadyStartedError = class extends Error {
+  constructor(workflowKey, workflowId, existingRunId) {
+    super(
+      `Workflow ${workflowKey} already has a run with workflow id "${workflowId}" (${existingRunId})`
+    );
+    this.workflowKey = workflowKey;
+    this.workflowId = workflowId;
+    this.existingRunId = existingRunId;
+    this.name = "WorkflowAlreadyStartedError";
+  }
+  workflowKey;
+  workflowId;
+  existingRunId;
+};
+var UnfinishedHandlersError = class extends Error {
+  constructor(runId, handlers) {
+    super(
+      `Run ${runId} finished while handlers were still running: ${handlers.map((handler) => `${handler.kind} ${handler.name} x${handler.count}`).join(", ")} (await ctx.allHandlersFinished(), or set unfinishedPolicy: 'ABANDON')`
+    );
+    this.runId = runId;
+    this.handlers = handlers;
+    this.name = "UnfinishedHandlersError";
+  }
+  runId;
+  handlers;
+};
 var WorkflowFailedError = class extends Error {
   constructor(runId, failure) {
     super(`Run ${runId} failed: ${failure.message}`);
@@ -69,7 +125,7 @@ var RunBlockedError = class extends Error {
   }
   runId;
 };
-var TestRunHandle = class {
+var TestRunHandle = class _TestRunHandle {
   constructor(env, runId) {
     this.env = env;
     this.runId = runId;
@@ -99,6 +155,22 @@ var TestRunHandle = class {
     this.env.terminate(this.runId, reason);
     await this.env.runUntilIdle(false);
   }
+  /** Send an update and run until idle (Phase C). */
+  update(update, args, options = {}) {
+    return this.env.update(this.runId, update, args, options);
+  }
+  /** Answer a query from the run's history (Phase C custom queries and the built-ins). */
+  query(query, args) {
+    return this.env.query(this.runId, query, args);
+  }
+  /** Reset the run (11 §2.7): a new run forked at a completed task; this one is terminated. */
+  async reset(options = {}) {
+    return new _TestRunHandle(this.env, await this.env.reset(this.runId, options));
+  }
+  /** Sink calls the run's tasks made (Phase C). */
+  sinkCalls() {
+    return this.env.sinkCallsOf(this.runId);
+  }
   /** 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);
@@ -113,6 +185,23 @@ function toDate(value) {
   if (value instanceof Date) return value.getTime();
   return typeof value === "number" ? value : Date.parse(value);
 }
+function optionalDuration(value, what) {
+  return value === void 0 ? void 0 : toMs(value, what);
+}
+var FAILED_STATUSES = /* @__PURE__ */ new Set([
+  "FAILED",
+  "CANCELLED",
+  "TERMINATED",
+  "TIMED_OUT"
+]);
+function admittedPayload(update) {
+  return {
+    updateId: update.updateId,
+    name: update.name,
+    args: update.args,
+    ...update.headers !== void 0 ? { headers: { ...update.headers } } : {}
+  };
+}
 function toJsonValue(value) {
   if (value === void 0) return null;
   const text = JSON.stringify(value);
@@ -122,6 +211,12 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   clock;
   timeSkipping;
   enabled;
+  /** The bundle features the gate's flags enable, sent with every task (`request.features`). */
+  codeFeatures;
+  failOnUnfinishedHandlers;
+  historyRelease;
+  dues = [];
+  held = /* @__PURE__ */ new Set();
   workspaceId;
   runs = /* @__PURE__ */ new Map();
   runOrder = [];
@@ -133,17 +228,65 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   timers = [];
   mockedChildren = [];
   runCounter = 0;
+  updateCounter = 0;
   executor;
   workflowKeys;
+  interceptors;
+  activityImpls;
+  activityInterceptors;
+  connections;
+  sinks;
+  /** Attempts that handed their completion to an outside system (`completeAsync`), by token. */
+  asyncAttempts = /* @__PURE__ */ new Map();
   constructor(options) {
     this.clock = toDate(options.startTime);
     this.timeSkipping = options.timeSkipping !== false;
-    this.enabled = options.enabled ?? "parity";
+    this.enabled = options.enabled ?? new Set(COMMAND_FEATURES);
+    this.codeFeatures = codeFeaturesEnabledBy(this.enabled);
+    this.failOnUnfinishedHandlers = options.failOnUnfinishedHandlers !== false;
+    this.historyRelease = options.historyRelease ?? RUNTIME_RELEASE;
     this.workspaceId = options.workspaceId ?? "test-workspace";
     this.workflows = { ...options.workflows ?? {} };
-    this.registry = registryOf(this.workflows);
+    this.interceptors = options.interceptors;
+    this.registry = registryOf(this.workflows, this.interceptors);
     this.executor = options.taskExecutor;
     this.workflowKeys = { ...options.workflowKeys ?? {} };
+    this.activityImpls = [...options.activities ?? []];
+    for (const impl of this.activityImpls)
+      if (!isActivityImplementation(impl))
+        throw new TypeError("activities must be implementActivity() or defineActivity() values");
+    this.activityInterceptors = [...options.activityInterceptors ?? []];
+    this.connections = { ...options.connections ?? {} };
+    this.sinks = { ...options.sinks ?? {} };
+  }
+  /** Register a user-activity implementation (Phase C). A later one replaces an earlier of the same name. */
+  registerActivity(implementation) {
+    if (!isActivityImplementation(implementation))
+      throw new TypeError(
+        "registerActivity needs an implementActivity() or defineActivity() value"
+      );
+    const index = this.activityImpls.findIndex(
+      (impl) => impl.name === implementation.name && impl.dynamic === implementation.dynamic
+    );
+    if (index >= 0) this.activityImpls.splice(index, 1);
+    this.activityImpls.push(implementation);
+  }
+  /** Mock a user activity by name or declaration (Phase C). */
+  mockActivity(activity, fn) {
+    const name = typeof activity === "string" ? activity : activity.name;
+    if (typeof activity !== "string" && !isActivityDefinition(activity))
+      throw new TypeError("mockActivity needs an activity name or a declareActivity() value");
+    this.registerActivity(
+      Object.freeze({
+        __fluidgrids: ACTIVITY_MARKER,
+        name,
+        options: typeof activity === "string" ? {} : activity.options,
+        implementation: ACTIVITY_IMPL_MARKER,
+        // The mock receives the activity's JSON args, typed by the declaration.
+        fn: (ctx, args) => fn(args, ctx),
+        dynamic: false
+      })
+    );
   }
   /** Create an environment. */
   static async create(options = {}) {
@@ -162,6 +305,26 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       impl
     );
   }
+  /**
+   * 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 = "*") {
+    this.held.add(nodeType);
+  }
+  /** Release held activity queues (all when no node type is given). */
+  releaseActivities(nodeType) {
+    if (nodeType === void 0) this.held.clear();
+    else this.held.delete(nodeType);
+  }
+  /** The hold key of an attempt: its node type, or the task queue of a user activity. */
+  holdKeyOf(entry) {
+    return entry.kind === "user" ? entry.taskQueue ?? "" : entry.nodeType;
+  }
+  isHeld(nodeType) {
+    return this.held.has("*") || this.held.has(nodeType);
+  }
   /** Mock a child workflow started by key (graph or durable). */
   mockChild(workflowKey, impl) {
     this.childMocks.set(workflowKey, impl);
@@ -172,17 +335,327 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       // A declared workflow is stored by its declaration; its input type is the caller's.
       this.ensureRegistered(definition)
     );
+    const declared = this.workflows[workflowFn]?.options ?? {};
+    const workflowKey = options.workflowKey ?? (typeof definition === "string" ? this.workflows[workflowFn]?.name ?? workflowFn : definition.name);
+    if (options.update !== void 0 && options.startDelay !== void 0)
+      throw new UpdateRefusedError(
+        "Update-with-start cannot be combined with a start delay (11 \xA72.6)"
+      );
+    if (options.workflowId !== void 0) {
+      const existing = this.useExisting(workflowKey, options);
+      if (existing !== void 0) {
+        for (const signal of options.signals ?? [])
+          this.deliverSignal(existing, signal.name, signal.payload);
+        if (options.update !== void 0)
+          this.addUpdate(this.run(existing), options.update, "PENDING");
+        await this.runUntilIdle(false);
+        return new TestRunHandle(this, existing);
+      }
+    }
+    const executionTimeoutMs = optionalDuration(
+      options.executionTimeout ?? declared.executionTimeout,
+      "executionTimeout"
+    );
+    const retry = options.retry ?? declared.retry;
+    const config = {
+      workflowKey,
+      runAttempt: 1,
+      ...options.workflowId !== void 0 ? { businessId: options.workflowId } : {},
+      ...executionTimeoutMs !== void 0 ? { executionTimeoutMs, executionDeadline: this.clock + executionTimeoutMs } : {},
+      ...this.durationConfig(options.runTimeout ?? declared.runTimeout, "runTimeoutMs"),
+      ...this.durationConfig(
+        options.workflowTaskTimeout ?? declared.workflowTaskTimeout,
+        "workflowTaskTimeoutMs"
+      ),
+      ...this.durationConfig(options.startDelay, "startDelayMs"),
+      ...retry !== void 0 ? { retry: runRetryPolicyOf(retry) } : {},
+      ...options.summary !== void 0 ? { summary: options.summary } : {},
+      ...options.details !== void 0 ? { details: options.details } : {},
+      ...options.memo !== void 0 ? { memo: toJsonValue(options.memo) } : {},
+      ...(options.versioningBehavior ?? declared.versioningBehavior) !== void 0 ? { versioningBehavior: options.versioningBehavior ?? declared.versioningBehavior } : {},
+      ...options.headers !== void 0 ? { headers: { ...options.headers } } : {},
+      ...options.searchAttributes !== void 0 ? { searchAttributes: toJsonValue(options.searchAttributes) } : {},
+      ...options.fairnessKey !== void 0 ? { fairnessKey: options.fairnessKey } : {},
+      ...options.fairnessWeight !== void 0 ? { fairnessWeight: options.fairnessWeight } : {}
+    };
     const runId = this.createRun(
       workflowFn,
       toJsonValue(options.input),
       { ...options.info, ...options.runId !== void 0 ? { runId: options.runId } : {} },
-      void 0
+      void 0,
+      {},
+      config,
+      options.update !== void 0 ? [this.newUpdate(options.update, "ADMITTED")] : []
     );
     for (const signal of options.signals ?? [])
       this.deliverSignal(runId, signal.name, signal.payload);
     await this.runUntilIdle(false);
     return new TestRunHandle(this, runId);
   }
+  /**
+   * Update-with-start (11 §2.6): start the run (or, with
+   * `idConflictPolicy: USE_EXISTING`, reach the open one) and deliver the
+   * update before any other task runs.
+   */
+  async startWithUpdate(definition, options) {
+    const updateId = options.update.updateId ?? this.nextUpdateId();
+    const handle = await this.start(definition, {
+      ...options,
+      update: { ...options.update, updateId }
+    });
+    return { handle, update: this.updateResultOf(handle.runId, updateId) };
+  }
+  nextUpdateId() {
+    this.updateCounter += 1;
+    return `u${this.updateCounter}`;
+  }
+  /** A new update row (not attached to a run yet). */
+  newUpdate(update, status) {
+    return {
+      updateId: update.updateId ?? this.nextUpdateId(),
+      name: update.name,
+      args: toJsonValue(update.args),
+      ...update.headers !== void 0 ? { headers: { ...update.headers } } : {},
+      status
+    };
+  }
+  /** Record an update on a run: pending (delivered by the next task) or admitted into history. */
+  addUpdate(run, update, status) {
+    const existing = update.updateId !== void 0 ? run.updates.get(update.updateId) : void 0;
+    if (existing) return existing;
+    const entry = this.newUpdate(update, status);
+    run.updates.set(entry.updateId, entry);
+    if (status === "ADMITTED")
+      this.append(run, { type: "UPDATE_ADMITTED", payload: admittedPayload(entry) });
+    else {
+      if (run.delayedUntil !== void 0) this.endDelay(run);
+      else this.scheduleTask(run);
+    }
+    return entry;
+  }
+  /** Schedule a workflow task for a run that has none (an update needs no input event). */
+  scheduleTask(run) {
+    if (run.state.status !== "RUNNING" || run.state.task.state !== "NONE") return;
+    if (run.delayedUntil !== void 0) return;
+    run.taskCounter += 1;
+    const taskId = `${run.runId}-task-${run.taskCounter}`;
+    const scheduled = {
+      seq: run.history.length + 1,
+      type: "WORKFLOW_TASK_SCHEDULED",
+      payload: { taskId },
+      createdAt: new Date(this.clock).toISOString()
+    };
+    applyEvent(run.state, scheduled);
+    run.history.push(scheduled);
+  }
+  /**
+   * Send an update to a run and run until idle (Phase C, 05 §6). The result
+   * is `REJECTED` (the validator refused it or no handler took it; nothing is
+   * written to history), `COMPLETED`, or `ACCEPTED` while its handler still
+   * waits (for a timer without time skipping, or with `waitFor: ACCEPTED`).
+   */
+  async update(runId, update, args, options = {}) {
+    const run = this.run(runId);
+    const name = typeof update === "string" ? update : update.name;
+    if (options.updateId !== void 0 && run.updates.has(options.updateId))
+      return this.updateResultOf(runId, options.updateId);
+    if (run.state.status !== "RUNNING")
+      throw new UpdateRefusedError(`Run ${runId} is ${run.state.status}; it takes no updates`);
+    const entry = this.addUpdate(
+      run,
+      {
+        name,
+        args,
+        ...options.updateId !== void 0 ? { updateId: options.updateId } : {},
+        ...options.headers !== void 0 ? { headers: options.headers } : {}
+      },
+      "PENDING"
+    );
+    await this.runUntilIdle(false);
+    return this.updateResultOf(runId, entry.updateId);
+  }
+  /** The current result of an update. */
+  updateResultOf(runId, updateId) {
+    const entry = this.run(runId).updates.get(updateId);
+    if (!entry) throw new Error(`Run ${runId} has no update ${updateId}`);
+    return {
+      updateId,
+      status: entry.status === "ADMITTED" ? "PENDING" : entry.status,
+      ...entry.result !== void 0 ? { result: entry.result } : {},
+      ...entry.failure !== void 0 ? { failure: entry.failure } : {}
+    };
+  }
+  /** Answer a query from the run's history (a replay-only `query` task). */
+  async query(runId, query, args) {
+    const run = this.run(runId);
+    const name = typeof query === "string" ? query : query.name;
+    const request = {
+      protocol: HISTORY_PROTOCOL,
+      kind: "query",
+      workflowFn: run.workflowFn,
+      info: run.info,
+      history: run.history,
+      nowMs: this.clock,
+      queries: [{ queryId: "q1", name, args: toJsonValue(args) }]
+    };
+    const result = await this.execute(request);
+    const answer = result.queryResults?.[0];
+    if (answer?.rejected === true)
+      throw new QueryRejectedError(runId, name, answer.error ?? `No handler for query ${name}`);
+    if (answer === void 0 || answer.error !== void 0)
+      throw new QueryFailedError(
+        runId,
+        name,
+        answer?.error ?? result.failure?.message ?? "The query was not answered"
+      );
+    return answer.value ?? null;
+  }
+  /** Sink calls the run's tasks made. */
+  sinkCallsOf(runId) {
+    return this.run(runId).sinkCalls.map((call) => ({ ...call, args: [...call.args] }));
+  }
+  /**
+   * Reset a run (11 §2.7): a new run whose history is the original's up to
+   * and including the chosen completed workflow task (with its commands),
+   * then `WORKFLOW_RESET`, then the signals (and, as `UPDATE_ADMITTED`, the
+   * accepted updates) received after that point. The original is terminated
+   * with reason `RESET`; children it started before the point follow the new
+   * run, the others get their parent-close policy. Returns the new run id.
+   */
+  async reset(runId, options = {}) {
+    const original = this.run(runId);
+    const history = original.history;
+    const points = [];
+    for (const event of history) {
+      if (event.type !== "WORKFLOW_TASK_COMPLETED") continue;
+      const taskId = typeof event.payload["taskId"] === "string" ? event.payload["taskId"] : "";
+      let end = event.seq;
+      let closes = false;
+      while (end < history.length) {
+        const next = history[end];
+        if (!next || !isCommandEvent(next) || next.taskId !== taskId) break;
+        if (TERMINAL_EVENTS.has(next.type)) closes = true;
+        end += 1;
+      }
+      if (!closes) points.push({ seq: event.seq, cut: end });
+    }
+    const point = options.toSeq !== void 0 ? [...points].reverse().find((entry) => entry.seq <= (options.toSeq ?? 0)) : options.to === "FIRST_TASK" ? points[0] : points[points.length - 1];
+    if (!point) throw new Error(`Run ${runId} has no completed workflow task to reset to`);
+    const cut = point.cut;
+    const copied = history.slice(0, cut).map((event) => ({ ...event, payload: { ...event.payload } }));
+    const later = history.slice(cut);
+    const reapplySignals = options.reapplySignals !== false;
+    const reapplyUpdates = options.reapplyUpdates !== false;
+    const keptChildren = new Set(
+      copied.filter((event) => event.type === "CHILD_RUN_INITIATED").map((event) => String(event.payload["childId"]))
+    );
+    this.runCounter += 1;
+    const newRunId = `run-${this.runCounter}`;
+    if (original.state.status === "RUNNING") {
+      original.resetTo = newRunId;
+      this.append(original, { type: "WORKFLOW_TERMINATED", payload: { reason: "RESET" } });
+      this.onClosed(original, keptChildren);
+    } else original.resetTo = newRunId;
+    const fork = {
+      runId: newRunId,
+      workflowFn: original.workflowFn,
+      history: copied,
+      state: projectRunState(copied),
+      taskCounter: copied.filter((event) => event.type === "WORKFLOW_TASK_SCHEDULED").length,
+      info: { ...original.info, runId: newRunId },
+      children: new Map([...original.children].filter(([childId]) => keptChildren.has(childId))),
+      config: { ...original.config },
+      ...original.parent ? { parent: original.parent } : {},
+      updates: /* @__PURE__ */ new Map(),
+      sinkCalls: []
+    };
+    this.runs.set(newRunId, fork);
+    this.runOrder.push(newRunId);
+    for (const [childId, childRunId] of fork.children) {
+      const child = childRunId !== void 0 ? this.runs.get(childRunId) : void 0;
+      if (child) child.parent = { runId: newRunId, childId };
+    }
+    this.append(fork, {
+      type: "WORKFLOW_RESET",
+      payload: {
+        fromRunId: runId,
+        toSeq: cut,
+        reapplySignals,
+        reapplyUpdates,
+        ...options.reason !== void 0 ? { reason: options.reason } : {}
+      }
+    });
+    for (const [activityId, activity] of Object.entries(fork.state.activities)) {
+      if (!isActivityOpen(activity)) continue;
+      const scheduled = copied[activity.scheduledSeq - 1];
+      if (scheduled?.type !== "ACTIVITY_SCHEDULED") continue;
+      this.afterCommand(fork, {
+        // The run-event schema checked the payload; it is the command that scheduled it.
+        ...scheduled.payload,
+        type: "SCHEDULE_ACTIVITY",
+        activityId
+      });
+    }
+    for (const [timerId, timer] of Object.entries(fork.state.timers))
+      if (timer.status === "PENDING")
+        this.timers.push({ runId: newRunId, timerId, fireAt: Date.parse(timer.fireAt) });
+    for (const event of later) {
+      if (event.type === "SIGNAL_RECEIVED" && reapplySignals)
+        this.append(fork, { type: "SIGNAL_RECEIVED", payload: { ...event.payload } });
+      if (reapplyUpdates && (event.type === "UPDATE_ACCEPTED" || event.type === "UPDATE_ADMITTED") && !fork.updates.has(String(event.payload["updateId"])) && fork.state.updates[String(event.payload["updateId"])] === void 0) {
+        const headers = event.payload["headers"];
+        this.addUpdate(
+          fork,
+          {
+            updateId: String(event.payload["updateId"]),
+            name: String(event.payload["name"]),
+            args: event.payload["args"] ?? null,
+            ...typeof headers === "object" && headers !== null && !Array.isArray(headers) ? (
+              // The run-event schema checked the headers map.
+              { headers }
+            ) : {}
+          },
+          "ADMITTED"
+        );
+      }
+    }
+    if (hasUnprocessedInput(fork.history)) this.scheduleTask(fork);
+    await this.runUntilIdle(false);
+    return newRunId;
+  }
+  durationConfig(value, key) {
+    const ms = optionalDuration(value, key);
+    if (ms === void 0) return {};
+    const out = {};
+    out[key] = ms;
+    return out;
+  }
+  /**
+   * 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}.
+   */
+  useExisting(workflowKey, options) {
+    const workflowId = options.workflowId ?? "";
+    const runs = this.runOrder.map((id) => this.run(id)).filter(
+      (run) => run.config.workflowKey === workflowKey && run.config.businessId === workflowId
+    );
+    const open = runs.find((run) => run.state.status === "RUNNING");
+    if (open) {
+      const conflict = options.idConflictPolicy ?? "FAIL";
+      if (conflict === "USE_EXISTING") return open.runId;
+      if (conflict === "FAIL")
+        throw new WorkflowAlreadyStartedError(workflowKey, workflowId, open.runId);
+      this.terminate(open.runId, "ID_CONFLICT");
+      return void 0;
+    }
+    const last = runs[runs.length - 1];
+    if (!last) return void 0;
+    const reuse = options.idReusePolicy ?? "ALLOW_DUPLICATE";
+    if (reuse === "REJECT_DUPLICATE" || reuse === "ALLOW_DUPLICATE_FAILED_ONLY" && !FAILED_STATUSES.has(last.state.status))
+      throw new WorkflowAlreadyStartedError(workflowKey, workflowId, last.runId);
+    return void 0;
+  }
   /** 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");
@@ -225,7 +698,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       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);
+    this.registry = registryOf(this.workflows, this.interceptors);
     return name;
   }
   run(runId) {
@@ -233,7 +706,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     if (!run) throw new Error(`Unknown run ${runId}`);
     return run;
   }
-  createRun(workflowFn, input, info, parent, extraStarted = {}) {
+  createRun(workflowFn, input, info, parent, extraStarted = {}, config = { workflowKey: workflowFn, runAttempt: 1 }, admitted = []) {
     this.runCounter += 1;
     const runId = info.runId ?? `run-${this.runCounter}`;
     const snapshot = {
@@ -254,19 +727,80 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       taskCounter: 0,
       info: snapshot,
       children: /* @__PURE__ */ new Map(),
-      ...parent ? { parent } : {}
+      config,
+      ...parent ? { parent } : {},
+      updates: /* @__PURE__ */ new Map(),
+      sinkCalls: []
     };
+    const firstTaskDelay = config.startDelayMs ?? config.firstTaskDelayMs;
+    if (firstTaskDelay !== void 0 && firstTaskDelay > 0) {
+      run.delayedUntil = this.clock + firstTaskDelay;
+      this.dues.push({ runId, kind: "start", at: run.delayedUntil });
+    }
+    if (config.runTimeoutMs !== void 0)
+      this.dues.push({ runId, kind: "runTimeout", at: this.clock + config.runTimeoutMs });
+    if (config.executionDeadline !== void 0)
+      this.dues.push({ runId, kind: "executionTimeout", at: config.executionDeadline });
     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 }
-    });
+    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: config.taskQueue ?? "managed",
+          randomnessSeed: runId,
+          ...extraStarted,
+          ...this.startedFields(config)
+        }
+      },
+      admitted.length === 0
+    );
+    if (admitted.length > 0) {
+      for (const update of admitted) {
+        run.updates.set(update.updateId, update);
+        this.append(run, { type: "UPDATE_ADMITTED", payload: admittedPayload(update) }, false);
+      }
+      this.scheduleTask(run);
+    }
     return runId;
   }
-  append(run, draft) {
+  /** The R2 fields of `WORKFLOW_STARTED`, each written only when it is set. */
+  startedFields(config) {
+    const out = {};
+    if (config.businessId !== void 0) {
+      out["businessId"] = config.businessId;
+      out["workflowId"] = config.businessId;
+    }
+    if (config.startDelayMs !== void 0) out["startDelayMs"] = config.startDelayMs;
+    if (config.retry !== void 0 || config.runAttempt > 1) out["runAttempt"] = config.runAttempt;
+    if (config.summary !== void 0) out["summary"] = config.summary;
+    if (config.details !== void 0) out["details"] = config.details;
+    if (config.memo !== void 0) out["context"] = config.memo;
+    const timeouts = {};
+    if (config.executionTimeoutMs !== void 0)
+      timeouts["executionTimeout"] = config.executionTimeoutMs;
+    if (config.runTimeoutMs !== void 0) timeouts["runTimeout"] = config.runTimeoutMs;
+    if (config.workflowTaskTimeoutMs !== void 0)
+      timeouts["workflowTaskTimeout"] = config.workflowTaskTimeoutMs;
+    if (Object.keys(timeouts).length > 0) out["timeouts"] = timeouts;
+    if (config.retry !== void 0) out["retry"] = toJsonValue(config.retry);
+    if (config.versioningBehavior !== void 0)
+      out["versioningBehavior"] = config.versioningBehavior;
+    if (config.lastCompletionResult !== void 0 && this.historyRelease >= 2)
+      out["lastCompletionResult"] = config.lastCompletionResult;
+    if (config.lastFailure !== void 0) out["lastFailure"] = toJsonValue(config.lastFailure);
+    if (config.headers !== void 0) out["headers"] = { ...config.headers };
+    if (config.searchAttributes !== void 0) out["searchAttributes"] = config.searchAttributes;
+    if (config.fairnessKey !== void 0) out["fairnessKey"] = config.fairnessKey;
+    if (config.fairnessWeight !== void 0) out["fairnessWeight"] = config.fairnessWeight;
+    return out;
+  }
+  append(run, draft, schedule = true) {
     const event = {
       seq: run.history.length + 1,
       type: draft.type,
@@ -276,7 +810,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     };
     applyEvent(run.state, event);
     run.history.push(event);
-    if (isInputEvent(event) && run.state.status === "RUNNING" && run.state.task.state === "NONE") {
+    if (run.delayedUntil !== void 0 && event.type === "SIGNAL_RECEIVED") this.endDelay(run);
+    if (schedule && run.delayedUntil === void 0 && isInputEvent(event) && run.state.status === "RUNNING" && run.state.task.state === "NONE") {
       run.taskCounter += 1;
       const taskId = `${run.runId}-task-${run.taskCounter}`;
       const scheduled = {
@@ -290,7 +825,13 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     }
     return event;
   }
-  deliverSignal(runId, name, payload) {
+  /** End a start delay: the first workflow task is scheduled now. */
+  endDelay(run) {
+    run.delayedUntil = void 0;
+    this.dues = this.dues.filter((due) => !(due.runId === run.runId && due.kind === "start"));
+    this.scheduleTask(run);
+  }
+  deliverSignal(runId, name, payload, headers) {
     const run = this.runs.get(runId);
     if (!run || run.state.status !== "RUNNING") return false;
     this.append(run, {
@@ -298,7 +839,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       payload: {
         name,
         payload: toJsonValue(payload),
-        receivedAt: new Date(this.clock).toISOString()
+        receivedAt: new Date(this.clock).toISOString(),
+        ...headers !== void 0 ? { headers: { ...headers } } : {}
       }
     });
     return true;
@@ -311,6 +853,11 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       type: "WORKFLOW_CANCEL_REQUESTED",
       payload: reason !== void 0 ? { reason } : {}
     });
+    if (run.delayedUntil !== void 0) {
+      run.delayedUntil = void 0;
+      this.append(run, { type: "WORKFLOW_CANCELLED", payload: {} });
+      this.onClosed(run);
+    }
     return true;
   }
   terminate(runId, reason) {
@@ -330,7 +877,9 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         await this.runTask(task);
         continue;
       }
-      const attempt = this.attempts.find((entry) => entry.dueAt <= this.clock);
+      const attempt = this.attempts.find(
+        (entry) => entry.dueAt <= this.clock && !this.isHeld(this.holdKeyOf(entry))
+      );
       if (attempt) {
         this.attempts = this.attempts.filter((entry) => entry !== attempt);
         await this.runAttempt(attempt);
@@ -349,16 +898,78 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     }
     throw new Error("The test environment did not settle after 100000 steps");
   }
+  /** When a held attempt's schedule-to-start timeout expires, if it has one. */
+  heldDeadline(entry) {
+    return this.isHeld(this.holdKeyOf(entry)) && entry.scheduleToStart !== void 0 ? entry.dueAt + entry.scheduleToStart : void 0;
+  }
   nextDue() {
-    const due = [
-      ...this.timers.map((timer) => timer.fireAt),
-      ...this.attempts.map((entry) => entry.dueAt)
-    ];
+    const due = [...this.timers.map((timer) => timer.fireAt)];
+    for (const entry of this.attempts) {
+      if (!this.isHeld(this.holdKeyOf(entry))) due.push(entry.dueAt);
+      const deadline = this.heldDeadline(entry);
+      if (deadline !== void 0) due.push(deadline);
+    }
+    for (const entry of this.dues) due.push(entry.at);
     return due.length === 0 ? void 0 : Math.min(...due);
   }
+  /** Expire held attempts whose schedule-to-start timeout passed (not retried, 11 §2.3). */
+  expireHeld() {
+    const expired = this.attempts.filter((entry) => {
+      const deadline = this.heldDeadline(entry);
+      return deadline !== void 0 && deadline <= this.clock;
+    });
+    if (expired.length === 0) return false;
+    this.attempts = this.attempts.filter((entry) => !expired.includes(entry));
+    for (const entry of expired) {
+      const run = this.runs.get(entry.runId);
+      const activity = run?.state.activities[entry.activityId];
+      if (!run || run.state.status !== "RUNNING" || !activity || !isActivityOpen(activity))
+        continue;
+      this.append(run, {
+        type: "ACTIVITY_TIMED_OUT",
+        payload: {
+          activityId: entry.activityId,
+          attempt: entry.attempt,
+          timeoutType: "SCHEDULE_TO_START"
+        }
+      });
+    }
+    return true;
+  }
+  /** Fire run-level deadlines: the end of a start delay, run and execution timeouts. */
+  fireRunDues() {
+    const due = this.dues.filter((entry) => entry.at <= this.clock).sort((a, b) => a.at - b.at);
+    if (due.length === 0) return false;
+    this.dues = this.dues.filter((entry) => !due.includes(entry));
+    for (const entry of due) {
+      const run = this.runs.get(entry.runId);
+      if (!run || run.state.status !== "RUNNING") continue;
+      if (entry.kind === "start") {
+        if (run.delayedUntil !== void 0) this.endDelay(run);
+        continue;
+      }
+      const timeoutType = entry.kind === "runTimeout" ? "WORKFLOW_RUN" : "WORKFLOW_EXECUTION";
+      const failure = {
+        errorType: "TIMEOUT",
+        message: timeoutType === "WORKFLOW_RUN" ? "The run timeout expired" : "The execution timeout of the chain expired",
+        type: "TimeoutFailure",
+        timeoutType,
+        source: "engine"
+      };
+      run.delayedUntil = void 0;
+      this.append(run, {
+        type: "WORKFLOW_TIMED_OUT",
+        payload: { timeoutType, failure: toJsonValue(failure) }
+      });
+      this.onClosed(run);
+    }
+    return true;
+  }
   fireDue() {
+    const expired = this.expireHeld();
+    const fired = this.fireRunDues();
     const due = this.timers.filter((timer) => timer.fireAt <= this.clock).sort((a, b) => a.fireAt - b.fireAt);
-    if (due.length === 0) return false;
+    if (due.length === 0) return expired || fired;
     this.timers = this.timers.filter((timer) => !due.includes(timer));
     for (const timer of due) {
       const run = this.runs.get(timer.runId);
@@ -371,15 +982,27 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   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 delivered = [...run.updates.values()].filter(
+      (update) => update.status === "PENDING" || update.status === "ADMITTED"
+    );
+    const updates = delivered.map((update) => ({
+      updateId: update.updateId,
+      name: update.name,
+      args: update.args,
+      ...update.headers !== void 0 ? { headers: { ...update.headers } } : {},
+      ...update.status === "ADMITTED" ? { admitted: true } : {}
+    }));
     const request = {
       protocol: HISTORY_PROTOCOL,
       kind: "task",
       workflowFn: run.workflowFn,
       info: run.info,
       history: run.history,
-      nowMs: this.clock
+      nowMs: this.clock,
+      ...updates.length > 0 ? { updates } : {},
+      ...this.codeFeatures.length > 0 ? { features: [...this.codeFeatures] } : {}
     };
-    const result = this.executor ? await this.executor(request) : await runWorkflowTaskInProcess(this.registry, request);
+    const result = await this.executeWithLocalActivities(run, request);
     const fail = (cause, message) => {
       this.append(run, {
         type: "WORKFLOW_TASK_FAILED",
@@ -392,7 +1015,11 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       run.taskFailure = result;
       return;
     }
-    const checked = validateCommands(result.commands, { enabled: this.enabled });
+    const relief = {
+      grantedLocalActivityIds: [],
+      deliveredUpdateIds: delivered.map((update) => update.updateId)
+    };
+    const checked = validateCommands(result.commands, { enabled: this.enabled, relief });
     if (!checked.ok) {
       fail(checked.cause, checked.issues.map((issue) => issue.message).join("; "));
       return;
@@ -400,21 +1027,133 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     const drafts = eventsForCommands(run.state, checked.commands, {
       taskId,
       nowMs: this.clock,
-      enabled: this.enabled
+      enabled: this.enabled,
+      relief,
+      updates: Object.fromEntries(
+        delivered.map((update) => [
+          update.updateId,
+          {
+            name: update.name,
+            args: update.args,
+            ...update.headers !== void 0 ? { headers: update.headers } : {}
+          }
+        ])
+      )
     });
     if (!drafts.ok) {
       fail(drafts.cause, drafts.issues.map((issue) => issue.message).join("; "));
       return;
     }
+    if (result.unfinishedHandlers !== void 0 && result.unfinishedHandlers.length > 0)
+      run.unfinishedHandlers = result.unfinishedHandlers;
+    this.recordUpdateReplies(run, checked.commands, delivered);
+    this.runSinks(run, result.sinkCalls ?? []);
     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);
   }
+  /** What a task's update replies mean for the run's update rows. */
+  recordUpdateReplies(run, commands, delivered) {
+    const answered = /* @__PURE__ */ new Set();
+    for (const command of commands) {
+      if (command.type !== "ACCEPT_UPDATE" && command.type !== "REJECT_UPDATE" && command.type !== "COMPLETE_UPDATE")
+        continue;
+      const entry = run.updates.get(command.updateId);
+      if (!entry) continue;
+      answered.add(command.updateId);
+      if (command.type === "ACCEPT_UPDATE") entry.status = "ACCEPTED";
+      else if (command.type === "REJECT_UPDATE") {
+        entry.status = "REJECTED";
+        entry.failure = command.failure;
+      } else {
+        entry.status = "COMPLETED";
+        if (command.failure !== void 0) entry.failure = command.failure;
+        else entry.result = command.result ?? null;
+      }
+    }
+    for (const update of delivered)
+      if (!answered.has(update.updateId) && update.status === "PENDING") {
+        update.status = "REJECTED";
+        update.failure = {
+          errorType: "VALIDATION",
+          type: "UpdateNotHandled",
+          message: `The workflow task did not answer update "${update.name}"`
+        };
+      }
+  }
+  /** Keep a task's sink calls and call the configured sinks with them. */
+  runSinks(run, calls) {
+    for (const call of calls) {
+      run.sinkCalls.push(call);
+      const fn = this.sinks[call.sink]?.[call.fn];
+      if (fn === void 0) continue;
+      try {
+        fn(...call.args);
+      } catch {
+      }
+    }
+  }
+  execute(request) {
+    return this.executor ? this.executor(request) : runWorkflowTaskInProcess(this.registry, request);
+  }
+  /**
+   * 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.
+   */
+  async executeWithLocalActivities(run, request) {
+    const outcomes = /* @__PURE__ */ new Map();
+    let result = await this.execute(request);
+    for (let round = 0; result.outcome === "localActivityRequested"; round++) {
+      if (round >= 1e3)
+        return {
+          ...result,
+          outcome: "failed",
+          commands: [],
+          failure: { cause: "INTERNAL", message: "The task asked for local activities 1000 times" }
+        };
+      for (const wanted of result.localActivityRequests ?? [])
+        outcomes.set(wanted.localActivityId, await this.runLocalActivity(run, wanted));
+      result = await this.execute({ ...request, localActivityResults: [...outcomes.values()] });
+    }
+    return result;
+  }
+  async runLocalActivity(run, wanted) {
+    const mock = this.mocks.get(`${wanted.nodeType}#${wanted.operation}`) ?? this.mocks.get(wanted.nodeType);
+    try {
+      if (!mock)
+        throw new ApplicationError(
+          `No mock for ${wanted.nodeType} ${wanted.operation} (use env.mock)`,
+          { errorType: "VALIDATION", nonRetryable: true, type: "UnmockedActivity" }
+        );
+      const result = toJsonValue(
+        await mock(wanted.args, {
+          runId: run.runId,
+          activityId: wanted.localActivityId,
+          attempt: wanted.attempt,
+          nodeType: wanted.nodeType,
+          operation: wanted.operation,
+          local: true,
+          ...wanted.connection !== void 0 ? { connection: wanted.connection } : {}
+        })
+      );
+      return { localActivityId: wanted.localActivityId, result, attempts: wanted.attempt };
+    } catch (error) {
+      const failure = errorToFailure(error, `node:${wanted.nodeType}`);
+      delete failure.stackTrace;
+      return {
+        localActivityId: wanted.localActivityId,
+        failure: toJsonValue(failure),
+        attempts: wanted.attempt
+      };
+    }
+  }
   afterCommand(run, command) {
     switch (command.type) {
       case "SCHEDULE_ACTIVITY": {
+        const user = command.kind === "user";
         const attempt = {
           runId: run.runId,
           activityId: command.activityId,
@@ -422,12 +1161,16 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
           dueAt: this.clock,
           scheduledAt: this.clock,
           args: command.args,
-          nodeType: command.nodeType,
-          operation: command.operation,
+          kind: command.kind,
+          nodeType: user ? "" : command.nodeType,
+          operation: user ? command.activityName : command.operation,
           retry: command.retry,
           cancelRequested: false,
-          ...command.connection !== void 0 ? { connection: command.connection } : {},
-          ...command.scheduleToCloseTimeout !== void 0 ? { scheduleToClose: command.scheduleToCloseTimeout } : {}
+          ...!user && command.connection !== void 0 ? { connection: command.connection } : {},
+          ...user ? { taskQueue: command.taskQueue } : {},
+          ...command.headers !== void 0 ? { headers: { ...command.headers } } : {},
+          ...command.scheduleToCloseTimeout !== void 0 ? { scheduleToClose: command.scheduleToCloseTimeout } : {},
+          ...command.scheduleToStartTimeout !== void 0 ? { scheduleToStart: command.scheduleToStartTimeout } : {}
         };
         this.attempts.push(attempt);
         return;
@@ -502,18 +1245,25 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         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;
+        const options = command.options;
+        const config = {
+          ...this.chainConfig(run.config),
+          // The run timeout restarts and the attempt count resets; the
+          // execution timeout of the chain carries over (11 §2.20).
+          lastCompletionResult: command.input
+        };
+        if (typeof options["taskQueue"] === "string") config.taskQueue = options["taskQueue"];
+        if (typeof options["workflowTaskTimeout"] === "number")
+          config.workflowTaskTimeoutMs = options["workflowTaskTimeout"];
+        if (options["versioningBehavior"] === "PINNED" || options["versioningBehavior"] === "AUTO_UPGRADE")
+          config.versioningBehavior = options["versioningBehavior"];
+        const memo = options["context"];
+        if (typeof memo === "object" && memo !== null && !Array.isArray(memo)) config.memo = memo;
+        else if (Object.keys(run.state.context).length > 0) config.memo = { ...run.state.context };
+        const retry = options["retry"];
+        if (continueAsNewRetryShape(options) === "run" && typeof retry === "object" && retry !== null && !Array.isArray(retry))
+          config.retry = retry;
+        this.startSuccessor(run, command.input, config);
         this.onClosed(run);
         return;
       }
@@ -526,11 +1276,62 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         return;
     }
   }
+  /** What a successor of a run inherits (continue-as-new, run retry). */
+  chainConfig(config) {
+    const out = { workflowKey: config.workflowKey, runAttempt: 1 };
+    for (const key of [
+      "businessId",
+      "executionDeadline",
+      "executionTimeoutMs",
+      "runTimeoutMs",
+      "workflowTaskTimeoutMs",
+      "retry",
+      "versioningBehavior",
+      "taskQueue",
+      "memo"
+    ])
+      if (config[key] !== void 0) Object.assign(out, { [key]: config[key] });
+    return out;
+  }
+  /** Start the next run of a chain; the closed run's parent and handles follow it. */
+  startSuccessor(run, input, config) {
+    const next = this.createRun(
+      run.workflowFn,
+      input,
+      {
+        ...run.info,
+        runId: void 0,
+        continuedFromRunId: run.runId,
+        firstRunId: run.info.firstRunId ?? run.runId
+      },
+      run.parent,
+      {},
+      config
+    );
+    run.continuedTo = next;
+    return next;
+  }
   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;
+    if ("childId" in target) {
+      let childRunId = run.children.get(target.childId);
+      while (childRunId !== void 0) {
+        const next = this.runs.get(childRunId)?.continuedTo;
+        if (next === void 0) break;
+        childRunId = next;
+      }
+      return childRunId;
+    }
+    return this.resolveWorkflowId(target.workflowKey, target.workflowId, target.firstRunId);
+  }
+  /** The open run of a workflow id, else its latest run (11 §2.1). */
+  resolveWorkflowId(workflowKey, workflowId, firstRunId) {
+    const matching = this.runOrder.map((id) => this.run(id)).filter(
+      (candidate) => candidate.config.workflowKey === workflowKey && candidate.config.businessId === workflowId && (firstRunId === void 0 || (candidate.info.firstRunId ?? candidate.runId) === firstRunId)
+    );
+    const open = matching.find((candidate) => candidate.state.status === "RUNNING");
+    return (open ?? matching[matching.length - 1])?.runId;
   }
   startChild(run, command) {
     const byFn = command.workflowFn !== void 0 && (this.executor !== void 0 || this.registry.byName.has(command.workflowFn));
@@ -563,6 +1364,28 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       });
       return;
     }
+    const options = command.options;
+    const ms = (key) => typeof options[key] === "number" ? options[key] : void 0;
+    const executionTimeoutMs = ms("executionTimeout");
+    const childKey = command.workflowKey ?? this.registry.byName.get(workflowFn)?.name ?? workflowFn;
+    const config = { workflowKey: childKey, runAttempt: 1 };
+    if (typeof options.workflowId === "string") config.businessId = options.workflowId;
+    if (executionTimeoutMs !== void 0) {
+      config.executionTimeoutMs = executionTimeoutMs;
+      config.executionDeadline = this.clock + executionTimeoutMs;
+    }
+    const runTimeoutMs = ms("runTimeout");
+    if (runTimeoutMs !== void 0) config.runTimeoutMs = runTimeoutMs;
+    const taskTimeoutMs = ms("workflowTaskTimeout");
+    if (taskTimeoutMs !== void 0) config.workflowTaskTimeoutMs = taskTimeoutMs;
+    const startDelayMs = ms("startDelay");
+    if (startDelayMs !== void 0) config.startDelayMs = startDelayMs;
+    if (typeof options.summary === "string") config.summary = options.summary;
+    if (typeof options.details === "string") config.details = options.details;
+    if (options.context !== void 0) config.memo = options.context;
+    if (options.versioningBehavior !== void 0)
+      config.versioningBehavior = options.versioningBehavior;
+    if (options.retry !== void 0) config.retry = options.retry;
     const childRunId = this.createRun(
       workflowFn,
       command.input,
@@ -571,7 +1394,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       {
         parentRunId: run.runId,
         parentClosePolicy: command.options.parentClosePolicy
-      }
+      },
+      config
     );
     run.children.set(command.childId, childRunId);
     this.append(run, {
@@ -625,35 +1449,151 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       });
       return;
     }
-    const mock = this.mocks.get(`${attempt.nodeType}#${attempt.operation}`) ?? this.mocks.get(attempt.nodeType);
     let failure;
     let result = null;
+    let heartbeatDetails = attempt.heartbeatDetails;
+    let asyncToken;
     try {
-      if (!mock)
-        throw new ApplicationError(
-          `No mock for ${attempt.nodeType} ${attempt.operation} (use env.mock)`,
-          {
-            errorType: "VALIDATION",
-            nonRetryable: true,
-            type: "UnmockedActivity"
+      if (attempt.kind === "user") {
+        const impl = findActivityImplementation(this.activityImpls, attempt.operation);
+        if (!impl)
+          throw new ApplicationError(
+            `No implementation of activity ${attempt.operation} (use env.registerActivity or env.mockActivity)`,
+            { errorType: "VALIDATION", nonRetryable: true, type: "ActivityNotRegistered" }
+          );
+        const ctx = this.activityContext(
+          attempt,
+          (details) => {
+            heartbeatDetails = details;
+          },
+          (token) => {
+            asyncToken = token;
           }
         );
-      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 } : {}
-        })
-      );
+        result = toJsonValue(
+          await executeActivity(impl, ctx, attempt.args, this.activityInterceptors)
+        );
+      } else {
+        const mock = this.mocks.get(`${attempt.nodeType}#${attempt.operation}`) ?? this.mocks.get(attempt.nodeType);
+        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 } : {},
+            ...attempt.heartbeatDetails !== void 0 ? { heartbeatDetails: attempt.heartbeatDetails } : {},
+            heartbeat: (details) => {
+              heartbeatDetails = toJsonValue(details);
+            }
+          })
+        );
+      }
     } catch (error) {
-      failure = errorToFailure(error, `node:${attempt.nodeType}`);
+      failure = errorToFailure(
+        error,
+        attempt.kind === "user" ? "sdk-ts" : `node:${attempt.nodeType}`
+      );
       delete failure.stackTrace;
     }
     if (run.state.status !== "RUNNING" || !isActivityOpen(run.state.activities[attempt.activityId] ?? activity))
       return;
+    if (asyncToken !== void 0 && failure === void 0) {
+      this.asyncAttempts.set(asyncToken, {
+        ...attempt,
+        ...heartbeatDetails !== void 0 ? { heartbeatDetails } : {}
+      });
+      return;
+    }
+    this.finishAttempt(run, attempt, failure, result, heartbeatDetails);
+  }
+  /** The `ActivityContext` of one user-activity attempt. */
+  activityContext(attempt, onHeartbeat, onAsync) {
+    const run = this.runs.get(attempt.runId);
+    const listeners = /* @__PURE__ */ new Set();
+    const signal = {
+      get aborted() {
+        return attempt.cancelRequested;
+      },
+      addEventListener: (_type, listener) => {
+        listeners.add(listener);
+      },
+      removeEventListener: (_type, listener) => {
+        listeners.delete(listener);
+      }
+    };
+    return {
+      info: {
+        runId: attempt.runId,
+        workspaceId: this.workspaceId,
+        ...run?.config.workflowKey !== void 0 ? { workflowKey: run.config.workflowKey } : {},
+        activityId: attempt.activityId,
+        activityName: attempt.operation,
+        taskQueue: attempt.taskQueue ?? "managed",
+        attempt: attempt.attempt,
+        ...attempt.heartbeatDetails !== void 0 ? { heartbeatDetails: attempt.heartbeatDetails } : {},
+        headers: { ...attempt.headers ?? {} }
+      },
+      heartbeat: (details) => {
+        onHeartbeat(toJsonValue(details));
+        return Promise.resolve({ cancelRequested: attempt.cancelRequested, paused: false });
+      },
+      cancellationSignal: signal,
+      completeAsync: () => {
+        const token = `test-task-token:${attempt.runId}:${attempt.activityId}:${attempt.attempt}`;
+        onAsync(token);
+        return Promise.resolve(token);
+      },
+      connection: (name) => {
+        const found = this.connections[name];
+        if (found === void 0)
+          return Promise.reject(
+            new ApplicationError(`No connection "${name}" in the test environment`, {
+              errorType: "AUTHORIZATION",
+              nonRetryable: true,
+              type: "ConnectionNotReleased"
+            })
+          );
+        return Promise.resolve({ ...found });
+      }
+    };
+  }
+  /** Complete an activity that called `completeAsync()` (`completeActivityAsync`). */
+  async completeActivityAsync(token, result) {
+    const attempt = this.takeAsync(token);
+    const run = this.run(attempt.runId);
+    this.finishAttempt(run, attempt, void 0, toJsonValue(result), attempt.heartbeatDetails);
+    await this.runUntilIdle(false);
+  }
+  /** Fail an activity that called `completeAsync()` (`failActivityAsync`); the retry policy applies. */
+  async failActivityAsync(token, error) {
+    const attempt = this.takeAsync(token);
+    const run = this.run(attempt.runId);
+    const failure = errorToFailure(error, "sdk-ts");
+    delete failure.stackTrace;
+    this.finishAttempt(run, attempt, failure, null, attempt.heartbeatDetails);
+    await this.runUntilIdle(false);
+  }
+  takeAsync(token) {
+    const attempt = this.asyncAttempts.get(token);
+    if (!attempt) throw new Error(`Unknown or used activity task token ${token}`);
+    this.asyncAttempts.delete(token);
+    return attempt;
+  }
+  /** Record an attempt's outcome: completion, a final failure or timeout, or the next attempt. */
+  finishAttempt(run, attempt, failure, result, heartbeatDetails) {
+    const open = run.state.activities[attempt.activityId];
+    if (run.state.status !== "RUNNING" || !open || !isActivityOpen(open)) return;
     const started = () => {
       this.append(run, {
         type: "ACTIVITY_STARTED",
@@ -686,7 +1626,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       this.attempts.push({
         ...attempt,
         attempt: attempt.attempt + 1,
-        dueAt: this.clock + decision2.delayMs
+        dueAt: this.clock + decision2.delayMs,
+        ...heartbeatDetails !== void 0 ? { heartbeatDetails } : {}
       });
       return;
     }
@@ -695,7 +1636,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       this.attempts.push({
         ...attempt,
         attempt: attempt.attempt + 1,
-        dueAt: this.clock + decision.delayMs
+        dueAt: this.clock + decision.delayMs,
+        ...heartbeatDetails !== void 0 ? { heartbeatDetails } : {}
       });
       return;
     }
@@ -709,16 +1651,57 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       }
     });
   }
-  onClosed(run) {
+  /**
+   * 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`.
+   */
+  retryRun(run) {
+    if (run.continuedTo !== void 0) return;
+    const last = run.history[run.history.length - 1];
+    if (!last || last.type !== "WORKFLOW_FAILED" && last.type !== "WORKFLOW_TIMED_OUT") return;
+    const failure = last.payload["failure"] ?? { errorType: "TIMEOUT", message: "timed out", timeoutType: "WORKFLOW_RUN" };
+    const decision = computeRunRetryDelay(run.config.retry, run.config.runAttempt, failure);
+    if (!decision.retry) return;
+    const config = {
+      ...this.chainConfig(run.config),
+      runAttempt: run.config.runAttempt + 1,
+      lastFailure: failure
+    };
+    if (decision.delayMs > 0) config.firstTaskDelayMs = decision.delayMs;
+    this.startSuccessor(run, run.state.input ?? null, config);
+  }
+  /**
+   * A run closed: drop its pending work, retry it, apply the parent-close
+   * policy to its children (except `keptChildren`, which follow a reset
+   * fork), settle its open updates and notify its parent.
+   */
+  onClosed(run, keptChildren = /* @__PURE__ */ new Set()) {
     this.timers = this.timers.filter((timer) => timer.runId !== run.runId);
     this.attempts = this.attempts.filter((entry) => entry.runId !== run.runId);
+    this.dues = this.dues.filter((entry) => entry.runId !== run.runId);
+    for (const [token, entry] of this.asyncAttempts)
+      if (entry.runId === run.runId) this.asyncAttempts.delete(token);
+    this.retryRun(run);
     for (const [childId2, childRunId] of run.children) {
+      if (keptChildren.has(childId2)) continue;
       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");
     }
+    for (const update of run.updates.values()) {
+      if (update.status !== "PENDING" && update.status !== "ACCEPTED" && update.status !== "ADMITTED")
+        continue;
+      const accepted = update.status === "ACCEPTED";
+      update.status = accepted ? "COMPLETED" : "REJECTED";
+      update.failure = {
+        errorType: accepted ? "PERMANENT" : "VALIDATION",
+        type: "RunClosed",
+        message: `The run closed before update "${update.name}" ${accepted ? "completed" : "was accepted"}`
+      };
+    }
     if (!run.parent) return;
     const parent = this.runs.get(run.parent.runId);
     if (!parent || parent.state.status !== "RUNNING") return;
@@ -726,6 +1709,10 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     if (!parent.state.children[childId] || !isChildOpen(parent.state.children[childId])) return;
     const last = run.history[run.history.length - 1];
     if (!last) return;
+    if (run.resetTo !== void 0) {
+      parent.children.set(childId, run.resetTo);
+      return;
+    }
     if (run.continuedTo !== void 0) {
       const next = this.runs.get(run.continuedTo);
       if (next) {
@@ -766,19 +1753,34 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       default:
         this.append(parent, {
           type: "CHILD_RUN_TIMED_OUT",
-          payload: { ...base, timeoutType: "WORKFLOW_RUN" }
+          payload: {
+            ...base,
+            timeoutType: last.payload["timeoutType"] === "WORKFLOW_EXECUTION" ? "WORKFLOW_EXECUTION" : "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);
+    while (run.continuedTo !== void 0 || run.resetTo !== void 0)
+      run = this.run(run.continuedTo ?? run.resetTo ?? run.runId);
     if (run.taskFailure) throw new WorkflowTaskFailedError(run.runId, run.taskFailure);
+    if (this.failOnUnfinishedHandlers && run.unfinishedHandlers !== void 0)
+      throw new UnfinishedHandlersError(run.runId, run.unfinishedHandlers);
     const last = run.history[run.history.length - 1];
     switch (run.state.status) {
       case "COMPLETED":
         return run.state.output ?? null;
+      case "TIMED_OUT":
+        throw new WorkflowFailedError(
+          run.runId,
+          last?.payload["failure"] ?? {
+            errorType: "TIMEOUT",
+            message: "timed out",
+            type: "TimeoutFailure"
+          }
+        );
       case "FAILED":
         throw new WorkflowFailedError(
           run.runId,
@@ -1034,4 +2036,4 @@ async function runWorkflowTaskInVm(script, request, options = {}) {
   }
 }
 
-export { HistoryAssertionError, ReplayError, RunBlockedError, TestRunHandle, TestWorkflowEnvironment, WorkflowFailedError, WorkflowTaskFailedError, assertHistory, bundleToScript, drainJobs, expectIR, jsonCopy, registryOf, replay, replayRequest, runWorkflowTaskInProcess, runWorkflowTaskInVm, simulate };
+export { HistoryAssertionError, QueryFailedError, QueryRejectedError, ReplayError, RunBlockedError, TestRunHandle, TestWorkflowEnvironment, UnfinishedHandlersError, UpdateRefusedError, WorkflowAlreadyStartedError, WorkflowFailedError, WorkflowTaskFailedError, assertHistory, bundleToScript, drainJobs, expectIR, jsonCopy, registryOf, replay, replayRequest, runWorkflowTaskInProcess, runWorkflowTaskInVm, simulate };