@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/{chunk-NXFBVDOI.cjs → chunk-IQPXHQQQ.cjs}

@@ -4,7 +4,7 @@ var chunkG4UEPUGO_cjs = require('./chunk-G4UEPUGO.cjs');
 var chunkGVTZMA5C_cjs = require('./chunk-GVTZMA5C.cjs');
 var chunkTBDXTV22_cjs = require('./chunk-TBDXTV22.cjs');
 var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
-var chunkJ3PYFGKA_cjs = require('./chunk-J3PYFGKA.cjs');
+var chunkVA4OFR72_cjs = require('./chunk-VA4OFR72.cjs');
 
 // src/builder/descriptors.ts
 function op(nodeType, version, operation) {
@@ -63,7 +63,11 @@ var internalNodes = {
   respondToWebhook: op("internal:respond-to-webhook"),
   sendAndWait: op("internal:send-and-wait"),
   codeWorkflow: op("internal:code-workflow"),
-  waitForSignal: op("internal:wait-for-signal")
+  waitForSignal: op("internal:wait-for-signal"),
+  /** Phase C: signal another run (`fluidgrids.run-control`). */
+  signalRun: op("internal:signal-run"),
+  /** Phase C: upsert the run's search attributes (`fluidgrids.search-attributes`). */
+  setSearchAttributes: op("internal:set-search-attributes")
 };
 var nodes = {
   internal: internalNodes,
@@ -334,7 +338,7 @@ var WorkflowBuilder = class {
     let workflowFn;
     let definition;
     if (typeof fn === "string" && fn !== "") workflowFn = fn;
-    else if (chunkJ3PYFGKA_cjs.isDurableWorkflow(fn)) {
+    else if (chunkVA4OFR72_cjs.isDurableWorkflow(fn)) {
       definition = fn;
       workflowFn = fn.name;
     } else throw new chunkGVTZMA5C_cjs.BuilderError("wf.codeWorkflow needs a workflow() function or its export name");
@@ -755,7 +759,7 @@ function assembleRecording(recording, options = {}) {
   const authoring = options.authoring ?? {
     mode: "canvas",
     generator: "sdk-ts",
-    generatorVersion: chunkJ3PYFGKA_cjs.SDK_VERSION
+    generatorVersion: chunkVA4OFR72_cjs.SDK_VERSION
   };
   const out = { schemaVersion: 2 };
   for (const key of ["key", "name", "description", "interface", "code"]) {

package/dist/{chunk-RUQIMTN5.cjs → chunk-ISOIA7NV.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
-var chunk3FIDHONL_cjs = require('./chunk-3FIDHONL.cjs');
+var chunkA5SXCA62_cjs = require('./chunk-A5SXCA62.cjs');
+var chunkTYF56RGB_cjs = require('./chunk-TYF56RGB.cjs');
 
 // src/history/commands.ts
 var COMMAND_FEATURES = [
@@ -31,6 +32,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",
@@ -43,7 +77,9 @@ var CORE_CHILD_OPTIONS = /* @__PURE__ */ new Set([
   "startDelay",
   "executionTimeout",
   "runTimeout",
-  "workflowTaskTimeout"
+  "workflowTaskTimeout",
+  "fairnessKey",
+  "fairnessWeight"
 ]);
 var CORE_CAN_OPTIONS = /* @__PURE__ */ new Set([
   "taskQueue",
@@ -70,6 +106,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");
@@ -108,22 +147,44 @@ function commandFeatures(command) {
   return COMMAND_FEATURES.filter((feature) => needed.has(feature));
 }
 function isCommandEnabled(type, enabled = "core") {
-  if (chunk3FIDHONL_cjs.PHASE_C_COMMANDS.has(type)) return false;
-  if (chunk3FIDHONL_cjs.PHASE_B_CORE_COMMANDS.has(type)) return true;
-  return enabled === "parity" && chunk3FIDHONL_cjs.PHASE_B_PARITY_COMMANDS.has(type);
+  if (chunkTYF56RGB_cjs.PHASE_C_COMMANDS.has(type)) return false;
+  if (chunkTYF56RGB_cjs.PHASE_B_CORE_COMMANDS.has(type)) return true;
+  return enabled === "parity" && chunkTYF56RGB_cjs.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) {
@@ -132,8 +193,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;
   }
@@ -189,10 +251,10 @@ function walk(history) {
         continue;
       }
     }
-    if (chunk3FIDHONL_cjs.isInputEvent(event)) {
+    if (chunkTYF56RGB_cjs.isInputEvent(event)) {
       if (started) afterStarted.push(event);
       else pending.push(event);
-    } else if (chunk3FIDHONL_cjs.isCommandEvent(event) && last?.recorded) {
+    } else if (chunkTYF56RGB_cjs.isCommandEvent(event) && last?.recorded) {
       last.recorded.push(event);
     }
   }
@@ -238,9 +300,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++) {
@@ -315,6 +387,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 };
@@ -339,11 +413,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"] } : {}
@@ -492,6 +569,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))
@@ -547,6 +661,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 = [];
@@ -565,6 +684,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))) {
@@ -572,14 +693,14 @@ function eventsForCommands(state, commands, context) {
       reject(index, "commands.unsupported", unsupportedMessage(command, context.enabled));
       return;
     }
-    if (chunk3FIDHONL_cjs.TERMINAL_COMMANDS.has(command.type) && index !== commands.length - 1)
+    if (chunkTYF56RGB_cjs.TERMINAL_COMMANDS.has(command.type) && index !== commands.length - 1)
       reject(index, "commands.terminalNotLast", `${command.type} must be last`);
     const base = { taskId: context.taskId };
     switch (command.type) {
       case "SCHEDULE_ACTIVITY":
         if (activities.has(command.activityId))
           reject(index, "activity.duplicate", `Activity "${command.activityId}" already exists`);
-        if (!chunk3FIDHONL_cjs.isActivityNodeTypeAllowed(command.nodeType))
+        if (command.kind === "node" && !chunkA5SXCA62_cjs.isActivityNodeTypeAllowed(command.nodeType))
           reject(
             index,
             "durable.activityTypeNotAllowed",
@@ -676,6 +797,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)
@@ -721,13 +878,18 @@ var CHILD_DEFAULT_CANCELLATION_TYPE = "WAIT_CANCELLATION_COMPLETED";
 
 exports.CHILD_DEFAULT_CANCELLATION_TYPE = CHILD_DEFAULT_CANCELLATION_TYPE;
 exports.CHILD_DEFAULT_PARENT_CLOSE_POLICY = CHILD_DEFAULT_PARENT_CLOSE_POLICY;
+exports.CODE_FEATURE_FLAGS = CODE_FEATURE_FLAGS;
 exports.COMMAND_FEATURES = COMMAND_FEATURES;
 exports.CORE_CAN_OPTIONS = CORE_CAN_OPTIONS;
 exports.CORE_CHILD_OPTIONS = CORE_CHILD_OPTIONS;
 exports.HistoryStateError = HistoryStateError;
 exports.PHASE_B_CORE_FEATURES = PHASE_B_CORE_FEATURES;
 exports.PHASE_B_PARITY_FEATURES = PHASE_B_PARITY_FEATURES;
+exports.PHASE_C_CODE_FEATURES = PHASE_C_CODE_FEATURES;
+exports.PHASE_C_FEATURES = PHASE_C_FEATURES;
+exports.PHASE_C_FEATURE_FLAGS = PHASE_C_FEATURE_FLAGS;
 exports.applyEvent = applyEvent;
+exports.codeFeaturesEnabledBy = codeFeaturesEnabledBy;
 exports.codeWorkflowParentClosePolicy = codeWorkflowParentClosePolicy;
 exports.commandFeatures = commandFeatures;
 exports.continueAsNewRetryShape = continueAsNewRetryShape;
@@ -739,6 +901,7 @@ exports.isChildOpen = isChildOpen;
 exports.isCommandEnabled = isCommandEnabled;
 exports.isReliefCommand = isReliefCommand;
 exports.isWorkflowCommandEnabled = isWorkflowCommandEnabled;
+exports.mergeSearchAttributes = mergeSearchAttributes;
 exports.pendingCounts = pendingCounts;
 exports.projectRunState = projectRunState;
 exports.splitActivations = splitActivations;

package/dist/chunk-JSC75O5C.cjs

@@ -0,0 +1,167 @@
+'use strict';
+
+// src/history/payload-fields.ts
+var ENCODED_PAYLOAD_MARKER = "$fgp";
+var ENCODED_PAYLOAD_VERSION = 1;
+var PAYLOAD_ENCODINGS = [
+  "json/plain",
+  "binary/plain",
+  "binary/encrypted",
+  "kms/envelope"
+];
+var ENCODED_KEYS = /* @__PURE__ */ new Set(["$fgp", "encoding", "metadata", "data"]);
+var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+function isEncodedPayload(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  if (record[ENCODED_PAYLOAD_MARKER] !== ENCODED_PAYLOAD_VERSION) return false;
+  if (!Object.keys(record).every((key) => ENCODED_KEYS.has(key))) return false;
+  const encoding = record["encoding"];
+  if (typeof encoding !== "string" || encoding === "" || encoding === "json/plain") return false;
+  const data = record["data"];
+  if (typeof data !== "string" || data.length % 4 !== 0 || !BASE64.test(data)) return false;
+  const metadata = record["metadata"];
+  if (metadata === void 0) return true;
+  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) return false;
+  return Object.values(metadata).every((entry) => typeof entry === "string");
+}
+function payloadEncodingOf(value) {
+  return isEncodedPayload(value) ? value.encoding : "json/plain";
+}
+var PAYLOAD_FIELDS = {
+  WORKFLOW_STARTED: ["/input", "/lastCompletionResult", "/context"],
+  ACTIVITY_SCHEDULED: ["/args"],
+  ACTIVITY_HEARTBEAT: ["/details"],
+  ACTIVITY_COMPLETED: ["/result"],
+  ACTIVITY_CANCELLED: ["/details"],
+  SIGNAL_RECEIVED: ["/payload"],
+  UPDATE_ADMITTED: ["/args"],
+  UPDATE_ACCEPTED: ["/args"],
+  UPDATE_COMPLETED: ["/result"],
+  CHILD_RUN_INITIATED: ["/input", "/options/context"],
+  CHILD_RUN_COMPLETED: ["/result"],
+  EXTERNAL_RUN_SIGNALED: ["/payload"],
+  SIDE_EFFECT_RECORDED: ["/value"],
+  LOCAL_ACTIVITY_COMPLETED: ["/result"],
+  CONTEXT_UPSERTED: ["/entries"],
+  MARKER_RECORDED: ["/data/currentDetails"],
+  WORKFLOW_COMPLETED: ["/output"],
+  WORKFLOW_CANCELLED: ["/details"],
+  WORKFLOW_CONTINUED_AS_NEW: ["/input", "/options/context"]
+};
+var FAILURE_FIELDS = {
+  WORKFLOW_STARTED: ["/lastFailure"],
+  ACTIVITY_FAILED: ["/failure"],
+  ACTIVITY_TIMED_OUT: ["/failure"],
+  UPDATE_COMPLETED: ["/failure"],
+  CHILD_RUN_FAILED: ["/failure"],
+  EXTERNAL_RUN_SIGNALED: ["/failure"],
+  EXTERNAL_RUN_CANCEL_RESOLVED: ["/failure"],
+  LOCAL_ACTIVITY_FAILED: ["/failure"],
+  WORKFLOW_FAILED: ["/failure"],
+  WORKFLOW_TIMED_OUT: ["/failure"]
+};
+var COMMAND_PAYLOAD_FIELDS = {
+  SCHEDULE_ACTIVITY: ["/args"],
+  START_CHILD_RUN: ["/input", "/options/context"],
+  SIGNAL_RUN: ["/payload"],
+  RECORD_SIDE_EFFECT: ["/value"],
+  RECORD_MARKER: ["/data/currentDetails"],
+  COMPLETE_WORKFLOW: ["/output"],
+  UPSERT_CONTEXT: ["/entries"],
+  RECORD_LOCAL_ACTIVITY: ["/result"],
+  CONTINUE_AS_NEW: ["/input", "/options/context"],
+  COMPLETE_UPDATE: ["/result"]
+};
+var COMMAND_FAILURE_FIELDS = {
+  FAIL_WORKFLOW: ["/failure"],
+  RECORD_LOCAL_ACTIVITY: ["/failure"],
+  REJECT_UPDATE: ["/failure"],
+  COMPLETE_UPDATE: ["/failure"]
+};
+var FAILURE_PAYLOAD_FIELDS = ["/details"];
+var FAILURE_CAUSE_FIELD = "/cause";
+var PAYLOAD_FIELDS_FORMAT = "fluidgrids.payload-fields";
+var PAYLOAD_FIELDS_DOCUMENT = {
+  format: PAYLOAD_FIELDS_FORMAT,
+  formatVersion: 2,
+  description: 'JSON pointers of user payloads per event type (relative to the payload) and per command type (relative to the command). `events` and `commands` are plain payload pointers. `eventFailures` and `commandFailures` point at failure objects: the payloads of a failure are the `failure.payloads` pointers relative to it, and the same rule applies again to the failure at `failure.cause` (recursively, to the end of the cause chain). Payload codecs and the at-rest envelope apply to these pointers only; everything else stays in clear text. A value that is not plain JSON is carried as {"$fgp": 1, "encoding", "metadata"?, "data" (base64)}.',
+  encodedMarker: ENCODED_PAYLOAD_MARKER,
+  encodedVersion: ENCODED_PAYLOAD_VERSION,
+  encodings: [...PAYLOAD_ENCODINGS],
+  events: PAYLOAD_FIELDS,
+  commands: COMMAND_PAYLOAD_FIELDS,
+  eventFailures: FAILURE_FIELDS,
+  commandFailures: COMMAND_FAILURE_FIELDS,
+  failure: { payloads: FAILURE_PAYLOAD_FIELDS, cause: FAILURE_CAUSE_FIELD }
+};
+function tokensOf(pointer) {
+  if (pointer === "") return [];
+  return pointer.slice(1).split("/").map((token) => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function locate(root, pointer) {
+  const tokens = tokensOf(pointer);
+  const key = tokens.pop();
+  if (key === void 0) return void 0;
+  let holder = root;
+  for (const token of tokens) {
+    if (typeof holder !== "object" || holder === null || Array.isArray(holder)) return void 0;
+    holder = holder[token];
+  }
+  if (typeof holder !== "object" || holder === null || Array.isArray(holder)) return void 0;
+  const parent = holder;
+  if (!Object.hasOwn(parent, key) || parent[key] === void 0) return void 0;
+  return { parent, key };
+}
+function mapAt(root, pointer, fn) {
+  const found = locate(root, pointer);
+  if (found === void 0) return;
+  const current = found.parent[found.key];
+  if (current !== void 0) found.parent[found.key] = fn(current, pointer);
+}
+function mapFailureAt(root, pointer, fn) {
+  let failure = pointer;
+  for (; ; ) {
+    const found = locate(root, failure);
+    if (found === void 0) return;
+    const value = found.parent[found.key];
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+    for (const field of FAILURE_PAYLOAD_FIELDS) mapAt(root, failure + field, fn);
+    failure += FAILURE_CAUSE_FIELD;
+  }
+}
+function mapPayloadFields(record, pointers, fn, failures = []) {
+  const copy = JSON.parse(JSON.stringify(record));
+  for (const pointer of pointers) mapAt(copy, pointer, fn);
+  for (const pointer of failures) mapFailureAt(copy, pointer, fn);
+  return copy;
+}
+function mapEventPayloads(type, payload, fn) {
+  return mapPayloadFields(payload, PAYLOAD_FIELDS[type] ?? [], fn, FAILURE_FIELDS[type] ?? []);
+}
+function mapCommandPayloads(command, fn) {
+  const record = command;
+  return mapPayloadFields(
+    record,
+    COMMAND_PAYLOAD_FIELDS[command.type] ?? [],
+    fn,
+    COMMAND_FAILURE_FIELDS[command.type] ?? []
+  );
+}
+
+exports.COMMAND_FAILURE_FIELDS = COMMAND_FAILURE_FIELDS;
+exports.COMMAND_PAYLOAD_FIELDS = COMMAND_PAYLOAD_FIELDS;
+exports.ENCODED_PAYLOAD_MARKER = ENCODED_PAYLOAD_MARKER;
+exports.ENCODED_PAYLOAD_VERSION = ENCODED_PAYLOAD_VERSION;
+exports.FAILURE_CAUSE_FIELD = FAILURE_CAUSE_FIELD;
+exports.FAILURE_FIELDS = FAILURE_FIELDS;
+exports.FAILURE_PAYLOAD_FIELDS = FAILURE_PAYLOAD_FIELDS;
+exports.PAYLOAD_ENCODINGS = PAYLOAD_ENCODINGS;
+exports.PAYLOAD_FIELDS = PAYLOAD_FIELDS;
+exports.PAYLOAD_FIELDS_DOCUMENT = PAYLOAD_FIELDS_DOCUMENT;
+exports.PAYLOAD_FIELDS_FORMAT = PAYLOAD_FIELDS_FORMAT;
+exports.isEncodedPayload = isEncodedPayload;
+exports.mapCommandPayloads = mapCommandPayloads;
+exports.mapEventPayloads = mapEventPayloads;
+exports.mapPayloadFields = mapPayloadFields;
+exports.payloadEncodingOf = payloadEncodingOf;

package/dist/{chunk-BD7ZPG53.js → chunk-NWQ5WRLE.js}

@@ -47,9 +47,17 @@ var EXECUTOR_INTERNAL_TYPES = /* @__PURE__ */ new Set([
 ]);
 var CODE_WORKFLOW_NODE_TYPE = "internal:code-workflow";
 var WAIT_FOR_SIGNAL_NODE_TYPE = "internal:wait-for-signal";
+var SIGNAL_RUN_NODE_TYPE = "internal:signal-run";
+var SET_SEARCH_ATTRIBUTES_NODE_TYPE = "internal:set-search-attributes";
 var V2_NODE_TYPES = /* @__PURE__ */ new Set([
   CODE_WORKFLOW_NODE_TYPE,
-  WAIT_FOR_SIGNAL_NODE_TYPE
+  WAIT_FOR_SIGNAL_NODE_TYPE,
+  SIGNAL_RUN_NODE_TYPE,
+  SET_SEARCH_ATTRIBUTES_NODE_TYPE
+]);
+var PHASE_C_NODE_TYPES = /* @__PURE__ */ new Set([
+  SIGNAL_RUN_NODE_TYPE,
+  SET_SEARCH_ATTRIBUTES_NODE_TYPE
 ]);
 var INTERNAL_TRIGGER_TYPES = /* @__PURE__ */ new Set([
   "internal:api",
@@ -260,4 +268,4 @@ function buildIdOf(bundle) {
   return sha256Tagged(bundle);
 }
 
-export { CODE_WORKFLOW_NODE_TYPE, INTERNAL_TRIGGER_TYPES, V2_NODE_TYPES, WAIT_FOR_SIGNAL_NODE_TYPE, buildIdOf, hashedProjection, irHash, normalizeDefinition, sourceHash, usesMergedParameters };
+export { CODE_WORKFLOW_NODE_TYPE, INTERNAL_TRIGGER_TYPES, PHASE_C_NODE_TYPES, SET_SEARCH_ATTRIBUTES_NODE_TYPE, SIGNAL_RUN_NODE_TYPE, V2_NODE_TYPES, WAIT_FOR_SIGNAL_NODE_TYPE, buildIdOf, hashedProjection, irHash, normalizeDefinition, sourceHash, usesMergedParameters };