@fluidgrids/workflows 2026.1028.2 → 2026.1029.1

package/dist/testing/index.cjs

@@ -1,22 +1,23 @@
 'use strict';
 
-var chunkJD2VQIDZ_cjs = require('../chunk-JD2VQIDZ.cjs');
-var chunkSAOBPYYJ_cjs = require('../chunk-SAOBPYYJ.cjs');
+var chunkEWYADREB_cjs = require('../chunk-EWYADREB.cjs');
+var chunkNXFBVDOI_cjs = require('../chunk-NXFBVDOI.cjs');
 var chunkGBQ33SIZ_cjs = require('../chunk-GBQ33SIZ.cjs');
 require('../chunk-G4UEPUGO.cjs');
 require('../chunk-GVTZMA5C.cjs');
 require('../chunk-QKZL3ONM.cjs');
 require('../chunk-TBDXTV22.cjs');
-var chunkPZCVF76Q_cjs = require('../chunk-PZCVF76Q.cjs');
+var chunkI47EENR4_cjs = require('../chunk-I47EENR4.cjs');
 var chunkSAENRNBJ_cjs = require('../chunk-SAENRNBJ.cjs');
-var chunkM4BBAERY_cjs = require('../chunk-M4BBAERY.cjs');
-var chunkFMSW2HDF_cjs = require('../chunk-FMSW2HDF.cjs');
-require('../chunk-FR7KYWRO.cjs');
+var chunkOMY3CKUZ_cjs = require('../chunk-OMY3CKUZ.cjs');
+var chunkELL2RBML_cjs = require('../chunk-ELL2RBML.cjs');
+require('../chunk-Q4MWQNJK.cjs');
 var chunkL24YIZY7_cjs = require('../chunk-L24YIZY7.cjs');
-var chunkDHTLALBL_cjs = require('../chunk-DHTLALBL.cjs');
-var chunkP6TA5EZT_cjs = require('../chunk-P6TA5EZT.cjs');
-var chunk623FVQSN_cjs = require('../chunk-623FVQSN.cjs');
-require('../chunk-2J6TF7YI.cjs');
+var chunkJ3PYFGKA_cjs = require('../chunk-J3PYFGKA.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');
 require('../chunk-Z2Y65YOY.cjs');
 var vm = require('vm');
 
@@ -25,7 +26,7 @@ function drainJobs() {
   return new Promise((resolve) => setImmediate(resolve));
 }
 function registryOf(workflows) {
-  return chunkM4BBAERY_cjs.buildWorkflowRegistry([["in-process", { ...workflows }]]);
+  return chunkOMY3CKUZ_cjs.buildWorkflowRegistry([["in-process", { ...workflows }]]);
 }
 async function hostLoop(abi, requestJson) {
   abi.start(requestJson);
@@ -35,19 +36,45 @@ async function hostLoop(abi, requestJson) {
   return abi.complete();
 }
 async function runWorkflowTaskInProcess(registry, request) {
-  const abi = chunkM4BBAERY_cjs.createWorkflowRuntime(registry);
+  const abi = chunkOMY3CKUZ_cjs.createWorkflowRuntime(registry);
   const json = await hostLoop(abi, JSON.stringify(request));
   return JSON.parse(json);
 }
 
 // src/testing/environment.ts
+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}`);
     this.runId = runId;
     this.failure = failure;
     this.name = "WorkflowFailedError";
-    Object.defineProperty(this, "cause", { value: chunkFMSW2HDF_cjs.failureToError(failure), enumerable: false });
+    Object.defineProperty(this, "cause", { value: chunkELL2RBML_cjs.failureToError(failure), enumerable: false });
   }
   runId;
   failure;
@@ -89,7 +116,7 @@ var TestRunHandle = class {
   }
   /** Deliver a signal and run until idle (without skipping time). */
   async signal(signal, payload) {
-    this.env.deliverSignal(this.runId, chunkFMSW2HDF_cjs.signalName(signal), payload);
+    this.env.deliverSignal(this.runId, chunkELL2RBML_cjs.signalName(signal), payload);
     await this.env.runUntilIdle(false);
   }
   /** Request cancellation and run until idle (without skipping time). */
@@ -116,6 +143,15 @@ 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 : chunkJ3PYFGKA_cjs.toMs(value, what);
+}
+var FAILED_STATUSES = /* @__PURE__ */ new Set([
+  "FAILED",
+  "CANCELLED",
+  "TERMINATED",
+  "TIMED_OUT"
+]);
 function toJsonValue(value) {
   if (value === void 0) return null;
   const text = JSON.stringify(value);
@@ -125,6 +161,10 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   clock;
   timeSkipping;
   enabled;
+  failOnUnfinishedHandlers;
+  historyRelease;
+  dues = [];
+  held = /* @__PURE__ */ new Set();
   workspaceId;
   runs = /* @__PURE__ */ new Map();
   runOrder = [];
@@ -142,6 +182,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     this.clock = toDate(options.startTime);
     this.timeSkipping = options.timeSkipping !== false;
     this.enabled = options.enabled ?? "parity";
+    this.failOnUnfinishedHandlers = options.failOnUnfinishedHandlers !== false;
+    this.historyRelease = options.historyRelease ?? chunk3FIDHONL_cjs.RUNTIME_RELEASE;
     this.workspaceId = options.workspaceId ?? "test-workspace";
     this.workflows = { ...options.workflows ?? {} };
     this.registry = registryOf(this.workflows);
@@ -165,6 +207,22 @@ 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);
+  }
+  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);
@@ -175,20 +233,88 @@ 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.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);
+        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: chunkJ3PYFGKA_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 } : {}
+    };
     const runId = this.createRun(
       workflowFn,
       toJsonValue(options.input),
       { ...options.info, ...options.runId !== void 0 ? { runId: options.runId } : {} },
-      void 0
+      void 0,
+      {},
+      config
     );
     for (const signal of options.signals ?? [])
       this.deliverSignal(runId, signal.name, signal.payload);
     await this.runUntilIdle(false);
     return new TestRunHandle(this, runId);
   }
+  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 + chunkFMSW2HDF_cjs.toMs(duration, "sleep duration");
+    const until = this.clock + chunkJ3PYFGKA_cjs.toMs(duration, "sleep duration");
     await this.runUntilIdle(false);
     for (; ; ) {
       const next = this.nextDue();
@@ -210,7 +336,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
   }
   historyFileOf(runId, extra = {}) {
     const run = this.run(runId);
-    return chunkPZCVF76Q_cjs.createHistoryFile(run.workflowFn, this.historyOf(runId), {
+    return chunkI47EENR4_cjs.createHistoryFile(run.workflowFn, this.historyOf(runId), {
       info: { ...run.info },
       ...extra
     });
@@ -236,7 +362,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 }) {
     this.runCounter += 1;
     const runId = info.runId ?? `run-${this.runCounter}`;
     const snapshot = {
@@ -253,22 +379,66 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       runId,
       workflowFn,
       history: [],
-      state: chunkP6TA5EZT_cjs.initialRunState(),
+      state: chunkRUQIMTN5_cjs.initialRunState(),
       taskCounter: 0,
       info: snapshot,
       children: /* @__PURE__ */ new Map(),
+      config,
       ...parent ? { parent } : {}
     };
+    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 }
+      payload: {
+        workflowFn,
+        input,
+        taskQueue: config.taskQueue ?? "managed",
+        randomnessSeed: runId,
+        ...extraStarted,
+        ...this.startedFields(config)
+      }
     });
     return runId;
   }
+  /** 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);
+    return out;
+  }
   append(run, draft) {
     const event = {
       seq: run.history.length + 1,
@@ -277,9 +447,10 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       createdAt: new Date(this.clock).toISOString(),
       ...draft.taskId !== void 0 ? { taskId: draft.taskId } : {}
     };
-    chunkP6TA5EZT_cjs.applyEvent(run.state, event);
+    chunkRUQIMTN5_cjs.applyEvent(run.state, event);
     run.history.push(event);
-    if (chunk623FVQSN_cjs.isInputEvent(event) && run.state.status === "RUNNING" && run.state.task.state === "NONE") {
+    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") {
       run.taskCounter += 1;
       const taskId = `${run.runId}-task-${run.taskCounter}`;
       const scheduled = {
@@ -288,11 +459,27 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
         payload: { taskId },
         createdAt: event.createdAt
       };
-      chunkP6TA5EZT_cjs.applyEvent(run.state, scheduled);
+      chunkRUQIMTN5_cjs.applyEvent(run.state, scheduled);
       run.history.push(scheduled);
     }
     return event;
   }
+  /** 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"));
+    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);
+  }
   deliverSignal(runId, name, payload) {
     const run = this.runs.get(runId);
     if (!run || run.state.status !== "RUNNING") return false;
@@ -314,6 +501,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) {
@@ -333,7 +525,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(entry.nodeType)
+      );
       if (attempt) {
         this.attempts = this.attempts.filter((entry) => entry !== attempt);
         await this.runAttempt(attempt);
@@ -352,16 +546,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(entry.nodeType) && 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(entry.nodeType)) 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 || !chunkRUQIMTN5_cjs.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);
@@ -375,14 +631,14 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     const taskId = run.state.task.taskId ?? `${run.runId}-task-${run.taskCounter}`;
     this.append(run, { type: "WORKFLOW_TASK_STARTED", payload: { taskId, attempt: 1 } });
     const request = {
-      protocol: chunk623FVQSN_cjs.HISTORY_PROTOCOL,
+      protocol: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
       kind: "task",
       workflowFn: run.workflowFn,
       info: run.info,
       history: run.history,
       nowMs: this.clock
     };
-    const result = this.executor ? await this.executor(request) : await runWorkflowTaskInProcess(this.registry, request);
+    const result = await this.executeWithLocalActivities(run, request);
     const fail = (cause, message) => {
       this.append(run, {
         type: "WORKFLOW_TASK_FAILED",
@@ -395,12 +651,12 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       run.taskFailure = result;
       return;
     }
-    const checked = chunkPZCVF76Q_cjs.validateCommands(result.commands, { enabled: this.enabled });
+    const checked = chunkI47EENR4_cjs.validateCommands(result.commands, { enabled: this.enabled });
     if (!checked.ok) {
       fail(checked.cause, checked.issues.map((issue) => issue.message).join("; "));
       return;
     }
-    const drafts = chunkP6TA5EZT_cjs.eventsForCommands(run.state, checked.commands, {
+    const drafts = chunkRUQIMTN5_cjs.eventsForCommands(run.state, checked.commands, {
       taskId,
       nowMs: this.clock,
       enabled: this.enabled
@@ -409,12 +665,69 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       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.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" || chunk623FVQSN_cjs.TERMINAL_COMMANDS.has(command.type))
+      if (run.state.status === "RUNNING" || chunk3FIDHONL_cjs.TERMINAL_COMMANDS.has(command.type))
         this.afterCommand(run, command);
   }
+  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 chunkELL2RBML_cjs.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 = chunkELL2RBML_cjs.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": {
@@ -430,7 +743,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
           retry: command.retry,
           cancelRequested: false,
           ...command.connection !== void 0 ? { connection: command.connection } : {},
-          ...command.scheduleToCloseTimeout !== void 0 ? { scheduleToClose: command.scheduleToCloseTimeout } : {}
+          ...command.scheduleToCloseTimeout !== void 0 ? { scheduleToClose: command.scheduleToCloseTimeout } : {},
+          ...command.scheduleToStartTimeout !== void 0 ? { scheduleToStart: command.scheduleToStartTimeout } : {}
         };
         this.attempts.push(attempt);
         return;
@@ -505,18 +819,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 (chunkRUQIMTN5_cjs.continueAsNewRetryShape(options) === "run" && typeof retry === "object" && retry !== null && !Array.isArray(retry))
+          config.retry = retry;
+        this.startSuccessor(run, command.input, config);
         this.onClosed(run);
         return;
       }
@@ -529,11 +850,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));
@@ -566,6 +938,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,
@@ -574,7 +968,8 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       {
         parentRunId: run.runId,
         parentClosePolicy: command.options.parentClosePolicy
-      }
+      },
+      config
     );
     run.children.set(command.childId, childRunId);
     this.append(run, {
@@ -607,7 +1002,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
           payload: {
             childId: entry.childId,
             childRunId,
-            failure: toJsonValue(chunkFMSW2HDF_cjs.errorToFailure(error, "engine"))
+            failure: toJsonValue(chunkELL2RBML_cjs.errorToFailure(error, "engine"))
           }
         });
     }
@@ -616,7 +1011,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 || !chunkP6TA5EZT_cjs.isActivityOpen(activity)) return;
+    if (!activity || !chunkRUQIMTN5_cjs.isActivityOpen(activity)) return;
     if (attempt.scheduleToClose !== void 0 && this.clock - attempt.scheduledAt > attempt.scheduleToClose) {
       this.append(run, {
         type: "ACTIVITY_TIMED_OUT",
@@ -631,9 +1026,10 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     const mock = this.mocks.get(`${attempt.nodeType}#${attempt.operation}`) ?? this.mocks.get(attempt.nodeType);
     let failure;
     let result = null;
+    let heartbeatDetails = attempt.heartbeatDetails;
     try {
       if (!mock)
-        throw new chunkFMSW2HDF_cjs.ApplicationError(
+        throw new chunkELL2RBML_cjs.ApplicationError(
           `No mock for ${attempt.nodeType} ${attempt.operation} (use env.mock)`,
           {
             errorType: "VALIDATION",
@@ -648,14 +1044,18 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
           attempt: attempt.attempt,
           nodeType: attempt.nodeType,
           operation: attempt.operation,
-          ...attempt.connection !== void 0 ? { connection: attempt.connection } : {}
+          ...attempt.connection !== void 0 ? { connection: attempt.connection } : {},
+          ...attempt.heartbeatDetails !== void 0 ? { heartbeatDetails: attempt.heartbeatDetails } : {},
+          heartbeat: (details) => {
+            heartbeatDetails = toJsonValue(details);
+          }
         })
       );
     } catch (error) {
-      failure = chunkFMSW2HDF_cjs.errorToFailure(error, `node:${attempt.nodeType}`);
+      failure = chunkELL2RBML_cjs.errorToFailure(error, `node:${attempt.nodeType}`);
       delete failure.stackTrace;
     }
-    if (run.state.status !== "RUNNING" || !chunkP6TA5EZT_cjs.isActivityOpen(run.state.activities[attempt.activityId] ?? activity))
+    if (run.state.status !== "RUNNING" || !chunkRUQIMTN5_cjs.isActivityOpen(run.state.activities[attempt.activityId] ?? activity))
       return;
     const started = () => {
       this.append(run, {
@@ -672,7 +1072,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       return;
     }
     if (failure.timeoutType !== void 0 || failure.type === "TimeoutFailure") {
-      const decision2 = chunkP6TA5EZT_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
+      const decision2 = chunkYHBVMOMK_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
       if (!decision2.retry) {
         started();
         this.append(run, {
@@ -689,16 +1089,18 @@ 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;
     }
-    const decision = chunkP6TA5EZT_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
+    const decision = chunkYHBVMOMK_cjs.computeRetryDelay(attempt.retry, attempt.attempt, failure);
     if (decision.retry) {
       this.attempts.push({
         ...attempt,
         attempt: attempt.attempt + 1,
-        dueAt: this.clock + decision.delayMs
+        dueAt: this.clock + decision.delayMs,
+        ...heartbeatDetails !== void 0 ? { heartbeatDetails } : {}
       });
       return;
     }
@@ -712,12 +1114,34 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
       }
     });
   }
+  /**
+   * 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 = chunkYHBVMOMK_cjs.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);
+  }
   onClosed(run) {
     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);
+    this.retryRun(run);
     for (const [childId2, childRunId] of run.children) {
       const child = run.state.children[childId2];
-      if (!child || !chunkP6TA5EZT_cjs.isChildOpen(child) || childRunId === void 0) continue;
+      if (!child || !chunkRUQIMTN5_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");
@@ -726,7 +1150,7 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     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] || !chunkP6TA5EZT_cjs.isChildOpen(parent.state.children[childId])) return;
+    if (!parent.state.children[childId] || !chunkRUQIMTN5_cjs.isChildOpen(parent.state.children[childId])) return;
     const last = run.history[run.history.length - 1];
     if (!last) return;
     if (run.continuedTo !== void 0) {
@@ -769,7 +1193,10 @@ 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"
+          }
         });
     }
   }
@@ -778,17 +1205,28 @@ var TestWorkflowEnvironment = class _TestWorkflowEnvironment {
     let run = this.run(runId);
     while (run.continuedTo !== void 0) run = this.run(run.continuedTo);
     if (run.taskFailure) throw new WorkflowTaskFailedError(run.runId, run.taskFailure);
+    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,
           run.state.failure ?? { errorType: "UNKNOWN", message: "failed" }
         );
       case "CANCELLED":
-        throw new chunkFMSW2HDF_cjs.CancelledFailure(`Run ${run.runId} was cancelled`);
+        throw new chunkELL2RBML_cjs.CancelledFailure(`Run ${run.runId} was cancelled`);
       case "TERMINATED":
         throw new WorkflowFailedError(run.runId, {
           errorType: "PERMANENT",
@@ -819,7 +1257,7 @@ var ReplayError = class extends Error {
 function replayRequest(workflowFn, history, info = {}, nowMs) {
   const last = history[history.length - 1];
   return {
-    protocol: chunk623FVQSN_cjs.HISTORY_PROTOCOL,
+    protocol: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
     kind: "verify",
     workflowFn,
     info: { runId: "replay", workspaceId: "replay", ...info },
@@ -829,14 +1267,14 @@ function replayRequest(workflowFn, history, info = {}, nowMs) {
 }
 function eventsOf(input) {
   if (Array.isArray(input)) return { events: input };
-  const file = typeof input === "string" ? chunkPZCVF76Q_cjs.parseHistoryFile(input) : input;
+  const file = typeof input === "string" ? chunkI47EENR4_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 = chunkDHTLALBL_cjs.isDurableWorkflow(workflows) ? { [recordedFn ?? workflows.name]: workflows } : { ...workflows };
+  const map = chunkJ3PYFGKA_cjs.isDurableWorkflow(workflows) ? { [recordedFn ?? workflows.name]: workflows } : { ...workflows };
   const workflowFn = recordedFn ?? Object.keys(map)[0] ?? "";
   const result = await runWorkflowTaskInProcess(
     registryOf(map),
@@ -849,7 +1287,7 @@ async function replay(workflows, input, options = {}) {
   );
   if (result.outcome === "failed") {
     if (result.failure?.cause === "NON_DETERMINISM")
-      throw new chunkFMSW2HDF_cjs.DeterminismViolation(result.failure.message);
+      throw new chunkELL2RBML_cjs.DeterminismViolation(result.failure.message);
     throw new ReplayError(result);
   }
   return result;
@@ -898,7 +1336,7 @@ function assertHistory(history, expected, options = {}) {
     );
 }
 function definitionOf(value) {
-  return chunkGBQ33SIZ_cjs.normalizeDefinition(chunkSAOBPYYJ_cjs.isTier1Workflow(value) ? chunkSAOBPYYJ_cjs.toIR(value) : value);
+  return chunkGBQ33SIZ_cjs.normalizeDefinition(chunkNXFBVDOI_cjs.isTier1Workflow(value) ? chunkNXFBVDOI_cjs.toIR(value) : value);
 }
 function expectIR(value) {
   const definition = definitionOf(value);
@@ -1018,22 +1456,22 @@ async function runWorkflowTaskInVm(script, request, options = {}) {
       await settle();
       if (step !== "more") break;
       if (Date.now() > deadline)
-        return chunkJD2VQIDZ_cjs.failedTaskResult(
+        return chunkEWYADREB_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 chunkJD2VQIDZ_cjs.failedTaskResult("INTERNAL", "The runtime returned no result");
+      return chunkEWYADREB_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 chunkJD2VQIDZ_cjs.failedTaskResult("TASK_TIMEOUT", message);
-    if (name === "DeterminismViolation") return chunkJD2VQIDZ_cjs.failedTaskResult("NON_DETERMINISM", message);
-    return chunkJD2VQIDZ_cjs.failedTaskResult("WORKFLOW_CODE_ERROR", `${name || "Error"}: ${message}`);
+    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}`);
   }
 }
 
@@ -1042,6 +1480,8 @@ exports.ReplayError = ReplayError;
 exports.RunBlockedError = RunBlockedError;
 exports.TestRunHandle = TestRunHandle;
 exports.TestWorkflowEnvironment = TestWorkflowEnvironment;
+exports.UnfinishedHandlersError = UnfinishedHandlersError;
+exports.WorkflowAlreadyStartedError = WorkflowAlreadyStartedError;
 exports.WorkflowFailedError = WorkflowFailedError;
 exports.WorkflowTaskFailedError = WorkflowTaskFailedError;
 exports.assertHistory = assertHistory;