@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/{chunk-FQSJI5NV.js → chunk-SR7TR5KX.js}

@@ -2,7 +2,7 @@ import { autoLayout } from './chunk-5LUIDMF4.js';
 import { makeRef, isPredicate, conditionTreeOf, BuilderError, refModelOf } from './chunk-JZ4TOOLN.js';
 import { formatRefTemplate } from './chunk-7AAZGVKD.js';
 import { isRecord, setOwn, cloneJson, ownValue } from './chunk-PMCM2OH4.js';
-import { isDurableWorkflow, SDK_VERSION } from './chunk-7ILGCUI6.js';
+import { isDurableWorkflow, SDK_VERSION } from './chunk-C4F5KJTI.js';
 
 // src/builder/descriptors.ts
 function op(nodeType, version, operation) {
@@ -61,7 +61,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,

package/dist/{chunk-OKX3FYIM.cjs → chunk-TCTE7DX5.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk6QPOJZT6_cjs = require('./chunk-6QPOJZT6.cjs');
+var chunkODZ2IAR2_cjs = require('./chunk-ODZ2IAR2.cjs');
 
 // src/generated/vm-worker-source.ts
 var VM_WORKER_SOURCE = '"use strict";\n\nvar import_node_worker_threads = require("node:worker_threads");\n\nfunction isRecord(value) {\n  return typeof value === "object" && value !== null && !Array.isArray(value);\n}\n\nvar DETERMINISM_VIOLATION = "DeterminismViolation";\nvar DETERMINISM_PRELUDE = `(() => {\n  const NAME = ${JSON.stringify(DETERMINISM_VIOLATION)};\n  const fail = (what) => {\n    const error = new Error(\n      what + " is not allowed in workflow code: lowering must give the same IR on every build. Read times and random values at run time instead (for example wf.now)."\n    );\n    error.name = NAME;\n    throw error;\n  };\n  const lock = (target, key, value) =>\n    Object.defineProperty(target, key, { value, writable: false, enumerable: false, configurable: false });\n  const RealDate = Date;\n  const LockedDate = function Date(...args) {\n    if (new.target === undefined) return fail("Date()");\n    if (args.length === 0) return fail("new Date()");\n    return Reflect.construct(RealDate, args, new.target);\n  };\n  lock(LockedDate, "prototype", RealDate.prototype);\n  lock(RealDate.prototype, "constructor", LockedDate);\n  lock(LockedDate, "now", function now() { return fail("Date.now()"); });\n  lock(LockedDate, "parse", RealDate.parse);\n  lock(LockedDate, "UTC", RealDate.UTC);\n  lock(globalThis, "Date", LockedDate);\n  lock(Math, "random", function random() { return fail("Math.random()"); });\n  const crypto = globalThis.crypto;\n  if (crypto !== null && typeof crypto === "object") {\n    for (const name of ["getRandomValues", "randomUUID"]) {\n      if (typeof crypto[name] === "function") lock(crypto, name, function () { return fail("crypto." + name + "()"); });\n    }\n  }\n  const DateTimeFormat = typeof Intl === "object" && Intl !== null ? Intl.DateTimeFormat : undefined;\n  if (typeof DateTimeFormat === "function") {\n    const proto = DateTimeFormat.prototype;\n    const format = Object.getOwnPropertyDescriptor(proto, "format");\n    if (format && typeof format.get === "function") {\n      const get = format.get;\n      Object.defineProperty(proto, "format", {\n        get() {\n          const bound = get.call(this);\n          return (date) => (date === undefined ? fail("Intl.DateTimeFormat format()") : bound(date));\n        },\n        enumerable: false,\n        configurable: false,\n      });\n    }\n    const formatToParts = proto.formatToParts;\n    if (typeof formatToParts === "function") {\n      lock(proto, "formatToParts", function (date) {\n        return date === undefined ? fail("Intl.DateTimeFormat formatToParts()") : formatToParts.call(this, date);\n      });\n    }\n  }\n})();\n`;\nfunction failure(kind, message) {\n  return { ok: false, failure: kind, message };\n}\n\nvar import_node_vm = require("node:vm");\nvar import_node_util = require("node:util");\nvar BUNDLE_GLOBAL = "__fluidgridsBundle";\nfunction wrap(code) {\n  return `(function () {\n  const describe = (error) => {\n    let name = "Error";\n    let message = "";\n    try {\n      if (error !== null && (typeof error === "object" || typeof error === "function")) {\n        const n = error.name;\n        if (typeof n === "string") name = n;\n        const m = error.message;\n        message = typeof m === "string" ? m : m === undefined ? "" + error : "" + m;\n      } else {\n        message = "" + error;\n      }\n    } catch (_) {\n      message = "a value whose message cannot be read was thrown";\n    }\n    return (name === ${JSON.stringify(DETERMINISM_VIOLATION)} ? "D" : "E") + message;\n  };\n  try {\n${code}\n;const __fluidgridsValue = ${BUNDLE_GLOBAL}.__fluidgrids;\n    return typeof __fluidgridsValue === "string" ? "R" + __fluidgridsValue : "N";\n  } catch (error) {\n    try {\n      return describe(error);\n    } catch (_) {\n      return "Ean error that cannot be described was thrown";\n    }\n  }\n})()`;\n}\nfunction hostErrorFields(error) {\n  if (!import_node_util.types.isNativeError(error)) return {};\n  const code = Object.getOwnPropertyDescriptor(error, "code")?.value;\n  const message = Object.getOwnPropertyDescriptor(error, "message")?.value;\n  return {\n    ...typeof code === "string" ? { code } : {},\n    ...typeof message === "string" ? { message } : {}\n  };\n}\nfunction decode(result) {\n  const tag = result.charAt(0);\n  const rest = result.slice(1);\n  if (tag === "R") return { ok: true, value: rest };\n  if (tag === "N")\n    return failure("no-collection", "The bundle did not export a workflow collection");\n  if (tag === "D") return failure("determinism", rest);\n  return failure("error", rest);\n}\nfunction runInVmContext(code, timeoutMs) {\n  const context = (0, import_node_vm.createContext)(/* @__PURE__ */ Object.create(null), {\n    codeGeneration: { strings: false, wasm: false },\n    microtaskMode: "afterEvaluate",\n    name: "fluidgrids-workflow-lowering"\n  });\n  const refuseImport = () => {\n    throw new Error("Workflow code may not import modules at run time");\n  };\n  const deadline = Date.now() + timeoutMs;\n  const run = (source, filename) => new import_node_vm.Script(source, { filename, importModuleDynamically: refuseImport }).runInContext(context, {\n    timeout: Math.max(1, deadline - Date.now()),\n    breakOnSigint: true\n  });\n  try {\n    run(DETERMINISM_PRELUDE, "determinism-prelude.js");\n    const result = run(wrap(code), "workflow-bundle.js");\n    return typeof result === "string" ? decode(result) : failure("no-collection", "The bundle did not export a workflow collection");\n  } catch (error) {\n    const fields = hostErrorFields(error);\n    if (fields.code === "ERR_SCRIPT_EXECUTION_TIMEOUT" || fields.message !== void 0 && /^Script execution timed out/.test(fields.message)) {\n      return failure("timeout", `Evaluating the workflow code timed out after ${timeoutMs} ms`);\n    }\n    return failure("error", fields.message ?? "The workflow code could not be evaluated");\n  }\n}\n\nprocess.on("unhandledRejection", () => void 0);\nvar input = import_node_worker_threads.workerData;\nimport_node_worker_threads.parentPort?.postMessage(\n  isRecord(input) && typeof input["code"] === "string" && typeof input["timeoutMs"] === "number" ? runInVmContext(input["code"], input["timeoutMs"]) : failure("crashed", "The evaluation worker received no bundle")\n);\n';
@@ -13,13 +13,13 @@ function createNodeVmEvaluator(options = {}) {
   return {
     format: "iife",
     async evaluate(code) {
-      const outcome = await chunk6QPOJZT6_cjs.runIsolateWorker({
+      const outcome = await chunkODZ2IAR2_cjs.runIsolateWorker({
         source: VM_WORKER_SOURCE,
         workerData: { code, timeoutMs },
         timeoutMs,
         resourceLimits: { maxOldGenerationSizeMb: Math.max(16, Math.ceil(memoryLimitBytes / MIB)) }
       });
-      return chunk6QPOJZT6_cjs.outcomeToCollection(outcome);
+      return chunkODZ2IAR2_cjs.outcomeToCollection(outcome);
     }
   };
 }

package/dist/{chunk-3FIDHONL.cjs → chunk-TYF56RGB.cjs}

@@ -1,86 +1,89 @@
 '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;
+// 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 isActivityNodeTypeAllowed(nodeType) {
-  if (typeof nodeType !== "string" || nodeType.trim() === "") return false;
-  const type = canonicalType(nodeType);
-  if (!type.startsWith("internal:")) return true;
-  return ACTIVITY_INTERNAL_ALLOWLIST.has(type);
+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;
 }
-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";
+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" };
   }
-  nodeType;
-  code = "durable.activityTypeNotAllowed";
-  errorType = "VALIDATION";
-  nonRetryable = true;
-};
-function assertActivityNodeType(nodeType) {
-  if (!isActivityNodeTypeAllowed(nodeType)) throw new ActivityNodeTypeNotAllowedError(nodeType);
+}
+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 = 2;
+var RUNTIME_RELEASE = 3;
+var RUNTIME_CAPABILITIES = ["updates", "queries", "dynamic"];
 var EVENT_TYPES = [
   "WORKFLOW_STARTED",
   "WORKFLOW_TASK_SCHEDULED",
@@ -232,6 +235,14 @@ var WORKFLOW_ID_CONFLICT_POLICIES = [
 ];
 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;
@@ -319,37 +330,45 @@ function isCommandEvent(event) {
 }
 
 exports.ACTIVITY_CANCELLATION_TYPES = ACTIVITY_CANCELLATION_TYPES;
-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.ACTIVITY_NAME_PATTERN = ACTIVITY_NAME_PATTERN;
 exports.BUILT_IN_QUERIES = BUILT_IN_QUERIES;
 exports.CHILD_CANCELLATION_TYPES = CHILD_CANCELLATION_TYPES;
 exports.COMMAND_EVENTS = COMMAND_EVENTS;
 exports.COMMAND_EVENT_TYPES = COMMAND_EVENT_TYPES;
 exports.COMMAND_TYPES = COMMAND_TYPES;
 exports.CONTINUE_AS_NEW_SUGGESTED_RATIO = CONTINUE_AS_NEW_SUGGESTED_RATIO;
+exports.DEFAULT_ACTIVITY_RETRY = DEFAULT_ACTIVITY_RETRY;
 exports.DEFAULT_HISTORY_LIMIT = DEFAULT_HISTORY_LIMIT;
 exports.ERROR_TYPES = ERROR_TYPES;
 exports.EVENT_TYPES = EVENT_TYPES;
 exports.EXECUTION_KINDS = EXECUTION_KINDS;
+exports.FAIRNESS_KEY_MAX_LENGTH = FAIRNESS_KEY_MAX_LENGTH;
+exports.FAIRNESS_WEIGHT_MAX = FAIRNESS_WEIGHT_MAX;
+exports.FAIRNESS_WEIGHT_MIN = FAIRNESS_WEIGHT_MIN;
 exports.HISTORY_LIMIT_EXCEEDED_RATIO = HISTORY_LIMIT_EXCEEDED_RATIO;
 exports.HISTORY_PROTOCOL = HISTORY_PROTOCOL;
 exports.INPUT_EVENTS = INPUT_EVENTS;
 exports.LOCAL_ACTIVITY_MAX_TIMEOUT_MS = LOCAL_ACTIVITY_MAX_TIMEOUT_MS;
+exports.MAX_ACTIVITY_CONNECTIONS = MAX_ACTIVITY_CONNECTIONS;
+exports.MAX_HEADERS_BYTES = MAX_HEADERS_BYTES;
+exports.MAX_SINK_CALLS = MAX_SINK_CALLS;
 exports.PARENT_CLOSE_POLICIES = PARENT_CLOSE_POLICIES;
 exports.PHASE_B_CORE_COMMANDS = PHASE_B_CORE_COMMANDS;
 exports.PHASE_B_PARITY_COMMANDS = PHASE_B_PARITY_COMMANDS;
 exports.PHASE_C_COMMANDS = PHASE_C_COMMANDS;
+exports.RUNTIME_CAPABILITIES = RUNTIME_CAPABILITIES;
 exports.RUNTIME_RELEASE = RUNTIME_RELEASE;
 exports.TASK_FAILURE_CAUSES = TASK_FAILURE_CAUSES;
+exports.TASK_QUEUE_NAME_PATTERN = TASK_QUEUE_NAME_PATTERN;
 exports.TERMINAL_COMMANDS = TERMINAL_COMMANDS;
 exports.TERMINAL_EVENTS = TERMINAL_EVENTS;
 exports.VERSIONING_BEHAVIORS = VERSIONING_BEHAVIORS;
 exports.WORKFLOW_ID_CONFLICT_POLICIES = WORKFLOW_ID_CONFLICT_POLICIES;
 exports.WORKFLOW_ID_REUSE_POLICIES = WORKFLOW_ID_REUSE_POLICIES;
 exports.WORKFLOW_TIMEOUT_TYPES = WORKFLOW_TIMEOUT_TYPES;
-exports.assertActivityNodeType = assertActivityNodeType;
-exports.isActivityNodeTypeAllowed = isActivityNodeTypeAllowed;
+exports.computeRetryDelay = computeRetryDelay;
+exports.computeRunRetryDelay = computeRunRetryDelay;
+exports.explicitRetryPolicy = explicitRetryPolicy;
+exports.explicitRunRetryPolicy = explicitRunRetryPolicy;
 exports.isCommandEvent = isCommandEvent;
 exports.isInputEvent = isInputEvent;

package/dist/{chunk-J3PYFGKA.cjs → chunk-VA4OFR72.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var chunkFR7KYWRO_cjs = require('./chunk-FR7KYWRO.cjs');
-var chunkYHBVMOMK_cjs = require('./chunk-YHBVMOMK.cjs');
+var chunkTYF56RGB_cjs = require('./chunk-TYF56RGB.cjs');
 
 // src/durable/durations.ts
 function toMs(value, what = "duration") {
@@ -49,6 +49,17 @@ function workflow(name, optionsOrFn, maybeFn) {
   checkRunOptions(name, options);
   return Object.freeze({ __fluidgrids: DURABLE_MARKER, name, options, fn });
 }
+function dynamicWorkflow(name, optionsOrFn, maybeFn) {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn ?? {};
+  if (typeof fn !== "function") throw new TypeError(`dynamicWorkflow("${name}") needs a function`);
+  const declared = workflow(
+    name,
+    options,
+    (ctx, input) => fn(ctx, ctx.info.workflowFn, input)
+  );
+  return Object.freeze({ ...declared, dynamic: true });
+}
 function isDurableWorkflow(value) {
   return typeof value === "object" && value !== null && value.__fluidgrids === DURABLE_MARKER && typeof value.fn === "function";
 }
@@ -102,6 +113,14 @@ function interfaceOf(definition) {
     for (const update of updates)
       out.updates[update.name] = update.description !== void 0 ? { description: update.description } : {};
   }
+  const open = definition.options.open;
+  if (open !== void 0) {
+    const flags = {};
+    if (open.signals === true) flags.signals = true;
+    if (open.queries === true) flags.queries = true;
+    if (open.updates === true) flags.updates = true;
+    if (Object.keys(flags).length > 0) out.open = flags;
+  }
   return out;
 }
 var RUN_RETRY_OPTION_KEYS = /* @__PURE__ */ new Set([
@@ -135,7 +154,7 @@ function runRetryPolicyOf(retry) {
   if (retry.maxDelay !== void 0) policy.maxDelayMs = toMs(retry.maxDelay, "retry.maxDelay");
   if (retry.nonRetryableErrorTypes !== void 0)
     policy.nonRetryableErrorTypes = [...retry.nonRetryableErrorTypes];
-  return chunkYHBVMOMK_cjs.explicitRunRetryPolicy(policy);
+  return chunkTYF56RGB_cjs.explicitRunRetryPolicy(policy);
 }
 function continueAsNewRetryOf(retry) {
   if (typeof retry !== "object" || retry === null || Array.isArray(retry))
@@ -147,20 +166,159 @@ function continueAsNewRetryOf(retry) {
     throw new TypeError(
       "continueAsNew retry mixes the activity retry shape (retryDelay, maxRetries) with the run-level one (maxAttempts, initialDelay); use the run-level keys"
     );
-  return chunkYHBVMOMK_cjs.explicitRetryPolicy(retry);
+  return chunkTYF56RGB_cjs.explicitRetryPolicy(retry);
 }
 
 // src/generated/version.ts
-var SDK_VERSION = "2026.1029.1";
+var SDK_VERSION = "2026.1030.1";
+
+// src/durable/interceptors.ts
+var INTERCEPTORS_MARKER = "fluidgrids.workflow-interceptors";
+function workflowInterceptors(factory) {
+  if (typeof factory !== "function")
+    throw new TypeError("workflowInterceptors() needs a factory function");
+  return Object.freeze({ __fluidgrids: INTERCEPTORS_MARKER, factory });
+}
+function interceptorsFactoryOf(value) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (typeof value === "object" && value !== null && value.__fluidgrids === INTERCEPTORS_MARKER && typeof value.factory === "function")
+    return value.factory;
+  return void 0;
+}
+function resolveWorkflowInterceptors(factories) {
+  const inbound = [];
+  const outbound = [];
+  for (const factory of factories) {
+    const made = factory();
+    if (typeof made !== "object" || made === null)
+      throw new TypeError("An interceptors factory must return { inbound?, outbound? }");
+    const lists = made;
+    if (lists.inbound !== void 0) {
+      if (!Array.isArray(lists.inbound))
+        throw new TypeError("interceptors.inbound must be an array");
+      inbound.push(...lists.inbound);
+    }
+    if (lists.outbound !== void 0) {
+      if (!Array.isArray(lists.outbound))
+        throw new TypeError("interceptors.outbound must be an array");
+      outbound.push(...lists.outbound);
+    }
+  }
+  return { inbound, outbound };
+}
+function compose(interceptors, method, terminal) {
+  let next = terminal;
+  for (let index = interceptors.length - 1; index >= 0; index--) {
+    const interceptor = interceptors[index];
+    const fn = interceptor?.[method];
+    if (typeof fn !== "function") continue;
+    const inner = next;
+    const call = fn;
+    next = (input) => call.call(interceptor, input, inner);
+  }
+  return next;
+}
+
+// src/durable/activities.ts
+var ACTIVITY_MARKER = "fluidgrids.activity";
+var ACTIVITY_IMPL_MARKER = "fluidgrids.activity-impl";
+var ACTIVITY_NAME = new RegExp(chunkTYF56RGB_cjs.ACTIVITY_NAME_PATTERN);
+var TASK_QUEUE_NAME = new RegExp(chunkTYF56RGB_cjs.TASK_QUEUE_NAME_PATTERN);
+var DYNAMIC_ACTIVITY_NAME = "*";
+function checkActivityName(name) {
+  if (typeof name !== "string" || !ACTIVITY_NAME.test(name))
+    throw new TypeError(
+      `An activity name must match ${chunkTYF56RGB_cjs.ACTIVITY_NAME_PATTERN} (got "${String(name)}")`
+    );
+}
+function checkTaskQueueName(queue, what = "taskQueue") {
+  if (typeof queue !== "string" || !TASK_QUEUE_NAME.test(queue))
+    throw new TypeError(`${what} must match ${chunkTYF56RGB_cjs.TASK_QUEUE_NAME_PATTERN} (got "${String(queue)}")`);
+}
+function declareActivity(name, options = {}) {
+  checkActivityName(name);
+  if (options.taskQueue !== void 0) checkTaskQueueName(options.taskQueue);
+  return Object.freeze({ __fluidgrids: ACTIVITY_MARKER, name, options: { ...options } });
+}
+function implementActivity(definition, fn) {
+  if (!isActivityDefinition(definition))
+    throw new TypeError("implementActivity() needs a declareActivity() value");
+  if (typeof fn !== "function") throw new TypeError("implementActivity() needs a function");
+  return Object.freeze({
+    __fluidgrids: ACTIVITY_MARKER,
+    name: definition.name,
+    options: definition.options,
+    implementation: ACTIVITY_IMPL_MARKER,
+    fn,
+    dynamic: false
+  });
+}
+function defineActivity(name, optionsOrFn, maybeFn) {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+  if (typeof fn !== "function") throw new TypeError(`defineActivity("${name}") needs a function`);
+  return implementActivity(declareActivity(name, options), fn);
+}
+function dynamicActivity(fn, options = {}) {
+  if (typeof fn !== "function") throw new TypeError("dynamicActivity() needs a function");
+  if (options.taskQueue !== void 0) checkTaskQueueName(options.taskQueue);
+  return Object.freeze({
+    __fluidgrids: ACTIVITY_MARKER,
+    name: DYNAMIC_ACTIVITY_NAME,
+    options: { ...options },
+    implementation: ACTIVITY_IMPL_MARKER,
+    fn,
+    dynamic: true
+  });
+}
+function isActivityDefinition(value) {
+  return typeof value === "object" && value !== null && value.__fluidgrids === ACTIVITY_MARKER && typeof value.name === "string";
+}
+function isActivityImplementation(value) {
+  return isActivityDefinition(value) && value.implementation === ACTIVITY_IMPL_MARKER && typeof value.fn === "function";
+}
+function findActivityImplementation(implementations, name) {
+  return implementations.find((impl) => !impl.dynamic && impl.name === name) ?? implementations.find((impl) => impl.dynamic);
+}
+function executeActivity(implementation, ctx, args, interceptors = []) {
+  const fn = implementation.fn;
+  const run = compose(
+    interceptors,
+    "execute",
+    async (input) => fn(ctx, input.args)
+  );
+  return run({ args, headers: ctx.info.headers, info: ctx.info });
+}
 
+exports.ACTIVITY_IMPL_MARKER = ACTIVITY_IMPL_MARKER;
+exports.ACTIVITY_MARKER = ACTIVITY_MARKER;
 exports.DURABLE_MARKER = DURABLE_MARKER;
+exports.DYNAMIC_ACTIVITY_NAME = DYNAMIC_ACTIVITY_NAME;
+exports.INTERCEPTORS_MARKER = INTERCEPTORS_MARKER;
 exports.MAX_WORKFLOW_TASK_TIMEOUT_MS = MAX_WORKFLOW_TASK_TIMEOUT_MS;
 exports.SDK_VERSION = SDK_VERSION;
+exports.checkActivityName = checkActivityName;
+exports.checkTaskQueueName = checkTaskQueueName;
+exports.compose = compose;
 exports.continueAsNewRetryOf = continueAsNewRetryOf;
+exports.declareActivity = declareActivity;
+exports.defineActivity = defineActivity;
+exports.dynamicActivity = dynamicActivity;
+exports.dynamicWorkflow = dynamicWorkflow;
+exports.executeActivity = executeActivity;
+exports.findActivityImplementation = findActivityImplementation;
+exports.implementActivity = implementActivity;
+exports.interceptorsFactoryOf = interceptorsFactoryOf;
 exports.interfaceOf = interfaceOf;
+exports.isActivityDefinition = isActivityDefinition;
+exports.isActivityImplementation = isActivityImplementation;
 exports.isDurableWorkflow = isDurableWorkflow;
 exports.jsonSchemaOf = jsonSchemaOf;
 exports.optionalMs = optionalMs;
+exports.resolveWorkflowInterceptors = resolveWorkflowInterceptors;
 exports.runRetryPolicyOf = runRetryPolicyOf;
 exports.toMs = toMs;
 exports.workflow = workflow;
+exports.workflowInterceptors = workflowInterceptors;

package/dist/chunk-VU5S5A7V.js

@@ -0,0 +1,150 @@
+// 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] ?? []
+  );
+}
+
+export { COMMAND_FAILURE_FIELDS, COMMAND_PAYLOAD_FIELDS, ENCODED_PAYLOAD_MARKER, ENCODED_PAYLOAD_VERSION, FAILURE_CAUSE_FIELD, FAILURE_FIELDS, FAILURE_PAYLOAD_FIELDS, PAYLOAD_ENCODINGS, PAYLOAD_FIELDS, PAYLOAD_FIELDS_DOCUMENT, PAYLOAD_FIELDS_FORMAT, isEncodedPayload, mapCommandPayloads, mapEventPayloads, mapPayloadFields, payloadEncodingOf };