@temporalio/workflow 1.4.4 → 1.5.1

package/src/internals.ts

@@ -1,29 +1,35 @@
-import { defaultFailureConverter, FailureConverter, PayloadConverter } from '@temporalio/common';
 import type { RawSourceMap } from 'source-map';
 import {
+  defaultFailureConverter,
+  FailureConverter,
+  PayloadConverter,
   arrayFromPayloads,
   defaultPayloadConverter,
   ensureTemporalFailure,
   IllegalStateError,
   TemporalFailure,
   Workflow,
+  WorkflowExecutionAlreadyStartedError,
   WorkflowQueryType,
   WorkflowSignalType,
+  ProtoFailure,
 } from '@temporalio/common';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { checkExtends } from '@temporalio/common/lib/type-helpers';
 import type { coresdk } from '@temporalio/proto';
 import { alea, RNG } from './alea';
-import { ROOT_SCOPE } from './cancellation-scope';
-import { DeterminismViolationError, isCancellation, WorkflowExecutionAlreadyStartedError } from './errors';
+import { RootCancellationScope } from './cancellation-scope';
+import { DeterminismViolationError, isCancellation } from './errors';
+import { QueryInput, SignalInput, WorkflowExecuteInput, WorkflowInterceptors } from './interceptors';
 import {
-  QueryInput,
-  SignalInput,
-  WorkflowExecuteInput,
-  WorkflowInterceptors,
-  WorkflowInterceptorsFactory,
-} from './interceptors';
-import { ContinueAsNew, SDKInfo, FileSlice, EnhancedStackTrace, FileLocation, WorkflowInfo } from './interfaces';
+  ContinueAsNew,
+  SDKInfo,
+  FileSlice,
+  EnhancedStackTrace,
+  FileLocation,
+  WorkflowInfo,
+  WorkflowCreateOptionsWithSourceMap,
+} from './interfaces';
 import { SinkCall } from './sinks';
 import { untrackPromise } from './stack-helpers';
 import pkg from './pkg';
@@ -49,12 +55,9 @@ export interface PromiseStackStore {
   promiseToStack: Map<Promise<unknown>, Stack>;
 }
 
-export type ResolveFunction<T = any> = (val: T) => any;
-export type RejectFunction<E = any> = (val: E) => any;
-
 export interface Completion {
-  resolve: ResolveFunction;
-  reject: RejectFunction;
+  resolve(val: unknown): unknown;
+  reject(reason: unknown): unknown;
 }
 
 export interface Condition {
@@ -74,15 +77,278 @@ export type ActivationHandlerFunction<K extends keyof coresdk.workflow_activatio
   activation: NonNullable<coresdk.workflow_activation.IWorkflowActivationJob[K]>
 ) => void;
 
+/**
+ * Verifies all activation job handling methods are implemented
+ */
 export type ActivationHandler = {
   [P in keyof coresdk.workflow_activation.IWorkflowActivationJob]: ActivationHandlerFunction<P>;
 };
 
+/**
+ * SDK Internal Patches are created by the SDK to avoid breaking history when behaviour
+ * of existing API need to be modified. This is the patch number supported by the current
+ * version of the SDK.
+ *
+ * History:
+ * 1: Fix `condition(..., 0)` is not the same as `condition(..., undefined)`
+ */
+export const LATEST_INTERNAL_PATCH_NUMBER = 1;
+
+/**
+ * Keeps all of the Workflow runtime state like pending completions for activities and timers.
+ *
+ * Implements handlers for all workflow activation jobs.
+ */
 export class Activator implements ActivationHandler {
-  workflowFunctionWasCalled = false;
+  /**
+   * Map of task sequence to a Completion
+   */
+  readonly completions = {
+    timer: new Map<number, Completion>(),
+    activity: new Map<number, Completion>(),
+    childWorkflowStart: new Map<number, Completion>(),
+    childWorkflowComplete: new Map<number, Completion>(),
+    signalWorkflow: new Map<number, Completion>(),
+    cancelWorkflow: new Map<number, Completion>(),
+  };
+
+  /**
+   * Holds buffered signal calls until a handler is registered
+   */
+  readonly bufferedSignals = new Map<string, coresdk.workflow_activation.ISignalWorkflow[]>();
+
+  /**
+   * Holds buffered query calls until a handler is registered.
+   *
+   * **IMPORTANT** queries are only buffered until workflow is started.
+   * This is required because async interceptors might block workflow function invocation
+   * which delays query handler registration.
+   */
+  protected readonly bufferedQueries = Array<coresdk.workflow_activation.IQueryWorkflow>();
+
+  /**
+   * Mapping of signal name to handler
+   */
+  readonly signalHandlers = new Map<string, WorkflowSignalType>();
+
+  /**
+   * Source map file for looking up the source files in response to __enhanced_stack_trace
+   */
+  protected readonly sourceMap: RawSourceMap;
+
+  /**
+   * Whether or not to send the sources in enhanced stack trace query responses
+   */
+  protected readonly showStackTraceSources;
+
+  protected readonly promiseStackStore: PromiseStackStore = {
+    promiseToStack: new Map(),
+    childToParent: new Map(),
+  };
+
+  public readonly rootScope = new RootCancellationScope();
+
+  /**
+   * Mapping of query name to handler
+   */
+  public readonly queryHandlers = new Map<string, WorkflowQueryType>([
+    [
+      '__stack_trace',
+      () => {
+        return this.getStackTraces()
+          .map((s) => s.formatted)
+          .join('\n\n');
+      },
+    ],
+    [
+      '__enhanced_stack_trace',
+      (): EnhancedStackTrace => {
+        const { sourceMap } = this;
+        const sdk: SDKInfo = { name: 'typescript', version: pkg.version };
+        const stacks = this.getStackTraces().map(({ structured: locations }) => ({ locations }));
+        const sources: Record<string, FileSlice[]> = {};
+        if (this.showStackTraceSources) {
+          for (const { locations } of stacks) {
+            for (const { filePath } of locations) {
+              if (!filePath) continue;
+              const content = sourceMap?.sourcesContent?.[sourceMap?.sources.indexOf(filePath)];
+              if (!content) continue;
+              sources[filePath] = [
+                {
+                  content,
+                  lineOffset: 0,
+                },
+              ];
+            }
+          }
+        }
+        return { sdk, stacks, sources };
+      },
+    ],
+  ]);
+
+  /**
+   * Loaded in {@link initRuntime}
+   */
+  public readonly interceptors: Required<WorkflowInterceptors> = { inbound: [], outbound: [], internals: [] };
+
+  /**
+   * Buffer that stores all generated commands, reset after each activation
+   */
+  protected commands: coresdk.workflow_commands.IWorkflowCommand[] = [];
+
+  /**
+   * Stores all {@link condition}s that haven't been unblocked yet
+   */
+  public readonly blockedConditions = new Map<number, Condition>();
+
+  /**
+   * Is this Workflow completed?
+   *
+   * A Workflow will be considered completed if it generates a command that the
+   * system considers as a final Workflow command (e.g.
+   * completeWorkflowExecution or failWorkflowExecution).
+   */
+  public completed = false;
+
+  /**
+   * Was this Workflow cancelled?
+   */
+  protected cancelled = false;
+
+  /**
+   * This is tracked to allow buffering queries until a workflow function is called.
+   * TODO(bergundy): I don't think this makes sense since queries run last in an activation and must be responded to in
+   * the same activation.
+   */
+  protected workflowFunctionWasCalled = false;
+
+  /**
+   * The next (incremental) sequence to assign when generating completable commands
+   */
+  public nextSeqs = {
+    timer: 1,
+    activity: 1,
+    childWorkflow: 1,
+    signalWorkflow: 1,
+    cancelWorkflow: 1,
+    condition: 1,
+    // Used internally to keep track of active stack traces
+    stack: 1,
+  };
+
+  /**
+   * This is set every time the workflow executes an activation
+   */
+  now: number;
+
+  /**
+   * Reference to the current Workflow, initialized when a Workflow is started
+   */
+  public workflow?: Workflow;
+
+  /**
+   * Information about the current Workflow
+   */
+  public readonly info: WorkflowInfo;
+
+  /**
+   * A deterministic RNG, used by the isolate's overridden Math.random
+   */
+  public random: RNG;
+
+  public payloadConverter: PayloadConverter = defaultPayloadConverter;
+  public failureConverter: FailureConverter = defaultFailureConverter;
+
+  /**
+   * Patches we know the status of for this workflow, as in {@link patched}
+   */
+  public readonly knownPresentPatches = new Set<string>();
+
+  /**
+   * Patches we sent to core {@link patched}
+   */
+  public readonly sentPatches = new Set<string>();
+
+  /**
+   * SDK Internal Patches are created by the SDK to avoid breaking history when behaviour
+   * of existing API need to be modified.
+   */
+  public internalPatchNumber = 0;
+
+  sinkCalls = Array<SinkCall>();
+
+  constructor({
+    info,
+    now,
+    showStackTraceSources,
+    sourceMap,
+    randomnessSeed,
+    patches,
+  }: WorkflowCreateOptionsWithSourceMap) {
+    this.info = info;
+    this.now = now;
+    this.showStackTraceSources = showStackTraceSources;
+    this.sourceMap = sourceMap;
+    this.random = alea(randomnessSeed);
+
+    if (info.unsafe.isReplaying) {
+      for (const patch of patches) {
+        this.knownPresentPatches.add(patch);
+      }
+    }
+  }
+
+  protected getStackTraces(): Stack[] {
+    const { childToParent, promiseToStack } = this.promiseStackStore;
+    const internalNodes = [...childToParent.values()].reduce((acc, curr) => {
+      for (const p of curr) {
+        acc.add(p);
+      }
+      return acc;
+    }, new Set());
+    const stacks = new Map<string, Stack>();
+    for (const child of childToParent.keys()) {
+      if (!internalNodes.has(child)) {
+        const stack = promiseToStack.get(child);
+        if (!stack || !stack.formatted) continue;
+        stacks.set(stack.formatted, stack);
+      }
+    }
+    // Not 100% sure where this comes from, just filter it out
+    stacks.delete('    at Promise.then (<anonymous>)');
+    stacks.delete('    at Promise.then (<anonymous>)\n');
+    return [...stacks].map(([_, stack]) => stack);
+  }
+
+  getAndResetSinkCalls(): SinkCall[] {
+    const { sinkCalls } = this;
+    this.sinkCalls = [];
+    return sinkCalls;
+  }
+
+  /**
+   * Buffer a Workflow command to be collected at the end of the current activation.
+   *
+   * Prevents commands from being added after Workflow completion.
+   */
+  pushCommand(cmd: coresdk.workflow_commands.IWorkflowCommand, complete = false): void {
+    // Only query responses may be sent after completion
+    if (this.completed && !cmd.respondToQuery) return;
+    this.commands.push(cmd);
+    if (complete) {
+      this.completed = true;
+    }
+  }
+
+  getAndResetCommands(): coresdk.workflow_commands.IWorkflowCommand[] {
+    const commands = this.commands;
+    this.commands = [];
+    return commands;
+  }
 
   public async startWorkflowNextHandler({ args }: WorkflowExecuteInput): Promise<any> {
-    const { workflow } = state;
+    const { workflow } = this;
     if (workflow === undefined) {
       throw new IllegalStateError('Workflow uninitialized');
     }
@@ -94,7 +360,7 @@ export class Activator implements ActivationHandler {
       // Otherwise this Workflow will now be queryable.
       this.workflowFunctionWasCalled = true;
       // Empty the buffer
-      const buffer = state.bufferedQueries.splice(0);
+      const buffer = this.bufferedQueries.splice(0);
       for (const activation of buffer) {
         this.queryWorkflow(activation);
       }
@@ -103,32 +369,24 @@ export class Activator implements ActivationHandler {
   }
 
   public startWorkflow(activation: coresdk.workflow_activation.IStartWorkflow): void {
-    const { info } = state;
-    if (info === undefined) {
-      throw new IllegalStateError('Workflow has not been initialized');
-    }
-    const execute = composeInterceptors(
-      state.interceptors.inbound,
-      'execute',
-      this.startWorkflowNextHandler.bind(this)
-    );
+    const execute = composeInterceptors(this.interceptors.inbound, 'execute', this.startWorkflowNextHandler.bind(this));
     untrackPromise(
       execute({
         headers: activation.headers ?? {},
-        args: arrayFromPayloads(state.payloadConverter, activation.arguments),
-      }).then(completeWorkflow, handleWorkflowFailure)
+        args: arrayFromPayloads(this.payloadConverter, activation.arguments),
+      }).then(this.completeWorkflow.bind(this), this.handleWorkflowFailure.bind(this))
     );
   }
 
   public cancelWorkflow(_activation: coresdk.workflow_activation.ICancelWorkflow): void {
-    state.cancelled = true;
-    ROOT_SCOPE.cancel();
+    this.cancelled = true;
+    this.rootScope.cancel();
   }
 
   public fireTimer(activation: coresdk.workflow_activation.IFireTimer): void {
     // Timers are a special case where their completion might not be in Workflow state,
     // this is due to immediate timer cancellation that doesn't go wait for Core.
-    const completion = maybeConsumeCompletion('timer', getSeq(activation));
+    const completion = this.maybeConsumeCompletion('timer', getSeq(activation));
     completion?.resolve(undefined);
   }
 
@@ -136,18 +394,18 @@ export class Activator implements ActivationHandler {
     if (!activation.result) {
       throw new TypeError('Got ResolveActivity activation with no result');
     }
-    const { resolve, reject } = 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 ? state.payloadConverter.fromPayload(completed.result) : undefined;
+      const result = completed.result ? this.payloadConverter.fromPayload(completed.result) : undefined;
       resolve(result);
     } else if (activation.result.failed) {
       const { failure } = activation.result.failed;
-      const err = failure ? state.failureConverter.failureToError(failure) : undefined;
+      const err = failure ? this.failureToError(failure) : undefined;
       reject(err);
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
-      const err = failure ? state.failureConverter.failureToError(failure) : undefined;
+      const err = failure ? this.failureToError(failure) : undefined;
       reject(err);
     } else if (activation.result.backoff) {
       reject(new LocalActivityDoBackoff(activation.result.backoff));
@@ -157,7 +415,7 @@ export class Activator implements ActivationHandler {
   public resolveChildWorkflowExecutionStart(
     activation: coresdk.workflow_activation.IResolveChildWorkflowExecutionStart
   ): void {
-    const { resolve, reject } = consumeCompletion('childWorkflowStart', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('childWorkflowStart', getSeq(activation));
     if (activation.succeeded) {
       resolve(activation.succeeded.runId);
     } else if (activation.failed) {
@@ -181,7 +439,7 @@ export class Activator implements ActivationHandler {
       if (!activation.cancelled.failure) {
         throw new TypeError('Got no failure in cancelled variant');
       }
-      reject(state.failureConverter.failureToError(activation.cancelled.failure));
+      reject(this.failureToError(activation.cancelled.failure));
     } else {
       throw new TypeError('Got ResolveChildWorkflowExecutionStart with no status');
     }
@@ -191,34 +449,36 @@ export class Activator implements ActivationHandler {
     if (!activation.result) {
       throw new TypeError('Got ResolveChildWorkflowExecution activation with no result');
     }
-    const { resolve, reject } = 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 ? state.payloadConverter.fromPayload(completed.result) : 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 === undefined || failure === null) {
         throw new TypeError('Got failed result with no failure attribute');
       }
-      reject(state.failureConverter.failureToError(failure));
+      reject(this.failureToError(failure));
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
       if (failure === undefined || failure === null) {
         throw new TypeError('Got cancelled result with no failure attribute');
       }
-      reject(state.failureConverter.failureToError(failure));
+      reject(this.failureToError(failure));
     }
   }
 
   // Intentionally not made function async so this handler doesn't show up in the stack trace
   protected queryWorkflowNextHandler({ queryName, args }: QueryInput): Promise<unknown> {
-    const fn = state.queryHandlers.get(queryName);
+    const fn = this.queryHandlers.get(queryName);
     if (fn === undefined) {
-      const knownQueryTypes = [...state.queryHandlers.keys()].join(' ');
+      const knownQueryTypes = [...this.queryHandlers.keys()].join(' ');
       // Fail the query
-      throw new ReferenceError(
-        `Workflow did not register a handler for ${queryName}. Registered queries: [${knownQueryTypes}]`
+      return Promise.reject(
+        new ReferenceError(
+          `Workflow did not register a handler for ${queryName}. Registered queries: [${knownQueryTypes}]`
+        )
       );
     }
     try {
@@ -234,7 +494,7 @@ export class Activator implements ActivationHandler {
 
   public queryWorkflow(activation: coresdk.workflow_activation.IQueryWorkflow): void {
     if (!this.workflowFunctionWasCalled) {
-      state.bufferedQueries.push(activation);
+      this.bufferedQueries.push(activation);
       return;
     }
 
@@ -244,23 +504,23 @@ export class Activator implements ActivationHandler {
     }
 
     const execute = composeInterceptors(
-      state.interceptors.inbound,
+      this.interceptors.inbound,
       'handleQuery',
       this.queryWorkflowNextHandler.bind(this)
     );
     execute({
       queryName: queryType,
-      args: arrayFromPayloads(state.payloadConverter, activation.arguments),
+      args: arrayFromPayloads(this.payloadConverter, activation.arguments),
       queryId,
       headers: headers ?? {},
     }).then(
-      (result) => completeQuery(queryId, result),
-      (reason) => failQuery(queryId, reason)
+      (result) => this.completeQuery(queryId, result),
+      (reason) => this.failQuery(queryId, reason)
     );
   }
 
   public async signalWorkflowNextHandler({ signalName, args }: SignalInput): Promise<void> {
-    const fn = state.signalHandlers.get(signalName);
+    const fn = this.signalHandlers.get(signalName);
     if (fn === undefined) {
       throw new IllegalStateError(`No registered signal handler for signal ${signalName}`);
     }
@@ -273,33 +533,33 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing activation signalName');
     }
 
-    const fn = state.signalHandlers.get(signalName);
+    const fn = this.signalHandlers.get(signalName);
     if (fn === undefined) {
-      let buffer = state.bufferedSignals.get(signalName);
+      let buffer = this.bufferedSignals.get(signalName);
       if (buffer === undefined) {
         buffer = [];
-        state.bufferedSignals.set(signalName, buffer);
+        this.bufferedSignals.set(signalName, buffer);
       }
       buffer.push(activation);
       return;
     }
 
     const execute = composeInterceptors(
-      state.interceptors.inbound,
+      this.interceptors.inbound,
       'handleSignal',
       this.signalWorkflowNextHandler.bind(this)
     );
     execute({
-      args: arrayFromPayloads(state.payloadConverter, activation.input),
+      args: arrayFromPayloads(this.payloadConverter, activation.input),
       signalName,
       headers: headers ?? {},
-    }).catch(handleWorkflowFailure);
+    }).catch(this.handleWorkflowFailure.bind(this));
   }
 
   public resolveSignalExternalWorkflow(activation: coresdk.workflow_activation.IResolveSignalExternalWorkflow): void {
-    const { resolve, reject } = consumeCompletion('signalWorkflow', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('signalWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(state.failureConverter.failureToError(activation.failure));
+      reject(this.failureToError(activation.failure));
     } else {
       resolve(undefined);
     }
@@ -308,9 +568,9 @@ export class Activator implements ActivationHandler {
   public resolveRequestCancelExternalWorkflow(
     activation: coresdk.workflow_activation.IResolveRequestCancelExternalWorkflow
   ): void {
-    const { resolve, reject } = consumeCompletion('cancelWorkflow', getSeq(activation));
+    const { resolve, reject } = this.consumeCompletion('cancelWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(state.failureConverter.failureToError(activation.failure));
+      reject(this.failureToError(activation.failure));
     } else {
       resolve(undefined);
     }
@@ -320,331 +580,127 @@ export class Activator implements ActivationHandler {
     if (!activation.randomnessSeed) {
       throw new TypeError('Expected activation with randomnessSeed attribute');
     }
-    state.random = alea(activation.randomnessSeed.toBytes());
+    this.random = alea(activation.randomnessSeed.toBytes());
   }
 
   public notifyHasPatch(activation: coresdk.workflow_activation.INotifyHasPatch): void {
     if (!activation.patchId) {
       throw new TypeError('Notify has patch missing patch name');
     }
-    state.knownPresentPatches.add(activation.patchId);
+    if (activation.patchId.startsWith('__sdk_internal_patch_number:')) {
+      const internalPatchNumber = parseInt(activation.patchId.substring('__sdk_internal_patch_number:'.length));
+      if (internalPatchNumber > LATEST_INTERNAL_PATCH_NUMBER)
+        throw new IllegalStateError(
+          `Unsupported internal patch number: ${internalPatchNumber} > ${LATEST_INTERNAL_PATCH_NUMBER}`
+        );
+      if (this.internalPatchNumber < internalPatchNumber) this.internalPatchNumber = internalPatchNumber;
+    } else {
+      this.knownPresentPatches.add(activation.patchId);
+    }
+  }
+
+  public checkInternalPatchAtLeast(minimumPatchNumber: number): boolean {
+    if (this.internalPatchNumber >= minimumPatchNumber) return true;
+    if (!this.info.unsafe.isReplaying) {
+      this.internalPatchNumber = minimumPatchNumber;
+      this.pushCommand({
+        setPatchMarker: { patchId: `__sdk_internal_patch_number:${LATEST_INTERNAL_PATCH_NUMBER}`, deprecated: false },
+      });
+      return true;
+    }
+    return false;
   }
 
   public removeFromCache(): void {
     throw new IllegalStateError('removeFromCache activation job should not reach workflow');
   }
-}
-
-export type WorkflowsImportFunc = () => Promise<Record<string, any>>;
-export type InterceptorsImportFunc = () => Promise<Array<{ interceptors: WorkflowInterceptorsFactory }>>;
-
-/**
- * Keeps all of the Workflow runtime state like pending completions for activities and timers and the scope stack.
- *
- * State mutates each time the Workflow is activated.
- */
-export class State {
-  /**
-   * Activator executes activation jobs
-   */
-  public readonly activator = new Activator();
-
-  /**
-   * Map of task sequence to a Completion
-   */
-  public readonly completions = {
-    timer: new Map<number, Completion>(),
-    activity: new Map<number, Completion>(),
-    childWorkflowStart: new Map<number, Completion>(),
-    childWorkflowComplete: new Map<number, Completion>(),
-    signalWorkflow: new Map<number, Completion>(),
-    cancelWorkflow: new Map<number, Completion>(),
-  };
-
-  /**
-   * Holds buffered signal calls until a handler is registered
-   */
-  public readonly bufferedSignals = new Map<string, coresdk.workflow_activation.ISignalWorkflow[]>();
 
   /**
-   * Holds buffered query calls until a handler is registered.
-   *
-   * **IMPORTANT** queries are only buffered until workflow is started.
-   * This is required because async interceptors might block workflow function invocation
-   * which delays query handler registration.
-   */
-  public readonly bufferedQueries = Array<coresdk.workflow_activation.IQueryWorkflow>();
-
-  /**
-   * Mapping of signal name to handler
+   * Transforms failures into a command to be sent to the server.
+   * Used to handle any failure emitted by the Workflow.
    */
-  public readonly signalHandlers = new Map<string, WorkflowSignalType>();
-
-  /**
-   * Source map file for looking up the source files in response to __enhanced_stack_trace
-   */
-  public sourceMap: RawSourceMap | undefined;
-
-  /**
-   * Whether or not to send the sources in enhanced stack trace query responses
-   */
-  public showStackTraceSources = false;
-
-  protected getStackTraces(): Stack[] {
-    const { childToParent, promiseToStack } = (globalThis as any).__TEMPORAL__.promiseStackStore as PromiseStackStore;
-    const internalNodes = [...childToParent.values()].reduce((acc, curr) => {
-      for (const p of curr) {
-        acc.add(p);
-      }
-      return acc;
-    }, new Set());
-    const stacks = new Map<string, Stack>();
-    for (const child of childToParent.keys()) {
-      if (!internalNodes.has(child)) {
-        const stack = promiseToStack.get(child);
-        if (!stack || !stack.formatted) continue;
-        stacks.set(stack.formatted, stack);
+  async handleWorkflowFailure(error: unknown): Promise<void> {
+    if (this.cancelled && isCancellation(error)) {
+      this.pushCommand({ cancelWorkflowExecution: {} }, true);
+    } else if (error instanceof ContinueAsNew) {
+      this.pushCommand({ continueAsNewWorkflowExecution: error.command }, true);
+    } else {
+      if (!(error instanceof TemporalFailure)) {
+        // This results in an unhandled rejection which will fail the activation
+        // preventing it from completing.
+        throw error;
       }
-    }
-    // Not 100% sure where this comes from, just filter it out
-    stacks.delete('    at Promise.then (<anonymous>)');
-    stacks.delete('    at Promise.then (<anonymous>)\n');
-    return [...stacks].map(([_, stack]) => stack);
-  }
-
-  /**
-   * Mapping of query name to handler
-   */
-  public readonly queryHandlers = new Map<string, WorkflowQueryType>([
-    [
-      '__stack_trace',
-      () => {
-        return this.getStackTraces()
-          .map((s) => s.formatted)
-          .join('\n\n');
-      },
-    ],
-    [
-      '__enhanced_stack_trace',
-      (): EnhancedStackTrace => {
-        const { sourceMap } = this;
-        const sdk: SDKInfo = { name: 'typescript', version: pkg.version };
-        const stacks = this.getStackTraces().map(({ structured: locations }) => ({ locations }));
-        const sources: Record<string, FileSlice[]> = {};
-        if (this.showStackTraceSources) {
-          for (const { locations } of stacks) {
-            for (const { filePath } of locations) {
-              if (!filePath) continue;
-              const content = sourceMap?.sourcesContent?.[sourceMap?.sources.indexOf(filePath)];
-              if (!content) continue;
-              sources[filePath] = [
-                {
-                  content,
-                  lineOffset: 0,
-                },
-              ];
-            }
-          }
-        }
-        return { sdk, stacks, sources };
-      },
-    ],
-  ]);
-
-  /**
-   * Loaded in {@link initRuntime}
-   */
-  public interceptors: Required<WorkflowInterceptors> = { inbound: [], outbound: [], internals: [] };
 
-  /**
-   * Buffer that stores all generated commands, reset after each activation
-   */
-  public commands: coresdk.workflow_commands.IWorkflowCommand[] = [];
-
-  /**
-   * Stores all {@link condition}s that haven't been unblocked yet
-   */
-  public blockedConditions = new Map<number, Condition>();
-
-  /**
-   * Is this Workflow completed?
-   *
-   * A Workflow will be considered completed if it generates a command that the
-   * system considers as a final Workflow command (e.g.
-   * completeWorkflowExecution or failWorkflowExecution).
-   */
-  public completed = false;
-
-  /**
-   * Was this Workflow cancelled?
-   */
-  public cancelled = false;
-
-  /**
-   * The next (incremental) sequence to assign when generating completable commands
-   */
-  public nextSeqs = {
-    timer: 1,
-    activity: 1,
-    childWorkflow: 1,
-    signalWorkflow: 1,
-    cancelWorkflow: 1,
-    condition: 1,
-    // Used internally to keep track of active stack traces
-    stack: 1,
-  };
-
-  /**
-   * This is set every time the workflow executes an activation
-   */
-  #now: number | undefined;
-
-  get now(): number {
-    if (this.#now === undefined) {
-      throw new IllegalStateError('Tried to get Date before Workflow has been initialized');
+      this.pushCommand(
+        {
+          failWorkflowExecution: {
+            failure: this.errorToFailure(error),
+          },
+        },
+        true
+      );
     }
-    return this.#now;
   }
 
-  set now(value: number) {
-    this.#now = value;
+  private completeQuery(queryId: string, result: unknown): void {
+    this.pushCommand({
+      respondToQuery: { queryId, succeeded: { response: this.payloadConverter.toPayload(result) } },
+    });
   }
 
-  /**
-   * Reference to the current Workflow, initialized when a Workflow is started
-   */
-  public workflow?: Workflow;
-
-  /**
-   * Information about the current Workflow
-   */
-  public info?: WorkflowInfo;
-
-  /**
-   * A deterministic RNG, used by the isolate's overridden Math.random
-   */
-  public random: RNG = function () {
-    throw new IllegalStateError('Tried to use Math.random before Workflow has been initialized');
-  };
-
-  /**
-   * Used to import the user workflows
-   *
-   * Injected on isolate context startup
-   */
-  public importWorkflows?: WorkflowsImportFunc;
-
-  /**
-   * Used to import the user interceptors
-   *
-   * Injected on isolate context startup
-   */
-  public importInterceptors?: InterceptorsImportFunc;
-
-  public payloadConverter: PayloadConverter = defaultPayloadConverter;
-  public failureConverter: FailureConverter = defaultFailureConverter;
-
-  /**
-   * Patches we know the status of for this workflow, as in {@link patched}
-   */
-  public readonly knownPresentPatches = new Set<string>();
-
-  /**
-   * Patches we sent to core {@link patched}
-   */
-  public readonly sentPatches = new Set<string>();
-
-  sinkCalls = Array<SinkCall>();
-
-  getAndResetSinkCalls(): SinkCall[] {
-    const { sinkCalls } = this;
-    this.sinkCalls = [];
-    return sinkCalls;
+  private failQuery(queryId: string, error: unknown): void {
+    this.pushCommand({
+      respondToQuery: {
+        queryId,
+        failed: this.errorToFailure(ensureTemporalFailure(error)),
+      },
+    });
   }
 
-  /**
-   * Buffer a Workflow command to be collected at the end of the current activation.
-   *
-   * Prevents commands from being added after Workflow completion.
-   */
-  pushCommand(cmd: coresdk.workflow_commands.IWorkflowCommand, complete = false): void {
-    // Only query responses may be sent after completion
-    if (this.completed && !cmd.respondToQuery) return;
-    this.commands.push(cmd);
-    if (complete) {
-      this.completed = true;
+  /** Consume a completion if it exists in Workflow state */
+  private maybeConsumeCompletion(type: keyof Activator['completions'], taskSeq: number): Completion | undefined {
+    const completion = this.completions[type].get(taskSeq);
+    if (completion !== undefined) {
+      this.completions[type].delete(taskSeq);
     }
+    return completion;
   }
-}
-
-export const state = new State();
 
-function completeWorkflow(result: any) {
-  state.pushCommand(
-    {
-      completeWorkflowExecution: {
-        result: state.payloadConverter.toPayload(result),
-      },
-    },
-    true
-  );
-}
-
-/**
- * Transforms failures into a command to be sent to the server.
- * Used to handle any failure emitted by the Workflow.
- */
-export async function handleWorkflowFailure(error: unknown): Promise<void> {
-  if (state.cancelled && isCancellation(error)) {
-    state.pushCommand({ cancelWorkflowExecution: {} }, true);
-  } else if (error instanceof ContinueAsNew) {
-    state.pushCommand({ continueAsNewWorkflowExecution: error.command }, true);
-  } else {
-    if (!(error instanceof TemporalFailure)) {
-      // This results in an unhandled rejection which will fail the activation
-      // preventing it from completing.
-      throw error;
+  /** Consume a completion if it exists in Workflow state, throws if it doesn't */
+  private consumeCompletion(type: keyof Activator['completions'], taskSeq: number): Completion {
+    const completion = this.maybeConsumeCompletion(type, taskSeq);
+    if (completion === undefined) {
+      throw new IllegalStateError(`No completion for taskSeq ${taskSeq}`);
     }
+    return completion;
+  }
 
-    state.pushCommand(
+  private completeWorkflow(result: unknown): void {
+    this.pushCommand(
       {
-        failWorkflowExecution: {
-          failure: state.failureConverter.errorToFailure(error),
+        completeWorkflowExecution: {
+          result: this.payloadConverter.toPayload(result),
         },
       },
       true
     );
   }
-}
-
-function completeQuery(queryId: string, result: unknown) {
-  state.pushCommand({
-    respondToQuery: { queryId, succeeded: { response: state.payloadConverter.toPayload(result) } },
-  });
-}
 
-async function failQuery(queryId: string, error: any) {
-  state.pushCommand({
-    respondToQuery: { queryId, failed: state.failureConverter.errorToFailure(ensureTemporalFailure(error)) },
-  });
-}
+  errorToFailure(err: unknown): ProtoFailure {
+    return this.failureConverter.errorToFailure(err, this.payloadConverter);
+  }
 
-/** Consume a completion if it exists in Workflow state */
-export function maybeConsumeCompletion(type: keyof State['completions'], taskSeq: number): Completion | undefined {
-  const completion = state.completions[type].get(taskSeq);
-  if (completion !== undefined) {
-    state.completions[type].delete(taskSeq);
+  failureToError(failure: ProtoFailure): Error {
+    return this.failureConverter.failureToError(failure, this.payloadConverter);
   }
-  return completion;
 }
 
-/** Consume a completion if it exists in Workflow state, throws if it doesn't */
-export function consumeCompletion(type: keyof State['completions'], taskSeq: number): Completion {
-  const completion = maybeConsumeCompletion(type, taskSeq);
-  if (completion === undefined) {
-    throw new IllegalStateError(`No completion for taskSeq ${taskSeq}`);
+export function getActivator(): Activator {
+  const activator = (globalThis as any).__TEMPORAL__?.activator;
+  if (activator === undefined) {
+    throw new IllegalStateError('Workflow uninitialized');
   }
-  return completion;
+  return activator;
 }
 
 function getSeq<T extends { seq?: number | null }>(activation: T): number {