@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

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

@@ -1,15 +1,202 @@
-import { PHASE_C_COMMANDS, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, TERMINAL_COMMANDS, isInputEvent, isCommandEvent } from './chunk-DJYMDLV5.js';
-import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.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 = [
+  "core",
+  "parity.can",
+  "parity.context",
+  "parity.localActivity",
+  "parity.externalCancel",
+  "parity.childOptions",
+  "parity.canOptions",
+  "parity.workflowIdTarget",
+  "c.updates",
+  "c.searchAttributes",
+  "c.userActivity"
+];
+var PHASE_B_CORE_FEATURES = /* @__PURE__ */ new Set([
+  "core",
+  "parity.can",
+  "parity.context"
+]);
+var PHASE_B_PARITY_FEATURES = /* @__PURE__ */ new Set([
+  "core",
+  "parity.can",
+  "parity.context",
+  "parity.localActivity",
+  "parity.externalCancel",
+  "parity.childOptions",
+  "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",
+  "taskQueue",
+  "workflowId",
+  "priority",
+  "summary",
+  "details",
+  "context",
+  "startDelay",
+  "executionTimeout",
+  "runTimeout",
+  "workflowTaskTimeout",
+  "fairnessKey",
+  "fairnessWeight"
+]);
+var CORE_CAN_OPTIONS = /* @__PURE__ */ new Set([
+  "taskQueue",
+  "retry",
+  "workflowTaskTimeout",
+  "context",
+  "versioningBehavior"
+]);
+var LEGACY_RETRY_KEYS = ["retryDelay", "maxRetries", "maxDelay"];
+var RUN_RETRY_KEYS = ["initialDelayMs", "maxAttempts", "maxDelayMs"];
+function continueAsNewRetryShape(options) {
+  const retry = options["retry"];
+  if (retry === void 0) return "none";
+  if (typeof retry !== "object" || retry === null || Array.isArray(retry)) return "invalid";
+  const keys = Object.keys(retry);
+  const run = keys.some((key) => RUN_RETRY_KEYS.includes(key));
+  const legacy = keys.some((key) => LEGACY_RETRY_KEYS.includes(key));
+  if (run === legacy) return "invalid";
+  return run ? "run" : "legacy";
+}
+function hasOtherKeys(value, allowed) {
+  return Object.entries(value).some(([key, entry]) => entry !== void 0 && !allowed.has(key));
+}
+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");
+      break;
+    case "SIGNAL_RUN":
+      needed.add("core");
+      if ("workflowId" in command.target) needed.add("parity.workflowIdTarget");
+      break;
+    case "REQUEST_CANCEL_EXTERNAL_RUN":
+      if ("childId" in command.target) needed.add("core");
+      else needed.add("parity.externalCancel");
+      if ("workflowId" in command.target) needed.add("parity.workflowIdTarget");
+      break;
+    case "CONTINUE_AS_NEW":
+      needed.add("parity.can");
+      if (hasOtherKeys(command.options, CORE_CAN_OPTIONS) || continueAsNewRetryShape(command.options) === "run")
+        needed.add("parity.canOptions");
+      break;
+    case "UPSERT_CONTEXT":
+      needed.add("parity.context");
+      break;
+    case "RECORD_LOCAL_ACTIVITY":
+      needed.add("parity.localActivity");
+      break;
+    case "UPSERT_SEARCH_ATTRIBUTES":
+      needed.add("c.searchAttributes");
+      break;
+    case "ACCEPT_UPDATE":
+    case "REJECT_UPDATE":
+    case "COMPLETE_UPDATE":
+      needed.add("c.updates");
+      break;
+    default:
+      needed.add("core");
+  }
+  return COMMAND_FEATURES.filter((feature) => needed.has(feature));
+}
 function isCommandEnabled(type, enabled = "core") {
   if (PHASE_C_COMMANDS.has(type)) return false;
   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 (command.type === "REQUEST_CANCEL_EXTERNAL_RUN" && "childId" in command.target) return true;
-  return isCommandEnabled(command.type, enabled);
+  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") {
+  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) {
+  switch (command.type) {
+    case "RECORD_LOCAL_ACTIVITY":
+      return lease.grantedLocalActivityIds.includes(command.localActivityId);
+    case "ACCEPT_UPDATE":
+    case "REJECT_UPDATE":
+      return lease.deliveredUpdateIds.includes(command.updateId);
+    case "COMPLETE_UPDATE":
+      return true;
+    default:
+      return false;
+  }
 }
 
 // src/history/activation.ts
@@ -107,12 +294,23 @@ function initialRunState() {
     timers: {},
     children: {},
     externals: {},
+    localActivities: {},
     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++) {
@@ -187,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 };
@@ -211,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"] } : {}
@@ -346,9 +549,61 @@ function applyEvent(state, event) {
     case "SIDE_EFFECT_RECORDED":
       state.sideEffects[str(p, "sideEffectId")] = p["value"] ?? null;
       break;
+    case "LOCAL_ACTIVITY_COMPLETED":
+    case "LOCAL_ACTIVITY_FAILED": {
+      const id = str(p, "localActivityId");
+      if (state.localActivities[id])
+        throw new HistoryStateError(`Local activity "${id}" is recorded twice`, event.seq);
+      state.localActivities[id] = {
+        status: event.type === "LOCAL_ACTIVITY_COMPLETED" ? "COMPLETED" : "FAILED",
+        attempts: typeof p["attempts"] === "number" ? p["attempts"] : 1,
+        recordedSeq: event.seq,
+        ...typeof p["nodeType"] === "string" ? { nodeType: p["nodeType"] } : {},
+        ...typeof p["operation"] === "string" ? { operation: p["operation"] } : {},
+        ...typeof p["summary"] === "string" ? { summary: p["summary"] } : {}
+      };
+      break;
+    }
     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))
@@ -404,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 = [];
@@ -421,11 +681,14 @@ function eventsForCommands(state, commands, context) {
   const children = new Set(Object.keys(state.children));
   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)) {
+    if (!isWorkflowCommandEnabled(command, context.enabled) && !(context.relief !== void 0 && isReliefCommand(command, context.relief))) {
       unsupported = true;
-      reject(index, "commands.unsupported", `${command.type} is not supported in this release`);
+      reject(index, "commands.unsupported", unsupportedMessage(command, context.enabled));
       return;
     }
     if (TERMINAL_COMMANDS.has(command.type) && index !== commands.length - 1)
@@ -435,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",
@@ -516,6 +779,13 @@ function eventsForCommands(state, commands, context) {
         events.push({ ...base, type: "CONTEXT_UPSERTED", payload: payloadOf(command) });
         break;
       case "RECORD_LOCAL_ACTIVITY":
+        if (localActivities.has(command.localActivityId))
+          reject(
+            index,
+            "localActivity.duplicate",
+            `Local activity "${command.localActivityId}" is already recorded`
+          );
+        localActivities.add(command.localActivityId);
         events.push({
           ...base,
           type: command.failure ? "LOCAL_ACTIVITY_FAILED" : "LOCAL_ACTIVITY_COMPLETED",
@@ -525,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)
@@ -559,47 +865,6 @@ function hasUnprocessedInput(history) {
   return unseenInputs(history).length > 0;
 }
 
-// src/history/retry.ts
-var DEFAULT_ACTIVITY_RETRY = Object.freeze({
-  retryDelay: 1e3,
-  backoffMultiplier: 2,
-  maxDelay: 1e5
-});
-var FINAL_TIMEOUTS = /* @__PURE__ */ new Set(["SCHEDULE_TO_START", "SCHEDULE_TO_CLOSE"]);
-function computeRetryDelay(policy, attempt, failure) {
-  if (failure?.nonRetryable === true) return { retry: false, reason: "nonRetryable" };
-  if (failure?.timeoutType !== void 0 && FINAL_TIMEOUTS.has(failure.timeoutType))
-    return { retry: false, reason: "finalTimeout" };
-  if (failure?.type !== void 0 && policy.nonRetryableErrorTypes !== void 0 && policy.nonRetryableErrorTypes.includes(failure.type))
-    return { retry: false, reason: "typeDenied" };
-  if (failure !== void 0 && policy.retryOnErrorTypes !== void 0 && policy.retryOnErrorTypes.length > 0 && !policy.retryOnErrorTypes.includes(failure.errorType))
-    return { retry: false, reason: "errorTypeNotListed" };
-  if (policy.maxRetries !== void 0 && attempt > policy.maxRetries)
-    return { retry: false, reason: "maxRetries" };
-  if (failure?.nextRetryDelayMs !== void 0)
-    return { retry: true, delayMs: Math.max(0, Math.round(failure.nextRetryDelayMs)) };
-  const base = Math.max(0, policy.retryDelay);
-  const multiplier = policy.backoffMultiplier ?? 2;
-  const cap = policy.maxDelay ?? base * 100;
-  const exponent = Math.max(0, attempt - 1);
-  const delay = Math.min(base * Math.pow(multiplier, exponent), cap);
-  return { retry: true, delayMs: Math.round(Number.isFinite(delay) ? delay : cap) };
-}
-function explicitRetryPolicy(policy) {
-  const retryDelay = policy?.retryDelay ?? DEFAULT_ACTIVITY_RETRY.retryDelay;
-  const out = {
-    retryDelay,
-    backoffMultiplier: policy?.backoffMultiplier ?? DEFAULT_ACTIVITY_RETRY.backoffMultiplier ?? 2,
-    maxDelay: policy?.maxDelay ?? (policy?.retryDelay === void 0 ? 1e5 : Math.max(retryDelay, retryDelay * 100))
-  };
-  if (policy?.maxRetries !== void 0) out.maxRetries = policy.maxRetries;
-  if (policy?.retryOnErrorTypes !== void 0)
-    out.retryOnErrorTypes = [...policy.retryOnErrorTypes];
-  if (policy?.nonRetryableErrorTypes !== void 0)
-    out.nonRetryableErrorTypes = [...policy.nonRetryableErrorTypes];
-  return out;
-}
-
 // src/history/defaults.ts
 function codeWorkflowParentClosePolicy(state) {
   const policy = state.parentClosePolicy;
@@ -609,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, DEFAULT_ACTIVITY_RETRY, HistoryStateError, applyEvent, codeWorkflowParentClosePolicy, computeRetryDelay, eventsForCommands, explicitRetryPolicy, hasUnprocessedInput, initialRunState, isActivityOpen, isChildOpen, isCommandEnabled, isWorkflowCommandEnabled, pendingCounts, projectRunState, splitActivations, taskCompletedEvents, unseenInputs, 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 };