@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/testing/index.cjs

@@ -1,23 +1,24 @@
 'use strict';
 
-var chunkEWYADREB_cjs = require('../chunk-EWYADREB.cjs');
-var chunkNXFBVDOI_cjs = require('../chunk-NXFBVDOI.cjs');
-var chunkGBQ33SIZ_cjs = require('../chunk-GBQ33SIZ.cjs');
+var chunk672KMMBK_cjs = require('../chunk-672KMMBK.cjs');
+var chunkIQPXHQQQ_cjs = require('../chunk-IQPXHQQQ.cjs');
+var chunk54FLQNUM_cjs = require('../chunk-54FLQNUM.cjs');
 require('../chunk-G4UEPUGO.cjs');
 require('../chunk-GVTZMA5C.cjs');
 require('../chunk-QKZL3ONM.cjs');
 require('../chunk-TBDXTV22.cjs');
-var chunkI47EENR4_cjs = require('../chunk-I47EENR4.cjs');
+var chunkHMZUGSMU_cjs = require('../chunk-HMZUGSMU.cjs');
+require('../chunk-JSC75O5C.cjs');
 var chunkSAENRNBJ_cjs = require('../chunk-SAENRNBJ.cjs');
-var chunkOMY3CKUZ_cjs = require('../chunk-OMY3CKUZ.cjs');
-var chunkELL2RBML_cjs = require('../chunk-ELL2RBML.cjs');
+var chunkGEQDGUGB_cjs = require('../chunk-GEQDGUGB.cjs');
+var chunkZCGKGDCL_cjs = require('../chunk-ZCGKGDCL.cjs');
 require('../chunk-Q4MWQNJK.cjs');
 var chunkL24YIZY7_cjs = require('../chunk-L24YIZY7.cjs');
-var chunkJ3PYFGKA_cjs = require('../chunk-J3PYFGKA.cjs');
+var chunkVA4OFR72_cjs = require('../chunk-VA4OFR72.cjs');
 require('../chunk-FR7KYWRO.cjs');
-var chunkRUQIMTN5_cjs = require('../chunk-RUQIMTN5.cjs');
-var chunk3FIDHONL_cjs = require('../chunk-3FIDHONL.cjs');
-var chunkYHBVMOMK_cjs = require('../chunk-YHBVMOMK.cjs');
+var chunkISOIA7NV_cjs = require('../chunk-ISOIA7NV.cjs');
+require('../chunk-A5SXCA62.cjs');
+var chunkTYF56RGB_cjs = require('../chunk-TYF56RGB.cjs');
 require('../chunk-Z2Y65YOY.cjs');
 var vm = require('vm');
 
@@ -25,8 +26,10 @@ var vm = require('vm');
 function drainJobs() {
   return new Promise((resolve) => setImmediate(resolve));
 }
-function registryOf(workflows) {
-  return chunkOMY3CKUZ_cjs.buildWorkflowRegistry([["in-process", { ...workflows }]]);
+function registryOf(workflows, interceptors) {
+  return chunkGEQDGUGB_cjs.buildWorkflowRegistry([
+    ["in-process", { ...workflows, ...interceptors !== void 0 ? { interceptors } : {} }]
+  ]);
 }
 async function hostLoop(abi, requestJson) {
   abi.start(requestJson);
@@ -36,12 +39,38 @@ async function hostLoop(abi, requestJson) {
   return abi.complete();
 }
 async function runWorkflowTaskInProcess(registry, request) {
-  const abi = chunkOMY3CKUZ_cjs.createWorkflowRuntime(registry);
+  const abi = chunkGEQDGUGB_cjs.createWorkflowRuntime(registry);
   const json = await hostLoop(abi, JSON.stringify(request));
   return JSON.parse(json);
 }
 
 // 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(
@@ -74,7 +103,7 @@ var WorkflowFailedError = class extends Error {
     this.runId = runId;
     this.failure = failure;
     this.name = "WorkflowFailedError";
-    Object.defineProperty(this, "cause", { value: chunkELL2RBML_cjs.failureToError(failure), enumerable: false });
+    Object.defineProperty(this, "cause", { value: chunkZCGKGDCL_cjs.failureToError(failure), enumerable: false });
   }
   runId;
   failure;
@@ -99,7 +128,7 @@ var RunBlockedError = class extends Error {
   }
   runId;
 };
-var TestRunHandle = class {
+var TestRunHandle = class _TestRunHandle {
   constructor(env, runId) {
     this.env = env;
     this.runId = runId;
@@ -116,7 +145,7 @@ var TestRunHandle = class {
   }
   /** Deliver a signal and run until idle (without skipping time). */
   async signal(signal, payload) {
-    this.env.deliverSignal(this.runId, chunkELL2RBML_cjs.signalName(signal), payload);
+    this.env.deliverSignal(this.runId, chunkZCGKGDCL_cjs.signalName(signal), payload);
     await this.env.runUntilIdle(false);
   }
   /** Request cancellation and run until idle (without skipping time). */
@@ -129,6 +158,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);
@@ -144,7 +189,7 @@ function toDate(value) {
   return typeof value === "number" ? value : Date.parse(value);
 }
 function optionalDuration(value, what) {
-  return value === void 0 ? void 0 : chunkJ3PYFGKA_cjs.toMs(value, what);
+  return value === void 0 ? void 0 : chunkVA4OFR72_cjs.toMs(value, what);
 }
 var FAILED_STATUSES = /* @__PURE__ */ new Set([
   "FAILED",
@@ -152,6 +197,14 @@ var FAILED_STATUSES = /* @__PURE__ */ new Set([
   "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);
@@ -161,6 +214,8 @@ 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 = [];
@@ -176,19 +231,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(chunkISOIA7NV_cjs.COMMAND_FEATURES);
+    this.codeFeatures = chunkISOIA7NV_cjs.codeFeaturesEnabledBy(this.enabled);
     this.failOnUnfinishedHandlers = options.failOnUnfinishedHandlers !== false;
-    this.historyRelease = options.historyRelease ?? chunk3FIDHONL_cjs.RUNTIME_RELEASE;
+    this.historyRelease = options.historyRelease ?? chunkTYF56RGB_cjs.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 (!chunkVA4OFR72_cjs.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 (!chunkVA4OFR72_cjs.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" && !chunkVA4OFR72_cjs.isActivityDefinition(activity))
+      throw new TypeError("mockActivity needs an activity name or a declareActivity() value");
+    this.registerActivity(
+      Object.freeze({
+        __fluidgrids: chunkVA4OFR72_cjs.ACTIVITY_MARKER,
+        name,
+        options: typeof activity === "string" ? {} : activity.options,
+        implementation: chunkVA4OFR72_cjs.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 = {}) {
@@ -220,6 +321,10 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     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);
   }
@@ -235,11 +340,17 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     );
     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);
       }
@@ -260,11 +371,15 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         "workflowTaskTimeoutMs"
       ),
       ...this.durationConfig(options.startDelay, "startDelayMs"),
-      ...retry !== void 0 ? { retry: chunkJ3PYFGKA_cjs.runRetryPolicyOf(retry) } : {},
+      ...retry !== void 0 ? { retry: chunkVA4OFR72_cjs.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.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,
@@ -272,13 +387,245 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       { ...options.info, ...options.runId !== void 0 ? { runId: options.runId } : {} },
       void 0,
       {},
-      config
+      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()
+    };
+    chunkISOIA7NV_cjs.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: chunkTYF56RGB_cjs.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 || !chunkTYF56RGB_cjs.isCommandEvent(next) || next.taskId !== taskId) break;
+        if (chunkTYF56RGB_cjs.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: chunkISOIA7NV_cjs.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 (!chunkISOIA7NV_cjs.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 (chunkISOIA7NV_cjs.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 {};
@@ -314,7 +661,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   }
   /** Advance the clock by `duration`, firing timers and running work as it comes due. */
   async sleep(duration) {
-    const until = this.clock + chunkJ3PYFGKA_cjs.toMs(duration, "sleep duration");
+    const until = this.clock + chunkVA4OFR72_cjs.toMs(duration, "sleep duration");
     await this.runUntilIdle(false);
     for (; ; ) {
       const next = this.nextDue();
@@ -336,7 +683,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   }
   historyFileOf(runId, extra = {}) {
     const run = this.run(runId);
-    return chunkI47EENR4_cjs.createHistoryFile(run.workflowFn, this.historyOf(runId), {
+    return chunkHMZUGSMU_cjs.createHistoryFile(run.workflowFn, this.historyOf(runId), {
       info: { ...run.info },
       ...extra
     });
@@ -354,7 +701,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) {
@@ -362,7 +709,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     if (!run) throw new Error(`Unknown run ${runId}`);
     return run;
   }
-  createRun(workflowFn, input, info, parent, extraStarted = {}, config = { workflowKey: workflowFn, runAttempt: 1 }) {
+  createRun(workflowFn, input, info, parent, extraStarted = {}, config = { workflowKey: workflowFn, runAttempt: 1 }, admitted = []) {
     this.runCounter += 1;
     const runId = info.runId ?? `run-${this.runCounter}`;
     const snapshot = {
@@ -379,12 +726,14 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       runId,
       workflowFn,
       history: [],
-      state: chunkRUQIMTN5_cjs.initialRunState(),
+      state: chunkISOIA7NV_cjs.initialRunState(),
       taskCounter: 0,
       info: snapshot,
       children: /* @__PURE__ */ new Map(),
       config,
-      ...parent ? { parent } : {}
+      ...parent ? { parent } : {},
+      updates: /* @__PURE__ */ new Map(),
+      sinkCalls: []
     };
     const firstTaskDelay = config.startDelayMs ?? config.firstTaskDelayMs;
     if (firstTaskDelay !== void 0 && firstTaskDelay > 0) {
@@ -397,19 +746,30 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       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: config.taskQueue ?? "managed",
-        randomnessSeed: runId,
-        ...extraStarted,
-        ...this.startedFields(config)
+    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;
   }
   /** The R2 fields of `WORKFLOW_STARTED`, each written only when it is set. */
@@ -437,9 +797,13 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     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) {
+  append(run, draft, schedule = true) {
     const event = {
       seq: run.history.length + 1,
       type: draft.type,
@@ -447,10 +811,10 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       createdAt: new Date(this.clock).toISOString(),
       ...draft.taskId !== void 0 ? { taskId: draft.taskId } : {}
     };
-    chunkRUQIMTN5_cjs.applyEvent(run.state, event);
+    chunkISOIA7NV_cjs.applyEvent(run.state, event);
     run.history.push(event);
     if (run.delayedUntil !== void 0 && event.type === "SIGNAL_RECEIVED") this.endDelay(run);
-    if (run.delayedUntil === void 0 && chunk3FIDHONL_cjs.isInputEvent(event) && run.state.status === "RUNNING" && run.state.task.state === "NONE") {
+    if (schedule && run.delayedUntil === void 0 && chunkTYF56RGB_cjs.isInputEvent(event) && run.state.status === "RUNNING" && run.state.task.state === "NONE") {
       run.taskCounter += 1;
       const taskId = `${run.runId}-task-${run.taskCounter}`;
       const scheduled = {
@@ -459,7 +823,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         payload: { taskId },
         createdAt: event.createdAt
       };
-      chunkRUQIMTN5_cjs.applyEvent(run.state, scheduled);
+      chunkISOIA7NV_cjs.applyEvent(run.state, scheduled);
       run.history.push(scheduled);
     }
     return event;
@@ -468,19 +832,9 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   endDelay(run) {
     run.delayedUntil = void 0;
     this.dues = this.dues.filter((due) => !(due.runId === run.runId && due.kind === "start"));
-    if (run.state.status !== "RUNNING" || run.state.task.state !== "NONE") 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()
-    };
-    chunkRUQIMTN5_cjs.applyEvent(run.state, scheduled);
-    run.history.push(scheduled);
+    this.scheduleTask(run);
   }
-  deliverSignal(runId, name, payload) {
+  deliverSignal(runId, name, payload, headers) {
     const run = this.runs.get(runId);
     if (!run || run.state.status !== "RUNNING") return false;
     this.append(run, {
@@ -488,7 +842,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;
@@ -526,7 +881,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         continue;
       }
       const attempt = this.attempts.find(
-        (entry) => entry.dueAt <= this.clock && !this.isHeld(entry.nodeType)
+        (entry) => entry.dueAt <= this.clock && !this.isHeld(this.holdKeyOf(entry))
       );
       if (attempt) {
         this.attempts = this.attempts.filter((entry) => entry !== attempt);
@@ -548,12 +903,12 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   }
   /** When a held attempt's schedule-to-start timeout expires, if it has one. */
   heldDeadline(entry) {
-    return this.isHeld(entry.nodeType) && entry.scheduleToStart !== void 0 ? entry.dueAt + entry.scheduleToStart : void 0;
+    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)];
     for (const entry of this.attempts) {
-      if (!this.isHeld(entry.nodeType)) due.push(entry.dueAt);
+      if (!this.isHeld(this.holdKeyOf(entry))) due.push(entry.dueAt);
       const deadline = this.heldDeadline(entry);
       if (deadline !== void 0) due.push(deadline);
     }
@@ -571,7 +926,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     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 || !chunkRUQIMTN5_cjs.isActivityOpen(activity))
+      if (!run || run.state.status !== "RUNNING" || !activity || !chunkISOIA7NV_cjs.isActivityOpen(activity))
         continue;
       this.append(run, {
         type: "ACTIVITY_TIMED_OUT",
@@ -630,13 +985,25 @@ 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: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
+      protocol: chunkTYF56RGB_cjs.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 = await this.executeWithLocalActivities(run, request);
     const fail = (cause, message) => {
@@ -651,15 +1018,30 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       run.taskFailure = result;
       return;
     }
-    const checked = chunkI47EENR4_cjs.validateCommands(result.commands, { enabled: this.enabled });
+    const relief = {
+      grantedLocalActivityIds: [],
+      deliveredUpdateIds: delivered.map((update) => update.updateId)
+    };
+    const checked = chunkHMZUGSMU_cjs.validateCommands(result.commands, { enabled: this.enabled, relief });
     if (!checked.ok) {
       fail(checked.cause, checked.issues.map((issue) => issue.message).join("; "));
       return;
     }
-    const drafts = chunkRUQIMTN5_cjs.eventsForCommands(run.state, checked.commands, {
+    const drafts = chunkISOIA7NV_cjs.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("; "));
@@ -667,12 +1049,55 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     }
     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" || chunk3FIDHONL_cjs.TERMINAL_COMMANDS.has(command.type))
+      if (run.state.status === "RUNNING" || chunkTYF56RGB_cjs.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);
   }
@@ -702,7 +1127,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     const mock = this.mocks.get(`${wanted.nodeType}#${wanted.operation}`) ?? this.mocks.get(wanted.nodeType);
     try {
       if (!mock)
-        throw new chunkELL2RBML_cjs.ApplicationError(
+        throw new chunkZCGKGDCL_cjs.ApplicationError(
           `No mock for ${wanted.nodeType} ${wanted.operation} (use env.mock)`,
           { errorType: "VALIDATION", nonRetryable: true, type: "UnmockedActivity" }
         );
@@ -719,7 +1144,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       );
       return { localActivityId: wanted.localActivityId, result, attempts: wanted.attempt };
     } catch (error) {
-      const failure = chunkELL2RBML_cjs.errorToFailure(error, `node:${wanted.nodeType}`);
+      const failure = chunkZCGKGDCL_cjs.errorToFailure(error, `node:${wanted.nodeType}`);
       delete failure.stackTrace;
       return {
         localActivityId: wanted.localActivityId,
@@ -731,6 +1156,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   afterCommand(run, command) {
     switch (command.type) {
       case "SCHEDULE_ACTIVITY": {
+        const user = command.kind === "user";
         const attempt = {
           runId: run.runId,
           activityId: command.activityId,
@@ -738,11 +1164,14 @@ 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 } : {},
+          ...!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 } : {}
         };
@@ -835,7 +1264,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         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 (chunkRUQIMTN5_cjs.continueAsNewRetryShape(options) === "run" && typeof retry === "object" && retry !== null && !Array.isArray(retry))
+        if (chunkISOIA7NV_cjs.continueAsNewRetryShape(options) === "run" && typeof retry === "object" && retry !== null && !Array.isArray(retry))
           config.retry = retry;
         this.startSuccessor(run, command.input, config);
         this.onClosed(run);
@@ -1002,7 +1431,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
           payload: {
             childId: entry.childId,
             childRunId,
-            failure: toJsonValue(chunkELL2RBML_cjs.errorToFailure(error, "engine"))
+            failure: toJsonValue(chunkZCGKGDCL_cjs.errorToFailure(error, "engine"))
           }
         });
     }
@@ -1011,7 +1440,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     const run = this.runs.get(attempt.runId);
     if (!run || run.state.status !== "RUNNING") return;
     const activity = run.state.activities[attempt.activityId];
-    if (!activity || !chunkRUQIMTN5_cjs.isActivityOpen(activity)) return;
+    if (!activity || !chunkISOIA7NV_cjs.isActivityOpen(activity)) return;
     if (attempt.scheduleToClose !== void 0 && this.clock - attempt.scheduledAt > attempt.scheduleToClose) {
       this.append(run, {
         type: "ACTIVITY_TIMED_OUT",
@@ -1023,40 +1452,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 chunkELL2RBML_cjs.ApplicationError(
-          `No mock for ${attempt.nodeType} ${attempt.operation} (use env.mock)`,
-          {
-            errorType: "VALIDATION",
-            nonRetryable: true,
-            type: "UnmockedActivity"
+      if (attempt.kind === "user") {
+        const impl = chunkVA4OFR72_cjs.findActivityImplementation(this.activityImpls, attempt.operation);
+        if (!impl)
+          throw new chunkZCGKGDCL_cjs.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 } : {},
-          ...attempt.heartbeatDetails !== void 0 ? { heartbeatDetails: attempt.heartbeatDetails } : {},
-          heartbeat: (details) => {
-            heartbeatDetails = toJsonValue(details);
-          }
-        })
-      );
+        result = toJsonValue(
+          await chunkVA4OFR72_cjs.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 chunkZCGKGDCL_cjs.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 = chunkELL2RBML_cjs.errorToFailure(error, `node:${attempt.nodeType}`);
+      failure = chunkZCGKGDCL_cjs.errorToFailure(
+        error,
+        attempt.kind === "user" ? "sdk-ts" : `node:${attempt.nodeType}`
+      );
       delete failure.stackTrace;
     }
-    if (run.state.status !== "RUNNING" || !chunkRUQIMTN5_cjs.isActivityOpen(run.state.activities[attempt.activityId] ?? activity))
+    if (run.state.status !== "RUNNING" || !chunkISOIA7NV_cjs.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 chunkZCGKGDCL_cjs.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 = chunkZCGKGDCL_cjs.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 || !chunkISOIA7NV_cjs.isActivityOpen(open)) return;
     const started = () => {
       this.append(run, {
         type: "ACTIVITY_STARTED",
@@ -1072,7 +1612,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       return;
     }
     if (failure.timeoutType !== void 0 || failure.type === "TimeoutFailure") {
-      const decision2 = chunkYHBVMOMK_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
+      const decision2 = chunkTYF56RGB_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
       if (!decision2.retry) {
         started();
         this.append(run, {
@@ -1094,7 +1634,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       });
       return;
     }
-    const decision = chunkYHBVMOMK_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
+    const decision = chunkTYF56RGB_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
     if (decision.retry) {
       this.attempts.push({
         ...attempt,
@@ -1124,7 +1664,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     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 = chunkYHBVMOMK_cjs.computeRunRetryDelay(run.config.retry, run.config.runAttempt, failure);
+    const decision = chunkTYF56RGB_cjs.computeRunRetryDelay(run.config.retry, run.config.runAttempt, failure);
     if (!decision.retry) return;
     const config = {
       ...this.chainConfig(run.config),
@@ -1134,25 +1674,48 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     if (decision.delayMs > 0) config.firstTaskDelayMs = decision.delayMs;
     this.startSuccessor(run, run.state.input ?? null, config);
   }
-  onClosed(run) {
+  /**
+   * 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 || !chunkRUQIMTN5_cjs.isChildOpen(child) || childRunId === void 0) continue;
+      if (!child || !chunkISOIA7NV_cjs.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;
     const childId = run.parent.childId;
-    if (!parent.state.children[childId] || !chunkRUQIMTN5_cjs.isChildOpen(parent.state.children[childId])) return;
+    if (!parent.state.children[childId] || !chunkISOIA7NV_cjs.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) {
@@ -1203,7 +1766,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   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);
@@ -1226,7 +1790,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
           run.state.failure ?? { errorType: "UNKNOWN", message: "failed" }
         );
       case "CANCELLED":
-        throw new chunkELL2RBML_cjs.CancelledFailure(`Run ${run.runId} was cancelled`);
+        throw new chunkZCGKGDCL_cjs.CancelledFailure(`Run ${run.runId} was cancelled`);
       case "TERMINATED":
         throw new WorkflowFailedError(run.runId, {
           errorType: "PERMANENT",
@@ -1257,7 +1821,7 @@ var ReplayError = class extends Error {
 function replayRequest(workflowFn, history, info = {}, nowMs) {
   const last = history[history.length - 1];
   return {
-    protocol: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
+    protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
     kind: "verify",
     workflowFn,
     info: { runId: "replay", workspaceId: "replay", ...info },
@@ -1267,14 +1831,14 @@ function replayRequest(workflowFn, history, info = {}, nowMs) {
 }
 function eventsOf(input) {
   if (Array.isArray(input)) return { events: input };
-  const file = typeof input === "string" ? chunkI47EENR4_cjs.parseHistoryFile(input) : input;
+  const file = typeof input === "string" ? chunkHMZUGSMU_cjs.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 = chunkJ3PYFGKA_cjs.isDurableWorkflow(workflows) ? { [recordedFn ?? workflows.name]: workflows } : { ...workflows };
+  const map = chunkVA4OFR72_cjs.isDurableWorkflow(workflows) ? { [recordedFn ?? workflows.name]: workflows } : { ...workflows };
   const workflowFn = recordedFn ?? Object.keys(map)[0] ?? "";
   const result = await runWorkflowTaskInProcess(
     registryOf(map),
@@ -1287,7 +1851,7 @@ async function replay(workflows, input, options = {}) {
   );
   if (result.outcome === "failed") {
     if (result.failure?.cause === "NON_DETERMINISM")
-      throw new chunkELL2RBML_cjs.DeterminismViolation(result.failure.message);
+      throw new chunkZCGKGDCL_cjs.DeterminismViolation(result.failure.message);
     throw new ReplayError(result);
   }
   return result;
@@ -1336,16 +1900,16 @@ function assertHistory(history, expected, options = {}) {
     );
 }
 function definitionOf(value) {
-  return chunkGBQ33SIZ_cjs.normalizeDefinition(chunkNXFBVDOI_cjs.isTier1Workflow(value) ? chunkNXFBVDOI_cjs.toIR(value) : value);
+  return chunk54FLQNUM_cjs.normalizeDefinition(chunkIQPXHQQQ_cjs.isTier1Workflow(value) ? chunkIQPXHQQQ_cjs.toIR(value) : value);
 }
 function expectIR(value) {
   const definition = definitionOf(value);
-  const hash = chunkGBQ33SIZ_cjs.irHash(definition);
+  const hash = chunk54FLQNUM_cjs.irHash(definition);
   return {
     definition,
     irHash: hash,
     toEqualIR(other) {
-      const otherHash = chunkGBQ33SIZ_cjs.irHash(definitionOf(other));
+      const otherHash = chunk54FLQNUM_cjs.irHash(definitionOf(other));
       if (otherHash !== hash)
         throw new HistoryAssertionError(`The IR differs: ${hash} versus ${otherHash}`);
     }
@@ -1388,7 +1952,7 @@ async function simulate(definition, options = {}) {
         output = produced.output;
         handle = produced.handle;
       } else output = produced;
-    } else if (node.type === chunkGBQ33SIZ_cjs.CODE_WORKFLOW_NODE_TYPE) {
+    } else if (node.type === chunk54FLQNUM_cjs.CODE_WORKFLOW_NODE_TYPE) {
       const state = node.args?.state;
       const workflowFn = chunkSAENRNBJ_cjs.isRecord(state) && typeof state["workflowFn"] === "string" ? state["workflowFn"] : "";
       const fn = options.workflows?.[workflowFn];
@@ -1456,31 +2020,34 @@ async function runWorkflowTaskInVm(script, request, options = {}) {
       await settle();
       if (step !== "more") break;
       if (Date.now() > deadline)
-        return chunkEWYADREB_cjs.failedTaskResult(
+        return chunk672KMMBK_cjs.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 chunkEWYADREB_cjs.failedTaskResult("INTERNAL", "The runtime returned no result");
+      return chunk672KMMBK_cjs.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 chunkEWYADREB_cjs.failedTaskResult("TASK_TIMEOUT", message);
-    if (name === "DeterminismViolation") return chunkEWYADREB_cjs.failedTaskResult("NON_DETERMINISM", message);
-    return chunkEWYADREB_cjs.failedTaskResult("WORKFLOW_CODE_ERROR", `${name || "Error"}: ${message}`);
+    if (/timed out/i.test(message)) return chunk672KMMBK_cjs.failedTaskResult("TASK_TIMEOUT", message);
+    if (name === "DeterminismViolation") return chunk672KMMBK_cjs.failedTaskResult("NON_DETERMINISM", message);
+    return chunk672KMMBK_cjs.failedTaskResult("WORKFLOW_CODE_ERROR", `${name || "Error"}: ${message}`);
   }
 }
 
 exports.HistoryAssertionError = HistoryAssertionError;
+exports.QueryFailedError = QueryFailedError;
+exports.QueryRejectedError = QueryRejectedError;
 exports.ReplayError = ReplayError;
 exports.RunBlockedError = RunBlockedError;
 exports.TestRunHandle = TestRunHandle;
 exports.TestWorkflowEnvironment = TestWorkflowEnvironment;
 exports.UnfinishedHandlersError = UnfinishedHandlersError;
+exports.UpdateRefusedError = UpdateRefusedError;
 exports.WorkflowAlreadyStartedError = WorkflowAlreadyStartedError;
 exports.WorkflowFailedError = WorkflowFailedError;
 exports.WorkflowTaskFailedError = WorkflowTaskFailedError;