@dbos-inc/dbos-sdk 3.0.23-preview → 3.0.29-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 = {
@@ -96,51 +88,16 @@ class DBOSExecutor {
     procedurePool;
     // Temporary workflows are created by calling transaction/send/recv directly from the executor class
     static tempWorkflowName = 'temp_workflow';
-    workflowInfoMap = new Map([
-        // We initialize the map with an entry for temporary workflows.
-        [
-            DBOSExecutor.tempWorkflowName,
-            {
-                workflow: async () => {
-                    this.logger.error('UNREACHABLE: Indirect invoke of temp workflow');
-                    return Promise.resolve();
-                },
-                workflowOrigFunction: async () => {
-                    this.logger.error('UNREACHABLE: Indirect invoke of temp workflow');
-                    return Promise.resolve();
-                },
-                config: {},
-            },
-        ],
-    ]);
-    transactionInfoMap = new Map();
-    stepInfoMap = new Map();
-    procedureInfoMap = new Map();
-    registeredOperations = [];
     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 = [];
     drizzleEntities = {};
-    eventReceivers = [];
     scheduler = undefined;
     wfqEnded = undefined;
     executorID = utils_1.globalParams.executorID;
@@ -148,7 +105,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 +126,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);
@@ -253,39 +211,6 @@ class DBOSExecutor {
             this.logger.debug('Loaded Postgres user database');
         }
     }
-    #registerClass(clsname) {
-        const registeredClassOperations = (0, decorators_1.getRegisteredOperationsByClassname)(clsname);
-        this.registeredOperations.push(...registeredClassOperations);
-        for (const ro of registeredClassOperations) {
-            if (ro.workflowConfig) {
-                this.#registerWorkflow(ro);
-            }
-            else if (ro.txnConfig) {
-                this.#registerTransaction(ro);
-            }
-            else if (ro.stepConfig) {
-                this.#registerStep(ro);
-            }
-            else if (ro.procConfig) {
-                this.#registerProcedure(ro);
-            }
-            for (const [evtRcvr, _cfg] of ro.eventReceiverInfo) {
-                if (!this.eventReceivers.includes(evtRcvr))
-                    this.eventReceivers.push(evtRcvr);
-            }
-        }
-    }
-    getRegistrationsFor(obj) {
-        const res = [];
-        for (const r of this.registeredOperations) {
-            if (!r.eventReceiverInfo.has(obj))
-                continue;
-            const methodConfig = r.eventReceiverInfo.get(obj);
-            const classConfig = r.defaults?.eventReceiverInfo.get(obj) ?? {};
-            res.push({ methodReg: r, methodConfig, classConfig });
-        }
-        return res;
-    }
     async init(classes) {
         if (this.initialized) {
             this.logger.error('Workflow executor already initialized!');
@@ -318,7 +243,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();
@@ -326,12 +251,9 @@ class DBOSExecutor {
                 this.logger.error('No user database configured!');
                 throw new error_1.DBOSInitializationError('No user database configured!');
             }
-            for (const cls of classnames) {
-                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 +276,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);
@@ -362,7 +284,7 @@ class DBOSExecutor {
                     await cfg.initialize(new _1.InitContext());
                 }
             }
-            for (const v of this.registeredOperations) {
+            for (const v of (0, decorators_1.getAllRegisteredFunctions)()) {
                 const m = v;
                 if (m.init === true) {
                     this.logger.debug('Executing init method: ' + m.name);
@@ -422,109 +344,11 @@ class DBOSExecutor {
             throw err;
         }
     }
-    /* WORKFLOW OPERATIONS */
-    #registerWorkflow(ro) {
-        const wf = ro.registeredFunction;
-        if (wf.name === DBOSExecutor.tempWorkflowName) {
-            throw new error_1.DBOSError(`Unexpected use of reserved workflow name: ${wf.name}`);
-        }
-        const wfn = ro.className + '.' + ro.name;
-        if (this.workflowInfoMap.has(wfn)) {
-            throw new error_1.DBOSError(`Repeated workflow name: ${wfn}`);
-        }
-        const workflowInfo = {
-            workflow: wf,
-            workflowOrigFunction: ro.origFunction,
-            config: { ...ro.workflowConfig },
-            registration: ro,
-        };
-        this.workflowInfoMap.set(wfn, workflowInfo);
-        this.logger.debug(`Registered workflow ${wfn}`);
-    }
-    #registerTransaction(ro) {
-        const txf = ro.registeredFunction;
-        const tfn = ro.className + '.' + ro.name;
-        if (this.transactionInfoMap.has(tfn)) {
-            throw new error_1.DBOSError(`Repeated Transaction name: ${tfn}`);
-        }
-        const txnInfo = {
-            transaction: txf,
-            config: { ...ro.txnConfig },
-            registration: ro,
-        };
-        this.transactionInfoMap.set(tfn, txnInfo);
-        this.logger.debug(`Registered transaction ${tfn}`);
+    // This could return WF, or the function underlying a temp wf
+    #getFunctionInfoFromWFStatus(wf) {
+        const methReg = (0, decorators_1.getFunctionRegistrationByName)(wf.workflowClassName, wf.workflowName);
+        return { methReg, configuredInst: (0, decorators_1.getConfiguredInstance)(wf.workflowClassName, wf.workflowConfigName) };
     }
-    #registerStep(ro) {
-        const comm = ro.registeredFunction;
-        const cfn = ro.className + '.' + ro.name;
-        if (this.stepInfoMap.has(cfn)) {
-            throw new error_1.DBOSError(`Repeated Commmunicator name: ${cfn}`);
-        }
-        const stepInfo = {
-            step: comm,
-            config: { ...ro.stepConfig },
-            registration: ro,
-        };
-        this.stepInfoMap.set(cfn, stepInfo);
-        this.logger.debug(`Registered step ${cfn}`);
-    }
-    #registerProcedure(ro) {
-        const proc = ro.registeredFunction;
-        const cfn = ro.className + '.' + ro.name;
-        if (this.procedureInfoMap.has(cfn)) {
-            throw new error_1.DBOSError(`Repeated Procedure name: ${cfn}`);
-        }
-        const procInfo = {
-            procedure: proc,
-            config: { ...ro.procConfig },
-            registration: ro,
-        };
-        this.procedureInfoMap.set(cfn, procInfo);
-        this.logger.debug(`Registered stored proc ${cfn}`);
-    }
-    getWorkflowInfo(wf) {
-        const wfname = wf.name === DBOSExecutor.tempWorkflowName ? wf.name : (0, decorators_1.getRegisteredMethodClassName)(wf) + '.' + wf.name;
-        return this.workflowInfoMap.get(wfname);
-    }
-    getWorkflowInfoByStatus(wf) {
-        const wfname = wf.workflowClassName + '.' + wf.workflowName;
-        const wfInfo = this.workflowInfoMap.get(wfname);
-        // wfInfo may be undefined here, if this is a temp workflow
-        return { wfInfo, configuredInst: (0, decorators_1.getConfiguredInstance)(wf.workflowClassName, wf.workflowConfigName) };
-    }
-    getTransactionInfo(tf) {
-        const tfname = (0, decorators_1.getRegisteredMethodClassName)(tf) + '.' + tf.name;
-        return this.transactionInfoMap.get(tfname);
-    }
-    getTransactionInfoByNames(className, functionName, cfgName) {
-        const tfname = className + '.' + functionName;
-        const txnInfo = this.transactionInfoMap.get(tfname);
-        if (!txnInfo) {
-            throw new error_1.DBOSNotRegisteredError(tfname, `Transaction function name '${tfname}' is not registered.`);
-        }
-        return { txnInfo, clsInst: (0, decorators_1.getConfiguredInstance)(className, cfgName) };
-    }
-    getStepInfo(cf) {
-        const cfname = (0, decorators_1.getRegisteredMethodClassName)(cf) + '.' + cf.name;
-        return this.stepInfoMap.get(cfname);
-    }
-    getStepInfoByNames(className, functionName, cfgName) {
-        const cfname = className + '.' + functionName;
-        const stepInfo = this.stepInfoMap.get(cfname);
-        if (!stepInfo) {
-            throw new error_1.DBOSNotRegisteredError(cfname, `Step function name '${cfname}' is not registered.`);
-        }
-        return { commInfo: stepInfo, clsInst: (0, decorators_1.getConfiguredInstance)(className, cfgName) };
-    }
-    getProcedureClassName(pf) {
-        return (0, decorators_1.getRegisteredMethodClassName)(pf);
-    }
-    getProcedureInfo(pf) {
-        const pfName = (0, decorators_1.getRegisteredMethodClassName)(pf) + '.' + pf.name;
-        return this.procedureInfoMap.get(pfName);
-    }
-    // TODO: getProcedureInfoByNames??
     static reviveResultOrError(r, success) {
         if (success === true || !r.error) {
             return utils_1.DBOSJSON.parse(r.output ?? null);
@@ -536,7 +360,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 +384,43 @@ class DBOSExecutor {
                 this.logger.warn(`Priority is not enabled for queue ${params.queueName}. Setting priority will not have any effect.`);
             }
         }
-        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 pctx = (0, context_1.getCurrentContextStore)();
+        let wConfig = {};
+        const wInfo = (0, decorators_1.getFunctionRegistration)(wf);
+        if (wf.name !== DBOSExecutor.tempWorkflowName) {
+            if (!wInfo || !wInfo.workflowConfig) {
+                throw new error_1.DBOSNotRegisteredError(wf.name);
+            }
+            wConfig = wInfo.workflowConfig;
+        }
+        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?.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: (0, decorators_1.getRegisteredFunctionName)(wf),
+            workflowClassName: isTempWorkflow ? '' : (0, decorators_1.getRegisteredFunctionClassName)(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 +428,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 +454,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 +492,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 +517,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 +535,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 +567,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 +637,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 +659,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 {
@@ -841,70 +684,64 @@ class DBOSExecutor {
         }
         return rows;
     }
-    async transaction(txn, params, ...args) {
+    async runTransactionTempWF(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);
+            tempWfName: (0, decorators_1.getRegisteredFunctionName)(txn),
+            tempWfClass: (0, decorators_1.getRegisteredFunctionClassName)(txn),
+        }, callerWFID, callerFunctionID, ...args);
     }
-    async callTransactionFunction(txn, clsinst, wfCtx, ...args) {
-        const txnInfo = this.getTransactionInfo(txn);
-        if (txnInfo === undefined) {
+    async callTransactionFunction(txn, clsinst, ...args) {
+        const txnReg = (0, decorators_1.getFunctionRegistration)(txn);
+        if (!txnReg || !txnReg.txnConfig) {
             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,
-            isolationLevel: txnInfo.config.isolationLevel,
-        }, wfCtx.span);
+            operationName: txn.name,
+            authenticatedUser: pctx.authenticatedUser ?? '',
+            assumedRole: pctx.assumedRole ?? '',
+            authenticatedRoles: pctx.authenticatedRoles ?? [],
+            isolationLevel: txnReg.txnConfig.isolationLevel,
+        }, 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 +749,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 +791,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;
@@ -964,7 +806,7 @@ class DBOSExecutor {
                 return result;
             };
             try {
-                const result = await this.userDatabase.transaction(wrappedTransaction, txnInfo.config);
+                const result = await this.userDatabase.transaction(wrappedTransaction, txnReg.txnConfig);
                 span.setStatus({ code: api_1.SpanStatusCode.OK });
                 this.tracer.endSpan(span);
                 return result;
@@ -985,7 +827,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 });
@@ -994,40 +836,43 @@ class DBOSExecutor {
             }
         }
     }
-    async procedure(proc, params, ...args) {
+    async runProcedureTempWF(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,
             tempWfType: exports.TempWorkflowType.procedure,
-            tempWfName: (0, decorators_1.getRegisteredMethodName)(proc),
-            tempWfClass: (0, decorators_1.getRegisteredMethodClassName)(proc),
+            tempWfName: (0, decorators_1.getRegisteredFunctionName)(proc),
+            tempWfClass: (0, decorators_1.getRegisteredFunctionClassName)(proc),
         }, ...args)).getResult();
     }
-    async callProcedureFunction(proc, wfCtx, ...args) {
-        const procInfo = this.getProcedureInfo(proc);
-        if (procInfo === undefined) {
+    async callProcedureFunction(proc, ...args) {
+        const procInfo = (0, decorators_1.getFunctionRegistration)(proc);
+        if (!procInfo || !procInfo.procConfig) {
             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 procConfig = procInfo.procConfig;
+        const pctx = (0, context_1.getCurrentContextStore)();
+        const wfid = pctx.workflowId;
+        await this.systemDatabase.checkIfCanceled(wfid);
+        const executeLocally = this.debugMode || (procConfig.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,
-            isolationLevel: procInfo.config.isolationLevel,
+            operationName: proc.name,
+            authenticatedUser: pctx.authenticatedUser ?? '',
+            assumedRole: pctx.assumedRole ?? '',
+            authenticatedRoles: pctx.authenticatedRoles ?? [],
+            isolationLevel: procInfo.procConfig.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, procConfig, funcId);
             span.setStatus({ code: api_1.SpanStatusCode.OK });
             return result;
         }
@@ -1040,35 +885,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 +916,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,20 +961,20 @@ 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 {
                 const result = await this.invokeStoredProcFunction(wrappedProcedure, {
-                    isolationLevel: procInfo.config.isolationLevel,
+                    isolationLevel: procInfo.procConfig.isolationLevel,
                 });
                 span.setStatus({ code: api_1.SpanStatusCode.OK });
                 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 +988,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);
@@ -1185,8 +1036,8 @@ class DBOSExecutor {
     async #invokeStoredProc(proc, args) {
         const client = await this.procedurePool.connect();
         const log = (msg) => this.#logNotice(msg);
-        const procClassName = this.getProcedureClassName(proc);
-        const plainProcName = `${procClassName}_${proc.name}_p`;
+        const procname = (0, decorators_1.getRegisteredFunctionFullName)(proc);
+        const plainProcName = `${procname.className}_${procname.name}_p`;
         const procName = utils_1.globalParams.wasComputed ? plainProcName : `v${utils_1.globalParams.appVersion}_${plainProcName}`;
         const sql = `CALL "${procName}"(${args.map((_v, i) => `$${i + 1}`).join()});`;
         try {
@@ -1219,106 +1070,99 @@ class DBOSExecutor {
             client.release();
         }
     }
-    async external(stepFn, params, ...args) {
+    async runStepTempWF(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);
+            tempWfName: (0, decorators_1.getRegisteredFunctionName)(stepFn),
+            tempWfClass: (0, decorators_1.getRegisteredFunctionClassName)(stepFn),
+        }, 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;
+            const stepReg = (0, decorators_1.getFunctionRegistration)(stepFn);
+            stepConfig = stepReg?.stepConfig;
         }
         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 +1171,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 +1184,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 runSendTempWF(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.
@@ -1443,33 +1282,13 @@ class DBOSExecutor {
             return await this.userDatabase.query(sql);
         }
     }
-    async userDBListen(channels, callback) {
-        const notificationsClient = await this.procedurePool.connect();
-        for (const nname of channels) {
-            await notificationsClient.query(`LISTEN ${nname};`);
-        }
-        notificationsClient.on('notification', callback);
-        return {
-            close: async () => {
-                for (const nname of channels) {
-                    try {
-                        await notificationsClient.query(`UNLISTEN ${nname};`);
-                    }
-                    catch (e) {
-                        this.logger.warn(e);
-                    }
-                    notificationsClient.release();
-                }
-            },
-        };
-    }
     /* INTERNAL HELPERS */
     /**
      * A recovery process that by default runs during executor init time.
      * 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 = [];
@@ -1510,34 +1329,22 @@ class DBOSExecutor {
         this.scheduler = new scheduler_1.DBOSScheduler(this);
         this.scheduler.initScheduler();
         this.wfqEnded = wfqueue_1.wfQueueRunner.dispatchLoop(this);
-        for (const evtRcvr of this.eventReceivers) {
-            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;
                 this.logger.warn(`Error destroying lifecycle listener: ${e.message}`);
             }
         }
-        this.logger.debug('Deactivating event receivers');
-        for (const evtRcvr of this.eventReceivers || []) {
-            try {
-                await evtRcvr.destroy();
-            }
-            catch (err) {
-                const e = err;
-                this.logger.warn(`Error destroying event receiver: ${e.message}`);
-            }
-        }
+        this.logger.debug('Deactivating scheduler');
         try {
             await this.scheduler?.destroyScheduler();
         }
@@ -1545,6 +1352,7 @@ class DBOSExecutor {
             const e = err;
             this.logger.warn(`Error destroying scheduler: ${e.message}`);
         }
+        this.logger.debug('Deactivating queue runner');
         if (stopQueueThread) {
             try {
                 wfqueue_1.wfQueueRunner.stop();
@@ -1567,67 +1375,72 @@ 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 { wfInfo, configuredInst } = this.getWorkflowInfoByStatus(wfStatus);
+        const recoverCtx = this.#getRecoveryContext(workflowID, wfStatus);
+        const { methReg, configuredInst } = this.#getFunctionInfoFromWFStatus(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);
+        if (methReg?.workflowConfig) {
+            return await (0, context_1.runWithTopContext)(recoverCtx, async () => {
+                return await this.workflow(methReg.registeredFunction, {
+                    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;
         const nameArr = wfName.split('-');
         if (!nameArr[0].startsWith(DBOSExecutor.tempWorkflowName)) {
-            // 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}`);
+            throw new error_1.DBOSError(`Cannot find workflow function for a non-temporary workflow, ID ${workflowID}, class '${wfStatus.workflowClassName}', function '${wfName}'; did you change your code?`);
         }
-        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]}`);
+            const txnReg = (0, decorators_1.getFunctionRegistrationByName)(wfStatus.workflowClassName, nameArr[2]);
+            if (!txnReg?.txnConfig) {
+                this.logger.error(`Cannot find transaction info for ID ${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(txnReg.registeredFunction, {
+                    workflowUUID: workflowStartID,
+                    configuredInstance: configuredInst,
+                    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);
-            if (!commInfo) {
-                this.logger.error(`Cannot find step info for UUID ${workflowID}, name ${nameArr[2]}`);
+            const stepReg = (0, decorators_1.getFunctionRegistrationByName)(wfStatus.workflowClassName, nameArr[2]);
+            if (!stepReg?.stepConfig) {
+                this.logger.error(`Cannot find step info for ID ${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(stepReg.registeredFunction, {
+                    workflowUUID: workflowStartID,
+                    configuredInstance: configuredInst,
+                    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 +1453,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) {
@@ -1671,7 +1483,7 @@ class DBOSExecutor {
     }
     logRegisteredHTTPUrls() {
         this.logger.info('HTTP endpoints supported:');
-        this.registeredOperations.forEach((registeredOperation) => {
+        (0, decorators_1.getAllRegisteredFunctions)().forEach((registeredOperation) => {
             const ro = registeredOperation;
             if (ro.apiURL) {
                 this.logger.info('    ' + ro.apiType.padEnd(6) + '  :  ' + ro.apiURL);
@@ -1699,8 +1511,9 @@ class DBOSExecutor {
      */
     computeAppVersion() {
         const hasher = crypto.createHash('md5');
-        const sortedWorkflowSource = Array.from(this.workflowInfoMap.values())
-            .map((i) => i.workflowOrigFunction.toString())
+        const sortedWorkflowSource = Array.from((0, decorators_1.getAllRegisteredFunctions)())
+            .filter((e) => e.workflowConfig)
+            .map((i) => i.origFunction.toString())
             .sort();
         // Different DBOS versions should produce different hashes.
         sortedWorkflowSource.push(utils_1.globalParams.dbosVersion);