@fluidgrids/workflows 2026.1028.2 → 2026.1029.1

package/dist/{chunk-PZCVF76Q.cjs → chunk-I47EENR4.cjs}

@@ -1,9 +1,8 @@
 'use strict';
 
 var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
-var chunkP6TA5EZT_cjs = require('./chunk-P6TA5EZT.cjs');
-var chunk623FVQSN_cjs = require('./chunk-623FVQSN.cjs');
-var chunk2J6TF7YI_cjs = require('./chunk-2J6TF7YI.cjs');
+var chunkRUQIMTN5_cjs = require('./chunk-RUQIMTN5.cjs');
+var chunk3FIDHONL_cjs = require('./chunk-3FIDHONL.cjs');
 var _2020_js = require('ajv/dist/2020.js');
 
 // src/history/schema.ts
@@ -24,7 +23,7 @@ var SHARED_DEFS = {
     type: "object",
     required: ["errorType", "message"],
     properties: {
-      errorType: { enum: [...chunk623FVQSN_cjs.ERROR_TYPES] },
+      errorType: { enum: [...chunk3FIDHONL_cjs.ERROR_TYPES] },
       message: { type: "string" },
       type: { type: "string" },
       details: {},
@@ -47,7 +46,7 @@ var SHARED_DEFS = {
       retryDelay: NON_NEGATIVE_MS,
       backoffMultiplier: { type: "number", minimum: 1 },
       maxDelay: NON_NEGATIVE_MS,
-      retryOnErrorTypes: { type: "array", items: { enum: [...chunk623FVQSN_cjs.ERROR_TYPES] } },
+      retryOnErrorTypes: { type: "array", items: { enum: [...chunk3FIDHONL_cjs.ERROR_TYPES] } },
       nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
     },
     additionalProperties: false
@@ -75,17 +74,42 @@ var SHARED_DEFS = {
       {
         type: "object",
         required: ["workflowKey", "workflowId"],
-        properties: { workflowKey: ID, workflowId: ID },
+        description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).",
+        properties: { workflowKey: ID, workflowId: ID, firstRunId: ID },
         additionalProperties: false
       }
     ]
   },
+  runRetryPolicy: {
+    type: "object",
+    required: ["initialDelayMs"],
+    description: "Run-level retry (11 \xA72.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.",
+    properties: {
+      maxAttempts: { type: "integer", minimum: 1 },
+      initialDelayMs: NON_NEGATIVE_MS,
+      backoffMultiplier: { type: "number", minimum: 1 },
+      maxDelayMs: NON_NEGATIVE_MS,
+      retryOnErrorTypes: { type: "array", items: { enum: [...chunk3FIDHONL_cjs.ERROR_TYPES] } },
+      nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
+    },
+    additionalProperties: false
+  },
+  timeouts: {
+    type: "object",
+    description: "The three workflow timeouts (11 \xA72.20), in milliseconds.",
+    properties: {
+      executionTimeout: NON_NEGATIVE_MS,
+      runTimeout: NON_NEGATIVE_MS,
+      workflowTaskTimeout: NON_NEGATIVE_MS
+    },
+    additionalProperties: false
+  },
   childOptions: {
     type: "object",
     required: ["parentClosePolicy"],
     properties: {
-      parentClosePolicy: { enum: [...chunk623FVQSN_cjs.PARENT_CLOSE_POLICIES] },
-      cancellationType: { enum: [...chunk623FVQSN_cjs.CHILD_CANCELLATION_TYPES] },
+      parentClosePolicy: { enum: [...chunk3FIDHONL_cjs.PARENT_CLOSE_POLICIES] },
+      cancellationType: { enum: [...chunk3FIDHONL_cjs.CHILD_CANCELLATION_TYPES] },
       taskQueue: ID,
       workflowId: ID,
       priority: { type: "integer", minimum: 1, maximum: 5 },
@@ -95,9 +119,41 @@ var SHARED_DEFS = {
       executionTimeout: NON_NEGATIVE_MS,
       runTimeout: NON_NEGATIVE_MS,
       workflowTaskTimeout: NON_NEGATIVE_MS,
-      startDelay: NON_NEGATIVE_MS
+      startDelay: NON_NEGATIVE_MS,
+      retry: { $ref: "#/$defs/runRetryPolicy" },
+      versioningBehavior: { enum: [...chunk3FIDHONL_cjs.VERSIONING_BEHAVIORS] },
+      idReusePolicy: { enum: [...chunk3FIDHONL_cjs.WORKFLOW_ID_REUSE_POLICIES] },
+      idConflictPolicy: { enum: [...chunk3FIDHONL_cjs.WORKFLOW_ID_CONFLICT_POLICIES] }
     }
   },
+  legacyCanRetryPolicy: {
+    type: "object",
+    required: ["retryDelay"],
+    description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.",
+    properties: {
+      maxRetries: { type: "number" },
+      retryDelay: { type: "number" },
+      backoffMultiplier: { type: "number" },
+      maxDelay: { type: "number" },
+      retryOnErrorTypes: { type: "array", items: { type: "string" } },
+      nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
+    },
+    additionalProperties: false
+  },
+  canOptions: {
+    type: "object",
+    description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.",
+    properties: {
+      taskQueue: ID,
+      retry: {
+        oneOf: [{ $ref: "#/$defs/runRetryPolicy" }, { $ref: "#/$defs/legacyCanRetryPolicy" }]
+      },
+      workflowTaskTimeout: NON_NEGATIVE_MS,
+      context: { type: "object" },
+      versioningBehavior: { enum: [...chunk3FIDHONL_cjs.VERSIONING_BEHAVIORS] }
+    },
+    additionalProperties: false
+  },
   headers: STRING_MAP
 };
 function command(type, required, properties) {
@@ -125,7 +181,7 @@ var COMMAND_DEFS = {
       scheduleToCloseTimeout: NON_NEGATIVE_MS,
       scheduleToStartTimeout: NON_NEGATIVE_MS,
       heartbeatTimeout: NON_NEGATIVE_MS,
-      cancellationType: { enum: [...chunk623FVQSN_cjs.ACTIVITY_CANCELLATION_TYPES] },
+      cancellationType: { enum: [...chunk3FIDHONL_cjs.ACTIVITY_CANCELLATION_TYPES] },
       priority: { type: "integer", minimum: 1, maximum: 5 },
       summary: { type: "string", maxLength: 200 },
       runOn: { type: "string" }
@@ -171,13 +227,16 @@ var COMMAND_DEFS = {
       localActivityId: ID,
       result: {},
       failure: { $ref: "#/$defs/failure" },
-      attempts: { type: "integer", minimum: 1 }
+      attempts: { type: "integer", minimum: 1 },
+      nodeType: ID,
+      operation: ID,
+      summary: { type: "string", maxLength: 200 }
     }),
     oneOf: [{ required: ["result"] }, { required: ["failure"] }]
   },
   CONTINUE_AS_NEW: command("CONTINUE_AS_NEW", ["input", "options"], {
     input: {},
-    options: { type: "object" }
+    options: { $ref: "#/$defs/canOptions" }
   }),
   REQUEST_CANCEL_EXTERNAL_RUN: command("REQUEST_CANCEL_EXTERNAL_RUN", ["externalId", "target"], {
     externalId: ID,
@@ -213,7 +272,7 @@ var EVENT_PAYLOADS = {
     rootRunId: { type: ["string", "null"] },
     firstRunId: { type: ["string", "null"] },
     continuedFromRunId: { type: ["string", "null"] },
-    parentClosePolicy: { enum: [...chunk623FVQSN_cjs.PARENT_CLOSE_POLICIES] },
+    parentClosePolicy: { enum: [...chunk3FIDHONL_cjs.PARENT_CLOSE_POLICIES] },
     startDelay: NON_NEGATIVE_MS,
     lastCompletionResult: {},
     lastFailure: { oneOf: [{ type: "null" }, FAILURE_REF] },
@@ -223,9 +282,26 @@ var EVENT_PAYLOADS = {
     executionTimeout: NON_NEGATIVE_MS,
     runTimeout: NON_NEGATIVE_MS,
     workflowTaskTimeout: NON_NEGATIVE_MS,
-    versioningBehavior: { enum: ["PINNED", "AUTO_UPGRADE"] },
+    versioningBehavior: { enum: [...chunk3FIDHONL_cjs.VERSIONING_BEHAVIORS] },
     /** Seed of `ctx.random()`/`ctx.uuid()`; the service writes the run id. Absent: `info.runId`. */
-    randomnessSeed: ID
+    randomnessSeed: ID,
+    startDelayMs: {
+      ...NON_NEGATIVE_MS,
+      description: "R2: the start delay of a delayed run (11 \xA72.23); the first task waits for it."
+    },
+    runAttempt: {
+      type: "integer",
+      minimum: 1,
+      description: "R2: the run-level retry attempt (11 \xA72.17), 1-based."
+    },
+    businessId: {
+      type: "string",
+      description: "R2: the workflow id (11 \xA72.1), stored as WorkflowRun.businessId."
+    },
+    workflowId: { type: "string", description: "R2: the same value as businessId." },
+    timeouts: { $ref: "#/$defs/timeouts" },
+    retry: { $ref: "#/$defs/runRetryPolicy" },
+    priority: { type: "integer", minimum: 1, maximum: 5 }
   }),
   WORKFLOW_TASK_SCHEDULED: payload(["taskId"], {
     taskId: ID,
@@ -244,6 +320,9 @@ var EVENT_PAYLOADS = {
       type: "integer",
       minimum: 1,
       description: "The history length the attempt was leased with (run.taskStartedSeq), when it is not this event's own seq. Required on the WORKFLOW_TASK_STARTED of a transient attempt: input events with a higher seq that precede this event arrived during the attempt and belong to the next activation."
+    },
+    version: {
+      description: "R2: the workflow version whose bundle served the task (it differs from WORKFLOW_STARTED.version after an AUTO_UPGRADE or a versioning override)."
     }
   }),
   WORKFLOW_TASK_COMPLETED: payload(["taskId"], {
@@ -254,7 +333,7 @@ var EVENT_PAYLOADS = {
   WORKFLOW_TASK_FAILED: payload(["taskId", "attempt", "cause"], {
     taskId: ID,
     attempt: { type: "integer", minimum: 1 },
-    cause: { enum: [...chunk623FVQSN_cjs.TASK_FAILURE_CAUSES] },
+    cause: { enum: [...chunk3FIDHONL_cjs.TASK_FAILURE_CAUSES] },
     message: { type: "string" },
     stackTrace: { type: "string" },
     buildId: { type: "string" }
@@ -348,7 +427,7 @@ var EVENT_PAYLOADS = {
   CHILD_RUN_TIMED_OUT: payload(["childId"], {
     childId: ID,
     childRunId: ID,
-    timeoutType: { enum: ["WORKFLOW_RUN", "WORKFLOW_EXECUTION"] }
+    timeoutType: { enum: [...chunk3FIDHONL_cjs.WORKFLOW_TIMEOUT_TYPES] }
   }),
   EXTERNAL_RUN_CANCEL_REQUESTED: payload(["externalId", "target"], {
     externalId: ID,
@@ -382,12 +461,18 @@ var EVENT_PAYLOADS = {
   LOCAL_ACTIVITY_COMPLETED: payload(["localActivityId", "attempts"], {
     localActivityId: ID,
     result: {},
-    attempts: { type: "integer", minimum: 1 }
+    attempts: { type: "integer", minimum: 1 },
+    nodeType: ID,
+    operation: ID,
+    summary: { type: "string" }
   }),
   LOCAL_ACTIVITY_FAILED: payload(["localActivityId", "attempts", "failure"], {
     localActivityId: ID,
     failure: FAILURE_REF,
-    attempts: { type: "integer", minimum: 1 }
+    attempts: { type: "integer", minimum: 1 },
+    nodeType: ID,
+    operation: ID,
+    summary: { type: "string" }
   }),
   SEARCH_ATTRIBUTES_UPSERTED: payload(["attributes"], { attributes: { type: "object" } }),
   CONTEXT_UPSERTED: payload(["entries"], { entries: { type: "object" } }),
@@ -401,17 +486,45 @@ var EVENT_PAYLOADS = {
     toSeq: { type: "integer", minimum: 1 },
     reason: { type: "string" }
   }),
-  VERSIONING_OVERRIDE_SET: payload(["override"], { override: {} }),
+  VERSIONING_OVERRIDE_SET: payload(["override"], {
+    override: {
+      description: "The per-run override (11 \xA72.27): { behavior: PINNED, version } pins the run, { behavior: AUTO_UPGRADE } upgrades it, null removes the override.",
+      oneOf: [
+        { type: "null" },
+        {
+          type: "object",
+          required: ["behavior", "version"],
+          properties: { behavior: { const: "PINNED" }, version: {} },
+          additionalProperties: false
+        },
+        {
+          type: "object",
+          required: ["behavior"],
+          properties: { behavior: { const: "AUTO_UPGRADE" } },
+          additionalProperties: false
+        }
+      ]
+    },
+    actor: {},
+    reason: { type: "string" }
+  }),
   WORKFLOW_COMPLETED: payload(["output"], { output: {} }),
   WORKFLOW_FAILED: payload(["failure"], { failure: FAILURE_REF }),
   WORKFLOW_CANCELLED: payload([], { details: {} }),
   WORKFLOW_TERMINATED: payload([], { reason: { type: "string" }, actor: {} }),
   WORKFLOW_TIMED_OUT: payload(["timeoutType"], {
-    timeoutType: { enum: ["WORKFLOW_RUN", "WORKFLOW_EXECUTION"] }
+    timeoutType: { enum: [...chunk3FIDHONL_cjs.WORKFLOW_TIMEOUT_TYPES] },
+    failure: FAILURE_REF
   }),
   WORKFLOW_CONTINUED_AS_NEW: payload(["input", "options"], {
     input: {},
-    options: { type: "object" },
+    // Not canOptions: the event keeps what the service accepted when the run
+    // continued, and Phase B (R1) runs stored options that the R2 command shape
+    // refuses (fractional delays, a backoff below 1, a long task queue).
+    options: {
+      type: "object",
+      description: "The CONTINUE_AS_NEW options as the service recorded them. New commands are checked against canOptions; histories recorded before R2 may hold any object the R1 contract accepted."
+    },
     newRunId: { type: "string" }
   })
 };
@@ -428,32 +541,32 @@ var RUN_EVENT_RECORD = {
   required: ["seq", "type", "payload", "createdAt"],
   properties: {
     seq: { type: "integer", minimum: 1 },
-    type: { enum: [...chunk623FVQSN_cjs.EVENT_TYPES] },
+    type: { enum: [...chunk3FIDHONL_cjs.EVENT_TYPES] },
     taskId: { type: ["string", "null"] },
     payload: { type: "object" },
     createdAt: { type: "string", minLength: 1 },
     dedupeKey: { type: ["string", "null"] }
   },
-  allOf: chunk623FVQSN_cjs.EVENT_TYPES.map((type) => ({
+  allOf: chunk3FIDHONL_cjs.EVENT_TYPES.map((type) => ({
     if: { properties: { type: { const: type } }, required: ["type"] },
     then: { properties: { payload: { $ref: `#/$defs/payload_${type}` } } }
   }))
 };
 function payloadDefs() {
   const defs = {};
-  for (const type of chunk623FVQSN_cjs.EVENT_TYPES) defs[`payload_${type}`] = compact(EVENT_PAYLOADS[type]);
+  for (const type of chunk3FIDHONL_cjs.EVENT_TYPES) defs[`payload_${type}`] = compact(EVENT_PAYLOADS[type]);
   return defs;
 }
 function commandDefs() {
   const defs = {};
-  for (const type of chunk623FVQSN_cjs.COMMAND_TYPES) defs[`command_${type}`] = COMMAND_DEFS[type];
+  for (const type of chunk3FIDHONL_cjs.COMMAND_TYPES) defs[`command_${type}`] = COMMAND_DEFS[type];
   return defs;
 }
 var COMMAND_ONE_OF = {
   type: "object",
   required: ["type"],
-  properties: { type: { enum: [...chunk623FVQSN_cjs.COMMAND_TYPES] } },
-  allOf: chunk623FVQSN_cjs.COMMAND_TYPES.map((type) => ({
+  properties: { type: { enum: [...chunk3FIDHONL_cjs.COMMAND_TYPES] } },
+  allOf: chunk3FIDHONL_cjs.COMMAND_TYPES.map((type) => ({
     if: { properties: { type: { const: type } }, required: ["type"] },
     then: { $ref: `#/$defs/command_${type}` }
   }))
@@ -496,7 +609,9 @@ var WORKFLOW_TASK_SCHEMA = {
         version: {},
         buildId: { type: "string" },
         businessId: { type: "string" },
+        workflowId: { type: "string" },
         attempt: { type: "integer", minimum: 1 },
+        runAttempt: { type: "integer", minimum: 1 },
         taskQueue: { type: "string" },
         parentRunId: { type: ["string", "null"] },
         rootRunId: { type: ["string", "null"] },
@@ -519,14 +634,51 @@ var WORKFLOW_TASK_SCHEMA = {
         priority: { type: "integer", minimum: 1, maximum: 5 },
         summary: { type: "string" },
         details: { type: "string" },
-        context: { type: "object" }
+        context: { type: "object" },
+        memo: { type: "object" },
+        versioningBehavior: { enum: [...chunk3FIDHONL_cjs.VERSIONING_BEHAVIORS] },
+        retry: { $ref: "#/$defs/runRetryPolicy" }
       }
     },
+    localActivityRequest: {
+      type: "object",
+      required: [
+        "localActivityId",
+        "kind",
+        "nodeType",
+        "operation",
+        "args",
+        "retry",
+        "startToCloseTimeout",
+        "attempt",
+        "backoffMs"
+      ],
+      description: "R2: a local activity the task needs (11 \xA72.12). Run attempt `attempt` after waiting backoffMs, then run the same task again with the outcome in localActivityResults.",
+      properties: {
+        localActivityId: ID,
+        kind: { const: "node" },
+        nodeType: ID,
+        nodeVersion: { type: "string" },
+        operation: ID,
+        args: {},
+        connection: ID,
+        retry: { $ref: "#/$defs/retryPolicy" },
+        startToCloseTimeout: {
+          type: "integer",
+          minimum: 1,
+          maximum: chunk3FIDHONL_cjs.LOCAL_ACTIVITY_MAX_TIMEOUT_MS
+        },
+        attempt: { type: "integer", minimum: 1 },
+        backoffMs: NON_NEGATIVE_MS,
+        summary: { type: "string", maxLength: 200 }
+      },
+      additionalProperties: false
+    },
     request: {
       type: "object",
       required: ["protocol", "kind", "workflowFn", "info", "history", "nowMs"],
       properties: {
-        protocol: { const: chunk623FVQSN_cjs.HISTORY_PROTOCOL },
+        protocol: { const: chunk3FIDHONL_cjs.HISTORY_PROTOCOL },
         kind: { enum: ["task", "query", "verify"] },
         workflowFn: ID,
         info: { $ref: "#/$defs/info" },
@@ -552,7 +704,7 @@ var WORKFLOW_TASK_SCHEMA = {
             required: ["queryId", "name"],
             properties: {
               queryId: ID,
-              name: { enum: [...chunk623FVQSN_cjs.BUILT_IN_QUERIES] },
+              name: { enum: [...chunk3FIDHONL_cjs.BUILT_IN_QUERIES] },
               args: {}
             }
           }
@@ -563,10 +715,27 @@ var WORKFLOW_TASK_SCHEMA = {
       type: "object",
       required: ["protocol", "outcome", "commands", "logs"],
       properties: {
-        protocol: { const: chunk623FVQSN_cjs.HISTORY_PROTOCOL },
+        protocol: { const: chunk3FIDHONL_cjs.HISTORY_PROTOCOL },
         outcome: { enum: ["commands", "failed", "localActivityRequested"] },
         commands: { type: "array", items: { $ref: "#/$defs/command" } },
-        localActivityRequests: { type: "array", items: { type: "object" } },
+        localActivityRequests: {
+          type: "array",
+          items: { $ref: "#/$defs/localActivityRequest" }
+        },
+        unfinishedHandlers: {
+          type: "array",
+          description: "R2: handlers still running when the terminal command was issued (11 \xA72.18); never set on replay.",
+          items: {
+            type: "object",
+            required: ["kind", "name", "count"],
+            properties: {
+              kind: { enum: ["signal", "update"] },
+              name: { type: "string" },
+              count: { type: "integer", minimum: 1 }
+            },
+            additionalProperties: false
+          }
+        },
         queryResults: {
           type: "array",
           items: {
@@ -579,7 +748,7 @@ var WORKFLOW_TASK_SCHEMA = {
           type: "object",
           required: ["cause", "message"],
           properties: {
-            cause: { enum: [...chunk623FVQSN_cjs.TASK_FAILURE_CAUSES] },
+            cause: { enum: [...chunk3FIDHONL_cjs.TASK_FAILURE_CAUSES] },
             message: { type: "string" },
             stackTrace: { type: "string" },
             seq: { type: "integer" },
@@ -611,7 +780,7 @@ var HISTORY_FILE_SCHEMA = {
   required: ["format", "formatVersion", "workflowFn", "events"],
   properties: {
     format: { const: HISTORY_FILE_FORMAT },
-    formatVersion: { const: chunk623FVQSN_cjs.HISTORY_PROTOCOL },
+    formatVersion: { const: chunk3FIDHONL_cjs.HISTORY_PROTOCOL },
     name: { type: "string" },
     description: { type: "string" },
     workflowFn: ID,
@@ -729,12 +898,12 @@ function validateCommands(commands, options = {}) {
       return;
     }
     const command2 = checked.command;
-    if (!chunkP6TA5EZT_cjs.isWorkflowCommandEnabled(command2, options.enabled)) {
+    if (!chunkRUQIMTN5_cjs.isWorkflowCommandEnabled(command2, options.enabled) && !(options.relief !== void 0 && chunkRUQIMTN5_cjs.isReliefCommand(command2, options.relief))) {
       unsupported = true;
       issues.push({
         index,
         code: "commands.unsupported",
-        message: `${command2.type} is not supported in this release`
+        message: chunkRUQIMTN5_cjs.unsupportedMessage(command2, options.enabled)
       });
     }
     const id = idOf(command2);
@@ -743,13 +912,13 @@ function validateCommands(commands, options = {}) {
         issues.push({ index, code: "commands.duplicateId", message: `${id} is used twice` });
       ids.add(id);
     }
-    if (chunk623FVQSN_cjs.TERMINAL_COMMANDS.has(command2.type) && index !== commands.length - 1)
+    if (chunk3FIDHONL_cjs.TERMINAL_COMMANDS.has(command2.type) && index !== commands.length - 1)
       issues.push({
         index,
         code: "commands.terminalNotLast",
         message: `${command2.type} must be the last command of the batch`
       });
-    if (command2.type === "SCHEDULE_ACTIVITY" && !chunk2J6TF7YI_cjs.isActivityNodeTypeAllowed(command2.nodeType))
+    if (command2.type === "SCHEDULE_ACTIVITY" && !chunk3FIDHONL_cjs.isActivityNodeTypeAllowed(command2.nodeType))
       issues.push({
         index,
         code: "durable.activityTypeNotAllowed",
@@ -836,7 +1005,7 @@ function parseHistoryFile(input) {
 function createHistoryFile(workflowFn, events, extra = {}) {
   return {
     format: HISTORY_FILE_FORMAT,
-    formatVersion: chunk623FVQSN_cjs.HISTORY_PROTOCOL,
+    formatVersion: chunk3FIDHONL_cjs.HISTORY_PROTOCOL,
     ...extra,
     workflowFn,
     events

package/dist/chunk-J3PYFGKA.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+var chunkFR7KYWRO_cjs = require('./chunk-FR7KYWRO.cjs');
+var chunkYHBVMOMK_cjs = require('./chunk-YHBVMOMK.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 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 } : {};
+  }
+  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 chunkYHBVMOMK_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 chunkYHBVMOMK_cjs.explicitRetryPolicy(retry);
+}
+
+// src/generated/version.ts
+var SDK_VERSION = "2026.1029.1";
+
+exports.DURABLE_MARKER = DURABLE_MARKER;
+exports.MAX_WORKFLOW_TASK_TIMEOUT_MS = MAX_WORKFLOW_TASK_TIMEOUT_MS;
+exports.SDK_VERSION = SDK_VERSION;
+exports.continueAsNewRetryOf = continueAsNewRetryOf;
+exports.interfaceOf = interfaceOf;
+exports.isDurableWorkflow = isDurableWorkflow;
+exports.jsonSchemaOf = jsonSchemaOf;
+exports.optionalMs = optionalMs;
+exports.runRetryPolicyOf = runRetryPolicyOf;
+exports.toMs = toMs;
+exports.workflow = workflow;

package/dist/{chunk-C5OLWZ42.js → chunk-KXJDRQ6G.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("__"))
@@ -232,14 +230,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, ApplicationError, CancelledFailure, ChildRunFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, ServerFailure, TerminatedFailure, TimeoutFailure, WorkflowFailure, defineQuery, defineSignal, defineUpdate, errorToFailure, failureToError, isCancellation, isRunFailure, signalName };