@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/{chunk-VRHHBPT6.js → chunk-2D3MYIIF.js}

@@ -1,13 +1,22 @@
-import { ServerFailure, failureToError, CancelledFailure, TimeoutFailure, ApplicationError, TerminatedFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, isCancellation, isRunFailure, errorToFailure, optionalMs, ActivityFailure, toMs, signalName, ChildRunFailure } from './chunk-C5OLWZ42.js';
+import { QueryHandlerSideEffect, ServerFailure, failureToError, CancelledFailure, TimeoutFailure, ApplicationError, TerminatedFailure, errorToFailure, isRunFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, isCancellation, ActivityFailure, signalName, ChildRunFailure } from './chunk-6A2FGSUS.js';
+import { captureStack, parseStack } from './chunk-M272AHEX.js';
 import { createRandom, seedOf, takeShimControl, uuidFrom } from './chunk-4LYSEANA.js';
-import { isDurableWorkflow, SDK_VERSION } from './chunk-N23SKIG4.js';
-import { utf8Bytes, splitActivations, explicitRetryPolicy, CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY } from './chunk-ABFZWYHT.js';
-import { COMMAND_EVENT_TYPES, DEFAULT_HISTORY_LIMIT, CONTINUE_AS_NEW_SUGGESTED_RATIO, HISTORY_PROTOCOL, HISTORY_LIMIT_EXCEEDED_RATIO, BUILT_IN_QUERIES } from './chunk-DJYMDLV5.js';
-import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.js';
+import { resolveWorkflowInterceptors, compose, optionalMs, isActivityDefinition, checkActivityName, checkTaskQueueName, toMs, isDurableWorkflow, runRetryPolicyOf, continueAsNewRetryOf, interceptorsFactoryOf, SDK_VERSION } from './chunk-C4F5KJTI.js';
+import { utf8Bytes, splitActivations, CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, mergeSearchAttributes } from './chunk-AE5Q6ZAJ.js';
+import { isActivityNodeTypeAllowed } from './chunk-AC6ZEXVR.js';
+import { COMMAND_EVENT_TYPES, DEFAULT_HISTORY_LIMIT, CONTINUE_AS_NEW_SUGGESTED_RATIO, HISTORY_PROTOCOL, HISTORY_LIMIT_EXCEEDED_RATIO, explicitRetryPolicy, MAX_ACTIVITY_CONNECTIONS, LOCAL_ACTIVITY_MAX_TIMEOUT_MS, MAX_SINK_CALLS, RUNTIME_CAPABILITIES, computeRetryDelay, FAIRNESS_KEY_MAX_LENGTH, FAIRNESS_WEIGHT_MIN, FAIRNESS_WEIGHT_MAX, BUILT_IN_QUERIES } from './chunk-5HIVIV53.js';
 
 // src/runtime/ids.ts
 var CommandIds = class {
-  counters = { a: 0, t: 0, c: 0, s: 0, x: 0, m: 0 };
+  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;
@@ -28,7 +37,7 @@ function field(event, key) {
 function describeCommand(command) {
   switch (command.type) {
     case "SCHEDULE_ACTIVITY":
-      return `SCHEDULE_ACTIVITY ${command.activityId} (${command.nodeType} ${command.operation})`;
+      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":
@@ -45,13 +54,17 @@ function describeCommand(command) {
     case "RECORD_MARKER":
       return `RECORD_MARKER ${command.markerId}`;
     case "RECORD_LOCAL_ACTIVITY":
-      return `RECORD_LOCAL_ACTIVITY ${command.localActivityId}`;
+      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");
+  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) {
@@ -60,8 +73,13 @@ function mismatch(command, event) {
   const differ = () => `the code issued ${describeCommand(command)} where the history has ${describeEvent(event)}`;
   if (!typeOk) return differ();
   switch (command.type) {
-    case "SCHEDULE_ACTIVITY":
-      return field(event, "activityId") === command.activityId && field(event, "nodeType") === command.nodeType && field(event, "operation") === command.operation ? void 0 : differ();
+    case "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":
@@ -77,8 +95,13 @@ function mismatch(command, event) {
       return field(event, "sideEffectId") === command.sideEffectId ? void 0 : differ();
     case "RECORD_MARKER":
       return field(event, "markerId") === command.markerId ? void 0 : differ();
-    case "RECORD_LOCAL_ACTIVITY":
-      return field(event, "localActivityId") === command.localActivityId ? void 0 : differ();
+    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;
   }
@@ -90,6 +113,7 @@ function isSkippablePatch(event) {
 function matchActivation(commands, recorded) {
   let position = 0;
   for (const command of commands) {
+    if (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;
@@ -114,40 +138,36 @@ function matchActivation(commands, recorded) {
   return void 0;
 }
 
-// src/runtime/stack.ts
-var RUNTIME_FRAME = /fluidgrids-runtime|\/runtime\/(scheduler|index)\.|WorkflowExecution|RuntimeContext/;
-function captureStack() {
-  const stack = new Error("stack").stack ?? "";
-  return stack.split("\n").slice(1).filter((line) => line.trim() !== "" && !RUNTIME_FRAME.test(line)).join("\n");
-}
-var V8_FRAME = /^\s*at (?:(.*?) \()?(.*?):(\d+):(\d+)\)?$/;
-var QUICKJS_FRAME = /^\s*at (?:(.*?) )?\(?(.*?)(?::(\d+))?(?::(\d+))?\)?$/;
-function parseStack(stack) {
-  const locations = [];
-  for (const line of stack.split("\n")) {
-    if (line.trim() === "") continue;
-    const match = V8_FRAME.exec(line) ?? QUICKJS_FRAME.exec(line);
-    if (!match) continue;
-    const location = {};
-    if (match[1]) location.functionName = match[1];
-    if (match[2]) location.filePath = match[2];
-    if (match[3]) location.line = Number(match[3]);
-    if (match[4]) location.column = Number(match[4]);
-    locations.push(location);
-  }
-  return locations;
-}
-
 // src/runtime/scheduler.ts
+var 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 BUILT_IN_QUERIES.includes(name);
+}
 var SDK_NAME = "@fluidgrids/workflows";
 var ContinueAsNewRequest = class {
-  constructor(input, options) {
+  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;
@@ -222,6 +242,32 @@ var Scope = class {
     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 > FAIRNESS_KEY_MAX_LENGTH))
+    throw new TypeError(
+      `fairnessKey must be a string of 1 to ${FAIRNESS_KEY_MAX_LENGTH} characters`
+    );
+  const weight = options.fairnessWeight;
+  if (weight !== void 0 && (typeof weight !== "number" || !Number.isFinite(weight) || weight < FAIRNESS_WEIGHT_MIN || weight > FAIRNESS_WEIGHT_MAX))
+    throw new TypeError(
+      `fairnessWeight must be a number from ${FAIRNESS_WEIGHT_MIN} to ${FAIRNESS_WEIGHT_MAX}`
+    );
+}
 function toJson(value, what) {
   if (value === void 0) return null;
   if (typeof value === "function" || typeof value === "symbol")
@@ -251,6 +297,54 @@ function messageOf(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 = 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;
@@ -261,7 +355,7 @@ var WorkflowExecution = class {
   activationOpen = false;
   replaying = false;
   clock = 0;
-  random;
+  randomSource;
   ids = new CommandIds();
   commands = [];
   newCommands = [];
@@ -300,7 +394,34 @@ var WorkflowExecution = class {
   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;
@@ -323,7 +444,7 @@ var WorkflowExecution = class {
     this.limitEvents = limit.events;
     this.limitBytes = limit.bytes;
     this.captureStacks = input.request.kind === "query";
-    this.random = createRandom(seedOf(randomnessSeedOf(input.request)));
+    this.randomSource = createRandom(seedOf(randomnessSeedOf(input.request)));
     for (const event of history) {
       if (event.type === "SIDE_EFFECT_RECORDED") {
         const id = event.payload["sideEffectId"];
@@ -332,17 +453,67 @@ var WorkflowExecution = class {
       } 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 = 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 = 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 = {
-      ...input.request.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;
       },
@@ -365,9 +536,33 @@ var WorkflowExecution = class {
   now() {
     return this.clock;
   }
-  /** The next deterministic random number. */
+  /** The next deterministic random number (`Math.random()` and `crypto.getRandomValues()`). */
   nextRandom() {
-    return this.random();
+    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 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() {
@@ -389,12 +584,26 @@ var WorkflowExecution = class {
       this.checkConditions();
       this.finishActivation();
     }
+    const requests = this.pendingLocalActivityRequests();
+    if (requests.length > 0) {
+      const requested = {
+        protocol: HISTORY_PROTOCOL,
+        outcome: "localActivityRequested",
+        commands: [],
+        localActivityRequests: requests,
+        logs: []
+      };
+      return requested;
+    }
     const result = {
       protocol: 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)
@@ -402,9 +611,19 @@ var WorkflowExecution = class {
       if (this.failure.seq !== void 0) result.failure.seq = this.failure.seq;
       if (this.failure.errorType !== void 0) result.failure.errorType = this.failure.errorType;
     }
-    if (this.request.kind === "query") result.queryResults = this.answerQueries();
+    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);
@@ -420,11 +639,54 @@ var WorkflowExecution = class {
       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)
@@ -434,11 +696,30 @@ var WorkflowExecution = class {
           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;
@@ -465,8 +746,20 @@ var WorkflowExecution = class {
         return;
       }
       case "SIGNAL_RECEIVED":
-        this.dispatchSignal(id("name"), p["payload"] ?? null);
+        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":
@@ -516,12 +809,14 @@ var WorkflowExecution = class {
     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 ActivityFailure(
-      `Activity ${activityId} (${pending.nodeType} ${pending.operation}) failed: ${cause.message}`,
+      `Activity ${activityId} (${label}) failed: ${cause.message}`,
       activityId,
       pending.nodeType,
       pending.operation,
-      cause
+      cause,
+      pending.activityName
     );
     switch (event.type) {
       case "ACTIVITY_COMPLETED":
@@ -613,10 +908,24 @@ var WorkflowExecution = class {
       else result.reject(outcome.error);
     }
   }
-  dispatchSignal(name, payload) {
+  /** Run a signal handler through the inbound `handleSignal` interceptors. */
+  signalCall(name, payload, headers, handler) {
+    if (this.inbound.length === 0) return () => handler(payload);
+    const chain = 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(() => handler(payload));
+      this.runHandler(
+        this.signalCall(name, payload, headers, handler),
+        name,
+        this.signalPolicies.get(name)
+      );
       return;
     }
     const waiters = this.signalWaiters.get(name);
@@ -628,7 +937,11 @@ var WorkflowExecution = class {
     }
     if (this.defaultSignalHandler) {
       const fallback = this.defaultSignalHandler;
-      this.runHandler(() => fallback(name, payload));
+      this.runHandler(
+        this.signalCall(name, payload, headers, (value) => fallback(name, value)),
+        name,
+        this.defaultSignalPolicy
+      );
       return;
     }
     const buffer = this.signalBuffers.get(name) ?? [];
@@ -644,7 +957,7 @@ var WorkflowExecution = class {
     if (position >= 0) this.signalOrder.splice(position, 1);
     return payload;
   }
-  runHandler(call) {
+  runHandler(call, name, policy = "WARN_AND_ABANDON") {
     let result;
     try {
       result = call();
@@ -653,23 +966,265 @@ var WorkflowExecution = class {
       return;
     }
     if (result instanceof Promise) {
-      this.runningHandlers += 1;
+      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 QueryHandlerSideEffect))
+          throw new QueryHandlerSideEffect(`${violation2} (in ${what})`);
+        throw error;
+      }
+      const violation = this.readOnlyViolation;
+      if (violation !== void 0) throw new 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 = 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 QueryHandlerSideEffect) {
+          this.failTask("WORKFLOW_CODE_ERROR", messageOf(error), stackTextOf(error));
+          return;
+        }
+        const failure = 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 = 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(
-        () => {
-          this.runningHandlers -= 1;
+        (value) => {
+          done();
+          this.completeUpdate(update, { ok: true, value });
         },
         (error) => {
-          this.runningHandlers -= 1;
-          this.onWorkflowError(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 || !(isRunFailure(error) || this.isFailureType(error))) {
+      this.onWorkflowError(error);
+      return;
+    }
+    const failure = 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 {
-      promise = Promise.resolve(this.definition.fn(this.context, input));
+      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) : compose(
+        this.inbound,
+        "execute",
+        (execute) => run(execute.input)
+      )({ workflowFn: this.request.workflowFn, input, headers: { ...this.startHeaders } });
     } catch (error) {
       promise = Promise.reject(error);
     }
@@ -699,7 +1254,13 @@ var WorkflowExecution = class {
   onWorkflowError(error) {
     if (this.closed || this.failure) return;
     if (error instanceof ContinueAsNewRequest) {
-      this.pushTerminal({ type: "CONTINUE_AS_NEW", input: error.input, options: error.options });
+      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);
@@ -719,6 +1280,10 @@ var WorkflowExecution = class {
       this.failTask("UNSUPPORTED_COMMAND", messageOf(error), stackTextOf(error));
       return;
     }
+    if (error instanceof QueryHandlerSideEffect) {
+      this.failTask("WORKFLOW_CODE_ERROR", messageOf(error), stackTextOf(error), void 0, name);
+      return;
+    }
     if (this.cancelRequested && isCancellation(error)) {
       this.pushTerminal({ type: "CANCEL_WORKFLOW" });
       return;
@@ -753,6 +1318,7 @@ var WorkflowExecution = class {
   }
   /** 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);
@@ -762,6 +1328,7 @@ var WorkflowExecution = class {
     if (this.closed || this.failure) return;
     this.commands.push(command);
     this.closed = true;
+    this.checkUnfinishedHandlers(command);
   }
   stack() {
     return this.captureStacks ? captureStack() : void 0;
@@ -777,7 +1344,7 @@ var WorkflowExecution = class {
         `${operation.nodeType} cannot run as a durable activity: only store and registry nodes and internal:http, internal:datatable, internal:set and internal:code can`,
         { type: "durable.activityTypeNotAllowed", errorType: "VALIDATION", nonRetryable: true }
       );
-    const activityId = this.ids.next("a");
+    const activityId = this.nextId("a");
     const operationName = options.operation ?? operation.operation ?? "execute";
     const nodeVersion = options.nodeVersion ?? operation.version;
     const cancellationType = options.cancellationType ?? "WAIT_CANCELLATION_COMPLETED";
@@ -804,20 +1371,119 @@ var WorkflowExecution = class {
     if (options.priority !== void 0) command.priority = options.priority;
     if (options.summary !== void 0) command.summary = options.summary;
     if (options.runOn !== void 0) command.runOn = options.runOn;
-    if (options.headers !== void 0) command.headers = { ...options.headers };
+    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 (isActivityDefinition(activity)) {
+      name = activity.name;
+      declaredQueue = activity.options.taskQueue;
+    } else throw new TypeError("ctx.activity needs an activity name or a declareActivity() value");
+    checkActivityName(name);
+    const taskQueue = options.taskQueue ?? declaredQueue ?? this.info.taskQueue ?? "managed";
+    checkTaskQueueName(taskQueue);
+    const connections = options.connections;
+    if (connections !== void 0 && (!Array.isArray(connections) || connections.length > MAX_ACTIVITY_CONNECTIONS || new Set(connections).size !== connections.length || !connections.every((entry) => typeof entry === "string" && entry !== "")))
+      throw new TypeError(
+        `connections must be at most ${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: explicitRetryPolicy(options.retry)
+    };
+    const startToClose = optionalMs(options.startToCloseTimeout, "startToCloseTimeout");
+    const scheduleToClose = optionalMs(options.scheduleToCloseTimeout, "scheduleToCloseTimeout");
+    const scheduleToStart = optionalMs(options.scheduleToStartTimeout, "scheduleToStartTimeout");
+    const heartbeat = optionalMs(options.heartbeatTimeout, "heartbeatTimeout");
+    if (startToClose !== void 0) command.startToCloseTimeout = startToClose;
+    if (scheduleToClose !== void 0) command.scheduleToCloseTimeout = scheduleToClose;
+    if (scheduleToStart !== void 0) command.scheduleToStartTimeout = scheduleToStart;
+    if (heartbeat !== void 0) command.heartbeatTimeout = heartbeat;
+    if (options.cancellationType !== void 0) command.cancellationType = options.cancellationType;
+    if (options.priority !== void 0) command.priority = options.priority;
+    if (options.summary !== void 0) command.summary = options.summary;
+    if (options.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 = 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 CancelledFailure("Scope is cancelled"));
     if (!this.push(command)) return this.never();
     this.issued.add(`activity:${activityId}`);
     return new Promise((resolve, reject) => {
-      const entry = {
-        resolve,
-        reject,
-        description: `activity ${activityId} (${operation.nodeType} ${operationName})`,
-        nodeType: operation.nodeType,
-        operation: operationName,
-        cancellationType
-      };
+      const entry = { ...pending, resolve, reject };
       const stack = this.stack();
       if (stack !== void 0) entry.stack = stack;
       entry.release = scope.onCancel(() => {
@@ -827,7 +1493,8 @@ var WorkflowExecution = class {
           activityId,
           entry.nodeType,
           entry.operation,
-          new CancelledFailure("Activity cancelled")
+          new CancelledFailure("Activity cancelled"),
+          entry.activityName
         );
         if (cancellationType !== "ABANDON")
           this.push({ type: "REQUEST_CANCEL_ACTIVITY", activityId });
@@ -839,6 +1506,124 @@ var WorkflowExecution = class {
       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 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" || !isActivityNodeTypeAllowed(descriptor.nodeType))
+      throw new 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 ? LOCAL_ACTIVITY_MAX_TIMEOUT_MS : toMs(options.startToCloseTimeout, "startToCloseTimeout");
+    if (timeout < 1 || timeout > 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 = explicitRetryPolicy(options.retry);
+    const args = toJson(options.args, `The args of ${descriptor.nodeType}`);
+    const proceed = (args2) => {
+      if (scope.consideredCancelled)
+        return Promise.reject(new CancelledFailure("Scope is cancelled"));
+      const label = `local activity ${localActivityId} (${descriptor.nodeType} ${operationName})`;
+      const wrap = (cause) => new 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(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 = 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 CancelledFailure("Local activity cancelled")));
+        });
+        this.localActivities.set(localActivityId, entry);
+      });
+    };
+    if (this.outbound.length === 0) return proceed(args);
+    const chain = 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;
   }
@@ -847,7 +1632,7 @@ var WorkflowExecution = class {
     if (durationMs <= 0) return { promise: Promise.resolve() };
     if (scope.consideredCancelled)
       return { promise: Promise.reject(new CancelledFailure("Scope is cancelled")) };
-    const timerId = this.ids.next("t");
+    const timerId = this.nextId("t");
     const command = {
       type: "START_TIMER",
       timerId,
@@ -960,13 +1745,16 @@ var WorkflowExecution = class {
       });
     });
   }
-  onSignal(signal, handler) {
+  onSignal(signal, handler, options = {}) {
+    if (typeof handler !== "function") throw new TypeError("ctx.onSignal needs a handler function");
+    const policy = checkPolicy(options.unfinishedPolicy);
     const name = 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));
+      this.runHandler(() => handler(value), name, policy);
       payload = this.takeBuffered(name);
     }
   }
@@ -976,8 +1764,36 @@ var WorkflowExecution = class {
     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));
+      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, signalName(signal), payload),
+      cancel: () => this.cancelExternal(resolved)
+    };
   }
   childTarget(target) {
     if (typeof target === "string") {
@@ -1004,6 +1820,12 @@ var WorkflowExecution = class {
     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(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"],
@@ -1025,13 +1847,39 @@ var WorkflowExecution = class {
         ...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 = 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.ids.next("c");
+    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}`);
@@ -1056,7 +1904,7 @@ var WorkflowExecution = class {
         entry.reject(error);
         return;
       }
-      const externalId = this.ids.next("x");
+      const externalId = this.nextId("x");
       if (this.push({
         type: "REQUEST_CANCEL_EXTERNAL_RUN",
         externalId,
@@ -1090,15 +1938,17 @@ var WorkflowExecution = class {
     };
   }
   child(scope, target, options) {
-    const child = this.startChildRun(
-      scope,
-      target,
-      options,
-      CHILD_DEFAULT_PARENT_CLOSE_POLICY.child
-    );
-    if (!child)
-      return scope.consideredCancelled ? Promise.reject(new CancelledFailure("Scope is cancelled")) : this.never();
-    return this.childResult(child);
+    return this.interceptChild(target, options, (opts) => {
+      const child = this.startChildRun(
+        scope,
+        target,
+        opts,
+        CHILD_DEFAULT_PARENT_CLOSE_POLICY.child
+      );
+      if (!child)
+        return scope.consideredCancelled ? Promise.reject(new CancelledFailure("Scope is cancelled")) : this.never();
+      return this.childResult(child);
+    });
   }
   childResult(child) {
     if (child.settled && child.outcome) {
@@ -1118,6 +1968,13 @@ var WorkflowExecution = class {
     });
   }
   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,
@@ -1147,7 +2004,21 @@ var WorkflowExecution = class {
     });
   }
   signalExternal(target, name, payload) {
-    const externalId = this.ids.next("x");
+    if (this.outbound.length === 0) return this.pushSignal(target, name, payload, void 0);
+    const chain = 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,
@@ -1155,6 +2026,7 @@ var WorkflowExecution = class {
       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) => {
@@ -1169,7 +2041,15 @@ var WorkflowExecution = class {
     });
   }
   cancelExternal(target) {
-    const externalId = this.ids.next("x");
+    if (this.outbound.length === 0) return this.pushCancel(target);
+    return 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}`);
@@ -1185,7 +2065,15 @@ var WorkflowExecution = class {
     });
   }
   sideEffect(fn) {
-    const sideEffectId = this.ids.next("s");
+    if (this.outbound.length === 0) return this.recordSideEffect(fn);
+    return 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;
@@ -1199,6 +2087,7 @@ var WorkflowExecution = class {
     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) {
@@ -1225,25 +2114,120 @@ var WorkflowExecution = class {
   }
   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.ids.next("m"),
+      markerId: this.nextId("m"),
       data: { currentDetails: markdown }
     });
   }
   upsertContext(entries) {
-    this.push({
-      type: "UPSERT_CONTEXT",
-      entries: toJson(entries, "The context 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
+      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 = mergeSearchAttributes(this.searchAttributes, final);
+    };
+    if (this.outbound.length === 0) apply({ attributes: json });
+    else
+      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 >= MAX_SINK_CALLS) {
+      if (!this.sinkCallsDropped) {
+        this.sinkCallsDropped = true;
+        this.logs.push({
+          level: "warn",
+          message: `More than ${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 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(explicitRetryPolicy(options.retry), "retry");
+      opts["retry"] = toJson(continueAsNewRetryOf(options.retry), "retry");
     if (options.workflowTaskTimeout !== void 0)
       opts["workflowTaskTimeout"] = toMs(options.workflowTaskTimeout, "workflowTaskTimeout");
     if (options.context !== void 0) opts["context"] = toJson(options.context, "context");
@@ -1292,6 +2276,7 @@ var WorkflowExecution = class {
       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");
@@ -1309,13 +2294,49 @@ var WorkflowExecution = class {
       );
     return out;
   }
-  answerQueries() {
-    return (this.request.queries ?? []).map((query) => {
-      if (!BUILT_IN_QUERIES.includes(query.name))
+  /**
+   * 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 = 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: `Unknown query ${String(query.name)}; custom queries are Phase C`
+          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")
@@ -1363,9 +2384,20 @@ ${entry.stack}`).join("\n\n")
   contextFor(bound) {
     const scope = () => bound ?? this.currentScope();
     const log = (level) => (message, data) => {
-      if (this.replaying) return;
+      if (this.replaying || this.readOnly !== void 0) return;
       const line = { level, message: String(message) };
-      if (data !== void 0) line.data = toJson(data, "The log data");
+      const payload = data !== void 0 ? toJson(data, "The log data") : void 0;
+      const attributes = this.outbound.length === 0 ? {} : 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 = {
@@ -1376,31 +2408,42 @@ ${entry.stack}`).join("\n\n")
     };
     const scopeFn = ((fn, options = {}) => this.cancellationScope(scope(), fn, options));
     scopeFn.current = () => scope();
-    const phaseC = (feature) => () => {
-      throw new PhaseCFeatureError(feature);
-    };
     const context = {
       info: this.info,
       log: logger,
       run: (operation, options) => this.scheduleActivity(scope(), operation, options),
-      sleep: (duration, options = {}) => this.startTimer(scope(), toMs(duration, "sleep duration"), options.summary),
+      sleep: (duration, options = {}) => {
+        const durationMs = toMs(duration, "sleep duration");
+        if (this.outbound.length === 0)
+          return this.startTimer(scope(), durationMs, options.summary);
+        const current = scope();
+        return compose(
+          this.outbound,
+          "startTimer",
+          (input) => this.startTimer(current, 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, handler) => this.onSignal(signal, handler),
+      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: (runId, signal, payload) => this.signalExternal({ runId }, signalName(signal), payload),
+      signalRun: (target, signal, payload) => this.signalExternal(this.externalTarget(target), signalName(signal), payload),
       signalParent: (signal, payload) => this.signalExternal({ parent: true }, signalName(signal), payload),
-      getRunHandle: (runId) => ({
-        runId,
-        signal: (signal, payload) => this.signalExternal({ runId }, signalName(signal), payload),
-        cancel: () => this.cancelExternal({ runId })
-      }),
-      cancelRun: (runId) => this.cancelExternal({ runId }),
+      getRunHandle: (target) => this.runHandle(target),
+      cancelRun: (target) => this.cancelExternal(this.externalTarget(target)),
       now: () => this.clock,
       random: () => this.random(),
-      uuid: () => uuidFrom(this.random),
+      uuid: () => {
+        this.assertWritable("ctx.uuid()");
+        return uuidFrom(this.randomSource);
+      },
       sideEffect: (fn) => this.sideEffect(fn),
       patched: (patchId) => this.patched(patchId, false),
       deprecatePatch: (patchId) => {
@@ -1408,13 +2451,7 @@ ${entry.stack}`).join("\n\n")
       },
       setCurrentDetails: (markdown) => this.setCurrentDetails(markdown),
       upsertContext: (entries) => this.upsertContext(entries),
-      continueAsNew: (input, options = {}) => {
-        try {
-          return Promise.reject(this.continueAsNew(input, options));
-        } catch (error) {
-          return Promise.reject(error);
-        }
-      },
+      continueAsNew: (input, options = {}) => this.continueAsNewCall(input, options),
       cancellationScope: scopeFn,
       nonCancellable: (fn) => this.cancellationScope(scope(), fn, { nonCancellable: true }),
       onCancel: (fn) => {
@@ -1450,13 +2487,14 @@ ${entry.stack}`).join("\n\n")
         };
       },
       allHandlersFinished: () => this.allHandlersFinished(),
-      activity: phaseC("ctx.activity (user activities)"),
-      localActivity: phaseC(
-        "ctx.localActivity (local activities)"
-      ),
-      handleQuery: phaseC("ctx.handleQuery (custom queries)"),
-      handleUpdate: phaseC("ctx.handleUpdate (updates)"),
-      upsertSearchAttributes: phaseC("ctx.upsertSearchAttributes (search attributes)")
+      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);
   }
@@ -1468,17 +2506,36 @@ 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 = interceptorsFactoryOf(value);
+        if (factory !== void 0 && !interceptors.includes(factory)) interceptors.push(factory);
+        continue;
+      }
       if (!isDurableWorkflow(value)) continue;
       const existing = byName.get(exportName);
       if (existing && existing !== value) ambiguous.add(exportName);
       byName.set(exportName, value);
       if (!exportNames.has(value)) exportNames.set(value, exportName);
+      if (value.dynamic === true) {
+        if (dynamic !== void 0 && dynamic !== value) dynamicAmbiguous = true;
+        dynamic ??= value;
+      }
     }
   }
-  return { byName, exportNames, ambiguous };
+  return {
+    byName,
+    exportNames,
+    ambiguous,
+    ...dynamic !== void 0 ? { dynamic } : {},
+    ...dynamicAmbiguous ? { dynamicAmbiguous } : {},
+    ...interceptors.length > 0 ? { interceptors } : {}
+  };
 }
 function failedResult(cause, message) {
   return {
@@ -1507,6 +2564,23 @@ function checkRequest(value) {
   }
   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) {
@@ -1523,6 +2597,7 @@ function createWorkflowRuntime(registry, shims = void 0) {
   return Object.freeze({
     protocol: HISTORY_PROTOCOL,
     sdkVersion: SDK_VERSION,
+    capabilities: Object.freeze([...RUNTIME_CAPABILITIES]),
     start(requestJson) {
       shims?.detach();
       execution = void 0;
@@ -1556,7 +2631,15 @@ function createWorkflowRuntime(registry, shims = void 0) {
         );
         return;
       }
-      const definition = registry.byName.get(request.workflowFn);
+      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",
@@ -1569,7 +2652,8 @@ function createWorkflowRuntime(registry, shims = void 0) {
           definition,
           exportNames: registry.exportNames,
           request,
-          sdkVersion: SDK_VERSION
+          sdkVersion: SDK_VERSION,
+          ...registry.interceptors !== void 0 ? { interceptors: registry.interceptors } : {}
         });
         execution = created;
         shims?.attach({ now: () => created.now(), random: () => created.nextRandom() });