@dbos-inc/dbos-sdk 3.0.23-preview → 3.0.27-preview

package/dist/src/dbos-executor.js

@@ -26,11 +26,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBOSExecutor = exports.TempWorkflowType = exports.OperationType = exports.DebugMode = exports.isDeprecatedDBOSConfig = exports.DBOS_QUEUE_MAX_PRIORITY = exports.DBOS_QUEUE_MIN_PRIORITY = exports.dbosNull = void 0;
+exports.DBOSExecutor = exports.TempWorkflowType = exports.OperationType = exports.isDeprecatedDBOSConfig = exports.DBOS_QUEUE_MAX_PRIORITY = exports.DBOS_QUEUE_MIN_PRIORITY = exports.dbosNull = void 0;
 const error_1 = require("./error");
 const workflow_1 = require("./workflow");
 const transaction_1 = require("./transaction");
-const step_1 = require("./step");
 const collector_1 = require("./telemetry/collector");
 const traces_1 = require("./telemetry/traces");
 const logs_1 = require("./telemetry/logs");
@@ -46,7 +45,6 @@ const context_1 = require("./context");
 const serialize_error_1 = require("serialize-error");
 const utils_1 = require("./utils");
 const node_path_1 = __importDefault(require("node:path"));
-const procedure_1 = require("./procedure");
 const _1 = require(".");
 const lodash_1 = require("lodash");
 const wfqueue_1 = require("./wfqueue");
@@ -67,17 +65,11 @@ function isDeprecatedDBOSConfig(config) {
     return isDeprecated;
 }
 exports.isDeprecatedDBOSConfig = isDeprecatedDBOSConfig;
-var DebugMode;
-(function (DebugMode) {
-    DebugMode[DebugMode["DISABLED"] = 0] = "DISABLED";
-    DebugMode[DebugMode["ENABLED"] = 1] = "ENABLED";
-    DebugMode[DebugMode["TIME_TRAVEL"] = 2] = "TIME_TRAVEL";
-})(DebugMode || (exports.DebugMode = DebugMode = {}));
 exports.OperationType = {
     HANDLER: 'handler',
     WORKFLOW: 'workflow',
     TRANSACTION: 'transaction',
-    COMMUNICATOR: 'communicator',
+    STEP: 'step',
     PROCEDURE: 'procedure',
 };
 exports.TempWorkflowType = {
@@ -120,22 +112,9 @@ class DBOSExecutor {
     telemetryCollector;
     static defaultNotificationTimeoutSec = 60;
     debugMode;
-    get isDebugging() {
-        switch (this.debugMode) {
-            case DebugMode.DISABLED:
-                return false;
-            case DebugMode.ENABLED:
-            case DebugMode.TIME_TRAVEL:
-                return true;
-            default: {
-                const _never = this.debugMode;
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                throw new Error(`Unexpected DBOS debug mode: ${this.debugMode}`);
-            }
-        }
-    }
     static systemDBSchemaName = 'dbos';
     logger;
+    ctxLogger;
     tracer;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     typeormEntities = [];
@@ -148,7 +127,7 @@ class DBOSExecutor {
     /* WORKFLOW EXECUTOR LIFE CYCLE MANAGEMENT */
     constructor(config, { systemDatabase, debugMode } = {}) {
         this.config = config;
-        this.debugMode = debugMode ?? DebugMode.DISABLED;
+        this.debugMode = debugMode ?? false;
         // Set configured environment variables
         if (config.env) {
             for (const [key, value] of Object.entries(config.env)) {
@@ -169,8 +148,9 @@ class DBOSExecutor {
             this.telemetryCollector = new collector_1.TelemetryCollector();
         }
         this.logger = new logs_1.GlobalLogger(this.telemetryCollector, this.config.telemetry.logs);
+        this.ctxLogger = new logs_1.DBOSContextualLogger(this.logger, () => (0, context_1.getCurrentContextStore)().span);
         this.tracer = new traces_1.Tracer(this.telemetryCollector);
-        if (this.isDebugging) {
+        if (this.debugMode) {
             this.logger.info('Running in debug mode!');
         }
         this.procedurePool = new pg_1.Pool(this.config.poolConfig);
@@ -318,7 +298,7 @@ class DBOSExecutor {
                 }
                 this.logger.debug(`Loaded ${length} ORM entities`);
             }
-            if (!this.isDebugging) {
+            if (!this.debugMode) {
                 await (0, user_database_1.createDBIfDoesNotExist)(this.config.poolConfig, this.logger);
             }
             this.configureDbClient();
@@ -330,8 +310,8 @@ class DBOSExecutor {
                 this.#registerClass(cls);
             }
             // Debug mode doesn't need to initialize the DBs. Everything should appear to be read-only.
-            await this.userDatabase.init(this.isDebugging);
-            if (!this.isDebugging) {
+            await this.userDatabase.init(this.debugMode);
+            if (!this.debugMode) {
                 await this.systemDatabase.init();
             }
         }
@@ -354,7 +334,7 @@ class DBOSExecutor {
         }
         this.initialized = true;
         // Only execute init code if under non-debug mode
-        if (!this.isDebugging) {
+        if (!this.debugMode) {
             for (const cls of classnames) {
                 // Init its configurations
                 const creg = (0, decorators_1.getClassRegistrationByName)(cls);
@@ -536,7 +516,7 @@ class DBOSExecutor {
     async workflow(wf, params, ...args) {
         return this.internalWorkflow(wf, params, undefined, undefined, ...args);
     }
-    // If callerUUID and functionID are set, it means the workflow is invoked from within a workflow.
+    // If callerWFID and functionID are set, it means the workflow is invoked from within a workflow.
     async internalWorkflow(wf, params, callerID, callerFunctionID, ...args) {
         const workflowID = params.workflowUUID ? params.workflowUUID : (0, node_crypto_1.randomUUID)();
         const presetID = params.workflowUUID ? true : false;
@@ -560,29 +540,40 @@ class DBOSExecutor {
                 this.logger.warn(`Priority is not enabled for queue ${params.queueName}. Setting priority will not have any effect.`);
             }
         }
+        const pctx = (0, context_1.getCurrentContextStore)();
         const wInfo = this.getWorkflowInfo(wf);
         if (wInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(wf.name);
         }
         const wConfig = wInfo.config;
-        const passContext = wInfo.registration?.passContext ?? true;
-        const wCtxt = new workflow_1.WorkflowContextImpl(this, params.parentCtx, workflowID, wConfig, wf.name, presetID, timeoutMS, deadlineEpochMS, params.tempWfType, params.tempWfName);
+        const maxRecoveryAttempts = wConfig.maxRecoveryAttempts ? wConfig.maxRecoveryAttempts : 50;
+        const wfname = wf.name; // TODO: Should be what was registered in wfInfo...
+        const span = this.tracer.startSpan(wfname, {
+            status: workflow_1.StatusString.PENDING,
+            operationUUID: workflowID,
+            operationType: exports.OperationType.WORKFLOW,
+            operationName: wInfo.registration?.name ?? wf.name,
+            authenticatedUser: pctx?.authenticatedUser ?? '',
+            authenticatedRoles: pctx?.authenticatedRoles ?? [],
+            assumedRole: pctx?.assumedRole ?? '',
+        }, pctx?.span);
+        const isTempWorkflow = DBOSExecutor.tempWorkflowName === wfname;
         const internalStatus = {
             workflowUUID: workflowID,
             status: params.queueName !== undefined ? workflow_1.StatusString.ENQUEUED : workflow_1.StatusString.PENDING,
-            workflowName: wf.name,
-            workflowClassName: wCtxt.isTempWorkflow ? '' : (0, decorators_1.getRegisteredMethodClassName)(wf),
+            workflowName: wfname,
+            workflowClassName: isTempWorkflow ? '' : (0, decorators_1.getRegisteredMethodClassName)(wf),
             workflowConfigName: params.configuredInstance?.name || '',
             queueName: params.queueName,
-            authenticatedUser: wCtxt.authenticatedUser,
             output: null,
             error: null,
-            assumedRole: wCtxt.assumedRole,
-            authenticatedRoles: wCtxt.authenticatedRoles,
-            request: wCtxt.request,
-            executorId: wCtxt.executorID,
+            authenticatedUser: pctx?.authenticatedUser || '',
+            assumedRole: pctx?.assumedRole || '',
+            authenticatedRoles: pctx?.authenticatedRoles || [],
+            request: pctx?.request || {},
+            executorId: utils_1.globalParams.executorID,
             applicationVersion: utils_1.globalParams.appVersion,
-            applicationID: wCtxt.applicationID,
+            applicationID: utils_1.globalParams.appID,
             createdAt: Date.now(), // Remember the start time of this workflow,
             timeoutMS: timeoutMS,
             deadlineEpochMS: deadlineEpochMS,
@@ -590,15 +581,15 @@ class DBOSExecutor {
             deduplicationID: params.enqueueOptions?.deduplicationID,
             priority: priority ?? 0,
         };
-        if (wCtxt.isTempWorkflow) {
-            internalStatus.workflowName = `${DBOSExecutor.tempWorkflowName}-${wCtxt.tempWfOperationType}-${wCtxt.tempWfOperationName}`;
+        if (isTempWorkflow) {
+            internalStatus.workflowName = `${DBOSExecutor.tempWorkflowName}-${params.tempWfType}-${params.tempWfName}`;
             internalStatus.workflowClassName = params.tempWfClass ?? '';
         }
         let status = undefined;
         let $deadlineEpochMS = undefined;
         // Synchronously set the workflow's status to PENDING and record workflow inputs.
         // We have to do it for all types of workflows because operation_outputs table has a foreign key constraint on workflow status table.
-        if (this.isDebugging) {
+        if (this.debugMode) {
             const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowID);
             if (!wfStatus) {
                 throw new error_1.DBOSDebuggerError(`Failed to find inputs for workflow UUID ${workflowID}`);
@@ -616,7 +607,7 @@ class DBOSExecutor {
                     return new workflow_1.RetrievedHandle(this.systemDatabase, result.childWorkflowID, callerID, callerFunctionID);
                 }
             }
-            const ires = await this.systemDatabase.initWorkflowStatus(internalStatus, wCtxt.maxRecoveryAttempts);
+            const ires = await this.systemDatabase.initWorkflowStatus(internalStatus, maxRecoveryAttempts);
             if (callerFunctionID !== undefined && callerID !== undefined) {
                 await this.systemDatabase.recordOperationResult(callerID, callerFunctionID, internalStatus.workflowName, true, {
                     childWorkflowID: workflowID,
@@ -654,19 +645,24 @@ class DBOSExecutor {
             e.dbos_already_logged = true;
             internalStatus.error = utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(e));
             internalStatus.status = workflow_1.StatusString.ERROR;
-            if (!exec.isDebugging) {
+            if (!exec.debugMode) {
                 await exec.systemDatabase.recordWorkflowError(workflowID, internalStatus);
             }
-            wCtxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: e.message });
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: e.message });
         }
         const runWorkflow = async () => {
             let result;
             // Execute the workflow.
             try {
-                const callResult = await (0, context_1.runWithWorkflowContext)(wCtxt, () => {
-                    const callPromise = passContext
-                        ? wf.call(params.configuredInstance, wCtxt, ...args)
-                        : wf.call(params.configuredInstance, ...args);
+                const callResult = await (0, context_1.runWithParentContext)(pctx, {
+                    presetID,
+                    timeoutMS,
+                    deadlineEpochMS,
+                    workflowId: workflowID,
+                    span,
+                    logger: this.ctxLogger,
+                }, () => {
+                    const callPromise = wf.call(params.configuredInstance, ...args);
                     if ($deadlineEpochMS === undefined) {
                         return callPromise;
                     }
@@ -674,7 +670,7 @@ class DBOSExecutor {
                         return callPromiseWithTimeout(callPromise, $deadlineEpochMS, this.systemDatabase);
                     }
                 });
-                if (this.isDebugging) {
+                if (this.debugMode) {
                     const recordedResult = DBOSExecutor.reviveResultOrError((await this.systemDatabase.awaitWorkflowResult(workflowID)));
                     if (!resultsMatch(recordedResult, callResult)) {
                         this.logger.error(`Detect different output for the workflow UUID ${workflowID}!\n Received: ${utils_1.DBOSJSON.stringify(callResult)}\n Original: ${utils_1.DBOSJSON.stringify(recordedResult)}`);
@@ -692,21 +688,21 @@ class DBOSExecutor {
                 }
                 internalStatus.output = utils_1.DBOSJSON.stringify(result);
                 internalStatus.status = workflow_1.StatusString.SUCCESS;
-                if (!this.isDebugging) {
+                if (!this.debugMode) {
                     await this.systemDatabase.recordWorkflowOutput(workflowID, internalStatus);
                 }
-                wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
             }
             catch (err) {
                 if (err instanceof error_1.DBOSWorkflowConflictError) {
                     // Retrieve the handle and wait for the result.
                     const retrievedHandle = this.retrieveWorkflow(workflowID);
                     result = await retrievedHandle.getResult();
-                    wCtxt.span.setAttribute('cached', true);
-                    wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
+                    span.setAttribute('cached', true);
+                    span.setStatus({ code: api_1.SpanStatusCode.OK });
                 }
                 else if (err instanceof error_1.DBOSWorkflowCancelledError) {
-                    wCtxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
                     internalStatus.error = err.message;
                     if (err.workflowID === workflowID) {
                         internalStatus.status = workflow_1.StatusString.CANCELLED;
@@ -724,11 +720,11 @@ class DBOSExecutor {
                 }
             }
             finally {
-                this.tracer.endSpan(wCtxt.span);
+                this.tracer.endSpan(span);
             }
             return result;
         };
-        if (this.isDebugging ||
+        if (this.debugMode ||
             (status !== 'SUCCESS' && status !== 'ERROR' && (params.queueName === undefined || params.executeWorkflow))) {
             const workflowPromise = runWorkflow();
             this.systemDatabase.registerRunningWorkflow(workflowID, workflowPromise);
@@ -794,7 +790,7 @@ class DBOSExecutor {
      * Write a operation's output to the database.
      */
     async #recordOutput(query, workflowUUID, funcID, txnSnapshot, output, isKeyConflict, function_name) {
-        if (this.isDebugging) {
+        if (this.debugMode) {
             throw new error_1.DBOSDebuggerError('Cannot record output in debug mode.');
         }
         try {
@@ -816,7 +812,7 @@ class DBOSExecutor {
      * Record an error in an operation to the database.
      */
     async #recordError(query, workflowUUID, funcID, txnSnapshot, err, isKeyConflict, function_name) {
-        if (this.isDebugging) {
+        if (this.debugMode) {
             throw new error_1.DBOSDebuggerError('Cannot record error in debug mode.');
         }
         try {
@@ -844,67 +840,61 @@ class DBOSExecutor {
     async transaction(txn, params, ...args) {
         return await (await this.startTransactionTempWF(txn, params, undefined, undefined, ...args)).getResult();
     }
-    async startTransactionTempWF(txn, params, callerUUID, callerFunctionID, ...args) {
+    async startTransactionTempWF(txn, params, callerWFID, callerFunctionID, ...args) {
         // Create a workflow and call transaction.
-        const temp_workflow = async (ctxt, ...args) => {
-            const ctxtImpl = ctxt;
-            return await this.callTransactionFunction(txn, params.configuredInstance ?? null, ctxtImpl, ...args);
+        const temp_workflow = async (...args) => {
+            return await this.callTransactionFunction(txn, params.configuredInstance ?? null, ...args);
         };
         return await this.internalWorkflow(temp_workflow, {
             ...params,
             tempWfType: exports.TempWorkflowType.transaction,
             tempWfName: (0, decorators_1.getRegisteredMethodName)(txn),
             tempWfClass: (0, decorators_1.getRegisteredMethodClassName)(txn),
-        }, callerUUID, callerFunctionID, ...args);
+        }, callerWFID, callerFunctionID, ...args);
     }
-    async callTransactionFunction(txn, clsinst, wfCtx, ...args) {
+    async callTransactionFunction(txn, clsinst, ...args) {
         const txnInfo = this.getTransactionInfo(txn);
         if (txnInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(txn.name);
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+        const pctx = (0, context_1.getCurrentContextStore)();
+        const wfid = pctx.workflowId;
+        await this.systemDatabase.checkIfCanceled(wfid);
         let retryWaitMillis = 1;
         const backoffFactor = 1.5;
         const maxRetryWaitMs = 2000; // Maximum wait 2 seconds.
-        const funcId = wfCtx.functionIDGetIncrement();
+        const funcId = (0, context_1.functionIDGetIncrement)();
         const span = this.tracer.startSpan(txn.name, {
-            operationUUID: wfCtx.workflowUUID,
+            operationUUID: wfid,
             operationType: exports.OperationType.TRANSACTION,
-            authenticatedUser: wfCtx.authenticatedUser,
-            assumedRole: wfCtx.assumedRole,
-            authenticatedRoles: wfCtx.authenticatedRoles,
+            operationName: txn.name,
+            authenticatedUser: pctx.authenticatedUser ?? '',
+            assumedRole: pctx.assumedRole ?? '',
+            authenticatedRoles: pctx.authenticatedRoles ?? [],
             isolationLevel: txnInfo.config.isolationLevel,
-        }, wfCtx.span);
+        }, pctx.span);
         while (true) {
-            await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+            await this.systemDatabase.checkIfCanceled(wfid);
             let txn_snapshot = 'invalid';
             let prevResultFound = false;
-            const workflowUUID = wfCtx.workflowUUID;
             const wrappedTransaction = async (client) => {
-                const tCtxt = new transaction_1.TransactionContextImpl(this.userDatabase.getName(), client, wfCtx, span, this.logger, funcId, txn.name);
                 // If the UUID is preset, it is possible this execution previously happened. Check, and return its original result if it did.
                 // Note: It is possible to retrieve a generated ID from a workflow handle, run a concurrent execution, and cause trouble for yourself. We recommend against this.
                 let prevResult = exports.dbosNull;
                 const queryFunc = (sql, args) => this.userDatabase.queryWithClient(client, sql, ...args);
-                if (wfCtx.presetUUID) {
-                    const executionResult = await this.#checkExecution(queryFunc, workflowUUID, funcId, txn.name);
+                if (pctx.presetID) {
+                    const executionResult = await this.#checkExecution(queryFunc, wfid, funcId, txn.name);
                     prevResult = executionResult.result;
                     txn_snapshot = executionResult.txn_snapshot;
                     if (prevResult !== exports.dbosNull) {
                         prevResultFound = true;
-                        tCtxt.span.setAttribute('cached', true);
-                        if (this.debugMode === DebugMode.TIME_TRAVEL) {
-                            // for time travel debugging, navigate the proxy to the time of this transaction's snapshot
-                            await queryFunc(`--proxy:${executionResult.txn_id ?? ''}:${txn_snapshot}`, []);
+                        span.setAttribute('cached', true);
+                        // Return/throw the previous result
+                        if (prevResult instanceof Error) {
+                            throw prevResult;
                         }
                         else {
-                            // otherwise, return/throw the previous result
-                            if (prevResult instanceof Error) {
-                                throw prevResult;
-                            }
-                            else {
-                                return prevResult;
-                            }
+                            return prevResult;
                         }
                     }
                 }
@@ -912,27 +902,32 @@ class DBOSExecutor {
                     // Collect snapshot information for read-only transactions and non-preset UUID transactions, if not already collected above
                     txn_snapshot = await DBOSExecutor.#retrieveSnapshot(queryFunc);
                 }
-                if (this.isDebugging && prevResult === exports.dbosNull) {
-                    throw new error_1.DBOSDebuggerError(`Failed to find the recorded output for the transaction: workflow UUID ${workflowUUID}, step number ${funcId}`);
+                if (this.debugMode && prevResult === exports.dbosNull) {
+                    throw new error_1.DBOSDebuggerError(`Failed to find the recorded output for the transaction: workflow UUID ${wfid}, step number ${funcId}`);
                 }
                 // Execute the user's transaction.
+                const ctxlog = this.ctxLogger;
                 const result = await (async function () {
                     try {
-                        return await (0, context_1.runWithTransactionContext)(tCtxt, async () => {
-                            if (txnInfo.registration.passContext) {
-                                return await txn.call(clsinst, tCtxt, ...args);
-                            }
-                            else {
-                                const tf = txn;
-                                return await tf.call(clsinst, ...args);
-                            }
+                        return await (0, context_1.runWithParentContext)(pctx, {
+                            authenticatedRoles: pctx?.authenticatedRoles,
+                            authenticatedUser: pctx?.authenticatedUser,
+                            workflowId: wfid,
+                            curTxFunctionId: funcId,
+                            parentCtx: pctx,
+                            sqlClient: client,
+                            logger: ctxlog,
+                            span,
+                        }, async () => {
+                            const tf = txn;
+                            return await tf.call(clsinst, ...args);
                         });
                     }
                     catch (e) {
                         return e instanceof Error ? e : new Error(`${e}`);
                     }
                 })();
-                if (this.isDebugging) {
+                if (this.debugMode) {
                     if (prevResult instanceof Error) {
                         throw prevResult;
                     }
@@ -949,13 +944,13 @@ class DBOSExecutor {
                 // Record the execution, commit, and return.
                 try {
                     // Synchronously record the output of write transactions and obtain the transaction ID.
-                    const pg_txn_id = await this.#recordOutput(queryFunc, wfCtx.workflowUUID, funcId, txn_snapshot, result, (error) => this.userDatabase.isKeyConflictError(error), txn.name);
-                    tCtxt.span.setAttribute('pg_txn_id', pg_txn_id);
+                    const pg_txn_id = await this.#recordOutput(queryFunc, wfid, funcId, txn_snapshot, result, (error) => this.userDatabase.isKeyConflictError(error), txn.name);
+                    span.setAttribute('pg_txn_id', pg_txn_id);
                 }
                 catch (error) {
                     if (this.userDatabase.isFailedSqlTransactionError(error)) {
-                        this.logger.error(`Postgres aborted the ${txn.name} @DBOS.transaction of Workflow ${workflowUUID}, but the function did not raise an exception.  Please ensure that the @DBOS.transaction method raises an exception if the database transaction is aborted.`);
-                        throw new error_1.DBOSFailedSqlTransactionError(workflowUUID, txn.name);
+                        this.logger.error(`Postgres aborted the ${txn.name} @DBOS.transaction of Workflow ${wfid}, but the function did not raise an exception.  Please ensure that the @DBOS.transaction method raises an exception if the database transaction is aborted.`);
+                        throw new error_1.DBOSFailedSqlTransactionError(wfid, txn.name);
                     }
                     else {
                         throw error;
@@ -985,7 +980,7 @@ class DBOSExecutor {
                     const e = err;
                     await this.userDatabase.transaction(async (client) => {
                         const func = (sql, args) => this.userDatabase.queryWithClient(client, sql, ...args);
-                        await this.#recordError(func, wfCtx.workflowUUID, funcId, txn_snapshot, e, (error) => this.userDatabase.isKeyConflictError(error), txn.name);
+                        await this.#recordError(func, wfid, funcId, txn_snapshot, e, (error) => this.userDatabase.isKeyConflictError(error), txn.name);
                     }, { isolationLevel: transaction_1.IsolationLevel.ReadCommitted });
                 }
                 span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: e.message });
@@ -996,9 +991,8 @@ class DBOSExecutor {
     }
     async procedure(proc, params, ...args) {
         // Create a workflow and call procedure.
-        const temp_workflow = async (ctxt, ...args) => {
-            const ctxtImpl = ctxt;
-            return this.callProcedureFunction(proc, ctxtImpl, ...args);
+        const temp_workflow = async (...args) => {
+            return this.callProcedureFunction(proc, ...args);
         };
         return await (await this.workflow(temp_workflow, {
             ...params,
@@ -1007,27 +1001,30 @@ class DBOSExecutor {
             tempWfClass: (0, decorators_1.getRegisteredMethodClassName)(proc),
         }, ...args)).getResult();
     }
-    async callProcedureFunction(proc, wfCtx, ...args) {
+    async callProcedureFunction(proc, ...args) {
         const procInfo = this.getProcedureInfo(proc);
         if (procInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(proc.name);
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
-        const executeLocally = this.isDebugging || (procInfo.config.executeLocally ?? false);
-        const funcId = wfCtx.functionIDGetIncrement();
+        const pctx = (0, context_1.getCurrentContextStore)();
+        const wfid = pctx.workflowId;
+        await this.systemDatabase.checkIfCanceled(wfid);
+        const executeLocally = this.debugMode || (procInfo.config.executeLocally ?? false);
+        const funcId = (0, context_1.functionIDGetIncrement)();
         const span = this.tracer.startSpan(proc.name, {
-            operationUUID: wfCtx.workflowUUID,
+            operationUUID: wfid,
             operationType: exports.OperationType.PROCEDURE,
-            authenticatedUser: wfCtx.authenticatedUser,
-            assumedRole: wfCtx.assumedRole,
-            authenticatedRoles: wfCtx.authenticatedRoles,
+            operationName: proc.name,
+            authenticatedUser: pctx.authenticatedUser ?? '',
+            assumedRole: pctx.assumedRole ?? '',
+            authenticatedRoles: pctx.authenticatedRoles ?? [],
             isolationLevel: procInfo.config.isolationLevel,
             executeLocally,
-        }, wfCtx.span);
+        }, pctx.span);
         try {
             const result = executeLocally
-                ? await this.#callProcedureFunctionLocal(proc, args, wfCtx, span, procInfo, funcId)
-                : await this.#callProcedureFunctionRemote(proc, args, wfCtx, span, procInfo.config, funcId);
+                ? await this.#callProcedureFunctionLocal(proc, args, span, procInfo, funcId)
+                : await this.#callProcedureFunctionRemote(proc, args, span, procInfo.config, funcId);
             span.setStatus({ code: api_1.SpanStatusCode.OK });
             return result;
         }
@@ -1040,35 +1037,30 @@ class DBOSExecutor {
             this.tracer.endSpan(span);
         }
     }
-    async #callProcedureFunctionLocal(proc, args, wfCtx, span, procInfo, funcId) {
+    async #callProcedureFunctionLocal(proc, args, span, procInfo, funcId) {
         let retryWaitMillis = 1;
         const backoffFactor = 1.5;
         const maxRetryWaitMs = 2000; // Maximum wait 2 seconds.
+        const pctx = (0, context_1.getCurrentContextStore)();
+        const wfid = pctx.workflowId;
         while (true) {
-            await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+            await this.systemDatabase.checkIfCanceled(wfid);
             let txn_snapshot = 'invalid';
             const wrappedProcedure = async (client) => {
-                const ctxt = new procedure_1.StoredProcedureContextImpl(client, wfCtx, span, this.logger, funcId, proc.name);
                 let prevResult = exports.dbosNull;
                 const queryFunc = (sql, args) => this.procedurePool.query(sql, args).then((v) => v.rows);
-                if (wfCtx.presetUUID) {
-                    const executionResult = await this.#checkExecution(queryFunc, wfCtx.workflowUUID, funcId, wfCtx.operationName);
+                if (pctx.presetID) {
+                    const executionResult = await this.#checkExecution(queryFunc, wfid, funcId, proc.name);
                     prevResult = executionResult.result;
                     txn_snapshot = executionResult.txn_snapshot;
                     if (prevResult !== exports.dbosNull) {
-                        ctxt.span.setAttribute('cached', true);
-                        if (this.debugMode === DebugMode.TIME_TRAVEL) {
-                            // for time travel debugging, navigate the proxy to the time of this transaction's snapshot
-                            await queryFunc(`--proxy:${executionResult.txn_id ?? ''}:${txn_snapshot}`, []);
+                        span.setAttribute('cached', true);
+                        // Return/throw the previous result
+                        if (prevResult instanceof Error) {
+                            throw prevResult;
                         }
                         else {
-                            // otherwise, return/throw the previous result
-                            if (prevResult instanceof Error) {
-                                throw prevResult;
-                            }
-                            else {
-                                return prevResult;
-                            }
+                            return prevResult;
                         }
                     }
                 }
@@ -1076,27 +1068,36 @@ class DBOSExecutor {
                     // Collect snapshot information for read-only transactions and non-preset UUID transactions, if not already collected above
                     txn_snapshot = await DBOSExecutor.#retrieveSnapshot(queryFunc);
                 }
-                if (this.isDebugging && prevResult === exports.dbosNull) {
-                    throw new error_1.DBOSDebuggerError(`Failed to find the recorded output for the procedure: workflow UUID ${wfCtx.workflowUUID}, step number ${funcId}`);
+                if (this.debugMode && prevResult === exports.dbosNull) {
+                    throw new error_1.DBOSDebuggerError(`Failed to find the recorded output for the procedure: workflow UUID ${wfid}, step number ${funcId}`);
                 }
                 // Execute the user's transaction.
+                const ctxlog = this.ctxLogger;
                 const result = await (async function () {
                     try {
-                        return await (0, context_1.runWithStoredProcContext)(ctxt, async () => {
-                            if (procInfo.registration.passContext) {
-                                return await proc(ctxt, ...args);
-                            }
-                            else {
-                                const pf = proc;
-                                return await pf(...args);
-                            }
+                        // Check we are in a workflow context and not in a step / transaction already
+                        const pctx = (0, context_1.getCurrentContextStore)();
+                        if (!pctx)
+                            throw new error_1.DBOSInvalidWorkflowTransitionError();
+                        if (!(0, context_1.isInWorkflowCtx)(pctx))
+                            throw new error_1.DBOSInvalidWorkflowTransitionError();
+                        return await (0, context_1.runWithParentContext)(pctx, {
+                            curTxFunctionId: funcId,
+                            parentCtx: pctx,
+                            isInStoredProc: true,
+                            sqlClient: client,
+                            logger: ctxlog,
+                            span,
+                        }, async () => {
+                            const pf = proc;
+                            return await pf(...args);
                         });
                     }
                     catch (e) {
                         return e instanceof Error ? e : new Error(`${e}`);
                     }
                 })();
-                if (this.isDebugging) {
+                if (this.debugMode) {
                     if (prevResult instanceof Error) {
                         throw prevResult;
                     }
@@ -1112,9 +1113,9 @@ class DBOSExecutor {
                 }
                 // Synchronously record the output of write transactions and obtain the transaction ID.
                 const func = (sql, args) => client.query(sql, args).then((v) => v.rows);
-                const pg_txn_id = await this.#recordOutput(func, wfCtx.workflowUUID, funcId, txn_snapshot, result, user_database_1.pgNodeIsKeyConflictError, wfCtx.operationName);
+                const pg_txn_id = await this.#recordOutput(func, wfid, funcId, txn_snapshot, result, user_database_1.pgNodeIsKeyConflictError, proc.name);
                 // const pg_txn_id = await wfCtx.recordOutputProc<R>(client, funcId, txn_snapshot, result);
-                ctxt.span.setAttribute('pg_txn_id', pg_txn_id);
+                span.setAttribute('pg_txn_id', pg_txn_id);
                 return result;
             };
             try {
@@ -1125,7 +1126,7 @@ class DBOSExecutor {
                 return result;
             }
             catch (err) {
-                if (!this.isDebugging) {
+                if (!this.debugMode) {
                     if (this.userDatabase.isRetriableTransactionError(err)) {
                         // serialization_failure in PostgreSQL
                         span.addEvent('TXN SERIALIZATION FAILURE', { retryWaitMillis: retryWaitMillis }, performance.now());
@@ -1139,32 +1140,34 @@ class DBOSExecutor {
                     const e = err;
                     await this.invokeStoredProcFunction(async (client) => {
                         const func = (sql, args) => client.query(sql, args).then((v) => v.rows);
-                        await this.#recordError(func, wfCtx.workflowUUID, funcId, txn_snapshot, e, user_database_1.pgNodeIsKeyConflictError, wfCtx.operationName);
+                        await this.#recordError(func, wfid, funcId, txn_snapshot, e, user_database_1.pgNodeIsKeyConflictError, proc.name);
                     }, { isolationLevel: transaction_1.IsolationLevel.ReadCommitted });
                     await this.userDatabase.transaction(async (client) => {
                         const func = (sql, args) => this.userDatabase.queryWithClient(client, sql, ...args);
-                        await this.#recordError(func, wfCtx.workflowUUID, funcId, txn_snapshot, e, (error) => this.userDatabase.isKeyConflictError(error), wfCtx.operationName);
+                        await this.#recordError(func, wfid, funcId, txn_snapshot, e, (error) => this.userDatabase.isKeyConflictError(error), proc.name);
                     }, { isolationLevel: transaction_1.IsolationLevel.ReadCommitted });
                 }
                 throw err;
             }
         }
     }
-    async #callProcedureFunctionRemote(proc, args, wfCtx, span, config, funcId) {
-        if (this.isDebugging) {
+    async #callProcedureFunctionRemote(proc, args, span, config, funcId) {
+        if (this.debugMode) {
             throw new error_1.DBOSDebuggerError("Can't invoke stored procedure in debug mode.");
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+        const pctx = (0, context_1.getCurrentContextStore)();
+        const wfid = pctx.workflowId;
+        await this.systemDatabase.checkIfCanceled(wfid);
         const $jsonCtx = {
-            request: wfCtx.request,
-            authenticatedUser: wfCtx.authenticatedUser,
-            authenticatedRoles: wfCtx.authenticatedRoles,
-            assumedRole: wfCtx.assumedRole,
+            request: pctx.request,
+            authenticatedUser: pctx.authenticatedUser,
+            authenticatedRoles: pctx.authenticatedRoles,
+            assumedRole: pctx.assumedRole,
         };
         // TODO (Qian/Harry): remove this unshift when we remove the resultBuffer argument
         // Note, node-pg converts JS arrays to postgres array literals, so must call JSON.strigify on
         // args and bufferedResults before being passed to #invokeStoredProc
-        const $args = [wfCtx.workflowUUID, funcId, wfCtx.presetUUID, $jsonCtx, null, JSON.stringify(args)];
+        const $args = [wfid, funcId, pctx.presetID, $jsonCtx, null, JSON.stringify(args)];
         const readonly = config.readOnly ?? false;
         if (!readonly) {
             $args.unshift(null);
@@ -1222,103 +1225,96 @@ class DBOSExecutor {
     async external(stepFn, params, ...args) {
         return await (await this.startStepTempWF(stepFn, params, undefined, undefined, ...args)).getResult();
     }
-    async startStepTempWF(stepFn, params, callerUUID, callerFunctionID, ...args) {
+    async startStepTempWF(stepFn, params, callerWFID, callerFunctionID, ...args) {
         // Create a workflow and call external.
-        const temp_workflow = async (ctxt, ...args) => {
-            const ctxtImpl = ctxt;
-            return await this.callStepFunction(stepFn, undefined, undefined, params.configuredInstance ?? null, ctxtImpl, ...args);
+        const temp_workflow = async (...args) => {
+            return await this.callStepFunction(stepFn, undefined, undefined, params.configuredInstance ?? null, ...args);
         };
         return await this.internalWorkflow(temp_workflow, {
             ...params,
             tempWfType: exports.TempWorkflowType.step,
             tempWfName: (0, decorators_1.getRegisteredMethodName)(stepFn),
             tempWfClass: (0, decorators_1.getRegisteredMethodClassName)(stepFn),
-        }, callerUUID, callerFunctionID, ...args);
+        }, callerWFID, callerFunctionID, ...args);
     }
     /**
      * Execute a step function.
      * If it encounters any error, retry according to its configured retry policy until the maximum number of attempts is reached, then throw an DBOSError.
      * The step may execute many times, but once it is complete, it will not re-execute.
      */
-    async callStepFunction(stepFn, stepFnName, stepConfig, clsInst, wfCtx, ...args) {
+    async callStepFunction(stepFn, stepFnName, stepConfig, clsInst, ...args) {
         stepFnName = stepFnName ?? stepFn.name ?? '<unnamed>';
-        let passContext = false;
         if (!stepConfig) {
             const stepReg = this.getStepInfo(stepFn);
             stepConfig = stepReg?.config;
-            passContext = stepReg?.registration.passContext ?? true;
         }
         if (stepConfig === undefined) {
             throw new error_1.DBOSNotRegisteredError(stepFnName);
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
-        const funcID = wfCtx.functionIDGetIncrement();
+        const lctx = (0, context_1.getCurrentContextStore)();
+        const wfid = lctx.workflowId;
+        await this.systemDatabase.checkIfCanceled(wfid);
+        const funcID = (0, context_1.functionIDGetIncrement)();
         const maxRetryIntervalSec = 3600; // Maximum retry interval: 1 hour
         const span = this.tracer.startSpan(stepFnName, {
-            operationUUID: wfCtx.workflowUUID,
-            operationType: exports.OperationType.COMMUNICATOR,
-            authenticatedUser: wfCtx.authenticatedUser,
-            assumedRole: wfCtx.assumedRole,
-            authenticatedRoles: wfCtx.authenticatedRoles,
+            operationUUID: wfid,
+            operationType: exports.OperationType.STEP,
+            operationName: stepFnName,
+            authenticatedUser: lctx.authenticatedUser ?? '',
+            assumedRole: lctx.assumedRole ?? '',
+            authenticatedRoles: lctx.authenticatedRoles ?? [],
             retriesAllowed: stepConfig.retriesAllowed,
             intervalSeconds: stepConfig.intervalSeconds,
             maxAttempts: stepConfig.maxAttempts,
             backoffRate: stepConfig.backoffRate,
-        }, wfCtx.span);
-        const ctxt = new step_1.StepContextImpl(wfCtx, funcID, span, this.logger, stepConfig, stepFnName);
+        }, lctx.span);
         // Check if this execution previously happened, returning its original result if it did.
-        const checkr = await this.systemDatabase.getOperationResultAndThrowIfCancelled(wfCtx.workflowUUID, ctxt.functionID);
+        const checkr = await this.systemDatabase.getOperationResultAndThrowIfCancelled(wfid, funcID);
         if (checkr) {
-            if (checkr.functionName !== ctxt.operationName) {
-                throw new error_1.DBOSUnexpectedStepError(ctxt.workflowUUID, ctxt.functionID, ctxt.operationName, checkr.functionName ?? '?');
+            if (checkr.functionName !== stepFnName) {
+                throw new error_1.DBOSUnexpectedStepError(wfid, funcID, stepFnName, checkr.functionName ?? '?');
             }
             const check = DBOSExecutor.reviveResultOrError(checkr);
-            ctxt.span.setAttribute('cached', true);
-            ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
-            this.tracer.endSpan(ctxt.span);
+            span.setAttribute('cached', true);
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            this.tracer.endSpan(span);
             return check;
         }
-        if (this.isDebugging) {
-            throw new error_1.DBOSDebuggerError(`Failed to find the recorded output for the step: workflow UUID: ${wfCtx.workflowUUID}, step number: ${funcID}`);
+        if (this.debugMode) {
+            throw new error_1.DBOSDebuggerError(`Failed to find the recorded output for the step: workflow UUID: ${wfid}, step number: ${funcID}`);
         }
+        const maxAttempts = stepConfig.maxAttempts ?? 3;
         // Execute the step function.  If it throws an exception, retry with exponential backoff.
         // After reaching the maximum number of retries, throw an DBOSError.
         let result = exports.dbosNull;
         let err = exports.dbosNull;
         const errors = [];
-        if (ctxt.retriesAllowed) {
-            let numAttempts = 0;
-            let intervalSeconds = ctxt.intervalSeconds;
+        if (stepConfig.retriesAllowed) {
+            let attemptNum = 0;
+            let intervalSeconds = stepConfig.intervalSeconds ?? 1;
             if (intervalSeconds > maxRetryIntervalSec) {
                 this.logger.warn(`Step config interval exceeds maximum allowed interval, capped to ${maxRetryIntervalSec} seconds!`);
             }
-            while (result === exports.dbosNull && numAttempts++ < ctxt.maxAttempts) {
+            while (result === exports.dbosNull && attemptNum++ < (maxAttempts ?? 3)) {
                 try {
-                    await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+                    await this.systemDatabase.checkIfCanceled(wfid);
                     let cresult;
-                    if (passContext) {
-                        await (0, context_1.runWithStepContext)(ctxt, numAttempts, async () => {
-                            cresult = await stepFn.call(clsInst, ctxt, ...args);
-                        });
-                    }
-                    else {
-                        await (0, context_1.runWithStepContext)(ctxt, numAttempts, async () => {
-                            const sf = stepFn;
-                            cresult = await sf.call(clsInst, ...args);
-                        });
-                    }
+                    await (0, context_1.runInStepContext)(lctx, funcID, span, maxAttempts, attemptNum, async () => {
+                        const sf = stepFn;
+                        cresult = await sf.call(clsInst, ...args);
+                    });
                     result = cresult;
                 }
                 catch (error) {
                     const e = error;
                     errors.push(e);
-                    this.logger.warn(`Error in step being automatically retried. Attempt ${numAttempts} of ${ctxt.maxAttempts}. ${e.stack}`);
-                    span.addEvent(`Step attempt ${numAttempts + 1} failed`, { retryIntervalSeconds: intervalSeconds, error: error.message }, performance.now());
-                    if (numAttempts < ctxt.maxAttempts) {
+                    this.logger.warn(`Error in step being automatically retried. Attempt ${attemptNum} of ${maxAttempts}. ${e.stack}`);
+                    span.addEvent(`Step attempt ${attemptNum + 1} failed`, { retryIntervalSeconds: intervalSeconds, error: error.message }, performance.now());
+                    if (attemptNum < maxAttempts) {
                         // Sleep for an interval, then increase the interval by backoffRate.
                         // Cap at the maximum allowed retry interval.
                         await (0, utils_1.sleepms)(intervalSeconds * 1000);
-                        intervalSeconds *= ctxt.backoffRate;
+                        intervalSeconds *= stepConfig.backoffRate ?? 2;
                         intervalSeconds = intervalSeconds < maxRetryIntervalSec ? intervalSeconds : maxRetryIntervalSec;
                     }
                 }
@@ -1327,17 +1323,10 @@ class DBOSExecutor {
         else {
             try {
                 let cresult;
-                if (passContext) {
-                    await (0, context_1.runWithStepContext)(ctxt, undefined, async () => {
-                        cresult = await stepFn.call(clsInst, ctxt, ...args);
-                    });
-                }
-                else {
-                    await (0, context_1.runWithStepContext)(ctxt, undefined, async () => {
-                        const sf = stepFn;
-                        cresult = await sf.call(clsInst, ...args);
-                    });
-                }
+                await (0, context_1.runInStepContext)(lctx, funcID, span, maxAttempts, undefined, async () => {
+                    const sf = stepFn;
+                    cresult = await sf.call(clsInst, ...args);
+                });
                 result = cresult;
             }
             catch (error) {
@@ -1347,35 +1336,37 @@ class DBOSExecutor {
         // `result` can only be dbosNull when the step timed out
         if (result === exports.dbosNull) {
             // Record the error, then throw it.
-            err = err === exports.dbosNull ? new error_1.DBOSMaxStepRetriesError(stepFnName, ctxt.maxAttempts, errors) : err;
-            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, ctxt.operationName, true, {
+            err = err === exports.dbosNull ? new error_1.DBOSMaxStepRetriesError(stepFnName, maxAttempts, errors) : err;
+            await this.systemDatabase.recordOperationResult(wfid, funcID, stepFnName, true, {
                 error: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(err)),
             });
-            ctxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
-            this.tracer.endSpan(ctxt.span);
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
+            this.tracer.endSpan(span);
             throw err;
         }
         else {
             // Record the execution and return.
-            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, ctxt.operationName, true, {
+            await this.systemDatabase.recordOperationResult(wfid, funcID, stepFnName, true, {
                 output: utils_1.DBOSJSON.stringify(result),
             });
-            ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
-            this.tracer.endSpan(ctxt.span);
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            this.tracer.endSpan(span);
             return result;
         }
     }
-    async send(destinationUUID, message, topic, idempotencyKey) {
+    async send(destinationId, message, topic, idempotencyKey) {
         // Create a workflow and call send.
-        const temp_workflow = async (ctxt, destinationUUID, message, topic) => {
-            return await ctxt.send(destinationUUID, message, topic);
+        const temp_workflow = async (destinationId, message, topic) => {
+            const ctx = (0, context_1.getCurrentContextStore)();
+            const functionID = (0, context_1.functionIDGetIncrement)();
+            await this.systemDatabase.send(ctx.workflowId, functionID, destinationId, utils_1.DBOSJSON.stringify(message), topic);
         };
-        const workflowUUID = idempotencyKey ? destinationUUID + idempotencyKey : undefined;
+        const workflowUUID = idempotencyKey ? destinationId + idempotencyKey : undefined;
         return (await this.workflow(temp_workflow, {
             workflowUUID: workflowUUID,
             tempWfType: exports.TempWorkflowType.send,
             configuredInstance: null,
-        }, destinationUUID, message, topic)).getResult();
+        }, destinationId, message, topic)).getResult();
     }
     /**
      * Wait for a workflow to emit an event, then return its value.
@@ -1469,7 +1460,7 @@ class DBOSExecutor {
      * It runs to completion all pending workflows that were executing when the previous executor failed.
      */
     async recoverPendingWorkflows(executorIDs = ['local']) {
-        if (this.isDebugging) {
+        if (this.debugMode) {
             throw new error_1.DBOSDebuggerError('Cannot recover pending workflows in debug mode.');
         }
         const handlerArray = [];
@@ -1514,14 +1505,14 @@ class DBOSExecutor {
             await evtRcvr.initialize(this);
         }
         for (const lcl of (0, decorators_1.getLifecycleListeners)()) {
-            await lcl.initialize();
+            await lcl.initialize?.();
         }
     }
     async deactivateEventReceivers(stopQueueThread = true) {
         this.logger.debug('Deactivating lifecycle listeners');
         for (const lcl of (0, decorators_1.getLifecycleListeners)()) {
             try {
-                await lcl.destroy();
+                await lcl.destroy?.();
             }
             catch (err) {
                 const e = err;
@@ -1567,19 +1558,20 @@ class DBOSExecutor {
             throw new error_1.DBOSError(`Failed to find inputs for workflow UUID: ${workflowID}`);
         }
         const inputs = utils_1.DBOSJSON.parse(wfStatus.input);
-        const parentCtx = this.#getRecoveryContext(workflowID, wfStatus);
+        const recoverCtx = this.#getRecoveryContext(workflowID, wfStatus);
         const { wfInfo, configuredInst } = this.getWorkflowInfoByStatus(wfStatus);
         // If starting a new workflow, assign a new UUID. Otherwise, use the workflow's original UUID.
         const workflowStartID = startNewWorkflow ? undefined : workflowID;
         if (wfInfo) {
-            return this.workflow(wfInfo.workflow, {
-                workflowUUID: workflowStartID,
-                parentCtx: parentCtx,
-                configuredInstance: configuredInst,
-                queueName: wfStatus.queueName,
-                executeWorkflow: true,
-                deadlineEpochMS: wfStatus.deadlineEpochMS,
-            }, ...inputs);
+            return await (0, context_1.runWithTopContext)(recoverCtx, async () => {
+                return await this.workflow(wfInfo.workflow, {
+                    workflowUUID: workflowStartID,
+                    configuredInstance: configuredInst,
+                    queueName: wfStatus.queueName,
+                    executeWorkflow: true,
+                    deadlineEpochMS: wfStatus.deadlineEpochMS,
+                }, ...inputs);
+            });
         }
         // Should be temporary workflows. Parse the name of the workflow.
         const wfName = wfStatus.workflowName;
@@ -1588,20 +1580,20 @@ class DBOSExecutor {
             // CB - Doesn't this happen if the user changed the function name in their code?
             throw new error_1.DBOSError(`This should never happen! Cannot find workflow info for a non-temporary workflow! UUID ${workflowID}, name ${wfName}`);
         }
-        let temp_workflow;
         if (nameArr[1] === exports.TempWorkflowType.transaction) {
             const { txnInfo, clsInst } = this.getTransactionInfoByNames(wfStatus.workflowClassName, nameArr[2], wfStatus.workflowConfigName);
             if (!txnInfo) {
                 this.logger.error(`Cannot find transaction info for UUID ${workflowID}, name ${nameArr[2]}`);
                 throw new error_1.DBOSNotRegisteredError(nameArr[2]);
             }
-            return await this.startTransactionTempWF(txnInfo.transaction, {
-                workflowUUID: workflowStartID,
-                parentCtx: parentCtx ?? undefined,
-                configuredInstance: clsInst,
-                queueName: wfStatus.queueName,
-                executeWorkflow: true,
-            }, undefined, undefined, ...inputs);
+            return await (0, context_1.runWithTopContext)(recoverCtx, async () => {
+                return await this.startTransactionTempWF(txnInfo.transaction, {
+                    workflowUUID: workflowStartID,
+                    configuredInstance: clsInst,
+                    queueName: wfStatus.queueName,
+                    executeWorkflow: true,
+                }, undefined, undefined, ...inputs);
+            });
         }
         else if (nameArr[1] === exports.TempWorkflowType.step) {
             const { commInfo, clsInst } = this.getStepInfoByNames(wfStatus.workflowClassName, nameArr[2], wfStatus.workflowConfigName);
@@ -1609,25 +1601,30 @@ class DBOSExecutor {
                 this.logger.error(`Cannot find step info for UUID ${workflowID}, name ${nameArr[2]}`);
                 throw new error_1.DBOSNotRegisteredError(nameArr[2]);
             }
-            return await this.startStepTempWF(commInfo.step, {
-                workflowUUID: workflowStartID,
-                parentCtx: parentCtx ?? undefined,
-                configuredInstance: clsInst,
-                queueName: wfStatus.queueName, // Probably null
-                executeWorkflow: true,
-            }, undefined, undefined, ...inputs);
+            return await (0, context_1.runWithTopContext)(recoverCtx, async () => {
+                return await this.startStepTempWF(commInfo.step, {
+                    workflowUUID: workflowStartID,
+                    configuredInstance: clsInst,
+                    queueName: wfStatus.queueName, // Probably null
+                    executeWorkflow: true,
+                }, undefined, undefined, ...inputs);
+            });
         }
         else if (nameArr[1] === exports.TempWorkflowType.send) {
-            temp_workflow = async (ctxt, ...args) => {
-                return await ctxt.send(args[0], args[1], args[2]); // id, value, topic
+            const swf = async (destinationID, message, topic) => {
+                const ctx = (0, context_1.getCurrentContextStore)();
+                const functionID = (0, context_1.functionIDGetIncrement)();
+                await this.systemDatabase.send(ctx.workflowId, functionID, destinationID, utils_1.DBOSJSON.stringify(message), topic);
             };
-            return this.workflow(temp_workflow, {
-                workflowUUID: workflowStartID,
-                parentCtx: parentCtx ?? undefined,
-                tempWfType: exports.TempWorkflowType.send,
-                queueName: wfStatus.queueName,
-                executeWorkflow: true,
-            }, ...inputs);
+            const temp_workflow = swf;
+            return await (0, context_1.runWithTopContext)(recoverCtx, async () => {
+                return this.workflow(temp_workflow, {
+                    workflowUUID: workflowStartID,
+                    tempWfType: exports.TempWorkflowType.send,
+                    queueName: wfStatus.queueName,
+                    executeWorkflow: true,
+                }, ...inputs);
+            });
         }
         else {
             this.logger.error(`Unrecognized temporary workflow! UUID ${workflowID}, name ${wfName}`);
@@ -1640,14 +1637,13 @@ class DBOSExecutor {
     async upsertEventDispatchState(state) {
         return await this.systemDatabase.upsertEventDispatchState(state);
     }
-    #getRecoveryContext(workflowUUID, status) {
+    #getRecoveryContext(_workflowID, status) {
         // Note: this doesn't inherit the original parent context's span.
-        const oc = new context_1.DBOSContextImpl(status.workflowName, undefined, this.logger);
+        const oc = {};
         oc.request = status.request;
         oc.authenticatedUser = status.authenticatedUser;
         oc.authenticatedRoles = status.authenticatedRoles;
         oc.assumedRole = status.assumedRole;
-        oc.workflowUUID = workflowUUID;
         return oc;
     }
     async cancelWorkflow(workflowID) {