@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/chunk-3FOTFQ3J.js

@@ -0,0 +1,1622 @@
+import { ServerFailure, failureToError, CancelledFailure, TimeoutFailure, ApplicationError, TerminatedFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, isCancellation, isRunFailure, errorToFailure, optionalMs, ActivityFailure, toMs, signalName, ChildRunFailure } from './chunk-C5OLWZ42.js';
+import { createRandom, seedOf, takeShimControl, uuidFrom } from './chunk-4LYSEANA.js';
+import { isDurableWorkflow, SDK_VERSION } from './chunk-7NQ37GZU.js';
+import { utf8Bytes, splitActivations, explicitRetryPolicy, CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY } from './chunk-ABFZWYHT.js';
+import { COMMAND_EVENT_TYPES, DEFAULT_HISTORY_LIMIT, CONTINUE_AS_NEW_SUGGESTED_RATIO, HISTORY_PROTOCOL, HISTORY_LIMIT_EXCEEDED_RATIO, BUILT_IN_QUERIES } from './chunk-DJYMDLV5.js';
+import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.js';
+
+// src/runtime/ids.ts
+var CommandIds = class {
+  counters = { a: 0, t: 0, c: 0, s: 0, x: 0, m: 0 };
+  /** The next id of a kind: `a1`, `a2`, ... */
+  next(kind) {
+    this.counters[kind] += 1;
+    return `${kind}${this.counters[kind]}`;
+  }
+};
+function patchMarkerId(patchId) {
+  return `patch:${patchId}`;
+}
+function isPatchMarkerId(markerId) {
+  return markerId.startsWith("patch:");
+}
+
+// src/runtime/matcher.ts
+function field(event, key) {
+  return event.payload[key];
+}
+function describeCommand(command) {
+  switch (command.type) {
+    case "SCHEDULE_ACTIVITY":
+      return `SCHEDULE_ACTIVITY ${command.activityId} (${command.nodeType} ${command.operation})`;
+    case "REQUEST_CANCEL_ACTIVITY":
+      return `REQUEST_CANCEL_ACTIVITY ${command.activityId}`;
+    case "START_TIMER":
+    case "CANCEL_TIMER":
+      return `${command.type} ${command.timerId}`;
+    case "START_CHILD_RUN":
+      return `START_CHILD_RUN ${command.childId} (${command.workflowKey ?? command.workflowFn ?? ""})`;
+    case "SIGNAL_RUN":
+      return `SIGNAL_RUN ${command.externalId} (${command.name})`;
+    case "REQUEST_CANCEL_EXTERNAL_RUN":
+      return `REQUEST_CANCEL_EXTERNAL_RUN ${command.externalId}`;
+    case "RECORD_SIDE_EFFECT":
+      return `RECORD_SIDE_EFFECT ${command.sideEffectId}`;
+    case "RECORD_MARKER":
+      return `RECORD_MARKER ${command.markerId}`;
+    case "RECORD_LOCAL_ACTIVITY":
+      return `RECORD_LOCAL_ACTIVITY ${command.localActivityId}`;
+    default:
+      return command.type;
+  }
+}
+function describeEvent(event) {
+  const id = field(event, "activityId") ?? field(event, "timerId") ?? field(event, "childId") ?? field(event, "externalId") ?? field(event, "sideEffectId") ?? field(event, "markerId") ?? field(event, "localActivityId");
+  return `${event.type}${typeof id === "string" ? ` ${id}` : ""} (seq ${event.seq})`;
+}
+function mismatch(command, event) {
+  const expected = COMMAND_EVENT_TYPES[command.type];
+  const typeOk = command.type === "RECORD_LOCAL_ACTIVITY" ? event.type === "LOCAL_ACTIVITY_COMPLETED" || event.type === "LOCAL_ACTIVITY_FAILED" : event.type === expected;
+  const differ = () => `the code issued ${describeCommand(command)} where the history has ${describeEvent(event)}`;
+  if (!typeOk) return differ();
+  switch (command.type) {
+    case "SCHEDULE_ACTIVITY":
+      return field(event, "activityId") === command.activityId && field(event, "nodeType") === command.nodeType && field(event, "operation") === command.operation ? void 0 : differ();
+    case "REQUEST_CANCEL_ACTIVITY":
+      return field(event, "activityId") === command.activityId ? void 0 : differ();
+    case "START_TIMER":
+    case "CANCEL_TIMER":
+      return field(event, "timerId") === command.timerId ? void 0 : differ();
+    case "START_CHILD_RUN":
+      return field(event, "childId") === command.childId && (field(event, "workflowKey") ?? null) === (command.workflowKey ?? null) && (field(event, "workflowFn") ?? null) === (command.workflowFn ?? null) ? void 0 : differ();
+    case "SIGNAL_RUN":
+      return field(event, "externalId") === command.externalId && field(event, "name") === command.name ? void 0 : differ();
+    case "REQUEST_CANCEL_EXTERNAL_RUN":
+      return field(event, "externalId") === command.externalId ? void 0 : differ();
+    case "RECORD_SIDE_EFFECT":
+      return field(event, "sideEffectId") === command.sideEffectId ? void 0 : differ();
+    case "RECORD_MARKER":
+      return field(event, "markerId") === command.markerId ? void 0 : differ();
+    case "RECORD_LOCAL_ACTIVITY":
+      return field(event, "localActivityId") === command.localActivityId ? void 0 : differ();
+    default:
+      return void 0;
+  }
+}
+function isSkippablePatch(event) {
+  const markerId = field(event, "markerId");
+  return event.type === "MARKER_RECORDED" && typeof markerId === "string" && isPatchMarkerId(markerId);
+}
+function matchActivation(commands, recorded) {
+  let position = 0;
+  for (const command of commands) {
+    let event = recorded[position];
+    while (event !== void 0 && isSkippablePatch(event) && !(command.type === "RECORD_MARKER" && command.markerId === field(event, "markerId"))) {
+      position += 1;
+      event = recorded[position];
+    }
+    if (event === void 0)
+      return {
+        message: `the code issued ${describeCommand(command)}, which the history does not have`
+      };
+    const reason = mismatch(command, event);
+    if (reason !== void 0) return { message: reason, seq: event.seq };
+    position += 1;
+  }
+  for (; position < recorded.length; position++) {
+    const event = recorded[position];
+    if (event !== void 0 && !isSkippablePatch(event))
+      return {
+        message: `the history has ${describeEvent(event)}, which the code did not issue`,
+        seq: event.seq
+      };
+  }
+  return void 0;
+}
+
+// src/runtime/stack.ts
+var RUNTIME_FRAME = /fluidgrids-runtime|\/runtime\/(scheduler|index)\.|WorkflowExecution|RuntimeContext/;
+function captureStack() {
+  const stack = new Error("stack").stack ?? "";
+  return stack.split("\n").slice(1).filter((line) => line.trim() !== "" && !RUNTIME_FRAME.test(line)).join("\n");
+}
+var V8_FRAME = /^\s*at (?:(.*?) \()?(.*?):(\d+):(\d+)\)?$/;
+var QUICKJS_FRAME = /^\s*at (?:(.*?) )?\(?(.*?)(?::(\d+))?(?::(\d+))?\)?$/;
+function parseStack(stack) {
+  const locations = [];
+  for (const line of stack.split("\n")) {
+    if (line.trim() === "") continue;
+    const match = V8_FRAME.exec(line) ?? QUICKJS_FRAME.exec(line);
+    if (!match) continue;
+    const location = {};
+    if (match[1]) location.functionName = match[1];
+    if (match[2]) location.filePath = match[2];
+    if (match[3]) location.line = Number(match[3]);
+    if (match[4]) location.column = Number(match[4]);
+    locations.push(location);
+  }
+  return locations;
+}
+
+// src/runtime/scheduler.ts
+var SDK_NAME = "@fluidgrids/workflows";
+var ContinueAsNewRequest = class {
+  constructor(input, options) {
+    this.input = input;
+    this.options = options;
+  }
+  input;
+  options;
+};
+var TaskFailure = class {
+  constructor(cause, message, stackTrace, seq, errorType) {
+    this.cause = cause;
+    this.message = message;
+    this.stackTrace = stackTrace;
+    this.seq = seq;
+    this.errorType = errorType;
+  }
+  cause;
+  message;
+  stackTrace;
+  seq;
+  errorType;
+};
+var Scope = class {
+  constructor(parent, nonCancellable) {
+    this.parent = parent;
+    this.nonCancellable = nonCancellable;
+    this.cancelRequested = new Promise((_resolve, reject) => {
+      this.rejectRequested = reject;
+    });
+    this.cancelRequested.catch(() => void 0);
+    if (parent && !nonCancellable) {
+      parent.children.add(this);
+      if (parent.consideredCancelled) this.cancel();
+    }
+  }
+  parent;
+  nonCancellable;
+  consideredCancelled = false;
+  cancelRequested;
+  rejectRequested = () => void 0;
+  handlers = /* @__PURE__ */ new Set();
+  children = /* @__PURE__ */ new Set();
+  /** Register a reaction to cancellation; returns its removal. */
+  onCancel(handler) {
+    if (this.consideredCancelled) {
+      handler();
+      return () => void 0;
+    }
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  /**
+   * Cancel the scope and its children. Every handler and child runs even when
+   * one throws; the first error is rethrown once the fan-out is complete.
+   */
+  cancel() {
+    if (this.consideredCancelled) return;
+    this.consideredCancelled = true;
+    this.rejectRequested(new CancelledFailure("Cancellation requested"));
+    const errors = [];
+    const handlers = [...this.handlers];
+    this.handlers.clear();
+    for (const handler of handlers) {
+      try {
+        handler();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    for (const child of [...this.children]) {
+      try {
+        child.cancel();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) throw errors[0];
+  }
+  detach() {
+    this.parent?.children.delete(this);
+  }
+};
+function toJson(value, what) {
+  if (value === void 0) return null;
+  if (typeof value === "function" || typeof value === "symbol")
+    throw new TypeError(`${what} is not JSON: it is a ${typeof value}`);
+  let text;
+  try {
+    text = JSON.stringify(value);
+  } catch (error) {
+    if (!(error instanceof TypeError)) throw error;
+    throw new TypeError(`${what} is not JSON: ${error.message}`);
+  }
+  if (text === void 0) return null;
+  const parsed = JSON.parse(text);
+  return parsed;
+}
+function randomnessSeedOf(request) {
+  const started = request.history[0];
+  const seed = started?.type === "WORKFLOW_STARTED" ? started.payload["randomnessSeed"] : void 0;
+  return typeof seed === "string" ? seed : request.info.runId;
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : "";
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function stackTextOf(error) {
+  return error instanceof Error && typeof error.stack === "string" ? error.stack : void 0;
+}
+var WorkflowExecution = class {
+  request;
+  definition;
+  exportNames;
+  sdkVersion;
+  activations;
+  index = -1;
+  activationOpen = false;
+  replaying = false;
+  clock = 0;
+  random;
+  ids = new CommandIds();
+  commands = [];
+  newCommands = [];
+  logs = [];
+  failure;
+  closed = false;
+  captureStacks;
+  /** History length and inline bytes the current activation reports (see `Activation.historyLength`). */
+  historyLength = 0;
+  historyBytes = 0;
+  /** `bytesUpTo[n]`: UTF-8 bytes of the payloads of events 1..n. */
+  bytesUpTo;
+  limitEvents;
+  limitBytes;
+  root = new Scope(void 0, false);
+  /**
+   * Scopes whose function is running synchronously right now, innermost
+   * last. The outer `ctx` uses the innermost one, else the root: a scope is
+   * ambient only during the synchronous part of its function, never across
+   * an await, so concurrent branches never see each other's scopes.
+   */
+  syncScopes = [];
+  /** A scope that is never cancelled, for waits that ignore cancellation. */
+  detachedScope = new Scope(void 0, true);
+  cancelRequested = false;
+  activities = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  children = /* @__PURE__ */ new Map();
+  externals = /* @__PURE__ */ new Map();
+  issued = /* @__PURE__ */ new Set();
+  recordedSideEffects = /* @__PURE__ */ new Map();
+  recordedMarkers = /* @__PURE__ */ new Set();
+  patches = /* @__PURE__ */ new Map();
+  signalBuffers = /* @__PURE__ */ new Map();
+  signalOrder = [];
+  signalHandlers = /* @__PURE__ */ new Map();
+  signalWaiters = /* @__PURE__ */ new Map();
+  defaultSignalHandler;
+  runningHandlers = 0;
+  conditions = [];
+  currentDetails;
+  context;
+  info;
+  constructor(input) {
+    this.request = input.request;
+    this.definition = input.definition;
+    this.exportNames = input.exportNames;
+    this.sdkVersion = input.sdkVersion;
+    const history = input.request.history;
+    this.bytesUpTo = [0];
+    let bytes = 0;
+    for (const event of history) {
+      bytes += utf8Bytes(JSON.stringify(event.payload));
+      this.bytesUpTo.push(bytes);
+    }
+    this.historyLength = history.length;
+    this.historyBytes = bytes;
+    const limit = input.request.info.historyLimit ?? DEFAULT_HISTORY_LIMIT;
+    this.limitEvents = limit.events;
+    this.limitBytes = limit.bytes;
+    this.captureStacks = input.request.kind === "query";
+    this.random = createRandom(seedOf(randomnessSeedOf(input.request)));
+    for (const event of history) {
+      if (event.type === "SIDE_EFFECT_RECORDED") {
+        const id = event.payload["sideEffectId"];
+        if (typeof id === "string")
+          this.recordedSideEffects.set(id, event.payload["value"] ?? null);
+      } else if (event.type === "MARKER_RECORDED") {
+        const id = event.payload["markerId"];
+        if (typeof id === "string") this.recordedMarkers.add(id);
+      }
+    }
+    this.activations = splitActivations(
+      history,
+      input.request.nowMs,
+      input.request.kind !== "query"
+    );
+    const execution = this;
+    this.info = {
+      ...input.request.info,
+      workflowFn: input.request.workflowFn,
+      get historyLength() {
+        return execution.historyLength;
+      },
+      get historyBytes() {
+        return execution.historyBytes;
+      },
+      get continueAsNewSuggested() {
+        return execution.continueAsNewSuggested();
+      },
+      get isReplaying() {
+        return execution.replaying;
+      }
+    };
+    this.context = this.contextFor(void 0);
+  }
+  continueAsNewSuggested() {
+    return this.historyLength >= this.limitEvents * CONTINUE_AS_NEW_SUGGESTED_RATIO || this.historyBytes >= this.limitBytes * CONTINUE_AS_NEW_SUGGESTED_RATIO;
+  }
+  /** The workflow clock. */
+  now() {
+    return this.clock;
+  }
+  /** The next deterministic random number. */
+  nextRandom() {
+    return this.random();
+  }
+  /** Begin or finish an activation; `done` when there is nothing left to do. */
+  step() {
+    if (this.failure) return "done";
+    if (this.activationOpen) {
+      if (this.checkConditions()) return "more";
+      this.finishActivation();
+      if (this.failure) return "done";
+    }
+    const next = this.activations[this.index + 1];
+    if (!next) return "done";
+    this.index += 1;
+    this.beginActivation(next);
+    return this.failure ? "done" : "more";
+  }
+  /** The task's result. Call after `step()` returned `done` and jobs were drained. */
+  complete() {
+    if (!this.failure && this.activationOpen) {
+      this.checkConditions();
+      this.finishActivation();
+    }
+    const result = {
+      protocol: HISTORY_PROTOCOL,
+      outcome: this.failure ? "failed" : "commands",
+      commands: this.failure ? [] : this.newCommands,
+      logs: this.logs
+    };
+    if (this.failure) {
+      result.failure = { cause: this.failure.cause, message: this.failure.message };
+      if (this.failure.stackTrace !== void 0)
+        result.failure.stackTrace = this.failure.stackTrace;
+      if (this.failure.seq !== void 0) result.failure.seq = this.failure.seq;
+      if (this.failure.errorType !== void 0) result.failure.errorType = this.failure.errorType;
+    }
+    if (this.request.kind === "query") result.queryResults = this.answerQueries();
+    return result;
+  }
+  /** Fail the task (the runtime's own failures and code errors). */
+  failTask(cause, message, stackTrace, seq, errorType) {
+    if (!this.failure) this.failure = new TaskFailure(cause, message, stackTrace, seq, errorType);
+  }
+  beginActivation(activation) {
+    this.activationOpen = true;
+    this.replaying = activation.recorded !== void 0;
+    this.clock = activation.timeMs;
+    this.historyLength = activation.historyLength;
+    this.historyBytes = this.bytesUpTo[Math.min(activation.historyLength, this.bytesUpTo.length - 1)] ?? 0;
+    this.commands = [];
+    for (const event of activation.inputs) {
+      if (this.failure) return;
+      this.deliver(event);
+    }
+  }
+  finishActivation() {
+    this.activationOpen = false;
+    const activation = this.activations[this.index];
+    if (!activation) return;
+    if (activation.recorded) {
+      const found = matchActivation(this.commands, activation.recorded);
+      if (found)
+        this.failTask(
+          "NON_DETERMINISM",
+          `Replay of workflow task ${activation.taskId ?? this.index + 1} diverged: ${found.message}`,
+          void 0,
+          found.seq
+        );
+    } else {
+      this.newCommands = this.commands;
+    }
+    this.commands = [];
+  }
+  // ---- inputs ---------------------------------------------------------------
+  deliver(event) {
+    const p = event.payload;
+    const id = (key) => typeof p[key] === "string" ? p[key] : "";
+    switch (event.type) {
+      case "WORKFLOW_STARTED":
+        this.startFunction(p["input"] ?? null);
+        return;
+      case "ACTIVITY_COMPLETED":
+      case "ACTIVITY_FAILED":
+      case "ACTIVITY_TIMED_OUT":
+      case "ACTIVITY_CANCELLED":
+        this.settleActivity(event, id("activityId"));
+        return;
+      case "TIMER_FIRED": {
+        const timerId = id("timerId");
+        this.expectIssued(`timer:${timerId}`, event);
+        const pending = this.timers.get(timerId);
+        if (pending) {
+          this.timers.delete(timerId);
+          pending.release?.();
+          pending.resolve(void 0);
+        }
+        return;
+      }
+      case "SIGNAL_RECEIVED":
+        this.dispatchSignal(id("name"), p["payload"] ?? null);
+        return;
+      case "CHILD_RUN_STARTED":
+      case "CHILD_RUN_COMPLETED":
+      case "CHILD_RUN_FAILED":
+      case "CHILD_RUN_CANCELLED":
+      case "CHILD_RUN_TERMINATED":
+      case "CHILD_RUN_TIMED_OUT":
+        this.settleChild(event, id("childId"));
+        return;
+      case "EXTERNAL_RUN_SIGNALED":
+      case "EXTERNAL_RUN_CANCEL_RESOLVED": {
+        const externalId = id("externalId");
+        this.expectIssued(`external:${externalId}`, event);
+        const pending = this.externals.get(externalId);
+        if (!pending) return;
+        this.externals.delete(externalId);
+        if (p["ok"] === true) pending.resolve(void 0);
+        else {
+          const failure = p["failure"];
+          pending.reject(
+            typeof failure === "object" && failure !== null && !Array.isArray(failure) ? failureToError(failure) : new ServerFailure(`${pending.description} was not delivered`)
+          );
+        }
+        return;
+      }
+      case "WORKFLOW_CANCEL_REQUESTED":
+        this.cancelRequested = true;
+        this.root.cancel();
+        return;
+      default:
+        return;
+    }
+  }
+  expectIssued(key, event) {
+    if (!this.issued.has(key))
+      this.failTask(
+        "NON_DETERMINISM",
+        `The history has ${event.type} (seq ${event.seq}) for ${key}, which the code never issued`,
+        void 0,
+        event.seq
+      );
+  }
+  settleActivity(event, activityId) {
+    this.expectIssued(`activity:${activityId}`, event);
+    const pending = this.activities.get(activityId);
+    if (!pending) return;
+    this.activities.delete(activityId);
+    pending.release?.();
+    const p = event.payload;
+    const failure = typeof p["failure"] === "object" && p["failure"] !== null && !Array.isArray(p["failure"]) ? p["failure"] : void 0;
+    const wrap = (cause) => new ActivityFailure(
+      `Activity ${activityId} (${pending.nodeType} ${pending.operation}) failed: ${cause.message}`,
+      activityId,
+      pending.nodeType,
+      pending.operation,
+      cause
+    );
+    switch (event.type) {
+      case "ACTIVITY_COMPLETED":
+        pending.resolve(p["result"] ?? null);
+        return;
+      case "ACTIVITY_FAILED":
+        pending.reject(
+          wrap(
+            failure ? failureToError(failure) : new ApplicationError("Activity failed", { errorType: "UNKNOWN" })
+          )
+        );
+        return;
+      case "ACTIVITY_TIMED_OUT": {
+        const timeoutType = typeof p["timeoutType"] === "string" ? p["timeoutType"] : "UNKNOWN";
+        pending.reject(
+          wrap(new TimeoutFailure(`Activity timed out (${timeoutType})`, timeoutType))
+        );
+        return;
+      }
+      default:
+        pending.reject(wrap(new CancelledFailure("Activity cancelled")));
+    }
+  }
+  settleChild(event, childId) {
+    this.expectIssued(`child:${childId}`, event);
+    const child = this.children.get(childId);
+    if (!child) return;
+    const p = event.payload;
+    if (typeof p["childRunId"] === "string") child.runId = p["childRunId"];
+    if (event.type === "CHILD_RUN_STARTED") {
+      const started2 = child.started;
+      child.started = void 0;
+      started2?.resolve(child.runId);
+      return;
+    }
+    let outcome;
+    const failureValue = p["failure"];
+    const failure = typeof failureValue === "object" && failureValue !== null && !Array.isArray(failureValue) ? failureValue : void 0;
+    const wrap = (cause) => new ChildRunFailure(
+      `Child run ${childId} ${event.type.slice("CHILD_RUN_".length).toLowerCase().replace("_", " ")}: ${cause.message}`,
+      childId,
+      child.runId,
+      cause
+    );
+    switch (event.type) {
+      case "CHILD_RUN_COMPLETED":
+        outcome = { ok: true, value: p["result"] ?? null };
+        break;
+      case "CHILD_RUN_FAILED":
+        outcome = {
+          ok: false,
+          error: wrap(
+            failure ? failureToError(failure) : new ApplicationError("Child failed", { errorType: "UNKNOWN" })
+          )
+        };
+        break;
+      case "CHILD_RUN_CANCELLED":
+        outcome = { ok: false, error: wrap(new CancelledFailure("Child run cancelled")) };
+        break;
+      case "CHILD_RUN_TERMINATED":
+        outcome = {
+          ok: false,
+          error: wrap(
+            new TerminatedFailure(typeof p["reason"] === "string" ? p["reason"] : "Terminated")
+          )
+        };
+        break;
+      default: {
+        const timeoutType = typeof p["timeoutType"] === "string" ? p["timeoutType"] : "WORKFLOW_RUN";
+        outcome = {
+          ok: false,
+          error: wrap(new TimeoutFailure(`Child run timed out (${timeoutType})`, timeoutType))
+        };
+      }
+    }
+    child.settled = true;
+    child.outcome = outcome;
+    const started = child.started;
+    child.started = void 0;
+    if (started) {
+      if (outcome.ok) started.resolve(child.runId);
+      else started.reject(outcome.error);
+    }
+    const result = child.result;
+    child.result = void 0;
+    if (result) {
+      result.release?.();
+      if (outcome.ok) result.resolve(outcome.value);
+      else result.reject(outcome.error);
+    }
+  }
+  dispatchSignal(name, payload) {
+    const handler = this.signalHandlers.get(name);
+    if (handler) {
+      this.runHandler(() => handler(payload));
+      return;
+    }
+    const waiters = this.signalWaiters.get(name);
+    const waiter = waiters?.shift();
+    if (waiter) {
+      waiter.release?.();
+      waiter.resolve(payload);
+      return;
+    }
+    if (this.defaultSignalHandler) {
+      const fallback = this.defaultSignalHandler;
+      this.runHandler(() => fallback(name, payload));
+      return;
+    }
+    const buffer = this.signalBuffers.get(name) ?? [];
+    buffer.push(payload);
+    this.signalBuffers.set(name, buffer);
+    this.signalOrder.push({ name, payload });
+  }
+  takeBuffered(name) {
+    const buffer = this.signalBuffers.get(name);
+    if (!buffer || buffer.length === 0) return void 0;
+    const payload = buffer.shift();
+    const position = this.signalOrder.findIndex((entry) => entry.name === name);
+    if (position >= 0) this.signalOrder.splice(position, 1);
+    return payload;
+  }
+  runHandler(call) {
+    let result;
+    try {
+      result = call();
+    } catch (error) {
+      this.onWorkflowError(error);
+      return;
+    }
+    if (result instanceof Promise) {
+      this.runningHandlers += 1;
+      result.then(
+        () => {
+          this.runningHandlers -= 1;
+        },
+        (error) => {
+          this.runningHandlers -= 1;
+          this.onWorkflowError(error);
+        }
+      );
+    }
+  }
+  // ---- the workflow function ------------------------------------------------
+  startFunction(input) {
+    let promise;
+    try {
+      promise = Promise.resolve(this.definition.fn(this.context, input));
+    } catch (error) {
+      promise = Promise.reject(error);
+    }
+    promise.then(
+      (value) => this.onReturn(value),
+      (error) => this.onWorkflowError(error)
+    );
+  }
+  onReturn(value) {
+    if (this.closed || this.failure) return;
+    let output;
+    try {
+      output = toJson(value, "The workflow output");
+    } catch (error) {
+      if (error instanceof TypeError)
+        this.failTask("WORKFLOW_CODE_ERROR", messageOf(error), stackTextOf(error));
+      else this.onWorkflowError(error);
+      return;
+    }
+    this.pushTerminal({ type: "COMPLETE_WORKFLOW", output });
+  }
+  isFailureType(error) {
+    const listed = this.definition.options.failureErrorTypes ?? [];
+    return listed.some((type) => error instanceof type);
+  }
+  /** What an error thrown out of workflow code does (11 §2.25, §2.37). */
+  onWorkflowError(error) {
+    if (this.closed || this.failure) return;
+    if (error instanceof ContinueAsNewRequest) {
+      this.pushTerminal({ type: "CONTINUE_AS_NEW", input: error.input, options: error.options });
+      return;
+    }
+    const name = errorName(error);
+    if (error instanceof DeterminismViolation || name === "DeterminismViolation") {
+      this.failTask("NON_DETERMINISM", messageOf(error), stackTextOf(error), void 0, name);
+      return;
+    }
+    if (error instanceof HistoryLimitExceeded) {
+      this.failTask("HISTORY_LIMIT", messageOf(error), stackTextOf(error));
+      return;
+    }
+    if (name === "InternalError" && /out of memory/i.test(messageOf(error))) {
+      this.failTask("ISOLATE_MEMORY", messageOf(error), stackTextOf(error), void 0, name);
+      return;
+    }
+    if (error instanceof PhaseCFeatureError) {
+      this.failTask("UNSUPPORTED_COMMAND", messageOf(error), stackTextOf(error));
+      return;
+    }
+    if (this.cancelRequested && isCancellation(error)) {
+      this.pushTerminal({ type: "CANCEL_WORKFLOW" });
+      return;
+    }
+    if (isRunFailure(error) || this.isFailureType(error)) {
+      this.pushTerminal({ type: "FAIL_WORKFLOW", failure: errorToFailure(error) });
+      return;
+    }
+    this.failTask(
+      "WORKFLOW_CODE_ERROR",
+      `${name || "Error"}: ${messageOf(error)}`,
+      stackTextOf(error),
+      void 0,
+      name || void 0
+    );
+  }
+  // ---- commands -------------------------------------------------------------
+  currentScope() {
+    return this.syncScopes[this.syncScopes.length - 1] ?? this.root;
+  }
+  /**
+   * Throw `HistoryLimitExceeded` from 95 % of the cap. It runs on replay too:
+   * the history length is the activation's cutoff and the command count is
+   * the activation's own, so replay sees what the first execution saw.
+   */
+  checkLimit() {
+    const events = this.historyLength + this.commands.length;
+    if (events >= this.limitEvents * HISTORY_LIMIT_EXCEEDED_RATIO || this.historyBytes >= this.limitBytes * HISTORY_LIMIT_EXCEEDED_RATIO)
+      throw new HistoryLimitExceeded(
+        `The history has ${events} events and ${this.historyBytes} bytes, past 95 % of its limit (${this.limitEvents} events, ${this.limitBytes} bytes); continue as new`
+      );
+  }
+  /** Issue a command; false when the run is already closed (the command is dropped). */
+  push(command) {
+    if (this.closed || this.failure) return false;
+    this.checkLimit();
+    this.commands.push(command);
+    return true;
+  }
+  pushTerminal(command) {
+    if (this.closed || this.failure) return;
+    this.commands.push(command);
+    this.closed = true;
+  }
+  stack() {
+    return this.captureStacks ? captureStack() : void 0;
+  }
+  never() {
+    return new Promise(() => void 0);
+  }
+  scheduleActivity(scope, operation, options) {
+    if (typeof operation !== "object" || operation === null || typeof operation.nodeType !== "string")
+      throw new TypeError("ctx.run needs a node operation (from nodes.* or the generated clients)");
+    if (operation.role === "trigger" || !isActivityNodeTypeAllowed(operation.nodeType))
+      throw new ApplicationError(
+        `${operation.nodeType} cannot run as a durable activity: only store and registry nodes and internal:http, internal:datatable, internal:set and internal:code can`,
+        { type: "durable.activityTypeNotAllowed", errorType: "VALIDATION", nonRetryable: true }
+      );
+    const activityId = this.ids.next("a");
+    const operationName = options.operation ?? operation.operation ?? "execute";
+    const nodeVersion = options.nodeVersion ?? operation.version;
+    const cancellationType = options.cancellationType ?? "WAIT_CANCELLATION_COMPLETED";
+    const command = {
+      type: "SCHEDULE_ACTIVITY",
+      activityId,
+      kind: "node",
+      nodeType: operation.nodeType,
+      operation: operationName,
+      args: toJson(options.args, `The args of ${operation.nodeType}`),
+      retry: explicitRetryPolicy(options.retry)
+    };
+    if (nodeVersion !== void 0) command.nodeVersion = nodeVersion;
+    if (options.connection !== void 0) command.connection = options.connection;
+    const startToClose = optionalMs(options.startToCloseTimeout, "startToCloseTimeout");
+    const scheduleToClose = optionalMs(options.scheduleToCloseTimeout, "scheduleToCloseTimeout");
+    const scheduleToStart = optionalMs(options.scheduleToStartTimeout, "scheduleToStartTimeout");
+    const heartbeat = optionalMs(options.heartbeatTimeout, "heartbeatTimeout");
+    if (startToClose !== void 0) command.startToCloseTimeout = startToClose;
+    if (scheduleToClose !== void 0) command.scheduleToCloseTimeout = scheduleToClose;
+    if (scheduleToStart !== void 0) command.scheduleToStartTimeout = scheduleToStart;
+    if (heartbeat !== void 0) command.heartbeatTimeout = heartbeat;
+    if (options.cancellationType !== void 0) command.cancellationType = options.cancellationType;
+    if (options.priority !== void 0) command.priority = options.priority;
+    if (options.summary !== void 0) command.summary = options.summary;
+    if (options.runOn !== void 0) command.runOn = options.runOn;
+    if (options.headers !== void 0) command.headers = { ...options.headers };
+    if (scope.consideredCancelled)
+      return Promise.reject(new CancelledFailure("Scope is cancelled"));
+    if (!this.push(command)) return this.never();
+    this.issued.add(`activity:${activityId}`);
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: `activity ${activityId} (${operation.nodeType} ${operationName})`,
+        nodeType: operation.nodeType,
+        operation: operationName,
+        cancellationType
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      entry.release = scope.onCancel(() => {
+        if (!this.activities.has(activityId)) return;
+        const cancelled = new ActivityFailure(
+          `Activity ${activityId} cancelled`,
+          activityId,
+          entry.nodeType,
+          entry.operation,
+          new CancelledFailure("Activity cancelled")
+        );
+        if (cancellationType !== "ABANDON")
+          this.push({ type: "REQUEST_CANCEL_ACTIVITY", activityId });
+        if (cancellationType !== "WAIT_CANCELLATION_COMPLETED") {
+          this.activities.delete(activityId);
+          reject(cancelled);
+        }
+      });
+      this.activities.set(activityId, entry);
+    });
+  }
+  startTimer(scope, durationMs, summary) {
+    return this.timer(scope, durationMs, summary).promise;
+  }
+  /** Start a durable timer; `timerId` is undefined when no timer was needed or issued. */
+  timer(scope, durationMs, summary) {
+    if (durationMs <= 0) return { promise: Promise.resolve() };
+    if (scope.consideredCancelled)
+      return { promise: Promise.reject(new CancelledFailure("Scope is cancelled")) };
+    const timerId = this.ids.next("t");
+    const command = {
+      type: "START_TIMER",
+      timerId,
+      durationMs: Math.max(1, Math.round(durationMs))
+    };
+    if (summary !== void 0) command.summary = summary;
+    if (!this.push(command)) return { promise: this.never() };
+    this.issued.add(`timer:${timerId}`);
+    const promise = new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: `timer ${timerId} (${durationMs} ms)`
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      entry.release = scope.onCancel(() => {
+        if (!this.timers.has(timerId)) return;
+        this.timers.delete(timerId);
+        this.push({ type: "CANCEL_TIMER", timerId });
+        reject(new CancelledFailure("Timer cancelled"));
+      });
+      this.timers.set(timerId, entry);
+    });
+    return { promise, timerId };
+  }
+  /** Cancel a pending timer the runtime started for itself (condition and scope timeouts). */
+  cancelOwnTimer(timerId) {
+    if (timerId === void 0) return;
+    const pending = this.timers.get(timerId);
+    if (!pending) return;
+    this.timers.delete(timerId);
+    pending.release?.();
+    this.push({ type: "CANCEL_TIMER", timerId });
+  }
+  condition(scope, predicate, timeout) {
+    if (predicate()) return Promise.resolve(true);
+    if (scope.consideredCancelled)
+      return Promise.reject(new CancelledFailure("Scope is cancelled"));
+    return new Promise((resolve, reject) => {
+      const condition = { predicate, resolve, reject };
+      const stack = this.stack();
+      if (stack !== void 0) condition.stack = stack;
+      this.conditions.push(condition);
+      if (timeout !== void 0) {
+        const timer = this.timer(scope, toMs(timeout, "condition timeout"), void 0);
+        if (timer.timerId !== void 0) condition.timerId = timer.timerId;
+        timer.promise.then(
+          () => {
+            if (!this.conditions.includes(condition)) return;
+            this.conditions = this.conditions.filter((entry) => entry !== condition);
+            condition.release?.();
+            resolve(false);
+          },
+          () => void 0
+        );
+      }
+      condition.release = scope.onCancel(() => {
+        if (!this.conditions.includes(condition)) return;
+        this.conditions = this.conditions.filter((entry) => entry !== condition);
+        this.cancelOwnTimer(condition.timerId);
+        reject(new CancelledFailure("Condition cancelled"));
+      });
+    });
+  }
+  /** Resolve conditions whose predicate now holds; true when any did. */
+  checkConditions() {
+    let fired = false;
+    for (const condition of [...this.conditions]) {
+      let holds = false;
+      try {
+        holds = condition.predicate();
+      } catch (error) {
+        this.conditions = this.conditions.filter((entry) => entry !== condition);
+        condition.release?.();
+        condition.reject(error);
+        fired = true;
+        continue;
+      }
+      if (!holds) continue;
+      this.conditions = this.conditions.filter((entry) => entry !== condition);
+      condition.release?.();
+      this.cancelOwnTimer(condition.timerId);
+      condition.resolve(true);
+      fired = true;
+    }
+    return fired;
+  }
+  signalReceived(scope, signal) {
+    const name = signalName(signal);
+    const buffered = this.takeBuffered(name);
+    if (buffered !== void 0) return Promise.resolve(buffered);
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: `signal ${name}`
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      const waiters = this.signalWaiters.get(name) ?? [];
+      waiters.push(entry);
+      this.signalWaiters.set(name, waiters);
+      entry.release = scope.onCancel(() => {
+        const list = this.signalWaiters.get(name) ?? [];
+        const position = list.indexOf(entry);
+        if (position < 0) return;
+        list.splice(position, 1);
+        reject(new CancelledFailure("Signal wait cancelled"));
+      });
+    });
+  }
+  onSignal(signal, handler) {
+    const name = signalName(signal);
+    this.signalHandlers.set(name, handler);
+    let payload = this.takeBuffered(name);
+    while (payload !== void 0) {
+      const value = payload;
+      this.runHandler(() => handler(value));
+      payload = this.takeBuffered(name);
+    }
+  }
+  setDefaultSignalHandler(handler) {
+    this.defaultSignalHandler = handler;
+    const buffered = [...this.signalOrder];
+    for (const entry of buffered) {
+      if (this.signalHandlers.has(entry.name)) continue;
+      const payload = this.takeBuffered(entry.name);
+      if (payload !== void 0) this.runHandler(() => handler(entry.name, payload));
+    }
+  }
+  childTarget(target) {
+    if (typeof target === "string") {
+      if (target === "") throw new TypeError("ctx.child needs a workflow key or function");
+      return { workflowKey: target };
+    }
+    if (isDurableWorkflow(target)) {
+      const exportName = this.exportNames.get(target);
+      if (exportName === void 0)
+        throw new TypeError(
+          `workflow("${target.name}") is not exported by any module of this bundle; export it to start it as a child (in the test environment, pass it in \`workflows\`)`
+        );
+      return { workflowFn: exportName };
+    }
+    throw new TypeError("ctx.child needs a workflow key or a workflow() function");
+  }
+  childCommand(childId, target, options, defaultPolicy) {
+    const opts = { parentClosePolicy: options.parentClosePolicy ?? defaultPolicy };
+    if (options.cancellationType !== void 0) opts["cancellationType"] = options.cancellationType;
+    if (options.taskQueue !== void 0) opts["taskQueue"] = options.taskQueue;
+    if (options.workflowId !== void 0) opts["workflowId"] = options.workflowId;
+    if (options.priority !== void 0) opts["priority"] = options.priority;
+    if (options.summary !== void 0) opts["summary"] = options.summary;
+    if (options.details !== void 0) opts["details"] = options.details;
+    if (options.context !== void 0)
+      opts["context"] = toJson(options.context, "The child context");
+    const durations = [
+      ["startDelay", "startDelay"],
+      ["executionTimeout", "executionTimeout"],
+      ["runTimeout", "runTimeout"],
+      ["workflowTaskTimeout", "workflowTaskTimeout"]
+    ];
+    for (const [key, name] of durations) {
+      const value = options[key];
+      if (value !== void 0 && (typeof value === "number" || typeof value === "string"))
+        opts[name] = toMs(value, name);
+    }
+    const command = {
+      type: "START_CHILD_RUN",
+      childId,
+      ...this.childTarget(target),
+      input: toJson(options.input, "The child input"),
+      options: {
+        parentClosePolicy: opts["parentClosePolicy"] === "ABANDON" ? "ABANDON" : opts["parentClosePolicy"] === "REQUEST_CANCEL" ? "REQUEST_CANCEL" : "TERMINATE",
+        ...opts
+      }
+    };
+    if (options.version !== void 0) command.version = options.version;
+    if (options.headers !== void 0) command.headers = { ...options.headers };
+    return command;
+  }
+  startChildRun(scope, target, options, defaultPolicy) {
+    if (scope.consideredCancelled) return void 0;
+    const childId = this.ids.next("c");
+    const command = this.childCommand(childId, target, options, defaultPolicy);
+    if (!this.push(command)) return void 0;
+    this.issued.add(`child:${childId}`);
+    const child = { childId, settled: false, scope };
+    if (options.cancellationType !== void 0) child.cancellationType = options.cancellationType;
+    this.children.set(childId, child);
+    return child;
+  }
+  /** What cancelling the scope of a child's awaitable does (see `ChildOptions.cancellationType`). */
+  onChildCancel(child, entry) {
+    return () => {
+      if (child.settled) return;
+      const type = child.cancellationType ?? CHILD_DEFAULT_CANCELLATION_TYPE;
+      const error = new ChildRunFailure(
+        `Child run ${child.childId} cancelled`,
+        child.childId,
+        child.runId,
+        new CancelledFailure("Child run cancelled")
+      );
+      if (type === "ABANDON") {
+        child.result = void 0;
+        entry.reject(error);
+        return;
+      }
+      const externalId = this.ids.next("x");
+      if (this.push({
+        type: "REQUEST_CANCEL_EXTERNAL_RUN",
+        externalId,
+        target: { childId: child.childId }
+      })) {
+        this.issued.add(`external:${externalId}`);
+        if (type === "WAIT_CANCELLATION_REQUESTED") {
+          this.externals.set(externalId, {
+            resolve: () => {
+              child.result = void 0;
+              entry.reject(error);
+            },
+            reject: () => {
+              child.result = void 0;
+              entry.reject(error);
+            },
+            description: `cancel of child ${child.childId}`
+          });
+        } else {
+          this.externals.set(externalId, {
+            resolve: () => void 0,
+            reject: () => void 0,
+            description: `cancel of child ${child.childId}`
+          });
+        }
+      }
+      if (type === "TRY_CANCEL") {
+        child.result = void 0;
+        entry.reject(error);
+      }
+    };
+  }
+  child(scope, target, options) {
+    const child = this.startChildRun(
+      scope,
+      target,
+      options,
+      CHILD_DEFAULT_PARENT_CLOSE_POLICY.child
+    );
+    if (!child)
+      return scope.consideredCancelled ? Promise.reject(new CancelledFailure("Scope is cancelled")) : this.never();
+    return this.childResult(child);
+  }
+  childResult(child) {
+    if (child.settled && child.outcome) {
+      const outcome = child.outcome;
+      return outcome.ok ? Promise.resolve(outcome.value) : Promise.reject(outcome.error);
+    }
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: `child run ${child.childId}`
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      entry.release = child.scope.onCancel(this.onChildCancel(child, entry));
+      child.result = entry;
+    });
+  }
+  startChild(scope, target, options) {
+    const child = this.startChildRun(
+      scope,
+      target,
+      options,
+      CHILD_DEFAULT_PARENT_CLOSE_POLICY.startChild
+    );
+    if (!child)
+      return scope.consideredCancelled ? Promise.reject(new CancelledFailure("Scope is cancelled")) : this.never();
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: `start of child run ${child.childId}`
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      child.started = entry;
+    }).then((runId) => {
+      const handle = {
+        childId: child.childId,
+        runId: runId ?? child.runId ?? "",
+        result: () => this.childResult(child),
+        signal: (signal, payload) => this.signalExternal({ childId: child.childId }, signalName(signal), payload),
+        cancel: () => this.cancelExternal({ childId: child.childId })
+      };
+      return handle;
+    });
+  }
+  signalExternal(target, name, payload) {
+    const externalId = this.ids.next("x");
+    const command = {
+      type: "SIGNAL_RUN",
+      externalId,
+      target,
+      name,
+      payload: toJson(payload, `The payload of signal ${name}`)
+    };
+    if (!this.push(command)) return this.never();
+    this.issued.add(`external:${externalId}`);
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: `signal ${name}`
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      this.externals.set(externalId, entry);
+    });
+  }
+  cancelExternal(target) {
+    const externalId = this.ids.next("x");
+    if (!this.push({ type: "REQUEST_CANCEL_EXTERNAL_RUN", externalId, target }))
+      return this.never();
+    this.issued.add(`external:${externalId}`);
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: `cancel request ${externalId}`
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      this.externals.set(externalId, entry);
+    });
+  }
+  sideEffect(fn) {
+    const sideEffectId = this.ids.next("s");
+    let value;
+    if (this.replaying && this.recordedSideEffects.has(sideEffectId)) {
+      value = this.recordedSideEffects.get(sideEffectId) ?? null;
+    } else {
+      value = toJson(fn(), "The side effect value");
+    }
+    this.push({ type: "RECORD_SIDE_EFFECT", sideEffectId, value });
+    return toJson(value, "The side effect value");
+  }
+  patched(patchId, deprecated) {
+    if (typeof patchId !== "string" || patchId === "") throw new TypeError("A patch needs an id");
+    const known = this.patches.get(patchId);
+    if (known !== void 0) return known;
+    const markerId = patchMarkerId(patchId);
+    let result;
+    if (this.replaying) {
+      result = this.recordedMarkers.has(markerId);
+      if (result)
+        this.push({
+          type: "RECORD_MARKER",
+          markerId,
+          data: { patchId, ...deprecated ? { deprecated: true } : {} }
+        });
+    } else {
+      result = true;
+      if (!this.recordedMarkers.has(markerId)) {
+        this.push({
+          type: "RECORD_MARKER",
+          markerId,
+          data: { patchId, ...deprecated ? { deprecated: true } : {} }
+        });
+        this.recordedMarkers.add(markerId);
+      }
+    }
+    this.patches.set(patchId, result);
+    return result;
+  }
+  setCurrentDetails(markdown) {
+    if (typeof markdown !== "string") throw new TypeError("setCurrentDetails takes Markdown text");
+    this.currentDetails = markdown;
+    this.push({
+      type: "RECORD_MARKER",
+      markerId: this.ids.next("m"),
+      data: { currentDetails: markdown }
+    });
+  }
+  upsertContext(entries) {
+    this.push({
+      type: "UPSERT_CONTEXT",
+      entries: toJson(entries, "The context entries")
+    });
+  }
+  /** The request a `ctx.continueAsNew` call throws; the run ends with `CONTINUE_AS_NEW`. */
+  continueAsNew(input, options) {
+    const opts = {};
+    if (options.taskQueue !== void 0) opts["taskQueue"] = options.taskQueue;
+    if (options.retry !== void 0)
+      opts["retry"] = toJson(explicitRetryPolicy(options.retry), "retry");
+    if (options.workflowTaskTimeout !== void 0)
+      opts["workflowTaskTimeout"] = toMs(options.workflowTaskTimeout, "workflowTaskTimeout");
+    if (options.context !== void 0) opts["context"] = toJson(options.context, "context");
+    if (options.versioningBehavior !== void 0)
+      opts["versioningBehavior"] = options.versioningBehavior;
+    return new ContinueAsNewRequest(toJson(input, "The continue-as-new input"), opts);
+  }
+  async cancellationScope(parent, fn, options) {
+    const scope = new Scope(parent, options.nonCancellable === true);
+    let timerId;
+    if (options.timeout !== void 0) {
+      const timer = this.timer(parent, toMs(options.timeout, "scope timeout"), void 0);
+      timerId = timer.timerId;
+      timer.promise.then(
+        () => scope.cancel(),
+        () => void 0
+      );
+    }
+    this.syncScopes.push(scope);
+    let promise;
+    try {
+      promise = Promise.resolve(fn(this.contextFor(scope)));
+    } catch (error) {
+      promise = Promise.reject(error);
+    } finally {
+      this.syncScopes.pop();
+    }
+    try {
+      return await promise;
+    } finally {
+      scope.detach();
+      if (timerId !== void 0 && this.timers.has(timerId)) this.cancelOwnTimer(timerId);
+    }
+  }
+  /** Waits for the signal handlers regardless of cancellation, as Temporal does. */
+  allHandlersFinished() {
+    return this.condition(this.detachedScope, () => this.runningHandlers === 0, void 0).then(
+      () => void 0
+    );
+  }
+  // ---- queries --------------------------------------------------------------
+  pendingStacks() {
+    const out = [];
+    const add = (entry, fallback) => {
+      if (!entry) return;
+      out.push({ description: entry.description ?? fallback, stack: entry.stack ?? "" });
+    };
+    for (const entry of this.activities.values()) add(entry, "activity");
+    for (const entry of this.timers.values()) add(entry, "timer");
+    for (const child of this.children.values()) {
+      add(child.started, "child start");
+      add(child.result, "child result");
+    }
+    for (const entry of this.externals.values()) add(entry, "external");
+    for (const list of this.signalWaiters.values()) for (const entry of list) add(entry, "signal");
+    for (const condition of this.conditions)
+      add(
+        {
+          description: "condition",
+          ...condition.stack !== void 0 ? { stack: condition.stack } : {}
+        },
+        "condition"
+      );
+    return out;
+  }
+  answerQueries() {
+    return (this.request.queries ?? []).map((query) => {
+      if (!BUILT_IN_QUERIES.includes(query.name))
+        return {
+          queryId: query.queryId,
+          error: `Unknown query ${String(query.name)}; custom queries are Phase C`
+        };
+      if (this.failure)
+        return { queryId: query.queryId, error: `The replay failed: ${this.failure.message}` };
+      if (query.name === "__stack_trace")
+        return {
+          queryId: query.queryId,
+          value: this.pendingStacks().map((entry) => `${entry.description}
+${entry.stack}`).join("\n\n")
+        };
+      if (query.name === "__enhanced_stack_trace")
+        return {
+          queryId: query.queryId,
+          value: {
+            sdk: { name: SDK_NAME, version: this.sdkVersion },
+            stacks: this.pendingStacks().map((entry) => ({
+              description: entry.description,
+              locations: parseStack(entry.stack).map((location) => {
+                const out = {};
+                if (location.filePath !== void 0) out["filePath"] = location.filePath;
+                if (location.line !== void 0) out["line"] = location.line;
+                if (location.column !== void 0) out["column"] = location.column;
+                if (location.functionName !== void 0)
+                  out["functionName"] = location.functionName;
+                return out;
+              })
+            }))
+          }
+        };
+      const options = this.definition.options;
+      const describe = (items) => (items ?? []).map((item) => ({ name: item.name, description: item.description ?? null }));
+      return {
+        queryId: query.queryId,
+        value: {
+          definition: {
+            name: this.definition.name,
+            signals: describe(options.signals),
+            queries: describe(options.queries),
+            updates: describe(options.updates)
+          },
+          currentDetails: this.currentDetails ?? null
+        }
+      };
+    });
+  }
+  // ---- the context ----------------------------------------------------------
+  contextFor(bound) {
+    const scope = () => bound ?? this.currentScope();
+    const log = (level) => (message, data) => {
+      if (this.replaying) return;
+      const line = { level, message: String(message) };
+      if (data !== void 0) line.data = toJson(data, "The log data");
+      this.logs.push(line);
+    };
+    const logger = {
+      debug: log("debug"),
+      info: log("info"),
+      warn: log("warn"),
+      error: log("error")
+    };
+    const scopeFn = ((fn, options = {}) => this.cancellationScope(scope(), fn, options));
+    scopeFn.current = () => scope();
+    const phaseC = (feature) => () => {
+      throw new PhaseCFeatureError(feature);
+    };
+    const context = {
+      info: this.info,
+      log: logger,
+      run: (operation, options) => this.scheduleActivity(scope(), operation, options),
+      sleep: (duration, options = {}) => this.startTimer(scope(), toMs(duration, "sleep duration"), options.summary),
+      condition: (predicate, timeout) => this.condition(scope(), predicate, timeout),
+      signalReceived: (signal) => this.signalReceived(scope(), signal),
+      onSignal: (signal, handler) => this.onSignal(signal, handler),
+      setDefaultSignalHandler: (handler) => this.setDefaultSignalHandler(handler),
+      child: (target, options = {}) => this.child(scope(), target, options),
+      startChild: (target, options = {}) => this.startChild(scope(), target, options),
+      signalRun: (runId, signal, payload) => this.signalExternal({ runId }, signalName(signal), payload),
+      signalParent: (signal, payload) => this.signalExternal({ parent: true }, signalName(signal), payload),
+      getRunHandle: (runId) => ({
+        runId,
+        signal: (signal, payload) => this.signalExternal({ runId }, signalName(signal), payload),
+        cancel: () => this.cancelExternal({ runId })
+      }),
+      cancelRun: (runId) => this.cancelExternal({ runId }),
+      now: () => this.clock,
+      random: () => this.random(),
+      uuid: () => uuidFrom(this.random),
+      sideEffect: (fn) => this.sideEffect(fn),
+      patched: (patchId) => this.patched(patchId, false),
+      deprecatePatch: (patchId) => {
+        this.patched(patchId, true);
+      },
+      setCurrentDetails: (markdown) => this.setCurrentDetails(markdown),
+      upsertContext: (entries) => this.upsertContext(entries),
+      continueAsNew: (input, options = {}) => {
+        try {
+          return Promise.reject(this.continueAsNew(input, options));
+        } catch (error) {
+          return Promise.reject(error);
+        }
+      },
+      cancellationScope: scopeFn,
+      nonCancellable: (fn) => this.cancellationScope(scope(), fn, { nonCancellable: true }),
+      onCancel: (fn) => {
+        scope().onCancel(() => {
+          try {
+            fn();
+          } catch (error) {
+            this.onWorkflowError(error);
+          }
+        });
+      },
+      isCancellation: (error) => isCancellation(error),
+      saga: () => {
+        const compensations = [];
+        return {
+          add: (compensation) => {
+            compensations.push(compensation);
+          },
+          // Each compensation runs in its own non-cancellable scope, so it
+          // still runs after a cancel request; it gets that scope's `ctx`.
+          compensate: async () => {
+            const pending = [...compensations].reverse();
+            compensations.length = 0;
+            for (const compensation of pending)
+              await this.cancellationScope(
+                scope(),
+                async (scoped) => {
+                  await compensation(scoped);
+                },
+                { nonCancellable: true }
+              );
+          }
+        };
+      },
+      allHandlersFinished: () => this.allHandlersFinished(),
+      activity: phaseC("ctx.activity (user activities)"),
+      localActivity: phaseC(
+        "ctx.localActivity (local activities)"
+      ),
+      handleQuery: phaseC("ctx.handleQuery (custom queries)"),
+      handleUpdate: phaseC("ctx.handleUpdate (updates)"),
+      upsertSearchAttributes: phaseC("ctx.upsertSearchAttributes (search attributes)")
+    };
+    return Object.freeze(context);
+  }
+};
+
+// src/runtime/index.ts
+var RUNTIME_GLOBAL = "__fluidgridsRuntime";
+function buildWorkflowRegistry(modules) {
+  const byName = /* @__PURE__ */ new Map();
+  const exportNames = /* @__PURE__ */ new Map();
+  const ambiguous = /* @__PURE__ */ new Set();
+  for (const [, namespace] of modules) {
+    for (const exportName of Object.keys(namespace).sort()) {
+      const value = namespace[exportName];
+      if (!isDurableWorkflow(value)) continue;
+      const existing = byName.get(exportName);
+      if (existing && existing !== value) ambiguous.add(exportName);
+      byName.set(exportName, value);
+      if (!exportNames.has(value)) exportNames.set(value, exportName);
+    }
+  }
+  return { byName, exportNames, ambiguous };
+}
+function failedResult(cause, message) {
+  return {
+    protocol: HISTORY_PROTOCOL,
+    outcome: "failed",
+    commands: [],
+    failure: { cause, message },
+    logs: []
+  };
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function checkRequest(value) {
+  if (!isObject(value)) return "the request is not an object";
+  if (typeof value["workflowFn"] !== "string" || value["workflowFn"] === "")
+    return "workflowFn is missing";
+  if (value["kind"] !== "task" && value["kind"] !== "query" && value["kind"] !== "verify")
+    return "kind must be task, query or verify";
+  const info = value["info"];
+  if (!isObject(info) || typeof info["runId"] !== "string") return "info.runId is missing";
+  if (!Array.isArray(value["history"])) return "history must be an array";
+  for (const [index, event] of value["history"].entries()) {
+    if (!isObject(event) || typeof event["type"] !== "string" || typeof event["seq"] !== "number" || !isObject(event["payload"]) || typeof event["createdAt"] !== "string")
+      return `history[${index}] is not an event`;
+  }
+  if (typeof value["nowMs"] !== "number" || !Number.isFinite(value["nowMs"]))
+    return "nowMs must be a number";
+  return value;
+}
+function createWorkflowRuntime(registry, shims = void 0) {
+  let execution;
+  let early;
+  const internalFailure = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : void 0;
+    if (error instanceof HistoryLimitExceeded) execution?.failTask("HISTORY_LIMIT", message, stack);
+    else if (error instanceof DeterminismViolation || error instanceof Error && error.name === "DeterminismViolation")
+      execution?.failTask("NON_DETERMINISM", message, stack);
+    else execution?.failTask("INTERNAL", message, stack);
+  };
+  return Object.freeze({
+    protocol: HISTORY_PROTOCOL,
+    sdkVersion: SDK_VERSION,
+    start(requestJson) {
+      shims?.detach();
+      execution = void 0;
+      early = void 0;
+      let parsed;
+      try {
+        parsed = JSON.parse(requestJson);
+      } catch (error) {
+        early = failedResult(
+          "INVALID_REQUEST",
+          `The request is not JSON: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return;
+      }
+      if (isObject(parsed) && parsed["protocol"] !== HISTORY_PROTOCOL) {
+        early = failedResult(
+          "PROTOCOL_MISMATCH",
+          `This bundle speaks runtime protocol ${HISTORY_PROTOCOL}; the request uses ${String(parsed["protocol"])}`
+        );
+        return;
+      }
+      const request = checkRequest(parsed);
+      if (typeof request === "string") {
+        early = failedResult("INVALID_REQUEST", `Invalid workflow task request: ${request}`);
+        return;
+      }
+      if (registry.ambiguous.has(request.workflowFn)) {
+        early = failedResult(
+          "INVALID_REQUEST",
+          `More than one module exports a workflow named "${request.workflowFn}"`
+        );
+        return;
+      }
+      const definition = registry.byName.get(request.workflowFn);
+      if (!definition) {
+        early = failedResult(
+          "INVALID_REQUEST",
+          `The bundle exports no workflow named "${request.workflowFn}"`
+        );
+        return;
+      }
+      try {
+        const created = new WorkflowExecution({
+          definition,
+          exportNames: registry.exportNames,
+          request,
+          sdkVersion: SDK_VERSION
+        });
+        execution = created;
+        shims?.attach({ now: () => created.now(), random: () => created.nextRandom() });
+      } catch (error) {
+        early = failedResult("INTERNAL", error instanceof Error ? error.message : String(error));
+      }
+    },
+    step() {
+      if (!execution) return "done";
+      try {
+        return execution.step();
+      } catch (error) {
+        internalFailure(error);
+        return "done";
+      }
+    },
+    complete() {
+      try {
+        if (early || !execution)
+          return JSON.stringify(early ?? failedResult("INVALID_REQUEST", "start() was not called"));
+        try {
+          return JSON.stringify(execution.complete());
+        } catch (error) {
+          internalFailure(error);
+          return JSON.stringify(execution.complete());
+        }
+      } finally {
+        shims?.detach();
+        execution = void 0;
+        early = void 0;
+      }
+    }
+  });
+}
+function installWorkflowRuntime(modules) {
+  const holder = globalThis;
+  if (holder[RUNTIME_GLOBAL] !== void 0) return;
+  const runtime = createWorkflowRuntime(buildWorkflowRegistry(modules), takeShimControl());
+  Object.defineProperty(globalThis, RUNTIME_GLOBAL, {
+    value: runtime,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+}
+function isRuntimeAbi(value) {
+  return isObject(value) && typeof value["start"] === "function" && typeof value["step"] === "function" && typeof value["complete"] === "function";
+}
+
+export { CommandIds, RUNTIME_GLOBAL, SDK_NAME, WorkflowExecution, buildWorkflowRegistry, createWorkflowRuntime, installWorkflowRuntime, isPatchMarkerId, isRuntimeAbi, matchActivation, mismatch, patchMarkerId };