@dbos-inc/dbos-sdk 4.10.7-preview → 4.10.9-preview

package/dist/src/system_database.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresSystemDatabase = exports.ensureSystemDatabase = exports.grantDbosSchemaPermissions = exports.DBOS_STREAM_CLOSED_SENTINEL = exports.DEFAULT_POOL_SIZE = exports.DBOS_FUNCNAME_CLOSESTREAM = exports.DBOS_FUNCNAME_WRITESTREAM = exports.DBOS_FUNCNAME_GETSTATUS = exports.DBOS_FUNCNAME_SLEEP = exports.DBOS_FUNCNAME_GETEVENT = exports.DBOS_FUNCNAME_SETEVENT = exports.DBOS_FUNCNAME_RECV = exports.DBOS_FUNCNAME_SEND = void 0;
+exports.SystemDatabase = exports.ensureSystemDatabase = exports.grantDbosSchemaPermissions = exports.DBOS_STREAM_CLOSED_SENTINEL = exports.DEFAULT_POOL_SIZE = exports.DBOS_FUNCNAME_CLOSESTREAM = exports.DBOS_FUNCNAME_WRITESTREAM = exports.DBOS_FUNCNAME_GETSTATUS = exports.DBOS_FUNCNAME_SLEEP = exports.DBOS_FUNCNAME_GETEVENT = exports.DBOS_FUNCNAME_SETEVENT = exports.DBOS_FUNCNAME_RECV = exports.DBOS_FUNCNAME_SEND = void 0;
 const dbos_executor_1 = require("./dbos-executor");
 const pg_1 = require("pg");
 const error_1 = require("./error");
@@ -146,180 +146,6 @@ class NotificationMap {
         }
     }
 }
-async function insertWorkflowStatus(client, initStatus, schemaName, ownerXid, incrementAttempts = false) {
-    try {
-        const { rows } = await client.query(`INSERT INTO "${schemaName}".workflow_status (
-        workflow_uuid,
-        status,
-        name,
-        class_name,
-        config_name,
-        queue_name,
-        authenticated_user,
-        assumed_role,
-        authenticated_roles,
-        request,
-        executor_id,
-        application_version,
-        application_id,
-        created_at,
-        recovery_attempts,
-        updated_at,
-        workflow_timeout_ms,
-        workflow_deadline_epoch_ms,
-        inputs,
-        deduplication_id,
-        priority,
-        queue_partition_key,
-        forked_from,
-        parent_workflow_id,
-        serialization,
-        owner_xid
-      ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $26, $27)
-      ON CONFLICT (workflow_uuid)
-        DO UPDATE SET
-          recovery_attempts = CASE
-            WHEN workflow_status.status != '${workflow_1.StatusString.ENQUEUED}'
-            THEN workflow_status.recovery_attempts + $25
-            ELSE workflow_status.recovery_attempts
-          END,
-          updated_at = EXCLUDED.updated_at,
-          executor_id = CASE
-            WHEN EXCLUDED.status != '${workflow_1.StatusString.ENQUEUED}'
-            THEN EXCLUDED.executor_id
-            ELSE workflow_status.executor_id
-          END
-        RETURNING recovery_attempts, status, name, class_name, config_name, queue_name, workflow_deadline_epoch_ms, executor_id, owner_xid, serialization`, [
-            initStatus.workflowUUID,
-            initStatus.status,
-            initStatus.workflowName,
-            // For cross-language compatibility, these variables MUST be NULL in the database when not set
-            initStatus.workflowClassName === '' ? null : initStatus.workflowClassName,
-            initStatus.workflowConfigName === '' ? null : initStatus.workflowConfigName,
-            initStatus.queueName ?? null,
-            initStatus.authenticatedUser,
-            initStatus.assumedRole,
-            JSON.stringify(initStatus.authenticatedRoles),
-            JSON.stringify(initStatus.request),
-            initStatus.executorId,
-            initStatus.applicationVersion ?? null,
-            initStatus.applicationID,
-            initStatus.createdAt,
-            initStatus.status === workflow_1.StatusString.ENQUEUED ? 0 : 1,
-            initStatus.updatedAt ?? Date.now(),
-            initStatus.timeoutMS ?? null,
-            initStatus.deadlineEpochMS ?? null,
-            initStatus.input ?? null,
-            initStatus.deduplicationID ?? null,
-            initStatus.priority,
-            initStatus.queuePartitionKey ?? null,
-            initStatus.forkedFrom ?? null,
-            initStatus.parentWorkflowID ?? null,
-            (incrementAttempts ?? false) ? 1 : 0,
-            initStatus.serialization,
-            ownerXid,
-        ]);
-        if (rows.length === 0) {
-            throw new Error(`Attempt to insert workflow ${initStatus.workflowUUID} failed`);
-        }
-        const ret = rows[0];
-        ret.class_name = ret.class_name ?? '';
-        ret.config_name = ret.config_name ?? '';
-        initStatus.serialization = ret.serialization;
-        return ret;
-    }
-    catch (error) {
-        const err = error;
-        if (err.code === '23505') {
-            throw new error_1.DBOSQueueDuplicatedError(initStatus.workflowUUID, initStatus.queueName ?? '', initStatus.deduplicationID ?? '');
-        }
-        throw error;
-    }
-}
-async function getWorkflowStatusValue(client, workflowID, schemaName) {
-    const { rows } = await client.query(`SELECT status FROM "${schemaName}".workflow_status WHERE workflow_uuid=$1`, [workflowID]);
-    return rows.length === 0 ? undefined : rows[0].status;
-}
-async function updateWorkflowStatus(client, workflowID, status, schemaName, options = {}) {
-    let setClause = `SET status=$2, updated_at=$3`;
-    let whereClause = `WHERE workflow_uuid=$1`;
-    const args = [workflowID, status, Date.now()];
-    const update = options.update ?? {};
-    if (update.output) {
-        const param = args.push(update.output);
-        setClause += `, output=$${param}`;
-    }
-    if (update.error) {
-        const param = args.push(update.error);
-        setClause += `, error=$${param}`;
-    }
-    if (update.resetRecoveryAttempts) {
-        setClause += `, recovery_attempts = 0`;
-    }
-    if (update.resetDeadline) {
-        setClause += `, workflow_deadline_epoch_ms = NULL`;
-    }
-    if (update.queueName !== undefined) {
-        const param = args.push(update.queueName ?? undefined);
-        setClause += `, queue_name=$${param}`;
-    }
-    if (update.resetDeduplicationID) {
-        setClause += `, deduplication_id = NULL`;
-    }
-    if (update.resetStartedAtEpochMs) {
-        setClause += `, started_at_epoch_ms = NULL`;
-    }
-    if (update.executorId !== undefined) {
-        const param = args.push(update.executorId ?? undefined);
-        setClause += `, executor_id=$${param}`;
-    }
-    if (update.resetNameTo !== undefined) {
-        const param = args.push(update.resetNameTo ?? undefined);
-        setClause += `, name=$${param}`;
-    }
-    const where = options.where ?? {};
-    if (where.status) {
-        const param = args.push(where.status);
-        whereClause += ` AND status=$${param}`;
-    }
-    const result = await client.query(`UPDATE "${schemaName}".workflow_status ${setClause} ${whereClause}`, args);
-    const throwOnFailure = options.throwOnFailure ?? true;
-    if (throwOnFailure && result.rowCount !== 1) {
-        throw new error_1.DBOSWorkflowConflictError(`Attempt to record transition of nonexistent workflow ${workflowID}`);
-    }
-}
-async function recordOperationResult(client, workflowID, functionID, functionName, checkConflict, schemaName, startTimeEpochMs, endTimeEpochMs, options = {}) {
-    try {
-        const out = await client.query(`INSERT INTO ${schemaName}.operation_outputs
-       (workflow_uuid, function_id, output, error, function_name, child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms, serialization)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-       ON CONFLICT DO NOTHING RETURNING completed_at_epoch_ms;`, [
-            workflowID,
-            functionID,
-            options.output ?? null,
-            options.error ?? null,
-            functionName,
-            options.childWorkflowID ?? null,
-            startTimeEpochMs,
-            endTimeEpochMs,
-            options.serialization ?? null,
-        ]);
-        if (checkConflict && (out?.rowCount ?? 0) > 0 && Number(out?.rows?.[0]?.completed_at_epoch_ms) !== endTimeEpochMs) {
-            dbos_executor_1.DBOSExecutor.globalInstance?.logger.warn(`Step output for ${workflowID}(${functionID}):${functionName} already recorded`);
-            throw new error_1.DBOSWorkflowConflictError(workflowID);
-        }
-    }
-    catch (error) {
-        const err = error;
-        if (err.code === '40001' || err.code === '23505') {
-            // Serialization and primary key conflict (Postgres).
-            throw new error_1.DBOSWorkflowConflictError(workflowID);
-        }
-        else {
-            throw err;
-        }
-    }
-}
 function mapWorkflowStatus(row) {
     return {
         workflowUUID: row.workflow_uuid,
@@ -489,10 +315,22 @@ function dbRetry(options = {}) {
         return descriptor;
     };
 }
-class PostgresSystemDatabase {
+/**
+ * General notes:
+ *   The responsibilities of the `SystemDatabase` are to store data for workflows, and
+ *     associated steps, transactions, messages, and events.  The system DB is
+ *     also the IPC mechanism that performs notifications when things change, for
+ *     example a receive is unblocked when a send occurs, or a cancel interrupts
+ *     the receive.
+ *   The `SystemDatabase` expects values in inputs/outputs/errors to be JSON.  However,
+ *     the serialization process of turning data into JSON or converting it back, should
+ *     be done elsewhere (executor), as it may require application-specific logic or extensions.
+ */
+class SystemDatabase {
     systemDatabaseUrl;
     logger;
     serializer;
+    // ==================== Lifecycle ====================
     pool;
     schemaName;
     /*
@@ -574,6 +412,7 @@ class PostgresSystemDatabase {
         }
         await this.pool.end();
     }
+    // ==================== Workflow Status ====================
     async initWorkflowStatus(initStatus, ownerXid, options) {
         const client = await this.pool.connect();
         let shouldCommit = false;
@@ -581,7 +420,7 @@ class PostgresSystemDatabase {
             await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
             // Moving from enqueued to pending asks to increment recovery attempts... rather than in the recovery process
             //  where it moves from pending back to enqueued.
-            const resRow = await insertWorkflowStatus(client, initStatus, this.schemaName, ownerXid, !!options?.isRecoveryRequest || !!options?.isDequeuedRequest);
+            const resRow = await this.insertWorkflowStatus(client, initStatus, ownerXid, !!options?.isRecoveryRequest || !!options?.isDequeuedRequest);
             if (resRow.name !== initStatus.workflowName) {
                 const msg = `Workflow already exists with a different function name: ${resRow.name}, but the provided function name is: ${initStatus.workflowName}`;
                 throw new error_1.DBOSConflictingWorkflowError(initStatus.workflowUUID, msg);
@@ -617,7 +456,7 @@ class PostgresSystemDatabase {
             // Thus, when this number becomes equal to `maxRetries + 1`, we should mark the workflow as `MAX_RECOVERY_ATTEMPTS_EXCEEDED`.
             const attempts = resRow.recovery_attempts;
             if (options?.maxRetries && attempts > options?.maxRetries + 1) {
-                await updateWorkflowStatus(client, initStatus.workflowUUID, workflow_1.StatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED, this.schemaName, {
+                await this.updateWorkflowStatus(client, initStatus.workflowUUID, workflow_1.StatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED, {
                     where: { status: workflow_1.StatusString.PENDING },
                     throwOnFailure: false,
                 });
@@ -649,7 +488,7 @@ class PostgresSystemDatabase {
     async recordWorkflowOutput(workflowID, status) {
         const client = await this.pool.connect();
         try {
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.SUCCESS, this.schemaName, {
+            await this.updateWorkflowStatus(client, workflowID, workflow_1.StatusString.SUCCESS, {
                 update: { output: status.output, resetDeduplicationID: true },
             });
         }
@@ -660,7 +499,7 @@ class PostgresSystemDatabase {
     async recordWorkflowError(workflowID, status) {
         const client = await this.pool.connect();
         try {
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ERROR, this.schemaName, {
+            await this.updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ERROR, {
                 update: { error: status.error, resetDeduplicationID: true },
             });
         }
@@ -677,23 +516,44 @@ class PostgresSystemDatabase {
             queueName: i.queue_name,
         }));
     }
-    async #getOperationResultAndThrowIfCancelled(client, workflowID, functionID) {
-        await this.#checkIfCanceled(client, workflowID);
-        const { rows } = await client.query(`SELECT output, error, child_workflow_id, function_name
-       FROM "${this.schemaName}".operation_outputs
-      WHERE workflow_uuid=$1 AND function_id=$2`, [workflowID, functionID]);
-        if (rows.length === 0) {
-            return undefined;
+    async getWorkflowStatus(workflowID, callerID, callerFN) {
+        const funcGetStatus = async () => {
+            const statuses = await this.listWorkflows({ workflowIDs: [workflowID] });
+            const status = statuses.find((s) => s.workflowUUID === workflowID);
+            return status ? JSON.stringify(status) : null;
+        };
+        if (callerID && callerFN) {
+            const client = await this.pool.connect();
+            try {
+                // Check if the operation has been done before for OAOO (only do this inside a workflow).
+                const json = await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_GETSTATUS, callerID, callerFN, funcGetStatus);
+                return parseStatus(json);
+            }
+            finally {
+                client.release();
+            }
         }
         else {
-            return {
-                output: rows[0].output,
-                error: rows[0].error,
-                childWorkflowID: rows[0].child_workflow_id,
-                functionName: rows[0].function_name,
-            };
+            const json = await funcGetStatus();
+            return parseStatus(json);
+        }
+        function parseStatus(json) {
+            return json ? JSON.parse(json) : null;
+        }
+    }
+    // Only used in tests
+    async setWorkflowStatus(workflowID, status, resetRecoveryAttempts, internalOptions) {
+        const client = await this.pool.connect();
+        try {
+            await this.updateWorkflowStatus(client, workflowID, status, {
+                update: { resetRecoveryAttempts, resetNameTo: internalOptions?.updateName },
+            });
+        }
+        finally {
+            client.release();
         }
     }
+    // ==================== Step Results ====================
     async getOperationResultAndThrowIfCancelled(workflowID, functionID) {
         const client = await this.pool.connect();
         try {
@@ -711,13 +571,194 @@ class PostgresSystemDatabase {
         const client = await this.pool.connect();
         const now = Date.now();
         try {
-            await recordOperationResult(client, workflowID, functionID, functionName, checkConflict, this.schemaName, startTimeEpochMs, now, options);
+            await this.recordOperationResultInternal(client, workflowID, functionID, functionName, checkConflict, startTimeEpochMs, now, options);
         }
         finally {
             client.release();
             await (0, debugpoint_1.debugTriggerPoint)(debugpoint_1.DEBUG_TRIGGER_STEP_COMMIT);
         }
     }
+    async runTransactionalStep(workflowID, functionID, functionName, callback) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
+            const existing = await this.#getOperationResultAndThrowIfCancelled(client, workflowID, functionID);
+            if (existing !== undefined) {
+                await client.query('ROLLBACK');
+                return existing;
+            }
+            const startTime = Date.now();
+            const output = await callback(client);
+            await this.recordOperationResultInternal(client, workflowID, functionID, functionName, true, startTime, Date.now(), {
+                output,
+            });
+            await client.query('COMMIT');
+            return undefined;
+        }
+        catch (e) {
+            await client.query('ROLLBACK');
+            throw e;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async checkPatch(workflowID, functionID, patchName, deprecated) {
+        // Not doing a cancel check at this point.
+        if (functionID === undefined)
+            throw new TypeError('functionID must be defined');
+        patchName = `DBOS.patch-${patchName}`;
+        const { rows } = await this.pool.query(`SELECT function_name
+       FROM "${this.schemaName}".operation_outputs
+      WHERE workflow_uuid=$1 AND function_id=$2`, [workflowID, functionID]);
+        if (deprecated) {
+            // Deprecated does not write anything.  We skip any existing matching patch marker if it matches
+            if (rows.length === 0) {
+                return { isPatched: true, hasEntry: false };
+            }
+            return { isPatched: true, hasEntry: rows[0].function_name === patchName };
+        }
+        // Nondeprecated - skip matching entry, unpatched if nonmatching entry,
+        //  If there is no entry, we insert one that indicates it is patched.
+        if (rows.length !== 0) {
+            if (rows[0].function_name === patchName) {
+                return { isPatched: true, hasEntry: true };
+            }
+            return { isPatched: false, hasEntry: false };
+        }
+        // Insert a patchmarker
+        const dn = Date.now();
+        await this.pool.query(`INSERT INTO ${this.schemaName}.operation_outputs
+       (workflow_uuid, function_id, output, error, function_name, child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+       ON CONFLICT DO NOTHING;`, [workflowID, functionID, null, null, patchName, null, dn, dn]);
+        return { isPatched: true, hasEntry: true };
+    }
+    // ==================== Workflow Management ====================
+    async cancelWorkflow(workflowID) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
+            const statusResult = await this.getWorkflowStatusValue(client, workflowID);
+            if (!statusResult) {
+                throw new error_1.DBOSNonExistentWorkflowError(`Workflow ${workflowID} does not exist`);
+            }
+            if (statusResult === workflow_1.StatusString.SUCCESS ||
+                statusResult === workflow_1.StatusString.ERROR ||
+                statusResult === workflow_1.StatusString.CANCELLED) {
+                await client.query('ROLLBACK');
+                return;
+            }
+            // Set the workflow's status to CANCELLED and remove it from any queue it is on
+            await this.updateWorkflowStatus(client, workflowID, workflow_1.StatusString.CANCELLED, {
+                update: { queueName: null, resetDeduplicationID: true, resetStartedAtEpochMs: true },
+            });
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            this.logger.error(error);
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+        this.#setWFCancelMap(workflowID);
+    }
+    async checkIfCanceled(workflowID) {
+        const client = await this.pool.connect();
+        try {
+            await this.#checkIfCanceled(client, workflowID);
+        }
+        finally {
+            client.release();
+        }
+    }
+    async resumeWorkflow(workflowID) {
+        this.#clearWFCancelMap(workflowID);
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN ISOLATION LEVEL REPEATABLE READ');
+            // Check workflow status. If it is complete, do nothing.
+            const statusResult = await this.getWorkflowStatusValue(client, workflowID);
+            if (!statusResult || statusResult === workflow_1.StatusString.SUCCESS || statusResult === workflow_1.StatusString.ERROR) {
+                await client.query('ROLLBACK');
+                if (!statusResult) {
+                    if (statusResult === undefined) {
+                        throw new error_1.DBOSNonExistentWorkflowError(`Workflow ${workflowID} does not exist`);
+                    }
+                }
+                return;
+            }
+            // Set the workflow's status to ENQUEUED and reset recovery attempts and deadline.
+            await this.updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ENQUEUED, {
+                update: {
+                    queueName: utils_1.INTERNAL_QUEUE_NAME,
+                    resetRecoveryAttempts: true,
+                    resetDeadline: true,
+                    resetDeduplicationID: true,
+                    resetStartedAtEpochMs: true,
+                },
+                throwOnFailure: false,
+            });
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            this.logger.error(error);
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async getWorkflowChildren(workflowID) {
+        // BFS to find all descendant workflows
+        const visited = new Set([workflowID]);
+        const queue = [workflowID];
+        const children = [];
+        const client = await this.pool.connect();
+        try {
+            while (queue.length > 0) {
+                const batch = queue.splice(0, queue.length);
+                const result = await client.query(`SELECT DISTINCT child_workflow_id
+           FROM "${this.schemaName}".operation_outputs
+           WHERE workflow_uuid = ANY($1)
+             AND child_workflow_id IS NOT NULL`, [batch]);
+                for (const row of result.rows) {
+                    if (!visited.has(row.child_workflow_id)) {
+                        visited.add(row.child_workflow_id);
+                        queue.push(row.child_workflow_id);
+                        children.push(row.child_workflow_id);
+                    }
+                }
+            }
+        }
+        finally {
+            client.release();
+        }
+        return children;
+    }
+    async deleteWorkflow(workflowID, deleteChildren = false) {
+        let workflowsToDelete = [workflowID];
+        if (deleteChildren) {
+            const children = await this.getWorkflowChildren(workflowID);
+            workflowsToDelete = [...workflowsToDelete, ...children];
+        }
+        const client = await this.pool.connect();
+        try {
+            await client.query(`DELETE FROM "${this.schemaName}".workflow_status
+         WHERE workflow_uuid = ANY($1)`, [workflowsToDelete]);
+        }
+        finally {
+            client.release();
+        }
+        // Clean up in-memory maps
+        for (const wfid of workflowsToDelete) {
+            this.runningWorkflowMap.delete(wfid);
+            this.workflowCancellationMap.delete(wfid);
+        }
+    }
     async forkWorkflow(workflowID, startStep, options = {}) {
         const newWorkflowID = options.newWorkflowID ?? (0, crypto_1.randomUUID)();
         const workflowStatus = await this.getWorkflowStatus(workflowID);
@@ -731,7 +772,7 @@ class PostgresSystemDatabase {
         try {
             await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
             const now = Date.now();
-            await insertWorkflowStatus(client, {
+            await this.insertWorkflowStatus(client, {
                 workflowUUID: newWorkflowID,
                 status: workflow_1.StatusString.ENQUEUED,
                 workflowName: workflowStatus.workflowName,
@@ -757,7 +798,7 @@ class PostgresSystemDatabase {
                 queuePartitionKey: undefined,
                 forkedFrom: workflowID,
                 serialization: workflowStatus.serialization,
-            }, this.schemaName, null);
+            }, null);
             if (startStep > 0) {
                 // Copy operation outputs
                 const copyOutputsQuery = `INSERT INTO "${this.schemaName}".operation_outputs
@@ -806,466 +847,6 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
-    async #runAndRecordResult(client, functionName, workflowID, functionID, func) {
-        const startTime = Date.now();
-        const result = await this.#getOperationResultAndThrowIfCancelled(client, workflowID, functionID);
-        if (result !== undefined) {
-            if (result.functionName !== functionName) {
-                throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, functionName, result.functionName);
-            }
-            return result.output;
-        }
-        const output = await func();
-        await recordOperationResult(client, workflowID, functionID, functionName, true, this.schemaName, startTime, Date.now(), {
-            output,
-        });
-        return output;
-    }
-    async durableSleepms(workflowID, functionID, durationMS) {
-        let resolveNotification;
-        const cancelPromise = new Promise((resolve) => {
-            resolveNotification = resolve;
-        });
-        const cbr = this.cancelWakeupMap.registerCallback(workflowID, resolveNotification);
-        try {
-            let timeoutPromise = Promise.resolve();
-            const { promise, cancel: timeoutCancel } = await this.#durableSleep(workflowID, functionID, durationMS);
-            timeoutPromise = promise;
-            try {
-                await Promise.race([cancelPromise, timeoutPromise]);
-            }
-            finally {
-                timeoutCancel();
-            }
-        }
-        finally {
-            this.cancelWakeupMap.deregisterCallback(cbr);
-        }
-        await this.checkIfCanceled(workflowID);
-    }
-    async #durableSleep(workflowID, functionID, durationMS, maxSleepPerIteration) {
-        if (maxSleepPerIteration === undefined)
-            maxSleepPerIteration = durationMS;
-        const curTime = Date.now();
-        let endTimeMs = curTime + durationMS;
-        const client = await this.pool.connect();
-        try {
-            const res = await this.#getOperationResultAndThrowIfCancelled(client, workflowID, functionID);
-            if (res) {
-                if (res.functionName !== exports.DBOS_FUNCNAME_SLEEP) {
-                    throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, res.functionName);
-                }
-                endTimeMs = JSON.parse(res.output);
-            }
-            else {
-                await recordOperationResult(client, workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, false, this.schemaName, Date.now(), Date.now(), {
-                    output: serialization_1.DBOSPortableJSON.stringify(endTimeMs),
-                    serialization: serialization_1.DBOSPortableJSON.name(),
-                });
-            }
-            return {
-                ...(0, utils_1.cancellableSleep)(Math.max(Math.min(maxSleepPerIteration, endTimeMs - curTime), 0)),
-                endTime: endTimeMs,
-            };
-        }
-        finally {
-            client.release();
-        }
-    }
-    nullTopic = '__null__topic__';
-    async send(workflowID, functionID, destinationID, message, topic, serialization) {
-        topic = topic ?? this.nullTopic;
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_SEND, workflowID, functionID, async () => {
-                await client.query(`INSERT INTO "${this.schemaName}".notifications (destination_uuid, topic, message, serialization) VALUES ($1, $2, $3, $4);`, [destinationID, topic, message, serialization]);
-                return undefined;
-            });
-            await client.query('COMMIT');
-        }
-        catch (error) {
-            await client.query('ROLLBACK');
-            const err = error;
-            if (err.code === '23503') {
-                // Foreign key constraint violation (only expected for the INSERT query)
-                throw new error_1.DBOSNonExistentWorkflowError(`Sent to non-existent destination workflow UUID: ${destinationID}`);
-            }
-            else {
-                throw err;
-            }
-        }
-        finally {
-            client.release();
-        }
-    }
-    async recv(workflowID, functionID, timeoutFunctionID, topic, timeoutSeconds = dbos_executor_1.DBOSExecutor.defaultNotificationTimeoutSec) {
-        topic = topic ?? this.nullTopic;
-        const startTime = Date.now();
-        // First, check for previous executions.
-        const res = await this.getOperationResultAndThrowIfCancelled(workflowID, functionID);
-        if (res) {
-            if (res.functionName !== exports.DBOS_FUNCNAME_RECV) {
-                throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_RECV, res.functionName);
-            }
-            return { serializedValue: res.output, serialization: res.serialization ?? null };
-        }
-        const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
-        let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
-        while (true) {
-            // register the key with the global notifications listener.
-            let resolveNotification;
-            const messagePromise = new Promise((resolve) => {
-                resolveNotification = resolve;
-            });
-            const payload = `${workflowID}::${topic}`;
-            const cbr = this.notificationsMap.registerCallback(payload, resolveNotification);
-            const crh = this.cancelWakeupMap.registerCallback(workflowID, (_res) => {
-                resolveNotification();
-            });
-            try {
-                await this.checkIfCanceled(workflowID);
-                // Check if the key is already in the DB, then wait for the notification if it isn't.
-                const initRecvRows = (await this.pool.query(`SELECT topic FROM "${this.schemaName}".notifications WHERE destination_uuid=$1 AND topic=$2;`, [workflowID, topic])).rows;
-                if (initRecvRows.length !== 0)
-                    break;
-                const ct = Date.now();
-                if (finishTime && ct > finishTime)
-                    break; // Time's up
-                let timeoutPromise = Promise.resolve();
-                let timeoutCancel = () => { };
-                if (timeoutms) {
-                    const { promise, cancel, endTime } = await this.#durableSleep(workflowID, timeoutFunctionID, timeoutms, this.dbPollingIntervalEventMs);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                    finishTime = endTime;
-                }
-                else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalEventMs;
-                    poll = Math.min(this.dbPollingIntervalEventMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                }
-                try {
-                    await Promise.race([messagePromise, timeoutPromise]);
-                }
-                finally {
-                    timeoutCancel();
-                }
-            }
-            finally {
-                this.notificationsMap.deregisterCallback(cbr);
-                this.cancelWakeupMap.deregisterCallback(crh);
-            }
-        }
-        await this.checkIfCanceled(workflowID);
-        // Transactionally consume and return the message if it's in the DB, otherwise return null.
-        let message = null;
-        let serialization = null;
-        const client = await this.pool.connect();
-        try {
-            await client.query(`BEGIN ISOLATION LEVEL READ COMMITTED`);
-            const finalRecvRows = (await client.query(`DELETE FROM "${this.schemaName}".notifications
-        WHERE destination_uuid = $1
-          AND topic = $2
-          AND message_uuid = (
-            SELECT message_uuid
-            FROM "${this.schemaName}".notifications
-            WHERE destination_uuid = $1
-              AND topic = $2
-            ORDER BY created_at_epoch_ms ASC
-            LIMIT 1
-          )
-        RETURNING notifications.message, notifications.serialization;`, [workflowID, topic])).rows;
-            if (finalRecvRows.length > 0) {
-                message = finalRecvRows[0].message;
-                serialization = finalRecvRows[0].serialization;
-            }
-            await recordOperationResult(client, workflowID, functionID, exports.DBOS_FUNCNAME_RECV, true, this.schemaName, startTime, Date.now(), {
-                output: message,
-                serialization,
-            });
-            await client.query(`COMMIT`);
-        }
-        catch (e) {
-            this.logger.error(e);
-            await client.query(`ROLLBACK`);
-            throw e;
-        }
-        finally {
-            client.release();
-        }
-        return { serializedValue: message, serialization };
-    }
-    // Only used in tests
-    async setWorkflowStatus(workflowID, status, resetRecoveryAttempts, internalOptions) {
-        const client = await this.pool.connect();
-        try {
-            await updateWorkflowStatus(client, workflowID, status, this.schemaName, {
-                update: { resetRecoveryAttempts, resetNameTo: internalOptions?.updateName },
-            });
-        }
-        finally {
-            client.release();
-        }
-    }
-    async setEvent(workflowID, functionID, key, message, serialization) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_SETEVENT, workflowID, functionID, async () => {
-                await client.query(`INSERT INTO "${this.schemaName}".workflow_events (workflow_uuid, key, value, serialization)
-             VALUES ($1, $2, $3, $4)
-             ON CONFLICT (workflow_uuid, key)
-             DO UPDATE SET value = $3
-             RETURNING workflow_uuid;`, [workflowID, key, message, serialization]);
-                // Also write to the immutable history table for fork support
-                await client.query(`INSERT INTO "${this.schemaName}".workflow_events_history (workflow_uuid, function_id, key, value, serialization)
-             VALUES ($1, $2, $3, $4, $5)
-             ON CONFLICT (workflow_uuid, function_id, key)
-             DO UPDATE SET value = $4;`, [workflowID, functionID, key, message, serialization]);
-                return undefined;
-            });
-            await client.query('COMMIT');
-        }
-        catch (e) {
-            this.logger.error(e);
-            await client.query(`ROLLBACK`);
-            throw e;
-        }
-        finally {
-            client.release();
-        }
-    }
-    async getEvent(workflowID, key, timeoutSeconds, callerWorkflow) {
-        const startTime = Date.now();
-        // Check if the operation has been done before for OAOO (only do this inside a workflow).
-        if (callerWorkflow) {
-            const res = await this.getOperationResultAndThrowIfCancelled(callerWorkflow.workflowID, callerWorkflow.functionID);
-            if (res) {
-                if (res.functionName !== exports.DBOS_FUNCNAME_GETEVENT) {
-                    throw new error_1.DBOSUnexpectedStepError(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, res.functionName);
-                }
-                return { serializedValue: res.output, serialization: null };
-            }
-        }
-        // Get the return the value. if it's in the DB, otherwise return null.
-        let value = null;
-        let valueSer = null;
-        const payloadKey = `${workflowID}::${key}`;
-        const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
-        let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
-        // Register the key with the global notifications listener first... we do not want to look in the DB first
-        //  or that would cause a timing hole.
-        while (true) {
-            let resolveNotification;
-            const valuePromise = new Promise((resolve) => {
-                resolveNotification = resolve;
-            });
-            const cbr = this.workflowEventsMap.registerCallback(payloadKey, resolveNotification);
-            const crh = callerWorkflow?.workflowID
-                ? this.cancelWakeupMap.registerCallback(callerWorkflow.workflowID, (_res) => {
-                    resolveNotification();
-                })
-                : undefined;
-            try {
-                if (callerWorkflow?.workflowID)
-                    await this.checkIfCanceled(callerWorkflow?.workflowID);
-                // Check if the key is already in the DB, then wait for the notification if it isn't.
-                const initRecvRows = (await this.pool.query(`SELECT key, value, serialization
-             FROM "${this.schemaName}".workflow_events
-             WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
-                if (initRecvRows.length > 0) {
-                    value = initRecvRows[0].value;
-                    valueSer = initRecvRows[0].serialization;
-                    break;
-                }
-                const ct = Date.now();
-                if (finishTime && ct > finishTime)
-                    break; // Time's up
-                // If we have a callerWorkflow, we want a durable sleep, otherwise, not
-                let timeoutPromise = Promise.resolve();
-                let timeoutCancel = () => { };
-                if (callerWorkflow && timeoutms) {
-                    const { promise, cancel, endTime } = await this.#durableSleep(callerWorkflow.workflowID, callerWorkflow.timeoutFunctionID ?? -1, timeoutms, this.dbPollingIntervalEventMs);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                    finishTime = endTime;
-                }
-                else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalEventMs;
-                    poll = Math.min(this.dbPollingIntervalEventMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                }
-                try {
-                    await Promise.race([valuePromise, timeoutPromise]);
-                }
-                finally {
-                    timeoutCancel();
-                }
-            }
-            finally {
-                this.workflowEventsMap.deregisterCallback(cbr);
-                if (crh)
-                    this.cancelWakeupMap.deregisterCallback(crh);
-            }
-        }
-        // Record the output if it is inside a workflow.
-        if (callerWorkflow) {
-            await this.recordOperationResult(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, true, startTime, {
-                output: value,
-                serialization: valueSer,
-            });
-        }
-        return { serializedValue: value, serialization: valueSer };
-    }
-    #setWFCancelMap(workflowID) {
-        if (this.runningWorkflowMap.has(workflowID)) {
-            this.workflowCancellationMap.set(workflowID, true);
-        }
-        this.cancelWakeupMap.callCallbacks(workflowID);
-    }
-    #clearWFCancelMap(workflowID) {
-        if (this.workflowCancellationMap.has(workflowID)) {
-            this.workflowCancellationMap.delete(workflowID);
-        }
-    }
-    async cancelWorkflow(workflowID) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            const statusResult = await getWorkflowStatusValue(client, workflowID, this.schemaName);
-            if (!statusResult) {
-                throw new error_1.DBOSNonExistentWorkflowError(`Workflow ${workflowID} does not exist`);
-            }
-            if (statusResult === workflow_1.StatusString.SUCCESS ||
-                statusResult === workflow_1.StatusString.ERROR ||
-                statusResult === workflow_1.StatusString.CANCELLED) {
-                await client.query('ROLLBACK');
-                return;
-            }
-            // Set the workflow's status to CANCELLED and remove it from any queue it is on
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.CANCELLED, this.schemaName, {
-                update: { queueName: null, resetDeduplicationID: true, resetStartedAtEpochMs: true },
-            });
-            await client.query('COMMIT');
-        }
-        catch (error) {
-            this.logger.error(error);
-            await client.query('ROLLBACK');
-            throw error;
-        }
-        finally {
-            client.release();
-        }
-        this.#setWFCancelMap(workflowID);
-    }
-    async #checkIfCanceled(client, workflowID) {
-        if (this.workflowCancellationMap.get(workflowID) === true) {
-            throw new error_1.DBOSWorkflowCancelledError(workflowID);
-        }
-        const statusValue = await getWorkflowStatusValue(client, workflowID, this.schemaName);
-        if (statusValue === workflow_1.StatusString.CANCELLED) {
-            throw new error_1.DBOSWorkflowCancelledError(workflowID);
-        }
-    }
-    async checkIfCanceled(workflowID) {
-        const client = await this.pool.connect();
-        try {
-            await this.#checkIfCanceled(client, workflowID);
-        }
-        finally {
-            client.release();
-        }
-    }
-    async resumeWorkflow(workflowID) {
-        this.#clearWFCancelMap(workflowID);
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL REPEATABLE READ');
-            // Check workflow status. If it is complete, do nothing.
-            const statusResult = await getWorkflowStatusValue(client, workflowID, this.schemaName);
-            if (!statusResult || statusResult === workflow_1.StatusString.SUCCESS || statusResult === workflow_1.StatusString.ERROR) {
-                await client.query('ROLLBACK');
-                if (!statusResult) {
-                    if (statusResult === undefined) {
-                        throw new error_1.DBOSNonExistentWorkflowError(`Workflow ${workflowID} does not exist`);
-                    }
-                }
-                return;
-            }
-            // Set the workflow's status to ENQUEUED and reset recovery attempts and deadline.
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ENQUEUED, this.schemaName, {
-                update: {
-                    queueName: utils_1.INTERNAL_QUEUE_NAME,
-                    resetRecoveryAttempts: true,
-                    resetDeadline: true,
-                    resetDeduplicationID: true,
-                    resetStartedAtEpochMs: true,
-                },
-                throwOnFailure: false,
-            });
-            await client.query('COMMIT');
-        }
-        catch (error) {
-            this.logger.error(error);
-            await client.query('ROLLBACK');
-            throw error;
-        }
-        finally {
-            client.release();
-        }
-    }
-    async getWorkflowChildren(workflowID) {
-        // BFS to find all descendant workflows
-        const visited = new Set([workflowID]);
-        const queue = [workflowID];
-        const children = [];
-        const client = await this.pool.connect();
-        try {
-            while (queue.length > 0) {
-                const batch = queue.splice(0, queue.length);
-                const result = await client.query(`SELECT DISTINCT child_workflow_id
-           FROM "${this.schemaName}".operation_outputs
-           WHERE workflow_uuid = ANY($1)
-             AND child_workflow_id IS NOT NULL`, [batch]);
-                for (const row of result.rows) {
-                    if (!visited.has(row.child_workflow_id)) {
-                        visited.add(row.child_workflow_id);
-                        queue.push(row.child_workflow_id);
-                        children.push(row.child_workflow_id);
-                    }
-                }
-            }
-        }
-        finally {
-            client.release();
-        }
-        return children;
-    }
-    async deleteWorkflow(workflowID, deleteChildren = false) {
-        let workflowsToDelete = [workflowID];
-        if (deleteChildren) {
-            const children = await this.getWorkflowChildren(workflowID);
-            workflowsToDelete = [...workflowsToDelete, ...children];
-        }
-        const client = await this.pool.connect();
-        try {
-            await client.query(`DELETE FROM "${this.schemaName}".workflow_status
-         WHERE workflow_uuid = ANY($1)`, [workflowsToDelete]);
-        }
-        finally {
-            client.release();
-        }
-        // Clean up in-memory maps
-        for (const wfid of workflowsToDelete) {
-            this.runningWorkflowMap.delete(wfid);
-            this.workflowCancellationMap.delete(wfid);
-        }
-    }
     async exportWorkflow(workflowID, exportChildren = false) {
         const workflowIDs = [workflowID];
         if (exportChildren) {
@@ -1415,6 +996,7 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
+    // ==================== Awaiting Workflows ====================
     registerRunningWorkflow(workflowID, workflowPromise) {
         // Need to await for the workflow and capture errors.
         const awaitWorkflowPromise = workflowPromise
@@ -1444,223 +1026,408 @@ class PostgresSystemDatabase {
             this.logger.warn('Message notification map is not empty - shutdown is not clean.');
             //throw new Error('Message notification map is not empty - shutdown is not clean.');
         }
-    }
-    async getWorkflowStatus(workflowID, callerID, callerFN) {
-        const funcGetStatus = async () => {
-            const statuses = await this.listWorkflows({ workflowIDs: [workflowID] });
-            const status = statuses.find((s) => s.workflowUUID === workflowID);
-            return status ? JSON.stringify(status) : null;
-        };
-        if (callerID && callerFN) {
-            const client = await this.pool.connect();
-            try {
-                // Check if the operation has been done before for OAOO (only do this inside a workflow).
-                const json = await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_GETSTATUS, callerID, callerFN, funcGetStatus);
-                return parseStatus(json);
+    }
+    async awaitWorkflowResult(workflowID, timeoutSeconds, callerID, timerFuncID) {
+        const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
+        let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
+        while (true) {
+            let resolveNotification;
+            const statusPromise = new Promise((resolve) => {
+                resolveNotification = resolve;
+            });
+            const irh = this.cancelWakeupMap.registerCallback(workflowID, (_res) => {
+                resolveNotification();
+            });
+            const crh = callerID
+                ? this.cancelWakeupMap.registerCallback(callerID, (_res) => {
+                    resolveNotification();
+                })
+                : undefined;
+            try {
+                if (callerID)
+                    await this.checkIfCanceled(callerID);
+                try {
+                    const { rows } = await this.pool.query(`SELECT status, output, error, serialization FROM "${this.schemaName}".workflow_status 
+             WHERE workflow_uuid=$1`, [workflowID]);
+                    if (rows.length > 0) {
+                        const status = rows[0].status;
+                        if (status === workflow_1.StatusString.SUCCESS) {
+                            return { output: rows[0].output, serialization: rows[0].serialization };
+                        }
+                        else if (status === workflow_1.StatusString.ERROR) {
+                            return { error: rows[0].error, serialization: rows[0].serialization };
+                        }
+                        else if (status === workflow_1.StatusString.CANCELLED) {
+                            return { cancelled: true };
+                        }
+                        else if (status === workflow_1.StatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED) {
+                            return { maxRecoveryAttemptsExceeded: true };
+                        }
+                        else {
+                            // Status is not actionable
+                        }
+                    }
+                }
+                catch (e) {
+                    const err = e;
+                    this.logger.error(`Exception from system database: ${err}`, err);
+                    throw err;
+                }
+                const ct = Date.now();
+                if (finishTime && ct > finishTime)
+                    return undefined; // Time's up
+                let timeoutPromise = Promise.resolve();
+                let timeoutCancel = () => { };
+                if (timerFuncID !== undefined && callerID !== undefined && timeoutms !== undefined) {
+                    const { promise, cancel, endTime } = await this.#durableSleep(callerID, timerFuncID, timeoutms, this.dbPollingIntervalResultMs);
+                    finishTime = endTime;
+                    timeoutPromise = promise;
+                    timeoutCancel = cancel;
+                }
+                else {
+                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalResultMs;
+                    poll = Math.min(this.dbPollingIntervalResultMs, poll);
+                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
+                    timeoutPromise = promise;
+                    timeoutCancel = cancel;
+                }
+                try {
+                    await Promise.race([statusPromise, timeoutPromise]);
+                }
+                finally {
+                    timeoutCancel();
+                }
+            }
+            finally {
+                this.cancelWakeupMap.deregisterCallback(irh);
+                if (crh)
+                    this.cancelWakeupMap.deregisterCallback(crh);
+            }
+        }
+    }
+    async awaitFirstWorkflowId(workflowIds, callerID) {
+        const placeholders = workflowIds.map((_, i) => `$${i + 1}`).join(', ');
+        while (true) {
+            let resolveNotification;
+            const wakeupPromise = new Promise((resolve) => {
+                resolveNotification = resolve;
+            });
+            // Register cancel callbacks for all target workflows and the caller.
+            const cbHandles = workflowIds.map((wfid) => this.cancelWakeupMap.registerCallback(wfid, () => resolveNotification()));
+            const callerCbHandle = callerID
+                ? this.cancelWakeupMap.registerCallback(callerID, () => resolveNotification())
+                : undefined;
+            try {
+                if (callerID)
+                    await this.checkIfCanceled(callerID);
+                const { rows } = await this.pool.query(`SELECT workflow_uuid FROM "${this.schemaName}".workflow_status
+           WHERE workflow_uuid IN (${placeholders})
+             AND status NOT IN ('${workflow_1.StatusString.PENDING}', '${workflow_1.StatusString.ENQUEUED}')
+           LIMIT 1`, workflowIds);
+                if (rows.length > 0) {
+                    return rows[0].workflow_uuid;
+                }
+                const { promise: sleepPromise, cancel: sleepCancel } = (0, utils_1.cancellableSleep)(this.dbPollingIntervalResultMs);
+                try {
+                    await Promise.race([wakeupPromise, sleepPromise]);
+                }
+                finally {
+                    sleepCancel();
+                }
+            }
+            finally {
+                for (const h of cbHandles) {
+                    this.cancelWakeupMap.deregisterCallback(h);
+                }
+                if (callerCbHandle)
+                    this.cancelWakeupMap.deregisterCallback(callerCbHandle);
+            }
+        }
+    }
+    // ==================== Sleep ====================
+    async durableSleepms(workflowID, functionID, durationMS) {
+        let resolveNotification;
+        const cancelPromise = new Promise((resolve) => {
+            resolveNotification = resolve;
+        });
+        const cbr = this.cancelWakeupMap.registerCallback(workflowID, resolveNotification);
+        try {
+            let timeoutPromise = Promise.resolve();
+            const { promise, cancel: timeoutCancel } = await this.#durableSleep(workflowID, functionID, durationMS);
+            timeoutPromise = promise;
+            try {
+                await Promise.race([cancelPromise, timeoutPromise]);
+            }
+            finally {
+                timeoutCancel();
+            }
+        }
+        finally {
+            this.cancelWakeupMap.deregisterCallback(cbr);
+        }
+        await this.checkIfCanceled(workflowID);
+    }
+    // ==================== Messaging ====================
+    nullTopic = '__null__topic__';
+    async send(workflowID, functionID, destinationID, message, topic, serialization, messageUUID) {
+        topic = topic ?? this.nullTopic;
+        messageUUID = messageUUID ?? (0, crypto_1.randomUUID)();
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
+            await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_SEND, workflowID, functionID, async () => {
+                await client.query(`INSERT INTO "${this.schemaName}".notifications (destination_uuid, topic, message, serialization, message_uuid)
+           VALUES ($1, $2, $3, $4, $5)
+           ON CONFLICT (message_uuid) DO NOTHING;`, [destinationID, topic, message, serialization, messageUUID]);
+                return undefined;
+            });
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            const err = error;
+            if (err.code === '23503') {
+                // Foreign key constraint violation (only expected for the INSERT query)
+                throw new error_1.DBOSNonExistentWorkflowError(`Sent to non-existent destination workflow UUID: ${destinationID}`);
             }
-            finally {
-                client.release();
+            else {
+                throw err;
             }
         }
-        else {
-            const json = await funcGetStatus();
-            return parseStatus(json);
+        finally {
+            client.release();
         }
-        function parseStatus(json) {
-            return json ? JSON.parse(json) : null;
+    }
+    async sendDirect(destinationID, message, topic, serialization, messageUUID) {
+        topic = topic ?? this.nullTopic;
+        messageUUID = messageUUID ?? (0, crypto_1.randomUUID)();
+        try {
+            await this.pool.query(`INSERT INTO "${this.schemaName}".notifications (destination_uuid, topic, message, serialization, message_uuid)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (message_uuid) DO NOTHING;`, [destinationID, topic, message, serialization, messageUUID]);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === '23503') {
+                throw new error_1.DBOSNonExistentWorkflowError(`Sent to non-existent destination workflow UUID: ${destinationID}`);
+            }
+            throw err;
         }
     }
-    async awaitWorkflowResult(workflowID, timeoutSeconds, callerID, timerFuncID) {
+    async recv(workflowID, functionID, timeoutFunctionID, topic, timeoutSeconds = dbos_executor_1.DBOSExecutor.defaultNotificationTimeoutSec) {
+        topic = topic ?? this.nullTopic;
+        const startTime = Date.now();
+        // First, check for previous executions.
+        const res = await this.getOperationResultAndThrowIfCancelled(workflowID, functionID);
+        if (res) {
+            if (res.functionName !== exports.DBOS_FUNCNAME_RECV) {
+                throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_RECV, res.functionName);
+            }
+            return { serializedValue: res.output, serialization: res.serialization ?? null };
+        }
         const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
         let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
         while (true) {
+            // register the key with the global notifications listener.
             let resolveNotification;
-            const statusPromise = new Promise((resolve) => {
+            const messagePromise = new Promise((resolve) => {
                 resolveNotification = resolve;
             });
-            const irh = this.cancelWakeupMap.registerCallback(workflowID, (_res) => {
+            const payload = `${workflowID}::${topic}`;
+            const cbr = this.notificationsMap.registerCallback(payload, resolveNotification);
+            const crh = this.cancelWakeupMap.registerCallback(workflowID, (_res) => {
                 resolveNotification();
             });
-            const crh = callerID
-                ? this.cancelWakeupMap.registerCallback(callerID, (_res) => {
-                    resolveNotification();
-                })
-                : undefined;
             try {
-                if (callerID)
-                    await this.checkIfCanceled(callerID);
-                try {
-                    const { rows } = await this.pool.query(`SELECT status, output, error, serialization FROM "${this.schemaName}".workflow_status 
-             WHERE workflow_uuid=$1`, [workflowID]);
-                    if (rows.length > 0) {
-                        const status = rows[0].status;
-                        if (status === workflow_1.StatusString.SUCCESS) {
-                            return { output: rows[0].output, serialization: rows[0].serialization };
-                        }
-                        else if (status === workflow_1.StatusString.ERROR) {
-                            return { error: rows[0].error, serialization: rows[0].serialization };
-                        }
-                        else if (status === workflow_1.StatusString.CANCELLED) {
-                            return { cancelled: true };
-                        }
-                        else if (status === workflow_1.StatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED) {
-                            return { maxRecoveryAttemptsExceeded: true };
-                        }
-                        else {
-                            // Status is not actionable
-                        }
-                    }
-                }
-                catch (e) {
-                    const err = e;
-                    this.logger.error(`Exception from system database: ${err}`, err);
-                    throw err;
-                }
+                await this.checkIfCanceled(workflowID);
+                // Check if the key is already in the DB, then wait for the notification if it isn't.
+                const initRecvRows = (await this.pool.query(`SELECT topic FROM "${this.schemaName}".notifications WHERE destination_uuid=$1 AND topic=$2 AND consumed = false;`, [workflowID, topic])).rows;
+                if (initRecvRows.length !== 0)
+                    break;
                 const ct = Date.now();
                 if (finishTime && ct > finishTime)
-                    return undefined; // Time's up
+                    break; // Time's up
                 let timeoutPromise = Promise.resolve();
                 let timeoutCancel = () => { };
-                if (timerFuncID !== undefined && callerID !== undefined && timeoutms !== undefined) {
-                    const { promise, cancel, endTime } = await this.#durableSleep(callerID, timerFuncID, timeoutms, this.dbPollingIntervalResultMs);
-                    finishTime = endTime;
+                if (timeoutms) {
+                    const { promise, cancel, endTime } = await this.#durableSleep(workflowID, timeoutFunctionID, timeoutms, this.dbPollingIntervalEventMs);
                     timeoutPromise = promise;
                     timeoutCancel = cancel;
+                    finishTime = endTime;
                 }
                 else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalResultMs;
-                    poll = Math.min(this.dbPollingIntervalResultMs, poll);
+                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalEventMs;
+                    poll = Math.min(this.dbPollingIntervalEventMs, poll);
                     const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
                     timeoutPromise = promise;
                     timeoutCancel = cancel;
                 }
                 try {
-                    await Promise.race([statusPromise, timeoutPromise]);
+                    await Promise.race([messagePromise, timeoutPromise]);
                 }
                 finally {
                     timeoutCancel();
                 }
             }
             finally {
-                this.cancelWakeupMap.deregisterCallback(irh);
-                if (crh)
-                    this.cancelWakeupMap.deregisterCallback(crh);
+                this.notificationsMap.deregisterCallback(cbr);
+                this.cancelWakeupMap.deregisterCallback(crh);
+            }
+        }
+        await this.checkIfCanceled(workflowID);
+        // Transactionally consume and return the message if it's in the DB, otherwise return null.
+        let message = null;
+        let serialization = null;
+        const client = await this.pool.connect();
+        try {
+            await client.query(`BEGIN ISOLATION LEVEL READ COMMITTED`);
+            const finalRecvRows = (await client.query(`UPDATE "${this.schemaName}".notifications
+        SET consumed = true
+        WHERE destination_uuid = $1
+          AND topic = $2
+          AND consumed = false
+          AND message_uuid = (
+            SELECT message_uuid
+            FROM "${this.schemaName}".notifications
+            WHERE destination_uuid = $1
+              AND topic = $2
+              AND consumed = false
+            ORDER BY created_at_epoch_ms ASC
+            LIMIT 1
+          )
+        RETURNING notifications.message, notifications.serialization;`, [workflowID, topic])).rows;
+            if (finalRecvRows.length > 0) {
+                message = finalRecvRows[0].message;
+                serialization = finalRecvRows[0].serialization;
             }
+            await this.recordOperationResultInternal(client, workflowID, functionID, exports.DBOS_FUNCNAME_RECV, true, startTime, Date.now(), {
+                output: message,
+                serialization,
+            });
+            await client.query(`COMMIT`);
+        }
+        catch (e) {
+            this.logger.error(e);
+            await client.query(`ROLLBACK`);
+            throw e;
         }
+        finally {
+            client.release();
+        }
+        return { serializedValue: message, serialization };
     }
-    async awaitFirstWorkflowId(workflowIds, callerID) {
-        const placeholders = workflowIds.map((_, i) => `$${i + 1}`).join(', ');
+    // ==================== Events ====================
+    async setEvent(workflowID, functionID, key, message, serialization) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
+            await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_SETEVENT, workflowID, functionID, async () => {
+                await client.query(`INSERT INTO "${this.schemaName}".workflow_events (workflow_uuid, key, value, serialization)
+             VALUES ($1, $2, $3, $4)
+             ON CONFLICT (workflow_uuid, key)
+             DO UPDATE SET value = $3
+             RETURNING workflow_uuid;`, [workflowID, key, message, serialization]);
+                // Also write to the immutable history table for fork support
+                await client.query(`INSERT INTO "${this.schemaName}".workflow_events_history (workflow_uuid, function_id, key, value, serialization)
+             VALUES ($1, $2, $3, $4, $5)
+             ON CONFLICT (workflow_uuid, function_id, key)
+             DO UPDATE SET value = $4;`, [workflowID, functionID, key, message, serialization]);
+                return undefined;
+            });
+            await client.query('COMMIT');
+        }
+        catch (e) {
+            this.logger.error(e);
+            await client.query(`ROLLBACK`);
+            throw e;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async getEvent(workflowID, key, timeoutSeconds, callerWorkflow) {
+        const startTime = Date.now();
+        // Check if the operation has been done before for OAOO (only do this inside a workflow).
+        if (callerWorkflow) {
+            const res = await this.getOperationResultAndThrowIfCancelled(callerWorkflow.workflowID, callerWorkflow.functionID);
+            if (res) {
+                if (res.functionName !== exports.DBOS_FUNCNAME_GETEVENT) {
+                    throw new error_1.DBOSUnexpectedStepError(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, res.functionName);
+                }
+                return { serializedValue: res.output, serialization: null };
+            }
+        }
+        // Get the return the value. if it's in the DB, otherwise return null.
+        let value = null;
+        let valueSer = null;
+        const payloadKey = `${workflowID}::${key}`;
+        const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
+        let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
+        // Register the key with the global notifications listener first... we do not want to look in the DB first
+        //  or that would cause a timing hole.
         while (true) {
             let resolveNotification;
-            const wakeupPromise = new Promise((resolve) => {
+            const valuePromise = new Promise((resolve) => {
                 resolveNotification = resolve;
             });
-            // Register cancel callbacks for all target workflows and the caller.
-            const cbHandles = workflowIds.map((wfid) => this.cancelWakeupMap.registerCallback(wfid, () => resolveNotification()));
-            const callerCbHandle = callerID
-                ? this.cancelWakeupMap.registerCallback(callerID, () => resolveNotification())
+            const cbr = this.workflowEventsMap.registerCallback(payloadKey, resolveNotification);
+            const crh = callerWorkflow?.workflowID
+                ? this.cancelWakeupMap.registerCallback(callerWorkflow.workflowID, (_res) => {
+                    resolveNotification();
+                })
                 : undefined;
             try {
-                if (callerID)
-                    await this.checkIfCanceled(callerID);
-                const { rows } = await this.pool.query(`SELECT workflow_uuid FROM "${this.schemaName}".workflow_status
-           WHERE workflow_uuid IN (${placeholders})
-             AND status NOT IN ('${workflow_1.StatusString.PENDING}', '${workflow_1.StatusString.ENQUEUED}')
-           LIMIT 1`, workflowIds);
-                if (rows.length > 0) {
-                    return rows[0].workflow_uuid;
+                if (callerWorkflow?.workflowID)
+                    await this.checkIfCanceled(callerWorkflow?.workflowID);
+                // Check if the key is already in the DB, then wait for the notification if it isn't.
+                const initRecvRows = (await this.pool.query(`SELECT key, value, serialization
+             FROM "${this.schemaName}".workflow_events
+             WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
+                if (initRecvRows.length > 0) {
+                    value = initRecvRows[0].value;
+                    valueSer = initRecvRows[0].serialization;
+                    break;
+                }
+                const ct = Date.now();
+                if (finishTime && ct > finishTime)
+                    break; // Time's up
+                // If we have a callerWorkflow, we want a durable sleep, otherwise, not
+                let timeoutPromise = Promise.resolve();
+                let timeoutCancel = () => { };
+                if (callerWorkflow && timeoutms) {
+                    const { promise, cancel, endTime } = await this.#durableSleep(callerWorkflow.workflowID, callerWorkflow.timeoutFunctionID ?? -1, timeoutms, this.dbPollingIntervalEventMs);
+                    timeoutPromise = promise;
+                    timeoutCancel = cancel;
+                    finishTime = endTime;
+                }
+                else {
+                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalEventMs;
+                    poll = Math.min(this.dbPollingIntervalEventMs, poll);
+                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
+                    timeoutPromise = promise;
+                    timeoutCancel = cancel;
                 }
-                const { promise: sleepPromise, cancel: sleepCancel } = (0, utils_1.cancellableSleep)(this.dbPollingIntervalResultMs);
                 try {
-                    await Promise.race([wakeupPromise, sleepPromise]);
+                    await Promise.race([valuePromise, timeoutPromise]);
                 }
                 finally {
-                    sleepCancel();
+                    timeoutCancel();
                 }
             }
             finally {
-                for (const h of cbHandles) {
-                    this.cancelWakeupMap.deregisterCallback(h);
-                }
-                if (callerCbHandle)
-                    this.cancelWakeupMap.deregisterCallback(callerCbHandle);
+                this.workflowEventsMap.deregisterCallback(cbr);
+                if (crh)
+                    this.cancelWakeupMap.deregisterCallback(crh);
             }
         }
-    }
-    /* BACKGROUND PROCESSES */
-    /**
-     * A background process that listens for notifications from Postgres then signals the appropriate
-     * workflow listener by resolving its promise.
-     */
-    reconnectTimeout = null;
-    async #listenForNotifications() {
-        const connect = async () => {
-            const reconnect = () => {
-                if (this.reconnectTimeout) {
-                    return;
-                }
-                this.reconnectTimeout = setTimeout(async () => {
-                    this.reconnectTimeout = null;
-                    await connect();
-                }, 1000);
-            };
-            let client = null;
-            try {
-                client = await this.pool.connect();
-                await client.query('LISTEN dbos_notifications_channel;');
-                await client.query('LISTEN dbos_workflow_events_channel;');
-                // Self-test: verify LISTEN actually works by sending a NOTIFY and checking it arrives.
-                // If a transaction-mode pooler (e.g. PgBouncer pool_mode=transaction) is in the path,
-                // LISTEN succeeds but the subscription is silently lost when the backend is released.
-                let selfTestReceived = false;
-                const onSelfTest = (msg) => {
-                    if (msg.channel === 'dbos_notifications_channel' && msg.payload === 'dbos_listen_selftest') {
-                        selfTestReceived = true;
-                    }
-                };
-                client.on('notification', onSelfTest);
-                await this.pool.query("NOTIFY dbos_notifications_channel, 'dbos_listen_selftest'");
-                for (let i = 0; i < 30 && !selfTestReceived; i++) {
-                    await new Promise((r) => setTimeout(r, 100));
-                }
-                client.removeListener('notification', onSelfTest);
-                if (!selfTestReceived) {
-                    this.logger.warn('LISTEN/NOTIFY self-test failed: notification was not received within 3 seconds. ' +
-                        'This typically means the connection is going through a transaction-mode pooler ' +
-                        '(e.g. PgBouncer with pool_mode=transaction), which silently breaks LISTEN/NOTIFY. ' +
-                        'Workflow notifications will fall back to polling, which may increase latency.');
-                }
-                const handler = (msg) => {
-                    if (!this.shouldUseDBNotifications)
-                        return;
-                    if (msg.channel === 'dbos_notifications_channel' && msg.payload) {
-                        this.notificationsMap.callCallbacks(msg.payload);
-                    }
-                    else if (msg.channel === 'dbos_workflow_events_channel' && msg.payload) {
-                        this.workflowEventsMap.callCallbacks(msg.payload);
-                    }
-                };
-                client.on('notification', handler);
-                client.on('error', (err) => {
-                    this.logger.warn(`Error in notifications client: ${err}`);
-                    if (client) {
-                        client.removeAllListeners();
-                        client.release(true);
-                    }
-                    reconnect();
-                });
-                this.notificationsClient = client;
-            }
-            catch (error) {
-                this.logger.warn(`Error in notifications listener: ${String(error)}`);
-                if (client) {
-                    client.removeAllListeners();
-                    client.release(true);
-                }
-                reconnect();
-            }
-        };
-        await connect();
+        // Record the output if it is inside a workflow.
+        if (callerWorkflow) {
+            await this.recordOperationResult(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, true, startTime, {
+                output: value,
+                serialization: valueSer,
+            });
+        }
+        return { serializedValue: value, serialization: valueSer };
     }
     // Event dispatcher queries / updates
     async getEventDispatchState(service, workflowName, key) {
@@ -1703,125 +1470,78 @@ class PostgresSystemDatabase {
                 : undefined,
         };
     }
-    async listWorkflows(input) {
-        const schemaName = this.schemaName;
-        const selectColumns = [
-            'workflow_uuid',
-            'status',
-            'name',
-            'recovery_attempts',
-            'config_name',
-            'class_name',
-            'authenticated_user',
-            'authenticated_roles',
-            'assumed_role',
-            'queue_name',
-            'executor_id',
-            'created_at',
-            'updated_at',
-            'application_version',
-            'application_id',
-            'workflow_deadline_epoch_ms',
-            'workflow_timeout_ms',
-            'deduplication_id',
-            'priority',
-            'queue_partition_key',
-            'started_at_epoch_ms',
-            'forked_from',
-            'parent_workflow_id',
-        ];
-        input.loadInput = input.loadInput ?? true;
-        input.loadOutput = input.loadOutput ?? true;
-        if (input.loadInput) {
-            selectColumns.push('inputs', 'request');
-        }
-        if (input.loadOutput) {
-            selectColumns.push('output', 'error');
-        }
-        if (input.loadInput || input.loadOutput) {
-            selectColumns.push('serialization');
+    // ==================== Streams ====================
+    async writeStreamFromStep(workflowID, functionID, key, serializedValue, serialization) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
+            // Find the maximum offset for this workflow_uuid and key combination
+            const maxOffsetResult = await client.query(`SELECT MAX("offset") FROM "${this.schemaName}".streams
+         WHERE workflow_uuid = $1 AND key = $2`, [workflowID, key]);
+            // Next offset is max + 1, or 0 if no records exist
+            const maxOffset = maxOffsetResult.rows[0].max;
+            const nextOffset = maxOffset !== null ? maxOffset + 1 : 0;
+            // Insert the new stream entry
+            await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id, serialization)
+         VALUES ($1, $2, $3, $4, $5, $6)`, [workflowID, key, serializedValue, nextOffset, functionID, serialization]);
+            await client.query('COMMIT');
         }
-        input.sortDesc = input.sortDesc ?? false; // By default, sort in ascending order
-        // Build WHERE clauses
-        const whereClauses = [];
-        const params = [];
-        let paramCounter = 1;
-        // Helper: add a filter for a field that may be a single value or an array.
-        // Uses = for a single value, IN (...) for an array.
-        const addFilter = (column, value) => {
-            if (!value)
-                return;
-            if (Array.isArray(value)) {
-                const placeholders = value.map((_, i) => `$${paramCounter + i}`).join(', ');
-                whereClauses.push(`${column} IN (${placeholders})`);
-                params.push(...value);
-                paramCounter += value.length;
-            }
-            else {
-                whereClauses.push(`${column} = $${paramCounter}`);
-                params.push(value);
-                paramCounter++;
-            }
-        };
-        // If queuesOnly, filter for queued workflows
-        if (input.queuesOnly) {
-            whereClauses.push(`queue_name IS NOT NULL`);
-            whereClauses.push(`status IN ($${paramCounter}, $${paramCounter + 1})`);
-            params.push(workflow_1.StatusString.ENQUEUED, workflow_1.StatusString.PENDING);
-            paramCounter += 2;
+        catch (e) {
+            this.logger.error(e);
+            await client.query('ROLLBACK');
+            throw e;
         }
-        addFilter('name', input.workflowName);
-        addFilter('queue_name', input.queueName);
-        if (input.workflow_id_prefix) {
-            if (Array.isArray(input.workflow_id_prefix)) {
-                const likeClauses = input.workflow_id_prefix.map((_, i) => `workflow_uuid LIKE $${paramCounter + i}`);
-                whereClauses.push(`(${likeClauses.join(' OR ')})`);
-                params.push(...input.workflow_id_prefix.map((p) => `${p}%`));
-                paramCounter += input.workflow_id_prefix.length;
-            }
-            else {
-                whereClauses.push(`workflow_uuid LIKE $${paramCounter}`);
-                params.push(`${input.workflow_id_prefix}%`);
-                paramCounter++;
-            }
+        finally {
+            client.release();
         }
-        if (input.workflowIDs) {
-            const placeholders = input.workflowIDs.map((_, i) => `$${paramCounter + i}`).join(', ');
-            whereClauses.push(`workflow_uuid IN (${placeholders})`);
-            params.push(...input.workflowIDs);
-            paramCounter += input.workflowIDs.length;
+    }
+    async writeStreamFromWorkflow(workflowID, functionID, key, serializedValue, serialization, functionName) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
+            await this.#runAndRecordResult(client, functionName, workflowID, functionID, async () => {
+                // Find the maximum offset for this workflow_uuid and key combination
+                const maxOffsetResult = await client.query(`SELECT MAX("offset") FROM "${this.schemaName}".streams 
+           WHERE workflow_uuid = $1 AND key = $2`, [workflowID, key]);
+                // Next offset is max + 1, or 0 if no records exist
+                const maxOffset = maxOffsetResult.rows[0].max;
+                const nextOffset = maxOffset !== null ? maxOffset + 1 : 0;
+                // Insert the new stream entry
+                await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id, serialization)
+           VALUES ($1, $2, $3, $4, $5, $6)`, [workflowID, key, serializedValue, nextOffset, functionID, serialization]);
+                return undefined;
+            });
+            await client.query('COMMIT');
         }
-        addFilter('authenticated_user', input.authenticatedUser);
-        addFilter('forked_from', input.forkedFrom);
-        addFilter('parent_workflow_id', input.parentWorkflowID);
-        if (input.startTime) {
-            whereClauses.push(`created_at >= $${paramCounter}`);
-            params.push(new Date(input.startTime).getTime());
-            paramCounter++;
+        catch (e) {
+            this.logger.error(e);
+            await client.query('ROLLBACK');
+            throw e;
         }
-        if (input.endTime) {
-            whereClauses.push(`created_at <= $${paramCounter}`);
-            params.push(new Date(input.endTime).getTime());
-            paramCounter++;
+        finally {
+            client.release();
+        }
+    }
+    async closeStream(workflowID, functionID, key) {
+        await this.writeStreamFromWorkflow(workflowID, functionID, key, exports.DBOS_STREAM_CLOSED_SENTINEL, 'portable_json', exports.DBOS_FUNCNAME_CLOSESTREAM);
+    }
+    async readStream(workflowID, key, offset) {
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(`SELECT value, serialization FROM "${this.schemaName}".streams 
+         WHERE workflow_uuid = $1 AND key = $2 AND "offset" = $3`, [workflowID, key, offset]);
+            if (result.rows.length === 0) {
+                throw new Error(`No value found for workflow_uuid=${workflowID}, key=${key}, offset=${offset}`);
+            }
+            // Deserialize the value before returning
+            const row = result.rows[0];
+            return { serializedValue: row.value, serialization: row.serialization };
+        }
+        finally {
+            client.release();
         }
-        addFilter('status', input.status);
-        addFilter('application_version', input.applicationVersion);
-        addFilter('executor_id', input.executorId);
-        const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(' AND ')}` : '';
-        const orderClause = `ORDER BY created_at ${input.sortDesc ? 'DESC' : 'ASC'}`;
-        const limitClause = input.limit ? `LIMIT ${input.limit}` : '';
-        const offsetClause = input.offset ? `OFFSET ${input.offset}` : '';
-        const query = `
-      SELECT ${selectColumns.join(', ')}
-      FROM "${schemaName}".workflow_status
-      ${whereClause}
-      ${orderClause}
-      ${limitClause}
-      ${offsetClause}
-    `;
-        const result = await this.pool.query(query, params);
-        return result.rows.map(mapWorkflowStatus);
     }
+    // ==================== Queues ====================
     async clearQueueAssignment(workflowID) {
         // Reset the status of the task from "PENDING" to "ENQUEUED"
         const wqRes = await this.pool.query(`UPDATE "${this.schemaName}".workflow_status
@@ -1960,75 +1680,125 @@ class PostgresSystemDatabase {
         // Return the IDs of all functions we marked started
         return claimedIDs;
     }
-    async writeStreamFromStep(workflowID, functionID, key, serializedValue, serialization) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            // Find the maximum offset for this workflow_uuid and key combination
-            const maxOffsetResult = await client.query(`SELECT MAX("offset") FROM "${this.schemaName}".streams
-         WHERE workflow_uuid = $1 AND key = $2`, [workflowID, key]);
-            // Next offset is max + 1, or 0 if no records exist
-            const maxOffset = maxOffsetResult.rows[0].max;
-            const nextOffset = maxOffset !== null ? maxOffset + 1 : 0;
-            // Insert the new stream entry
-            await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id, serialization)
-         VALUES ($1, $2, $3, $4, $5, $6)`, [workflowID, key, serializedValue, nextOffset, functionID, serialization]);
-            await client.query('COMMIT');
+    // ==================== Queries & Maintenance ====================
+    async listWorkflows(input) {
+        const schemaName = this.schemaName;
+        const selectColumns = [
+            'workflow_uuid',
+            'status',
+            'name',
+            'recovery_attempts',
+            'config_name',
+            'class_name',
+            'authenticated_user',
+            'authenticated_roles',
+            'assumed_role',
+            'queue_name',
+            'executor_id',
+            'created_at',
+            'updated_at',
+            'application_version',
+            'application_id',
+            'workflow_deadline_epoch_ms',
+            'workflow_timeout_ms',
+            'deduplication_id',
+            'priority',
+            'queue_partition_key',
+            'started_at_epoch_ms',
+            'forked_from',
+            'parent_workflow_id',
+        ];
+        input.loadInput = input.loadInput ?? true;
+        input.loadOutput = input.loadOutput ?? true;
+        if (input.loadInput) {
+            selectColumns.push('inputs', 'request');
         }
-        catch (e) {
-            this.logger.error(e);
-            await client.query('ROLLBACK');
-            throw e;
+        if (input.loadOutput) {
+            selectColumns.push('output', 'error');
         }
-        finally {
-            client.release();
+        if (input.loadInput || input.loadOutput) {
+            selectColumns.push('serialization');
         }
-    }
-    async writeStreamFromWorkflow(workflowID, functionID, key, serializedValue, serialization, functionName) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            await this.#runAndRecordResult(client, functionName, workflowID, functionID, async () => {
-                // Find the maximum offset for this workflow_uuid and key combination
-                const maxOffsetResult = await client.query(`SELECT MAX("offset") FROM "${this.schemaName}".streams 
-           WHERE workflow_uuid = $1 AND key = $2`, [workflowID, key]);
-                // Next offset is max + 1, or 0 if no records exist
-                const maxOffset = maxOffsetResult.rows[0].max;
-                const nextOffset = maxOffset !== null ? maxOffset + 1 : 0;
-                // Insert the new stream entry
-                await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id, serialization)
-           VALUES ($1, $2, $3, $4, $5, $6)`, [workflowID, key, serializedValue, nextOffset, functionID, serialization]);
-                return undefined;
-            });
-            await client.query('COMMIT');
+        input.sortDesc = input.sortDesc ?? false; // By default, sort in ascending order
+        // Build WHERE clauses
+        const whereClauses = [];
+        const params = [];
+        let paramCounter = 1;
+        // Helper: add a filter for a field that may be a single value or an array.
+        // Uses = for a single value, IN (...) for an array.
+        const addFilter = (column, value) => {
+            if (!value)
+                return;
+            if (Array.isArray(value)) {
+                const placeholders = value.map((_, i) => `$${paramCounter + i}`).join(', ');
+                whereClauses.push(`${column} IN (${placeholders})`);
+                params.push(...value);
+                paramCounter += value.length;
+            }
+            else {
+                whereClauses.push(`${column} = $${paramCounter}`);
+                params.push(value);
+                paramCounter++;
+            }
+        };
+        // If queuesOnly, filter for queued workflows
+        if (input.queuesOnly) {
+            whereClauses.push(`queue_name IS NOT NULL`);
+            whereClauses.push(`status IN ($${paramCounter}, $${paramCounter + 1})`);
+            params.push(workflow_1.StatusString.ENQUEUED, workflow_1.StatusString.PENDING);
+            paramCounter += 2;
         }
-        catch (e) {
-            this.logger.error(e);
-            await client.query('ROLLBACK');
-            throw e;
+        addFilter('name', input.workflowName);
+        addFilter('queue_name', input.queueName);
+        if (input.workflow_id_prefix) {
+            if (Array.isArray(input.workflow_id_prefix)) {
+                const likeClauses = input.workflow_id_prefix.map((_, i) => `workflow_uuid LIKE $${paramCounter + i}`);
+                whereClauses.push(`(${likeClauses.join(' OR ')})`);
+                params.push(...input.workflow_id_prefix.map((p) => `${p}%`));
+                paramCounter += input.workflow_id_prefix.length;
+            }
+            else {
+                whereClauses.push(`workflow_uuid LIKE $${paramCounter}`);
+                params.push(`${input.workflow_id_prefix}%`);
+                paramCounter++;
+            }
         }
-        finally {
-            client.release();
+        if (input.workflowIDs) {
+            const placeholders = input.workflowIDs.map((_, i) => `$${paramCounter + i}`).join(', ');
+            whereClauses.push(`workflow_uuid IN (${placeholders})`);
+            params.push(...input.workflowIDs);
+            paramCounter += input.workflowIDs.length;
         }
-    }
-    async closeStream(workflowID, functionID, key) {
-        await this.writeStreamFromWorkflow(workflowID, functionID, key, exports.DBOS_STREAM_CLOSED_SENTINEL, 'portable_json', exports.DBOS_FUNCNAME_CLOSESTREAM);
-    }
-    async readStream(workflowID, key, offset) {
-        const client = await this.pool.connect();
-        try {
-            const result = await client.query(`SELECT value, serialization FROM "${this.schemaName}".streams 
-         WHERE workflow_uuid = $1 AND key = $2 AND "offset" = $3`, [workflowID, key, offset]);
-            if (result.rows.length === 0) {
-                throw new Error(`No value found for workflow_uuid=${workflowID}, key=${key}, offset=${offset}`);
-            }
-            // Deserialize the value before returning
-            const row = result.rows[0];
-            return { serializedValue: row.value, serialization: row.serialization };
+        addFilter('authenticated_user', input.authenticatedUser);
+        addFilter('forked_from', input.forkedFrom);
+        addFilter('parent_workflow_id', input.parentWorkflowID);
+        if (input.startTime) {
+            whereClauses.push(`created_at >= $${paramCounter}`);
+            params.push(new Date(input.startTime).getTime());
+            paramCounter++;
         }
-        finally {
-            client.release();
+        if (input.endTime) {
+            whereClauses.push(`created_at <= $${paramCounter}`);
+            params.push(new Date(input.endTime).getTime());
+            paramCounter++;
         }
+        addFilter('status', input.status);
+        addFilter('application_version', input.applicationVersion);
+        addFilter('executor_id', input.executorId);
+        const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(' AND ')}` : '';
+        const orderClause = `ORDER BY created_at ${input.sortDesc ? 'DESC' : 'ASC'}`;
+        const limitClause = input.limit ? `LIMIT ${input.limit}` : '';
+        const offsetClause = input.offset ? `OFFSET ${input.offset}` : '';
+        const query = `
+      SELECT ${selectColumns.join(', ')}
+      FROM "${schemaName}".workflow_status
+      ${whereClause}
+      ${orderClause}
+      ${limitClause}
+      ${offsetClause}
+    `;
+        const result = await this.pool.query(query, params);
+        return result.rows.map(mapWorkflowStatus);
     }
     async garbageCollect(cutoffEpochTimestampMs, rowsThreshold) {
         if (rowsThreshold !== undefined) {
@@ -2055,92 +1825,36 @@ class PostgresSystemDatabase {
         return;
     }
     async getMetrics(startTime, endTime) {
-        const startEpochMs = new Date(startTime).getTime();
-        const endEpochMs = new Date(endTime).getTime();
-        const metrics = [];
-        // Query workflow metrics
-        const workflowResult = await this.pool.query(`SELECT name, COUNT(workflow_uuid) as count
-       FROM "${this.schemaName}".workflow_status
-       WHERE created_at >= $1 AND created_at < $2
-       GROUP BY name`, [startEpochMs, endEpochMs]);
-        for (const row of workflowResult.rows) {
-            metrics.push({
-                metricType: 'workflow_count',
-                metricName: row.name,
-                value: Number(row.count),
-            });
-        }
-        // Query step metrics
-        const stepResult = await this.pool.query(`SELECT function_name, COUNT(*) as count
-       FROM "${this.schemaName}".operation_outputs
-       WHERE completed_at_epoch_ms >= $1 AND completed_at_epoch_ms < $2
-       GROUP BY function_name`, [startEpochMs, endEpochMs]);
-        for (const row of stepResult.rows) {
-            metrics.push({
-                metricType: 'step_count',
-                metricName: row.function_name,
-                value: Number(row.count),
-            });
-        }
-        return metrics;
-    }
-    async checkPatch(workflowID, functionID, patchName, deprecated) {
-        // Not doing a cancel check at this point.
-        if (functionID === undefined)
-            throw new TypeError('functionID must be defined');
-        patchName = `DBOS.patch-${patchName}`;
-        const { rows } = await this.pool.query(`SELECT function_name
-       FROM "${this.schemaName}".operation_outputs
-      WHERE workflow_uuid=$1 AND function_id=$2`, [workflowID, functionID]);
-        if (deprecated) {
-            // Deprecated does not write anything.  We skip any existing matching patch marker if it matches
-            if (rows.length === 0) {
-                return { isPatched: true, hasEntry: false };
-            }
-            return { isPatched: true, hasEntry: rows[0].function_name === patchName };
-        }
-        // Nondeprecated - skip matching entry, unpatched if nonmatching entry,
-        //  If there is no entry, we insert one that indicates it is patched.
-        if (rows.length !== 0) {
-            if (rows[0].function_name === patchName) {
-                return { isPatched: true, hasEntry: true };
-            }
-            return { isPatched: false, hasEntry: false };
-        }
-        // Insert a patchmarker
-        const dn = Date.now();
-        await this.pool.query(`INSERT INTO ${this.schemaName}.operation_outputs
-       (workflow_uuid, function_id, output, error, function_name, child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-       ON CONFLICT DO NOTHING;`, [workflowID, functionID, null, null, patchName, null, dn, dn]);
-        return { isPatched: true, hasEntry: true };
-    }
-    async runTransactionalStep(workflowID, functionID, functionName, callback) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            const existing = await this.#getOperationResultAndThrowIfCancelled(client, workflowID, functionID);
-            if (existing !== undefined) {
-                await client.query('ROLLBACK');
-                return existing;
-            }
-            const startTime = Date.now();
-            const output = await callback(client);
-            await recordOperationResult(client, workflowID, functionID, functionName, true, this.schemaName, startTime, Date.now(), {
-                output,
+        const startEpochMs = new Date(startTime).getTime();
+        const endEpochMs = new Date(endTime).getTime();
+        const metrics = [];
+        // Query workflow metrics
+        const workflowResult = await this.pool.query(`SELECT name, COUNT(workflow_uuid) as count
+       FROM "${this.schemaName}".workflow_status
+       WHERE created_at >= $1 AND created_at < $2
+       GROUP BY name`, [startEpochMs, endEpochMs]);
+        for (const row of workflowResult.rows) {
+            metrics.push({
+                metricType: 'workflow_count',
+                metricName: row.name,
+                value: Number(row.count),
             });
-            await client.query('COMMIT');
-            return undefined;
-        }
-        catch (e) {
-            await client.query('ROLLBACK');
-            throw e;
         }
-        finally {
-            client.release();
+        // Query step metrics
+        const stepResult = await this.pool.query(`SELECT function_name, COUNT(*) as count
+       FROM "${this.schemaName}".operation_outputs
+       WHERE completed_at_epoch_ms >= $1 AND completed_at_epoch_ms < $2
+       GROUP BY function_name`, [startEpochMs, endEpochMs]);
+        for (const row of stepResult.rows) {
+            metrics.push({
+                metricType: 'step_count',
+                metricName: row.function_name,
+                value: Number(row.count),
+            });
         }
+        return metrics;
     }
-    // Dynamic workflow schedules
+    // ==================== Scheduling ====================
     async createSchedule(schedule, client) {
         const q = client ?? this.pool;
         try {
@@ -2255,144 +1969,483 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
+    // ==================== Internal ====================
+    async insertWorkflowStatus(client, initStatus, ownerXid, incrementAttempts = false) {
+        try {
+            const { rows } = await client.query(`INSERT INTO "${this.schemaName}".workflow_status (
+          workflow_uuid,
+          status,
+          name,
+          class_name,
+          config_name,
+          queue_name,
+          authenticated_user,
+          assumed_role,
+          authenticated_roles,
+          request,
+          executor_id,
+          application_version,
+          application_id,
+          created_at,
+          recovery_attempts,
+          updated_at,
+          workflow_timeout_ms,
+          workflow_deadline_epoch_ms,
+          inputs,
+          deduplication_id,
+          priority,
+          queue_partition_key,
+          forked_from,
+          parent_workflow_id,
+          serialization,
+          owner_xid
+        ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $26, $27)
+        ON CONFLICT (workflow_uuid)
+          DO UPDATE SET
+            recovery_attempts = CASE
+              WHEN workflow_status.status != '${workflow_1.StatusString.ENQUEUED}'
+              THEN workflow_status.recovery_attempts + $25
+              ELSE workflow_status.recovery_attempts
+            END,
+            updated_at = EXCLUDED.updated_at,
+            executor_id = CASE
+              WHEN EXCLUDED.status != '${workflow_1.StatusString.ENQUEUED}'
+              THEN EXCLUDED.executor_id
+              ELSE workflow_status.executor_id
+            END
+          RETURNING recovery_attempts, status, name, class_name, config_name, queue_name, workflow_deadline_epoch_ms, executor_id, owner_xid, serialization`, [
+                initStatus.workflowUUID,
+                initStatus.status,
+                initStatus.workflowName,
+                // For cross-language compatibility, these variables MUST be NULL in the database when not set
+                initStatus.workflowClassName === '' ? null : initStatus.workflowClassName,
+                initStatus.workflowConfigName === '' ? null : initStatus.workflowConfigName,
+                initStatus.queueName ?? null,
+                initStatus.authenticatedUser,
+                initStatus.assumedRole,
+                JSON.stringify(initStatus.authenticatedRoles),
+                JSON.stringify(initStatus.request),
+                initStatus.executorId,
+                initStatus.applicationVersion ?? null,
+                initStatus.applicationID,
+                initStatus.createdAt,
+                initStatus.status === workflow_1.StatusString.ENQUEUED ? 0 : 1,
+                initStatus.updatedAt ?? Date.now(),
+                initStatus.timeoutMS ?? null,
+                initStatus.deadlineEpochMS ?? null,
+                initStatus.input ?? null,
+                initStatus.deduplicationID ?? null,
+                initStatus.priority,
+                initStatus.queuePartitionKey ?? null,
+                initStatus.forkedFrom ?? null,
+                initStatus.parentWorkflowID ?? null,
+                (incrementAttempts ?? false) ? 1 : 0,
+                initStatus.serialization,
+                ownerXid,
+            ]);
+            if (rows.length === 0) {
+                throw new Error(`Attempt to insert workflow ${initStatus.workflowUUID} failed`);
+            }
+            const ret = rows[0];
+            ret.class_name = ret.class_name ?? '';
+            ret.config_name = ret.config_name ?? '';
+            initStatus.serialization = ret.serialization;
+            return ret;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === '23505') {
+                throw new error_1.DBOSQueueDuplicatedError(initStatus.workflowUUID, initStatus.queueName ?? '', initStatus.deduplicationID ?? '');
+            }
+            throw error;
+        }
+    }
+    async getWorkflowStatusValue(client, workflowID) {
+        const { rows } = await client.query(`SELECT status FROM "${this.schemaName}".workflow_status WHERE workflow_uuid=$1`, [workflowID]);
+        return rows.length === 0 ? undefined : rows[0].status;
+    }
+    async updateWorkflowStatus(client, workflowID, status, options = {}) {
+        let setClause = `SET status=$2, updated_at=$3`;
+        let whereClause = `WHERE workflow_uuid=$1`;
+        const args = [workflowID, status, Date.now()];
+        const update = options.update ?? {};
+        if (update.output) {
+            const param = args.push(update.output);
+            setClause += `, output=$${param}`;
+        }
+        if (update.error) {
+            const param = args.push(update.error);
+            setClause += `, error=$${param}`;
+        }
+        if (update.resetRecoveryAttempts) {
+            setClause += `, recovery_attempts = 0`;
+        }
+        if (update.resetDeadline) {
+            setClause += `, workflow_deadline_epoch_ms = NULL`;
+        }
+        if (update.queueName !== undefined) {
+            const param = args.push(update.queueName ?? undefined);
+            setClause += `, queue_name=$${param}`;
+        }
+        if (update.resetDeduplicationID) {
+            setClause += `, deduplication_id = NULL`;
+        }
+        if (update.resetStartedAtEpochMs) {
+            setClause += `, started_at_epoch_ms = NULL`;
+        }
+        if (update.executorId !== undefined) {
+            const param = args.push(update.executorId ?? undefined);
+            setClause += `, executor_id=$${param}`;
+        }
+        if (update.resetNameTo !== undefined) {
+            const param = args.push(update.resetNameTo ?? undefined);
+            setClause += `, name=$${param}`;
+        }
+        const where = options.where ?? {};
+        if (where.status) {
+            const param = args.push(where.status);
+            whereClause += ` AND status=$${param}`;
+        }
+        const result = await client.query(`UPDATE "${this.schemaName}".workflow_status ${setClause} ${whereClause}`, args);
+        const throwOnFailure = options.throwOnFailure ?? true;
+        if (throwOnFailure && result.rowCount !== 1) {
+            throw new error_1.DBOSWorkflowConflictError(`Attempt to record transition of nonexistent workflow ${workflowID}`);
+        }
+    }
+    async recordOperationResultInternal(client, workflowID, functionID, functionName, checkConflict, startTimeEpochMs, endTimeEpochMs, options = {}) {
+        try {
+            const out = await client.query(`INSERT INTO ${this.schemaName}.operation_outputs
+         (workflow_uuid, function_id, output, error, function_name, child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms, serialization)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+         ON CONFLICT DO NOTHING RETURNING completed_at_epoch_ms;`, [
+                workflowID,
+                functionID,
+                options.output ?? null,
+                options.error ?? null,
+                functionName,
+                options.childWorkflowID ?? null,
+                startTimeEpochMs,
+                endTimeEpochMs,
+                options.serialization ?? null,
+            ]);
+            if (checkConflict &&
+                (out?.rowCount ?? 0) > 0 &&
+                Number(out?.rows?.[0]?.completed_at_epoch_ms) !== endTimeEpochMs) {
+                dbos_executor_1.DBOSExecutor.globalInstance?.logger.warn(`Step output for ${workflowID}(${functionID}):${functionName} already recorded`);
+                throw new error_1.DBOSWorkflowConflictError(workflowID);
+            }
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === '40001' || err.code === '23505') {
+                // Serialization and primary key conflict (Postgres).
+                throw new error_1.DBOSWorkflowConflictError(workflowID);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async #getOperationResultAndThrowIfCancelled(client, workflowID, functionID) {
+        await this.#checkIfCanceled(client, workflowID);
+        const { rows } = await client.query(`SELECT output, error, child_workflow_id, function_name
+       FROM "${this.schemaName}".operation_outputs
+      WHERE workflow_uuid=$1 AND function_id=$2`, [workflowID, functionID]);
+        if (rows.length === 0) {
+            return undefined;
+        }
+        else {
+            return {
+                output: rows[0].output,
+                error: rows[0].error,
+                childWorkflowID: rows[0].child_workflow_id,
+                functionName: rows[0].function_name,
+            };
+        }
+    }
+    async #runAndRecordResult(client, functionName, workflowID, functionID, func) {
+        const startTime = Date.now();
+        const result = await this.#getOperationResultAndThrowIfCancelled(client, workflowID, functionID);
+        if (result !== undefined) {
+            if (result.functionName !== functionName) {
+                throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, functionName, result.functionName);
+            }
+            return result.output;
+        }
+        const output = await func();
+        await this.recordOperationResultInternal(client, workflowID, functionID, functionName, true, startTime, Date.now(), {
+            output,
+        });
+        return output;
+    }
+    #setWFCancelMap(workflowID) {
+        if (this.runningWorkflowMap.has(workflowID)) {
+            this.workflowCancellationMap.set(workflowID, true);
+        }
+        this.cancelWakeupMap.callCallbacks(workflowID);
+    }
+    #clearWFCancelMap(workflowID) {
+        if (this.workflowCancellationMap.has(workflowID)) {
+            this.workflowCancellationMap.delete(workflowID);
+        }
+    }
+    async #checkIfCanceled(client, workflowID) {
+        if (this.workflowCancellationMap.get(workflowID) === true) {
+            throw new error_1.DBOSWorkflowCancelledError(workflowID);
+        }
+        const statusValue = await this.getWorkflowStatusValue(client, workflowID);
+        if (statusValue === workflow_1.StatusString.CANCELLED) {
+            throw new error_1.DBOSWorkflowCancelledError(workflowID);
+        }
+    }
+    async #durableSleep(workflowID, functionID, durationMS, maxSleepPerIteration) {
+        if (maxSleepPerIteration === undefined)
+            maxSleepPerIteration = durationMS;
+        const curTime = Date.now();
+        let endTimeMs = curTime + durationMS;
+        const client = await this.pool.connect();
+        try {
+            const res = await this.#getOperationResultAndThrowIfCancelled(client, workflowID, functionID);
+            if (res) {
+                if (res.functionName !== exports.DBOS_FUNCNAME_SLEEP) {
+                    throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, res.functionName);
+                }
+                endTimeMs = JSON.parse(res.output);
+            }
+            else {
+                await this.recordOperationResultInternal(client, workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, false, Date.now(), Date.now(), {
+                    output: serialization_1.DBOSPortableJSON.stringify(endTimeMs),
+                    serialization: serialization_1.DBOSPortableJSON.name(),
+                });
+            }
+            return {
+                ...(0, utils_1.cancellableSleep)(Math.max(Math.min(maxSleepPerIteration, endTimeMs - curTime), 0)),
+                endTime: endTimeMs,
+            };
+        }
+        finally {
+            client.release();
+        }
+    }
+    /* BACKGROUND PROCESSES */
+    /**
+     * A background process that listens for notifications from Postgres then signals the appropriate
+     * workflow listener by resolving its promise.
+     */
+    reconnectTimeout = null;
+    async #listenForNotifications() {
+        const connect = async () => {
+            const reconnect = () => {
+                if (this.reconnectTimeout) {
+                    return;
+                }
+                this.reconnectTimeout = setTimeout(async () => {
+                    this.reconnectTimeout = null;
+                    await connect();
+                }, 1000);
+            };
+            let client = null;
+            try {
+                client = await this.pool.connect();
+                await client.query('LISTEN dbos_notifications_channel;');
+                await client.query('LISTEN dbos_workflow_events_channel;');
+                // Self-test: verify LISTEN actually works by sending a NOTIFY and checking it arrives.
+                // If a transaction-mode pooler (e.g. PgBouncer pool_mode=transaction) is in the path,
+                // LISTEN succeeds but the subscription is silently lost when the backend is released.
+                let selfTestReceived = false;
+                const onSelfTest = (msg) => {
+                    if (msg.channel === 'dbos_notifications_channel' && msg.payload === 'dbos_listen_selftest') {
+                        selfTestReceived = true;
+                    }
+                };
+                client.on('notification', onSelfTest);
+                await this.pool.query("NOTIFY dbos_notifications_channel, 'dbos_listen_selftest'");
+                for (let i = 0; i < 30 && !selfTestReceived; i++) {
+                    await new Promise((r) => setTimeout(r, 100));
+                }
+                client.removeListener('notification', onSelfTest);
+                if (!selfTestReceived) {
+                    this.logger.warn('LISTEN/NOTIFY self-test failed: notification was not received within 3 seconds. ' +
+                        'This typically means the connection is going through a transaction-mode pooler ' +
+                        '(e.g. PgBouncer with pool_mode=transaction), which silently breaks LISTEN/NOTIFY. ' +
+                        'Workflow notifications will fall back to polling, which may increase latency.');
+                }
+                const handler = (msg) => {
+                    if (!this.shouldUseDBNotifications)
+                        return;
+                    if (msg.channel === 'dbos_notifications_channel' && msg.payload) {
+                        this.notificationsMap.callCallbacks(msg.payload);
+                    }
+                    else if (msg.channel === 'dbos_workflow_events_channel' && msg.payload) {
+                        this.workflowEventsMap.callCallbacks(msg.payload);
+                    }
+                };
+                client.on('notification', handler);
+                client.on('error', (err) => {
+                    this.logger.warn(`Error in notifications client: ${err}`);
+                    if (client) {
+                        client.removeAllListeners();
+                        client.release(true);
+                    }
+                    reconnect();
+                });
+                this.notificationsClient = client;
+            }
+            catch (error) {
+                this.logger.warn(`Error in notifications listener: ${String(error)}`);
+                if (client) {
+                    client.removeAllListeners();
+                    client.release(true);
+                }
+                reconnect();
+            }
+        };
+        await connect();
+    }
 }
-exports.PostgresSystemDatabase = PostgresSystemDatabase;
+exports.SystemDatabase = SystemDatabase;
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "initWorkflowStatus", null);
+], SystemDatabase.prototype, "initWorkflowStatus", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "recordWorkflowOutput", null);
+], SystemDatabase.prototype, "recordWorkflowOutput", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "recordWorkflowError", null);
+], SystemDatabase.prototype, "recordWorkflowError", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number]),
+    __metadata("design:paramtypes", [String, String, Number]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "getOperationResultAndThrowIfCancelled", null);
+], SystemDatabase.prototype, "getWorkflowStatus", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Boolean, Number, Object]),
+    __metadata("design:paramtypes", [String, Number]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "recordOperationResult", null);
+], SystemDatabase.prototype, "getOperationResultAndThrowIfCancelled", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, Number]),
+    __metadata("design:paramtypes", [String, Number, String, Boolean, Number, Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "durableSleepms", null);
+], SystemDatabase.prototype, "recordOperationResult", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Object, Object, Object]),
+    __metadata("design:paramtypes", [String, Number, String, Boolean]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "send", null);
+], SystemDatabase.prototype, "checkPatch", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, Number, String, Number]),
+    __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "recv", null);
+], SystemDatabase.prototype, "checkIfCanceled", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Object, Object]),
+    __metadata("design:paramtypes", [String, Number, String, Number]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "setEvent", null);
+], SystemDatabase.prototype, "awaitWorkflowResult", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, Number, Object]),
+    __metadata("design:paramtypes", [Array, String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "getEvent", null);
+], SystemDatabase.prototype, "awaitFirstWorkflowId", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
+    __metadata("design:paramtypes", [String, Number, Number]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "checkIfCanceled", null);
+], SystemDatabase.prototype, "durableSleepms", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, Number]),
+    __metadata("design:paramtypes", [String, Number, String, Object, Object, Object, String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "getWorkflowStatus", null);
+], SystemDatabase.prototype, "send", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Number]),
+    __metadata("design:paramtypes", [String, Object, Object, Object, String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "awaitWorkflowResult", null);
+], SystemDatabase.prototype, "sendDirect", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, String]),
+    __metadata("design:paramtypes", [String, Number, Number, String, Number]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "awaitFirstWorkflowId", null);
+], SystemDatabase.prototype, "recv", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:paramtypes", [String, Number, String, Object, Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "getEventDispatchState", null);
+], SystemDatabase.prototype, "setEvent", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
+    __metadata("design:paramtypes", [String, String, Number, Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "upsertEventDispatchState", null);
+], SystemDatabase.prototype, "getEvent", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:paramtypes", [String, String, String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "getDeduplicatedWorkflow", null);
+], SystemDatabase.prototype, "getEventDispatchState", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "getQueuePartitions", null);
+], SystemDatabase.prototype, "upsertEventDispatchState", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Number, String, String, Object]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "writeStreamFromStep", null);
+], SystemDatabase.prototype, "writeStreamFromStep", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Number, String, String, Object, String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "writeStreamFromWorkflow", null);
+], SystemDatabase.prototype, "writeStreamFromWorkflow", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, String, Number]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "readStream", null);
+], SystemDatabase.prototype, "readStream", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "getMetrics", null);
+], SystemDatabase.prototype, "getDeduplicatedWorkflow", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Boolean]),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SystemDatabase.prototype, "getQueuePartitions", null);
+__decorate([
+    dbRetry(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Promise)
-], PostgresSystemDatabase.prototype, "checkPatch", null);
+], SystemDatabase.prototype, "getMetrics", null);
 //# sourceMappingURL=system_database.js.map