@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/chunk-3U2NU7YC.cjs

@@ -0,0 +1,124 @@
+'use strict';
+
+var chunkIQPXHQQQ_cjs = require('./chunk-IQPXHQQQ.cjs');
+var chunkGVTZMA5C_cjs = require('./chunk-GVTZMA5C.cjs');
+var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
+var chunkVA4OFR72_cjs = require('./chunk-VA4OFR72.cjs');
+
+// src/builder/collect.ts
+var COLLECTION_FORMAT = "fluidgrids.tier1-collection";
+function configDuration(value) {
+  return typeof value === "string" ? value : chunkVA4OFR72_cjs.toMs(value) / 1e3;
+}
+function runSettingsOf(options) {
+  const config = {};
+  const features = [];
+  if (options.runTimeout !== void 0) config.timeout = chunkVA4OFR72_cjs.toMs(options.runTimeout) / 1e3;
+  if (options.executionTimeout !== void 0)
+    config.executionTimeout = configDuration(options.executionTimeout);
+  if (options.workflowTaskTimeout !== void 0)
+    config.workflowTaskTimeout = configDuration(options.workflowTaskTimeout);
+  if (options.runTimeout !== void 0 || options.executionTimeout !== void 0 || options.workflowTaskTimeout !== void 0)
+    features.push("timeouts");
+  if (options.versioningBehavior !== void 0) {
+    config.versioningBehavior = options.versioningBehavior;
+    if (options.versioningBehavior === "AUTO_UPGRADE") features.push("autoUpgrade");
+  }
+  if (options.retry !== void 0) {
+    const retry = {};
+    if (options.retry.maxAttempts !== void 0) retry.maxAttempts = options.retry.maxAttempts;
+    if (options.retry.initialDelay !== void 0)
+      retry.initialDelay = configDuration(options.retry.initialDelay);
+    if (options.retry.backoffMultiplier !== void 0)
+      retry.backoffMultiplier = options.retry.backoffMultiplier;
+    if (options.retry.maxDelay !== void 0)
+      retry.maxDelay = configDuration(options.retry.maxDelay);
+    if (options.retry.nonRetryableErrorTypes !== void 0)
+      retry.nonRetryableErrorTypes = [...options.retry.nonRetryableErrorTypes];
+    config.retry = retry;
+    features.push("runRetry");
+  }
+  return { config, features };
+}
+function triggerOf(spec, where) {
+  if (spec === void 0) return void 0;
+  const operation = chunkIQPXHQQQ_cjs.isOperation(spec) ? spec : chunkSAENRNBJ_cjs.isRecord(spec) ? spec.operation : void 0;
+  if (!chunkIQPXHQQQ_cjs.isOperation(operation))
+    throw new chunkGVTZMA5C_cjs.BuilderError(`${where}: trigger must be a trigger operation`);
+  const out = { nodeType: operation.nodeType };
+  if (operation.version !== void 0) out.version = operation.version;
+  if (operation.operation !== void 0) out.operation = operation.operation;
+  if (!chunkIQPXHQQQ_cjs.isOperation(spec)) {
+    if (spec.args !== void 0) out.args = spec.args;
+    if (spec.id !== void 0) out.id = spec.id;
+  }
+  return out;
+}
+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 (chunkVA4OFR72_cjs.isActivityImplementation(value)) {
+        implementations.push({ module, exportName, name: value.name });
+        continue;
+      }
+      if (!chunkVA4OFR72_cjs.isDurableWorkflow(value) || exportNames.has(value)) continue;
+      exportNames.set(value, exportName);
+      const options = value.options;
+      const entry = {
+        module,
+        exportName,
+        name: value.name,
+        taskQueue: options.taskQueue ?? "managed",
+        interface: chunkVA4OFR72_cjs.interfaceOf(value)
+      };
+      if (options.title !== void 0) entry.title = options.title;
+      if (options.description !== void 0) entry.description = options.description;
+      if (options.standalone !== void 0) entry.standalone = options.standalone;
+      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);
+    }
+  }
+  const workflows = [];
+  for (const [module, namespace] of modules) {
+    for (const exportName of Object.keys(namespace).sort()) {
+      const value = namespace[exportName];
+      if (!chunkIQPXHQQQ_cjs.isTier1Workflow(value)) continue;
+      for (const ref of value.durableRefs ?? []) {
+        const resolved = exportNames.get(ref.definition);
+        if (resolved === void 0)
+          throw new chunkGVTZMA5C_cjs.BuilderError(
+            `${value.key}: wf.codeWorkflow node "${ref.nodeId}" uses workflow("${ref.definition.name}"), which no module exports`
+          );
+        const recorded = value.recording.nodes.find((entry) => entry.node.id === ref.nodeId);
+        const state = recorded?.node.args?.state;
+        if (chunkSAENRNBJ_cjs.isRecord(state)) chunkSAENRNBJ_cjs.setOwn(state, "workflowFn", resolved);
+      }
+      workflows.push({ module, exportName, recording: value.recording });
+    }
+  }
+  const collection = {
+    format: COLLECTION_FORMAT,
+    workflows,
+    ...durable.length > 0 ? { durable } : {},
+    ...implementations.length > 0 ? { activityImplementations: implementations } : {},
+    ...interceptorModules.length > 0 ? { interceptorModules } : {}
+  };
+  return JSON.stringify(collection);
+}
+
+exports.COLLECTION_FORMAT = COLLECTION_FORMAT;
+exports.collectWorkflowExports = collectWorkflowExports;

package/dist/{chunk-NEIUQASE.cjs → chunk-4QKB4ARC.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkGBQ33SIZ_cjs = require('./chunk-GBQ33SIZ.cjs');
+var chunk54FLQNUM_cjs = require('./chunk-54FLQNUM.cjs');
 var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
 
 // src/ir/diff.ts
@@ -53,8 +53,8 @@ function diffCollection(before, after, path, out) {
   }
 }
 function diffDefinitions(before, after) {
-  const left = chunkGBQ33SIZ_cjs.hashedProjection(before);
-  const right = chunkGBQ33SIZ_cjs.hashedProjection(after);
+  const left = chunk54FLQNUM_cjs.hashedProjection(before);
+  const right = chunk54FLQNUM_cjs.hashedProjection(after);
   const out = [];
   if (!chunkSAENRNBJ_cjs.isRecord(left) || !chunkSAENRNBJ_cjs.isRecord(right)) {
     diffValues(left, right, "", out);

package/dist/{chunk-GBQ33SIZ.cjs → chunk-54FLQNUM.cjs}

@@ -49,9 +49,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",
@@ -264,6 +272,9 @@ function buildIdOf(bundle) {
 
 exports.CODE_WORKFLOW_NODE_TYPE = CODE_WORKFLOW_NODE_TYPE;
 exports.INTERNAL_TRIGGER_TYPES = INTERNAL_TRIGGER_TYPES;
+exports.PHASE_C_NODE_TYPES = PHASE_C_NODE_TYPES;
+exports.SET_SEARCH_ATTRIBUTES_NODE_TYPE = SET_SEARCH_ATTRIBUTES_NODE_TYPE;
+exports.SIGNAL_RUN_NODE_TYPE = SIGNAL_RUN_NODE_TYPE;
 exports.V2_NODE_TYPES = V2_NODE_TYPES;
 exports.WAIT_FOR_SIGNAL_NODE_TYPE = WAIT_FOR_SIGNAL_NODE_TYPE;
 exports.buildIdOf = buildIdOf;

package/dist/chunk-5HIVIV53.js

@@ -0,0 +1,330 @@
+// 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;
+}
+function computeRunRetryDelay(policy, attempt, failure) {
+  if (policy === void 0) return { retry: false, reason: "noPolicy" };
+  if (failure.timeoutType === "WORKFLOW_EXECUTION")
+    return { retry: false, reason: "executionTimeout" };
+  if (policy.maxAttempts !== void 0 && attempt >= policy.maxAttempts)
+    return { retry: false, reason: "maxAttempts" };
+  const activityPolicy = {
+    retryDelay: policy.initialDelayMs,
+    ...policy.backoffMultiplier !== void 0 ? { backoffMultiplier: policy.backoffMultiplier } : {},
+    ...policy.maxDelayMs !== void 0 ? { maxDelay: policy.maxDelayMs } : {},
+    ...policy.retryOnErrorTypes !== void 0 ? { retryOnErrorTypes: policy.retryOnErrorTypes } : {},
+    ...policy.nonRetryableErrorTypes !== void 0 ? { nonRetryableErrorTypes: policy.nonRetryableErrorTypes } : {}
+  };
+  const classified = { ...failure };
+  if (classified.timeoutType === "WORKFLOW_RUN") delete classified.timeoutType;
+  const decision = computeRetryDelay(activityPolicy, attempt, classified);
+  if (decision.retry) return decision;
+  switch (decision.reason) {
+    case "nonRetryable":
+    case "typeDenied":
+    case "errorTypeNotListed":
+      return { retry: false, reason: decision.reason };
+    default:
+      return { retry: false, reason: "maxAttempts" };
+  }
+}
+function explicitRunRetryPolicy(policy) {
+  const initialDelayMs = policy.initialDelayMs ?? DEFAULT_ACTIVITY_RETRY.retryDelay;
+  const out = {
+    initialDelayMs,
+    backoffMultiplier: policy.backoffMultiplier ?? 2,
+    maxDelayMs: policy.maxDelayMs ?? (policy.initialDelayMs === void 0 ? 1e5 : Math.max(initialDelayMs, initialDelayMs * 100))
+  };
+  if (policy.maxAttempts !== void 0) out.maxAttempts = policy.maxAttempts;
+  if (policy.retryOnErrorTypes !== void 0) out.retryOnErrorTypes = [...policy.retryOnErrorTypes];
+  if (policy.nonRetryableErrorTypes !== void 0)
+    out.nonRetryableErrorTypes = [...policy.nonRetryableErrorTypes];
+  return out;
+}
+
+// src/history/types.ts
+var HISTORY_PROTOCOL = 1;
+var RUNTIME_RELEASE = 3;
+var RUNTIME_CAPABILITIES = ["updates", "queries", "dynamic"];
+var EVENT_TYPES = [
+  "WORKFLOW_STARTED",
+  "WORKFLOW_TASK_SCHEDULED",
+  "WORKFLOW_TASK_STARTED",
+  "WORKFLOW_TASK_COMPLETED",
+  "WORKFLOW_TASK_FAILED",
+  "WORKFLOW_TASK_TIMED_OUT",
+  "ACTIVITY_SCHEDULED",
+  "ACTIVITY_STARTED",
+  "ACTIVITY_HEARTBEAT",
+  "ACTIVITY_COMPLETED",
+  "ACTIVITY_FAILED",
+  "ACTIVITY_TIMED_OUT",
+  "ACTIVITY_CANCEL_REQUESTED",
+  "ACTIVITY_CANCELLED",
+  "ACTIVITY_PAUSED",
+  "ACTIVITY_UNPAUSED",
+  "ACTIVITY_RESET",
+  "ACTIVITY_OPTIONS_UPDATED",
+  "TIMER_STARTED",
+  "TIMER_FIRED",
+  "TIMER_CANCELLED",
+  "SIGNAL_RECEIVED",
+  "UPDATE_ADMITTED",
+  "UPDATE_ACCEPTED",
+  "UPDATE_COMPLETED",
+  "CHILD_RUN_INITIATED",
+  "CHILD_RUN_STARTED",
+  "CHILD_RUN_COMPLETED",
+  "CHILD_RUN_FAILED",
+  "CHILD_RUN_CANCELLED",
+  "CHILD_RUN_TERMINATED",
+  "CHILD_RUN_TIMED_OUT",
+  "EXTERNAL_RUN_CANCEL_REQUESTED",
+  "EXTERNAL_RUN_CANCEL_RESOLVED",
+  "EXTERNAL_RUN_SIGNALED",
+  "SIDE_EFFECT_RECORDED",
+  "LOCAL_ACTIVITY_COMPLETED",
+  "LOCAL_ACTIVITY_FAILED",
+  "SEARCH_ATTRIBUTES_UPSERTED",
+  "CONTEXT_UPSERTED",
+  "MARKER_RECORDED",
+  "WORKFLOW_CANCEL_REQUESTED",
+  "WORKFLOW_RESET",
+  "VERSIONING_OVERRIDE_SET",
+  "WORKFLOW_COMPLETED",
+  "WORKFLOW_FAILED",
+  "WORKFLOW_CANCELLED",
+  "WORKFLOW_TERMINATED",
+  "WORKFLOW_TIMED_OUT",
+  "WORKFLOW_CONTINUED_AS_NEW"
+];
+var COMMAND_TYPES = [
+  "SCHEDULE_ACTIVITY",
+  "REQUEST_CANCEL_ACTIVITY",
+  "START_TIMER",
+  "CANCEL_TIMER",
+  "START_CHILD_RUN",
+  "SIGNAL_RUN",
+  "RECORD_SIDE_EFFECT",
+  "RECORD_MARKER",
+  "COMPLETE_WORKFLOW",
+  "FAIL_WORKFLOW",
+  "CANCEL_WORKFLOW",
+  "UPSERT_CONTEXT",
+  "RECORD_LOCAL_ACTIVITY",
+  "CONTINUE_AS_NEW",
+  "REQUEST_CANCEL_EXTERNAL_RUN",
+  "UPSERT_SEARCH_ATTRIBUTES",
+  "ACCEPT_UPDATE",
+  "REJECT_UPDATE",
+  "COMPLETE_UPDATE"
+];
+var PHASE_B_CORE_COMMANDS = /* @__PURE__ */ new Set([
+  "SCHEDULE_ACTIVITY",
+  "REQUEST_CANCEL_ACTIVITY",
+  "START_TIMER",
+  "CANCEL_TIMER",
+  "START_CHILD_RUN",
+  "SIGNAL_RUN",
+  "RECORD_SIDE_EFFECT",
+  "RECORD_MARKER",
+  "COMPLETE_WORKFLOW",
+  "FAIL_WORKFLOW",
+  "CANCEL_WORKFLOW"
+]);
+var PHASE_B_PARITY_COMMANDS = /* @__PURE__ */ new Set([
+  "UPSERT_CONTEXT",
+  "RECORD_LOCAL_ACTIVITY",
+  "CONTINUE_AS_NEW",
+  "REQUEST_CANCEL_EXTERNAL_RUN"
+]);
+var PHASE_C_COMMANDS = /* @__PURE__ */ new Set([
+  "UPSERT_SEARCH_ATTRIBUTES",
+  "ACCEPT_UPDATE",
+  "REJECT_UPDATE",
+  "COMPLETE_UPDATE"
+]);
+var TERMINAL_COMMANDS = /* @__PURE__ */ new Set([
+  "COMPLETE_WORKFLOW",
+  "FAIL_WORKFLOW",
+  "CANCEL_WORKFLOW",
+  "CONTINUE_AS_NEW"
+]);
+var TASK_FAILURE_CAUSES = [
+  "NON_DETERMINISM",
+  "TASK_TIMEOUT",
+  "ISOLATE_MEMORY",
+  "PROTOCOL_MISMATCH",
+  "BUNDLE_UNAVAILABLE",
+  "BUNDLE_INTEGRITY",
+  "WORKFLOW_CODE_ERROR",
+  "HISTORY_LIMIT",
+  "UNSUPPORTED_COMMAND",
+  "INVALID_REQUEST",
+  "INTERNAL"
+];
+var ERROR_TYPES = [
+  "TIMEOUT",
+  "TRANSIENT",
+  "DEPENDENCY",
+  "AUTHORIZATION",
+  "VALIDATION",
+  "PERMANENT",
+  "UNKNOWN"
+];
+var EXECUTION_KINDS = ["GRAPH", "DURABLE_FN"];
+var PARENT_CLOSE_POLICIES = ["TERMINATE", "ABANDON", "REQUEST_CANCEL"];
+var ACTIVITY_CANCELLATION_TYPES = [
+  "WAIT_CANCELLATION_COMPLETED",
+  "TRY_CANCEL",
+  "ABANDON"
+];
+var CHILD_CANCELLATION_TYPES = [
+  "WAIT_CANCELLATION_COMPLETED",
+  "WAIT_CANCELLATION_REQUESTED",
+  "TRY_CANCEL",
+  "ABANDON"
+];
+var WORKFLOW_ID_REUSE_POLICIES = [
+  "ALLOW_DUPLICATE",
+  "ALLOW_DUPLICATE_FAILED_ONLY",
+  "REJECT_DUPLICATE"
+];
+var WORKFLOW_ID_CONFLICT_POLICIES = [
+  "FAIL",
+  "USE_EXISTING",
+  "TERMINATE_EXISTING"
+];
+var VERSIONING_BEHAVIORS = ["PINNED", "AUTO_UPGRADE"];
+var WORKFLOW_TIMEOUT_TYPES = ["WORKFLOW_RUN", "WORKFLOW_EXECUTION"];
+var FAIRNESS_KEY_MAX_LENGTH = 255;
+var FAIRNESS_WEIGHT_MIN = 0.1;
+var FAIRNESS_WEIGHT_MAX = 10;
+var ACTIVITY_NAME_PATTERN = "^[A-Za-z_][A-Za-z0-9_.-]{0,127}$";
+var TASK_QUEUE_NAME_PATTERN = "^[a-z0-9][a-z0-9-]{0,62}$";
+var MAX_ACTIVITY_CONNECTIONS = 16;
+var MAX_HEADERS_BYTES = 16 * 1024;
+var MAX_SINK_CALLS = 256;
+var DEFAULT_HISTORY_LIMIT = { events: 1e4, bytes: 16 * 1024 * 1024 };
+var CONTINUE_AS_NEW_SUGGESTED_RATIO = 0.8;
+var HISTORY_LIMIT_EXCEEDED_RATIO = 0.95;
+var BUILT_IN_QUERIES = [
+  "__stack_trace",
+  "__enhanced_stack_trace",
+  "__metadata"
+];
+var LOCAL_ACTIVITY_MAX_TIMEOUT_MS = 3e4;
+var COMMAND_EVENT_TYPES = {
+  SCHEDULE_ACTIVITY: "ACTIVITY_SCHEDULED",
+  REQUEST_CANCEL_ACTIVITY: "ACTIVITY_CANCEL_REQUESTED",
+  START_TIMER: "TIMER_STARTED",
+  CANCEL_TIMER: "TIMER_CANCELLED",
+  START_CHILD_RUN: "CHILD_RUN_INITIATED",
+  SIGNAL_RUN: "EXTERNAL_RUN_SIGNALED",
+  RECORD_SIDE_EFFECT: "SIDE_EFFECT_RECORDED",
+  RECORD_MARKER: "MARKER_RECORDED",
+  COMPLETE_WORKFLOW: "WORKFLOW_COMPLETED",
+  FAIL_WORKFLOW: "WORKFLOW_FAILED",
+  CANCEL_WORKFLOW: "WORKFLOW_CANCELLED",
+  UPSERT_CONTEXT: "CONTEXT_UPSERTED",
+  RECORD_LOCAL_ACTIVITY: "LOCAL_ACTIVITY_COMPLETED",
+  CONTINUE_AS_NEW: "WORKFLOW_CONTINUED_AS_NEW",
+  REQUEST_CANCEL_EXTERNAL_RUN: "EXTERNAL_RUN_CANCEL_REQUESTED",
+  UPSERT_SEARCH_ATTRIBUTES: "SEARCH_ATTRIBUTES_UPSERTED",
+  ACCEPT_UPDATE: "UPDATE_ACCEPTED",
+  REJECT_UPDATE: null,
+  COMPLETE_UPDATE: "UPDATE_COMPLETED"
+};
+var COMMAND_EVENTS = /* @__PURE__ */ new Set([
+  "ACTIVITY_SCHEDULED",
+  "ACTIVITY_CANCEL_REQUESTED",
+  "TIMER_STARTED",
+  "TIMER_CANCELLED",
+  "CHILD_RUN_INITIATED",
+  "EXTERNAL_RUN_SIGNALED",
+  "SIDE_EFFECT_RECORDED",
+  "MARKER_RECORDED",
+  "WORKFLOW_COMPLETED",
+  "WORKFLOW_FAILED",
+  "WORKFLOW_CANCELLED",
+  "CONTEXT_UPSERTED",
+  "LOCAL_ACTIVITY_COMPLETED",
+  "LOCAL_ACTIVITY_FAILED",
+  "WORKFLOW_CONTINUED_AS_NEW",
+  "EXTERNAL_RUN_CANCEL_REQUESTED",
+  "SEARCH_ATTRIBUTES_UPSERTED",
+  "UPDATE_ACCEPTED",
+  "UPDATE_COMPLETED"
+]);
+var INPUT_EVENTS = /* @__PURE__ */ new Set([
+  "WORKFLOW_STARTED",
+  "ACTIVITY_COMPLETED",
+  "ACTIVITY_FAILED",
+  "ACTIVITY_TIMED_OUT",
+  "ACTIVITY_CANCELLED",
+  "TIMER_FIRED",
+  "SIGNAL_RECEIVED",
+  "UPDATE_ADMITTED",
+  "CHILD_RUN_STARTED",
+  "CHILD_RUN_COMPLETED",
+  "CHILD_RUN_FAILED",
+  "CHILD_RUN_CANCELLED",
+  "CHILD_RUN_TERMINATED",
+  "CHILD_RUN_TIMED_OUT",
+  "EXTERNAL_RUN_CANCEL_RESOLVED",
+  "WORKFLOW_CANCEL_REQUESTED"
+]);
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set([
+  "WORKFLOW_COMPLETED",
+  "WORKFLOW_FAILED",
+  "WORKFLOW_CANCELLED",
+  "WORKFLOW_TERMINATED",
+  "WORKFLOW_TIMED_OUT",
+  "WORKFLOW_CONTINUED_AS_NEW"
+]);
+function isInputEvent(event) {
+  if (event.type === "EXTERNAL_RUN_SIGNALED") return event.payload["resolved"] === true;
+  return INPUT_EVENTS.has(event.type);
+}
+function isCommandEvent(event) {
+  if (event.type === "EXTERNAL_RUN_SIGNALED") return event.payload["resolved"] !== true;
+  return COMMAND_EVENTS.has(event.type);
+}
+
+export { ACTIVITY_CANCELLATION_TYPES, ACTIVITY_NAME_PATTERN, BUILT_IN_QUERIES, CHILD_CANCELLATION_TYPES, COMMAND_EVENTS, COMMAND_EVENT_TYPES, COMMAND_TYPES, CONTINUE_AS_NEW_SUGGESTED_RATIO, DEFAULT_ACTIVITY_RETRY, DEFAULT_HISTORY_LIMIT, ERROR_TYPES, EVENT_TYPES, EXECUTION_KINDS, FAIRNESS_KEY_MAX_LENGTH, FAIRNESS_WEIGHT_MAX, FAIRNESS_WEIGHT_MIN, HISTORY_LIMIT_EXCEEDED_RATIO, HISTORY_PROTOCOL, INPUT_EVENTS, LOCAL_ACTIVITY_MAX_TIMEOUT_MS, MAX_ACTIVITY_CONNECTIONS, MAX_HEADERS_BYTES, MAX_SINK_CALLS, PARENT_CLOSE_POLICIES, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, PHASE_C_COMMANDS, RUNTIME_CAPABILITIES, RUNTIME_RELEASE, TASK_FAILURE_CAUSES, TASK_QUEUE_NAME_PATTERN, TERMINAL_COMMANDS, TERMINAL_EVENTS, VERSIONING_BEHAVIORS, WORKFLOW_ID_CONFLICT_POLICIES, WORKFLOW_ID_REUSE_POLICIES, WORKFLOW_TIMEOUT_TYPES, computeRetryDelay, computeRunRetryDelay, explicitRetryPolicy, explicitRunRetryPolicy, isCommandEvent, isInputEvent };