@temporalio/workflow 1.17.4 → 1.18.1

package/src/nexus.ts

@@ -1,11 +1,11 @@
 import type * 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 { composeInterceptors } from './interceptor-composition';
 import { untrackPromise } from './stack-helpers';
 import type { StartNexusOperationInput, StartNexusOperationOutput, StartNexusOperationOptions } from './interceptors';
 
@@ -191,6 +191,11 @@ function startNexusOperationNextHandler({
   headers,
 }: StartNexusOperationInput): Promise<StartNexusOperationOutput> {
   const activator = getActivator();
+  const context = {
+    type: 'workflow' as const,
+    namespace: activator.info.namespace,
+    workflowId: activator.info.workflowId,
+  };
 
   return new Promise<StartNexusOperationOutput>((resolve, reject) => {
     const scope = CancellationScope.current();
@@ -223,13 +228,13 @@ function startNexusOperationNextHandler({
         service,
         operation,
         nexusHeader: headers,
-        input: activator.payloadConverter.toPayload(input),
+        input: activator.payloadConverter.toPayload(input, context),
         scheduleToCloseTimeout: msOptionalToTs(options?.scheduleToCloseTimeout),
         scheduleToStartTimeout: msOptionalToTs(options?.scheduleToStartTimeout),
         startToCloseTimeout: msOptionalToTs(options?.startToCloseTimeout),
         cancellationType: encodeNexusOperationCancellationType(options?.cancellationType),
       },
-      userMetadata: userMetadataToPayload(activator.payloadConverter, options?.summary, undefined),
+      userMetadata: userMetadataToPayload(activator.payloadConverter, options?.summary, undefined, context),
     });
 
     activator.completions.nexusOperationStart.set(seq, {

package/src/random-helpers.ts

@@ -0,0 +1,21 @@
+export function fillWithRandom(random: () => number, bytes: Uint8Array): Uint8Array {
+  for (let i = 0; i < bytes.length; ++i) {
+    bytes[i] = Math.floor(random() * 0x100);
+  }
+  return bytes;
+}
+
+export function uuid4FromRandom(random: () => number): string {
+  const ho = (n: number, p: number) => n.toString(16).padStart(p, '0');
+  const view = new DataView(new ArrayBuffer(16));
+  view.setUint32(0, (random() * 0x100000000) >>> 0);
+  view.setUint32(4, (random() * 0x100000000) >>> 0);
+  view.setUint32(8, (random() * 0x100000000) >>> 0);
+  view.setUint32(12, (random() * 0x100000000) >>> 0);
+  view.setUint8(6, (view.getUint8(6) & 0xf) | 0x40);
+  view.setUint8(8, (view.getUint8(8) & 0x3f) | 0x80);
+  return `${ho(view.getUint32(0), 8)}-${ho(view.getUint16(4), 4)}-${ho(view.getUint16(6), 4)}-${ho(
+    view.getUint16(8),
+    4
+  )}-${ho(view.getUint32(10), 8)}${ho(view.getUint16(14), 4)}`;
+}

package/src/random-stream-seed.ts

@@ -0,0 +1,18 @@
+import { encode } from '@temporalio/common/lib/encoding';
+
+const RANDOM_STREAM_SEED_PREFIX = Array.from(encode('temporal-workflow-random-stream-v1'));
+
+function encodeU32(value: number): number[] {
+  return [(value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff];
+}
+
+export function deriveAleaSeed(seed: number[], namespace: string): number[] {
+  const namespaceBytes = Array.from(encode(namespace));
+  return [
+    ...RANDOM_STREAM_SEED_PREFIX,
+    ...encodeU32(seed.length),
+    ...seed,
+    ...encodeU32(namespaceBytes.length),
+    ...namespaceBytes,
+  ];
+}

package/src/random-streams.ts

@@ -0,0 +1,132 @@
+import { assertInWorkflowContext } from './global-attributes';
+import type { Activator } from './internals';
+import { fillWithRandom, uuid4FromRandom } from './random-helpers';
+
+/**
+ * A deterministic PRNG stream scoped to the current Workflow execution.
+ *
+ * Workflow code already gets a deterministic default stream through `Math.random()`.
+ * This interface exposes additional named streams that are derived from the workflow
+ * seed without consuming that default stream. Repeated calls to
+ * {@link getRandomStream} with the same name refer to the same logical stream state
+ * for the current workflow execution, and that state is preserved across activations.
+ *
+ * The primary use case is workflow plugins and interceptors that need private,
+ * replay-stable entropy without perturbing user workflow randomness.
+ *
+ * @experimental This API may be removed or changed in the future.
+ */
+export interface WorkflowRandomStream {
+  /**
+   * Draw the next deterministic pseudo-random number from this stream.
+   *
+   * This is equivalent to `Math.random()`, but isolated from the workflow's main
+   * random stream and from other named streams.
+   */
+  random(): number;
+
+  /**
+   * Generate a deterministic UUIDv4 backed by this stream.
+   */
+  uuid4(): string;
+
+  /**
+   * Fill a byte array deterministically from this stream.
+   */
+  fill(bytes: Uint8Array): Uint8Array;
+
+  /**
+   * Run `fn` with scoped workflow-random helpers such as `Math.random()` and `uuid4()`
+   * routed through this stream.
+   *
+   * This is the scoped override API for workflow random streams. It is intended for
+   * bounded plugin/interceptor code that needs existing calls to `Math.random()` or
+   * `uuid4()` to use this stream without perturbing the workflow's default random
+   * sequence or any other named stream.
+   *
+   * The override follows async continuations started by `fn`. Workflow interceptor
+   * `next(...)` continuations restore the downstream workflow random scope before
+   * entering the rest of the interceptor chain or workflow code, so a temporary
+   * plugin scope does not leak downstream unless that downstream code explicitly
+   * establishes its own scope.
+   *
+   * Prefer explicit `stream.random()` / `stream.uuid4()` calls when that is practical.
+   * Use `stream.with(...)` when a temporary scoped override is the better fit, or
+   * when you want to keep the stream instance in module scope and reuse it directly.
+   */
+  with<T>(fn: () => T): T;
+}
+
+class ActivatorRandomStream implements WorkflowRandomStream {
+  constructor(
+    protected readonly activator: Activator,
+    protected readonly name: string
+  ) {}
+
+  random(): number {
+    return this.activator.getNamedRandom(this.name)();
+  }
+
+  uuid4(): string {
+    return uuid4FromRandom(() => this.random());
+  }
+
+  fill(bytes: Uint8Array): Uint8Array {
+    return fillWithRandom(() => this.random(), bytes);
+  }
+
+  with<T>(fn: () => T): T {
+    return this.activator.withCurrentRandom(this, fn);
+  }
+}
+
+class DefaultWorkflowRandomStream implements WorkflowRandomStream {
+  random(): number {
+    return assertInWorkflowContext('Workflow.workflowRandom may only be used from workflow context.').random();
+  }
+
+  uuid4(): string {
+    return uuid4FromRandom(() => this.random());
+  }
+
+  fill(bytes: Uint8Array): Uint8Array {
+    return fillWithRandom(() => this.random(), bytes);
+  }
+
+  with<T>(fn: () => T): T {
+    const activator = assertInWorkflowContext('Workflow.workflowRandom may only be used from workflow context.');
+    return activator.withCurrentRandom(this, fn);
+  }
+}
+
+/**
+ * The default deterministic random stream for the current workflow execution.
+ *
+ * This exposes the same underlying sequence used by workflow-level `Math.random()`
+ * when no named override is active. It can be useful for plugin/interceptor code
+ * that wants an explicit handle to the main workflow random stream, including from
+ * inside a temporary named scope established by another `WorkflowRandomStream`.
+ *
+ * @experimental This API may be removed or changed in the future.
+ */
+export const workflowRandom: WorkflowRandomStream = new DefaultWorkflowRandomStream();
+
+/**
+ * Get a named deterministic random stream for the current workflow execution.
+ *
+ * Named streams are derived from the workflow seed and a stable stream name,
+ * without consuming the workflow's default `Math.random()` stream. Repeated
+ * calls with the same `name` within a workflow execution refer to the same
+ * logical stream state, including across activations.
+ *
+ * This is the preferred entry point for workflow plugins and interceptors that
+ * need their own deterministic entropy. Use stable package- or module-style
+ * names so the stream identity remains replay-safe, then keep the returned
+ * `WorkflowRandomStream` around and call its methods directly.
+ *
+ * @experimental This API may be removed or changed in the future.
+ */
+export function getRandomStream(name: string): WorkflowRandomStream {
+  const activator = assertInWorkflowContext('Workflow.getRandomStream(...) may only be used from workflow context.');
+  return new ActivatorRandomStream(activator, name);
+}

package/src/worker-interface.ts

@@ -5,11 +5,11 @@
  */
 import type { WorkflowFunctionWithOptions } from '@temporalio/common';
 import { encodeVersioningBehavior, IllegalStateError } from '@temporalio/common';
-import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import type { coresdk } from '@temporalio/proto';
 import type { WorkflowInterceptorsFactory } from './interceptors';
 import type { WorkflowCreateOptionsInternal } from './interfaces';
 import { Activator } from './internals';
+import { composeInterceptors } from './interceptor-composition';
 import { setActivator, getActivator, maybeGetActivator } from './global-attributes';
 
 // Export the type for use on the "worker" side
@@ -91,6 +91,8 @@ export function initRuntime(options: WorkflowCreateOptionsInternal): void {
     if (isWorkflowFunctionWithOptions(activator.workflow)) {
       if (typeof activator.workflow.workflowDefinitionOptions === 'object') {
         activator.versioningBehavior = activator.workflow.workflowDefinitionOptions.versioningBehavior;
+        activator.workflowDefinitionFailureExceptionTypes =
+          activator.workflow.workflowDefinitionOptions.failureExceptionTypes;
       } else {
         activator.workflowDefinitionOptionsGetter = activator.workflow.workflowDefinitionOptions;
       }

package/src/workflow.ts

@@ -1,5 +1,6 @@
 import type {
   ActivityFunction,
+  ActivitySerializationContext,
   ActivityOptions,
   LocalActivityOptions,
   QueryDefinition,
@@ -10,6 +11,7 @@ import type {
   UpdateDefinition,
   WithWorkflowArgs,
   Workflow,
+  WorkflowSerializationContext,
   WorkflowResultType,
   WorkflowReturnType,
   WorkflowUpdateValidatorType,
@@ -24,9 +26,9 @@ import {
   extractWorkflowType,
   HandlerUnfinishedPolicy,
   mapToPayloads,
-  toPayloads,
-  TypedSearchAttributes,
   encodeInitialVersioningBehavior,
+  toPayloadsWithContext,
+  TypedSearchAttributes,
 } from '@temporalio/common';
 import { userMetadataToPayload } from '@temporalio/common/lib/user-metadata';
 import {
@@ -36,11 +38,11 @@ import {
 import { versioningIntentToProto } from '@temporalio/common/lib/versioning-intent-enum';
 import type { Duration } from '@temporalio/common/lib/time';
 import { msOptionalToTs, msToNumber, msToTs, requiredTsToMs } from '@temporalio/common/lib/time';
-import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import type { temporal } from '@temporalio/proto';
 import { deepMerge } from '@temporalio/common/lib/internal-workflow';
 import { throwIfReservedName } from '@temporalio/common/lib/reserved';
 import { CancellationScope, registerSleepImplementation } from './cancellation-scope';
+import { composeInterceptors } from './interceptor-composition';
 import { UpdateScope } from './update-scope';
 import type {
   ActivityInput,
@@ -73,12 +75,43 @@ import {
 } from './interfaces';
 import { LocalActivityDoBackoff } from './errors';
 import { assertInWorkflowContext, getActivator, maybeGetActivator } from './global-attributes';
+import { uuid4FromRandom } from './random-helpers';
 import { untrackPromise } from './stack-helpers';
 import type { ChildWorkflowHandle, ExternalWorkflowHandle } from './workflow-handle';
 
 // Avoid a circular dependency
 registerSleepImplementation(sleep);
 
+function currentWorkflowSerializationContext(info: WorkflowInfo): WorkflowSerializationContext {
+  return {
+    type: 'workflow',
+    namespace: info.namespace,
+    workflowId: info.workflowId,
+  };
+}
+
+function targetWorkflowSerializationContext(info: WorkflowInfo, workflowId: string): WorkflowSerializationContext {
+  return {
+    type: 'workflow',
+    namespace: info.namespace,
+    workflowId,
+  };
+}
+
+function activitySerializationContext(
+  info: WorkflowInfo,
+  activityId: string | undefined,
+  isLocal: boolean
+): ActivitySerializationContext {
+  return {
+    type: 'activity',
+    namespace: info.namespace,
+    activityId,
+    workflowId: info.workflowId,
+    isLocal,
+  };
+}
+
 /**
  * Adds default values of `workflowId` and `cancellationType` to given workflow options.
  */
@@ -99,6 +132,7 @@ export function addDefaultWorkflowOptions<T extends Workflow>(
  */
 function timerNextHandler({ seq, durationMs, options }: TimerInput) {
   const activator = getActivator();
+  const context = currentWorkflowSerializationContext(activator.info);
   return new Promise<void>((resolve, reject) => {
     const scope = CancellationScope.current();
     if (scope.consideredCancelled) {
@@ -125,7 +159,7 @@ function timerNextHandler({ seq, durationMs, options }: TimerInput) {
         seq,
         startToFireTimeout: msToTs(durationMs),
       },
-      userMetadata: userMetadataToPayload(activator.payloadConverter, options?.summary, undefined),
+      userMetadata: userMetadataToPayload(activator.payloadConverter, options?.summary, undefined, context),
     });
     activator.completions.timer.set(seq, {
       resolve,
@@ -173,6 +207,8 @@ const validateLocalActivityOptions = validateActivityOptions;
 function scheduleActivityNextHandler({ options, args, headers, seq, activityType }: ActivityInput): Promise<unknown> {
   const activator = getActivator();
   validateActivityOptions(options);
+  const activityId = options.activityId ?? `${seq}`;
+  const context = activitySerializationContext(activator.info, activityId, false);
   return new Promise((resolve, reject) => {
     const scope = CancellationScope.current();
     if (scope.consideredCancelled) {
@@ -196,9 +232,9 @@ function scheduleActivityNextHandler({ options, args, headers, seq, activityType
     activator.pushCommand({
       scheduleActivity: {
         seq,
-        activityId: options.activityId ?? `${seq}`,
+        activityId,
         activityType,
-        arguments: toPayloads(activator.payloadConverter, ...args),
+        arguments: toPayloadsWithContext(activator.payloadConverter, context, args),
         retryPolicy: options.retry ? compileRetryPolicy(options.retry) : undefined,
         taskQueue: options.taskQueue || activator.info.taskQueue,
         heartbeatTimeout: msOptionalToTs(options.heartbeatTimeout),
@@ -208,14 +244,15 @@ function scheduleActivityNextHandler({ options, args, headers, seq, activityType
         headers,
         cancellationType: encodeActivityCancellationType(options.cancellationType),
         doNotEagerlyExecute: !(options.allowEagerDispatch ?? true),
-        versioningIntent: versioningIntentToProto(options.versioningIntent), // eslint-disable-line @typescript-eslint/no-deprecated
+        versioningIntent: versioningIntentToProto(options.versioningIntent),
         priority: options.priority ? compilePriority(options.priority) : undefined,
       },
-      userMetadata: userMetadataToPayload(activator.payloadConverter, options.summary, undefined),
+      userMetadata: userMetadataToPayload(activator.payloadConverter, options.summary, undefined, context),
     });
     activator.completions.activity.set(seq, {
       resolve,
       reject,
+      context,
     });
   });
 }
@@ -233,6 +270,8 @@ async function scheduleLocalActivityNextHandler({
   originalScheduleTime,
 }: LocalActivityInput): Promise<unknown> {
   const activator = getActivator();
+  const activityId = `${seq}`;
+  const context = activitySerializationContext(activator.info, activityId, true);
   // Eagerly fail the local activity (which will in turn fail the workflow task.
   // Do not fail on replay where the local activities may not be registered on the replay worker.
   if (!activator.info.unsafe.isReplaying && !activator.registeredActivityNames.has(activityType)) {
@@ -265,10 +304,9 @@ async function scheduleLocalActivityNextHandler({
         seq,
         attempt,
         originalScheduleTime,
-        // Intentionally not exposing activityId as an option
-        activityId: `${seq}`,
+        activityId,
         activityType,
-        arguments: toPayloads(activator.payloadConverter, ...args),
+        arguments: toPayloadsWithContext(activator.payloadConverter, context, args),
         retryPolicy: options.retry ? compileRetryPolicy(options.retry) : undefined,
         scheduleToCloseTimeout: msOptionalToTs(options.scheduleToCloseTimeout),
         startToCloseTimeout: msOptionalToTs(options.startToCloseTimeout),
@@ -277,11 +315,12 @@ async function scheduleLocalActivityNextHandler({
         headers,
         cancellationType: encodeActivityCancellationType(options.cancellationType),
       },
-      userMetadata: userMetadataToPayload(activator.payloadConverter, options.summary, undefined),
+      userMetadata: userMetadataToPayload(activator.payloadConverter, options.summary, undefined, context),
     });
     activator.completions.activity.set(seq, {
       resolve,
       reject,
+      context,
     });
   });
 }
@@ -369,6 +408,7 @@ function startChildWorkflowExecutionNextHandler({
 }: StartChildWorkflowExecutionInput): Promise<[Promise<string>, Promise<unknown>]> {
   const activator = getActivator();
   const workflowId = options.workflowId ?? uuid4();
+  const context = targetWorkflowSerializationContext(activator.info, workflowId);
   const startPromise = new Promise<string>((resolve, reject) => {
     const scope = CancellationScope.current();
     if (scope.consideredCancelled) {
@@ -394,7 +434,7 @@ function startChildWorkflowExecutionNextHandler({
         seq,
         workflowId,
         workflowType,
-        input: toPayloads(activator.payloadConverter, ...options.args),
+        input: toPayloadsWithContext(activator.payloadConverter, context, options.args),
         retryPolicy: options.retry ? compileRetryPolicy(options.retry) : undefined,
         taskQueue: options.taskQueue || activator.info.taskQueue,
         workflowExecutionTimeout: msOptionalToTs(options.workflowExecutionTimeout),
@@ -407,18 +447,24 @@ function startChildWorkflowExecutionNextHandler({
         parentClosePolicy: encodeParentClosePolicy(options.parentClosePolicy),
         cronSchedule: options.cronSchedule,
         searchAttributes:
-          options.searchAttributes || options.typedSearchAttributes // eslint-disable-line @typescript-eslint/no-deprecated
-            ? { indexedFields: encodeUnifiedSearchAttributes(options.searchAttributes, options.typedSearchAttributes) } // eslint-disable-line @typescript-eslint/no-deprecated
+          options.searchAttributes || options.typedSearchAttributes
+            ? { indexedFields: encodeUnifiedSearchAttributes(options.searchAttributes, options.typedSearchAttributes) }
             : undefined,
-        memo: options.memo && mapToPayloads(activator.payloadConverter, options.memo),
-        versioningIntent: versioningIntentToProto(options.versioningIntent), // eslint-disable-line @typescript-eslint/no-deprecated
+        memo: options.memo && mapToPayloads(activator.payloadConverter, options.memo, context),
+        versioningIntent: versioningIntentToProto(options.versioningIntent),
         priority: options.priority ? compilePriority(options.priority) : undefined,
       },
-      userMetadata: userMetadataToPayload(activator.payloadConverter, options?.staticSummary, options?.staticDetails),
+      userMetadata: userMetadataToPayload(
+        activator.payloadConverter,
+        options?.staticSummary,
+        options?.staticDetails,
+        context
+      ),
     });
     activator.completions.childWorkflowStart.set(seq, {
       resolve,
       reject,
+      context,
     });
   });
 
@@ -430,6 +476,7 @@ function startChildWorkflowExecutionNextHandler({
     activator.completions.childWorkflowComplete.set(seq, {
       resolve,
       reject,
+      context,
     });
   });
   untrackPromise(startPromise);
@@ -443,6 +490,8 @@ function startChildWorkflowExecutionNextHandler({
 
 function signalWorkflowNextHandler({ seq, signalName, args, target, headers }: SignalWorkflowInput) {
   const activator = getActivator();
+  const targetWorkflowId = target.type === 'external' ? target.workflowExecution.workflowId : target.childWorkflowId;
+  const context = targetWorkflowSerializationContext(activator.info, targetWorkflowId!);
   return new Promise<any>((resolve, reject) => {
     const scope = CancellationScope.current();
     if (scope.consideredCancelled) {
@@ -463,7 +512,7 @@ function signalWorkflowNextHandler({ seq, signalName, args, target, headers }: S
     activator.pushCommand({
       signalExternalWorkflowExecution: {
         seq,
-        args: toPayloads(activator.payloadConverter, ...args),
+        args: toPayloadsWithContext(activator.payloadConverter, context, args),
         headers,
         signalName,
         ...(target.type === 'external'
@@ -479,7 +528,7 @@ function signalWorkflowNextHandler({ seq, signalName, args, target, headers }: S
       },
     });
 
-    activator.completions.signalWorkflow.set(seq, { resolve, reject });
+    activator.completions.signalWorkflow.set(seq, { resolve, reject, context });
   });
 }
 
@@ -526,7 +575,7 @@ export type ActivityFunctionWithOptions<T extends ActivityFunction> = T & {
    * provided options.
    *
    * @param options ActivityOptions
-   * @param args: list of arguments
+   * @param args list of arguments
    * @returns return value of the activity
    *
    * @experimental executeWithOptions is a new method to provide call-site options and is subject to change
@@ -547,7 +596,7 @@ export type LocalActivityFunctionWithOptions<T extends ActivityFunction> = T & {
    * provided options.
    *
    * @param options LocalActivityOptions
-   * @param args: list of arguments
+   * @param args list of arguments
    * @returns return value of the activity
    *
    * @experimental executeWithOptions is a new method to provide call-site options and is subject to change
@@ -735,7 +784,11 @@ export function getExternalWorkflowHandle(workflowId: string, runId?: string): E
             },
           },
         });
-        activator.completions.cancelWorkflow.set(seq, { resolve, reject });
+        activator.completions.cancelWorkflow.set(seq, {
+          resolve,
+          reject,
+          context: targetWorkflowSerializationContext(activator.info, workflowId),
+        });
       });
     },
     signal<Args extends any[]>(def: SignalDefinition<Args> | string, ...args: Args): Promise<void> {
@@ -1015,21 +1068,22 @@ export function makeContinueAsNewFunc<F extends Workflow>(
   };
 
   return (...args: Parameters<F>): Promise<never> => {
+    const context = currentWorkflowSerializationContext(info);
     const fn = composeInterceptors(activator.interceptors.outbound, 'continueAsNew', async (input) => {
       const { headers, args, options } = input;
       throw new ContinueAsNew({
         workflowType: options.workflowType,
-        arguments: toPayloads(activator.payloadConverter, ...args),
+        arguments: toPayloadsWithContext(activator.payloadConverter, context, args),
         headers,
         taskQueue: options.taskQueue,
-        memo: options.memo && mapToPayloads(activator.payloadConverter, options.memo),
+        memo: options.memo && mapToPayloads(activator.payloadConverter, options.memo, context),
         searchAttributes:
-          options.searchAttributes || options.typedSearchAttributes // eslint-disable-line @typescript-eslint/no-deprecated
-            ? { indexedFields: encodeUnifiedSearchAttributes(options.searchAttributes, options.typedSearchAttributes) } // eslint-disable-line @typescript-eslint/no-deprecated
+          options.searchAttributes || options.typedSearchAttributes
+            ? { indexedFields: encodeUnifiedSearchAttributes(options.searchAttributes, options.typedSearchAttributes) }
             : undefined,
         workflowRunTimeout: msOptionalToTs(options.workflowRunTimeout),
         workflowTaskTimeout: msOptionalToTs(options.workflowTaskTimeout),
-        versioningIntent: versioningIntentToProto(options.versioningIntent), // eslint-disable-line @typescript-eslint/no-deprecated
+        versioningIntent: versioningIntentToProto(options.versioningIntent),
         initialVersioningBehavior: encodeInitialVersioningBehavior(options.initialVersioningBehavior),
       });
     });
@@ -1042,7 +1096,7 @@ export function makeContinueAsNewFunc<F extends Workflow>(
 }
 
 /**
- * {@link https://docs.temporal.io/concepts/what-is-continue-as-new/ | Continues-As-New} the current Workflow Execution
+ * {@link https://docs.temporal.io/workflow-execution/continue-as-new#continue-as-new | Continues-As-New} the current Workflow Execution
  * with default options.
  *
  * Shorthand for `makeContinueAsNewFunc<F>()(...args)`. (See: {@link makeContinueAsNewFunc}.)
@@ -1070,24 +1124,8 @@ export function continueAsNew<F extends Workflow>(...args: Parameters<F>): Promi
  * See the {@link https://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid | stackoverflow discussion}.
  */
 export function uuid4(): string {
-  // Return the hexadecimal text representation of number `n`, padded with zeroes to be of length `p`
-  const ho = (n: number, p: number) => n.toString(16).padStart(p, '0');
-  // Create a view backed by a 16-byte buffer
-  const view = new DataView(new ArrayBuffer(16));
-  // Fill buffer with random values
-  view.setUint32(0, (Math.random() * 0x100000000) >>> 0);
-  view.setUint32(4, (Math.random() * 0x100000000) >>> 0);
-  view.setUint32(8, (Math.random() * 0x100000000) >>> 0);
-  view.setUint32(12, (Math.random() * 0x100000000) >>> 0);
-  // Patch the 6th byte to reflect a version 4 UUID
-  view.setUint8(6, (view.getUint8(6) & 0xf) | 0x40);
-  // Patch the 8th byte to reflect a variant 1 UUID (version 4 UUIDs are)
-  view.setUint8(8, (view.getUint8(8) & 0x3f) | 0x80);
-  // Compile the canonical textual form from the array data
-  return `${ho(view.getUint32(0), 8)}-${ho(view.getUint16(4), 4)}-${ho(view.getUint16(6), 4)}-${ho(
-    view.getUint16(8),
-    4
-  )}-${ho(view.getUint32(10), 8)}${ho(view.getUint16(14), 4)}`;
+  const activator = maybeGetActivator();
+  return uuid4FromRandom(activator ? () => activator.currentRandom() : Math.random);
 }
 
 /**
@@ -1516,7 +1554,6 @@ export function setDefaultQueryHandler(handler: DefaultQueryHandler | undefined)
  * If using SearchAttributeUpdatePair[] (preferred), set a value to null to remove the search attribute.
  * If using SearchAttributes (deprecated), set a value to undefined or an empty list to remove the search attribute.
  */
-// eslint-disable-next-line @typescript-eslint/no-deprecated
 export function upsertSearchAttributes(searchAttributes: SearchAttributes | SearchAttributeUpdatePair[]): void {
   const activator = assertInWorkflowContext(
     'Workflow.upsertSearchAttributes(...) may only be used from a Workflow Execution.'
@@ -1538,7 +1575,7 @@ export function upsertSearchAttributes(searchAttributes: SearchAttributes | Sear
 
     activator.mutateWorkflowInfo((info: WorkflowInfo): WorkflowInfo => {
       // Create a copy of the current state.
-      const newSearchAttributes: SearchAttributes = { ...info.searchAttributes }; // eslint-disable-line @typescript-eslint/no-deprecated
+      const newSearchAttributes: SearchAttributes = { ...info.searchAttributes };
       for (const pair of searchAttributes) {
         if (pair.value == null) {
           // If the value is null, remove the search attribute.
@@ -1547,7 +1584,7 @@ export function upsertSearchAttributes(searchAttributes: SearchAttributes | Sear
         } else {
           newSearchAttributes[pair.key.name] = Array.isArray(pair.value)
             ? pair.value
-            : ([pair.value] as SearchAttributeValue); // eslint-disable-line @typescript-eslint/no-deprecated
+            : ([pair.value] as SearchAttributeValue);
         }
       }
       return {
@@ -1570,7 +1607,7 @@ export function upsertSearchAttributes(searchAttributes: SearchAttributes | Sear
     activator.mutateWorkflowInfo((info: WorkflowInfo): WorkflowInfo => {
       // Create a new copy of the current state.
       let typedSearchAttributes = info.typedSearchAttributes.updateCopy([]);
-      const newSearchAttributes: SearchAttributes = { ...info.searchAttributes }; // eslint-disable-line @typescript-eslint/no-deprecated
+      const newSearchAttributes: SearchAttributes = { ...info.searchAttributes };
 
       // Upsert legacy search attributes into typedSearchAttributes.
       for (const [k, v] of Object.entries(searchAttributes)) {
@@ -1675,6 +1712,7 @@ export function upsertSearchAttributes(searchAttributes: SearchAttributes | Sear
  */
 export function upsertMemo(memo: Record<string, unknown>): void {
   const activator = assertInWorkflowContext('Workflow.upsertMemo(...) may only be used from a Workflow Execution.');
+  const context = currentWorkflowSerializationContext(activator.info);
 
   if (memo == null) {
     throw new Error('memo must be a non-null Record');
@@ -1686,7 +1724,8 @@ export function upsertMemo(memo: Record<string, unknown>): void {
         fields: mapToPayloads(
           activator.payloadConverter,
           // Convert null to undefined
-          Object.fromEntries(Object.entries(memo).map(([k, v]) => [k, v ?? undefined]))
+          Object.fromEntries(Object.entries(memo).map(([k, v]) => [k, v ?? undefined])),
+          context
         ),
       },
     },
@@ -1728,7 +1767,10 @@ export function allHandlersFinished(): boolean {
  * @example
  * For example:
  * ```ts
- * setWorkflowOptions({ versioningBehavior: 'PINNED' }, myWorkflow);
+ * setWorkflowOptions({
+ *   versioningBehavior: 'PINNED',
+ *   failureExceptionTypes: [CustomWorkflowError]
+ * }, myWorkflow);
  * export async function myWorkflow(): Promise<string> {
  *   // Workflow code here
  *   return "hi";
@@ -1742,7 +1784,10 @@ export function allHandlersFinished(): boolean {
  *   // Workflow code here
  *   return "hi";
  * }
- * setWorkflowOptions({ versioningBehavior: 'PINNED' }, module.exports.default);
+ * setWorkflowOptions({
+ *   versioningBehavior: 'PINNED',
+ *   failureExceptionTypes: [CustomWorkflowError]
+ * }, module.exports.default);
  * ```
  *
  * @param options Options for the workflow defintion, or a function that returns options. If a