@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/{chunk-OMY3CKUZ.cjs → chunk-GEQDGUGB.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 
-var chunkELL2RBML_cjs = require('./chunk-ELL2RBML.cjs');
+var chunkZCGKGDCL_cjs = require('./chunk-ZCGKGDCL.cjs');
 var chunkQ4MWQNJK_cjs = require('./chunk-Q4MWQNJK.cjs');
 var chunkL24YIZY7_cjs = require('./chunk-L24YIZY7.cjs');
-var chunkJ3PYFGKA_cjs = require('./chunk-J3PYFGKA.cjs');
-var chunkRUQIMTN5_cjs = require('./chunk-RUQIMTN5.cjs');
-var chunk3FIDHONL_cjs = require('./chunk-3FIDHONL.cjs');
-var chunkYHBVMOMK_cjs = require('./chunk-YHBVMOMK.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 {
@@ -39,7 +39,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":
@@ -57,22 +57,31 @@ function describeCommand(command) {
       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");
+  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 = chunk3FIDHONL_cjs.COMMAND_EVENT_TYPES[command.type];
+  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":
-      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":
@@ -88,6 +97,9 @@ 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 "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();
@@ -103,6 +115,7 @@ function isSkippablePatch(event) {
 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;
@@ -128,15 +141,35 @@ function matchActivation(commands, recorded) {
 }
 
 // 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) {
+  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;
@@ -187,7 +220,7 @@ var Scope = class {
   cancel() {
     if (this.consideredCancelled) return;
     this.consideredCancelled = true;
-    this.rejectRequested(new chunkELL2RBML_cjs.CancelledFailure("Cancellation requested"));
+    this.rejectRequested(new chunkZCGKGDCL_cjs.CancelledFailure("Cancellation requested"));
     const errors = [];
     const handlers = [...this.handlers];
     this.handlers.clear();
@@ -211,6 +244,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 > 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")
@@ -279,6 +338,11 @@ function infoFromStarted(info, started) {
   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;
@@ -293,7 +357,7 @@ var WorkflowExecution = class {
   activationOpen = false;
   replaying = false;
   clock = 0;
-  random;
+  randomSource;
   ids = new CommandIds();
   commands = [];
   newCommands = [];
@@ -338,6 +402,24 @@ var WorkflowExecution = class {
   /** 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();
@@ -355,16 +437,16 @@ var WorkflowExecution = class {
     this.bytesUpTo = [0];
     let bytes = 0;
     for (const event of history) {
-      bytes += chunkRUQIMTN5_cjs.utf8Bytes(JSON.stringify(event.payload));
+      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 ?? chunk3FIDHONL_cjs.DEFAULT_HISTORY_LIMIT;
+    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.random = chunkL24YIZY7_cjs.createRandom(chunkL24YIZY7_cjs.seedOf(randomnessSeedOf(input.request)));
+    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"];
@@ -390,7 +472,7 @@ var WorkflowExecution = class {
           ...entry.failure !== void 0 ? { failure: entry.failure } : { result: entry.result ?? null },
           attempts: entry.attempts
         });
-    this.activations = chunkRUQIMTN5_cjs.splitActivations(
+    this.activations = chunkISOIA7NV_cjs.splitActivations(
       history,
       input.request.nowMs,
       input.request.kind !== "query"
@@ -398,6 +480,30 @@ var WorkflowExecution = class {
     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,
@@ -407,6 +513,9 @@ var WorkflowExecution = class {
       get memo() {
         return { ...execution.memo };
       },
+      get searchAttributes() {
+        return { ...execution.searchAttributes };
+      },
       get historyLength() {
         return execution.historyLength;
       },
@@ -423,15 +532,39 @@ var WorkflowExecution = class {
     this.context = this.contextFor(void 0);
   }
   continueAsNewSuggested() {
-    return this.historyLength >= this.limitEvents * chunk3FIDHONL_cjs.CONTINUE_AS_NEW_SUGGESTED_RATIO || this.historyBytes >= this.limitBytes * chunk3FIDHONL_cjs.CONTINUE_AS_NEW_SUGGESTED_RATIO;
+    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. */
+  /** 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 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() {
@@ -456,7 +589,7 @@ var WorkflowExecution = class {
     const requests = this.pendingLocalActivityRequests();
     if (requests.length > 0) {
       const requested = {
-        protocol: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
+        protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
         outcome: "localActivityRequested",
         commands: [],
         localActivityRequests: requests,
@@ -465,12 +598,14 @@ var WorkflowExecution = class {
       return requested;
     }
     const result = {
-      protocol: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
+      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)
@@ -478,7 +613,8 @@ 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;
   }
   /**
@@ -505,11 +641,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)
@@ -569,8 +748,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":
@@ -590,7 +781,7 @@ var WorkflowExecution = class {
         else {
           const failure = p["failure"];
           pending.reject(
-            typeof failure === "object" && failure !== null && !Array.isArray(failure) ? chunkELL2RBML_cjs.failureToError(failure) : new chunkELL2RBML_cjs.ServerFailure(`${pending.description} was not delivered`)
+            typeof failure === "object" && failure !== null && !Array.isArray(failure) ? chunkZCGKGDCL_cjs.failureToError(failure) : new chunkZCGKGDCL_cjs.ServerFailure(`${pending.description} was not delivered`)
           );
         }
         return;
@@ -620,12 +811,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 wrap = (cause) => new chunkELL2RBML_cjs.ActivityFailure(
-      `Activity ${activityId} (${pending.nodeType} ${pending.operation}) failed: ${cause.message}`,
+    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
+      cause,
+      pending.activityName
     );
     switch (event.type) {
       case "ACTIVITY_COMPLETED":
@@ -634,19 +827,19 @@ var WorkflowExecution = class {
       case "ACTIVITY_FAILED":
         pending.reject(
           wrap(
-            failure ? chunkELL2RBML_cjs.failureToError(failure) : new chunkELL2RBML_cjs.ApplicationError("Activity failed", { errorType: "UNKNOWN" })
+            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 chunkELL2RBML_cjs.TimeoutFailure(`Activity timed out (${timeoutType})`, timeoutType))
+          wrap(new chunkZCGKGDCL_cjs.TimeoutFailure(`Activity timed out (${timeoutType})`, timeoutType))
         );
         return;
       }
       default:
-        pending.reject(wrap(new chunkELL2RBML_cjs.CancelledFailure("Activity cancelled")));
+        pending.reject(wrap(new chunkZCGKGDCL_cjs.CancelledFailure("Activity cancelled")));
     }
   }
   settleChild(event, childId) {
@@ -664,7 +857,7 @@ var WorkflowExecution = class {
     let outcome;
     const failureValue = p["failure"];
     const failure = typeof failureValue === "object" && failureValue !== null && !Array.isArray(failureValue) ? failureValue : void 0;
-    const wrap = (cause) => new chunkELL2RBML_cjs.ChildRunFailure(
+    const wrap = (cause) => new chunkZCGKGDCL_cjs.ChildRunFailure(
       `Child run ${childId} ${event.type.slice("CHILD_RUN_".length).toLowerCase().replace("_", " ")}: ${cause.message}`,
       childId,
       child.runId,
@@ -678,18 +871,18 @@ var WorkflowExecution = class {
         outcome = {
           ok: false,
           error: wrap(
-            failure ? chunkELL2RBML_cjs.failureToError(failure) : new chunkELL2RBML_cjs.ApplicationError("Child failed", { errorType: "UNKNOWN" })
+            failure ? chunkZCGKGDCL_cjs.failureToError(failure) : new chunkZCGKGDCL_cjs.ApplicationError("Child failed", { errorType: "UNKNOWN" })
           )
         };
         break;
       case "CHILD_RUN_CANCELLED":
-        outcome = { ok: false, error: wrap(new chunkELL2RBML_cjs.CancelledFailure("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 chunkELL2RBML_cjs.TerminatedFailure(typeof p["reason"] === "string" ? p["reason"] : "Terminated")
+            new chunkZCGKGDCL_cjs.TerminatedFailure(typeof p["reason"] === "string" ? p["reason"] : "Terminated")
           )
         };
         break;
@@ -697,7 +890,7 @@ var WorkflowExecution = class {
         const timeoutType = typeof p["timeoutType"] === "string" ? p["timeoutType"] : "WORKFLOW_RUN";
         outcome = {
           ok: false,
-          error: wrap(new chunkELL2RBML_cjs.TimeoutFailure(`Child run timed out (${timeoutType})`, timeoutType))
+          error: wrap(new chunkZCGKGDCL_cjs.TimeoutFailure(`Child run timed out (${timeoutType})`, timeoutType))
         };
       }
     }
@@ -717,10 +910,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 = 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(() => handler(payload), name, this.signalPolicies.get(name));
+      this.runHandler(
+        this.signalCall(name, payload, headers, handler),
+        name,
+        this.signalPolicies.get(name)
+      );
       return;
     }
     const waiters = this.signalWaiters.get(name);
@@ -732,7 +939,11 @@ var WorkflowExecution = class {
     }
     if (this.defaultSignalHandler) {
       const fallback = this.defaultSignalHandler;
-      this.runHandler(() => fallback(name, payload), name, this.defaultSignalPolicy);
+      this.runHandler(
+        this.signalCall(name, payload, headers, (value) => fallback(name, value)),
+        name,
+        this.defaultSignalPolicy
+      );
       return;
     }
     const buffer = this.signalBuffers.get(name) ?? [];
@@ -757,22 +968,228 @@ var WorkflowExecution = class {
       return;
     }
     if (result instanceof Promise) {
-      this.runningHandlers += 1;
-      const entry = this.running.get(name) ?? { count: 0, policy };
-      entry.count += 1;
-      entry.policy = policy;
-      this.running.set(name, entry);
-      const done = () => {
-        this.runningHandlers -= 1;
-        entry.count -= 1;
-        if (entry.count === 0) this.running.delete(name);
-      };
+      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
@@ -780,13 +1197,18 @@ var WorkflowExecution = class {
    */
   checkUnfinishedHandlers(command) {
     if (this.replaying || command.type === "CANCEL_WORKFLOW") return;
-    const unfinished = [...this.running.entries()].filter(([, entry]) => entry.count > 0 && entry.policy === "WARN_AND_ABANDON").map(([name, entry]) => ({ kind: "signal", name, count: entry.count })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    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} signal handler${total === 1 ? " was" : "s were"} still running (${unfinished.map((entry) => `${entry.name} x${entry.count}`).join(
+      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 }))
@@ -796,7 +1218,15 @@ var WorkflowExecution = class {
   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) : chunkVA4OFR72_cjs.compose(
+        this.inbound,
+        "execute",
+        (execute) => run(execute.input)
+      )({ workflowFn: this.request.workflowFn, input, headers: { ...this.startHeaders } });
     } catch (error) {
       promise = Promise.reject(error);
     }
@@ -826,15 +1256,21 @@ 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);
-    if (error instanceof chunkELL2RBML_cjs.DeterminismViolation || name === "DeterminismViolation") {
+    if (error instanceof chunkZCGKGDCL_cjs.DeterminismViolation || name === "DeterminismViolation") {
       this.failTask("NON_DETERMINISM", messageOf(error), stackTextOf(error), void 0, name);
       return;
     }
-    if (error instanceof chunkELL2RBML_cjs.HistoryLimitExceeded) {
+    if (error instanceof chunkZCGKGDCL_cjs.HistoryLimitExceeded) {
       this.failTask("HISTORY_LIMIT", messageOf(error), stackTextOf(error));
       return;
     }
@@ -842,16 +1278,20 @@ var WorkflowExecution = class {
       this.failTask("ISOLATE_MEMORY", messageOf(error), stackTextOf(error), void 0, name);
       return;
     }
-    if (error instanceof chunkELL2RBML_cjs.PhaseCFeatureError) {
+    if (error instanceof chunkZCGKGDCL_cjs.PhaseCFeatureError) {
       this.failTask("UNSUPPORTED_COMMAND", messageOf(error), stackTextOf(error));
       return;
     }
-    if (this.cancelRequested && chunkELL2RBML_cjs.isCancellation(error)) {
+    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 (chunkELL2RBML_cjs.isRunFailure(error) || this.isFailureType(error)) {
-      this.pushTerminal({ type: "FAIL_WORKFLOW", failure: chunkELL2RBML_cjs.errorToFailure(error) });
+    if (chunkZCGKGDCL_cjs.isRunFailure(error) || this.isFailureType(error)) {
+      this.pushTerminal({ type: "FAIL_WORKFLOW", failure: chunkZCGKGDCL_cjs.errorToFailure(error) });
       return;
     }
     this.failTask(
@@ -873,13 +1313,14 @@ var WorkflowExecution = class {
    */
   checkLimit() {
     const events = this.historyLength + this.commands.length;
-    if (events >= this.limitEvents * chunk3FIDHONL_cjs.HISTORY_LIMIT_EXCEEDED_RATIO || this.historyBytes >= this.limitBytes * chunk3FIDHONL_cjs.HISTORY_LIMIT_EXCEEDED_RATIO)
-      throw new chunkELL2RBML_cjs.HistoryLimitExceeded(
+    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);
@@ -900,12 +1341,12 @@ var WorkflowExecution = class {
   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" || !chunk3FIDHONL_cjs.isActivityNodeTypeAllowed(operation.nodeType))
-      throw new chunkELL2RBML_cjs.ApplicationError(
+    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.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";
@@ -916,14 +1357,14 @@ var WorkflowExecution = class {
       nodeType: operation.nodeType,
       operation: operationName,
       args: toJson(options.args, `The args of ${operation.nodeType}`),
-      retry: chunkYHBVMOMK_cjs.explicitRetryPolicy(options.retry)
+      retry: chunkTYF56RGB_cjs.explicitRetryPolicy(options.retry)
     };
     if (nodeVersion !== void 0) command.nodeVersion = nodeVersion;
     if (options.connection !== void 0) command.connection = options.connection;
-    const startToClose = chunkJ3PYFGKA_cjs.optionalMs(options.startToCloseTimeout, "startToCloseTimeout");
-    const scheduleToClose = chunkJ3PYFGKA_cjs.optionalMs(options.scheduleToCloseTimeout, "scheduleToCloseTimeout");
-    const scheduleToStart = chunkJ3PYFGKA_cjs.optionalMs(options.scheduleToStartTimeout, "scheduleToStartTimeout");
-    const heartbeat = chunkJ3PYFGKA_cjs.optionalMs(options.heartbeatTimeout, "heartbeatTimeout");
+    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;
@@ -932,30 +1373,130 @@ 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 };
-    if (scope.consideredCancelled)
-      return Promise.reject(new chunkELL2RBML_cjs.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,
+    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 chunkELL2RBML_cjs.ActivityFailure(
+        const cancelled = new chunkZCGKGDCL_cjs.ActivityFailure(
           `Activity ${activityId} cancelled`,
           activityId,
           entry.nodeType,
           entry.operation,
-          new chunkELL2RBML_cjs.CancelledFailure("Activity cancelled")
+          new chunkZCGKGDCL_cjs.CancelledFailure("Activity cancelled"),
+          entry.activityName
         );
         if (cancellationType !== "ABANDON")
           this.push({ type: "REQUEST_CANCEL_ACTIVITY", activityId });
@@ -977,98 +1518,112 @@ var WorkflowExecution = class {
    */
   localActivity(scope, operation, options) {
     if (typeof operation === "function")
-      throw new chunkELL2RBML_cjs.PhaseCFeatureError("ctx.localActivity with a function (user local activities)");
+      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" || !chunk3FIDHONL_cjs.isActivityNodeTypeAllowed(descriptor.nodeType))
-      throw new chunkELL2RBML_cjs.ApplicationError(
+    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 ? chunk3FIDHONL_cjs.LOCAL_ACTIVITY_MAX_TIMEOUT_MS : chunkJ3PYFGKA_cjs.toMs(options.startToCloseTimeout, "startToCloseTimeout");
-    if (timeout < 1 || timeout > chunk3FIDHONL_cjs.LOCAL_ACTIVITY_MAX_TIMEOUT_MS)
+    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.ids.next("l");
+    const localActivityId = this.nextId("l");
     const operationName = options.operation ?? descriptor.operation ?? "execute";
     const nodeVersion = options.nodeVersion ?? descriptor.version;
-    const retry = chunkYHBVMOMK_cjs.explicitRetryPolicy(options.retry);
+    const retry = chunkTYF56RGB_cjs.explicitRetryPolicy(options.retry);
     const args = toJson(options.args, `The args of ${descriptor.nodeType}`);
-    if (scope.consideredCancelled)
-      return Promise.reject(new chunkELL2RBML_cjs.CancelledFailure("Scope is cancelled"));
-    const label = `local activity ${localActivityId} (${descriptor.nodeType} ${operationName})`;
-    const wrap = (cause) => new chunkELL2RBML_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",
+    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,
-        attempts: Math.max(1, Math.round(outcome.attempts)),
+        kind: "node",
         nodeType: descriptor.nodeType,
         operation: operationName,
-        ...outcome.failure !== void 0 ? { failure: outcome.failure } : { result: outcome.result ?? null }
+        args: args2,
+        retry,
+        startToCloseTimeout: timeout,
+        attempt,
+        backoffMs
       };
-      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(chunkELL2RBML_cjs.failureToError(outcome.failure)));
-      return Promise.resolve(outcome.result ?? null);
+      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);
+      });
     };
-    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 = chunkYHBVMOMK_cjs.computeRetryDelay(retry, given.attempts, given.failure);
-      if (!decision.retry) return record(given);
-      attempt = given.attempts + 1;
-      backoffMs = decision.delayMs;
-    }
-    const request = {
+    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,
-      kind: "node",
       nodeType: descriptor.nodeType,
       operation: operationName,
-      args,
-      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 chunkELL2RBML_cjs.CancelledFailure("Local activity cancelled")));
-      });
-      this.localActivities.set(localActivityId, entry);
+      args
     });
   }
   startTimer(scope, durationMs, summary) {
@@ -1078,8 +1633,8 @@ var WorkflowExecution = class {
   timer(scope, durationMs, summary) {
     if (durationMs <= 0) return { promise: Promise.resolve() };
     if (scope.consideredCancelled)
-      return { promise: Promise.reject(new chunkELL2RBML_cjs.CancelledFailure("Scope is cancelled")) };
-    const timerId = this.ids.next("t");
+      return { promise: Promise.reject(new chunkZCGKGDCL_cjs.CancelledFailure("Scope is cancelled")) };
+    const timerId = this.nextId("t");
     const command = {
       type: "START_TIMER",
       timerId,
@@ -1100,7 +1655,7 @@ var WorkflowExecution = class {
         if (!this.timers.has(timerId)) return;
         this.timers.delete(timerId);
         this.push({ type: "CANCEL_TIMER", timerId });
-        reject(new chunkELL2RBML_cjs.CancelledFailure("Timer cancelled"));
+        reject(new chunkZCGKGDCL_cjs.CancelledFailure("Timer cancelled"));
       });
       this.timers.set(timerId, entry);
     });
@@ -1118,14 +1673,14 @@ var WorkflowExecution = class {
   condition(scope, predicate, timeout) {
     if (predicate()) return Promise.resolve(true);
     if (scope.consideredCancelled)
-      return Promise.reject(new chunkELL2RBML_cjs.CancelledFailure("Scope is cancelled"));
+      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, chunkJ3PYFGKA_cjs.toMs(timeout, "condition 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(
           () => {
@@ -1141,7 +1696,7 @@ var WorkflowExecution = class {
         if (!this.conditions.includes(condition)) return;
         this.conditions = this.conditions.filter((entry) => entry !== condition);
         this.cancelOwnTimer(condition.timerId);
-        reject(new chunkELL2RBML_cjs.CancelledFailure("Condition cancelled"));
+        reject(new chunkZCGKGDCL_cjs.CancelledFailure("Condition cancelled"));
       });
     });
   }
@@ -1169,7 +1724,7 @@ var WorkflowExecution = class {
     return fired;
   }
   signalReceived(scope, signal) {
-    const name = chunkELL2RBML_cjs.signalName(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) => {
@@ -1188,16 +1743,14 @@ var WorkflowExecution = class {
         const position = list.indexOf(entry);
         if (position < 0) return;
         list.splice(position, 1);
-        reject(new chunkELL2RBML_cjs.CancelledFailure("Signal wait cancelled"));
+        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 = options.unfinishedPolicy ?? "WARN_AND_ABANDON";
-    if (policy !== "WARN_AND_ABANDON" && policy !== "ABANDON")
-      throw new TypeError("unfinishedPolicy must be WARN_AND_ABANDON or ABANDON");
-    const name = chunkELL2RBML_cjs.signalName(signal);
+    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);
@@ -1240,7 +1793,7 @@ var WorkflowExecution = class {
     return {
       runId: "runId" in resolved ? resolved.runId : "",
       ..."workflowId" in resolved ? { workflowKey: resolved.workflowKey, workflowId: resolved.workflowId } : {},
-      signal: (signal, payload) => this.signalExternal(resolved, chunkELL2RBML_cjs.signalName(signal), payload),
+      signal: (signal, payload) => this.signalExternal(resolved, chunkZCGKGDCL_cjs.signalName(signal), payload),
       cancel: () => this.cancelExternal(resolved)
     };
   }
@@ -1249,7 +1802,7 @@ var WorkflowExecution = class {
       if (target === "") throw new TypeError("ctx.child needs a workflow key or function");
       return { workflowKey: target };
     }
-    if (chunkJ3PYFGKA_cjs.isDurableWorkflow(target)) {
+    if (chunkVA4OFR72_cjs.isDurableWorkflow(target)) {
       const exportName = this.exportNames.get(target);
       if (exportName === void 0)
         throw new TypeError(
@@ -1270,7 +1823,7 @@ var WorkflowExecution = class {
     if (options.context !== void 0)
       opts["context"] = toJson(options.context, "The child context");
     if (options.retry !== void 0)
-      opts["retry"] = toJson(chunkJ3PYFGKA_cjs.runRetryPolicyOf(options.retry), "The child retry policy");
+      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;
@@ -1284,7 +1837,7 @@ var WorkflowExecution = class {
     for (const [key, name] of durations) {
       const value = options[key];
       if (value !== void 0 && (typeof value === "number" || typeof value === "string"))
-        opts[name] = chunkJ3PYFGKA_cjs.toMs(value, name);
+        opts[name] = chunkVA4OFR72_cjs.toMs(value, name);
     }
     const command = {
       type: "START_CHILD_RUN",
@@ -1296,13 +1849,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 = 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.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}`);
@@ -1315,19 +1894,19 @@ var WorkflowExecution = class {
   onChildCancel(child, entry) {
     return () => {
       if (child.settled) return;
-      const type = child.cancellationType ?? chunkRUQIMTN5_cjs.CHILD_DEFAULT_CANCELLATION_TYPE;
-      const error = new chunkELL2RBML_cjs.ChildRunFailure(
+      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 chunkELL2RBML_cjs.CancelledFailure("Child run cancelled")
+        new chunkZCGKGDCL_cjs.CancelledFailure("Child run cancelled")
       );
       if (type === "ABANDON") {
         child.result = void 0;
         entry.reject(error);
         return;
       }
-      const externalId = this.ids.next("x");
+      const externalId = this.nextId("x");
       if (this.push({
         type: "REQUEST_CANCEL_EXTERNAL_RUN",
         externalId,
@@ -1361,15 +1940,17 @@ var WorkflowExecution = class {
     };
   }
   child(scope, target, options) {
-    const child = this.startChildRun(
-      scope,
-      target,
-      options,
-      chunkRUQIMTN5_cjs.CHILD_DEFAULT_PARENT_CLOSE_POLICY.child
-    );
-    if (!child)
-      return scope.consideredCancelled ? Promise.reject(new chunkELL2RBML_cjs.CancelledFailure("Scope is cancelled")) : this.never();
-    return this.childResult(child);
+    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) {
@@ -1389,14 +1970,21 @@ 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,
       options,
-      chunkRUQIMTN5_cjs.CHILD_DEFAULT_PARENT_CLOSE_POLICY.startChild
+      chunkISOIA7NV_cjs.CHILD_DEFAULT_PARENT_CLOSE_POLICY.startChild
     );
     if (!child)
-      return scope.consideredCancelled ? Promise.reject(new chunkELL2RBML_cjs.CancelledFailure("Scope is cancelled")) : this.never();
+      return scope.consideredCancelled ? Promise.reject(new chunkZCGKGDCL_cjs.CancelledFailure("Scope is cancelled")) : this.never();
     return new Promise((resolve, reject) => {
       const entry = {
         resolve,
@@ -1411,14 +1999,28 @@ var WorkflowExecution = class {
         childId: child.childId,
         runId: runId ?? child.runId ?? "",
         result: () => this.childResult(child),
-        signal: (signal, payload) => this.signalExternal({ childId: child.childId }, chunkELL2RBML_cjs.signalName(signal), payload),
+        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) {
-    const externalId = this.ids.next("x");
+    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,
@@ -1426,6 +2028,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) => {
@@ -1440,7 +2043,15 @@ var WorkflowExecution = class {
     });
   }
   cancelExternal(target) {
-    const externalId = this.ids.next("x");
+    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}`);
@@ -1456,7 +2067,15 @@ var WorkflowExecution = class {
     });
   }
   sideEffect(fn) {
-    const sideEffectId = this.ids.next("s");
+    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;
@@ -1470,6 +2089,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) {
@@ -1496,26 +2116,122 @@ 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) {
     const json = toJson(entries, "The context entries");
     if (!isJsonObject(json)) throw new TypeError("ctx.upsertContext takes an object");
-    if (this.push({ type: "UPSERT_CONTEXT", entries: json })) this.memo = { ...this.memo, ...json };
+    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(chunkJ3PYFGKA_cjs.continueAsNewRetryOf(options.retry), "retry");
+      opts["retry"] = toJson(chunkVA4OFR72_cjs.continueAsNewRetryOf(options.retry), "retry");
     if (options.workflowTaskTimeout !== void 0)
-      opts["workflowTaskTimeout"] = chunkJ3PYFGKA_cjs.toMs(options.workflowTaskTimeout, "workflowTaskTimeout");
+      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;
@@ -1525,7 +2241,7 @@ var WorkflowExecution = class {
     const scope = new Scope(parent, options.nonCancellable === true);
     let timerId;
     if (options.timeout !== void 0) {
-      const timer = this.timer(parent, chunkJ3PYFGKA_cjs.toMs(options.timeout, "scope 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(),
@@ -1580,13 +2296,49 @@ var WorkflowExecution = class {
       );
     return out;
   }
-  answerQueries() {
-    return (this.request.queries ?? []).map((query) => {
-      if (!chunk3FIDHONL_cjs.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 = 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: `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")
@@ -1634,9 +2386,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 ? {} : 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 = {
@@ -1647,14 +2410,21 @@ ${entry.stack}`).join("\n\n")
     };
     const scopeFn = ((fn, options = {}) => this.cancellationScope(scope(), fn, options));
     scopeFn.current = () => scope();
-    const phaseC = (feature) => () => {
-      throw new chunkELL2RBML_cjs.PhaseCFeatureError(feature);
-    };
     const context = {
       info: this.info,
       log: logger,
       run: (operation, options) => this.scheduleActivity(scope(), operation, options),
-      sleep: (duration, options = {}) => this.startTimer(scope(), chunkJ3PYFGKA_cjs.toMs(duration, "sleep duration"), options.summary),
+      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) => {
@@ -1666,13 +2436,16 @@ ${entry.stack}`).join("\n\n")
       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), chunkELL2RBML_cjs.signalName(signal), payload),
-      signalParent: (signal, payload) => this.signalExternal({ parent: true }, chunkELL2RBML_cjs.signalName(signal), payload),
+      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: () => chunkL24YIZY7_cjs.uuidFrom(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) => {
@@ -1680,13 +2453,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) => {
@@ -1698,7 +2465,7 @@ ${entry.stack}`).join("\n\n")
           }
         });
       },
-      isCancellation: (error) => chunkELL2RBML_cjs.isCancellation(error),
+      isCancellation: (error) => chunkZCGKGDCL_cjs.isCancellation(error),
       saga: () => {
         const compensations = [];
         return {
@@ -1722,11 +2489,14 @@ ${entry.stack}`).join("\n\n")
         };
       },
       allHandlersFinished: () => this.allHandlersFinished(),
-      activity: phaseC("ctx.activity (user activities)"),
+      activity: (activity, options) => this.userActivity(scope(), activity, options),
       localActivity: ((operation, options) => this.localActivity(scope(), operation, options)),
-      handleQuery: phaseC("ctx.handleQuery (custom queries)"),
-      handleUpdate: phaseC("ctx.handleUpdate (updates)"),
-      upsertSearchAttributes: phaseC("ctx.upsertSearchAttributes (search attributes)")
+      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);
   }
@@ -1738,21 +2508,40 @@ 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 (!chunkJ3PYFGKA_cjs.isDurableWorkflow(value)) continue;
+      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 };
+  return {
+    byName,
+    exportNames,
+    ambiguous,
+    ...dynamic !== void 0 ? { dynamic } : {},
+    ...dynamicAmbiguous ? { dynamicAmbiguous } : {},
+    ...interceptors.length > 0 ? { interceptors } : {}
+  };
 }
 function failedResult(cause, message) {
   return {
-    protocol: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
+    protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
     outcome: "failed",
     commands: [],
     failure: { cause, message },
@@ -1777,6 +2566,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) {
@@ -1785,14 +2591,15 @@ function createWorkflowRuntime(registry, shims = void 0) {
   const internalFailure = (error) => {
     const message = error instanceof Error ? error.message : String(error);
     const stack = error instanceof Error ? error.stack : void 0;
-    if (error instanceof chunkELL2RBML_cjs.HistoryLimitExceeded) execution?.failTask("HISTORY_LIMIT", message, stack);
-    else if (error instanceof chunkELL2RBML_cjs.DeterminismViolation || error instanceof Error && error.name === "DeterminismViolation")
+    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: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
-    sdkVersion: chunkJ3PYFGKA_cjs.SDK_VERSION,
+    protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
+    sdkVersion: chunkVA4OFR72_cjs.SDK_VERSION,
+    capabilities: Object.freeze([...chunkTYF56RGB_cjs.RUNTIME_CAPABILITIES]),
     start(requestJson) {
       shims?.detach();
       execution = void 0;
@@ -1807,10 +2614,10 @@ function createWorkflowRuntime(registry, shims = void 0) {
         );
         return;
       }
-      if (isObject(parsed) && parsed["protocol"] !== chunk3FIDHONL_cjs.HISTORY_PROTOCOL) {
+      if (isObject(parsed) && parsed["protocol"] !== chunkTYF56RGB_cjs.HISTORY_PROTOCOL) {
         early = failedResult(
           "PROTOCOL_MISMATCH",
-          `This bundle speaks runtime protocol ${chunk3FIDHONL_cjs.HISTORY_PROTOCOL}; the request uses ${String(parsed["protocol"])}`
+          `This bundle speaks runtime protocol ${chunkTYF56RGB_cjs.HISTORY_PROTOCOL}; the request uses ${String(parsed["protocol"])}`
         );
         return;
       }
@@ -1826,7 +2633,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",
@@ -1839,7 +2654,8 @@ function createWorkflowRuntime(registry, shims = void 0) {
           definition,
           exportNames: registry.exportNames,
           request,
-          sdkVersion: chunkJ3PYFGKA_cjs.SDK_VERSION
+          sdkVersion: chunkVA4OFR72_cjs.SDK_VERSION,
+          ...registry.interceptors !== void 0 ? { interceptors: registry.interceptors } : {}
         });
         execution = created;
         shims?.attach({ now: () => created.now(), random: () => created.nextRandom() });