@temporalio/common 1.14.2-canary-release-testing.0 → 1.16.0

package/lib/worker-deployments.d.ts

@@ -1,8 +1,6 @@
 import type { temporal } from '@temporalio/proto';
 /**
  * Represents the version of a specific worker deployment.
- *
- * @experimental Deployment based versioning is experimental and may change in the future.
  */
 export interface WorkerDeploymentVersion {
     readonly buildId: string;
@@ -19,8 +17,6 @@ export declare function toCanonicalString(version: WorkerDeploymentVersion): str
  * * 'PINNED' - The workflow will be pinned to the current Build ID unless manually moved.
  * * 'AUTO_UPGRADE' - The workflow will automatically move to the latest version (default Build ID
  *    of the task queue) when the next task is dispatched.
- *
- * @experimental Deployment based versioning is experimental and may change in the future.
  */
 export declare const VersioningBehavior: {
     readonly PINNED: "PINNED";
@@ -45,3 +41,23 @@ export interface PinnedVersioningOverride {
  * The workflow will auto-upgrade to the current deployment version on the next workflow task.
  */
 export type AutoUpgradeVersioningOverride = 'AUTO_UPGRADE';
+/**
+ * Defines the versioning behavior to be used by the first task of a new workflow run in a continue-as-new chain.
+ *
+ * AUTO_UPGRADE - Start the new run with AutoUpgrade behavior. Use the Target Version of the workflow's task queue at
+ *   start-time, as AutoUpgrade workflows do. After the first workflow task completes, use whatever
+ *   Versioning Behavior the workflow is annotated with in the workflow code.
+ *
+ *   Note that if the previous workflow had a Pinned override, that override will be inherited by the
+ *   new workflow run regardless of the ContinueAsNewVersioningBehavior specified in the continue-as-new
+ *   command. If a Pinned override is inherited by the new run, and the new run starts with AutoUpgrade
+ *   behavior, the base version of the new run will be the Target Version as described above, but the
+ *   effective version will be whatever is specified by the Versioning Override until the override is removed.
+ *
+ * @experimental Versioning semantics with continue-as-new are experimental and may change in the future.
+ */
+export declare const InitialVersioningBehavior: {
+    readonly AUTO_UPGRADE: "AUTO_UPGRADE";
+};
+export type InitialVersioningBehavior = (typeof InitialVersioningBehavior)[keyof typeof InitialVersioningBehavior];
+export declare const encodeInitialVersioningBehavior: (input: "AUTO_UPGRADE" | temporal.api.enums.v1.ContinueAsNewVersioningBehavior | "CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_AUTO_UPGRADE" | null | undefined) => temporal.api.enums.v1.ContinueAsNewVersioningBehavior | undefined, decodeInitialVersioningBehavior: (input: temporal.api.enums.v1.ContinueAsNewVersioningBehavior | null | undefined) => "AUTO_UPGRADE" | undefined;

package/lib/worker-deployments.js

@@ -1,7 +1,7 @@
 "use strict";
-var _a;
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeVersioningBehavior = exports.encodeVersioningBehavior = exports.VersioningBehavior = void 0;
+exports.decodeInitialVersioningBehavior = exports.encodeInitialVersioningBehavior = exports.InitialVersioningBehavior = exports.decodeVersioningBehavior = exports.encodeVersioningBehavior = exports.VersioningBehavior = void 0;
 exports.toCanonicalString = toCanonicalString;
 const internal_workflow_1 = require("./internal-workflow");
 /**
@@ -17,8 +17,6 @@ function toCanonicalString(version) {
  * * 'PINNED' - The workflow will be pinned to the current Build ID unless manually moved.
  * * 'AUTO_UPGRADE' - The workflow will automatically move to the latest version (default Build ID
  *    of the task queue) when the next task is dispatched.
- *
- * @experimental Deployment based versioning is experimental and may change in the future.
  */
 exports.VersioningBehavior = {
     PINNED: 'PINNED',
@@ -29,4 +27,26 @@ _a = (0, internal_workflow_1.makeProtoEnumConverters)({
     [exports.VersioningBehavior.AUTO_UPGRADE]: 2,
     UNSPECIFIED: 0,
 }, 'VERSIONING_BEHAVIOR_'), exports.encodeVersioningBehavior = _a[0], exports.decodeVersioningBehavior = _a[1];
+/**
+ * Defines the versioning behavior to be used by the first task of a new workflow run in a continue-as-new chain.
+ *
+ * AUTO_UPGRADE - Start the new run with AutoUpgrade behavior. Use the Target Version of the workflow's task queue at
+ *   start-time, as AutoUpgrade workflows do. After the first workflow task completes, use whatever
+ *   Versioning Behavior the workflow is annotated with in the workflow code.
+ *
+ *   Note that if the previous workflow had a Pinned override, that override will be inherited by the
+ *   new workflow run regardless of the ContinueAsNewVersioningBehavior specified in the continue-as-new
+ *   command. If a Pinned override is inherited by the new run, and the new run starts with AutoUpgrade
+ *   behavior, the base version of the new run will be the Target Version as described above, but the
+ *   effective version will be whatever is specified by the Versioning Override until the override is removed.
+ *
+ * @experimental Versioning semantics with continue-as-new are experimental and may change in the future.
+ */
+exports.InitialVersioningBehavior = {
+    AUTO_UPGRADE: 'AUTO_UPGRADE',
+};
+_b = (0, internal_workflow_1.makeProtoEnumConverters)({
+    [exports.InitialVersioningBehavior.AUTO_UPGRADE]: 1,
+    UNSPECIFIED: 0,
+}, 'CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_'), exports.encodeInitialVersioningBehavior = _b[0], exports.decodeInitialVersioningBehavior = _b[1];
 //# sourceMappingURL=worker-deployments.js.map

package/lib/worker-deployments.js.map

@@ -1 +1 @@
-{"version":3,"file":"worker-deployments.js","sourceRoot":"","sources":["../src/worker-deployments.ts"],"names":[],"mappings":";;;;AAiBA,8CAEC;AAlBD,2DAA8D;AAY9D;;;GAGG;AACH,SAAgB,iBAAiB,CAAC,OAAgC;IAChE,OAAO,GAAG,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;AACxD,CAAC;AAED;;;;;;;;GAQG;AACU,QAAA,kBAAkB,GAAG;IAChC,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,cAAc;CACpB,CAAC;AAGE,KAAuD,IAAA,2CAAuB,EAOzF;IACE,CAAC,0BAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;IAC9B,CAAC,0BAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;IACpC,WAAW,EAAE,CAAC;CACN,EACV,sBAAsB,CACvB,EAba,gCAAwB,UAAE,gCAAwB,SAa9D"}
+{"version":3,"file":"worker-deployments.js","sourceRoot":"","sources":["../src/worker-deployments.ts"],"names":[],"mappings":";;;;AAeA,8CAEC;AAhBD,2DAA8D;AAU9D;;;GAGG;AACH,SAAgB,iBAAiB,CAAC,OAAgC;IAChE,OAAO,GAAG,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;AACxD,CAAC;AAED;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAG;IAChC,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,cAAc;CACpB,CAAC;AAGE,KAAuD,IAAA,2CAAuB,EAOzF;IACE,CAAC,0BAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;IAC9B,CAAC,0BAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;IACpC,WAAW,EAAE,CAAC;CACN,EACV,sBAAsB,CACvB,EAba,gCAAwB,UAAE,gCAAwB,SAa9D;AAsBF;;;;;;;;;;;;;;GAcG;AACU,QAAA,yBAAyB,GAAG;IACvC,YAAY,EAAE,cAAc;CACpB,CAAC;AAGE,KAAqE,IAAA,2CAAuB,EAOvG;IACE,CAAC,iCAAyB,CAAC,YAAY,CAAC,EAAE,CAAC;IAC3C,WAAW,EAAE,CAAC;CACN,EACV,sCAAsC,CACvC,EAZa,uCAA+B,UAAE,uCAA+B,SAY5E"}

package/lib/workflow-options.d.ts

@@ -64,7 +64,6 @@ export declare const encodeWorkflowIdReusePolicy: (input: "ALLOW_DUPLICATE" | "A
  *
  * *Note: It is never possible to have two _actively running_ Workflows with the same ID.*
  */
-export type WorkflowIdConflictPolicy = (typeof WorkflowIdConflictPolicy)[keyof typeof WorkflowIdConflictPolicy];
 export declare const WorkflowIdConflictPolicy: {
     /**
      * Do not start a new Workflow. Instead raise a `WorkflowExecutionAlreadyStartedError`.
@@ -79,6 +78,7 @@ export declare const WorkflowIdConflictPolicy: {
      */
     readonly TERMINATE_EXISTING: "TERMINATE_EXISTING";
 };
+export type WorkflowIdConflictPolicy = (typeof WorkflowIdConflictPolicy)[keyof typeof WorkflowIdConflictPolicy];
 export declare const encodeWorkflowIdConflictPolicy: (input: "FAIL" | "USE_EXISTING" | "TERMINATE_EXISTING" | temporal.api.enums.v1.WorkflowIdConflictPolicy | "WORKFLOW_ID_CONFLICT_POLICY_FAIL" | "WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING" | "WORKFLOW_ID_CONFLICT_POLICY_TERMINATE_EXISTING" | null | undefined) => temporal.api.enums.v1.WorkflowIdConflictPolicy | undefined, decodeWorkflowIdConflictPolicy: (input: temporal.api.enums.v1.WorkflowIdConflictPolicy | null | undefined) => "FAIL" | "USE_EXISTING" | "TERMINATE_EXISTING" | undefined;
 export interface BaseWorkflowOptions {
     /**
@@ -86,7 +86,7 @@ export interface BaseWorkflowOptions {
      *
      * *Note: It is not possible to have two actively running Workflows with the same ID.*
      *
-     * @default {@link WorkflowIdReusePolicy.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE}
+     * @default WorkflowIdReusePolicy.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE
      */
     workflowIdReusePolicy?: WorkflowIdReusePolicy;
     /**
@@ -94,7 +94,7 @@ export interface BaseWorkflowOptions {
      *
      * *Note: It is not possible to have two actively running Workflows with the same ID.*
      *
-     * @default {@link WorkflowIdConflictPolicy.WORKFLOW_ID_CONFLICT_POLICY_UNSPECIFIED}
+     * @default WorkflowIdConflictPolicy.WORKFLOW_ID_CONFLICT_POLICY_UNSPECIFIED
      */
     workflowIdConflictPolicy?: WorkflowIdConflictPolicy;
     /**

package/lib/workflow-options.js

@@ -37,30 +37,38 @@ exports.WorkflowIdReusePolicy = {
      *             {@link WorkflowIdConflictPolicy.WORKFLOW_ID_CONFLICT_POLICY_TERMINATE_EXISTING}.
      *             When using this option, `WorkflowOptions.workflowIdConflictPolicy` must be left unspecified.
      */
-    TERMINATE_IF_RUNNING: 'TERMINATE_IF_RUNNING', // eslint-disable-line deprecation/deprecation
+    TERMINATE_IF_RUNNING: 'TERMINATE_IF_RUNNING',
     /// Anything below this line has been deprecated
     /**
      * No need to use this. If a `WorkflowIdReusePolicy` is set to this, or is not set at all, the default value will be used.
      *
      * @deprecated Either leave property `undefined`, or use {@link ALLOW_DUPLICATE} instead.
      */
-    WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+    WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED: undefined,
     /** @deprecated Use {@link ALLOW_DUPLICATE} instead. */
-    WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE: 'ALLOW_DUPLICATE', // eslint-disable-line deprecation/deprecation
+    WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE: 'ALLOW_DUPLICATE',
     /** @deprecated Use {@link ALLOW_DUPLICATE_FAILED_ONLY} instead. */
-    WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY: 'ALLOW_DUPLICATE_FAILED_ONLY', // eslint-disable-line deprecation/deprecation
+    WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY: 'ALLOW_DUPLICATE_FAILED_ONLY',
     /** @deprecated Use {@link REJECT_DUPLICATE} instead. */
-    WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE: 'REJECT_DUPLICATE', // eslint-disable-line deprecation/deprecation
+    WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE: 'REJECT_DUPLICATE',
     /** @deprecated Use {@link TERMINATE_IF_RUNNING} instead. */
-    WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING: 'TERMINATE_IF_RUNNING', // eslint-disable-line deprecation/deprecation
+    WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING: 'TERMINATE_IF_RUNNING',
 };
 _a = (0, internal_workflow_1.makeProtoEnumConverters)({
     [exports.WorkflowIdReusePolicy.ALLOW_DUPLICATE]: 1,
     [exports.WorkflowIdReusePolicy.ALLOW_DUPLICATE_FAILED_ONLY]: 2,
     [exports.WorkflowIdReusePolicy.REJECT_DUPLICATE]: 3,
-    [exports.WorkflowIdReusePolicy.TERMINATE_IF_RUNNING]: 4, // eslint-disable-line deprecation/deprecation
+    [exports.WorkflowIdReusePolicy.TERMINATE_IF_RUNNING]: 4, // eslint-disable-line @typescript-eslint/no-deprecated
     UNSPECIFIED: 0,
 }, 'WORKFLOW_ID_REUSE_POLICY_'), exports.encodeWorkflowIdReusePolicy = _a[0], exports.decodeWorkflowIdReusePolicy = _a[1];
+/**
+ * Defines what happens when trying to start a Workflow with the same ID as a *Running* Workflow.
+ *
+ * See {@link WorkflowOptions.workflowIdReusePolicy} for what happens when trying to start a Workflow
+ * with the same ID as a *Closed* Workflow.
+ *
+ * *Note: It is never possible to have two _actively running_ Workflows with the same ID.*
+ */
 exports.WorkflowIdConflictPolicy = {
     /**
      * Do not start a new Workflow. Instead raise a `WorkflowExecutionAlreadyStartedError`.

package/lib/workflow-options.js.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-options.js","sourceRoot":"","sources":["../src/workflow-options.ts"],"names":[],"mappings":";;;;AAqQA,kDAWC;AA5QD,2DAA8D;AAK9D;;;;;;;;;;GAUG;AACU,QAAA,qBAAqB,GAAG;IACnC;;;OAGG;IACH,eAAe,EAAE,iBAAiB;IAElC;;OAEG;IACH,2BAA2B,EAAE,6BAA6B;IAE1D;;OAEG;IACH,gBAAgB,EAAE,kBAAkB;IAEpC;;;;;;;OAOG;IACH,oBAAoB,EAAE,sBAAsB,EAAE,8CAA8C;IAE5F,gDAAgD;IAEhD;;;;OAIG;IACH,oCAAoC,EAAE,SAAS,EAAE,8CAA8C;IAE/F,uDAAuD;IACvD,wCAAwC,EAAE,iBAAiB,EAAE,8CAA8C;IAE3G,mEAAmE;IACnE,oDAAoD,EAAE,6BAA6B,EAAE,8CAA8C;IAEnI,wDAAwD;IACxD,yCAAyC,EAAE,kBAAkB,EAAE,8CAA8C;IAE7G,4DAA4D;IAC5D,6CAA6C,EAAE,sBAAsB,EAAE,8CAA8C;CAC7G,CAAC;AAGE,KAA6D,IAAA,2CAAuB,EAO/F;IACE,CAAC,6BAAqB,CAAC,eAAe,CAAC,EAAE,CAAC;IAC1C,CAAC,6BAAqB,CAAC,2BAA2B,CAAC,EAAE,CAAC;IACtD,CAAC,6BAAqB,CAAC,gBAAgB,CAAC,EAAE,CAAC;IAC3C,CAAC,6BAAqB,CAAC,oBAAoB,CAAC,EAAE,CAAC,EAAE,8CAA8C;IAC/F,WAAW,EAAE,CAAC;CACN,EACV,2BAA2B,CAC5B,EAfa,mCAA2B,UAAE,mCAA2B,SAepE;AAWW,QAAA,wBAAwB,GAAG;IACtC;;OAEG;IACH,IAAI,EAAE,MAAM;IAEZ;;OAEG;IACH,YAAY,EAAE,cAAc;IAE5B;;OAEG;IACH,kBAAkB,EAAE,oBAAoB;CAChC,CAAC;AAEE,KAAmE,IAAA,2CAAuB,EAOrG;IACE,CAAC,gCAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAClC,CAAC,gCAAwB,CAAC,YAAY,CAAC,EAAE,CAAC;IAC1C,CAAC,gCAAwB,CAAC,kBAAkB,CAAC,EAAE,CAAC;IAChD,WAAW,EAAE,CAAC;CACN,EACV,8BAA8B,CAC/B,EAda,sCAA8B,UAAE,sCAA8B,SAc1E;AAsIF,SAAgB,mBAAmB,CACjC,kBAAwE;IAExE,IAAI,OAAO,kBAAkB,KAAK,QAAQ;QAAE,OAAO,kBAA4B,CAAC;IAChF,IAAI,OAAO,kBAAkB,KAAK,UAAU,EAAE,CAAC;QAC7C,IAAI,kBAAkB,EAAE,IAAI;YAAE,OAAO,kBAAkB,CAAC,IAAI,CAAC;QAC7D,MAAM,IAAI,SAAS,CAAC,2DAA2D,CAAC,CAAC;IACnF,CAAC;IACD,MAAM,IAAI,SAAS,CACjB,uEAAuE,OAAO,kBAAkB,GAAG,CACpG,CAAC;AACJ,CAAC"}
+{"version":3,"file":"workflow-options.js","sourceRoot":"","sources":["../src/workflow-options.ts"],"names":[],"mappings":";;;;AAqQA,kDAWC;AA5QD,2DAA8D;AAK9D;;;;;;;;;;GAUG;AACU,QAAA,qBAAqB,GAAG;IACnC;;;OAGG;IACH,eAAe,EAAE,iBAAiB;IAElC;;OAEG;IACH,2BAA2B,EAAE,6BAA6B;IAE1D;;OAEG;IACH,gBAAgB,EAAE,kBAAkB;IAEpC;;;;;;;OAOG;IACH,oBAAoB,EAAE,sBAAsB;IAE5C,gDAAgD;IAEhD;;;;OAIG;IACH,oCAAoC,EAAE,SAAS;IAE/C,uDAAuD;IACvD,wCAAwC,EAAE,iBAAiB;IAE3D,mEAAmE;IACnE,oDAAoD,EAAE,6BAA6B;IAEnF,wDAAwD;IACxD,yCAAyC,EAAE,kBAAkB;IAE7D,4DAA4D;IAC5D,6CAA6C,EAAE,sBAAsB;CAC7D,CAAC;AAGE,KAA6D,IAAA,2CAAuB,EAO/F;IACE,CAAC,6BAAqB,CAAC,eAAe,CAAC,EAAE,CAAC;IAC1C,CAAC,6BAAqB,CAAC,2BAA2B,CAAC,EAAE,CAAC;IACtD,CAAC,6BAAqB,CAAC,gBAAgB,CAAC,EAAE,CAAC;IAC3C,CAAC,6BAAqB,CAAC,oBAAoB,CAAC,EAAE,CAAC,EAAE,uDAAuD;IACxG,WAAW,EAAE,CAAC;CACN,EACV,2BAA2B,CAC5B,EAfa,mCAA2B,UAAE,mCAA2B,SAepE;AAEF;;;;;;;GAOG;AACU,QAAA,wBAAwB,GAAG;IACtC;;OAEG;IACH,IAAI,EAAE,MAAM;IAEZ;;OAEG;IACH,YAAY,EAAE,cAAc;IAE5B;;OAEG;IACH,kBAAkB,EAAE,oBAAoB;CAChC,CAAC;AAGE,KAAmE,IAAA,2CAAuB,EAOrG;IACE,CAAC,gCAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAClC,CAAC,gCAAwB,CAAC,YAAY,CAAC,EAAE,CAAC;IAC1C,CAAC,gCAAwB,CAAC,kBAAkB,CAAC,EAAE,CAAC;IAChD,WAAW,EAAE,CAAC;CACN,EACV,8BAA8B,CAC/B,EAda,sCAA8B,UAAE,sCAA8B,SAc1E;AAsIF,SAAgB,mBAAmB,CACjC,kBAAwE;IAExE,IAAI,OAAO,kBAAkB,KAAK,QAAQ;QAAE,OAAO,kBAA4B,CAAC;IAChF,IAAI,OAAO,kBAAkB,KAAK,UAAU,EAAE,CAAC;QAC7C,IAAI,kBAAkB,EAAE,IAAI;YAAE,OAAO,kBAAkB,CAAC,IAAI,CAAC;QAC7D,MAAM,IAAI,SAAS,CAAC,2DAA2D,CAAC,CAAC;IACnF,CAAC;IACD,MAAM,IAAI,SAAS,CACjB,uEAAuE,OAAO,kBAAkB,GAAG,CACpG,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/common",
-  "version": "1.14.2-canary-release-testing.0",
+  "version": "1.16.0",
   "description": "Common library for code that's used across the Client, Worker, and/or Workflow",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
@@ -14,9 +14,9 @@
   "dependencies": {
     "long": "^5.2.3",
     "ms": "3.0.0-canary.1",
-    "nexus-rpc": "^0.0.1",
+    "nexus-rpc": "^0.0.2",
     "proto3-json-serializer": "^2.0.0",
-    "@temporalio/proto": "1.14.2-canary-release-testing.0"
+    "@temporalio/proto": "1.16.0"
   },
   "devDependencies": {
     "protobufjs": "^7.2.5"
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">= 18.0.0"
+    "node": ">= 20.0.0"
   },
   "files": [
     "src",

package/src/activity-options.ts

@@ -5,10 +5,59 @@ import { VersioningIntent } from './versioning-intent';
 import { makeProtoEnumConverters } from './internal-workflow';
 import { Priority } from './priority';
 
+// Note: The types defined in this file are here for legacy reasons. They should have been defined
+// in the 'workflow' package, instead of 'common'. They are now reexported from the 'workflow'
+// package, which is the preferred way to import them, but we unfortunately can't remove them from
+// here as that would be a breaking change.
+
+/**
+ * Determines:
+ * - whether cancellation requests should be propagated from the current Workflow to the Activity; and
+ * - when should the Activity cancellation be reported to Workflow (i.e. at which moment should the
+ *   Activity call's promise fail with an `ActivityFailure`, with `cause` set to a `CancelledFailure`).
+ *
+ * Note that this setting only applies to cancellation originating from cancellation being
+ * externally requested on the Workflow itself, or from internal cancellation of the
+ * `CancellationScope` in which the Activity call was made. Termination of a Workflow Execution
+ * always results in cancellation of its outstanding Activity executions, regardless of those
+ * Activities' {@link ActivityCancellationType} settings.
+ *
+ * @default ActivityCancellationType.WAIT_CANCELLATION_COMPLETED
+ */
+// MAINTENANCE: Keep this typedoc in sync with the `ActivityOptions.cancellationType` and
+//              `LocalActivityOptions.cancellationType` fields later in this file.
 export const ActivityCancellationType = {
+  /**
+   * Do not propagate cancellation requests to the Activity, and immediately report cancellation
+   * to the caller.
+   */
+  ABANDON: 'ABANDON',
+
+  /**
+   * Propagate cancellation request from the Workflow to the Activity, yet _immediately_ report
+   * cancellation to the caller, i.e. without waiting for the server to confirm the cancellation
+   * request.
+   *
+   * Note that this cancellation type provides no guarantee, from the Workflow-side, that the
+   * cancellation request will actually be delivered to the Activity; e.g. the calling Workflow
+   * may exit before the delivery is completed, or the Activity may complete (either successfully
+   * or uncessfully) before the cancellation is delivered, resulting in a situation where the
+   * workflow thinks the activity was cancelled, but the activity actually completed successfully.
+   *
+   * To ensure that the Workflow is properly informed of the Activity's final state (i.e. either
+   * completion or cancellation), use {@link WAIT_CANCELLATION_COMPLETED}.
+   */
   TRY_CANCEL: 'TRY_CANCEL',
+
+  /**
+   * Propagate cancellation request from the Workflow to the Activity, and wait for the activity
+   * to complete its execution (either successfully, uncessfully, or as cancelled).
+   *
+   * Note that the Activity must heartbeat to receive a cancellation notification. This can block
+   * the Workflow's cancellation for a long time if the Activity doesn't heartbeat or chooses to
+   * ignore the cancellation request.
+   */
   WAIT_CANCELLATION_COMPLETED: 'WAIT_CANCELLATION_COMPLETED',
-  ABANDON: 'ABANDON',
 } as const;
 export type ActivityCancellationType = (typeof ActivityCancellationType)[keyof typeof ActivityCancellationType];
 
@@ -93,13 +142,20 @@ export interface ActivityOptions {
   scheduleToCloseTimeout?: Duration;
 
   /**
-   * Determines what the SDK does when the Activity is cancelled.
-   * - `TRY_CANCEL` - Initiate a cancellation request and immediately report cancellation to the workflow.
-   * - `WAIT_CANCELLATION_COMPLETED` - Wait for activity cancellation completion. Note that activity must heartbeat to receive a
-   *   cancellation notification. This can block the cancellation for a long time if activity doesn't
-   *   heartbeat or chooses to ignore the cancellation request.
-   * - `ABANDON` - Do not request cancellation of the activity and immediately report cancellation to the workflow.
+   * Determines:
+   * - whether cancellation requests should be propagated from the current Workflow to the Activity; and
+   * - when should the Activity cancellation be reported to Workflow (i.e. at which moment should the
+   *   Activity call's promise fail with an `ActivityFailure`, with `cause` set to a `CancelledFailure`).
+   *
+   * Note that this setting only applies to cancellation originating from cancellation being
+   * externally requested on the Workflow itself, or from internal cancellation of the
+   * `CancellationScope` in which the Activity call was made. Termination of a Workflow Execution
+   * always results in cancellation of its outstanding Activity executions, regardless of those
+   * Activities' {@link ActivityCancellationType} settings.
+   *
+   * @default ActivityCancellationType.WAIT_CANCELLATION_COMPLETED
    */
+  // MAINTENANCE: Keep this typedoc in sync with the `ActivityCancellationType` enum
   cancellationType?: ActivityCancellationType;
 
   /**
@@ -120,10 +176,9 @@ export interface ActivityOptions {
    *
    * @default 'COMPATIBLE'
    *
-   * @deprecated In favor of the new Worker Deployment API.
-   * @experimental The Worker Versioning API is still being designed. Major changes are expected.
+   * @deprecated Worker Versioning is now deprecated. Please use the Worker Deployment API instead: https://docs.temporal.io/worker-deployments
    */
-  versioningIntent?: VersioningIntent; // eslint-disable-line deprecation/deprecation
+  versioningIntent?: VersioningIntent; // eslint-disable-line @typescript-eslint/no-deprecated
 
   /**
    * A fixed, single-line summary for this workflow execution that may appear in the UI/CLI.
@@ -193,13 +248,20 @@ export interface LocalActivityOptions {
   localRetryThreshold?: Duration;
 
   /**
-   * Determines what the SDK does when the Activity is cancelled.
-   * - `TRY_CANCEL` - Initiate a cancellation request and immediately report cancellation to the workflow.
-   * - `WAIT_CANCELLATION_COMPLETED` - Wait for activity cancellation completion. Note that activity must heartbeat to receive a
-   *   cancellation notification. This can block the cancellation for a long time if activity doesn't
-   *   heartbeat or chooses to ignore the cancellation request.
-   * - `ABANDON` - Do not request cancellation of the activity and immediately report cancellation to the workflow.
+   * Determines:
+   * - whether cancellation requests should be propagated from the current Workflow to the Activity; and
+   * - when should the Activity cancellation be reported to Workflow (i.e. at which moment should the
+   *   Activity call's promise fail with an `ActivityFailure`, with `cause` set to a `CancelledFailure`).
+   *
+   * Note that this setting only applies to cancellation originating from cancellation being
+   * externally requested on the Workflow itself, or from internal cancellation of the
+   * `CancellationScope` in which the Activity call was made. Termination of a Workflow Execution
+   * always results in cancellation of its outstanding Activity executions, regardless of those
+   * Activities' {@link ActivityCancellationType} settings.
+   *
+   * @default ActivityCancellationType.WAIT_CANCELLATION_COMPLETED
    */
+  // MAINTENANCE: Keep this typedoc in sync with the `ActivityCancellationType` enum
   cancellationType?: ActivityCancellationType;
 
   /**

package/src/continue-as-new.ts

@@ -0,0 +1,52 @@
+import { temporal } from '@temporalio/proto';
+import { makeProtoEnumConverters } from './internal-workflow';
+
+/**
+ * Reason(s) why continue as new is suggested. Can potentially be multiple reasons.
+ *
+ * @experimental May be removed or changed in the future.
+ */
+export const SuggestContinueAsNewReason = {
+  HISTORY_SIZE_TOO_LARGE: 'HISTORY_SIZE_TOO_LARGE',
+  TOO_MANY_HISTORY_EVENTS: 'TOO_MANY_HISTORY_EVENTS',
+  TOO_MANY_UPDATES: 'TOO_MANY_UPDATES',
+} as const;
+export type SuggestContinueAsNewReason = (typeof SuggestContinueAsNewReason)[keyof typeof SuggestContinueAsNewReason];
+
+// ts-prune-ignore-next
+export const [encodeSuggestContinueAsNewReason, decodeSuggestContinueAsNewReason] = makeProtoEnumConverters<
+  temporal.api.enums.v1.SuggestContinueAsNewReason,
+  typeof temporal.api.enums.v1.SuggestContinueAsNewReason,
+  keyof typeof temporal.api.enums.v1.SuggestContinueAsNewReason,
+  typeof SuggestContinueAsNewReason,
+  'SUGGEST_CONTINUE_AS_NEW_REASON_'
+>(
+  {
+    [SuggestContinueAsNewReason.HISTORY_SIZE_TOO_LARGE]: 1,
+    [SuggestContinueAsNewReason.TOO_MANY_HISTORY_EVENTS]: 2,
+    [SuggestContinueAsNewReason.TOO_MANY_UPDATES]: 3,
+    UNSPECIFIED: 0,
+  } as const,
+  'SUGGEST_CONTINUE_AS_NEW_REASON_'
+);
+
+// ts-prune-ignore-next
+export function suggestContinueAsNewReasonsFromProto(
+  reasons: temporal.api.enums.v1.SuggestContinueAsNewReason[] | null | undefined
+): SuggestContinueAsNewReason[] | undefined {
+  if (reasons == null) {
+    return undefined;
+  }
+
+  const res: SuggestContinueAsNewReason[] = [];
+  for (const r of reasons) {
+    const decoded = decodeSuggestContinueAsNewReason(r);
+    if (decoded !== undefined) {
+      res.push(decoded);
+    }
+  }
+  if (res.length === 0) {
+    return undefined;
+  }
+  return res;
+}

package/src/converter/failure-converter.ts

@@ -23,6 +23,7 @@ import {
 import { makeProtoEnumConverters } from '../internal-workflow';
 import { isError } from '../type-helpers';
 import { msOptionalToTs } from '../time';
+import { encode } from '../encoding';
 import { arrayFromPayloads, fromPayloadsAtIndex, PayloadConverter, toPayloads } from './payload-converter';
 
 // Can't import proto enums into the workflow sandbox, use this helper type and enum converter instead.
@@ -30,7 +31,6 @@ const NexusHandlerErrorRetryBehavior = {
   RETRYABLE: 'RETRYABLE',
   NON_RETRYABLE: 'NON_RETRYABLE',
 } as const;
-
 type NexusHandlerErrorRetryBehavior =
   (typeof NexusHandlerErrorRetryBehavior)[keyof typeof NexusHandlerErrorRetryBehavior];
 
@@ -58,13 +58,13 @@ function combineRegExp(...regexps: RegExp[]): RegExp {
  */
 const CUTOFF_STACK_PATTERNS = combineRegExp(
   /** Activity execution */
-  /\s+at Activity\.execute \(.*[\\/]worker[\\/](?:src|lib)[\\/]activity\.[jt]s:\d+:\d+\)/,
+  /\s+at (Activity\.)?execute \(.*[\\/]worker[\\/](?:src|lib)[\\/]activity\.[jt]s:\d+:\d+\)/,
   /** Nexus execution */
-  /\s+at( async)? NexusHandler\.invokeUserCode \(.*[\\/]worker[\\/](?:src|lib)[\\/]nexus[\\/]index\.[jt]s:\d+:\d+\)/,
-  /** Workflow activation */
-  /\s+at Activator\.\S+NextHandler \(.*[\\/]workflow[\\/](?:src|lib)[\\/]internals\.[jt]s:\d+:\d+\)/,
+  /\s+at( async)? (NexusHandler\.)?invokeUserCode \(.*[\\/]worker[\\/](?:src|lib)[\\/]nexus[\\/]index\.[jt]s:\d+:\d+\)/,
+  /** Workflow activation (inbound handlers only) */
+  /\s+at( async)? (Activator\.)?(startWorkflow|queryWorkflow|signalWorkflow|update|validateUpdate)NextHandler \(.*\.[jt]s:\d+:\d+\)/,
   /** Workflow run anything in context */
-  /\s+at Script\.runInContext \((?:node:vm|vm\.js):\d+:\d+\)/
+  /\s+at (Script\.)?runInContext \(native|unknown|(?:(?:node:vm|vm\.js):\d+:\d+)\)/
 );
 
 /**
@@ -239,15 +239,17 @@ export class DefaultFailureConverter implements FailureConverter {
           break;
       }
 
-      return new nexus.HandlerError(
-        (failure.nexusHandlerFailureInfo.type as nexus.HandlerErrorType) ?? 'INTERNAL',
-        // TODO(nexus/error): Maybe set a default message here, once we've decided on error handling.
-        failure.message ?? undefined,
-        {
-          cause: this.optionalFailureToOptionalError(failure.cause, payloadConverter),
-          retryableOverride,
-        }
-      );
+      const rawErrorType = failure.nexusHandlerFailureInfo.type || '';
+      const resolvedType: nexus.HandlerErrorType = Object.hasOwn(nexus.HandlerErrorType, rawErrorType)
+        ? nexus.HandlerErrorType[rawErrorType as keyof typeof nexus.HandlerErrorType]
+        : 'UNKNOWN';
+
+      return new nexus.HandlerError(resolvedType, failure.message ?? 'Nexus handler error', {
+        cause: this.optionalFailureToOptionalError(failure.cause, payloadConverter),
+        retryableOverride,
+        rawErrorType,
+        originalFailure: this.temporalFailureToNexusFailure(failure),
+      });
     }
     if (failure.nexusOperationExecutionFailureInfo) {
       return new NexusOperationFailure(
@@ -304,9 +306,6 @@ export class DefaultFailureConverter implements FailureConverter {
   }
 
   errorToFailureInner(err: unknown, payloadConverter: PayloadConverter): ProtoFailure {
-    // TODO(nexus/error): If we decide not to have a NexusHandlerFailure, we could still attach the
-    //                    failure proto to the Nexus HandlerError object, by using a private symbol
-    //                    property. To be considered once we have a decision on error handling.
     if (err instanceof TemporalFailure || err instanceof nexus.HandlerError) {
       if (err instanceof TemporalFailure && err.failure) return err.failure;
       const base = {
@@ -387,28 +386,30 @@ export class DefaultFailureConverter implements FailureConverter {
         };
       }
       if (err instanceof nexus.HandlerError) {
-        let retryBehavior: temporal.api.enums.v1.NexusHandlerErrorRetryBehavior | undefined = undefined;
-        switch (err.retryableOverride) {
-          case true:
-            retryBehavior = encodeNexusHandlerErrorRetryBehavior('RETRYABLE');
-            break;
-          case false:
-            retryBehavior = encodeNexusHandlerErrorRetryBehavior('NON_RETRYABLE');
-            break;
-        }
+        if (err.originalFailure) {
+          return this.nexusFailureToTemporalFailure(err.originalFailure, err.retryable);
+        } else {
+          let retryBehavior: temporal.api.enums.v1.NexusHandlerErrorRetryBehavior | undefined = undefined;
+          switch (err.retryableOverride) {
+            case true:
+              retryBehavior = encodeNexusHandlerErrorRetryBehavior('RETRYABLE');
+              break;
+            case false:
+              retryBehavior = encodeNexusHandlerErrorRetryBehavior('NON_RETRYABLE');
+              break;
+          }
 
-        return {
-          // TODO(nexus/error): Maybe set a default message here, once we've decided on error handling.
-          ...base,
-          nexusHandlerFailureInfo: {
-            type: err.type,
-            retryBehavior,
-          },
-        };
+          return {
+            ...base,
+            nexusHandlerFailureInfo: {
+              type: err.type,
+              retryBehavior,
+            },
+          };
+        }
       }
       if (err instanceof NexusOperationFailure) {
         return {
-          // TODO(nexus/error): Maybe set a default message here, once we've decided on error handling.
           ...base,
           nexusOperationExecutionFailureInfo: {
             scheduledEventId: err.scheduledEventId ? Long.fromNumber(err.scheduledEventId) : undefined,
@@ -430,7 +431,7 @@ export class DefaultFailureConverter implements FailureConverter {
     if (isError(err)) {
       return {
         ...base,
-        message: String(err.message) ?? '',
+        message: String(err.message ?? ''),
         stackTrace: cutoffStackTrace(err.stack),
         cause: this.optionalErrorToOptionalFailure((err as any).cause, payloadConverter),
       };
@@ -470,4 +471,40 @@ export class DefaultFailureConverter implements FailureConverter {
   optionalErrorToOptionalFailure(err: unknown, payloadConverter: PayloadConverter): ProtoFailure | undefined {
     return err ? this.errorToFailure(err, payloadConverter) : undefined;
   }
+
+  private nexusFailureToTemporalFailure(failure: nexus.Failure, retryable: boolean): ProtoFailure {
+    if (failure.metadata?.type === 'temporal.api.failure.v1.Failure') {
+      if (failure.details == null) {
+        throw new TypeError("missing details for Nexus Failure of type 'temporal.api.failure.v1.Failure'");
+      }
+      return failure.details;
+    } else {
+      const temporalFailure: ProtoFailure = {};
+      temporalFailure.applicationFailureInfo = {
+        type: 'NexusFailure',
+        nonRetryable: !retryable,
+        details: {
+          payloads: [
+            {
+              metadata: { encoding: encode('json/plain') },
+              data: encode(JSON.stringify({ ...failure, message: '' })),
+            },
+          ],
+        },
+      };
+      temporalFailure.message = failure.message;
+      temporalFailure.stackTrace = failure.stackTrace ?? '';
+      return temporalFailure;
+    }
+  }
+
+  private temporalFailureToNexusFailure(failure: ProtoFailure): nexus.Failure {
+    return {
+      message: failure.message ?? '',
+      metadata: { type: 'temporal.api.failure.v1.Failure' },
+      // Store the full ProtoFailure as the Nexus failure details so it can be round-tripped
+      // losslessly back to a ProtoFailure via nexusFailureToTemporalFailure.
+      details: { ...failure },
+    };
+  }
 }

package/src/converter/payload-search-attributes.ts

@@ -164,7 +164,7 @@ export const typedSearchAttributePayloadConverter = new TypedSearchAttributePayl
 
 // If both params are provided, conflicting keys will be overwritten by typedSearchAttributes.
 export function encodeUnifiedSearchAttributes(
-  searchAttributes?: SearchAttributes, // eslint-disable-line deprecation/deprecation
+  searchAttributes?: SearchAttributes, // eslint-disable-line @typescript-eslint/no-deprecated
   typedSearchAttributes?: TypedSearchAttributes | SearchAttributeUpdatePair[]
 ): Record<string, Payload> {
   return {
@@ -184,11 +184,11 @@ export function encodeUnifiedSearchAttributes(
   };
 }
 
-// eslint-disable-next-line deprecation/deprecation
+// eslint-disable-next-line @typescript-eslint/no-deprecated
 export function decodeSearchAttributes(indexedFields: Record<string, Payload> | undefined | null): SearchAttributes {
   if (!indexedFields) return {};
   return Object.fromEntries(
-    // eslint-disable-next-line deprecation/deprecation
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     Object.entries(mapFromPayloads(searchAttributePayloadConverter, indexedFields) as SearchAttributes).filter(
       ([_, v]) => v && v.length > 0
     ) // Filter out empty arrays returned by pre 1.18 servers

package/src/errors.ts

@@ -53,3 +53,23 @@ export class NamespaceNotFoundError extends Error {
     super(`Namespace not found: '${namespace}'`);
   }
 }
+
+/**
+ * Throw this error from an Activity in order to make the Worker forget about this Activity.
+ *
+ * The Activity can then be completed asynchronously (from anywhere—usually outside the Worker) using
+ * the Client's activity handle.
+ *
+ * @example
+ *
+ * ```ts
+ *import { CompleteAsyncError } from '@temporalio/activity';
+ *
+ *export async function myActivity(): Promise<never> {
+ *  // ...
+ *  throw new CompleteAsyncError();
+ *}
+ * ```
+ */
+@SymbolBasedInstanceOfError('CompleteAsyncError')
+export class CompleteAsyncError extends Error {}