@temporalio/workflow 1.17.3 → 1.17.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/workflow",
-  "version": "1.17.3",
+  "version": "1.17.4",
   "description": "Temporal.io SDK Workflow sub-package",
   "keywords": [
     "temporal",
@@ -27,8 +27,8 @@
   },
   "dependencies": {
     "nexus-rpc": "^0.0.2",
-    "@temporalio/common": "1.17.3",
-    "@temporalio/proto": "1.17.3"
+    "@temporalio/common": "1.17.4",
+    "@temporalio/proto": "1.17.4"
   },
   "devDependencies": {
     "ava": "^5.3.1",

package/src/flags.ts

@@ -114,7 +114,7 @@ type AltConditionFn = (ctx: { info: WorkflowInfo; sdkVersion?: string }) => bool
 
 function buildIdSdkVersionMatches(version: RegExp): AltConditionFn {
   const regex = new RegExp(`^@temporalio/worker@(${version.source})[+]`);
-  return ({ info }) => info.currentBuildId != null && regex.test(info.currentBuildId);
+  return ({ info }) => info.currentBuildId != null && regex.test(info.currentBuildId); // eslint-disable-line @typescript-eslint/no-deprecated
 }
 
 type SemVer = {

package/src/global-overrides.ts

@@ -5,7 +5,6 @@
  */
 import { msToTs } from '@temporalio/common/lib/time';
 import { CancellationScope } from './cancellation-scope';
-import { currentRandom } from './current-random';
 import { DeterminismViolationError } from './errors';
 import { getActivator } from './global-attributes';
 import { SdkFlags } from './flags';
@@ -104,6 +103,6 @@ export function overrideGlobals(): void {
     }
   };
 
-  // currentRandom() dispatches to a scoped stream when WorkflowRandomStream.with(...) is active.
-  Math.random = currentRandom;
+  // activator.random is mutable, don't hardcode its reference
+  Math.random = () => getActivator().random();
 }

package/src/index.ts

@@ -93,8 +93,8 @@ export {
   PayloadConverter,
   RetryPolicy,
   rootCause,
-  SearchAttributes,
-  SearchAttributeValue,
+  SearchAttributes, // eslint-disable-line @typescript-eslint/no-deprecated
+  SearchAttributeValue, // eslint-disable-line @typescript-eslint/no-deprecated
   ServerFailure,
   TemporalFailure,
   TerminatedFailure,
@@ -136,8 +136,6 @@ export {
   WorkflowInfo,
 } from './interfaces';
 export { proxySinks, Sink, SinkCall, SinkFunction, Sinks } from './sinks';
-export type { WorkflowRandomStream } from './random-streams';
-export { getRandomStream, workflowRandom } from './random-streams';
 export { log } from './logs';
 export { Trigger } from './trigger';
 export * from './workflow';

package/src/interfaces.ts

@@ -47,7 +47,7 @@ export interface WorkflowInfo {
    * This value may change during the lifetime of an Execution.
    * @deprecated Use {@link typedSearchAttributes} instead.
    */
-  readonly searchAttributes: SearchAttributes;
+  readonly searchAttributes: SearchAttributes; // eslint-disable-line @typescript-eslint/no-deprecated
 
   /**
    * Indexed information attached to the Workflow Execution, exposed through an interface.
@@ -337,7 +337,7 @@ export interface ContinueAsNewOptions {
    * Searchable attributes to attach to next Workflow run
    * @deprecated Use {@link typedSearchAttributes} instead.
    */
-  searchAttributes?: SearchAttributes;
+  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
@@ -357,7 +357,7 @@ export interface ContinueAsNewOptions {
    *
    * @deprecated Worker Versioning is now deprecated. Please use the Worker Deployment API instead: https://docs.temporal.io/worker-deployments
    */
-  versioningIntent?: VersioningIntent;
+  versioningIntent?: VersioningIntent; // eslint-disable-line @typescript-eslint/no-deprecated
   /**
    * Defines the versioning behavior to be used by the first task of a new workflow run in a continue-as-new chain.
    *
@@ -567,7 +567,7 @@ export interface ChildWorkflowOptions extends Omit<CommonWorkflowOptions, 'workf
    *
    * @deprecated Worker Versioning is now deprecated. Please use the Worker Deployment API instead: https://docs.temporal.io/worker-deployments
    */
-  versioningIntent?: VersioningIntent;
+  versioningIntent?: VersioningIntent; // eslint-disable-line @typescript-eslint/no-deprecated
 }
 
 export type RequiredChildWorkflowOptions = Required<Pick<ChildWorkflowOptions, 'workflowId' | 'cancellationType'>> & {
@@ -646,7 +646,6 @@ export interface WorkflowCreateOptions {
   randomnessSeed: number[];
   now: number;
   showStackTraceSources: boolean;
-  failureExceptionTypeNames?: string[];
 }
 
 export interface WorkflowCreateOptionsInternal extends WorkflowCreateOptions {

package/src/internals.ts

@@ -1,20 +1,17 @@
-import type { AsyncLocalStorage as ALS } from 'node:async_hooks';
 import type { RawSourceMap } from 'source-map';
 import type {
-  ActivitySerializationContext,
   FailureConverter,
   PayloadConverter,
-  ProtoFailure,
   Workflow,
-  WorkflowFunctionWithOptions,
   WorkflowQueryAnnotatedType,
   WorkflowSignalAnnotatedType,
   WorkflowUpdateAnnotatedType,
+  ProtoFailure,
   WorkflowUpdateType,
   WorkflowUpdateValidatorType,
+  WorkflowFunctionWithOptions,
   VersioningBehavior,
   WorkflowDefinitionOptions,
-  WorkflowSerializationContext,
 } from '@temporalio/common';
 import {
   defaultFailureConverter,
@@ -34,6 +31,7 @@ import {
   decodeSearchAttributes,
   decodeTypedSearchAttributes,
 } from '@temporalio/common/lib/converter/payload-search-attributes';
+import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 import type { coresdk, temporal } from '@temporalio/proto';
 import {
@@ -44,9 +42,7 @@ import {
 import type { RNG } from './alea';
 import { alea } from './alea';
 import { RootCancellationScope } from './cancellation-scope';
-import { composeInterceptors } from './interceptor-composition';
-import { AsyncLocalStorage, UpdateScope } from './update-scope';
-import { deriveAleaSeed } from './random-stream-seed';
+import { UpdateScope } from './update-scope';
 import { DeterminismViolationError, LocalActivityDoBackoff, isCancellation } from './errors';
 import type {
   QueryInput,
@@ -110,10 +106,9 @@ export interface PromiseStackStore {
   promiseToStack: Map<Promise<unknown>, Stack>;
 }
 
-export interface Completion<Success, Context = never> {
+export interface Completion<Success> {
   resolve(val: Success): void;
   reject(reason: Error): void;
-  context?: Context;
 }
 
 export interface Condition {
@@ -144,10 +139,6 @@ interface MessageHandlerExecution {
 
 type InferMapValue<T> = T extends Map<number, infer V> ? V : never;
 
-interface ScopedWorkflowRandomSource {
-  random(): number;
-}
-
 /**
  * Keeps all of the Workflow runtime state like pending completions for activities and timers.
  *
@@ -177,13 +168,13 @@ export class Activator implements ActivationHandler {
    */
   readonly completions = {
     timer: new Map<number, Completion<void>>(),
-    activity: new Map<number, Completion<unknown, ActivitySerializationContext>>(),
+    activity: new Map<number, Completion<unknown>>(),
     nexusOperationStart: new Map<number, Completion<StartNexusOperationOutput>>(),
     nexusOperationComplete: new Map<number, Completion<unknown>>(),
-    childWorkflowStart: new Map<number, Completion<string, WorkflowSerializationContext>>(),
-    childWorkflowComplete: new Map<number, Completion<unknown, WorkflowSerializationContext>>(),
-    signalWorkflow: new Map<number, Completion<void, WorkflowSerializationContext>>(),
-    cancelWorkflow: new Map<number, Completion<void, WorkflowSerializationContext>>(),
+    childWorkflowStart: new Map<number, Completion<string>>(),
+    childWorkflowComplete: new Map<number, Completion<unknown>>(),
+    signalWorkflow: new Map<number, Completion<void>>(),
+    cancelWorkflow: new Map<number, Completion<void>>(),
   };
 
   /**
@@ -277,22 +268,6 @@ export class Activator implements ActivationHandler {
    */
   public workflowTaskError: unknown;
 
-  /**
-   * Error type _names_ (from {@link WorkerOptions.workflowFailureErrorTypes}) that
-   * should cause Workflow Execution failure rather than WFT failure.
-   *
-   * Set at workflow creation time from the worker options.
-   */
-  public failureExceptionTypeNames: string[] = [];
-
-  /**
-   * Error _types_ (from {@link WorkflowDefinitionOptions.failureExceptionTypes})
-   * that should cause Workflow Execution failure rather than WFT failure.
-   *
-   * Set in `worker-interface.ts` after the workflow definition options are read.
-   */
-  public workflowDefinitionFailureExceptionTypes: Array<new (...args: any[]) => Error> | undefined = undefined;
-
   /**
    * Set to true when running synchronous code (e.g. while processing activation jobs and when calling
    * `tryUnblockConditions()`). While this flag is set, it is safe to let errors bubble up.
@@ -444,24 +419,10 @@ export class Activator implements ActivationHandler {
   public info: WorkflowInfo;
 
   /**
-   * The main deterministic RNG for this workflow execution.
-   *
-   * Scoped overrides used by `WorkflowRandomStream.with(...)` are layered on top of this RNG.
+   * A deterministic RNG, used by the isolate's overridden Math.random
    */
   public random: RNG;
 
-  /**
-   * The current seed material for this workflow execution's deterministic RNGs.
-   */
-  public randomnessSeed: number[];
-
-  /**
-   * Additional deterministic RNG streams keyed by stable stream name.
-   */
-  public readonly namedRandomStreams = new Map<string, RNG>();
-
-  protected currentRandomStorage?: ALS<ScopedWorkflowRandomSource | undefined>;
-
   public payloadConverter: PayloadConverter = defaultPayloadConverter;
   public failureConverter: FailureConverter = defaultFailureConverter;
 
@@ -511,55 +472,15 @@ export class Activator implements ActivationHandler {
     randomnessSeed,
     registeredActivityNames,
     stackTracesEnabled,
-    failureExceptionTypeNames,
   }: WorkflowCreateOptionsInternal) {
     this.getTimeOfDay = getTimeOfDay;
     this.info = info;
     this.now = now;
     this.showStackTraceSources = showStackTraceSources;
     this.sourceMap = sourceMap;
-    this.randomnessSeed = [...randomnessSeed];
-    this.random = alea(this.randomnessSeed);
+    this.random = alea(randomnessSeed);
     this.registeredActivityNames = registeredActivityNames;
     this.stackTracesEnabled = stackTracesEnabled;
-    this.failureExceptionTypeNames = failureExceptionTypeNames ?? [];
-  }
-
-  protected setRandomnessSeed(randomnessSeed: number[]): void {
-    this.randomnessSeed = [...randomnessSeed];
-    this.random = alea(this.randomnessSeed);
-    this.namedRandomStreams.clear();
-  }
-
-  public getNamedRandom(name: string): RNG {
-    const cached = this.namedRandomStreams.get(name);
-    if (cached !== undefined) {
-      return cached;
-    }
-
-    const random = alea(deriveAleaSeed(this.randomnessSeed, name));
-    this.namedRandomStreams.set(name, random);
-    return random;
-  }
-
-  protected withRandomSource<T>(randomSource: ScopedWorkflowRandomSource | undefined, fn: () => T): T {
-    return (this.currentRandomStorage ??= new AsyncLocalStorage<ScopedWorkflowRandomSource | undefined>()).run(
-      randomSource,
-      fn
-    );
-  }
-
-  public withCurrentRandom<T>(randomSource: ScopedWorkflowRandomSource, fn: () => T): T {
-    return this.withRandomSource(randomSource, fn);
-  }
-
-  public bindCurrentRandom<T extends (...args: any[]) => any>(fn: T): T {
-    const randomSource = this.currentRandomStorage?.getStore();
-    return ((...args: Parameters<T>) => this.withRandomSource(randomSource, () => fn(...args))) as T;
-  }
-
-  public currentRandom(): number {
-    return this.currentRandomStorage?.getStore()?.random() ?? this.random();
   }
 
   /**
@@ -633,13 +554,12 @@ export class Activator implements ActivationHandler {
 
   public startWorkflow(activation: coresdk.workflow_activation.IInitializeWorkflow): void {
     const execute = composeInterceptors(this.interceptors.inbound, 'execute', this.startWorkflowNextHandler.bind(this));
-    const context = this.workflowSerializationContext();
 
     untrackPromise(
       executeWithLifecycleLogging(() =>
         execute({
           headers: activation.headers ?? {},
-          args: arrayFromPayloads(this.payloadConverter, activation.arguments, context),
+          args: arrayFromPayloads(this.payloadConverter, activation.arguments),
         })
       ).then(this.completeWorkflow.bind(this), this.handleWorkflowFailure.bind(this))
     );
@@ -647,7 +567,6 @@ export class Activator implements ActivationHandler {
 
   public initializeWorkflow(activation: coresdk.workflow_activation.IInitializeWorkflow): void {
     const { continuedFailure, lastCompletionResult, memo, searchAttributes } = activation;
-    const context = this.workflowSerializationContext();
 
     // Most things related to initialization have already been handled in the constructor
     this.mutateWorkflowInfo((info) => ({
@@ -656,17 +575,15 @@ export class Activator implements ActivationHandler {
       searchAttributes: decodeSearchAttributes(searchAttributes?.indexedFields),
       typedSearchAttributes: decodeTypedSearchAttributes(searchAttributes?.indexedFields),
 
-      memo: mapFromPayloads(this.payloadConverter, memo?.fields, context),
-      lastResult: fromPayloadsAtIndex(this.payloadConverter, 0, lastCompletionResult?.payloads, context),
+      memo: mapFromPayloads(this.payloadConverter, memo?.fields),
+      lastResult: fromPayloadsAtIndex(this.payloadConverter, 0, lastCompletionResult?.payloads),
       lastFailure:
         continuedFailure != null
-          ? this.failureConverter.failureToError(continuedFailure, this.payloadConverter, context)
+          ? this.failureConverter.failureToError(continuedFailure, this.payloadConverter)
           : undefined,
     }));
-    const workflowDefinitionOpts = this.workflowDefinitionOptionsGetter?.();
-    if (workflowDefinitionOpts) {
-      this.versioningBehavior = workflowDefinitionOpts.versioningBehavior;
-      this.workflowDefinitionFailureExceptionTypes = workflowDefinitionOpts.failureExceptionTypes;
+    if (this.workflowDefinitionOptionsGetter) {
+      this.versioningBehavior = this.workflowDefinitionOptionsGetter().versioningBehavior;
     }
   }
 
@@ -686,23 +603,23 @@ export class Activator implements ActivationHandler {
     if (!activation.result) {
       throw new TypeError('Got ResolveActivity activation with no result');
     }
-    const { resolve, reject, context } = this.consumeCompletion('activity', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('activity', getSeq(activation));
     if (activation.result.completed) {
       const completed = activation.result.completed;
-      const result = completed.result ? this.payloadConverter.fromPayload(completed.result, context) : undefined;
+      const result = completed.result ? this.payloadConverter.fromPayload(completed.result) : undefined;
       resolve(result);
     } else if (activation.result.failed) {
       const { failure } = activation.result.failed;
       if (failure == null) {
         throw new TypeError('Got failed result with no failure attribute');
       }
-      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
+      reject(this.failureToError(failure));
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
       if (failure == null) {
         throw new TypeError('Got cancelled result with no failure attribute');
       }
-      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
+      reject(this.failureToError(failure));
     } else if (activation.result.backoff) {
       reject(new LocalActivityDoBackoff(activation.result.backoff));
     }
@@ -711,7 +628,7 @@ export class Activator implements ActivationHandler {
   public resolveChildWorkflowExecutionStart(
     activation: coresdk.workflow_activation.IResolveChildWorkflowExecutionStart
   ): void {
-    const { resolve, reject, context } = this.consumeCompletion('childWorkflowStart', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('childWorkflowStart', getSeq(activation));
     if (activation.succeeded) {
       if (!activation.succeeded.runId) {
         throw new TypeError('Got ResolveChildWorkflowExecutionStart with no runId');
@@ -735,7 +652,7 @@ export class Activator implements ActivationHandler {
       if (!activation.cancelled.failure) {
         throw new TypeError('Got no failure in cancelled variant');
       }
-      reject(this.failureConverter.failureToError(activation.cancelled.failure, this.payloadConverter, context));
+      reject(this.failureToError(activation.cancelled.failure));
     } else {
       throw new TypeError('Got ResolveChildWorkflowExecutionStart with no status');
     }
@@ -745,23 +662,23 @@ export class Activator implements ActivationHandler {
     if (!activation.result) {
       throw new TypeError('Got ResolveChildWorkflowExecution activation with no result');
     }
-    const { resolve, reject, context } = this.consumeCompletion('childWorkflowComplete', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('childWorkflowComplete', getSeq(activation));
     if (activation.result.completed) {
       const completed = activation.result.completed;
-      const result = completed.result ? this.payloadConverter.fromPayload(completed.result, context) : undefined;
+      const result = completed.result ? this.payloadConverter.fromPayload(completed.result) : undefined;
       resolve(result);
     } else if (activation.result.failed) {
       const { failure } = activation.result.failed;
       if (failure == null) {
         throw new TypeError('Got failed result with no failure attribute');
       }
-      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
+      reject(this.failureToError(failure));
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
       if (failure == null) {
         throw new TypeError('Got cancelled result with no failure attribute');
       }
-      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
+      reject(this.failureToError(failure));
     }
   }
 
@@ -787,10 +704,9 @@ export class Activator implements ActivationHandler {
 
   public resolveNexusOperation(activation: coresdk.workflow_activation.IResolveNexusOperation): void {
     const seq = getSeq(activation);
-    const context = this.workflowSerializationContext();
 
     if (activation.result?.completed) {
-      const result = this.payloadConverter.fromPayload(activation.result.completed, context);
+      const result = this.payloadConverter.fromPayload(activation.result.completed);
 
       // It is possible for ResolveNexusOperation to be received without a prior ResolveNexusOperationStart,
       // e.g. because the handler completed the Operation synchronously.
@@ -851,14 +767,8 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing query activation attributes');
     }
 
-    // Reject __temporal_-prefixed queries that would otherwise be routed to the
-    // user's default handler. A specific registered handler (e.g. from a
-    // contrib package) is allowed through.
-    if (
-      queryType.startsWith(TEMPORAL_RESERVED_PREFIX) &&
-      !this.queryHandlers.has(queryType) &&
-      this.defaultQueryHandler !== undefined
-    ) {
+    // If query has __temporal_ prefix but no handler exists, throw error
+    if (queryType.startsWith(TEMPORAL_RESERVED_PREFIX) && !this.queryHandlers.has(queryType)) {
       throw new TypeError(`Cannot use query name: '${queryType}', with reserved prefix: '${TEMPORAL_RESERVED_PREFIX}'`);
     }
 
@@ -869,10 +779,9 @@ export class Activator implements ActivationHandler {
       queryType === ENHANCED_STACK_TRACE_QUERY_NAME;
     const interceptors = isInternalQuery ? [] : this.interceptors.inbound;
     const execute = composeInterceptors(interceptors, 'handleQuery', this.queryWorkflowNextHandler.bind(this));
-    const context = this.workflowSerializationContext();
     execute({
       queryName: queryType,
-      args: arrayFromPayloads(this.payloadConverter, activation.arguments, context),
+      args: arrayFromPayloads(this.payloadConverter, activation.arguments),
       queryId,
       headers: headers ?? {},
     }).then(
@@ -893,15 +802,8 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing activation update protocolInstanceId');
     }
 
-    // Reject __temporal_-prefixed updates that would otherwise be routed to the
-    // user's default handler. A specific registered handler (e.g. from a
-    // contrib package) is allowed through, and unregistered names without a
-    // default handler fall through to the buffer-then-reject path below.
-    if (
-      name.startsWith(TEMPORAL_RESERVED_PREFIX) &&
-      !this.updateHandlers.has(name) &&
-      this.defaultUpdateHandler !== undefined
-    ) {
+    // If update has __temporal_ prefix but no handler exists, throw error
+    if (name.startsWith(TEMPORAL_RESERVED_PREFIX) && !this.updateHandlers.get(name)) {
       throw new TypeError(`Cannot use update name: '${name}', with reserved prefix: '${TEMPORAL_RESERVED_PREFIX}'`);
     }
 
@@ -929,15 +831,12 @@ export class Activator implements ActivationHandler {
       return;
     }
 
-    const makeInput = (): UpdateInput => {
-      const context = this.workflowSerializationContext();
-      return {
-        updateId,
-        args: arrayFromPayloads(this.payloadConverter, activation.input, context),
-        name,
-        headers: headers ?? {},
-      };
-    };
+    const makeInput = (): UpdateInput => ({
+      updateId,
+      args: arrayFromPayloads(this.payloadConverter, activation.input),
+      name,
+      headers: headers ?? {},
+    });
 
     // The implementation below is responsible for upholding, and constrained
     // by, the following contract:
@@ -1080,15 +979,8 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing activation signalName');
     }
 
-    // Reject __temporal_-prefixed signals that would otherwise be routed to the
-    // user's default handler. A specific registered handler (e.g. from a
-    // contrib package) is allowed through, and unregistered names without a
-    // default handler fall through to the buffer-then-reject path below.
-    if (
-      signalName.startsWith(TEMPORAL_RESERVED_PREFIX) &&
-      !this.signalHandlers.has(signalName) &&
-      this.defaultSignalHandler !== undefined
-    ) {
+    // If signal has __temporal_ prefix but no handler exists, throw error
+    if (signalName.startsWith(TEMPORAL_RESERVED_PREFIX) && !this.signalHandlers.has(signalName)) {
       throw new TypeError(
         `Cannot use signal name: '${signalName}', with reserved prefix: '${TEMPORAL_RESERVED_PREFIX}'`
       );
@@ -1115,9 +1007,8 @@ export class Activator implements ActivationHandler {
     const signalExecutionNum = this.signalHandlerExecutionSeq++;
     this.inProgressSignals.set(signalExecutionNum, { name: signalName, unfinishedPolicy });
     const execute = composeInterceptors(interceptors, 'handleSignal', this.signalWorkflowNextHandler.bind(this));
-    const context = this.workflowSerializationContext();
     execute({
-      args: arrayFromPayloads(this.payloadConverter, activation.input, context),
+      args: arrayFromPayloads(this.payloadConverter, activation.input),
       signalName,
       headers: headers ?? {},
     })
@@ -1142,9 +1033,9 @@ export class Activator implements ActivationHandler {
   }
 
   public resolveSignalExternalWorkflow(activation: coresdk.workflow_activation.IResolveSignalExternalWorkflow): void {
-    const { resolve, reject, context } = this.consumeCompletion('signalWorkflow', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('signalWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(this.failureConverter.failureToError(activation.failure, this.payloadConverter, context));
+      reject(this.failureToError(activation.failure));
     } else {
       resolve(undefined);
     }
@@ -1153,9 +1044,9 @@ export class Activator implements ActivationHandler {
   public resolveRequestCancelExternalWorkflow(
     activation: coresdk.workflow_activation.IResolveRequestCancelExternalWorkflow
   ): void {
-    const { resolve, reject, context } = this.consumeCompletion('cancelWorkflow', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('cancelWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(this.failureConverter.failureToError(activation.failure, this.payloadConverter, context));
+      reject(this.failureToError(activation.failure));
     } else {
       resolve(undefined);
     }
@@ -1185,7 +1076,7 @@ export class Activator implements ActivationHandler {
     if (!activation.randomnessSeed) {
       throw new TypeError('Expected activation with randomnessSeed attribute');
     }
-    this.setRandomnessSeed(activation.randomnessSeed.toBytes());
+    this.random = alea(activation.randomnessSeed.toBytes());
   }
 
   public notifyHasPatch(activation: coresdk.workflow_activation.INotifyHasPatch): void {
@@ -1280,7 +1171,7 @@ export class Activator implements ActivationHandler {
       this.pushCommand({ cancelWorkflowExecution: {} }, true);
     } else if (error instanceof ContinueAsNew) {
       this.pushCommand({ continueAsNewWorkflowExecution: error.command }, true);
-    } else if (error instanceof TemporalFailure || this.isConfiguredFailureException(error)) {
+    } else if (error instanceof TemporalFailure) {
       // Fail the workflow. We do not want to issue unfinishedHandlers warnings. To achieve that, we
       // mark all handlers as completed now.
       this.inProgressSignals.clear();
@@ -1288,7 +1179,7 @@ export class Activator implements ActivationHandler {
       this.pushCommand(
         {
           failWorkflowExecution: {
-            failure: this.errorToFailure(ensureTemporalFailure(error)),
+            failure: this.errorToFailure(error),
           },
         },
         true
@@ -1298,42 +1189,6 @@ export class Activator implements ActivationHandler {
     }
   }
 
-  /**
-   * Returns true if the given error matches any of the configured failure exception types
-   * (from {@link WorkerOptions.workflowFailureErrorTypes} or
-   * {@link WorkflowDefinitionOptions.failureExceptionTypes}).
-   */
-  private isConfiguredFailureException(error: unknown): boolean {
-    // Check class references from WorkflowDefinitionOptions (instanceof-based, supports subclasses)
-    if (this.workflowDefinitionFailureExceptionTypes) {
-      // We guarantee that including Error in the list will catch _any_ error.
-      if (this.workflowDefinitionFailureExceptionTypes.includes(Error)) return true;
-
-      for (const errorType of this.workflowDefinitionFailureExceptionTypes) {
-        if (error instanceof errorType) return true;
-      }
-    }
-
-    // Check class name strings from WorkerOptions (prototype-chain-based)
-    if (this.failureExceptionTypeNames.length > 0) {
-      // We guarantee that including 'Error' in the list will catch _any_ error.
-      if (this.failureExceptionTypeNames.includes('Error')) return true;
-
-      if (typeof error === 'object' && error !== null) {
-        let ctor = (error as any).constructor;
-        while (ctor != null && ctor !== Function.prototype) {
-          const name = (ctor as any).name as string | undefined;
-          if (name) {
-            if (this.failureExceptionTypeNames.includes(name)) return true;
-          }
-          ctor = Object.getPrototypeOf(ctor);
-        }
-      }
-    }
-
-    return false;
-  }
-
   recordWorkflowTaskError(error: unknown): void {
     // Only keep the first error that bubbles up; subsequent errors will be ignored.
     if (this.workflowTaskError === undefined) this.workflowTaskError = error;
@@ -1353,9 +1208,8 @@ export class Activator implements ActivationHandler {
   }
 
   private completeQuery(queryId: string, result: unknown): void {
-    const context = this.workflowSerializationContext();
     this.pushCommand({
-      respondToQuery: { queryId, succeeded: { response: this.payloadConverter.toPayload(result, context) } },
+      respondToQuery: { queryId, succeeded: { response: this.payloadConverter.toPayload(result) } },
     });
   }
 
@@ -1373,9 +1227,8 @@ export class Activator implements ActivationHandler {
   }
 
   private completeUpdate(protocolInstanceId: string, result: unknown): void {
-    const context = this.workflowSerializationContext();
     this.pushCommand({
-      updateResponse: { protocolInstanceId, completed: this.payloadConverter.toPayload(result, context) },
+      updateResponse: { protocolInstanceId, completed: this.payloadConverter.toPayload(result) },
     });
   }
 
@@ -1413,11 +1266,10 @@ export class Activator implements ActivationHandler {
   }
 
   private completeWorkflow(result: unknown): void {
-    const context = this.workflowSerializationContext();
     this.pushCommand(
       {
         completeWorkflowExecution: {
-          result: this.payloadConverter.toPayload(result, context),
+          result: this.payloadConverter.toPayload(result),
         },
       },
       true
@@ -1425,21 +1277,11 @@ export class Activator implements ActivationHandler {
   }
 
   errorToFailure(err: unknown): ProtoFailure {
-    const context = this.workflowSerializationContext();
-    return this.failureConverter.errorToFailure(err, this.payloadConverter, context);
+    return this.failureConverter.errorToFailure(err, this.payloadConverter);
   }
 
   failureToError(failure: ProtoFailure): Error {
-    const context = this.workflowSerializationContext();
-    return this.failureConverter.failureToError(failure, this.payloadConverter, context);
-  }
-
-  private workflowSerializationContext(): WorkflowSerializationContext {
-    return {
-      type: 'workflow',
-      namespace: this.info.namespace,
-      workflowId: this.info.workflowId,
-    };
+    return this.failureConverter.failureToError(failure, this.payloadConverter);
   }
 }