@temporalio/workflow 1.4.3 → 1.5.0

package/lib/internals.js

@@ -1,23 +1,10 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _State_now;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consumeCompletion = exports.maybeConsumeCompletion = exports.handleWorkflowFailure = exports.state = exports.State = exports.Activator = exports.LocalActivityDoBackoff = void 0;
+exports.getActivator = exports.Activator = exports.LATEST_INTERNAL_PATCH_NUMBER = exports.LocalActivityDoBackoff = void 0;
 const common_1 = require("@temporalio/common");
-const common_2 = require("@temporalio/common");
 const interceptors_1 = require("@temporalio/common/lib/interceptors");
 const type_helpers_1 = require("@temporalio/common/lib/type-helpers");
 const alea_1 = require("./alea");
@@ -43,14 +30,214 @@ class LocalActivityDoBackoff {
     }
 }
 exports.LocalActivityDoBackoff = LocalActivityDoBackoff;
+/**
+ * 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)`
+ */
+exports.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.
+ */
 class Activator {
-    constructor() {
+    constructor({ info, now, showStackTraceSources, sourceMap, randomnessSeed, patches, }) {
+        /**
+         * Map of task sequence to a Completion
+         */
+        this.completions = {
+            timer: new Map(),
+            activity: new Map(),
+            childWorkflowStart: new Map(),
+            childWorkflowComplete: new Map(),
+            signalWorkflow: new Map(),
+            cancelWorkflow: new Map(),
+        };
+        /**
+         * Holds buffered signal calls until a handler is registered
+         */
+        this.bufferedSignals = new Map();
+        /**
+         * 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.
+         */
+        this.bufferedQueries = Array();
+        /**
+         * Mapping of signal name to handler
+         */
+        this.signalHandlers = new Map();
+        this.promiseStackStore = {
+            promiseToStack: new Map(),
+            childToParent: new Map(),
+        };
+        this.rootScope = new cancellation_scope_1.RootCancellationScope();
+        /**
+         * Mapping of query name to handler
+         */
+        this.queryHandlers = new Map([
+            [
+                '__stack_trace',
+                () => {
+                    return this.getStackTraces()
+                        .map((s) => s.formatted)
+                        .join('\n\n');
+                },
+            ],
+            [
+                '__enhanced_stack_trace',
+                () => {
+                    const { sourceMap } = this;
+                    const sdk = { name: 'typescript', version: pkg_1.default.version };
+                    const stacks = this.getStackTraces().map(({ structured: locations }) => ({ locations }));
+                    const sources = {};
+                    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}
+         */
+        this.interceptors = { inbound: [], outbound: [], internals: [] };
+        /**
+         * Buffer that stores all generated commands, reset after each activation
+         */
+        this.commands = [];
+        /**
+         * Stores all {@link condition}s that haven't been unblocked yet
+         */
+        this.blockedConditions = new Map();
+        /**
+         * 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).
+         */
+        this.completed = false;
+        /**
+         * Was this Workflow cancelled?
+         */
+        this.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.
+         */
         this.workflowFunctionWasCalled = false;
+        /**
+         * The next (incremental) sequence to assign when generating completable commands
+         */
+        this.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.payloadConverter = common_1.defaultPayloadConverter;
+        this.failureConverter = common_1.defaultFailureConverter;
+        /**
+         * Patches we know the status of for this workflow, as in {@link patched}
+         */
+        this.knownPresentPatches = new Set();
+        /**
+         * Patches we sent to core {@link patched}
+         */
+        this.sentPatches = new Set();
+        /**
+         * SDK Internal Patches are created by the SDK to avoid breaking history when behaviour
+         * of existing API need to be modified.
+         */
+        this.internalPatchNumber = 0;
+        this.sinkCalls = Array();
+        this.info = info;
+        this.now = now;
+        this.showStackTraceSources = showStackTraceSources;
+        this.sourceMap = sourceMap;
+        this.random = (0, alea_1.alea)(randomnessSeed);
+        if (info.unsafe.isReplaying) {
+            for (const patch of patches) {
+                this.knownPresentPatches.add(patch);
+            }
+        }
+    }
+    getStackTraces() {
+        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();
+        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() {
+        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, complete = false) {
+        // Only query responses may be sent after completion
+        if (this.completed && !cmd.respondToQuery)
+            return;
+        this.commands.push(cmd);
+        if (complete) {
+            this.completed = true;
+        }
+    }
+    getAndResetCommands() {
+        const commands = this.commands;
+        this.commands = [];
+        return commands;
     }
     async startWorkflowNextHandler({ args }) {
-        const { workflow } = exports.state;
+        const { workflow } = this;
         if (workflow === undefined) {
-            throw new common_2.IllegalStateError('Workflow uninitialized');
+            throw new common_1.IllegalStateError('Workflow uninitialized');
         }
         let promise;
         try {
@@ -61,7 +248,7 @@ class Activator {
             // Otherwise this Workflow will now be queryable.
             this.workflowFunctionWasCalled = true;
             // Empty the buffer
-            const buffer = exports.state.bufferedQueries.splice(0);
+            const buffer = this.bufferedQueries.splice(0);
             for (const activation of buffer) {
                 this.queryWorkflow(activation);
             }
@@ -69,44 +256,40 @@ class Activator {
         return await promise;
     }
     startWorkflow(activation) {
-        const { info } = exports.state;
-        if (info === undefined) {
-            throw new common_2.IllegalStateError('Workflow has not been initialized');
-        }
-        const execute = (0, interceptors_1.composeInterceptors)(exports.state.interceptors.inbound, 'execute', this.startWorkflowNextHandler.bind(this));
+        const execute = (0, interceptors_1.composeInterceptors)(this.interceptors.inbound, 'execute', this.startWorkflowNextHandler.bind(this));
         (0, stack_helpers_1.untrackPromise)(execute({
             headers: activation.headers ?? {},
-            args: (0, common_2.arrayFromPayloads)(exports.state.payloadConverter, activation.arguments),
-        }).then(completeWorkflow, handleWorkflowFailure));
+            args: (0, common_1.arrayFromPayloads)(this.payloadConverter, activation.arguments),
+        }).then(this.completeWorkflow.bind(this), this.handleWorkflowFailure.bind(this)));
     }
     cancelWorkflow(_activation) {
-        exports.state.cancelled = true;
-        cancellation_scope_1.ROOT_SCOPE.cancel();
+        this.cancelled = true;
+        this.rootScope.cancel();
     }
     fireTimer(activation) {
         // 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);
     }
     resolveActivity(activation) {
         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 ? exports.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 ? exports.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 ? exports.state.failureConverter.failureToError(failure) : undefined;
+            const err = failure ? this.failureToError(failure) : undefined;
             reject(err);
         }
         else if (activation.result.backoff) {
@@ -114,25 +297,25 @@ class Activator {
         }
     }
     resolveChildWorkflowExecutionStart(activation) {
-        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) {
             if (activation.failed.cause !==
                 StartChildWorkflowExecutionFailedCause.START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_EXISTS) {
-                throw new common_2.IllegalStateError('Got unknown StartChildWorkflowExecutionFailedCause');
+                throw new common_1.IllegalStateError('Got unknown StartChildWorkflowExecutionFailedCause');
             }
             if (!(activation.seq && activation.failed.workflowId && activation.failed.workflowType)) {
                 throw new TypeError('Missing attributes in activation job');
             }
-            reject(new errors_1.WorkflowExecutionAlreadyStartedError('Workflow execution already started', activation.failed.workflowId, activation.failed.workflowType));
+            reject(new common_1.WorkflowExecutionAlreadyStartedError('Workflow execution already started', activation.failed.workflowId, activation.failed.workflowType));
         }
         else if (activation.cancelled) {
             if (!activation.cancelled.failure) {
                 throw new TypeError('Got no failure in cancelled variant');
             }
-            reject(exports.state.failureConverter.failureToError(activation.cancelled.failure));
+            reject(this.failureToError(activation.cancelled.failure));
         }
         else {
             throw new TypeError('Got ResolveChildWorkflowExecutionStart with no status');
@@ -142,10 +325,10 @@ class Activator {
         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 ? exports.state.payloadConverter.fromPayload(completed.result) : undefined;
+            const result = completed.result ? this.payloadConverter.fromPayload(completed.result) : undefined;
             resolve(result);
         }
         else if (activation.result.failed) {
@@ -153,23 +336,23 @@ class Activator {
             if (failure === undefined || failure === null) {
                 throw new TypeError('Got failed result with no failure attribute');
             }
-            reject(exports.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(exports.state.failureConverter.failureToError(failure));
+            reject(this.failureToError(failure));
         }
     }
     // Intentionally not made function async so this handler doesn't show up in the stack trace
     queryWorkflowNextHandler({ queryName, args }) {
-        const fn = exports.state.queryHandlers.get(queryName);
+        const fn = this.queryHandlers.get(queryName);
         if (fn === undefined) {
-            const knownQueryTypes = [...exports.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 {
             const ret = fn(...args);
@@ -184,25 +367,25 @@ class Activator {
     }
     queryWorkflow(activation) {
         if (!this.workflowFunctionWasCalled) {
-            exports.state.bufferedQueries.push(activation);
+            this.bufferedQueries.push(activation);
             return;
         }
         const { queryType, queryId, headers } = activation;
         if (!(queryType && queryId)) {
             throw new TypeError('Missing query activation attributes');
         }
-        const execute = (0, interceptors_1.composeInterceptors)(exports.state.interceptors.inbound, 'handleQuery', this.queryWorkflowNextHandler.bind(this));
+        const execute = (0, interceptors_1.composeInterceptors)(this.interceptors.inbound, 'handleQuery', this.queryWorkflowNextHandler.bind(this));
         execute({
             queryName: queryType,
-            args: (0, common_2.arrayFromPayloads)(exports.state.payloadConverter, activation.arguments),
+            args: (0, common_1.arrayFromPayloads)(this.payloadConverter, activation.arguments),
             queryId,
             headers: headers ?? {},
-        }).then((result) => completeQuery(queryId, result), (reason) => failQuery(queryId, reason));
+        }).then((result) => this.completeQuery(queryId, result), (reason) => this.failQuery(queryId, reason));
     }
     async signalWorkflowNextHandler({ signalName, args }) {
-        const fn = exports.state.signalHandlers.get(signalName);
+        const fn = this.signalHandlers.get(signalName);
         if (fn === undefined) {
-            throw new common_2.IllegalStateError(`No registered signal handler for signal ${signalName}`);
+            throw new common_1.IllegalStateError(`No registered signal handler for signal ${signalName}`);
         }
         return await fn(...args);
     }
@@ -211,36 +394,36 @@ class Activator {
         if (!signalName) {
             throw new TypeError('Missing activation signalName');
         }
-        const fn = exports.state.signalHandlers.get(signalName);
+        const fn = this.signalHandlers.get(signalName);
         if (fn === undefined) {
-            let buffer = exports.state.bufferedSignals.get(signalName);
+            let buffer = this.bufferedSignals.get(signalName);
             if (buffer === undefined) {
                 buffer = [];
-                exports.state.bufferedSignals.set(signalName, buffer);
+                this.bufferedSignals.set(signalName, buffer);
             }
             buffer.push(activation);
             return;
         }
-        const execute = (0, interceptors_1.composeInterceptors)(exports.state.interceptors.inbound, 'handleSignal', this.signalWorkflowNextHandler.bind(this));
+        const execute = (0, interceptors_1.composeInterceptors)(this.interceptors.inbound, 'handleSignal', this.signalWorkflowNextHandler.bind(this));
         execute({
-            args: (0, common_2.arrayFromPayloads)(exports.state.payloadConverter, activation.input),
+            args: (0, common_1.arrayFromPayloads)(this.payloadConverter, activation.input),
             signalName,
             headers: headers ?? {},
-        }).catch(handleWorkflowFailure);
+        }).catch(this.handleWorkflowFailure.bind(this));
     }
     resolveSignalExternalWorkflow(activation) {
-        const { resolve, reject } = consumeCompletion('signalWorkflow', getSeq(activation));
+        const { resolve, reject } = this.consumeCompletion('signalWorkflow', getSeq(activation));
         if (activation.failure) {
-            reject(exports.state.failureConverter.failureToError(activation.failure));
+            reject(this.failureToError(activation.failure));
         }
         else {
             resolve(undefined);
         }
     }
     resolveRequestCancelExternalWorkflow(activation) {
-        const { resolve, reject } = consumeCompletion('cancelWorkflow', getSeq(activation));
+        const { resolve, reject } = this.consumeCompletion('cancelWorkflow', getSeq(activation));
         if (activation.failure) {
-            reject(exports.state.failureConverter.failureToError(activation.failure));
+            reject(this.failureToError(activation.failure));
         }
         else {
             resolve(undefined);
@@ -250,274 +433,114 @@ class Activator {
         if (!activation.randomnessSeed) {
             throw new TypeError('Expected activation with randomnessSeed attribute');
         }
-        exports.state.random = (0, alea_1.alea)(activation.randomnessSeed.toBytes());
+        this.random = (0, alea_1.alea)(activation.randomnessSeed.toBytes());
     }
     notifyHasPatch(activation) {
         if (!activation.patchId) {
             throw new TypeError('Notify has patch missing patch name');
         }
-        exports.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 > exports.LATEST_INTERNAL_PATCH_NUMBER)
+                throw new common_1.IllegalStateError(`Unsupported internal patch number: ${internalPatchNumber} > ${exports.LATEST_INTERNAL_PATCH_NUMBER}`);
+            if (this.internalPatchNumber < internalPatchNumber)
+                this.internalPatchNumber = internalPatchNumber;
+        }
+        else {
+            this.knownPresentPatches.add(activation.patchId);
+        }
     }
-    removeFromCache() {
-        throw new common_2.IllegalStateError('removeFromCache activation job should not reach workflow');
+    checkInternalPatchAtLeast(minimumPatchNumber) {
+        if (this.internalPatchNumber >= minimumPatchNumber)
+            return true;
+        if (!this.info.unsafe.isReplaying) {
+            this.internalPatchNumber = minimumPatchNumber;
+            this.pushCommand({
+                setPatchMarker: { patchId: `__sdk_internal_patch_number:${exports.LATEST_INTERNAL_PATCH_NUMBER}`, deprecated: false },
+            });
+            return true;
+        }
+        return false;
     }
-}
-exports.Activator = Activator;
-/**
- * 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.
- */
-class State {
-    constructor() {
-        /**
-         * Activator executes activation jobs
-         */
-        this.activator = new Activator();
-        /**
-         * Map of task sequence to a Completion
-         */
-        this.completions = {
-            timer: new Map(),
-            activity: new Map(),
-            childWorkflowStart: new Map(),
-            childWorkflowComplete: new Map(),
-            signalWorkflow: new Map(),
-            cancelWorkflow: new Map(),
-        };
-        /**
-         * Holds buffered signal calls until a handler is registered
-         */
-        this.bufferedSignals = new Map();
-        /**
-         * 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.
-         */
-        this.bufferedQueries = Array();
-        /**
-         * Mapping of signal name to handler
-         */
-        this.signalHandlers = new Map();
-        /**
-         * Whether or not to send the sources in enhanced stack trace query responses
-         */
-        this.showStackTraceSources = false;
-        /**
-         * Mapping of query name to handler
-         */
-        this.queryHandlers = new Map([
-            [
-                '__stack_trace',
-                () => {
-                    return this.getStackTraces()
-                        .map((s) => s.formatted)
-                        .join('\n\n');
-                },
-            ],
-            [
-                '__enhanced_stack_trace',
-                () => {
-                    const { sourceMap } = this;
-                    const sdk = { name: 'typescript', version: pkg_1.default.version };
-                    const stacks = this.getStackTraces().map(({ structured: locations }) => ({ locations }));
-                    const sources = {};
-                    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}
-         */
-        this.interceptors = { inbound: [], outbound: [], internals: [] };
-        /**
-         * Buffer that stores all generated commands, reset after each activation
-         */
-        this.commands = [];
-        /**
-         * Stores all {@link condition}s that haven't been unblocked yet
-         */
-        this.blockedConditions = new Map();
-        /**
-         * 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).
-         */
-        this.completed = false;
-        /**
-         * Was this Workflow cancelled?
-         */
-        this.cancelled = false;
-        /**
-         * The next (incremental) sequence to assign when generating completable commands
-         */
-        this.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
-         */
-        _State_now.set(this, void 0);
-        /**
-         * A deterministic RNG, used by the isolate's overridden Math.random
-         */
-        this.random = function () {
-            throw new common_2.IllegalStateError('Tried to use Math.random before Workflow has been initialized');
-        };
-        this.payloadConverter = common_2.defaultPayloadConverter;
-        this.failureConverter = common_1.defaultFailureConverter;
-        /**
-         * Patches we know the status of for this workflow, as in {@link patched}
-         */
-        this.knownPresentPatches = new Set();
-        /**
-         * Patches we sent to core {@link patched}
-         */
-        this.sentPatches = new Set();
-        this.sinkCalls = Array();
+    removeFromCache() {
+        throw new common_1.IllegalStateError('removeFromCache activation job should not reach workflow');
     }
-    getStackTraces() {
-        const { childToParent, promiseToStack } = globalThis.__TEMPORAL__.promiseStackStore;
-        const internalNodes = [...childToParent.values()].reduce((acc, curr) => {
-            for (const p of curr) {
-                acc.add(p);
-            }
-            return acc;
-        }, new Set());
-        const stacks = new Map();
-        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);
+    /**
+     * Transforms failures into a command to be sent to the server.
+     * Used to handle any failure emitted by the Workflow.
+     */
+    async handleWorkflowFailure(error) {
+        if (this.cancelled && (0, errors_1.isCancellation)(error)) {
+            this.pushCommand({ cancelWorkflowExecution: {} }, true);
+        }
+        else if (error instanceof interfaces_1.ContinueAsNew) {
+            this.pushCommand({ continueAsNewWorkflowExecution: error.command }, true);
+        }
+        else {
+            if (!(error instanceof common_1.TemporalFailure)) {
+                // This results in an unhandled rejection which will fail the activation
+                // preventing it from completing.
+                throw error;
             }
+            this.pushCommand({
+                failWorkflowExecution: {
+                    failure: this.errorToFailure(error),
+                },
+            }, true);
         }
-        // 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);
     }
-    get now() {
-        if (__classPrivateFieldGet(this, _State_now, "f") === undefined) {
-            throw new common_2.IllegalStateError('Tried to get Date before Workflow has been initialized');
-        }
-        return __classPrivateFieldGet(this, _State_now, "f");
+    completeQuery(queryId, result) {
+        this.pushCommand({
+            respondToQuery: { queryId, succeeded: { response: this.payloadConverter.toPayload(result) } },
+        });
     }
-    set now(value) {
-        __classPrivateFieldSet(this, _State_now, value, "f");
+    failQuery(queryId, error) {
+        this.pushCommand({
+            respondToQuery: {
+                queryId,
+                failed: this.errorToFailure((0, common_1.ensureTemporalFailure)(error)),
+            },
+        });
     }
-    getAndResetSinkCalls() {
-        const { sinkCalls } = this;
-        this.sinkCalls = [];
-        return sinkCalls;
+    /** Consume a completion if it exists in Workflow state */
+    maybeConsumeCompletion(type, taskSeq) {
+        const completion = this.completions[type].get(taskSeq);
+        if (completion !== undefined) {
+            this.completions[type].delete(taskSeq);
+        }
+        return completion;
     }
-    /**
-     * Buffer a Workflow command to be collected at the end of the current activation.
-     *
-     * Prevents commands from being added after Workflow completion.
-     */
-    pushCommand(cmd, complete = false) {
-        // 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, throws if it doesn't */
+    consumeCompletion(type, taskSeq) {
+        const completion = this.maybeConsumeCompletion(type, taskSeq);
+        if (completion === undefined) {
+            throw new common_1.IllegalStateError(`No completion for taskSeq ${taskSeq}`);
         }
+        return completion;
     }
-}
-exports.State = State;
-_State_now = new WeakMap();
-exports.state = new State();
-function completeWorkflow(result) {
-    exports.state.pushCommand({
-        completeWorkflowExecution: {
-            result: exports.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.
- */
-async function handleWorkflowFailure(error) {
-    if (exports.state.cancelled && (0, errors_1.isCancellation)(error)) {
-        exports.state.pushCommand({ cancelWorkflowExecution: {} }, true);
-    }
-    else if (error instanceof interfaces_1.ContinueAsNew) {
-        exports.state.pushCommand({ continueAsNewWorkflowExecution: error.command }, true);
-    }
-    else {
-        if (!(error instanceof common_2.TemporalFailure)) {
-            // This results in an unhandled rejection which will fail the activation
-            // preventing it from completing.
-            throw error;
-        }
-        exports.state.pushCommand({
-            failWorkflowExecution: {
-                failure: exports.state.failureConverter.errorToFailure(error),
+    completeWorkflow(result) {
+        this.pushCommand({
+            completeWorkflowExecution: {
+                result: this.payloadConverter.toPayload(result),
             },
         }, true);
     }
-}
-exports.handleWorkflowFailure = handleWorkflowFailure;
-function completeQuery(queryId, result) {
-    exports.state.pushCommand({
-        respondToQuery: { queryId, succeeded: { response: exports.state.payloadConverter.toPayload(result) } },
-    });
-}
-async function failQuery(queryId, error) {
-    exports.state.pushCommand({
-        respondToQuery: { queryId, failed: exports.state.failureConverter.errorToFailure((0, common_2.ensureTemporalFailure)(error)) },
-    });
-}
-/** Consume a completion if it exists in Workflow state */
-function maybeConsumeCompletion(type, taskSeq) {
-    const completion = exports.state.completions[type].get(taskSeq);
-    if (completion !== undefined) {
-        exports.state.completions[type].delete(taskSeq);
+    errorToFailure(err) {
+        return this.failureConverter.errorToFailure(err, this.payloadConverter);
+    }
+    failureToError(failure) {
+        return this.failureConverter.failureToError(failure, this.payloadConverter);
     }
-    return completion;
 }
-exports.maybeConsumeCompletion = maybeConsumeCompletion;
-/** Consume a completion if it exists in Workflow state, throws if it doesn't */
-function consumeCompletion(type, taskSeq) {
-    const completion = maybeConsumeCompletion(type, taskSeq);
-    if (completion === undefined) {
-        throw new common_2.IllegalStateError(`No completion for taskSeq ${taskSeq}`);
-    }
-    return completion;
+exports.Activator = Activator;
+function getActivator() {
+    const activator = globalThis.__TEMPORAL__?.activator;
+    if (activator === undefined) {
+        throw new common_1.IllegalStateError('Workflow uninitialized');
+    }
+    return activator;
 }
-exports.consumeCompletion = consumeCompletion;
+exports.getActivator = getActivator;
 function getSeq(activation) {
     const seq = activation.seq;
     if (seq === undefined || seq === null) {