@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/chunk-GEQDGUGB.cjs

@@ -0,0 +1,2719 @@
+'use strict';
+
+var chunkZCGKGDCL_cjs = require('./chunk-ZCGKGDCL.cjs');
+var chunkQ4MWQNJK_cjs = require('./chunk-Q4MWQNJK.cjs');
+var chunkL24YIZY7_cjs = require('./chunk-L24YIZY7.cjs');
+var chunkVA4OFR72_cjs = require('./chunk-VA4OFR72.cjs');
+var chunkISOIA7NV_cjs = require('./chunk-ISOIA7NV.cjs');
+var chunkA5SXCA62_cjs = require('./chunk-A5SXCA62.cjs');
+var chunkTYF56RGB_cjs = require('./chunk-TYF56RGB.cjs');
+
+// src/runtime/ids.ts
+var CommandIds = class {
+  counters = {
+    a: 0,
+    t: 0,
+    c: 0,
+    s: 0,
+    x: 0,
+    m: 0,
+    l: 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 command.kind === "user" ? `SCHEDULE_ACTIVITY ${command.activityId} (user ${command.activityName})` : `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}${command.nodeType !== void 0 ? ` (${command.nodeType} ${command.operation ?? ""})` : ""}`;
+    case "ACCEPT_UPDATE":
+    case "REJECT_UPDATE":
+    case "COMPLETE_UPDATE":
+      return `${command.type} ${command.updateId}`;
+    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") ?? field(event, "updateId");
+  return `${event.type}${typeof id === "string" ? ` ${id}` : ""} (seq ${event.seq})`;
+}
+function mismatch(command, event) {
+  const expected = chunkTYF56RGB_cjs.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": {
+      if (field(event, "activityId") !== command.activityId) return differ();
+      const kind = field(event, "kind") ?? "node";
+      if (command.kind === "user")
+        return kind === "user" && field(event, "activityName") === command.activityName ? void 0 : differ();
+      return kind === "node" && 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 "ACCEPT_UPDATE":
+    case "COMPLETE_UPDATE":
+      return field(event, "updateId") === command.updateId ? void 0 : differ();
+    case "RECORD_LOCAL_ACTIVITY": {
+      const sameOperation = field(event, "nodeType") === void 0 || field(event, "nodeType") === command.nodeType && field(event, "operation") === command.operation;
+      return field(event, "localActivityId") === command.localActivityId && sameOperation ? 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) {
+    if (chunkTYF56RGB_cjs.COMMAND_EVENT_TYPES[command.type] === null) continue;
+    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/scheduler.ts
+var COMMAND_ID_CALLS = {
+  a: "Scheduling an activity",
+  t: "Starting a timer",
+  c: "Starting a child run",
+  s: "ctx.sideEffect()",
+  x: "Signalling or cancelling another run",
+  m: "ctx.setCurrentDetails()",
+  l: "Running a local activity"
+};
+function isBuiltInQuery(name) {
+  return chunkTYF56RGB_cjs.BUILT_IN_QUERIES.includes(name);
+}
+var SDK_NAME = "@fluidgrids/workflows";
+var ContinueAsNewRequest = class {
+  constructor(input, options, headers = {}) {
+    this.input = input;
+    this.options = options;
+    this.headers = headers;
+  }
+  input;
+  options;
+  headers;
+};
+function checkPolicy(policy) {
+  const value = policy ?? "WARN_AND_ABANDON";
+  if (value !== "WARN_AND_ABANDON" && value !== "ABANDON")
+    throw new TypeError("unfinishedPolicy must be WARN_AND_ABANDON or ABANDON");
+  return value;
+}
+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 chunkZCGKGDCL_cjs.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 checkHandlerName(name, what) {
+  if (typeof name !== "string" || name === "" || name.startsWith("__"))
+    throw new TypeError(`${what} needs a name that does not start with "__"`);
+  return name;
+}
+function definitionName(value, what) {
+  return checkHandlerName(typeof value === "string" ? value : value?.name, what);
+}
+function isHeaders(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function headersOf(value) {
+  return isHeaders(value) ? { ...value } : {};
+}
+function checkFairness(options) {
+  const key = options.fairnessKey;
+  if (key !== void 0 && (typeof key !== "string" || key === "" || key.length > chunkTYF56RGB_cjs.FAIRNESS_KEY_MAX_LENGTH))
+    throw new TypeError(
+      `fairnessKey must be a string of 1 to ${chunkTYF56RGB_cjs.FAIRNESS_KEY_MAX_LENGTH} characters`
+    );
+  const weight = options.fairnessWeight;
+  if (weight !== void 0 && (typeof weight !== "number" || !Number.isFinite(weight) || weight < chunkTYF56RGB_cjs.FAIRNESS_WEIGHT_MIN || weight > chunkTYF56RGB_cjs.FAIRNESS_WEIGHT_MAX))
+    throw new TypeError(
+      `fairnessWeight must be a number from ${chunkTYF56RGB_cjs.FAIRNESS_WEIGHT_MIN} to ${chunkTYF56RGB_cjs.FAIRNESS_WEIGHT_MAX}`
+    );
+}
+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;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asFailure(value) {
+  return isJsonObject(value) ? value : void 0;
+}
+function infoFromStarted(info, started) {
+  if (started?.type !== "WORKFLOW_STARTED") return { ...info };
+  const p = started.payload;
+  const out = { ...info };
+  if (Object.hasOwn(p, "lastCompletionResult")) out.lastResult = p["lastCompletionResult"] ?? null;
+  if (Object.hasOwn(p, "lastFailure")) out.lastFailure = asFailure(p["lastFailure"]) ?? null;
+  const businessId = typeof p["businessId"] === "string" ? p["businessId"] : void 0;
+  const workflowId = typeof p["workflowId"] === "string" ? p["workflowId"] : businessId;
+  if (businessId !== void 0) out.businessId = businessId;
+  if (workflowId !== void 0) out.workflowId = workflowId;
+  if (typeof p["runAttempt"] === "number") {
+    out.runAttempt = p["runAttempt"];
+    out.attempt = p["runAttempt"];
+  }
+  if (typeof p["summary"] === "string") out.summary = p["summary"];
+  if (typeof p["details"] === "string") out.details = p["details"];
+  if (isJsonObject(p["context"])) {
+    out.context = { ...p["context"] };
+    out.memo = { ...p["context"] };
+  }
+  const timeouts = {};
+  const nested = isJsonObject(p["timeouts"]) ? p["timeouts"] : {};
+  for (const key of ["executionTimeout", "runTimeout", "workflowTaskTimeout"]) {
+    const value = nested[key] ?? p[key];
+    if (typeof value === "number") timeouts[key] = value;
+  }
+  if (Object.keys(timeouts).length > 0) out.timeouts = timeouts;
+  if (p["versioningBehavior"] === "PINNED" || p["versioningBehavior"] === "AUTO_UPGRADE")
+    out.versioningBehavior = p["versioningBehavior"];
+  if (isJsonObject(p["retry"])) out.retry = p["retry"];
+  if (typeof p["priority"] === "number") out.priority = p["priority"];
+  if (typeof p["firstRunId"] === "string") out.firstRunId = p["firstRunId"];
+  if (typeof p["continuedFromRunId"] === "string") out.continuedFromRunId = p["continuedFromRunId"];
+  if (isHeaders(p["headers"])) out.headers = { ...p["headers"] };
+  if (isJsonObject(p["searchAttributes"]))
+    out.searchAttributes = chunkISOIA7NV_cjs.mergeSearchAttributes({}, p["searchAttributes"]);
+  if (typeof p["fairnessKey"] === "string") out.fairnessKey = p["fairnessKey"];
+  if (typeof p["fairnessWeight"] === "number") out.fairnessWeight = p["fairnessWeight"];
+  if (out.workflowId === void 0 && out.businessId !== void 0) out.workflowId = out.businessId;
+  if (out.runAttempt === void 0 && out.attempt !== void 0) out.runAttempt = out.attempt;
+  return out;
+}
+var WorkflowExecution = class {
+  request;
+  definition;
+  exportNames;
+  sdkVersion;
+  activations;
+  index = -1;
+  activationOpen = false;
+  replaying = false;
+  clock = 0;
+  randomSource;
+  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;
+  defaultSignalPolicy = "WARN_AND_ABANDON";
+  signalPolicies = /* @__PURE__ */ new Map();
+  runningHandlers = 0;
+  /** Running asynchronous handlers by name, for the drain warning (11 §2.18). */
+  running = /* @__PURE__ */ new Map();
+  unfinished;
+  /** Updates delivered so far, by id (an update is delivered at most once per task). */
+  deliveredUpdates = /* @__PURE__ */ new Set();
+  /** Updates delivered in the current activation without a handler yet. */
+  bufferedUpdates = [];
+  updateHandlers = /* @__PURE__ */ new Map();
+  defaultUpdateHandler;
+  queryHandlers = /* @__PURE__ */ new Map();
+  defaultQueryHandler;
+  /** Set while a query handler or an update validator runs: commands and sinks throw. */
+  readOnly;
+  /** The first state-changing call a read-only handler made, even when it caught the error. */
+  readOnlyViolation;
+  searchAttributes;
+  startHeaders;
+  inbound;
+  outbound;
+  sinkCalls = [];
+  sinkCallsDropped = false;
+  recordedLocalActivities = /* @__PURE__ */ new Map();
+  localActivityResults = /* @__PURE__ */ new Map();
+  localActivities = /* @__PURE__ */ new Map();
+  memo;
+  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 += chunkISOIA7NV_cjs.utf8Bytes(JSON.stringify(event.payload));
+      this.bytesUpTo.push(bytes);
+    }
+    this.historyLength = history.length;
+    this.historyBytes = bytes;
+    const limit = input.request.info.historyLimit ?? chunkTYF56RGB_cjs.DEFAULT_HISTORY_LIMIT;
+    this.limitEvents = limit.events;
+    this.limitBytes = limit.bytes;
+    this.captureStacks = input.request.kind === "query";
+    this.randomSource = chunkL24YIZY7_cjs.createRandom(chunkL24YIZY7_cjs.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);
+      } else if (event.type === "LOCAL_ACTIVITY_COMPLETED" || event.type === "LOCAL_ACTIVITY_FAILED") {
+        const id = event.payload["localActivityId"];
+        const failure = asFailure(event.payload["failure"]);
+        const attempts = event.payload["attempts"];
+        if (typeof id === "string")
+          this.recordedLocalActivities.set(id, {
+            ...event.type === "LOCAL_ACTIVITY_FAILED" && failure ? { failure } : { result: event.payload["result"] ?? null },
+            attempts: typeof attempts === "number" ? attempts : 1
+          });
+      }
+    }
+    if (input.request.kind === "task")
+      for (const entry of input.request.localActivityResults ?? [])
+        this.localActivityResults.set(entry.localActivityId, {
+          ...entry.failure !== void 0 ? { failure: entry.failure } : { result: entry.result ?? null },
+          attempts: entry.attempts
+        });
+    this.activations = chunkISOIA7NV_cjs.splitActivations(
+      history,
+      input.request.nowMs,
+      input.request.kind !== "query"
+    );
+    const execution = this;
+    const snapshot = infoFromStarted(input.request.info, history[0]);
+    this.memo = { ...snapshot.memo ?? snapshot.context ?? {} };
+    this.searchAttributes = { ...snapshot.searchAttributes ?? {} };
+    this.startHeaders = { ...snapshot.headers ?? {} };
+    let inbound = [];
+    let outbound = [];
+    const factories = input.interceptors ?? [];
+    if (factories.length > 0 && input.request.kind === "task" && !(input.request.features ?? []).includes("interceptors"))
+      this.failTask(
+        "UNSUPPORTED_COMMAND",
+        "The bundle exports interceptors, which this workspace does not enable (needs the fluidgrids.run-control flag)"
+      );
+    else
+      try {
+        const resolved = chunkVA4OFR72_cjs.resolveWorkflowInterceptors(factories);
+        inbound = resolved.inbound;
+        outbound = resolved.outbound;
+      } catch (error) {
+        this.failTask(
+          "WORKFLOW_CODE_ERROR",
+          `The interceptors factory failed: ${messageOf(error)}`,
+          stackTextOf(error)
+        );
+      }
+    this.inbound = inbound;
+    this.outbound = outbound;
+    this.info = {
+      ...snapshot,
+      workflowFn: input.request.workflowFn,
+      get context() {
+        return { ...execution.memo };
+      },
+      get memo() {
+        return { ...execution.memo };
+      },
+      get searchAttributes() {
+        return { ...execution.searchAttributes };
+      },
+      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 * chunkTYF56RGB_cjs.CONTINUE_AS_NEW_SUGGESTED_RATIO || this.historyBytes >= this.limitBytes * chunkTYF56RGB_cjs.CONTINUE_AS_NEW_SUGGESTED_RATIO;
+  }
+  /** The workflow clock. */
+  now() {
+    return this.clock;
+  }
+  /** The next deterministic random number (`Math.random()` and `crypto.getRandomValues()`). */
+  nextRandom() {
+    this.assertWritable("Math.random() or crypto.getRandomValues()");
+    return this.randomSource();
+  }
+  /** `ctx.random()`: advances the run's random source, so read-only handlers may not call it. */
+  random() {
+    this.assertWritable("ctx.random()");
+    return this.randomSource();
+  }
+  /**
+   * Throw `QueryHandlerSideEffect` when a query handler or an update validator
+   * calls something that changes the run's deterministic state (the random
+   * source, the command id counters, patches, details). Validators are not run
+   * again on replay, and a worker that keeps a run's state between tasks keeps
+   * whatever a query handler changed, so either would make the next replay
+   * diverge. The violation is remembered, so catching the error does not hide it.
+   */
+  assertWritable(what) {
+    if (this.readOnly === void 0) return;
+    this.readOnlyViolation ??= what;
+    throw new chunkZCGKGDCL_cjs.QueryHandlerSideEffect(`${what} (in ${this.readOnly})`);
+  }
+  /** The next command id of a kind; refused in read-only handlers (it advances a counter). */
+  nextId(kind) {
+    this.assertWritable(COMMAND_ID_CALLS[kind]);
+    return this.ids.next(kind);
+  }
+  /** 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 requests = this.pendingLocalActivityRequests();
+    if (requests.length > 0) {
+      const requested = {
+        protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
+        outcome: "localActivityRequested",
+        commands: [],
+        localActivityRequests: requests,
+        logs: []
+      };
+      return requested;
+    }
+    const result = {
+      protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
+      outcome: this.failure ? "failed" : "commands",
+      commands: this.failure ? [] : this.newCommands,
+      logs: this.logs
+    };
+    if (!this.failure && this.unfinished !== void 0) result.unfinishedHandlers = this.unfinished;
+    if (!this.failure && this.request.kind === "task" && this.sinkCalls.length > 0)
+      result.sinkCalls = this.sinkCalls;
+    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" || (this.request.queries ?? []).length > 0)
+      result.queryResults = this.answerQueries();
+    return result;
+  }
+  /**
+   * The local activities the open activation waits for, when the task is a
+   * workflow task that has not failed or closed the run (a run that ends
+   * abandons a local activity it did not await).
+   */
+  pendingLocalActivityRequests() {
+    if (this.failure || this.closed || this.request.kind !== "task") return [];
+    return [...this.localActivities.values()].filter((entry) => !entry.replayed).map((entry) => entry.request);
+  }
+  /** 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);
+    }
+    for (const update of this.updatesOf(activation)) {
+      if (this.failure) return;
+      this.deliverUpdate(update);
+    }
+  }
+  /**
+   * The updates an activation delivers after its inputs (C-ABI-H): a replayed
+   * activation re-delivers the updates its task accepted (validators
+   * skipped); the open activation of a workflow task delivers the lease's
+   * pending updates. Updates history admitted (`UPDATE_ADMITTED`) arrive as
+   * inputs instead.
+   */
+  updatesOf(activation) {
+    const out = [];
+    if (activation.recorded) {
+      for (const event of activation.recorded) {
+        if (event.type !== "UPDATE_ACCEPTED") continue;
+        const p = event.payload;
+        const updateId = typeof p["updateId"] === "string" ? p["updateId"] : "";
+        if (this.deliveredUpdates.has(updateId)) continue;
+        out.push({
+          updateId,
+          name: typeof p["name"] === "string" ? p["name"] : "",
+          args: p["args"] ?? null,
+          headers: headersOf(p["headers"]),
+          validate: false
+        });
+      }
+      return out;
+    }
+    if (this.request.kind === "query") return out;
+    for (const update of this.request.updates ?? []) {
+      if (update.admitted === true || this.deliveredUpdates.has(update.updateId)) continue;
+      out.push({
+        updateId: update.updateId,
+        name: update.name,
+        args: update.args ?? null,
+        headers: headersOf(update.headers),
+        validate: true
+      });
+    }
+    return out;
+  }
+  finishActivation() {
+    this.activationOpen = false;
+    const activation = this.activations[this.index];
+    if (!activation) return;
+    this.rejectUnhandledUpdates();
+    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.checkReplayedLocalActivities();
+    } else {
+      this.newCommands = this.commands;
+    }
+    this.commands = [];
+  }
+  /**
+   * A local activity issued on a replayed activation without a recorded
+   * outcome is fine only when the first execution dropped it in that same
+   * activation: its scope was cancelled (the entry is gone) or the run closed.
+   * One still waiting means the first execution would have requested and
+   * recorded it, so the code diverged from the history.
+   */
+  checkReplayedLocalActivities() {
+    if (this.closed) return;
+    for (const entry of this.localActivities.values()) {
+      if (!entry.replayed) continue;
+      this.failTask(
+        "NON_DETERMINISM",
+        `Replay of ${entry.description ?? "a local activity"} found no recorded outcome: the code issued a local activity the history does not have`
+      );
+      return;
+    }
+  }
+  // ---- 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, headersOf(p["headers"]));
+        return;
+      case "UPDATE_ADMITTED": {
+        const updateId = id("updateId");
+        if (this.deliveredUpdates.has(updateId)) return;
+        this.deliverUpdate({
+          updateId,
+          name: id("name"),
+          args: p["args"] ?? null,
+          headers: headersOf(p["headers"]),
+          validate: true
+        });
+        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) ? chunkZCGKGDCL_cjs.failureToError(failure) : new chunkZCGKGDCL_cjs.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 label = pending.activityName !== void 0 ? `user ${pending.activityName}` : `${pending.nodeType} ${pending.operation}`;
+    const wrap = (cause) => new chunkZCGKGDCL_cjs.ActivityFailure(
+      `Activity ${activityId} (${label}) failed: ${cause.message}`,
+      activityId,
+      pending.nodeType,
+      pending.operation,
+      cause,
+      pending.activityName
+    );
+    switch (event.type) {
+      case "ACTIVITY_COMPLETED":
+        pending.resolve(p["result"] ?? null);
+        return;
+      case "ACTIVITY_FAILED":
+        pending.reject(
+          wrap(
+            failure ? chunkZCGKGDCL_cjs.failureToError(failure) : new chunkZCGKGDCL_cjs.ApplicationError("Activity failed", { errorType: "UNKNOWN" })
+          )
+        );
+        return;
+      case "ACTIVITY_TIMED_OUT": {
+        const timeoutType = typeof p["timeoutType"] === "string" ? p["timeoutType"] : "UNKNOWN";
+        pending.reject(
+          wrap(new chunkZCGKGDCL_cjs.TimeoutFailure(`Activity timed out (${timeoutType})`, timeoutType))
+        );
+        return;
+      }
+      default:
+        pending.reject(wrap(new chunkZCGKGDCL_cjs.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 chunkZCGKGDCL_cjs.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 ? chunkZCGKGDCL_cjs.failureToError(failure) : new chunkZCGKGDCL_cjs.ApplicationError("Child failed", { errorType: "UNKNOWN" })
+          )
+        };
+        break;
+      case "CHILD_RUN_CANCELLED":
+        outcome = { ok: false, error: wrap(new chunkZCGKGDCL_cjs.CancelledFailure("Child run cancelled")) };
+        break;
+      case "CHILD_RUN_TERMINATED":
+        outcome = {
+          ok: false,
+          error: wrap(
+            new chunkZCGKGDCL_cjs.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 chunkZCGKGDCL_cjs.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);
+    }
+  }
+  /** Run a signal handler through the inbound `handleSignal` interceptors. */
+  signalCall(name, payload, headers, handler) {
+    if (this.inbound.length === 0) return () => handler(payload);
+    const chain = chunkVA4OFR72_cjs.compose(
+      this.inbound,
+      "handleSignal",
+      (input) => handler(input.payload)
+    );
+    return () => chain({ name, payload, headers });
+  }
+  dispatchSignal(name, payload, headers = {}) {
+    const handler = this.signalHandlers.get(name);
+    if (handler) {
+      this.runHandler(
+        this.signalCall(name, payload, headers, handler),
+        name,
+        this.signalPolicies.get(name)
+      );
+      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(
+        this.signalCall(name, payload, headers, (value) => fallback(name, value)),
+        name,
+        this.defaultSignalPolicy
+      );
+      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, name, policy = "WARN_AND_ABANDON") {
+    let result;
+    try {
+      result = call();
+    } catch (error) {
+      this.onWorkflowError(error);
+      return;
+    }
+    if (result instanceof Promise) {
+      const done = this.trackHandler("signal", name, policy);
+      result.then(done, (error) => {
+        done();
+        this.onWorkflowError(error);
+      });
+    }
+  }
+  /** Count a running asynchronous handler (drain check, `allHandlersFinished`); returns its end. */
+  trackHandler(kind, name, policy) {
+    this.runningHandlers += 1;
+    const key = `${kind}:${name}`;
+    const entry = this.running.get(key) ?? { kind, name, count: 0, policy };
+    entry.count += 1;
+    entry.policy = policy;
+    this.running.set(key, entry);
+    return () => {
+      this.runningHandlers -= 1;
+      entry.count -= 1;
+      if (entry.count === 0) this.running.delete(key);
+    };
+  }
+  // ---- updates (Phase C) ----------------------------------------------------
+  deliverUpdate(update) {
+    this.deliveredUpdates.add(update.updateId);
+    const entry = this.updateHandlerFor(update.name);
+    if (!entry) {
+      this.bufferedUpdates.push(update);
+      return;
+    }
+    this.runUpdate(update, entry);
+  }
+  updateHandlerFor(name) {
+    const own = this.updateHandlers.get(name);
+    if (own) return own;
+    const fallback = this.defaultUpdateHandler;
+    if (!fallback) return void 0;
+    const validate = fallback.validate;
+    return {
+      handler: (args) => fallback.handler(name, args),
+      ...validate !== void 0 ? { validate: (args) => validate(name, args) } : {},
+      policy: fallback.policy
+    };
+  }
+  /**
+   * Run `fn` with commands, sinks and every other change to the run's
+   * deterministic state refused (query handlers, update validators). A
+   * refused call fails the whole call with `QueryHandlerSideEffect`, even
+   * when the code caught the error it threw.
+   */
+  readOnlyCall(what, fn) {
+    const previous = this.readOnly;
+    const previousViolation = this.readOnlyViolation;
+    this.readOnly = what;
+    this.readOnlyViolation = void 0;
+    try {
+      let value;
+      try {
+        value = fn();
+      } catch (error) {
+        const violation2 = this.readOnlyViolation;
+        if (violation2 !== void 0 && !(error instanceof chunkZCGKGDCL_cjs.QueryHandlerSideEffect))
+          throw new chunkZCGKGDCL_cjs.QueryHandlerSideEffect(`${violation2} (in ${what})`);
+        throw error;
+      }
+      const violation = this.readOnlyViolation;
+      if (violation !== void 0) throw new chunkZCGKGDCL_cjs.QueryHandlerSideEffect(`${violation} (in ${what})`);
+      return value;
+    } finally {
+      this.readOnly = previous;
+      this.readOnlyViolation = previousViolation;
+    }
+  }
+  /**
+   * Validate, accept and run one update. A validator error rejects it
+   * (`REJECT_UPDATE`, no history); otherwise `ACCEPT_UPDATE` is issued and
+   * the handler's result or failure completes it (`COMPLETE_UPDATE`). A
+   * handler that throws something other than a failure class fails the task,
+   * as a signal handler does.
+   */
+  runUpdate(update, entry) {
+    if (this.closed || this.failure) return;
+    const input = {
+      updateId: update.updateId,
+      name: update.name,
+      args: update.args,
+      headers: update.headers
+    };
+    if (update.validate && (entry.validate !== void 0 || this.inbound.length > 0)) {
+      const validate = chunkVA4OFR72_cjs.compose(
+        this.inbound,
+        "validateUpdate",
+        (checked) => entry.validate?.(checked.args)
+      );
+      try {
+        this.readOnlyCall(`The validator of update ${update.name}`, () => validate(input));
+      } catch (error) {
+        if (error instanceof chunkZCGKGDCL_cjs.QueryHandlerSideEffect) {
+          this.failTask("WORKFLOW_CODE_ERROR", messageOf(error), stackTextOf(error));
+          return;
+        }
+        const failure = chunkZCGKGDCL_cjs.errorToFailure(error);
+        delete failure.stackTrace;
+        this.commands.push({ type: "REJECT_UPDATE", updateId: update.updateId, failure });
+        return;
+      }
+    }
+    if (!this.push({ type: "ACCEPT_UPDATE", updateId: update.updateId })) return;
+    const handle = chunkVA4OFR72_cjs.compose(
+      this.inbound,
+      "handleUpdate",
+      (accepted) => entry.handler(accepted.args)
+    );
+    let result;
+    try {
+      result = handle(input);
+    } catch (error) {
+      this.completeUpdate(update, { ok: false, error });
+      return;
+    }
+    if (result instanceof Promise) {
+      const done = this.trackHandler("update", update.name, entry.policy);
+      result.then(
+        (value) => {
+          done();
+          this.completeUpdate(update, { ok: true, value });
+        },
+        (error) => {
+          done();
+          this.completeUpdate(update, { ok: false, error });
+        }
+      );
+      return;
+    }
+    this.completeUpdate(update, { ok: true, value: result });
+  }
+  completeUpdate(update, outcome) {
+    if (this.closed || this.failure) return;
+    if (outcome.ok) {
+      let value;
+      try {
+        value = toJson(outcome.value, `The result of update ${update.name}`);
+      } catch (error2) {
+        this.onWorkflowError(error2);
+        return;
+      }
+      this.push({ type: "COMPLETE_UPDATE", updateId: update.updateId, result: value });
+      return;
+    }
+    const error = outcome.error;
+    if (error instanceof ContinueAsNewRequest || !(chunkZCGKGDCL_cjs.isRunFailure(error) || this.isFailureType(error))) {
+      this.onWorkflowError(error);
+      return;
+    }
+    const failure = chunkZCGKGDCL_cjs.errorToFailure(error);
+    delete failure.stackTrace;
+    this.push({ type: "COMPLETE_UPDATE", updateId: update.updateId, failure });
+  }
+  /** Reject the updates of this activation that no handler took (`UpdateNotHandled`). */
+  rejectUnhandledUpdates() {
+    const pending = this.bufferedUpdates;
+    this.bufferedUpdates = [];
+    if (this.closed || this.failure) return;
+    for (const update of pending)
+      this.commands.push({
+        type: "REJECT_UPDATE",
+        updateId: update.updateId,
+        failure: {
+          errorType: "VALIDATION",
+          type: "UpdateNotHandled",
+          message: `The workflow has no handler for update "${update.name}"`,
+          source: "sdk-ts"
+        }
+      });
+  }
+  handleUpdate(update, handler, options = {}) {
+    const name = definitionName(update, "ctx.handleUpdate");
+    if (typeof handler !== "function")
+      throw new TypeError("ctx.handleUpdate needs a handler function");
+    if (options.validate !== void 0 && typeof options.validate !== "function")
+      throw new TypeError("validate must be a function");
+    const policy = checkPolicy(options.unfinishedPolicy);
+    this.updateHandlers.set(name, {
+      handler,
+      ...options.validate !== void 0 ? { validate: options.validate } : {},
+      policy
+    });
+    this.dispatchBufferedUpdates();
+  }
+  setDefaultUpdateHandler(first, second) {
+    const handler = typeof first === "function" ? first : second;
+    const options = (typeof first === "function" ? second : first) ?? {};
+    if (typeof handler !== "function" || typeof options !== "object")
+      throw new TypeError("ctx.setDefaultUpdateHandler needs a handler function");
+    if (options.validate !== void 0 && typeof options.validate !== "function")
+      throw new TypeError("validate must be a function");
+    this.defaultUpdateHandler = {
+      handler,
+      ...options.validate !== void 0 ? { validate: options.validate } : {},
+      policy: checkPolicy(options.unfinishedPolicy)
+    };
+    this.dispatchBufferedUpdates();
+  }
+  dispatchBufferedUpdates() {
+    const pending = this.bufferedUpdates;
+    this.bufferedUpdates = [];
+    for (const update of pending) {
+      const entry = this.updateHandlerFor(update.name);
+      if (entry) this.runUpdate(update, entry);
+      else this.bufferedUpdates.push(update);
+    }
+  }
+  handleQuery(query, handler) {
+    const name = definitionName(query, "ctx.handleQuery");
+    if (typeof handler !== "function")
+      throw new TypeError("ctx.handleQuery needs a handler function");
+    this.queryHandlers.set(name, handler);
+  }
+  setDefaultQueryHandler(handler) {
+    if (typeof handler !== "function")
+      throw new TypeError("ctx.setDefaultQueryHandler needs a handler function");
+    this.defaultQueryHandler = handler;
+  }
+  /**
+   * The drain check of 11 §2.18 when the workflow finishes: handlers still
+   * running with policy `WARN_AND_ABANDON` give one warning line and
+   * `unfinishedHandlers` in the result. A replay never reports them.
+   */
+  checkUnfinishedHandlers(command) {
+    if (this.replaying || command.type === "CANCEL_WORKFLOW") return;
+    const unfinished = [...this.running.values()].filter((entry) => entry.count > 0 && entry.policy === "WARN_AND_ABANDON").map(
+      (entry) => ({ kind: entry.kind, name: entry.name, count: entry.count })
+    ).sort(
+      (a, b) => a.kind !== b.kind ? a.kind < b.kind ? -1 : 1 : a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+    );
+    if (unfinished.length === 0) return;
+    this.unfinished = unfinished;
+    const total = unfinished.reduce((sum, entry) => sum + entry.count, 0);
+    const what = unfinished.every((entry) => entry.kind === "signal") ? "signal handler" : unfinished.every((entry) => entry.kind === "update") ? "update handler" : "signal or update handler";
+    this.logs.push({
+      level: "warn",
+      message: `The workflow finished while ${total} ${what}${total === 1 ? " was" : "s were"} still running (${unfinished.map((entry) => `${entry.name} x${entry.count}`).join(
+        ", "
+      )}); await ctx.allHandlersFinished() before returning, or set unfinishedPolicy: 'ABANDON' on the handler`,
+      data: unfinished.map((entry) => ({ kind: entry.kind, name: entry.name, count: entry.count }))
+    });
+  }
+  // ---- the workflow function ------------------------------------------------
+  startFunction(input) {
+    let promise;
+    try {
+      const run = (value) => (
+        // The input crossed the history as JSON; the function declared its type.
+        Promise.resolve(this.definition.fn(this.context, value))
+      );
+      promise = this.inbound.length === 0 ? run(input) : chunkVA4OFR72_cjs.compose(
+        this.inbound,
+        "execute",
+        (execute) => run(execute.input)
+      )({ workflowFn: this.request.workflowFn, input, headers: { ...this.startHeaders } });
+    } 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) {
+      const command = {
+        type: "CONTINUE_AS_NEW",
+        input: error.input,
+        options: error.options
+      };
+      if (Object.keys(error.headers).length > 0) command.headers = { ...error.headers };
+      this.pushTerminal(command);
+      return;
+    }
+    const name = errorName(error);
+    if (error instanceof chunkZCGKGDCL_cjs.DeterminismViolation || name === "DeterminismViolation") {
+      this.failTask("NON_DETERMINISM", messageOf(error), stackTextOf(error), void 0, name);
+      return;
+    }
+    if (error instanceof chunkZCGKGDCL_cjs.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 chunkZCGKGDCL_cjs.PhaseCFeatureError) {
+      this.failTask("UNSUPPORTED_COMMAND", messageOf(error), stackTextOf(error));
+      return;
+    }
+    if (error instanceof chunkZCGKGDCL_cjs.QueryHandlerSideEffect) {
+      this.failTask("WORKFLOW_CODE_ERROR", messageOf(error), stackTextOf(error), void 0, name);
+      return;
+    }
+    if (this.cancelRequested && chunkZCGKGDCL_cjs.isCancellation(error)) {
+      this.pushTerminal({ type: "CANCEL_WORKFLOW" });
+      return;
+    }
+    if (chunkZCGKGDCL_cjs.isRunFailure(error) || this.isFailureType(error)) {
+      this.pushTerminal({ type: "FAIL_WORKFLOW", failure: chunkZCGKGDCL_cjs.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 * chunkTYF56RGB_cjs.HISTORY_LIMIT_EXCEEDED_RATIO || this.historyBytes >= this.limitBytes * chunkTYF56RGB_cjs.HISTORY_LIMIT_EXCEEDED_RATIO)
+      throw new chunkZCGKGDCL_cjs.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) {
+    this.assertWritable(command.type);
+    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;
+    this.checkUnfinishedHandlers(command);
+  }
+  stack() {
+    return this.captureStacks ? chunkQ4MWQNJK_cjs.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" || !chunkA5SXCA62_cjs.isActivityNodeTypeAllowed(operation.nodeType))
+      throw new chunkZCGKGDCL_cjs.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.nextId("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: chunkTYF56RGB_cjs.explicitRetryPolicy(options.retry)
+    };
+    if (nodeVersion !== void 0) command.nodeVersion = nodeVersion;
+    if (options.connection !== void 0) command.connection = options.connection;
+    const startToClose = chunkVA4OFR72_cjs.optionalMs(options.startToCloseTimeout, "startToCloseTimeout");
+    const scheduleToClose = chunkVA4OFR72_cjs.optionalMs(options.scheduleToCloseTimeout, "scheduleToCloseTimeout");
+    const scheduleToStart = chunkVA4OFR72_cjs.optionalMs(options.scheduleToStartTimeout, "scheduleToStartTimeout");
+    const heartbeat = chunkVA4OFR72_cjs.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;
+    checkFairness(options);
+    if (options.fairnessKey !== void 0) command.fairnessKey = options.fairnessKey;
+    if (options.fairnessWeight !== void 0) command.fairnessWeight = options.fairnessWeight;
+    return this.issueActivity(
+      scope,
+      command,
+      options.headers,
+      {
+        description: `activity ${activityId} (${operation.nodeType} ${operationName})`,
+        nodeType: operation.nodeType,
+        operation: operationName,
+        cancellationType
+      },
+      { kind: "node", name: operation.nodeType, operation: operationName }
+    );
+  }
+  /**
+   * `ctx.activity` (Phase C): a user activity on a self-hosted task queue
+   * (`SCHEDULE_ACTIVITY` of kind `user`). The queue is the option, else the
+   * declaration's, else the run's own.
+   */
+  userActivity(scope, activity, options) {
+    if (typeof options !== "object" || options === null)
+      throw new TypeError("ctx.activity needs options with args");
+    let name;
+    let declaredQueue;
+    if (typeof activity === "string") name = activity;
+    else if (chunkVA4OFR72_cjs.isActivityDefinition(activity)) {
+      name = activity.name;
+      declaredQueue = activity.options.taskQueue;
+    } else throw new TypeError("ctx.activity needs an activity name or a declareActivity() value");
+    chunkVA4OFR72_cjs.checkActivityName(name);
+    const taskQueue = options.taskQueue ?? declaredQueue ?? this.info.taskQueue ?? "managed";
+    chunkVA4OFR72_cjs.checkTaskQueueName(taskQueue);
+    const connections = options.connections;
+    if (connections !== void 0 && (!Array.isArray(connections) || connections.length > chunkTYF56RGB_cjs.MAX_ACTIVITY_CONNECTIONS || new Set(connections).size !== connections.length || !connections.every((entry) => typeof entry === "string" && entry !== "")))
+      throw new TypeError(
+        `connections must be at most ${chunkTYF56RGB_cjs.MAX_ACTIVITY_CONNECTIONS} distinct connection names`
+      );
+    checkFairness(options);
+    const activityId = this.nextId("a");
+    const cancellationType = options.cancellationType ?? "WAIT_CANCELLATION_COMPLETED";
+    const command = {
+      type: "SCHEDULE_ACTIVITY",
+      activityId,
+      kind: "user",
+      activityName: name,
+      taskQueue,
+      args: toJson(options.args, `The args of activity ${name}`),
+      retry: chunkTYF56RGB_cjs.explicitRetryPolicy(options.retry)
+    };
+    const startToClose = chunkVA4OFR72_cjs.optionalMs(options.startToCloseTimeout, "startToCloseTimeout");
+    const scheduleToClose = chunkVA4OFR72_cjs.optionalMs(options.scheduleToCloseTimeout, "scheduleToCloseTimeout");
+    const scheduleToStart = chunkVA4OFR72_cjs.optionalMs(options.scheduleToStartTimeout, "scheduleToStartTimeout");
+    const heartbeat = chunkVA4OFR72_cjs.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.fairnessKey !== void 0) command.fairnessKey = options.fairnessKey;
+    if (options.fairnessWeight !== void 0) command.fairnessWeight = options.fairnessWeight;
+    if (connections !== void 0) command.connections = [...connections];
+    return this.issueActivity(
+      scope,
+      command,
+      options.headers,
+      {
+        description: `activity ${activityId} (user ${name})`,
+        nodeType: "",
+        operation: name,
+        activityName: name,
+        cancellationType
+      },
+      { kind: "user", name }
+    );
+  }
+  /** Run the outbound `scheduleActivity` interceptors, then issue the command. */
+  issueActivity(scope, command, headers, pending, what) {
+    if (this.outbound.length === 0) {
+      if (headers !== void 0) command.headers = { ...headers };
+      return this.pushActivity(scope, command, pending);
+    }
+    const chain = chunkVA4OFR72_cjs.compose(
+      this.outbound,
+      "scheduleActivity",
+      (input) => {
+        command.args = toJson(input.args, `The args of ${what.name}`);
+        if (headers !== void 0 || Object.keys(input.headers).length > 0)
+          command.headers = { ...input.headers };
+        return this.pushActivity(scope, command, pending);
+      }
+    );
+    return chain({
+      activityId: command.activityId,
+      kind: what.kind,
+      name: what.name,
+      ...what.operation !== void 0 ? { operation: what.operation } : {},
+      args: command.args,
+      headers: { ...headers ?? {} }
+    });
+  }
+  pushActivity(scope, command, pending) {
+    const activityId = command.activityId;
+    const cancellationType = pending.cancellationType;
+    if (scope.consideredCancelled)
+      return Promise.reject(new chunkZCGKGDCL_cjs.CancelledFailure("Scope is cancelled"));
+    if (!this.push(command)) return this.never();
+    this.issued.add(`activity:${activityId}`);
+    return new Promise((resolve, reject) => {
+      const entry = { ...pending, resolve, reject };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      entry.release = scope.onCancel(() => {
+        if (!this.activities.has(activityId)) return;
+        const cancelled = new chunkZCGKGDCL_cjs.ActivityFailure(
+          `Activity ${activityId} cancelled`,
+          activityId,
+          entry.nodeType,
+          entry.operation,
+          new chunkZCGKGDCL_cjs.CancelledFailure("Activity cancelled"),
+          entry.activityName
+        );
+        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);
+    });
+  }
+  /**
+   * `ctx.localActivity` (11 §2.12). A replayed activation returns the outcome
+   * its history recorded; the open activation takes the outcome the worker
+   * passed in `localActivityResults`, or asks for the local activity
+   * (`localActivityRequested`) and waits for the same task to run again.
+   * Either way the outcome is recorded with `RECORD_LOCAL_ACTIVITY` at the
+   * call, so a replay issues the same command at the same position.
+   */
+  localActivity(scope, operation, options) {
+    if (typeof operation === "function")
+      throw new chunkZCGKGDCL_cjs.PhaseCFeatureError("ctx.localActivity with a function (user local activities)");
+    if (typeof operation !== "object" || operation === null || typeof operation.nodeType !== "string")
+      throw new TypeError(
+        "ctx.localActivity needs a node operation (from nodes.* or the generated clients)"
+      );
+    const descriptor = operation;
+    if (descriptor.role === "trigger" || !chunkA5SXCA62_cjs.isActivityNodeTypeAllowed(descriptor.nodeType))
+      throw new chunkZCGKGDCL_cjs.ApplicationError(
+        `${descriptor.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 }
+      );
+    if (typeof options !== "object" || options === null)
+      throw new TypeError("ctx.localActivity needs options with args");
+    const timeout = options.startToCloseTimeout === void 0 ? chunkTYF56RGB_cjs.LOCAL_ACTIVITY_MAX_TIMEOUT_MS : chunkVA4OFR72_cjs.toMs(options.startToCloseTimeout, "startToCloseTimeout");
+    if (timeout < 1 || timeout > chunkTYF56RGB_cjs.LOCAL_ACTIVITY_MAX_TIMEOUT_MS)
+      throw new TypeError(
+        `A local activity's startToCloseTimeout must be between 1 ms and 30 s (got ${timeout} ms); use ctx.run for longer calls`
+      );
+    const localActivityId = this.nextId("l");
+    const operationName = options.operation ?? descriptor.operation ?? "execute";
+    const nodeVersion = options.nodeVersion ?? descriptor.version;
+    const retry = chunkTYF56RGB_cjs.explicitRetryPolicy(options.retry);
+    const args = toJson(options.args, `The args of ${descriptor.nodeType}`);
+    const proceed = (args2) => {
+      if (scope.consideredCancelled)
+        return Promise.reject(new chunkZCGKGDCL_cjs.CancelledFailure("Scope is cancelled"));
+      const label = `local activity ${localActivityId} (${descriptor.nodeType} ${operationName})`;
+      const wrap = (cause) => new chunkZCGKGDCL_cjs.ActivityFailure(
+        `Local activity ${localActivityId} (${descriptor.nodeType} ${operationName}) failed: ${cause.message}`,
+        localActivityId,
+        descriptor.nodeType,
+        operationName,
+        cause
+      );
+      const record = (outcome) => {
+        const command = {
+          type: "RECORD_LOCAL_ACTIVITY",
+          localActivityId,
+          attempts: Math.max(1, Math.round(outcome.attempts)),
+          nodeType: descriptor.nodeType,
+          operation: operationName,
+          ...outcome.failure !== void 0 ? { failure: outcome.failure } : { result: outcome.result ?? null }
+        };
+        if (options.summary !== void 0) command.summary = options.summary;
+        if (!this.push(command)) return this.never();
+        if (outcome.failure !== void 0)
+          return Promise.reject(wrap(chunkZCGKGDCL_cjs.failureToError(outcome.failure)));
+        return Promise.resolve(outcome.result ?? null);
+      };
+      const replayed = this.replaying;
+      if (replayed) {
+        const recorded = this.recordedLocalActivities.get(localActivityId);
+        if (recorded !== void 0) return record(recorded);
+      }
+      const given = replayed ? void 0 : this.localActivityResults.get(localActivityId);
+      let attempt = 1;
+      let backoffMs = 0;
+      if (given !== void 0) {
+        if (given.failure === void 0) return record(given);
+        const decision = chunkTYF56RGB_cjs.computeRetryDelay(retry, given.attempts, given.failure);
+        if (!decision.retry) return record(given);
+        attempt = given.attempts + 1;
+        backoffMs = decision.delayMs;
+      }
+      const request = {
+        localActivityId,
+        kind: "node",
+        nodeType: descriptor.nodeType,
+        operation: operationName,
+        args: args2,
+        retry,
+        startToCloseTimeout: timeout,
+        attempt,
+        backoffMs
+      };
+      if (nodeVersion !== void 0) request.nodeVersion = nodeVersion;
+      if (options.connection !== void 0) request.connection = options.connection;
+      if (options.summary !== void 0) request.summary = options.summary;
+      return new Promise((resolve, reject) => {
+        const entry = {
+          resolve,
+          reject,
+          description: label,
+          request,
+          replayed
+        };
+        const stack = this.stack();
+        if (stack !== void 0) entry.stack = stack;
+        entry.release = scope.onCancel(() => {
+          if (!this.localActivities.delete(localActivityId)) return;
+          reject(wrap(new chunkZCGKGDCL_cjs.CancelledFailure("Local activity cancelled")));
+        });
+        this.localActivities.set(localActivityId, entry);
+      });
+    };
+    if (this.outbound.length === 0) return proceed(args);
+    const chain = chunkVA4OFR72_cjs.compose(
+      this.outbound,
+      "scheduleLocalActivity",
+      (input) => proceed(toJson(input.args, `The args of ${descriptor.nodeType}`))
+    );
+    return chain({
+      localActivityId,
+      nodeType: descriptor.nodeType,
+      operation: operationName,
+      args
+    });
+  }
+  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 chunkZCGKGDCL_cjs.CancelledFailure("Scope is cancelled")) };
+    const timerId = this.nextId("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 chunkZCGKGDCL_cjs.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 chunkZCGKGDCL_cjs.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, chunkVA4OFR72_cjs.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 chunkZCGKGDCL_cjs.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 = chunkZCGKGDCL_cjs.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 chunkZCGKGDCL_cjs.CancelledFailure("Signal wait cancelled"));
+      });
+    });
+  }
+  onSignal(signal, handler, options = {}) {
+    if (typeof handler !== "function") throw new TypeError("ctx.onSignal needs a handler function");
+    const policy = checkPolicy(options.unfinishedPolicy);
+    const name = chunkZCGKGDCL_cjs.signalName(signal);
+    this.signalHandlers.set(name, handler);
+    this.signalPolicies.set(name, policy);
+    let payload = this.takeBuffered(name);
+    while (payload !== void 0) {
+      const value = payload;
+      this.runHandler(() => handler(value), name, policy);
+      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), entry.name, this.defaultSignalPolicy);
+    }
+  }
+  /** The command target of a run handle (11 §2.1, §2.24). */
+  externalTarget(target) {
+    if (typeof target === "string") {
+      if (target === "") throw new TypeError("A run handle needs a run id");
+      return { runId: target };
+    }
+    if (typeof target === "object" && target !== null) {
+      if ("runId" in target && typeof target.runId === "string" && target.runId !== "")
+        return { runId: target.runId };
+      if ("workflowKey" in target && typeof target.workflowKey === "string" && target.workflowKey !== "" && typeof target.workflowId === "string" && target.workflowId !== "") {
+        const out = { workflowKey: target.workflowKey, workflowId: target.workflowId };
+        if (typeof target.firstRunId === "string" && target.firstRunId !== "")
+          out.firstRunId = target.firstRunId;
+        return out;
+      }
+    }
+    throw new TypeError("A run handle needs a run id or { workflowKey, workflowId }");
+  }
+  runHandle(target) {
+    const resolved = this.externalTarget(target);
+    return {
+      runId: "runId" in resolved ? resolved.runId : "",
+      ..."workflowId" in resolved ? { workflowKey: resolved.workflowKey, workflowId: resolved.workflowId } : {},
+      signal: (signal, payload) => this.signalExternal(resolved, chunkZCGKGDCL_cjs.signalName(signal), payload),
+      cancel: () => this.cancelExternal(resolved)
+    };
+  }
+  childTarget(target) {
+    if (typeof target === "string") {
+      if (target === "") throw new TypeError("ctx.child needs a workflow key or function");
+      return { workflowKey: target };
+    }
+    if (chunkVA4OFR72_cjs.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");
+    if (options.retry !== void 0)
+      opts["retry"] = toJson(chunkVA4OFR72_cjs.runRetryPolicyOf(options.retry), "The child retry policy");
+    if (options.versioningBehavior !== void 0)
+      opts["versioningBehavior"] = options.versioningBehavior;
+    if (options.idReusePolicy !== void 0) opts["idReusePolicy"] = options.idReusePolicy;
+    if (options.idConflictPolicy !== void 0) opts["idConflictPolicy"] = options.idConflictPolicy;
+    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] = chunkVA4OFR72_cjs.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
+      }
+    };
+    checkFairness(options);
+    if (options.fairnessKey !== void 0) command.options.fairnessKey = options.fairnessKey;
+    if (options.fairnessWeight !== void 0)
+      command.options.fairnessWeight = options.fairnessWeight;
+    if (options.version !== void 0) command.version = options.version;
+    if (options.headers !== void 0) command.headers = { ...options.headers };
+    return command;
+  }
+  /**
+   * Run the outbound `startChild` interceptors around a child start. `go`
+   * starts the child with the options the interceptors leave (input and
+   * headers).
+   */
+  interceptChild(target, options, go) {
+    if (this.outbound.length === 0) return go(options);
+    const chain = chunkVA4OFR72_cjs.compose(
+      this.outbound,
+      "startChild",
+      (input) => go({
+        ...options,
+        input: input.input,
+        ...options.headers !== void 0 || Object.keys(input.headers).length > 0 ? { headers: { ...input.headers } } : {}
+      })
+    );
+    return chain({
+      ...this.childTarget(target),
+      input: toJson(options.input, "The child input"),
+      headers: { ...options.headers ?? {} }
+    });
+  }
+  startChildRun(scope, target, options, defaultPolicy) {
+    if (scope.consideredCancelled) return void 0;
+    const childId = this.nextId("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 ?? chunkISOIA7NV_cjs.CHILD_DEFAULT_CANCELLATION_TYPE;
+      const error = new chunkZCGKGDCL_cjs.ChildRunFailure(
+        `Child run ${child.childId} cancelled`,
+        child.childId,
+        child.runId,
+        new chunkZCGKGDCL_cjs.CancelledFailure("Child run cancelled")
+      );
+      if (type === "ABANDON") {
+        child.result = void 0;
+        entry.reject(error);
+        return;
+      }
+      const externalId = this.nextId("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) {
+    return this.interceptChild(target, options, (opts) => {
+      const child = this.startChildRun(
+        scope,
+        target,
+        opts,
+        chunkISOIA7NV_cjs.CHILD_DEFAULT_PARENT_CLOSE_POLICY.child
+      );
+      if (!child)
+        return scope.consideredCancelled ? Promise.reject(new chunkZCGKGDCL_cjs.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) {
+    return this.interceptChild(
+      target,
+      options,
+      (opts) => this.startChildHandle(scope, target, opts)
+    );
+  }
+  startChildHandle(scope, target, options) {
+    const child = this.startChildRun(
+      scope,
+      target,
+      options,
+      chunkISOIA7NV_cjs.CHILD_DEFAULT_PARENT_CLOSE_POLICY.startChild
+    );
+    if (!child)
+      return scope.consideredCancelled ? Promise.reject(new chunkZCGKGDCL_cjs.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 }, chunkZCGKGDCL_cjs.signalName(signal), payload),
+        cancel: () => this.cancelExternal({ childId: child.childId })
+      };
+      return handle;
+    });
+  }
+  signalExternal(target, name, payload) {
+    if (this.outbound.length === 0) return this.pushSignal(target, name, payload, void 0);
+    const chain = chunkVA4OFR72_cjs.compose(
+      this.outbound,
+      "signalRun",
+      (input) => this.pushSignal(input.target, input.name, input.payload, input.headers)
+    );
+    return chain({
+      target,
+      name,
+      payload: toJson(payload, `The payload of signal ${name}`),
+      headers: {}
+    });
+  }
+  pushSignal(target, name, payload, headers) {
+    const externalId = this.nextId("x");
+    const command = {
+      type: "SIGNAL_RUN",
+      externalId,
+      target,
+      name,
+      payload: toJson(payload, `The payload of signal ${name}`)
+    };
+    if (headers !== void 0 && Object.keys(headers).length > 0) command.headers = { ...headers };
+    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) {
+    if (this.outbound.length === 0) return this.pushCancel(target);
+    return chunkVA4OFR72_cjs.compose(
+      this.outbound,
+      "cancelRun",
+      (input) => this.pushCancel(input.target)
+    )({ target });
+  }
+  pushCancel(target) {
+    const externalId = this.nextId("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) {
+    if (this.outbound.length === 0) return this.recordSideEffect(fn);
+    return chunkVA4OFR72_cjs.compose(
+      this.outbound,
+      "sideEffect",
+      () => this.recordSideEffect(fn)
+    )({});
+  }
+  recordSideEffect(fn) {
+    const sideEffectId = this.nextId("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;
+    this.assertWritable(deprecated ? "ctx.deprecatePatch()" : "ctx.patched()");
+    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.assertWritable("ctx.setCurrentDetails()");
+    this.currentDetails = markdown;
+    this.push({
+      type: "RECORD_MARKER",
+      markerId: this.nextId("m"),
+      data: { currentDetails: markdown }
+    });
+  }
+  upsertContext(entries) {
+    const json = toJson(entries, "The context entries");
+    if (!isJsonObject(json)) throw new TypeError("ctx.upsertContext takes an object");
+    const apply = (input) => {
+      const final = toJson(input.entries, "The context entries");
+      if (!isJsonObject(final)) throw new TypeError("ctx.upsertContext takes an object");
+      if (this.push({ type: "UPSERT_CONTEXT", entries: final }))
+        this.memo = { ...this.memo, ...final };
+    };
+    if (this.outbound.length === 0) apply({ entries: json });
+    else
+      chunkVA4OFR72_cjs.compose(
+        this.outbound,
+        "upsertContext",
+        apply
+      )({ entries: json });
+  }
+  /** `ctx.upsertSearchAttributes` (Phase C): a null value removes an attribute. */
+  upsertSearchAttributes(attributes) {
+    const json = toJson(attributes, "The search attributes");
+    if (!isJsonObject(json) || Object.keys(json).length === 0)
+      throw new TypeError("ctx.upsertSearchAttributes takes an object with at least one attribute");
+    for (const key of Object.keys(json))
+      if (key.trim() === "") throw new TypeError("A search attribute needs a name");
+    const apply = (input) => {
+      const final = toJson(input.attributes, "The search attributes");
+      if (!isJsonObject(final)) throw new TypeError("ctx.upsertSearchAttributes takes an object");
+      if (this.push({ type: "UPSERT_SEARCH_ATTRIBUTES", attributes: final }))
+        this.searchAttributes = chunkISOIA7NV_cjs.mergeSearchAttributes(this.searchAttributes, final);
+    };
+    if (this.outbound.length === 0) apply({ attributes: json });
+    else
+      chunkVA4OFR72_cjs.compose(
+        this.outbound,
+        "upsertSearchAttributes",
+        apply
+      )({ attributes: json });
+  }
+  /** A `ctx.sinks.<sink>.<fn>(...args)` call: recorded once, never on replay (11 §2.31). */
+  callSink(sink, fn, args) {
+    this.assertWritable(`The sink call ${sink}.${fn}`);
+    if (this.replaying || this.closed || this.failure || this.request.kind !== "task") return;
+    if (this.sinkCalls.length >= chunkTYF56RGB_cjs.MAX_SINK_CALLS) {
+      if (!this.sinkCallsDropped) {
+        this.sinkCallsDropped = true;
+        this.logs.push({
+          level: "warn",
+          message: `More than ${chunkTYF56RGB_cjs.MAX_SINK_CALLS} sink calls in one workflow task; the rest were dropped`
+        });
+      }
+      return;
+    }
+    this.sinkCalls.push({
+      sink,
+      fn,
+      args: args.map((arg, index) => toJson(arg, `Argument ${index + 1} of ${sink}.${fn}`))
+    });
+  }
+  sinksProxy() {
+    const execution = this;
+    const sinkOf = (sink) => new Proxy(
+      {},
+      {
+        get(_target, fn) {
+          if (typeof fn !== "string" || fn === "then") return void 0;
+          return (...args) => execution.callSink(sink, fn, args);
+        }
+      }
+    );
+    return new Proxy(
+      {},
+      {
+        get(_target, sink) {
+          if (typeof sink !== "string" || sink === "then") return void 0;
+          return sinkOf(sink);
+        }
+      }
+    );
+  }
+  /** `ctx.continueAsNew`: a rejection with the request, after the outbound interceptors. */
+  continueAsNewCall(input, options) {
+    let request;
+    try {
+      request = this.continueAsNew(input, options);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    if (this.outbound.length === 0) return Promise.reject(request);
+    return chunkVA4OFR72_cjs.compose(
+      this.outbound,
+      "continueAsNew",
+      (changed) => Promise.reject(
+        new ContinueAsNewRequest(
+          toJson(changed.input, "The continue-as-new input"),
+          changed.options,
+          headersOf(changed.headers)
+        )
+      )
+    )({ input: request.input, options: { ...request.options }, headers: {} });
+  }
+  /** 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(chunkVA4OFR72_cjs.continueAsNewRetryOf(options.retry), "retry");
+    if (options.workflowTaskTimeout !== void 0)
+      opts["workflowTaskTimeout"] = chunkVA4OFR72_cjs.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, chunkVA4OFR72_cjs.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.localActivities.values()) add(entry, "local 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;
+  }
+  /**
+   * Answer a custom query (Phase C): the handler registered for the name, else
+   * the default handler, run read-only through the inbound `handleQuery`
+   * interceptors. No handler gives `rejected`.
+   */
+  answerCustomQuery(query) {
+    if (this.failure)
+      return { queryId: query.queryId, error: `The replay failed: ${this.failure.message}` };
+    const own = this.queryHandlers.get(query.name);
+    const fallback = this.defaultQueryHandler;
+    const handler = own ?? (fallback !== void 0 ? (args) => fallback(query.name, args) : void 0);
+    if (handler === void 0)
+      return {
+        queryId: query.queryId,
+        rejected: true,
+        error: `The workflow has no handler for query "${query.name}"`
+      };
+    const chain = chunkVA4OFR72_cjs.compose(
+      this.inbound,
+      "handleQuery",
+      (input) => handler(input.args)
+    );
+    try {
+      const value = this.readOnlyCall(
+        `the handler of query ${query.name}`,
+        () => chain({ queryId: query.queryId, name: query.name, args: query.args ?? null })
+      );
+      if (typeof value === "object" && value !== null && typeof value.then === "function")
+        return {
+          queryId: query.queryId,
+          error: `The handler of query "${query.name}" returned a promise; query handlers must return a value`
+        };
+      return { queryId: query.queryId, value: toJson(value, `The result of query ${query.name}`) };
+    } catch (error) {
+      return {
+        queryId: query.queryId,
+        error: `${errorName(error) || "Error"}: ${messageOf(error)}`
+      };
+    }
+  }
+  answerQueries() {
+    return (this.request.queries ?? []).map((query) => {
+      if (!isBuiltInQuery(query.name)) return this.answerCustomQuery(query);
+      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: chunkQ4MWQNJK_cjs.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 || this.readOnly !== void 0) return;
+      const line = { level, message: String(message) };
+      const payload = data !== void 0 ? toJson(data, "The log data") : void 0;
+      const attributes = this.outbound.length === 0 ? {} : chunkVA4OFR72_cjs.compose(
+        this.outbound,
+        "getLogAttributes",
+        (input) => input
+      )({});
+      if (Object.keys(attributes).length === 0) {
+        if (payload !== void 0) line.data = payload;
+      } else {
+        const extra = toJson(attributes, "The log attributes");
+        line.data = payload === void 0 ? extra : isJsonObject(payload) && isJsonObject(extra) ? { ...extra, ...payload } : { ...isJsonObject(extra) ? extra : {}, data: payload };
+      }
+      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 context = {
+      info: this.info,
+      log: logger,
+      run: (operation, options) => this.scheduleActivity(scope(), operation, options),
+      sleep: (duration, options = {}) => {
+        const durationMs = chunkVA4OFR72_cjs.toMs(duration, "sleep duration");
+        if (this.outbound.length === 0)
+          return this.startTimer(scope(), durationMs, options.summary);
+        const current = scope();
+        return chunkVA4OFR72_cjs.compose(
+          this.outbound,
+          "startTimer",
+          (input) => this.startTimer(current, chunkVA4OFR72_cjs.toMs(input.durationMs, "sleep duration"), input.summary)
+        )({ durationMs, ...options.summary !== void 0 ? { summary: options.summary } : {} });
+      },
+      condition: (predicate, timeout) => this.condition(scope(), predicate, timeout),
+      signalReceived: (signal) => this.signalReceived(scope(), signal),
+      onSignal: ((signal, optionsOrHandler, maybeHandler) => {
+        if (typeof optionsOrHandler === "function") this.onSignal(signal, optionsOrHandler);
+        else if (maybeHandler !== void 0)
+          this.onSignal(signal, maybeHandler, optionsOrHandler ?? {});
+        else throw new TypeError("ctx.onSignal needs a handler function");
+      }),
+      setDefaultSignalHandler: (handler) => this.setDefaultSignalHandler(handler),
+      child: (target, options = {}) => this.child(scope(), target, options),
+      startChild: (target, options = {}) => this.startChild(scope(), target, options),
+      signalRun: (target, signal, payload) => this.signalExternal(this.externalTarget(target), chunkZCGKGDCL_cjs.signalName(signal), payload),
+      signalParent: (signal, payload) => this.signalExternal({ parent: true }, chunkZCGKGDCL_cjs.signalName(signal), payload),
+      getRunHandle: (target) => this.runHandle(target),
+      cancelRun: (target) => this.cancelExternal(this.externalTarget(target)),
+      now: () => this.clock,
+      random: () => this.random(),
+      uuid: () => {
+        this.assertWritable("ctx.uuid()");
+        return chunkL24YIZY7_cjs.uuidFrom(this.randomSource);
+      },
+      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 = {}) => this.continueAsNewCall(input, options),
+      cancellationScope: scopeFn,
+      nonCancellable: (fn) => this.cancellationScope(scope(), fn, { nonCancellable: true }),
+      onCancel: (fn) => {
+        scope().onCancel(() => {
+          try {
+            fn();
+          } catch (error) {
+            this.onWorkflowError(error);
+          }
+        });
+      },
+      isCancellation: (error) => chunkZCGKGDCL_cjs.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: (activity, options) => this.userActivity(scope(), activity, options),
+      localActivity: ((operation, options) => this.localActivity(scope(), operation, options)),
+      handleQuery: ((query, handler) => this.handleQuery(query, handler)),
+      setDefaultQueryHandler: (handler) => this.setDefaultQueryHandler(handler),
+      handleUpdate: ((update, handler, options) => this.handleUpdate(update, handler, options)),
+      setDefaultUpdateHandler: ((first, second) => this.setDefaultUpdateHandler(first, second)),
+      upsertSearchAttributes: (attributes) => this.upsertSearchAttributes(attributes),
+      sinks: this.sinksProxy()
+    };
+    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();
+  const interceptors = [];
+  let dynamic;
+  let dynamicAmbiguous = false;
+  for (const [, namespace] of modules) {
+    for (const exportName of Object.keys(namespace).sort()) {
+      const value = namespace[exportName];
+      if (exportName === "interceptors") {
+        const factory = chunkVA4OFR72_cjs.interceptorsFactoryOf(value);
+        if (factory !== void 0 && !interceptors.includes(factory)) interceptors.push(factory);
+        continue;
+      }
+      if (!chunkVA4OFR72_cjs.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);
+      if (value.dynamic === true) {
+        if (dynamic !== void 0 && dynamic !== value) dynamicAmbiguous = true;
+        dynamic ??= value;
+      }
+    }
+  }
+  return {
+    byName,
+    exportNames,
+    ambiguous,
+    ...dynamic !== void 0 ? { dynamic } : {},
+    ...dynamicAmbiguous ? { dynamicAmbiguous } : {},
+    ...interceptors.length > 0 ? { interceptors } : {}
+  };
+}
+function failedResult(cause, message) {
+  return {
+    protocol: chunkTYF56RGB_cjs.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";
+  const updates = value["updates"];
+  if (updates !== void 0) {
+    if (!Array.isArray(updates)) return "updates must be an array";
+    for (const [index, update] of updates.entries())
+      if (!isObject(update) || typeof update["updateId"] !== "string" || update["updateId"] === "" || typeof update["name"] !== "string")
+        return `updates[${index}] needs an updateId and a name`;
+  }
+  const queries = value["queries"];
+  if (queries !== void 0) {
+    if (!Array.isArray(queries)) return "queries must be an array";
+    for (const [index, query] of queries.entries())
+      if (!isObject(query) || typeof query["queryId"] !== "string" || typeof query["name"] !== "string")
+        return `queries[${index}] needs a queryId and a name`;
+  }
+  const features = value["features"];
+  if (features !== void 0 && (!Array.isArray(features) || !features.every((feature) => typeof feature === "string")))
+    return "features must be an array of strings";
+  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 chunkZCGKGDCL_cjs.HistoryLimitExceeded) execution?.failTask("HISTORY_LIMIT", message, stack);
+    else if (error instanceof chunkZCGKGDCL_cjs.DeterminismViolation || error instanceof Error && error.name === "DeterminismViolation")
+      execution?.failTask("NON_DETERMINISM", message, stack);
+    else execution?.failTask("INTERNAL", message, stack);
+  };
+  return Object.freeze({
+    protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
+    sdkVersion: chunkVA4OFR72_cjs.SDK_VERSION,
+    capabilities: Object.freeze([...chunkTYF56RGB_cjs.RUNTIME_CAPABILITIES]),
+    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"] !== chunkTYF56RGB_cjs.HISTORY_PROTOCOL) {
+        early = failedResult(
+          "PROTOCOL_MISMATCH",
+          `This bundle speaks runtime protocol ${chunkTYF56RGB_cjs.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 exported = registry.byName.get(request.workflowFn);
+      if (!exported && registry.dynamic !== void 0 && registry.dynamicAmbiguous === true) {
+        early = failedResult(
+          "INVALID_REQUEST",
+          `More than one module exports a dynamic workflow; "${request.workflowFn}" cannot be served`
+        );
+        return;
+      }
+      const definition = exported ?? registry.dynamic;
+      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: chunkVA4OFR72_cjs.SDK_VERSION,
+          ...registry.interceptors !== void 0 ? { interceptors: registry.interceptors } : {}
+        });
+        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), chunkL24YIZY7_cjs.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";
+}
+
+exports.CommandIds = CommandIds;
+exports.RUNTIME_GLOBAL = RUNTIME_GLOBAL;
+exports.SDK_NAME = SDK_NAME;
+exports.WorkflowExecution = WorkflowExecution;
+exports.buildWorkflowRegistry = buildWorkflowRegistry;
+exports.createWorkflowRuntime = createWorkflowRuntime;
+exports.installWorkflowRuntime = installWorkflowRuntime;
+exports.isPatchMarkerId = isPatchMarkerId;
+exports.isRuntimeAbi = isRuntimeAbi;
+exports.matchActivation = matchActivation;
+exports.mismatch = mismatch;
+exports.patchMarkerId = patchMarkerId;