@temporalio/workflow 1.14.2 → 1.15.1

package/src/interceptors.ts

@@ -15,7 +15,8 @@ import {
   WorkflowExecution,
 } from '@temporalio/common';
 import type { coresdk } from '@temporalio/proto';
-import { ChildWorkflowOptionsWithDefaults, ContinueAsNewOptions } from './interfaces';
+import type { ChildWorkflowOptionsWithDefaults, ContinueAsNewOptions } from './interfaces';
+import type { NexusOperationCancellationType } from './nexus';
 
 export { Next, Headers };
 
@@ -288,6 +289,22 @@ export interface StartNexusOperationOptions {
    */
   readonly scheduleToCloseTimeout?: Duration;
 
+  /**
+   * Determines:
+   * - whether cancellation requests should be propagated from the Workflow to the Nexus Operation
+   * - whether and when should the Operation's cancellation be reported back to the Workflow
+   *   (i.e. at which moment should the operation's result promise fail with a `NexusOperationFailure`,
+   *   with `cause` set to a `CancelledFailure`).
+   *
+   * Note that this setting only applies to cancellation originating from an external request for the
+   * Workflow itself, or from internal cancellation of the `CancellationScope` in which the
+   * Operation call was made.
+   *
+   * @default WAIT_CANCELLATION_COMPLETED
+   */
+  // MAINTENANCE: Keep this typedoc in sync with the `NexusOperationCancellationType` enum
+  readonly cancellationType?: NexusOperationCancellationType;
+
   /**
    * A fixed, single-line summary for this Nexus Operation that may appear in the UI/CLI.
    * This can be in single-line Temporal markdown format.

package/src/interfaces.ts

@@ -45,7 +45,7 @@ export interface WorkflowInfo {
    * This value may change during the lifetime of an Execution.
    * @deprecated Use {@link typedSearchAttributes} instead.
    */
-  readonly searchAttributes: SearchAttributes; // eslint-disable-line deprecation/deprecation
+  readonly searchAttributes: SearchAttributes; // eslint-disable-line @typescript-eslint/no-deprecated
 
   /**
    * Indexed information attached to the Workflow Execution, exposed through an interface.
@@ -208,8 +208,6 @@ export interface WorkflowInfo {
    * executing this task for the first time and has a Deployment Version set, then its ID will be
    * used. This value may change over the lifetime of the workflow run, but is deterministic and
    * safe to use for branching.
-   *
-   * @experimental Deployment based versioning is experimental and may change in the future.
    */
   readonly currentDeploymentVersion?: WorkerDeploymentVersion;
 
@@ -235,7 +233,22 @@ export interface UnsafeWorkflowInfo {
    */
   readonly now: () => number;
 
+  /**
+   * Whether the workflow is currently replaying.
+   */
   readonly isReplaying: boolean;
+
+  /**
+   * Whether the workflow is currently replaying history events.
+   *
+   * This is similar to {@link isReplaying}, but returns `false` during query handlers and update
+   * validators, which are live read-only operations that should not be considered as replaying
+   * history events.
+   *
+   * When this property is true, workflow log messages are suppressed and sinks defined with
+   * callDuringReplay=false won't get processed.
+   */
+  readonly isReplayingHistoryEvents: boolean;
 }
 
 /**
@@ -304,7 +317,7 @@ export interface ContinueAsNewOptions {
    * Searchable attributes to attach to next Workflow run
    * @deprecated Use {@link typedSearchAttributes} instead.
    */
-  searchAttributes?: SearchAttributes; // eslint-disable-line deprecation/deprecation
+  searchAttributes?: SearchAttributes; // eslint-disable-line @typescript-eslint/no-deprecated
   /**
    * Specifies additional indexed information to attach to the Workflow Execution. More info:
    * https://docs.temporal.io/docs/typescript/search-attributes
@@ -322,48 +335,74 @@ export interface ContinueAsNewOptions {
    *
    * @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
 }
 
 /**
- * Specifies:
- * - whether cancellation requests are sent to the Child
- * - whether and when a {@link CanceledFailure} is thrown from {@link executeChild} or
- *   {@link ChildWorkflowHandle.result}
+ * Determines:
+ * - whether cancellation requests should be propagated from the Parent Workflow to the Child, and
+ * - whether and when should the Child's cancellation be reported back to the Parent Workflow
+ *   (i.e. at which moment should the {@link executeChild}'s or {@link ChildWorkflowHandle.result}'s
+ *   promise fail with a `ChildWorkflowFailure`, with `cause` set to a `CancelledFailure`).
+ *
+ * Note that this setting only applies to cancellation originating from an external request for the
+ * Parent Workflow itself, or from internal cancellation of the `CancellationScope` in which the
+ * Child Workflow call was made. Eventual Cancellation of a Child Workflow on completion of the
+ * Parent Workflow is controlled by the {@link ParentClosePolicy} setting.
  *
- * @default {@link ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED}
+ * @default ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED
  */
-export type ChildWorkflowCancellationType =
-  (typeof ChildWorkflowCancellationType)[keyof typeof ChildWorkflowCancellationType];
+// MAINTENANCE: Keep this typedoc in sync with the `ChildWorkflowOptions.cancellationType` field
 export const ChildWorkflowCancellationType = {
   /**
-   * Don't send a cancellation request to the Child.
+   * Do not propagate cancellation requests to the Child, and immediately report cancellation
+   * to the caller.
    */
   ABANDON: 'ABANDON',
 
   /**
-   * Send a cancellation request to the Child. Immediately throw the error.
+   * Propagate cancellation request from the Parent Workflow to the Child, 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 Parent-side, that the
+   * cancellation request will actually be atomically added to the Child workflow's history.
+   * In particular, the Child may complete (either successfully or uncessfully) before the
+   * cancellation is delivered, resulting in a situation where the Parent workflow thinks its child
+   * was cancelled, but the child actually completed successfully.
+   *
+   * To guarantee that the Child will eventually be notified of the cancellation request,
+   * use {@link WAIT_CANCELLATION_REQUESTED}.
    */
   TRY_CANCEL: 'TRY_CANCEL',
 
   /**
-   * Send a cancellation request to the Child. The Child may respect cancellation, in which case an error will be thrown
-   * when cancellation has completed, and {@link isCancellation}(error) will be true. On the other hand, the Child may
-   * ignore the cancellation request, in which case an error might be thrown with a different cause, or the Child may
-   * complete successfully.
+   * Propagate cancellation request from the Parent Workflow to the Child, then wait for the server
+   * to confirm that the Child Workflow cancellation request was recorded in its history.
    *
-   * @default
+   * This cancellation type guarantees that the Child will eventually be notified of the
+   * cancellation request (that is, unless the Child terminates inbetween due to unexpected causes).
    */
-  WAIT_CANCELLATION_COMPLETED: 'WAIT_CANCELLATION_COMPLETED',
+  WAIT_CANCELLATION_REQUESTED: 'WAIT_CANCELLATION_REQUESTED',
 
   /**
-   * Send a cancellation request to the Child. Throw the error once the Server receives the Child cancellation request.
+   * Propagate cancellation request from the Parent Workflow to the Child, then wait for completion
+   * of the Child Workflow.
+   *
+   * The Child may respect cancellation, in which case the Parent's `executeChild` or
+   * `ChildWorkflowHandle.result` promise will fail with a `ChildWorkflowFailure`, with `cause`
+   * set to a `CancelledFailure`. On the other hand, the Child may ignore the cancellation request,
+   * in which case the corresponding promise will either resolve with a result (if Child completed
+   * successfully) or reject with a different cause (if Child completed uncessfully).
+   *
+   * @default
    */
-  WAIT_CANCELLATION_REQUESTED: 'WAIT_CANCELLATION_REQUESTED',
+  WAIT_CANCELLATION_COMPLETED: 'WAIT_CANCELLATION_COMPLETED',
 } as const;
+export type ChildWorkflowCancellationType =
+  (typeof ChildWorkflowCancellationType)[keyof typeof ChildWorkflowCancellationType];
 
 // ts-prune-ignore-next
 export const [encodeChildWorkflowCancellationType, decodeChildWorkflowCancellationType] = makeProtoEnumConverters<
@@ -387,7 +426,6 @@ export const [encodeChildWorkflowCancellationType, decodeChildWorkflowCancellati
  *
  * @see {@link https://docs.temporal.io/concepts/what-is-a-parent-close-policy/ | Parent Close Policy}
  */
-export type ParentClosePolicy = (typeof ParentClosePolicy)[keyof typeof ParentClosePolicy];
 export const ParentClosePolicy = {
   /**
    * When the Parent is Closed, the Child is Terminated.
@@ -413,29 +451,30 @@ export const ParentClosePolicy = {
    *
    * @deprecated Either leave property `undefined`, or set an explicit policy instead.
    */
-  PARENT_CLOSE_POLICY_UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+  PARENT_CLOSE_POLICY_UNSPECIFIED: undefined,
 
   /**
    * When the Parent is Closed, the Child is Terminated.
    *
    * @deprecated Use {@link ParentClosePolicy.TERMINATE} instead.
    */
-  PARENT_CLOSE_POLICY_TERMINATE: 'TERMINATE', // eslint-disable-line deprecation/deprecation
+  PARENT_CLOSE_POLICY_TERMINATE: 'TERMINATE',
 
   /**
    * When the Parent is Closed, nothing is done to the Child.
    *
    * @deprecated Use {@link ParentClosePolicy.ABANDON} instead.
    */
-  PARENT_CLOSE_POLICY_ABANDON: 'ABANDON', // eslint-disable-line deprecation/deprecation
+  PARENT_CLOSE_POLICY_ABANDON: 'ABANDON',
 
   /**
    * When the Parent is Closed, the Child is Cancelled.
    *
    * @deprecated Use {@link ParentClosePolicy.REQUEST_CANCEL} instead.
    */
-  PARENT_CLOSE_POLICY_REQUEST_CANCEL: 'REQUEST_CANCEL', // eslint-disable-line deprecation/deprecation
+  PARENT_CLOSE_POLICY_REQUEST_CANCEL: 'REQUEST_CANCEL',
 } as const;
+export type ParentClosePolicy = (typeof ParentClosePolicy)[keyof typeof ParentClosePolicy];
 
 // ts-prune-ignore-next
 export const [encodeParentClosePolicy, decodeParentClosePolicy] = makeProtoEnumConverters<
@@ -471,19 +510,26 @@ export interface ChildWorkflowOptions extends Omit<CommonWorkflowOptions, 'workf
   taskQueue?: string;
 
   /**
-   * Specifies:
-   * - whether cancellation requests are sent to the Child
-   * - whether and when an error is thrown from {@link executeChild} or
-   *   {@link ChildWorkflowHandle.result}
+   * Determines:
+   * - whether cancellation requests should be propagated from the Parent Workflow to the Child, and
+   * - whether and when should the Child's cancellation be reported back to the Parent Workflow
+   *   (i.e. at which moment should the {@link executeChild}'s or {@link ChildWorkflowHandle.result}'s
+   *   promise fail with a `ChildWorkflowFailure`, with `cause` set to a `CancelledFailure`).
+   *
+   * Note that this setting only applies to cancellation originating from an external request for the
+   * Parent Workflow itself, or from internal cancellation of the `CancellationScope` in which the
+   * Child Workflow call was made. Eventual Cancellation of a Child Workflow on completion of the
+   * Parent Workflow is controlled by the {@link ParentClosePolicy} setting.
    *
-   * @default {@link ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED}
+   * @default ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED
    */
+  // MAINTENANCE: Keep this typedoc in sync with the `ChildWorkflowCancellationType` enum
   cancellationType?: ChildWorkflowCancellationType;
 
   /**
    * Specifies how the Child reacts to the Parent Workflow reaching a Closed state.
    *
-   * @default {@link ParentClosePolicy.PARENT_CLOSE_POLICY_TERMINATE}
+   * @default ParentClosePolicy.PARENT_CLOSE_POLICY_TERMINATE
    */
   parentClosePolicy?: ParentClosePolicy;
 
@@ -493,10 +539,9 @@ export interface ChildWorkflowOptions extends Omit<CommonWorkflowOptions, 'workf
    *
    * @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
 }
 
 export type RequiredChildWorkflowOptions = Required<Pick<ChildWorkflowOptions, 'workflowId' | 'cancellationType'>> & {
@@ -581,6 +626,7 @@ export interface WorkflowCreateOptionsInternal extends WorkflowCreateOptions {
   sourceMap: RawSourceMap;
   registeredActivityNames: Set<string>;
   getTimeOfDay(): bigint;
+  stackTracesEnabled: boolean;
 }
 
 /**

package/src/internals.ts

@@ -455,6 +455,10 @@ export class Activator implements ActivationHandler {
   public versioningBehavior?: VersioningBehavior;
   public workflowDefinitionOptionsGetter?: () => WorkflowDefinitionOptions;
 
+  public readonly workflowSandboxDestructors: (() => void)[] = [];
+
+  protected readonly stackTracesEnabled: boolean;
+
   constructor({
     info,
     now,
@@ -463,6 +467,7 @@ export class Activator implements ActivationHandler {
     getTimeOfDay,
     randomnessSeed,
     registeredActivityNames,
+    stackTracesEnabled,
   }: WorkflowCreateOptionsInternal) {
     this.getTimeOfDay = getTimeOfDay;
     this.info = info;
@@ -471,6 +476,7 @@ export class Activator implements ActivationHandler {
     this.sourceMap = sourceMap;
     this.random = alea(randomnessSeed);
     this.registeredActivityNames = registeredActivityNames;
+    this.stackTracesEnabled = stackTracesEnabled;
   }
 
   /**
@@ -481,6 +487,9 @@ export class Activator implements ActivationHandler {
   }
 
   protected getStackTraces(): Stack[] {
+    if (!this.stackTracesEnabled) {
+      throw new IllegalStateError('Workflow stack traces are not enabled on this worker');
+    }
     const { childToParent, promiseToStack } = this.promiseStackStore;
     const internalNodes = [...childToParent.values()].reduce((acc, curr) => {
       for (const p of curr) {
@@ -856,12 +865,26 @@ export class Activator implements ActivationHandler {
       let input: UpdateInput;
       try {
         if (runValidator && entry.validator) {
-          const validate = composeInterceptors(
-            interceptors,
-            'validateUpdate',
-            this.validateUpdateNextHandler.bind(this, entry.validator)
-          );
-          validate(makeInput());
+          // Temporarily mark as not replaying history events during validator execution
+          // so that logging is permitted. Validators are live read-only operations.
+          const wasReplayingHistoryEvents = this.info.unsafe.isReplayingHistoryEvents;
+          this.mutateWorkflowInfo((info) => ({
+            ...info,
+            unsafe: { ...info.unsafe, isReplayingHistoryEvents: false },
+          }));
+          try {
+            const validate = composeInterceptors(
+              interceptors,
+              'validateUpdate',
+              this.validateUpdateNextHandler.bind(this, entry.validator)
+            );
+            validate(makeInput());
+          } finally {
+            this.mutateWorkflowInfo((info) => ({
+              ...info,
+              unsafe: { ...info.unsafe, isReplayingHistoryEvents: wasReplayingHistoryEvents },
+            }));
+          }
         }
         input = makeInput();
       } catch (error) {
@@ -928,7 +951,6 @@ export class Activator implements ActivationHandler {
       const update = this.bufferedUpdates.shift();
       if (update) {
         this.rejectUpdate(
-          /* eslint-disable @typescript-eslint/no-non-null-assertion */
           update.protocolInstanceId!,
           ApplicationFailure.nonRetryable(`No registered handler for update: ${update.name}`)
         );
@@ -995,7 +1017,7 @@ export class Activator implements ActivationHandler {
     while (bufferedSignals.length) {
       if (this.defaultSignalHandler) {
         // We have a default signal handler, so all signals are dispatchable
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
         this.signalWorkflow(bufferedSignals.shift()!);
       } else {
         const foundIndex = bufferedSignals.findIndex((signal) => this.signalHandlers.has(signal.signalName as string));

package/src/metrics.ts

@@ -48,6 +48,9 @@ class WorkflowMetricMeterImpl implements MetricMeter {
 }
 
 class WorkflowMetricCounter implements MetricCounter {
+  public readonly kind = 'counter';
+  public readonly valueType = 'int';
+
   constructor(
     public readonly name: string,
     public readonly unit: string | undefined,
@@ -70,6 +73,8 @@ class WorkflowMetricCounter implements MetricCounter {
 }
 
 class WorkflowMetricHistogram implements MetricHistogram {
+  public readonly kind = 'histogram';
+
   constructor(
     public readonly name: string,
     public readonly valueType: NumericMetricValueType,
@@ -93,6 +98,8 @@ class WorkflowMetricHistogram implements MetricHistogram {
 }
 
 class WorkflowMetricGauge implements MetricGauge {
+  public readonly kind = 'gauge';
+
   constructor(
     public readonly name: string,
     public readonly valueType: NumericMetricValueType,

package/src/nexus.ts

@@ -2,6 +2,8 @@ import * as nexus from 'nexus-rpc';
 import { msOptionalToTs } from '@temporalio/common/lib/time';
 import { userMetadataToPayload } from '@temporalio/common/lib/user-metadata';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
+import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow/enums-helpers';
+import type { coresdk } from '@temporalio/proto';
 import { CancellationScope } from './cancellation-scope';
 import { getActivator } from './global-attributes';
 import { untrackPromise } from './stack-helpers';
@@ -146,17 +148,18 @@ export function createNexusClient<T extends nexus.ServiceDefinition>(options: Ne
         startNexusOperationNextHandler
       );
 
-      // TODO: Do we want to make the interceptor async like we do for child workflow? That seems redundant.
-      // REVIEW: I ended up changing this so that the interceptor returns a Promise<StartNexusOperationOutput>,
-      //         and the result promise is contained in that Output object. As a consequence of this,
-      //         the result promise/completion does not exist until the StartNexusOperation event is received.
-      //         That's totally different from what we did in ChildWorkflow, but I think that's cleaner from
-      //         interceptors point of view, and will make it easier to extend the API in the future.
+      // The interceptor returns a Promise<StartNexusOperationOutput>, with the result promise contained
+      // in that Output object. As a consequence of this, the result promise/completion does not exist
+      // until the StartNexusOperation event is received. This is totally different from what we did in
+      // ChildWorkflow, but is much cleaner from the interceptors point of view.
       const { token, result: resultPromise } = await execute({
         endpoint: options.endpoint,
         service: options.service.name,
         operation: opName,
-        options: operationOptions ?? {},
+        options: {
+          ...operationOptions,
+          cancellationType: operationOptions?.cancellationType ?? 'WAIT_CANCELLATION_COMPLETED',
+        },
         headers: {},
         seq,
         input,
@@ -220,7 +223,7 @@ function startNexusOperationNextHandler({
         nexusHeader: headers,
         input: activator.payloadConverter.toPayload(input),
         scheduleToCloseTimeout: msOptionalToTs(options?.scheduleToCloseTimeout),
-        // FIXME(nexus-post-initial-release): cancellationType is not supported yet
+        cancellationType: encodeNexusOperationCancellationType(options?.cancellationType),
       },
       userMetadata: userMetadataToPayload(activator.payloadConverter, options?.summary, undefined),
     });
@@ -231,3 +234,76 @@ function startNexusOperationNextHandler({
     });
   });
 }
+
+/**
+ * Determines:
+ * - whether cancellation requests should be propagated from the Workflow to the Nexus Operation
+ * - whether and when should the Operation's cancellation be reported back to the Workflow
+ *   (i.e. at which moment should the operation's result promise fail with a `NexusOperationFailure`,
+ *   with `cause` set to a `CancelledFailure`).
+ *
+ * Note that this setting only applies to cancellation originating from an external request for the
+ * Workflow itself, or from internal cancellation of the `CancellationScope` in which the
+ * Operation call was made.
+ *
+ * @experimental Nexus support in Temporal SDK is experimental.
+ */
+// MAINTENANCE: Keep this typedoc in sync with the `StartNexusOperationOptions.cancellationType` field
+export const NexusOperationCancellationType = {
+  /**
+   * Do not propagate cancellation requests to the Nexus Operation, and immediately report
+   * cancellation to the caller.
+   */
+  ABANDON: 'ABANDON',
+
+  /**
+   * Initiate a cancellation request for the Nexus operation and immediately report cancellation to
+   * the caller. Note that it doesn't guarantee that cancellation is delivered to the operation if
+   * calling workflow exits before the delivery is done. If you want to ensure that cancellation is
+   * delivered to the operation, use {@link WAIT_CANCELLATION_REQUESTED}.
+   *
+   * Propagate cancellation request from the Workflow to the Operation, 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 be delivered to the Operation Handler. In particular, either the
+   * Operation or the Workflow may complete (either successfully or uncessfully) before the
+   * cancellation request is delivered, resulting in a situation where the Operation completed
+   * successfully, but the Workflow thinks it was cancelled.
+   *
+   * To guarantee that the Operation will eventually be notified of the cancellation request,
+   * use {@link WAIT_CANCELLATION_REQUESTED}.
+   */
+  TRY_CANCEL: 'TRY_CANCEL',
+
+  /**
+   * Propagate cancellation request from the Workflow to the Operation, then wait for the server
+   * to confirm that the Operation cancellation request was delivered to the Operation Handler.
+   */
+  WAIT_CANCELLATION_REQUESTED: 'WAIT_CANCELLATION_REQUESTED',
+
+  /**
+   * Propagate cancellation request from the Workflow to the Operation, then wait for completion
+   * of the Operation.
+   */
+  WAIT_CANCELLATION_COMPLETED: 'WAIT_CANCELLATION_COMPLETED',
+} as const;
+export type NexusOperationCancellationType =
+  (typeof NexusOperationCancellationType)[keyof typeof NexusOperationCancellationType];
+
+const [encodeNexusOperationCancellationType, _] = makeProtoEnumConverters<
+  coresdk.nexus.NexusOperationCancellationType,
+  typeof coresdk.nexus.NexusOperationCancellationType,
+  keyof typeof coresdk.nexus.NexusOperationCancellationType,
+  typeof NexusOperationCancellationType,
+  ''
+>(
+  {
+    [NexusOperationCancellationType.WAIT_CANCELLATION_COMPLETED]: 0,
+    [NexusOperationCancellationType.ABANDON]: 1,
+    [NexusOperationCancellationType.TRY_CANCEL]: 2,
+    [NexusOperationCancellationType.WAIT_CANCELLATION_REQUESTED]: 3,
+  } as const,
+  ''
+);

package/src/stack-helpers.ts

@@ -1,11 +1,10 @@
-import { maybeGetActivatorUntyped } from './global-attributes';
-import type { PromiseStackStore } from './internals';
+import { maybeGetActivator } from './global-attributes';
 
 /**
  * Helper function to remove a promise from being tracked for stack trace query purposes
  */
 export function untrackPromise(promise: Promise<unknown>): void {
-  const store = (maybeGetActivatorUntyped() as any)?.promiseStackStore as PromiseStackStore | undefined;
+  const store = maybeGetActivator()?.promiseStackStore;
   if (!store) return;
   store.childToParent.delete(promise);
   store.promiseToStack.delete(promise);

package/src/update-scope.ts

@@ -57,11 +57,4 @@ export class UpdateScope {
   }
 }
 
-const storage = new AsyncLocalStorage<UpdateScope>();
-
-/**
- * Disable the async local storage for updates.
- */
-export function disableUpdateStorage(): void {
-  storage.disable();
-}
+const storage: ALS<UpdateScope> = new AsyncLocalStorage();

package/src/worker-interface.ts

@@ -6,17 +6,14 @@
 import { encodeVersioningBehavior, IllegalStateError, WorkflowFunctionWithOptions } from '@temporalio/common';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { coresdk } from '@temporalio/proto';
-import { disableStorage } from './cancellation-scope';
-import { disableUpdateStorage } from './update-scope';
-import { WorkflowInterceptorsFactory } from './interceptors';
-import { WorkflowCreateOptionsInternal } from './interfaces';
+import type { WorkflowInterceptorsFactory } from './interceptors';
+import type { WorkflowCreateOptionsInternal } from './interfaces';
 import { Activator } from './internals';
-import { setActivatorUntyped, getActivator } from './global-attributes';
+import { setActivator, getActivator, maybeGetActivator } from './global-attributes';
 
 // Export the type for use on the "worker" side
 export { PromiseStackStore } from './internals';
 
-const global = globalThis as any;
 const OriginalDate = globalThis.Date;
 
 /**
@@ -35,7 +32,7 @@ export function initRuntime(options: WorkflowCreateOptionsInternal): void {
   // There's one activator per workflow instance, set it globally on the context.
   // We do this before importing any user code so user code can statically reference @temporalio/workflow functions
   // as well as Date and Math.random.
-  setActivatorUntyped(activator);
+  setActivator(activator);
 
   activator.rethrowSynchronously = true;
   try {
@@ -54,7 +51,7 @@ export function initRuntime(options: WorkflowCreateOptionsInternal): void {
       activator.failureConverter = customFailureConverter;
     }
 
-    const { importWorkflows, importInterceptors } = global.__TEMPORAL__;
+    const { importWorkflows, importInterceptors } = globalThis.__TEMPORAL__;
     if (importWorkflows === undefined || importInterceptors === undefined) {
       throw new IllegalStateError('Workflow bundle did not register import hooks');
     }
@@ -97,6 +94,15 @@ export function initRuntime(options: WorkflowCreateOptionsInternal): void {
         activator.workflowDefinitionOptionsGetter = activator.workflow.workflowDefinitionOptions;
       }
     }
+  } catch (e) {
+    try {
+      // Core won't send an eviction job after an early error, so we are responsible for triggering
+      // disposal of the workflow execution context. Otherwise, there might be resource leaks.
+      dispose();
+    } catch (_innerError) {
+      // Ignore error disposing of activator, it is more important to rethrow the original error
+    }
+    throw e;
   } finally {
     activator.rethrowSynchronously = false;
   }
@@ -252,17 +258,58 @@ export function tryUnblockConditions(): number {
   }
 }
 
+// Handle disposal of the workflow execution context (not to be confused with destroying
+// the sandbox vm, which may possibly be reused if `reuseV8Context` is true).
 export function dispose(): void {
+  let error: unknown | undefined = undefined;
+
   const activator = getActivator();
   activator.rethrowSynchronously = true;
   try {
-    const dispose = composeInterceptors(activator.interceptors.internals, 'dispose', async () => {
-      disableStorage();
-      disableUpdateStorage();
-    });
-    dispose({});
+    try {
+      const dispose = composeInterceptors(activator.interceptors.internals, 'dispose', async () => {});
+      dispose({});
+    } catch (e) {
+      error = e;
+    }
+
+    // Destructors are run outside of interceptors, because interceptors themselves often rely
+    // on objects that will be destroyed (notably AsyncLocalStorage instances), and because we
+    // want to make sure that resources get cleaned up even if an interceptor throws an error.
+    // Only the first error (if any) is rethrown.
+    for (const destructor of activator.workflowSandboxDestructors.splice(0)) {
+      try {
+        destructor();
+      } catch (e) {
+        if (error == null) {
+          error = e;
+        }
+      }
+    }
+
+    if (error != null) throw error;
   } finally {
     activator.rethrowSynchronously = false;
+
+    // The activator is no longer valid past this point.
+    setActivator(undefined);
+  }
+}
+
+// Destroy the sandbox VM (not to be confused with disposing of the workflow execution context).
+export function destroy(): void {
+  const activator = maybeGetActivator();
+  if (activator) throw new IllegalStateError('Workflow execution context should have been disposed first');
+
+  let error: unknown | undefined = undefined;
+  for (const destructor of globalThis.__temporal_globalSandboxDestructors?.splice(0) ?? []) {
+    try {
+      destructor();
+    } catch (e) {
+      if (error == null) {
+        error = e;
+      }
+    }
   }
 }