@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/{chunk-JD2VQIDZ.cjs → chunk-672KMMBK.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunk623FVQSN_cjs = require('./chunk-623FVQSN.cjs');
+var chunkTYF56RGB_cjs = require('./chunk-TYF56RGB.cjs');
 
 function failedTaskResult(cause, message) {
   return {
-    protocol: chunk623FVQSN_cjs.HISTORY_PROTOCOL,
+    protocol: chunkTYF56RGB_cjs.HISTORY_PROTOCOL,
     outcome: "failed",
     commands: [],
     failure: { cause, message },

package/dist/{chunk-C5OLWZ42.js → chunk-6A2FGSUS.js}

@@ -1,5 +1,3 @@
-import { durationMs } from './chunk-LNUQE6D6.js';
-
 // src/durable/definitions.ts
 function checkName(name, what) {
   if (typeof name !== "string" || name === "" || name.startsWith("__"))
@@ -84,16 +82,36 @@ var ApplicationError = class extends WorkflowFailure {
   }
 };
 var ActivityFailure = class extends WorkflowFailure {
-  constructor(message, activityId, nodeType, operation, cause) {
+  constructor(message, activityId, nodeType, operation, cause, activityName) {
     super(message, cause instanceof WorkflowFailure ? cause.errorType : "UNKNOWN", { cause });
     this.activityId = activityId;
     this.nodeType = nodeType;
     this.operation = operation;
+    this.activityName = activityName;
     this.name = "ActivityFailure";
   }
   activityId;
   nodeType;
   operation;
+  activityName;
+};
+var ActivityPausedError = class extends ApplicationError {
+  constructor(message = "The activity was paused", details) {
+    super(message, {
+      type: "ActivityPausedError",
+      errorType: "TRANSIENT",
+      ...details !== void 0 ? { details } : {}
+    });
+    this.name = "ActivityPausedError";
+  }
+};
+var QueryHandlerSideEffect = class extends Error {
+  constructor(what) {
+    super(
+      `${what} is not allowed in a query handler or an update validator; they must not change the run`
+    );
+    this.name = "QueryHandlerSideEffect";
+  }
 };
 var ChildRunFailure = class extends WorkflowFailure {
   constructor(message, childId, childRunId, cause) {
@@ -232,14 +250,4 @@ function failureToError(failure, depth = 0) {
   return error;
 }
 
-// src/durable/durations.ts
-function toMs(value, what = "duration") {
-  const ms = 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);
-}
-
-export { ActivityFailure, ApplicationError, CancelledFailure, ChildRunFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, ServerFailure, TerminatedFailure, TimeoutFailure, WorkflowFailure, defineQuery, defineSignal, defineUpdate, errorToFailure, failureToError, isCancellation, isRunFailure, optionalMs, signalName, toMs };
+export { ActivityFailure, ActivityPausedError, ApplicationError, CancelledFailure, ChildRunFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, QueryHandlerSideEffect, ServerFailure, TerminatedFailure, TimeoutFailure, WorkflowFailure, defineQuery, defineSignal, defineUpdate, errorToFailure, failureToError, isCancellation, isRunFailure, signalName };

package/dist/{chunk-XKJA7KX3.js → chunk-6OLN6BMB.js}

@@ -1,10 +1,43 @@
-import { isTier1Workflow, isOperation } from './chunk-HWJZVOG7.js';
+import { isTier1Workflow, isOperation } from './chunk-SR7TR5KX.js';
 import { BuilderError } from './chunk-JZ4TOOLN.js';
 import { isRecord, setOwn } from './chunk-PMCM2OH4.js';
-import { isDurableWorkflow, interfaceOf } from './chunk-N23SKIG4.js';
+import { isActivityImplementation, isDurableWorkflow, interfaceOf, toMs } from './chunk-C4F5KJTI.js';
 
 // src/builder/collect.ts
 var COLLECTION_FORMAT = "fluidgrids.tier1-collection";
+function configDuration(value) {
+  return typeof value === "string" ? value : toMs(value) / 1e3;
+}
+function runSettingsOf(options) {
+  const config = {};
+  const features = [];
+  if (options.runTimeout !== void 0) config.timeout = 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 = isOperation(spec) ? spec : isRecord(spec) ? spec.operation : void 0;
@@ -22,9 +55,16 @@ function triggerOf(spec, where) {
 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 (isActivityImplementation(value)) {
+        implementations.push({ module, exportName, name: value.name });
+        continue;
+      }
       if (!isDurableWorkflow(value) || exportNames.has(value)) continue;
       exportNames.set(value, exportName);
       const options = value.options;
@@ -40,6 +80,13 @@ function collectWorkflowExports(modules) {
       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);
     }
   }
@@ -64,7 +111,9 @@ function collectWorkflowExports(modules) {
   const collection = {
     format: COLLECTION_FORMAT,
     workflows,
-    ...durable.length > 0 ? { durable } : {}
+    ...durable.length > 0 ? { durable } : {},
+    ...implementations.length > 0 ? { activityImplementations: implementations } : {},
+    ...interceptorModules.length > 0 ? { interceptorModules } : {}
   };
   return JSON.stringify(collection);
 }

package/dist/{chunk-6FSHT5IL.js → chunk-7EZIANC7.js}

@@ -1,4 +1,4 @@
-import { hashedProjection } from './chunk-BD7ZPG53.js';
+import { hashedProjection } from './chunk-NWQ5WRLE.js';
 import { isRecord, deepEqual, ownValue } from './chunk-PMCM2OH4.js';
 
 // src/ir/diff.ts

package/dist/{chunk-2J6TF7YI.cjs → chunk-A5SXCA62.cjs}

@@ -55,10 +55,15 @@ function canonicalType(nodeType) {
   const lower = nodeType.trim().toLowerCase();
   return LEGACY_SHORT_NAMES.has(lower) ? `internal:${lower}` : lower;
 }
-function isActivityNodeTypeAllowed(nodeType) {
+var ACTIVITY_ASYNC_COMPLETION_ALLOWLIST = /* @__PURE__ */ new Set([
+  "internal:send-and-wait"
+]);
+function isActivityNodeTypeAllowed(nodeType, options = {}) {
   if (typeof nodeType !== "string" || nodeType.trim() === "") return false;
   const type = canonicalType(nodeType);
   if (!type.startsWith("internal:")) return true;
+  if (options.asyncCompletion === true && ACTIVITY_ASYNC_COMPLETION_ALLOWLIST.has(type))
+    return true;
   return ACTIVITY_INTERNAL_ALLOWLIST.has(type);
 }
 var ActivityNodeTypeNotAllowedError = class extends Error {
@@ -74,10 +79,12 @@ var ActivityNodeTypeNotAllowedError = class extends Error {
   errorType = "VALIDATION";
   nonRetryable = true;
 };
-function assertActivityNodeType(nodeType) {
-  if (!isActivityNodeTypeAllowed(nodeType)) throw new ActivityNodeTypeNotAllowedError(nodeType);
+function assertActivityNodeType(nodeType, options = {}) {
+  if (!isActivityNodeTypeAllowed(nodeType, options))
+    throw new ActivityNodeTypeNotAllowedError(nodeType);
 }
 
+exports.ACTIVITY_ASYNC_COMPLETION_ALLOWLIST = ACTIVITY_ASYNC_COMPLETION_ALLOWLIST;
 exports.ACTIVITY_INTERNAL_ALLOWLIST = ACTIVITY_INTERNAL_ALLOWLIST;
 exports.ACTIVITY_NODE_ALLOWLIST = ACTIVITY_NODE_ALLOWLIST;
 exports.ACTIVITY_NODE_DENYLIST = ACTIVITY_NODE_DENYLIST;

package/dist/{chunk-BO6OVILK.js → chunk-AC6ZEXVR.js}

@@ -53,10 +53,15 @@ function canonicalType(nodeType) {
   const lower = nodeType.trim().toLowerCase();
   return LEGACY_SHORT_NAMES.has(lower) ? `internal:${lower}` : lower;
 }
-function isActivityNodeTypeAllowed(nodeType) {
+var ACTIVITY_ASYNC_COMPLETION_ALLOWLIST = /* @__PURE__ */ new Set([
+  "internal:send-and-wait"
+]);
+function isActivityNodeTypeAllowed(nodeType, options = {}) {
   if (typeof nodeType !== "string" || nodeType.trim() === "") return false;
   const type = canonicalType(nodeType);
   if (!type.startsWith("internal:")) return true;
+  if (options.asyncCompletion === true && ACTIVITY_ASYNC_COMPLETION_ALLOWLIST.has(type))
+    return true;
   return ACTIVITY_INTERNAL_ALLOWLIST.has(type);
 }
 var ActivityNodeTypeNotAllowedError = class extends Error {
@@ -72,8 +77,9 @@ var ActivityNodeTypeNotAllowedError = class extends Error {
   errorType = "VALIDATION";
   nonRetryable = true;
 };
-function assertActivityNodeType(nodeType) {
-  if (!isActivityNodeTypeAllowed(nodeType)) throw new ActivityNodeTypeNotAllowedError(nodeType);
+function assertActivityNodeType(nodeType, options = {}) {
+  if (!isActivityNodeTypeAllowed(nodeType, options))
+    throw new ActivityNodeTypeNotAllowedError(nodeType);
 }
 
-export { ACTIVITY_INTERNAL_ALLOWLIST, ACTIVITY_NODE_ALLOWLIST, ACTIVITY_NODE_DENYLIST, ActivityNodeTypeNotAllowedError, assertActivityNodeType, isActivityNodeTypeAllowed };
+export { ACTIVITY_ASYNC_COMPLETION_ALLOWLIST, ACTIVITY_INTERNAL_ALLOWLIST, ACTIVITY_NODE_ALLOWLIST, ACTIVITY_NODE_DENYLIST, ActivityNodeTypeNotAllowedError, assertActivityNodeType, isActivityNodeTypeAllowed };