@fluidgrids/workflows 2026.1028.2 → 2026.1029.1

package/dist/{chunk-VOKMAAJP.js → chunk-A36CCOWS.js}

@@ -1,7 +1,6 @@
 import { isRecord } from './chunk-PMCM2OH4.js';
-import { isWorkflowCommandEnabled } from './chunk-ABFZWYHT.js';
-import { CHILD_CANCELLATION_TYPES, PARENT_CLOSE_POLICIES, ERROR_TYPES, ACTIVITY_CANCELLATION_TYPES, TASK_FAILURE_CAUSES, EVENT_TYPES, COMMAND_TYPES, BUILT_IN_QUERIES, HISTORY_PROTOCOL, TERMINAL_COMMANDS } from './chunk-DJYMDLV5.js';
-import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.js';
+import { isWorkflowCommandEnabled, isReliefCommand, unsupportedMessage } from './chunk-FWBRQWRX.js';
+import { VERSIONING_BEHAVIORS, WORKFLOW_ID_CONFLICT_POLICIES, WORKFLOW_ID_REUSE_POLICIES, CHILD_CANCELLATION_TYPES, PARENT_CLOSE_POLICIES, ERROR_TYPES, ACTIVITY_CANCELLATION_TYPES, WORKFLOW_TIMEOUT_TYPES, TASK_FAILURE_CAUSES, EVENT_TYPES, COMMAND_TYPES, BUILT_IN_QUERIES, HISTORY_PROTOCOL, LOCAL_ACTIVITY_MAX_TIMEOUT_MS, TERMINAL_COMMANDS, isActivityNodeTypeAllowed } from './chunk-2DDULZFM.js';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 
 // src/history/schema.ts
@@ -73,11 +72,36 @@ 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: [...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"],
@@ -93,9 +117,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: [...VERSIONING_BEHAVIORS] },
+      idReusePolicy: { enum: [...WORKFLOW_ID_REUSE_POLICIES] },
+      idConflictPolicy: { enum: [...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: [...VERSIONING_BEHAVIORS] }
+    },
+    additionalProperties: false
+  },
   headers: STRING_MAP
 };
 function command(type, required, properties) {
@@ -169,13 +225,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,
@@ -221,9 +280,26 @@ var EVENT_PAYLOADS = {
     executionTimeout: NON_NEGATIVE_MS,
     runTimeout: NON_NEGATIVE_MS,
     workflowTaskTimeout: NON_NEGATIVE_MS,
-    versioningBehavior: { enum: ["PINNED", "AUTO_UPGRADE"] },
+    versioningBehavior: { enum: [...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,
@@ -242,6 +318,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"], {
@@ -346,7 +425,7 @@ var EVENT_PAYLOADS = {
   CHILD_RUN_TIMED_OUT: payload(["childId"], {
     childId: ID,
     childRunId: ID,
-    timeoutType: { enum: ["WORKFLOW_RUN", "WORKFLOW_EXECUTION"] }
+    timeoutType: { enum: [...WORKFLOW_TIMEOUT_TYPES] }
   }),
   EXTERNAL_RUN_CANCEL_REQUESTED: payload(["externalId", "target"], {
     externalId: ID,
@@ -380,12 +459,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" } }),
@@ -399,17 +484,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: [...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" }
   })
 };
@@ -494,7 +607,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"] },
@@ -517,9 +632,46 @@ 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: [...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: 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"],
@@ -564,7 +716,24 @@ var WORKFLOW_TASK_SCHEMA = {
         protocol: { const: 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: {
@@ -727,12 +896,12 @@ function validateCommands(commands, options = {}) {
       return;
     }
     const command2 = checked.command;
-    if (!isWorkflowCommandEnabled(command2, options.enabled)) {
+    if (!isWorkflowCommandEnabled(command2, options.enabled) && !(options.relief !== void 0 && isReliefCommand(command2, options.relief))) {
       unsupported = true;
       issues.push({
         index,
         code: "commands.unsupported",
-        message: `${command2.type} is not supported in this release`
+        message: unsupportedMessage(command2, options.enabled)
       });
     }
     const id = idOf(command2);

package/dist/{chunk-FMSW2HDF.cjs → chunk-ELL2RBML.cjs}

@@ -1,7 +1,5 @@
 'use strict';
 
-var chunkFR7KYWRO_cjs = require('./chunk-FR7KYWRO.cjs');
-
 // src/durable/definitions.ts
 function checkName(name, what) {
   if (typeof name !== "string" || name === "" || name.startsWith("__"))
@@ -234,16 +232,6 @@ function failureToError(failure, depth = 0) {
   return error;
 }
 
-// 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);
-}
-
 exports.ActivityFailure = ActivityFailure;
 exports.ApplicationError = ApplicationError;
 exports.CancelledFailure = CancelledFailure;
@@ -262,6 +250,4 @@ exports.errorToFailure = errorToFailure;
 exports.failureToError = failureToError;
 exports.isCancellation = isCancellation;
 exports.isRunFailure = isRunFailure;
-exports.optionalMs = optionalMs;
 exports.signalName = signalName;
-exports.toMs = toMs;

package/dist/{chunk-JD2VQIDZ.cjs → chunk-EWYADREB.cjs}

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

package/dist/{chunk-HWJZVOG7.js → chunk-FQSJI5NV.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-7ILGCUI6.js';
 
 // src/builder/descriptors.ts
 function op(nodeType, version, operation) {

package/dist/{chunk-ABFZWYHT.js → chunk-FWBRQWRX.js}

@@ -1,15 +1,140 @@
-import { PHASE_C_COMMANDS, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, TERMINAL_COMMANDS, isInputEvent, isCommandEvent } from './chunk-DJYMDLV5.js';
-import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.js';
+import { PHASE_C_COMMANDS, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, TERMINAL_COMMANDS, isActivityNodeTypeAllowed, isInputEvent, isCommandEvent } from './chunk-2DDULZFM.js';
 
 // 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 (PHASE_C_COMMANDS.has(type)) return false;
   if (PHASE_B_CORE_COMMANDS.has(type)) return true;
   return enabled === "parity" && 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
@@ -107,6 +232,7 @@ function initialRunState() {
     timers: {},
     children: {},
     externals: {},
+    localActivities: {},
     sideEffects: {},
     markers: {},
     signalsReceived: 0,
@@ -346,6 +472,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;
@@ -421,11 +562,12 @@ 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 (TERMINAL_COMMANDS.has(command.type) && index !== commands.length - 1)
@@ -516,6 +658,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",
@@ -559,47 +708,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;
@@ -609,4 +717,4 @@ function codeWorkflowParentClosePolicy(state) {
 var CHILD_DEFAULT_PARENT_CLOSE_POLICY = Object.freeze({ child: "TERMINATE", startChild: "ABANDON" });
 var CHILD_DEFAULT_CANCELLATION_TYPE = "WAIT_CANCELLATION_COMPLETED";
 
-export { CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, DEFAULT_ACTIVITY_RETRY, HistoryStateError, applyEvent, codeWorkflowParentClosePolicy, computeRetryDelay, eventsForCommands, explicitRetryPolicy, hasUnprocessedInput, initialRunState, isActivityOpen, isChildOpen, isCommandEnabled, isWorkflowCommandEnabled, pendingCounts, projectRunState, splitActivations, taskCompletedEvents, unseenInputs, utf8Bytes };
+export { CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, COMMAND_FEATURES, CORE_CAN_OPTIONS, CORE_CHILD_OPTIONS, HistoryStateError, PHASE_B_CORE_FEATURES, PHASE_B_PARITY_FEATURES, applyEvent, codeWorkflowParentClosePolicy, commandFeatures, continueAsNewRetryShape, eventsForCommands, hasUnprocessedInput, initialRunState, isActivityOpen, isChildOpen, isCommandEnabled, isReliefCommand, isWorkflowCommandEnabled, pendingCounts, projectRunState, splitActivations, taskCompletedEvents, unseenInputs, unsupportedMessage, utf8Bytes };