@fluidgrids/workflows 2026.1028.1 → 2026.1029.1

package/dist/chunk-PWIUEWC3.js

@@ -0,0 +1,81 @@
+// 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;
+}
+
+export { DEFAULT_ACTIVITY_RETRY, computeRetryDelay, computeRunRetryDelay, explicitRetryPolicy, explicitRunRetryPolicy };

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-P6TA5EZT.cjs → chunk-RUQIMTN5.cjs}

@@ -1,17 +1,142 @@
 'use strict';
 
-var chunk623FVQSN_cjs = require('./chunk-623FVQSN.cjs');
-var chunk2J6TF7YI_cjs = require('./chunk-2J6TF7YI.cjs');
+var chunk3FIDHONL_cjs = require('./chunk-3FIDHONL.cjs');
 
 // src/history/commands.ts
+var COMMAND_FEATURES = [
+  "core",
+  "parity.can",
+  "parity.context",
+  "parity.localActivity",
+  "parity.externalCancel",
+  "parity.childOptions",
+  "parity.canOptions",
+  "parity.workflowIdTarget",
+  "c.updates",
+  "c.searchAttributes",
+  "c.userActivity"
+];
+var PHASE_B_CORE_FEATURES = /* @__PURE__ */ new Set([
+  "core",
+  "parity.can",
+  "parity.context"
+]);
+var PHASE_B_PARITY_FEATURES = /* @__PURE__ */ new Set([
+  "core",
+  "parity.can",
+  "parity.context",
+  "parity.localActivity",
+  "parity.externalCancel",
+  "parity.childOptions",
+  "parity.canOptions",
+  "parity.workflowIdTarget"
+]);
+var CORE_CHILD_OPTIONS = /* @__PURE__ */ new Set([
+  "parentClosePolicy",
+  "cancellationType",
+  "taskQueue",
+  "workflowId",
+  "priority",
+  "summary",
+  "details",
+  "context",
+  "startDelay",
+  "executionTimeout",
+  "runTimeout",
+  "workflowTaskTimeout"
+]);
+var CORE_CAN_OPTIONS = /* @__PURE__ */ new Set([
+  "taskQueue",
+  "retry",
+  "workflowTaskTimeout",
+  "context",
+  "versioningBehavior"
+]);
+var LEGACY_RETRY_KEYS = ["retryDelay", "maxRetries", "maxDelay"];
+var RUN_RETRY_KEYS = ["initialDelayMs", "maxAttempts", "maxDelayMs"];
+function continueAsNewRetryShape(options) {
+  const retry = options["retry"];
+  if (retry === void 0) return "none";
+  if (typeof retry !== "object" || retry === null || Array.isArray(retry)) return "invalid";
+  const keys = Object.keys(retry);
+  const run = keys.some((key) => RUN_RETRY_KEYS.includes(key));
+  const legacy = keys.some((key) => LEGACY_RETRY_KEYS.includes(key));
+  if (run === legacy) return "invalid";
+  return run ? "run" : "legacy";
+}
+function hasOtherKeys(value, allowed) {
+  return Object.entries(value).some(([key, entry]) => entry !== void 0 && !allowed.has(key));
+}
+function commandFeatures(command) {
+  const needed = /* @__PURE__ */ new Set();
+  switch (command.type) {
+    case "START_CHILD_RUN":
+      needed.add("core");
+      if (hasOtherKeys(command.options, CORE_CHILD_OPTIONS)) needed.add("parity.childOptions");
+      break;
+    case "SIGNAL_RUN":
+      needed.add("core");
+      if ("workflowId" in command.target) needed.add("parity.workflowIdTarget");
+      break;
+    case "REQUEST_CANCEL_EXTERNAL_RUN":
+      if ("childId" in command.target) needed.add("core");
+      else needed.add("parity.externalCancel");
+      if ("workflowId" in command.target) needed.add("parity.workflowIdTarget");
+      break;
+    case "CONTINUE_AS_NEW":
+      needed.add("parity.can");
+      if (hasOtherKeys(command.options, CORE_CAN_OPTIONS) || continueAsNewRetryShape(command.options) === "run")
+        needed.add("parity.canOptions");
+      break;
+    case "UPSERT_CONTEXT":
+      needed.add("parity.context");
+      break;
+    case "RECORD_LOCAL_ACTIVITY":
+      needed.add("parity.localActivity");
+      break;
+    case "UPSERT_SEARCH_ATTRIBUTES":
+      needed.add("c.searchAttributes");
+      break;
+    case "ACCEPT_UPDATE":
+    case "REJECT_UPDATE":
+    case "COMPLETE_UPDATE":
+      needed.add("c.updates");
+      break;
+    default:
+      needed.add("core");
+  }
+  return COMMAND_FEATURES.filter((feature) => needed.has(feature));
+}
 function isCommandEnabled(type, enabled = "core") {
-  if (chunk623FVQSN_cjs.PHASE_C_COMMANDS.has(type)) return false;
-  if (chunk623FVQSN_cjs.PHASE_B_CORE_COMMANDS.has(type)) return true;
-  return enabled === "parity" && chunk623FVQSN_cjs.PHASE_B_PARITY_COMMANDS.has(type);
+  if (chunk3FIDHONL_cjs.PHASE_C_COMMANDS.has(type)) return false;
+  if (chunk3FIDHONL_cjs.PHASE_B_CORE_COMMANDS.has(type)) return true;
+  return enabled === "parity" && chunk3FIDHONL_cjs.PHASE_B_PARITY_COMMANDS.has(type);
 }
 function isWorkflowCommandEnabled(command, enabled = "core") {
-  if (command.type === "REQUEST_CANCEL_EXTERNAL_RUN" && "childId" in command.target) return true;
-  return isCommandEnabled(command.type, enabled);
+  if (typeof enabled === "string") {
+    if (command.type === "REQUEST_CANCEL_EXTERNAL_RUN" && "childId" in command.target) return true;
+    return isCommandEnabled(command.type, enabled);
+  }
+  return commandFeatures(command).every((feature) => enabled.has(feature));
+}
+function unsupportedMessage(command, enabled = "core") {
+  if (typeof enabled === "string") return `${command.type} is not supported in this release`;
+  const missing = commandFeatures(command).filter((feature) => !enabled.has(feature));
+  const parity = missing.filter((feature) => feature.startsWith("parity."));
+  const flag = parity.length > 0 ? " (needs the fluidgrids.durable-parity flag)" : "";
+  return `${command.type} needs ${missing.join(", ")}, which this workspace does not enable${flag}`;
+}
+function isReliefCommand(command, lease) {
+  switch (command.type) {
+    case "RECORD_LOCAL_ACTIVITY":
+      return lease.grantedLocalActivityIds.includes(command.localActivityId);
+    case "ACCEPT_UPDATE":
+    case "REJECT_UPDATE":
+    case "COMPLETE_UPDATE":
+      return lease.deliveredUpdateIds.includes(command.updateId);
+    default:
+      return false;
+  }
 }
 
 // src/history/activation.ts
@@ -64,10 +189,10 @@ function walk(history) {
         continue;
       }
     }
-    if (chunk623FVQSN_cjs.isInputEvent(event)) {
+    if (chunk3FIDHONL_cjs.isInputEvent(event)) {
       if (started) afterStarted.push(event);
       else pending.push(event);
-    } else if (chunk623FVQSN_cjs.isCommandEvent(event) && last?.recorded) {
+    } else if (chunk3FIDHONL_cjs.isCommandEvent(event) && last?.recorded) {
       last.recorded.push(event);
     }
   }
@@ -109,6 +234,7 @@ function initialRunState() {
     timers: {},
     children: {},
     externals: {},
+    localActivities: {},
     sideEffects: {},
     markers: {},
     signalsReceived: 0,
@@ -348,6 +474,21 @@ function applyEvent(state, event) {
     case "SIDE_EFFECT_RECORDED":
       state.sideEffects[str(p, "sideEffectId")] = p["value"] ?? null;
       break;
+    case "LOCAL_ACTIVITY_COMPLETED":
+    case "LOCAL_ACTIVITY_FAILED": {
+      const id = str(p, "localActivityId");
+      if (state.localActivities[id])
+        throw new HistoryStateError(`Local activity "${id}" is recorded twice`, event.seq);
+      state.localActivities[id] = {
+        status: event.type === "LOCAL_ACTIVITY_COMPLETED" ? "COMPLETED" : "FAILED",
+        attempts: typeof p["attempts"] === "number" ? p["attempts"] : 1,
+        recordedSeq: event.seq,
+        ...typeof p["nodeType"] === "string" ? { nodeType: p["nodeType"] } : {},
+        ...typeof p["operation"] === "string" ? { operation: p["operation"] } : {},
+        ...typeof p["summary"] === "string" ? { summary: p["summary"] } : {}
+      };
+      break;
+    }
     case "MARKER_RECORDED":
       state.markers[str(p, "markerId")] = p["data"] ?? null;
       break;
@@ -423,21 +564,22 @@ function eventsForCommands(state, commands, context) {
   const children = new Set(Object.keys(state.children));
   const externals = new Set(Object.keys(state.externals));
   const sideEffects = new Set(Object.keys(state.sideEffects));
+  const localActivities = new Set(Object.keys(state.localActivities));
   let unsupported = false;
   commands.forEach((command, index) => {
-    if (!isWorkflowCommandEnabled(command, context.enabled)) {
+    if (!isWorkflowCommandEnabled(command, context.enabled) && !(context.relief !== void 0 && isReliefCommand(command, context.relief))) {
       unsupported = true;
-      reject(index, "commands.unsupported", `${command.type} is not supported in this release`);
+      reject(index, "commands.unsupported", unsupportedMessage(command, context.enabled));
       return;
     }
-    if (chunk623FVQSN_cjs.TERMINAL_COMMANDS.has(command.type) && index !== commands.length - 1)
+    if (chunk3FIDHONL_cjs.TERMINAL_COMMANDS.has(command.type) && index !== commands.length - 1)
       reject(index, "commands.terminalNotLast", `${command.type} must be last`);
     const base = { taskId: context.taskId };
     switch (command.type) {
       case "SCHEDULE_ACTIVITY":
         if (activities.has(command.activityId))
           reject(index, "activity.duplicate", `Activity "${command.activityId}" already exists`);
-        if (!chunk2J6TF7YI_cjs.isActivityNodeTypeAllowed(command.nodeType))
+        if (!chunk3FIDHONL_cjs.isActivityNodeTypeAllowed(command.nodeType))
           reject(
             index,
             "durable.activityTypeNotAllowed",
@@ -518,6 +660,13 @@ function eventsForCommands(state, commands, context) {
         events.push({ ...base, type: "CONTEXT_UPSERTED", payload: payloadOf(command) });
         break;
       case "RECORD_LOCAL_ACTIVITY":
+        if (localActivities.has(command.localActivityId))
+          reject(
+            index,
+            "localActivity.duplicate",
+            `Local activity "${command.localActivityId}" is already recorded`
+          );
+        localActivities.add(command.localActivityId);
         events.push({
           ...base,
           type: command.failure ? "LOCAL_ACTIVITY_FAILED" : "LOCAL_ACTIVITY_COMPLETED",
@@ -561,47 +710,6 @@ function hasUnprocessedInput(history) {
   return unseenInputs(history).length > 0;
 }
 
-// src/history/retry.ts
-var DEFAULT_ACTIVITY_RETRY = Object.freeze({
-  retryDelay: 1e3,
-  backoffMultiplier: 2,
-  maxDelay: 1e5
-});
-var FINAL_TIMEOUTS = /* @__PURE__ */ new Set(["SCHEDULE_TO_START", "SCHEDULE_TO_CLOSE"]);
-function computeRetryDelay(policy, attempt, failure) {
-  if (failure?.nonRetryable === true) return { retry: false, reason: "nonRetryable" };
-  if (failure?.timeoutType !== void 0 && FINAL_TIMEOUTS.has(failure.timeoutType))
-    return { retry: false, reason: "finalTimeout" };
-  if (failure?.type !== void 0 && policy.nonRetryableErrorTypes !== void 0 && policy.nonRetryableErrorTypes.includes(failure.type))
-    return { retry: false, reason: "typeDenied" };
-  if (failure !== void 0 && policy.retryOnErrorTypes !== void 0 && policy.retryOnErrorTypes.length > 0 && !policy.retryOnErrorTypes.includes(failure.errorType))
-    return { retry: false, reason: "errorTypeNotListed" };
-  if (policy.maxRetries !== void 0 && attempt > policy.maxRetries)
-    return { retry: false, reason: "maxRetries" };
-  if (failure?.nextRetryDelayMs !== void 0)
-    return { retry: true, delayMs: Math.max(0, Math.round(failure.nextRetryDelayMs)) };
-  const base = Math.max(0, policy.retryDelay);
-  const multiplier = policy.backoffMultiplier ?? 2;
-  const cap = policy.maxDelay ?? base * 100;
-  const exponent = Math.max(0, attempt - 1);
-  const delay = Math.min(base * Math.pow(multiplier, exponent), cap);
-  return { retry: true, delayMs: Math.round(Number.isFinite(delay) ? delay : cap) };
-}
-function explicitRetryPolicy(policy) {
-  const retryDelay = policy?.retryDelay ?? DEFAULT_ACTIVITY_RETRY.retryDelay;
-  const out = {
-    retryDelay,
-    backoffMultiplier: policy?.backoffMultiplier ?? DEFAULT_ACTIVITY_RETRY.backoffMultiplier ?? 2,
-    maxDelay: policy?.maxDelay ?? (policy?.retryDelay === void 0 ? 1e5 : Math.max(retryDelay, retryDelay * 100))
-  };
-  if (policy?.maxRetries !== void 0) out.maxRetries = policy.maxRetries;
-  if (policy?.retryOnErrorTypes !== void 0)
-    out.retryOnErrorTypes = [...policy.retryOnErrorTypes];
-  if (policy?.nonRetryableErrorTypes !== void 0)
-    out.nonRetryableErrorTypes = [...policy.nonRetryableErrorTypes];
-  return out;
-}
-
 // src/history/defaults.ts
 function codeWorkflowParentClosePolicy(state) {
   const policy = state.parentClosePolicy;
@@ -613,22 +721,28 @@ var CHILD_DEFAULT_CANCELLATION_TYPE = "WAIT_CANCELLATION_COMPLETED";
 
 exports.CHILD_DEFAULT_CANCELLATION_TYPE = CHILD_DEFAULT_CANCELLATION_TYPE;
 exports.CHILD_DEFAULT_PARENT_CLOSE_POLICY = CHILD_DEFAULT_PARENT_CLOSE_POLICY;
-exports.DEFAULT_ACTIVITY_RETRY = DEFAULT_ACTIVITY_RETRY;
+exports.COMMAND_FEATURES = COMMAND_FEATURES;
+exports.CORE_CAN_OPTIONS = CORE_CAN_OPTIONS;
+exports.CORE_CHILD_OPTIONS = CORE_CHILD_OPTIONS;
 exports.HistoryStateError = HistoryStateError;
+exports.PHASE_B_CORE_FEATURES = PHASE_B_CORE_FEATURES;
+exports.PHASE_B_PARITY_FEATURES = PHASE_B_PARITY_FEATURES;
 exports.applyEvent = applyEvent;
 exports.codeWorkflowParentClosePolicy = codeWorkflowParentClosePolicy;
-exports.computeRetryDelay = computeRetryDelay;
+exports.commandFeatures = commandFeatures;
+exports.continueAsNewRetryShape = continueAsNewRetryShape;
 exports.eventsForCommands = eventsForCommands;
-exports.explicitRetryPolicy = explicitRetryPolicy;
 exports.hasUnprocessedInput = hasUnprocessedInput;
 exports.initialRunState = initialRunState;
 exports.isActivityOpen = isActivityOpen;
 exports.isChildOpen = isChildOpen;
 exports.isCommandEnabled = isCommandEnabled;
+exports.isReliefCommand = isReliefCommand;
 exports.isWorkflowCommandEnabled = isWorkflowCommandEnabled;
 exports.pendingCounts = pendingCounts;
 exports.projectRunState = projectRunState;
 exports.splitActivations = splitActivations;
 exports.taskCompletedEvents = taskCompletedEvents;
 exports.unseenInputs = unseenInputs;
+exports.unsupportedMessage = unsupportedMessage;
 exports.utf8Bytes = utf8Bytes;

package/dist/{chunk-IISBRUWJ.js → chunk-WXXNCHUY.js}

@@ -1,4 +1,4 @@
-import { HISTORY_PROTOCOL } from './chunk-DJYMDLV5.js';
+import { HISTORY_PROTOCOL } from './chunk-2DDULZFM.js';
 
 function failedTaskResult(cause, message) {
   return {

package/dist/chunk-YHBVMOMK.cjs

@@ -0,0 +1,87 @@
+'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;
+}
+
+exports.DEFAULT_ACTIVITY_RETRY = DEFAULT_ACTIVITY_RETRY;
+exports.computeRetryDelay = computeRetryDelay;
+exports.computeRunRetryDelay = computeRunRetryDelay;
+exports.explicitRetryPolicy = explicitRetryPolicy;
+exports.explicitRunRetryPolicy = explicitRunRetryPolicy;

package/dist/codegen/index.d.cts

@@ -1,5 +1,5 @@
-import { N as NodeManifest } from '../manifest-0OLw0i7k.cjs';
-import '../types-BGoPzgcl.cjs';
+import { N as NodeManifest } from '../manifest-gRI2Q5Fj.cjs';
+import '../types-Bb2wRnJ5.cjs';
 
 interface GeneratedClients {
     path: string;

package/dist/codegen/index.d.ts

@@ -1,5 +1,5 @@
-import { N as NodeManifest } from '../manifest-C8N6HDYl.js';
-import '../types-BGoPzgcl.js';
+import { N as NodeManifest } from '../manifest-BJjrQt77.js';
+import '../types-Bb2wRnJ5.js';
 
 interface GeneratedClients {
     path: string;

package/dist/collect-BTHjQaSp.d.ts

@@ -0,0 +1,86 @@
+import { P as Position, a as JsonObject, d as ConnectionRef, i as WorkflowAuthoring, W as WorkflowDefinition, b as WorkflowInterface, k as WorkflowConfig } from './types-Bb2wRnJ5.js';
+import { T as Tier1Recording, x as Tier1Workflow } from './workflow-8uRU9rhL.js';
+
+declare const LAYOUT_FORMAT = "fluidgrids.layout";
+declare const LAYOUT_FORMAT_VERSION = 1;
+/**
+ * The layout sidecar (`workflows/<key>.layout.json`): canvas positions, sticky
+ * notes and `meta.layout`, kept out of the code so it stays readable.
+ */
+interface LayoutSidecar {
+    format: typeof LAYOUT_FORMAT;
+    formatVersion: typeof LAYOUT_FORMAT_VERSION;
+    positions: Record<string, Position>;
+    stickyNotes?: JsonObject[];
+    metaLayout?: JsonObject;
+}
+/** How connection names in code resolve to connection references. */
+type ConnectionResolver = Readonly<Record<string, ConnectionRef>> | ((name: string) => ConnectionRef | undefined);
+interface AssembleOptions {
+    layout?: LayoutSidecar;
+    connections?: ConnectionResolver;
+    /** TEST-only pinned data (`workflows/<key>.pinned.json`). */
+    pinnedData?: JsonObject;
+    /** Provenance; defaults to `{ mode: 'canvas', generator: 'sdk-ts', generatorVersion }`. */
+    authoring?: WorkflowAuthoring;
+}
+/** Connection names used in code that the target workspace does not have. */
+declare class UnresolvedConnectionsError extends Error {
+    readonly names: string[];
+    constructor(names: string[]);
+}
+/** Validate a parsed layout sidecar. */
+declare function parseLayoutSidecar(value: unknown): LayoutSidecar;
+/** Assemble IR v2 from a recording. */
+declare function assembleRecording(recording: Tier1Recording, options?: AssembleOptions): WorkflowDefinition;
+/** Lower a tier-1 workflow to IR v2 (spec 10 §1 `toIR`). */
+declare function toIR(workflow: Tier1Workflow, options?: AssembleOptions): WorkflowDefinition;
+
+/**
+ * Runs inside the evaluation isolate at the end of a bundle: gathers the
+ * recordings of every exported `defineWorkflow` value and the declarations of
+ * every exported tier-2 `workflow()` as one JSON string, the only thing that
+ * leaves the isolate.
+ */
+
+declare const COLLECTION_FORMAT = "fluidgrids.tier1-collection";
+interface CollectedWorkflow {
+    module: string;
+    exportName: string;
+    recording: Tier1Recording;
+}
+/** The trigger a standalone tier-2 workflow declares. */
+interface CollectedTrigger {
+    nodeType: string;
+    version?: string;
+    operation?: string;
+    args?: JsonObject;
+    id?: string;
+}
+/** One exported tier-2 workflow (C-ABI `durable` entries of the collection). */
+interface CollectedDurableWorkflow {
+    module: string;
+    exportName: string;
+    /** The workflow key it gets when standalone. */
+    name: string;
+    title?: string;
+    description?: string;
+    taskQueue: string;
+    interface: WorkflowInterface;
+    standalone?: boolean;
+    trigger?: CollectedTrigger;
+    /** Run-level settings the declaration lowers into `config` (R2). */
+    config?: WorkflowConfig;
+    /** Runtime features its options use (C-FEATURES): `autoUpgrade`, `runRetry`, `timeouts`. */
+    features?: string[];
+}
+interface Tier1Collection {
+    format: typeof COLLECTION_FORMAT;
+    workflows: CollectedWorkflow[];
+    /** Tier-2 functions; absent when the bundle has none. */
+    durable?: CollectedDurableWorkflow[];
+}
+/** Collect the workflows exported by each module, as JSON. */
+declare function collectWorkflowExports(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): string;
+
+export { type AssembleOptions as A, COLLECTION_FORMAT as C, LAYOUT_FORMAT as L, type Tier1Collection as T, UnresolvedConnectionsError as U, type CollectedDurableWorkflow as a, type CollectedTrigger as b, type CollectedWorkflow as c, type ConnectionResolver as d, LAYOUT_FORMAT_VERSION as e, type LayoutSidecar as f, assembleRecording as g, collectWorkflowExports as h, parseLayoutSidecar as p, toIR as t };