@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/chunk-Q4MWQNJK.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+// src/runtime/stack.ts
+var RUNTIME_FRAME = /fluidgrids-runtime|\/runtime\/(scheduler|index)\.|WorkflowExecution|RuntimeContext/;
+function captureStack() {
+  const stack = new Error("stack").stack ?? "";
+  return stack.split("\n").slice(1).filter((line) => line.trim() !== "" && !RUNTIME_FRAME.test(line)).join("\n");
+}
+var V8_FRAME = /^\s*at (?:(.*?) \()?(.*?):(\d+):(\d+)\)?$/;
+var QUICKJS_FRAME = /^\s*at (?:(.*?) )?\(?(.*?)(?::(\d+))?(?::(\d+))?\)?$/;
+function parseStack(stack) {
+  const locations = [];
+  for (const line of stack.split("\n")) {
+    if (line.trim() === "") continue;
+    const match = V8_FRAME.exec(line) ?? QUICKJS_FRAME.exec(line);
+    if (!match) continue;
+    const location = {};
+    if (match[1]) location.functionName = match[1];
+    if (match[2]) location.filePath = match[2];
+    if (match[3]) location.line = Number(match[3]);
+    if (match[4]) location.column = Number(match[4]);
+    locations.push(location);
+  }
+  return locations;
+}
+
+exports.captureStack = captureStack;
+exports.parseStack = parseStack;

package/dist/{chunk-HWJZVOG7.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-N23SKIG4.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-FEW3JBYA.cjs → chunk-TCTE7DX5.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkQQ6ULXHI_cjs = require('./chunk-QQ6ULXHI.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 chunkQQ6ULXHI_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 chunkQQ6ULXHI_cjs.outcomeToCollection(outcome);
+      return chunkODZ2IAR2_cjs.outcomeToCollection(outcome);
     }
   };
 }

package/dist/{chunk-623FVQSN.cjs → chunk-TYF56RGB.cjs}

@@ -1,7 +1,89 @@
 'use strict';
 
+// 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",
@@ -141,6 +223,26 @@ var CHILD_CANCELLATION_TYPES = [
   "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;
@@ -149,6 +251,7 @@ var BUILT_IN_QUERIES = [
   "__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",
@@ -227,25 +330,45 @@ function isCommandEvent(event) {
 }
 
 exports.ACTIVITY_CANCELLATION_TYPES = ACTIVITY_CANCELLATION_TYPES;
+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.computeRetryDelay = computeRetryDelay;
+exports.computeRunRetryDelay = computeRunRetryDelay;
+exports.explicitRetryPolicy = explicitRetryPolicy;
+exports.explicitRunRetryPolicy = explicitRunRetryPolicy;
 exports.isCommandEvent = isCommandEvent;
 exports.isInputEvent = isInputEvent;

package/dist/chunk-VA4OFR72.cjs

@@ -0,0 +1,324 @@
+'use strict';
+
+var chunkFR7KYWRO_cjs = require('./chunk-FR7KYWRO.cjs');
+var chunkTYF56RGB_cjs = require('./chunk-TYF56RGB.cjs');
+
+// src/durable/durations.ts
+function toMs(value, what = "duration") {
+  const ms = chunkFR7KYWRO_cjs.durationMs(value, "ms");
+  if (ms === void 0) throw new TypeError(`${what} "${String(value)}" is not a duration`);
+  return Math.round(ms);
+}
+function optionalMs(value, what) {
+  return value === void 0 ? void 0 : toMs(value, what);
+}
+
+// src/durable/workflow.ts
+var DURABLE_MARKER = "fluidgrids.durable-workflow";
+var MAX_WORKFLOW_TASK_TIMEOUT_MS = 12e4;
+function checkRunOptions(name, options) {
+  const where = `workflow("${name}")`;
+  for (const key of ["executionTimeout", "runTimeout", "workflowTaskTimeout"]) {
+    const value = options[key];
+    if (value !== void 0) toMs(value, `${where} ${key}`);
+  }
+  if (options.workflowTaskTimeout !== void 0 && toMs(options.workflowTaskTimeout) > MAX_WORKFLOW_TASK_TIMEOUT_MS)
+    throw new TypeError(`${where}: workflowTaskTimeout may be at most 120 s`);
+  if (options.versioningBehavior !== void 0 && options.versioningBehavior !== "PINNED" && options.versioningBehavior !== "AUTO_UPGRADE")
+    throw new TypeError(`${where}: versioningBehavior must be PINNED or AUTO_UPGRADE`);
+  const retry = options.retry;
+  if (retry !== void 0) {
+    checkRunRetryKeys(retry, `${where} retry`);
+    if (retry.maxAttempts !== void 0 && (!Number.isInteger(retry.maxAttempts) || retry.maxAttempts < 1))
+      throw new TypeError(`${where}: retry.maxAttempts must be a positive integer`);
+    if (retry.initialDelay !== void 0) toMs(retry.initialDelay, `${where} retry.initialDelay`);
+    if (retry.maxDelay !== void 0) toMs(retry.maxDelay, `${where} retry.maxDelay`);
+    if (retry.backoffMultiplier !== void 0 && !(Number.isFinite(retry.backoffMultiplier) && retry.backoffMultiplier >= 1))
+      throw new TypeError(`${where}: retry.backoffMultiplier must be at least 1`);
+  }
+}
+var KEY = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+function workflow(name, optionsOrFn, maybeFn) {
+  if (typeof name !== "string" || !KEY.test(name))
+    throw new TypeError(
+      `workflow() needs a key of lowercase letters, digits, "-" and "_" (got "${String(name)}")`
+    );
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn ?? {};
+  if (typeof fn !== "function") throw new TypeError(`workflow("${name}") needs a function`);
+  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";
+}
+function isJsonValue(value, depth = 0) {
+  if (depth > 64) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every((item) => isJsonValue(item, depth + 1));
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+      return false;
+    return Object.values(value).every((item) => isJsonValue(item, depth + 1));
+  }
+  return false;
+}
+function jsonSchemaOf(schema) {
+  if (schema === void 0) return void 0;
+  const method = schema.toJSONSchema;
+  if (typeof method === "function") {
+    const produced = method.call(schema);
+    return isJsonValue(produced) && typeof produced === "object" && !Array.isArray(produced) && produced !== null ? produced : void 0;
+  }
+  return isJsonValue(schema) && !Array.isArray(schema) && schema !== null && typeof schema === "object" ? schema : void 0;
+}
+function interfaceOf(definition) {
+  const out = {};
+  const input = jsonSchemaOf(definition.options.input);
+  const output = jsonSchemaOf(definition.options.output);
+  if (input) out.input = input;
+  if (output) out.output = output;
+  const signals = definition.options.signals ?? [];
+  if (signals.length > 0) {
+    out.signals = {};
+    for (const signal of signals) {
+      const entry = {};
+      const payload = jsonSchemaOf(signal.schema);
+      if (payload) entry.payload = payload;
+      if (signal.description !== void 0) entry.description = signal.description;
+      out.signals[signal.name] = entry;
+    }
+  }
+  const queries = definition.options.queries ?? [];
+  if (queries.length > 0) {
+    out.queries = {};
+    for (const query of queries)
+      out.queries[query.name] = query.description !== void 0 ? { description: query.description } : {};
+  }
+  const updates = definition.options.updates ?? [];
+  if (updates.length > 0) {
+    out.updates = {};
+    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([
+  "maxAttempts",
+  "initialDelay",
+  "backoffMultiplier",
+  "maxDelay",
+  "nonRetryableErrorTypes"
+]);
+var ACTIVITY_RETRY_ONLY_KEYS = /* @__PURE__ */ new Set([
+  "retryDelay",
+  "maxRetries",
+  "retryOnErrorTypes"
+]);
+function checkRunRetryKeys(retry, where) {
+  if (typeof retry !== "object" || retry === null || Array.isArray(retry))
+    throw new TypeError(`${where} must be an object`);
+  for (const key of Object.keys(retry)) {
+    if (RUN_RETRY_OPTION_KEYS.has(key)) continue;
+    const hint = ACTIVITY_RETRY_ONLY_KEYS.has(key) ? " (that is the activity retry shape; a run-level retry takes maxAttempts, initialDelay, backoffMultiplier, maxDelay and nonRetryableErrorTypes)" : "";
+    throw new TypeError(`${where} has an unknown option "${key}"${hint}`);
+  }
+}
+function runRetryPolicyOf(retry) {
+  checkRunRetryKeys(retry, "retry");
+  const policy = {};
+  if (retry.maxAttempts !== void 0) policy.maxAttempts = retry.maxAttempts;
+  if (retry.initialDelay !== void 0)
+    policy.initialDelayMs = toMs(retry.initialDelay, "retry.initialDelay");
+  if (retry.backoffMultiplier !== void 0) policy.backoffMultiplier = retry.backoffMultiplier;
+  if (retry.maxDelay !== void 0) policy.maxDelayMs = toMs(retry.maxDelay, "retry.maxDelay");
+  if (retry.nonRetryableErrorTypes !== void 0)
+    policy.nonRetryableErrorTypes = [...retry.nonRetryableErrorTypes];
+  return chunkTYF56RGB_cjs.explicitRunRetryPolicy(policy);
+}
+function continueAsNewRetryOf(retry) {
+  if (typeof retry !== "object" || retry === null || Array.isArray(retry))
+    throw new TypeError("continueAsNew retry must be an object");
+  const keys = Object.keys(retry);
+  const legacy = keys.some((key) => ACTIVITY_RETRY_ONLY_KEYS.has(key));
+  if (!legacy) return runRetryPolicyOf(retry);
+  if (keys.includes("maxAttempts") || keys.includes("initialDelay"))
+    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 chunkTYF56RGB_cjs.explicitRetryPolicy(retry);
+}
+
+// src/generated/version.ts
+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;