@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/{chunk-EWYADREB.cjs → chunk-672KMMBK.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunk3FIDHONL_cjs = require('./chunk-3FIDHONL.cjs');
+var chunkTYF56RGB_cjs = require('./chunk-TYF56RGB.cjs');
 
 function failedTaskResult(cause, message) {
   return {
-    protocol: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
+    protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
     outcome: "failed",
     commands: [],
     failure: { cause, message },

package/dist/{chunk-KXJDRQ6G.js → chunk-6A2FGSUS.js}

@@ -82,16 +82,36 @@ var ApplicationError = class extends WorkflowFailure {
   }
 };
 var ActivityFailure = class extends WorkflowFailure {
-  constructor(message, activityId, nodeType, operation, cause) {
+  constructor(message, activityId, nodeType, operation, cause, activityName) {
     super(message, cause instanceof WorkflowFailure ? cause.errorType : "UNKNOWN", { cause });
     this.activityId = activityId;
     this.nodeType = nodeType;
     this.operation = operation;
+    this.activityName = activityName;
     this.name = "ActivityFailure";
   }
   activityId;
   nodeType;
   operation;
+  activityName;
+};
+var ActivityPausedError = class extends ApplicationError {
+  constructor(message = "The activity was paused", details) {
+    super(message, {
+      type: "ActivityPausedError",
+      errorType: "TRANSIENT",
+      ...details !== void 0 ? { details } : {}
+    });
+    this.name = "ActivityPausedError";
+  }
+};
+var QueryHandlerSideEffect = class extends Error {
+  constructor(what) {
+    super(
+      `${what} is not allowed in a query handler or an update validator; they must not change the run`
+    );
+    this.name = "QueryHandlerSideEffect";
+  }
 };
 var ChildRunFailure = class extends WorkflowFailure {
   constructor(message, childId, childRunId, cause) {
@@ -230,4 +250,4 @@ function failureToError(failure, depth = 0) {
   return error;
 }
 
-export { ActivityFailure, ApplicationError, CancelledFailure, ChildRunFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, ServerFailure, TerminatedFailure, TimeoutFailure, WorkflowFailure, defineQuery, defineSignal, defineUpdate, errorToFailure, failureToError, isCancellation, isRunFailure, signalName };
+export { ActivityFailure, ActivityPausedError, ApplicationError, CancelledFailure, ChildRunFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, QueryHandlerSideEffect, ServerFailure, TerminatedFailure, TimeoutFailure, WorkflowFailure, defineQuery, defineSignal, defineUpdate, errorToFailure, failureToError, isCancellation, isRunFailure, signalName };

package/dist/{chunk-OIX4O6UR.js → chunk-6OLN6BMB.js}

@@ -1,7 +1,7 @@
-import { isTier1Workflow, isOperation } from './chunk-FQSJI5NV.js';
+import { isTier1Workflow, isOperation } from './chunk-SR7TR5KX.js';
 import { BuilderError } from './chunk-JZ4TOOLN.js';
 import { isRecord, setOwn } from './chunk-PMCM2OH4.js';
-import { isDurableWorkflow, interfaceOf, toMs } from './chunk-7ILGCUI6.js';
+import { isActivityImplementation, isDurableWorkflow, interfaceOf, toMs } from './chunk-C4F5KJTI.js';
 
 // src/builder/collect.ts
 var COLLECTION_FORMAT = "fluidgrids.tier1-collection";
@@ -55,9 +55,16 @@ function triggerOf(spec, where) {
 function collectWorkflowExports(modules) {
   const exportNames = /* @__PURE__ */ new Map();
   const durable = [];
+  const implementations = [];
+  const interceptorModules = [];
   for (const [module, namespace] of modules) {
+    if (Object.hasOwn(namespace, "interceptors")) interceptorModules.push(module);
     for (const exportName of Object.keys(namespace).sort()) {
       const value = namespace[exportName];
+      if (isActivityImplementation(value)) {
+        implementations.push({ module, exportName, name: value.name });
+        continue;
+      }
       if (!isDurableWorkflow(value) || exportNames.has(value)) continue;
       exportNames.set(value, exportName);
       const options = value.options;
@@ -74,6 +81,10 @@ function collectWorkflowExports(modules) {
       const trigger = triggerOf(options.trigger, `workflow("${value.name}")`);
       if (trigger) entry.trigger = trigger;
       const settings = runSettingsOf(options);
+      if (value.dynamic === true) {
+        entry.dynamic = true;
+        settings.features.push("dynamic");
+      }
       if (Object.keys(settings.config).length > 0) entry.config = settings.config;
       if (settings.features.length > 0) entry.features = settings.features;
       durable.push(entry);
@@ -100,7 +111,9 @@ function collectWorkflowExports(modules) {
   const collection = {
     format: COLLECTION_FORMAT,
     workflows,
-    ...durable.length > 0 ? { durable } : {}
+    ...durable.length > 0 ? { durable } : {},
+    ...implementations.length > 0 ? { activityImplementations: implementations } : {},
+    ...interceptorModules.length > 0 ? { interceptorModules } : {}
   };
   return JSON.stringify(collection);
 }

package/dist/{chunk-6FSHT5IL.js → chunk-7EZIANC7.js}

@@ -1,4 +1,4 @@
-import { hashedProjection } from './chunk-BD7ZPG53.js';
+import { hashedProjection } from './chunk-NWQ5WRLE.js';
 import { isRecord, deepEqual, ownValue } from './chunk-PMCM2OH4.js';
 
 // src/ir/diff.ts

package/dist/chunk-A5SXCA62.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+// src/history/allowlist.ts
+var ACTIVITY_INTERNAL_ALLOWLIST = /* @__PURE__ */ new Set([
+  "internal:http",
+  "internal:datatable",
+  "internal:set",
+  "internal:code"
+]);
+var ACTIVITY_NODE_DENYLIST = /* @__PURE__ */ new Set([
+  "internal:end",
+  "internal:if",
+  "internal:switch",
+  "internal:loop",
+  "internal:merge",
+  "internal:wait",
+  "internal:subworkflow",
+  "internal:code-workflow",
+  "internal:wait-for-signal",
+  "internal:send-and-wait",
+  "internal:respond-to-webhook",
+  "internal:failure-triage"
+]);
+var ACTIVITY_NODE_ALLOWLIST = {
+  internal: ACTIVITY_INTERNAL_ALLOWLIST,
+  refused: ACTIVITY_NODE_DENYLIST,
+  /** Non-built-in node types (store and registry nodes) are allowed. */
+  external: "allowed"
+};
+var LEGACY_SHORT_NAMES = /* @__PURE__ */ new Set([
+  "if",
+  "switch",
+  "loop",
+  "merge",
+  "set",
+  "filter",
+  "aggregate",
+  "wait",
+  "noop",
+  "code",
+  "http",
+  "transform",
+  "validate",
+  "log",
+  "error",
+  "subworkflow",
+  "end",
+  "trigger",
+  "webhook",
+  "schedule",
+  "manual",
+  "api"
+]);
+function canonicalType(nodeType) {
+  const lower = nodeType.trim().toLowerCase();
+  return LEGACY_SHORT_NAMES.has(lower) ? `internal:${lower}` : lower;
+}
+var ACTIVITY_ASYNC_COMPLETION_ALLOWLIST = /* @__PURE__ */ new Set([
+  "internal:send-and-wait"
+]);
+function isActivityNodeTypeAllowed(nodeType, options = {}) {
+  if (typeof nodeType !== "string" || nodeType.trim() === "") return false;
+  const type = canonicalType(nodeType);
+  if (!type.startsWith("internal:")) return true;
+  if (options.asyncCompletion === true && ACTIVITY_ASYNC_COMPLETION_ALLOWLIST.has(type))
+    return true;
+  return ACTIVITY_INTERNAL_ALLOWLIST.has(type);
+}
+var ActivityNodeTypeNotAllowedError = class extends Error {
+  constructor(nodeType) {
+    super(
+      `${nodeType} cannot run as a durable activity: only store and registry nodes and internal:http, internal:datatable, internal:set and internal:code can`
+    );
+    this.nodeType = nodeType;
+    this.name = "ActivityNodeTypeNotAllowedError";
+  }
+  nodeType;
+  code = "durable.activityTypeNotAllowed";
+  errorType = "VALIDATION";
+  nonRetryable = true;
+};
+function assertActivityNodeType(nodeType, options = {}) {
+  if (!isActivityNodeTypeAllowed(nodeType, options))
+    throw new ActivityNodeTypeNotAllowedError(nodeType);
+}
+
+exports.ACTIVITY_ASYNC_COMPLETION_ALLOWLIST = ACTIVITY_ASYNC_COMPLETION_ALLOWLIST;
+exports.ACTIVITY_INTERNAL_ALLOWLIST = ACTIVITY_INTERNAL_ALLOWLIST;
+exports.ACTIVITY_NODE_ALLOWLIST = ACTIVITY_NODE_ALLOWLIST;
+exports.ACTIVITY_NODE_DENYLIST = ACTIVITY_NODE_DENYLIST;
+exports.ActivityNodeTypeNotAllowedError = ActivityNodeTypeNotAllowedError;
+exports.assertActivityNodeType = assertActivityNodeType;
+exports.isActivityNodeTypeAllowed = isActivityNodeTypeAllowed;

package/dist/chunk-AC6ZEXVR.js

@@ -0,0 +1,85 @@
+// src/history/allowlist.ts
+var ACTIVITY_INTERNAL_ALLOWLIST = /* @__PURE__ */ new Set([
+  "internal:http",
+  "internal:datatable",
+  "internal:set",
+  "internal:code"
+]);
+var ACTIVITY_NODE_DENYLIST = /* @__PURE__ */ new Set([
+  "internal:end",
+  "internal:if",
+  "internal:switch",
+  "internal:loop",
+  "internal:merge",
+  "internal:wait",
+  "internal:subworkflow",
+  "internal:code-workflow",
+  "internal:wait-for-signal",
+  "internal:send-and-wait",
+  "internal:respond-to-webhook",
+  "internal:failure-triage"
+]);
+var ACTIVITY_NODE_ALLOWLIST = {
+  internal: ACTIVITY_INTERNAL_ALLOWLIST,
+  refused: ACTIVITY_NODE_DENYLIST,
+  /** Non-built-in node types (store and registry nodes) are allowed. */
+  external: "allowed"
+};
+var LEGACY_SHORT_NAMES = /* @__PURE__ */ new Set([
+  "if",
+  "switch",
+  "loop",
+  "merge",
+  "set",
+  "filter",
+  "aggregate",
+  "wait",
+  "noop",
+  "code",
+  "http",
+  "transform",
+  "validate",
+  "log",
+  "error",
+  "subworkflow",
+  "end",
+  "trigger",
+  "webhook",
+  "schedule",
+  "manual",
+  "api"
+]);
+function canonicalType(nodeType) {
+  const lower = nodeType.trim().toLowerCase();
+  return LEGACY_SHORT_NAMES.has(lower) ? `internal:${lower}` : lower;
+}
+var ACTIVITY_ASYNC_COMPLETION_ALLOWLIST = /* @__PURE__ */ new Set([
+  "internal:send-and-wait"
+]);
+function isActivityNodeTypeAllowed(nodeType, options = {}) {
+  if (typeof nodeType !== "string" || nodeType.trim() === "") return false;
+  const type = canonicalType(nodeType);
+  if (!type.startsWith("internal:")) return true;
+  if (options.asyncCompletion === true && ACTIVITY_ASYNC_COMPLETION_ALLOWLIST.has(type))
+    return true;
+  return ACTIVITY_INTERNAL_ALLOWLIST.has(type);
+}
+var ActivityNodeTypeNotAllowedError = class extends Error {
+  constructor(nodeType) {
+    super(
+      `${nodeType} cannot run as a durable activity: only store and registry nodes and internal:http, internal:datatable, internal:set and internal:code can`
+    );
+    this.nodeType = nodeType;
+    this.name = "ActivityNodeTypeNotAllowedError";
+  }
+  nodeType;
+  code = "durable.activityTypeNotAllowed";
+  errorType = "VALIDATION";
+  nonRetryable = true;
+};
+function assertActivityNodeType(nodeType, options = {}) {
+  if (!isActivityNodeTypeAllowed(nodeType, options))
+    throw new ActivityNodeTypeNotAllowedError(nodeType);
+}
+
+export { ACTIVITY_ASYNC_COMPLETION_ALLOWLIST, ACTIVITY_INTERNAL_ALLOWLIST, ACTIVITY_NODE_ALLOWLIST, ACTIVITY_NODE_DENYLIST, ActivityNodeTypeNotAllowedError, assertActivityNodeType, isActivityNodeTypeAllowed };

package/dist/{chunk-FWBRQWRX.js → chunk-AE5Q6ZAJ.js}

@@ -1,4 +1,5 @@
-import { PHASE_C_COMMANDS, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, TERMINAL_COMMANDS, isActivityNodeTypeAllowed, isInputEvent, isCommandEvent } from './chunk-2DDULZFM.js';
+import { isActivityNodeTypeAllowed } from './chunk-AC6ZEXVR.js';
+import { PHASE_C_COMMANDS, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, TERMINAL_COMMANDS, isInputEvent, isCommandEvent } from './chunk-5HIVIV53.js';
 
 // src/history/commands.ts
 var COMMAND_FEATURES = [
@@ -29,6 +30,39 @@ var PHASE_B_PARITY_FEATURES = /* @__PURE__ */ new Set([
   "parity.canOptions",
   "parity.workflowIdTarget"
 ]);
+var PHASE_C_FEATURES = [
+  "c.updates",
+  "c.searchAttributes",
+  "c.userActivity"
+];
+var PHASE_C_FEATURE_FLAGS = {
+  "c.updates": "fluidgrids.run-control",
+  "c.searchAttributes": "fluidgrids.search-attributes",
+  "c.userActivity": "fluidgrids.self-hosted-workers"
+};
+var CODE_FEATURE_FLAGS = {
+  localActivity: "fluidgrids.durable-parity",
+  externalCancel: "fluidgrids.durable-parity",
+  childOptions: "fluidgrids.durable-parity",
+  canOptions: "fluidgrids.durable-parity",
+  autoUpgrade: "fluidgrids.durable-parity",
+  runRetry: "fluidgrids.durable-parity",
+  timeouts: "fluidgrids.durable-parity",
+  userActivity: "fluidgrids.self-hosted-workers",
+  updates: "fluidgrids.run-control",
+  queries: "fluidgrids.run-control",
+  dynamic: "fluidgrids.run-control",
+  interceptors: "fluidgrids.run-control",
+  searchAttributes: "fluidgrids.search-attributes"
+};
+var PHASE_C_CODE_FEATURES = [
+  "userActivity",
+  "updates",
+  "queries",
+  "searchAttributes",
+  "dynamic",
+  "interceptors"
+];
 var CORE_CHILD_OPTIONS = /* @__PURE__ */ new Set([
   "parentClosePolicy",
   "cancellationType",
@@ -41,7 +75,9 @@ var CORE_CHILD_OPTIONS = /* @__PURE__ */ new Set([
   "startDelay",
   "executionTimeout",
   "runTimeout",
-  "workflowTaskTimeout"
+  "workflowTaskTimeout",
+  "fairnessKey",
+  "fairnessWeight"
 ]);
 var CORE_CAN_OPTIONS = /* @__PURE__ */ new Set([
   "taskQueue",
@@ -68,6 +104,9 @@ function hasOtherKeys(value, allowed) {
 function commandFeatures(command) {
   const needed = /* @__PURE__ */ new Set();
   switch (command.type) {
+    case "SCHEDULE_ACTIVITY":
+      needed.add(command.kind === "user" ? "c.userActivity" : "core");
+      break;
     case "START_CHILD_RUN":
       needed.add("core");
       if (hasOtherKeys(command.options, CORE_CHILD_OPTIONS)) needed.add("parity.childOptions");
@@ -110,18 +149,40 @@ function isCommandEnabled(type, enabled = "core") {
   if (PHASE_B_CORE_COMMANDS.has(type)) return true;
   return enabled === "parity" && PHASE_B_PARITY_COMMANDS.has(type);
 }
+function phaseCFeaturesOf(command) {
+  return commandFeatures(command).filter((feature) => feature.startsWith("c."));
+}
 function isWorkflowCommandEnabled(command, enabled = "core") {
   if (typeof enabled === "string") {
+    if (phaseCFeaturesOf(command).length > 0) return false;
     if (command.type === "REQUEST_CANCEL_EXTERNAL_RUN" && "childId" in command.target) return true;
     return isCommandEnabled(command.type, enabled);
   }
   return commandFeatures(command).every((feature) => enabled.has(feature));
 }
+function codeFeaturesEnabledBy(enabled) {
+  if (typeof enabled === "string") return [];
+  const flags = /* @__PURE__ */ new Set(["fluidgrids.durable-functions"]);
+  for (const feature of enabled) {
+    if (PHASE_B_PARITY_FEATURES.has(feature) && !PHASE_B_CORE_FEATURES.has(feature))
+      flags.add("fluidgrids.durable-parity");
+    const flag = PHASE_C_FEATURE_FLAGS[feature];
+    if (flag !== void 0) flags.add(flag);
+  }
+  return Object.keys(CODE_FEATURE_FLAGS).filter((feature) => flags.has(CODE_FEATURE_FLAGS[feature] ?? "")).sort();
+}
 function unsupportedMessage(command, enabled = "core") {
-  if (typeof enabled === "string") return `${command.type} is not supported in this release`;
-  const missing = commandFeatures(command).filter((feature) => !enabled.has(feature));
-  const parity = missing.filter((feature) => feature.startsWith("parity."));
-  const flag = parity.length > 0 ? " (needs the fluidgrids.durable-parity flag)" : "";
+  const missing = typeof enabled === "string" ? phaseCFeaturesOf(command) : commandFeatures(command).filter((feature) => !enabled.has(feature));
+  if (missing.length === 0) return `${command.type} is not supported in this release`;
+  const flags = /* @__PURE__ */ new Set();
+  if (missing.some((feature) => feature.startsWith("parity.")))
+    flags.add("fluidgrids.durable-parity");
+  for (const feature of missing) {
+    const flag2 = PHASE_C_FEATURE_FLAGS[feature];
+    if (flag2 !== void 0) flags.add(flag2);
+  }
+  const names = [...flags];
+  const flag = names.length === 0 ? "" : ` (needs the ${names.join(" and ")} flag${names.length === 1 ? "" : "s"})`;
   return `${command.type} needs ${missing.join(", ")}, which this workspace does not enable${flag}`;
 }
 function isReliefCommand(command, lease) {
@@ -130,8 +191,9 @@ function isReliefCommand(command, lease) {
       return lease.grantedLocalActivityIds.includes(command.localActivityId);
     case "ACCEPT_UPDATE":
     case "REJECT_UPDATE":
-    case "COMPLETE_UPDATE":
       return lease.deliveredUpdateIds.includes(command.updateId);
+    case "COMPLETE_UPDATE":
+      return true;
     default:
       return false;
   }
@@ -236,9 +298,19 @@ function initialRunState() {
     sideEffects: {},
     markers: {},
     signalsReceived: 0,
-    context: {}
+    context: {},
+    updates: {},
+    searchAttributes: {}
   };
 }
+function mergeSearchAttributes(current, entries) {
+  const out = { ...current };
+  for (const [key, value] of Object.entries(entries)) {
+    if (value === null) delete out[key];
+    else out[key] = value;
+  }
+  return out;
+}
 function utf8Bytes(text) {
   let bytes = 0;
   for (let index = 0; index < text.length; index++) {
@@ -313,6 +385,8 @@ function applyEvent(state, event) {
       state.input = p["input"] ?? null;
       if (typeof p["context"] === "object" && p["context"] !== null && !Array.isArray(p["context"]))
         state.context = { ...p["context"] };
+      if (typeof p["searchAttributes"] === "object" && p["searchAttributes"] !== null && !Array.isArray(p["searchAttributes"]))
+        state.searchAttributes = mergeSearchAttributes({}, p["searchAttributes"]);
       break;
     case "WORKFLOW_TASK_SCHEDULED":
       state.task = { state: "SCHEDULED", taskId: str(p, "taskId"), attempt: state.task.attempt };
@@ -337,11 +411,14 @@ function applyEvent(state, event) {
       const id = str(p, "activityId");
       if (state.activities[id])
         throw new HistoryStateError(`Activity "${id}" is scheduled twice`, event.seq);
+      const user = p["kind"] === "user";
       state.activities[id] = {
         status: "SCHEDULED",
         attempt: 0,
+        kind: user ? "user" : "node",
         nodeType: str(p, "nodeType"),
         operation: str(p, "operation"),
+        ...user ? { activityName: str(p, "activityName"), taskQueue: str(p, "taskQueue") } : {},
         scheduledSeq: event.seq,
         ...typeof p["cancellationType"] === "string" ? { cancellationType: p["cancellationType"] } : {},
         ...typeof p["summary"] === "string" ? { summary: p["summary"] } : {}
@@ -490,6 +567,43 @@ function applyEvent(state, event) {
     case "MARKER_RECORDED":
       state.markers[str(p, "markerId")] = p["data"] ?? null;
       break;
+    case "UPDATE_ADMITTED": {
+      const id = str(p, "updateId");
+      if (state.updates[id])
+        throw new HistoryStateError(`Update "${id}" is admitted twice`, event.seq);
+      state.updates[id] = { status: "ADMITTED", name: str(p, "name"), seq: event.seq };
+      break;
+    }
+    case "UPDATE_ACCEPTED": {
+      const id = str(p, "updateId");
+      const found = state.updates[id];
+      if (found && found.status !== "ADMITTED")
+        throw new HistoryStateError(`Update "${id}" is accepted twice`, event.seq);
+      state.updates[id] = {
+        status: "ACCEPTED",
+        name: found?.name ?? str(p, "name"),
+        seq: found?.seq ?? event.seq
+      };
+      break;
+    }
+    case "UPDATE_COMPLETED": {
+      const id = str(p, "updateId");
+      const found = state.updates[id];
+      if (!found || found.status !== "ACCEPTED")
+        throw new HistoryStateError(
+          `UPDATE_COMPLETED for update "${id}" that is not accepted`,
+          event.seq
+        );
+      found.status = "COMPLETED";
+      if (failureOf(p)) found.failed = true;
+      break;
+    }
+    case "SEARCH_ATTRIBUTES_UPSERTED": {
+      const attributes = p["attributes"];
+      if (typeof attributes === "object" && attributes !== null && !Array.isArray(attributes))
+        state.searchAttributes = mergeSearchAttributes(state.searchAttributes, attributes);
+      break;
+    }
     case "CONTEXT_UPSERTED": {
       const entries = p["entries"];
       if (typeof entries === "object" && entries !== null && !Array.isArray(entries))
@@ -545,6 +659,11 @@ function payloadOf(command) {
   }
   return out;
 }
+function completedPayload(command) {
+  if (command.failure !== void 0)
+    return { updateId: command.updateId, failure: command.failure };
+  return { updateId: command.updateId, result: command.result ?? null };
+}
 function eventsForCommands(state, commands, context) {
   const issues = [];
   const events = [];
@@ -563,6 +682,8 @@ function eventsForCommands(state, commands, context) {
   const externals = new Set(Object.keys(state.externals));
   const sideEffects = new Set(Object.keys(state.sideEffects));
   const localActivities = new Set(Object.keys(state.localActivities));
+  const updates = new Map(Object.entries(state.updates).map(([id, u]) => [id, u.status]));
+  const answered = /* @__PURE__ */ new Set();
   let unsupported = false;
   commands.forEach((command, index) => {
     if (!isWorkflowCommandEnabled(command, context.enabled) && !(context.relief !== void 0 && isReliefCommand(command, context.relief))) {
@@ -577,7 +698,7 @@ function eventsForCommands(state, commands, context) {
       case "SCHEDULE_ACTIVITY":
         if (activities.has(command.activityId))
           reject(index, "activity.duplicate", `Activity "${command.activityId}" already exists`);
-        if (!isActivityNodeTypeAllowed(command.nodeType))
+        if (command.kind === "node" && !isActivityNodeTypeAllowed(command.nodeType))
           reject(
             index,
             "durable.activityTypeNotAllowed",
@@ -674,6 +795,42 @@ function eventsForCommands(state, commands, context) {
       case "CONTINUE_AS_NEW":
         events.push({ ...base, type: "WORKFLOW_CONTINUED_AS_NEW", payload: payloadOf(command) });
         break;
+      case "UPSERT_SEARCH_ATTRIBUTES":
+        events.push({ ...base, type: "SEARCH_ATTRIBUTES_UPSERTED", payload: payloadOf(command) });
+        break;
+      case "ACCEPT_UPDATE":
+      case "REJECT_UPDATE": {
+        const id = command.updateId;
+        const status = updates.get(id);
+        const delivered = context.updates?.[id];
+        if (answered.has(id) || status !== void 0 && status !== "ADMITTED") {
+          reject(index, "update.answered", `Update "${id}" is already answered`);
+          break;
+        }
+        if (status === void 0 && delivered === void 0) {
+          reject(index, "update.unknown", `Update "${id}" was not delivered to this task`);
+          break;
+        }
+        answered.add(id);
+        if (command.type === "REJECT_UPDATE") break;
+        updates.set(id, "ACCEPTED");
+        const admitted = state.updates[id];
+        const payload = { updateId: id, name: admitted?.name ?? delivered?.name ?? "" };
+        if (delivered?.args !== void 0) payload["args"] = delivered.args;
+        if (delivered?.headers !== void 0) payload["headers"] = { ...delivered.headers };
+        events.push({ ...base, type: "UPDATE_ACCEPTED", payload });
+        break;
+      }
+      case "COMPLETE_UPDATE": {
+        const id = command.updateId;
+        if (updates.get(id) !== "ACCEPTED") {
+          reject(index, "update.notAccepted", `Update "${id}" is not accepted`);
+          break;
+        }
+        updates.set(id, "COMPLETED");
+        events.push({ ...base, type: "UPDATE_COMPLETED", payload: completedPayload(command) });
+        break;
+      }
     }
   });
   if (issues.length > 0)
@@ -717,4 +874,4 @@ function codeWorkflowParentClosePolicy(state) {
 var CHILD_DEFAULT_PARENT_CLOSE_POLICY = Object.freeze({ child: "TERMINATE", startChild: "ABANDON" });
 var CHILD_DEFAULT_CANCELLATION_TYPE = "WAIT_CANCELLATION_COMPLETED";
 
-export { CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, COMMAND_FEATURES, CORE_CAN_OPTIONS, CORE_CHILD_OPTIONS, HistoryStateError, PHASE_B_CORE_FEATURES, PHASE_B_PARITY_FEATURES, applyEvent, codeWorkflowParentClosePolicy, commandFeatures, continueAsNewRetryShape, eventsForCommands, hasUnprocessedInput, initialRunState, isActivityOpen, isChildOpen, isCommandEnabled, isReliefCommand, isWorkflowCommandEnabled, pendingCounts, projectRunState, splitActivations, taskCompletedEvents, unseenInputs, unsupportedMessage, utf8Bytes };
+export { CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, CODE_FEATURE_FLAGS, COMMAND_FEATURES, CORE_CAN_OPTIONS, CORE_CHILD_OPTIONS, HistoryStateError, PHASE_B_CORE_FEATURES, PHASE_B_PARITY_FEATURES, PHASE_C_CODE_FEATURES, PHASE_C_FEATURES, PHASE_C_FEATURE_FLAGS, applyEvent, codeFeaturesEnabledBy, codeWorkflowParentClosePolicy, commandFeatures, continueAsNewRetryShape, eventsForCommands, hasUnprocessedInput, initialRunState, isActivityOpen, isChildOpen, isCommandEnabled, isReliefCommand, isWorkflowCommandEnabled, mergeSearchAttributes, pendingCounts, projectRunState, splitActivations, taskCompletedEvents, unseenInputs, unsupportedMessage, utf8Bytes };