@tstdl/base 0.93.141 → 0.93.142

package/task-queue/postgres/task-queue.js

@@ -56,33 +56,34 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { aliasedTable, and, asc, count, eq, gt, gte, inArray, lt, lte, notExists, or, sql, count as sqlCount, isNull as sqlIsNull } from 'drizzle-orm';
-import { merge, throttleTime } from 'rxjs';
+import { aliasedTable, and, asc, count, eq, gt, gte, inArray, lt, lte, notExists, notInArray, or, sql, count as sqlCount, isNotNull as sqlIsNotNull, isNull as sqlIsNull } from 'drizzle-orm';
+import { filter, merge, throttleTime } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/index.js';
 import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/index.js';
 import { serializeError, TimeoutError } from '../../errors/index.js';
 import { afterResolve, inject, provide, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { MessageBus } from '../../message-bus/index.js';
-import { arrayOverlaps, coalesce, getEntityIds, interval, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
-import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
+import { arrayOverlaps, caseWhen, coalesce, enumValue, getEntityIds, greatest, interval, jsonbBuildObject, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { Database, DatabaseConfig, injectRepository } from '../../orm/server/index.js';
 import { RateLimiter } from '../../rate-limit/index.js';
-import { createArray, toArray } from '../../utils/array/array.js';
+import { distinct, toArray } from '../../utils/array/array.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { Timer } from '../../utils/timer.js';
 import { cancelableTimeout } from '../../utils/timing.js';
-import { isDefined, isNotNull, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../utils/type-guards.js';
-import { millisecondsPerSecond } from '../../utils/units.js';
+import { isDefined, isNotNull, isNull, isNumber, isString, isUndefined } from '../../utils/type-guards.js';
+import { millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.js';
 import { defaultQueueConfig, TaskDependencyType, TaskQueue, TaskStatus } from '../task-queue.js';
 import { PostgresTaskQueueModuleConfig } from './module.js';
-import { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, taskStatus, task as taskTable } from './schemas.js';
-import { PostgresTask, PostgresTaskArchive } from './task.model.js';
+import { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, taskDependencyType, taskStatus, task as taskTable } from './schemas.js';
+import { finalizedStatuses, PostgresTask, PostgresTaskArchive, queueableOrWaitableStatuses, queueableStatuses, terminalStatuses } from './task.model.js';
 let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
+    #database = inject(Database);
     #repository = injectRepository(PostgresTask);
     #archiveRepository = injectRepository(PostgresTaskArchive);
     #config = this.config;
     #namespace = isString(this.#config) ? this.#config : this.#config.namespace;
-    #messageBus = inject((MessageBus), `PostgresTaskQueue:${this.#namespace}`);
+    #messageBus = inject((MessageBus), 'PostgresTaskQueue');
     #logger = inject(Logger, `PostgresTaskQueue:${this.#namespace}`);
     #cancellationSignal = inject(CancellationSignal);
     #rateLimiter = inject(RateLimiter, {
@@ -109,18 +110,18 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     rateLimit = this.#config.rateLimit ?? defaultQueueConfig.rateLimit;
     rateInterval = this.#config.rateInterval ?? defaultQueueConfig.rateInterval;
     idempotencyWindow = this.#config.idempotencyWindow ?? defaultQueueConfig.idempotencyWindow;
-    globalConcurrency = this.#config.globalConcurrency ?? defaultQueueConfig.globalConcurrency;
     #takeNewUpdate = {
         namespace: this.#namespace,
         type: sql `excluded.type`,
-        status: sql `CASE WHEN excluded.unresolved_schedule_dependencies > 0 THEN ${TaskStatus.Waiting}::${taskStatus} ELSE ${TaskStatus.Pending}::${taskStatus} END`,
+        status: caseWhen(gt(sql `excluded.unresolved_schedule_dependencies`, 0), enumValue(TaskStatus, taskStatus, TaskStatus.Waiting)).else(enumValue(TaskStatus, taskStatus, TaskStatus.Pending)),
         token: null,
         priority: sql `excluded.priority`,
         idempotencyKey: sql `excluded.idempotency_key`,
         traceId: sql `excluded.trace_id`,
+        parentId: sql `excluded.parent_id`,
         tags: sql `excluded.tags`,
-        unresolvedScheduleDependencies: sql `excluded.unresolved_schedule_dependencies`,
-        unresolvedCompleteDependencies: sql `excluded.unresolved_complete_dependencies`,
+        unresolvedScheduleDependencies: taskTable.unresolvedScheduleDependencies,
+        unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies,
         failFast: sql `excluded.fail_fast`,
         tries: 0,
         creationTimestamp: TRANSACTION_TIMESTAMP,
@@ -138,7 +139,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     };
     [afterResolve]() {
         if (!this.isInTransaction) {
-            void this.maintenanceLoop();
+            this.maintenanceLoop();
         }
     }
     async enqueue(type, data, options) {
@@ -151,119 +152,167 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (items.length == 0) {
                 return (options?.returnTasks == true) ? [] : undefined;
             }
-            const newEntities = items.map((item) => {
-                const scheduleAfterCount = item.scheduleAfter?.length ?? 0;
-                const completeAfterCount = item.completeAfter?.length ?? 0;
-                const isWaiting = scheduleAfterCount > 0;
+            const itemsWithDistinctDependencies = items.map((item) => ({
+                ...item,
+                scheduleAfter: isDefined(item.scheduleAfter) ? Array.from(new Map(item.scheduleAfter.map((s) => [isNumber(s) || isString(s) ? s : JSON.stringify(s), s])).values()) : undefined,
+                completeAfter: isDefined(item.completeAfter) ? Array.from(new Map(item.completeAfter.map((s) => [isNumber(s) || isString(s) ? s : JSON.stringify(s), s])).values()) : undefined,
+            }));
+            const entitiesWithIndex = itemsWithDistinctDependencies.map((item, index) => {
                 return {
-                    namespace: this.#namespace,
-                    type: item.type,
-                    status: isWaiting ? TaskStatus.Waiting : TaskStatus.Pending,
-                    token: null,
-                    priority: item.priority ?? 1000,
-                    idempotencyKey: item.idempotencyKey ?? null,
-                    traceId: null,
-                    tags: item.tags ?? [],
-                    unresolvedScheduleDependencies: scheduleAfterCount,
-                    unresolvedCompleteDependencies: completeAfterCount,
-                    failFast: item.failFast ?? false,
-                    parentId: item.parentId ?? null,
-                    tries: 0,
-                    progress: 0,
-                    creationTimestamp: TRANSACTION_TIMESTAMP,
-                    priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
-                    scheduleTimestamp: item.scheduleTimestamp ?? TRANSACTION_TIMESTAMP,
-                    startTimestamp: null,
-                    timeToLive: item.timeToLive ?? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.defaultTimeToLive, 'milliseconds')}`,
-                    visibilityDeadline: null,
-                    completeTimestamp: null,
-                    data: item.data,
-                    state: null,
-                    result: null,
-                    error: null,
+                    index,
+                    entity: {
+                        namespace: this.#namespace,
+                        type: item.type,
+                        status: TaskStatus.Pending,
+                        token: null,
+                        priority: item.priority ?? 1000,
+                        idempotencyKey: item.idempotencyKey ?? null,
+                        traceId: null,
+                        tags: item.tags ?? [],
+                        unresolvedScheduleDependencies: 0,
+                        unresolvedCompleteDependencies: 0,
+                        failFast: item.failFast ?? false,
+                        parentId: item.parentId ?? null,
+                        tries: 0,
+                        progress: 0,
+                        creationTimestamp: TRANSACTION_TIMESTAMP,
+                        priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
+                        scheduleTimestamp: item.scheduleTimestamp ?? TRANSACTION_TIMESTAMP,
+                        startTimestamp: null,
+                        timeToLive: item.timeToLive ?? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.defaultTimeToLive, 'milliseconds')}`,
+                        visibilityDeadline: null,
+                        completeTimestamp: null,
+                        data: item.data,
+                        state: null,
+                        result: null,
+                        error: null,
+                    },
                 };
             });
-            const itemsWithIdempotency = newEntities.filter((e) => isNotNull(e.idempotencyKey));
-            const itemsWithoutIdempotency = newEntities.filter((e) => isNull(e.idempotencyKey));
-            const hasDependencies = items.some((item) => ((item.scheduleAfter?.length ?? 0) > 0) || ((item.completeAfter?.length ?? 0) > 0) || (isDefined(item.parentId) && (item.waitForCompletion ?? true)));
-            const mustUseTransaction = ((itemsWithoutIdempotency.length + itemsWithIdempotency.length) > 1) || hasDependencies;
+            const itemsWithIdempotency = entitiesWithIndex.filter((e) => isNotNull(e.entity.idempotencyKey));
+            const itemsWithoutIdempotency = entitiesWithIndex.filter((e) => isNull(e.entity.idempotencyKey));
+            const hasDependencies = itemsWithDistinctDependencies.some((item) => ((item.scheduleAfter?.length ?? 0) > 0) || ((item.completeAfter?.length ?? 0) > 0) || (isDefined(item.parentId) && (item.waitForCompletion ?? true)));
+            const mustUseTransaction = (entitiesWithIndex.length > 1) || hasDependencies;
             const newTransaction = __addDisposableResource(env_1, (mustUseTransaction && isUndefined(options?.transaction)) ? await this.#repository.startTransaction() : undefined, true);
             const transaction = newTransaction ?? options?.transaction;
             const session = transaction?.pgTransaction ?? this.#repository.session;
-            const tasks = [];
+            const tasks = new Array(itemsWithDistinctDependencies.length);
+            let insertedRows = [];
+            let upsertedRows = [];
             if (itemsWithoutIdempotency.length > 0) {
-                const insertedRows = await session.insert(taskTable).values(itemsWithoutIdempotency).returning();
-                tasks.push(...insertedRows);
+                insertedRows = await session.insert(taskTable).values(itemsWithoutIdempotency.map((i) => i.entity)).returning();
+                for (const [i, row] of insertedRows.entries()) {
+                    tasks[itemsWithoutIdempotency[i].index] = row;
+                }
             }
             if (itemsWithIdempotency.length > 0) {
                 const windowCutoff = sql `${TRANSACTION_TIMESTAMP} - ${interval(this.idempotencyWindow, 'milliseconds')}`;
                 const setWhere = (options?.replace == true) ? undefined : sql `${taskTable.creationTimestamp} < ${windowCutoff}`;
-                const upsertedRows = await session
+                upsertedRows = await session
                     .insert(taskTable)
-                    .values(itemsWithIdempotency)
+                    .values(itemsWithIdempotency.map((i) => i.entity))
                     .onConflictDoUpdate({
                     target: [taskTable.namespace, taskTable.idempotencyKey],
                     set: this.#takeNewUpdate,
                     setWhere,
                 })
                     .returning();
-                tasks.push(...upsertedRows);
-                if (options?.replace == true) {
-                    const upsertedIds = upsertedRows.map((t) => t.id);
-                    if (upsertedIds.length > 0) {
-                        await session.delete(taskDependencyTable).where(and(eq(taskDependencyTable.namespace, this.#namespace), inArray(taskDependencyTable.taskId, upsertedIds)));
-                    }
+                const upsertedIds = upsertedRows.map((t) => t.id);
+                if (upsertedIds.length > 0) {
+                    await session
+                        .delete(taskDependencyTable)
+                        .where(and(inArray(taskDependencyTable.taskId, upsertedIds), inArray(taskDependencyTable.type, [TaskDependencyType.Schedule, TaskDependencyType.Complete])));
+                    await session
+                        .update(taskTable)
+                        .set({ unresolvedScheduleDependencies: 0 })
+                        .where(inArray(taskTable.id, upsertedIds));
                 }
-                if (((options?.returnTasks == true) || hasDependencies) && (upsertedRows.length < itemsWithIdempotency.length)) {
-                    const upsertedKeys = new Set(upsertedRows.map((t) => t.idempotencyKey));
-                    const missingKeys = itemsWithIdempotency.map((i) => i.idempotencyKey).filter((k) => !upsertedKeys.has(k));
-                    if (missingKeys.length > 0) {
+                if ((options?.returnTasks == true) || hasDependencies) {
+                    const upsertedKeysMap = new Map(upsertedRows.map((t) => [t.idempotencyKey, t]));
+                    const missingKeysWithIndex = [];
+                    for (const item of itemsWithIdempotency) {
+                        const key = item.entity.idempotencyKey;
+                        const task = upsertedKeysMap.get(key);
+                        if (isDefined(task)) {
+                            tasks[item.index] = task;
+                        }
+                        else {
+                            missingKeysWithIndex.push({ index: item.index, key });
+                        }
+                    }
+                    if (missingKeysWithIndex.length > 0) {
                         const existingRows = await session
                             .select()
                             .from(taskTable)
-                            .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.idempotencyKey, missingKeys)));
-                        tasks.push(...existingRows);
+                            .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.idempotencyKey, missingKeysWithIndex.map((m) => m.key))));
+                        const existingRowsMap = new Map(existingRows.map((t) => [t.idempotencyKey, t]));
+                        for (const missing of missingKeysWithIndex) {
+                            tasks[missing.index] = existingRowsMap.get(missing.key);
+                        }
                     }
                 }
             }
             if (hasDependencies) {
                 const dependencies = [];
-                const parentIncrements = new Map();
-                for (const [index, item] of items.entries()) {
+                const processedTaskIds = new Set([...insertedRows.map((r) => r.id), ...upsertedRows.map((r) => r.id)]);
+                for (const [index, item] of itemsWithDistinctDependencies.entries()) {
                     const task = tasks[index];
+                    if (!processedTaskIds.has(task.id)) {
+                        continue;
+                    }
                     if (isDefined(item.parentId) && (item.waitForCompletion ?? true)) {
                         dependencies.push({
-                            namespace: this.#namespace,
                             taskId: item.parentId,
                             dependencyTaskId: task.id,
-                            type: TaskDependencyType.Complete,
+                            type: TaskDependencyType.Child,
                             requiredStatuses: [TaskStatus.Completed],
                         });
-                        parentIncrements.set(item.parentId, (parentIncrements.get(item.parentId) ?? 0) + 1);
                     }
                     if (isDefined(item.scheduleAfter)) {
                         for (const dependency of item.scheduleAfter) {
-                            const dependencyTaskId = isString(dependency) ? dependency : dependency.id;
-                            const requiredStatuses = (isString(dependency) ? [TaskStatus.Completed] : (dependency.requiredStatuses ?? [TaskStatus.Completed]));
+                            let dependencyTaskId;
+                            let requiredStatuses;
+                            if (isNumber(dependency)) {
+                                dependencyTaskId = tasks[dependency].id;
+                                requiredStatuses = [TaskStatus.Completed];
+                            }
+                            else if (isString(dependency)) {
+                                dependencyTaskId = dependency;
+                                requiredStatuses = [TaskStatus.Completed];
+                            }
+                            else {
+                                dependencyTaskId = isDefined(dependency.index) ? tasks[dependency.index].id : dependency.id;
+                                requiredStatuses = dependency.requiredStatuses ?? [TaskStatus.Completed];
+                            }
                             dependencies.push({
-                                namespace: this.#namespace,
                                 taskId: task.id,
                                 dependencyTaskId,
                                 type: TaskDependencyType.Schedule,
-                                requiredStatuses,
+                                requiredStatuses: requiredStatuses,
                             });
                         }
                     }
                     if (isDefined(item.completeAfter)) {
                         for (const dependency of item.completeAfter) {
-                            const dependencyTaskId = isString(dependency) ? dependency : dependency.id;
-                            const requiredStatuses = (isString(dependency) ? [TaskStatus.Completed] : (dependency.requiredStatuses ?? [TaskStatus.Completed]));
+                            let dependencyTaskId;
+                            let requiredStatuses;
+                            if (isNumber(dependency)) {
+                                dependencyTaskId = tasks[dependency].id;
+                                requiredStatuses = [TaskStatus.Completed];
+                            }
+                            else if (isString(dependency)) {
+                                dependencyTaskId = dependency;
+                                requiredStatuses = [TaskStatus.Completed];
+                            }
+                            else {
+                                dependencyTaskId = isDefined(dependency.index) ? tasks[dependency.index].id : dependency.id;
+                                requiredStatuses = dependency.requiredStatuses ?? [TaskStatus.Completed];
+                            }
                             dependencies.push({
-                                namespace: this.#namespace,
                                 taskId: task.id,
                                 dependencyTaskId,
                                 type: TaskDependencyType.Complete,
-                                requiredStatuses,
+                                requiredStatuses: requiredStatuses,
                             });
                         }
                     }
@@ -274,27 +323,35 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                         .values(dependencies)
                         .onConflictDoNothing()
                         .returning();
-                    if (parentIncrements.size > 0) {
-                        for (const [parentId, increment] of parentIncrements) {
-                            // We only increment for those that were actually inserted.
-                            // Since we use onConflict: 'do-nothing', inserted array only contains actually inserted ones.
-                            const actualIncrement = inserted.filter((d) => d.taskId == parentId && d.type == TaskDependencyType.Complete).length;
-                            if (actualIncrement > 0) {
-                                await session
-                                    .update(taskTable)
-                                    .set({
-                                    unresolvedCompleteDependencies: sql `${taskTable.unresolvedCompleteDependencies} + ${actualIncrement}`,
-                                })
-                                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, parentId)));
-                            }
+                    const distinctDependencyIds = distinct(dependencies.map((d) => d.dependencyTaskId));
+                    if (distinctDependencyIds.length > 0) {
+                        await this.incrementCounters(inserted, { transaction });
+                        const dependencyStatuses = await session
+                            .select({ id: taskTable.id, status: taskTable.status })
+                            .from(taskTable)
+                            .where(inArray(taskTable.id, distinctDependencyIds))
+                            .unionAll(session
+                            .select({ id: taskArchiveTable.id, status: sql `${enumValue(TaskStatus, taskStatus, TaskStatus.Completed)}` })
+                            .from(taskArchiveTable)
+                            .where(inArray(taskArchiveTable.id, distinctDependencyIds)));
+                        if (dependencyStatuses.length > 0) {
+                            await this.resolveDependenciesMany(dependencyStatuses.map((s) => ({ id: s.id, status: s.status })), { transaction: transaction });
                         }
                     }
                 }
             }
-            await newTransaction?.commit();
-            this.#messageBus.publishAndForget();
+            if (isDefined(newTransaction) && !newTransaction.isDone) {
+                await newTransaction.commit();
+            }
+            this.notify();
             if (options?.returnTasks == true) {
-                const mapped = await this.#repository.mapManyToEntity(tasks);
+                const finalTasks = await session
+                    .select()
+                    .from(taskTable)
+                    .where(inArray(taskTable.id, tasks.map((t) => t.id)));
+                const finalTasksMap = new Map(finalTasks.map((t) => [t.id, t]));
+                const orderedFinalTasks = tasks.map((t) => finalTasksMap.get(t.id));
+                const mapped = await this.#repository.mapManyToEntity(orderedFinalTasks);
                 return mapped;
             }
             return undefined;
@@ -309,12 +366,53 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 await result_1;
         }
     }
+    async incrementCounters(dependencies, options) {
+        if (dependencies.length == 0) {
+            return;
+        }
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const decrementsToApply = new Map();
+        for (const dep of dependencies) {
+            const current = decrementsToApply.get(dep.taskId) ?? { schedule: 0, complete: 0 };
+            if (dep.type == TaskDependencyType.Schedule) {
+                current.schedule++;
+            }
+            else if (dep.type == TaskDependencyType.Complete || dep.type == TaskDependencyType.Child) {
+                current.complete++;
+            }
+            decrementsToApply.set(dep.taskId, current);
+        }
+        const values = [...decrementsToApply]
+            .toSorted(([idA], [idB]) => idA.localeCompare(idB))
+            .map(([taskId, d]) => sql `(${taskId}::uuid, ${d.schedule}::int, ${d.complete}::int)`);
+        const updates = session.$with('updates').as((qb) => qb
+            .select({
+            taskId: sql `(id)::uuid`.as('task_id'),
+            scheduleIncrement: sql `(schedule)::int`.as('schedule_increment'),
+            completeIncrement: sql `(complete)::int`.as('complete_increment'),
+        })
+            .from(sql `(VALUES ${sql.join(values, sql `, `)}) AS t(id, schedule, complete)`));
+        const updatedRows = await session
+            .with(updates)
+            .update(taskTable)
+            .set({
+            unresolvedScheduleDependencies: sql `${taskTable.unresolvedScheduleDependencies} + ${updates.scheduleIncrement}`,
+            unresolvedCompleteDependencies: sql `${taskTable.unresolvedCompleteDependencies} + ${updates.completeIncrement}`,
+            status: caseWhen(and(eq(taskTable.status, TaskStatus.Pending), gt(sql `${taskTable.unresolvedScheduleDependencies} + ${updates.scheduleIncrement}`, 0)), enumValue(TaskStatus, taskStatus, TaskStatus.Waiting)).else(taskTable.status),
+        })
+            .from(updates)
+            .where(eq(taskTable.id, updates.taskId))
+            .returning({ id: taskTable.id, status: taskTable.status, namespace: taskTable.namespace });
+        for (const row of updatedRows) {
+            this.notify(row.namespace);
+        }
+    }
     async has(id, options) {
         const session = options?.transaction?.pgTransaction ?? this.#repository.session;
         const [result] = await session
             .select({ id: taskTable.id })
             .from(taskTable)
-            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id)))
+            .where(eq(taskTable.id, id))
             .limit(1);
         return isDefined(result);
     }
@@ -330,19 +428,27 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)));
         return result?.count ?? 0;
     }
+    async count(options) {
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const [result] = await session
+            .select({ count: count() })
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), isDefined(options?.status) ? eq(taskTable.status, options.status) : undefined));
+        return result?.count ?? 0;
+    }
     async getTask(id, options) {
         const session = options?.transaction?.pgTransaction ?? this.#repository.session;
         const [activeRow] = await session
             .select()
             .from(taskTable)
-            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id)));
+            .where(eq(taskTable.id, id));
         if (isDefined(activeRow)) {
             return await this.#repository.mapToEntity(activeRow);
         }
         const [archiveRow] = await session
             .select()
             .from(taskArchiveTable)
-            .where(and(eq(taskArchiveTable.namespace, this.#namespace), eq(taskArchiveTable.id, id)));
+            .where(eq(taskArchiveTable.id, id));
         if (isDefined(archiveRow)) {
             return await this.#archiveRepository.mapToEntity(archiveRow);
         }
@@ -381,7 +487,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
           FROM ${taskTable}
           WHERE ${inArray(taskTable.id, rootIds)}
 
-          UNION
+          UNION ALL
 
           SELECT child.*, parent.depth + 1
           FROM ${taskTable} child
@@ -400,10 +506,10 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         const timeout = options?.timeout ?? Infinity;
         const interval = options?.interval ?? 1000;
         const cancellationSignal = this.#cancellationSignal.optionallyInherit(options?.cancellationSignal);
-        const messageBus$ = this.#messageBus.allMessages$.pipe(throttleTime(500, undefined, { leading: true, trailing: true }));
+        const waitStatuses = options?.statuses ?? finalizedStatuses;
+        const messageBus$ = this.#messageBus.allMessages$.pipe(filter((namespace) => namespace == this.#namespace), throttleTime(500, undefined, { leading: true, trailing: true }));
         const continue$ = merge(messageBus$, cancellationSignal);
         const timer = Timer.startNew();
-        const finalizedStatuses = [TaskStatus.Completed, TaskStatus.Cancelled, TaskStatus.Dead];
         while (true) {
             if (cancellationSignal.isSet) {
                 return { cancelled: true };
@@ -411,11 +517,12 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (timer.milliseconds > timeout) {
                 throw new TimeoutError('Timeout while waiting for tasks to complete');
             }
-            const hasNonFinalized = await this.#repository.hasByQuery({
-                id: { $in: ids },
-                status: { $nin: finalizedStatuses },
-            });
-            if (!hasNonFinalized) {
+            const [remaining] = await this.#repository.session
+                .select({ id: taskTable.id })
+                .from(taskTable)
+                .where(and(inArray(taskTable.id, ids), notInArray(taskTable.status, waitStatuses)))
+                .limit(1);
+            if (isUndefined(remaining)) {
                 return { cancelled: false };
             }
             const remainingTimeout = timeout - timer.milliseconds;
@@ -433,16 +540,17 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (treeIds.length == 0) {
                 return;
             }
-            await tx.pgTransaction
+            const cancelledRows = await tx.pgTransaction
                 .update(taskTable)
                 .set({
                 status: TaskStatus.Cancelled,
                 token: null,
                 completeTimestamp: TRANSACTION_TIMESTAMP,
             })
-                .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.id, treeIds)));
-            for (const task of tree) {
-                await this.resolveDependencies(task.id, TaskStatus.Cancelled, { transaction: tx });
+                .where(and(inArray(taskTable.id, treeIds), notInArray(taskTable.status, terminalStatuses)))
+                .returning({ id: taskTable.id, namespace: taskTable.namespace });
+            if (cancelledRows.length > 0) {
+                await this.resolveDependenciesMany(cancelledRows.map((row) => ({ id: row.id, status: TaskStatus.Cancelled, namespace: row.namespace })), { transaction: tx });
             }
         });
     }
@@ -455,6 +563,32 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     }
     async clear(options) {
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
+            const nonFinalizedTasks = await tx.pgTransaction
+                .select({ id: taskTable.id, namespace: taskTable.namespace })
+                .from(taskTable)
+                .where(and(eq(taskTable.namespace, this.#namespace), notInArray(taskTable.status, finalizedStatuses)))
+                .for('update');
+            if (nonFinalizedTasks.length > 0) {
+                const ids = nonFinalizedTasks.map((t) => t.id);
+                await tx.pgTransaction
+                    .update(taskTable)
+                    .set({
+                    status: TaskStatus.Cancelled,
+                    token: null,
+                    completeTimestamp: TRANSACTION_TIMESTAMP,
+                })
+                    .where(inArray(taskTable.id, ids));
+                await this.resolveDependenciesMany(nonFinalizedTasks.map((t) => ({ id: t.id, status: TaskStatus.Cancelled, namespace: t.namespace })), { transaction: tx });
+            }
+            // Break internal parent-child links to allow deleting tasks within the same namespace.
+            // Cross-namespace links will still cause a foreign key violation as requested.
+            await tx.pgTransaction
+                .update(taskTable)
+                .set({ parentId: null })
+                .where(and(eq(taskTable.namespace, this.#namespace), sqlIsNotNull(taskTable.parentId), inArray(taskTable.parentId, tx.pgTransaction
+                .select({ id: taskTable.id })
+                .from(taskTable)
+                .where(eq(taskTable.namespace, this.#namespace)))));
             await tx.pgTransaction
                 .delete(taskTable)
                 .where(eq(taskTable.namespace, this.#namespace));
@@ -501,20 +635,6 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 }
                 effectiveCount = 1;
             }
-            // 2. Check Global Concurrency
-            if (!forceDequeue && isNotNull(this.globalConcurrency)) {
-                // WARN: This is a check-then-act race condition.
-                // A distributed lock or an atomic update strategy is needed for strict enforcement.
-                const [runningResult] = await tx.pgTransaction
-                    .select({ count: sqlCount() })
-                    .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running)));
-                const runningCount = runningResult?.count ?? 0;
-                if (runningCount >= this.globalConcurrency) {
-                    return [];
-                }
-                effectiveCount = Math.min(effectiveCount, this.globalConcurrency - runningCount);
-            }
             /*
              * Materialization required for LIMIT clause
              * https://stackoverflow.com/questions/73966670/select-for-update-subquery-not-respecting-limit-clause-under-load
@@ -523,7 +643,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             const selection = tx.pgTransaction.$with('selection').as((qb) => qb
                 .select({ id: taskTable.id })
                 .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), lte(taskTable.scheduleTimestamp, TRANSACTION_TIMESTAMP), eq(taskTable.status, TaskStatus.Pending), or(sqlIsNull(taskTable.timeToLive), lt(TRANSACTION_TIMESTAMP, taskTable.timeToLive)), isDefined(options?.types) ? inArray(taskTable.type, options.types) : undefined, sql `pg_sleep(0) IS NOT NULL` // Materialization hack until drizzle implements https://github.com/drizzle-team/drizzle-orm/issues/2318
+                .where(and(eq(taskTable.namespace, this.#namespace), lte(taskTable.scheduleTimestamp, TRANSACTION_TIMESTAMP), inArray(taskTable.status, queueableStatuses), or(sqlIsNull(taskTable.timeToLive), lt(TRANSACTION_TIMESTAMP, taskTable.timeToLive)), isDefined(options?.types) ? inArray(taskTable.type, options.types) : undefined, sql `pg_sleep(0) IS NOT NULL` // Materialization hack until drizzle implements https://github.com/drizzle-team/drizzle-orm/issues/2318
             ))
                 .orderBy(asc(taskTable.priority), asc(taskTable.scheduleTimestamp))
                 .limit(effectiveCount)
@@ -559,32 +679,26 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         await session
             .update(taskTable)
             .set({
-            status: TaskStatus.Pending,
+            status: caseWhen(gt(taskTable.unresolvedScheduleDependencies, 0), enumValue(TaskStatus, taskStatus, TaskStatus.Waiting)).else(enumValue(TaskStatus, taskStatus, TaskStatus.Pending)),
             token: null,
             scheduleTimestamp: timestamp,
             visibilityDeadline: null,
-            tries: sql `CASE
-          WHEN ${taskTable.status} = ${TaskStatus.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
-          ELSE ${taskTable.tries}
-        END`,
+            tries: caseWhen(eq(taskTable.status, enumValue(TaskStatus, taskStatus, TaskStatus.Running)), greatest(0, sql `${taskTable.tries} - 1`)).else(taskTable.tries),
         })
-            .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.id, ids)));
+            .where(and(inArray(taskTable.id, ids), notInArray(taskTable.status, terminalStatuses)));
     }
     async rescheduleManyByTags(tags, timestamp, options) {
         const session = options?.transaction?.pgTransaction ?? this.#repository.session;
         await session
             .update(taskTable)
             .set({
-            status: TaskStatus.Pending,
+            status: caseWhen(gt(taskTable.unresolvedScheduleDependencies, 0), enumValue(TaskStatus, taskStatus, TaskStatus.Waiting)).else(enumValue(TaskStatus, taskStatus, TaskStatus.Pending)),
             token: null,
             scheduleTimestamp: timestamp,
             visibilityDeadline: null,
-            tries: sql `CASE
-          WHEN ${taskTable.status} = ${TaskStatus.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
-          ELSE ${taskTable.tries}
-        END`,
+            tries: caseWhen(eq(taskTable.status, enumValue(TaskStatus, taskStatus, TaskStatus.Running)), greatest(0, sql `${taskTable.tries} - 1`)).else(taskTable.tries),
         })
-            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags))));
+            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags)), notInArray(taskTable.status, terminalStatuses)));
     }
     async touch(task, options) {
         if (isNull(task.token)) {
@@ -603,7 +717,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             const [updatedRow] = await tx.pgTransaction
                 .update(taskTable)
                 .set(update)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+                .where(and(eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
                 .returning();
             if (isDefined(updatedRow)) {
                 return await this.#repository.mapToEntity(updatedRow);
@@ -611,9 +725,18 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             const [existingRow] = await tx.pgTransaction
                 .select({ startTimestamp: taskTable.startTimestamp })
                 .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)));
+                .where(and(eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)));
             if (isDefined(existingRow) && isNotNull(existingRow.startTimestamp) && (currentTimestamp() - existingRow.startTimestamp) > this.maxExecutionTime) {
-                await this.fail(task, { message: 'Hard Execution Timeout' }, { fatal: true, transaction: tx });
+                await tx.pgTransaction
+                    .update(taskTable)
+                    .set({
+                    status: TaskStatus.TimedOut,
+                    completeTimestamp: TRANSACTION_TIMESTAMP,
+                    error: { code: 'MaxTimeExceeded', message: 'Hard Execution Timeout' },
+                })
+                    .where(eq(taskTable.id, task.id));
+                await this.resolveDependenciesMany([{ id: task.id, status: TaskStatus.TimedOut, namespace: task.namespace }], { transaction: tx });
+                this.notify();
             }
             return undefined;
         });
@@ -644,7 +767,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             state: coalesce(updates.updateState, taskTable.state),
         })
             .from(updates)
-            .where(and(eq(taskTable.id, updates.updateId), eq(taskTable.namespace, this.#namespace), eq(taskTable.token, updates.updateToken), eq(taskTable.status, TaskStatus.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+            .where(and(eq(taskTable.id, updates.updateId), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`, eq(taskTable.status, TaskStatus.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
             .returning({ id: taskTable.id }));
         const result = await session
             .with(updates, updated)
@@ -657,7 +780,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             const [freshTask] = await tx.pgTransaction
                 .select({ unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies })
                 .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, task.id)))
+                .where(eq(taskTable.id, task.id))
                 .for('update');
             if (isUndefined(freshTask)) {
                 return;
@@ -673,7 +796,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 completeTimestamp: (nextStatus == TaskStatus.Completed) ? TRANSACTION_TIMESTAMP : null,
                 visibilityDeadline: null,
             })
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, task.id), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)))
+                .where(and(eq(taskTable.id, task.id), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)))
                 .returning({ id: taskTable.id });
             if (isUndefined(updatedTask)) {
                 return;
@@ -681,7 +804,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (nextStatus == TaskStatus.Completed) {
                 await this.#circuitBreaker.recordSuccess();
             }
-            await this.resolveDependencies(task.id, nextStatus, { transaction: tx });
+            await this.resolveDependencies(task.id, nextStatus, { namespace: task.namespace, transaction: tx });
         });
     }
     async completeMany(tasks, options) {
@@ -689,43 +812,30 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             return;
         }
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const taskIds = getEntityIds(tasks);
-            const freshTasks = await tx.pgTransaction
-                .select({ id: taskTable.id, unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies })
-                .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.id, taskIds)))
-                .for('update');
-            const unresolvedDependencyCountMap = new Map(freshTasks.map((task) => [task.id, task.unresolvedCompleteDependencies]));
             const rows = tasks.map((t, i) => {
                 const result = options?.results?.[i] ?? null;
-                const unresolvedCount = unresolvedDependencyCountMap.get(t.id) ?? 0;
-                const nextStatus = (unresolvedCount > 0) ? TaskStatus.WaitingChildren : TaskStatus.Completed;
-                const progress = (nextStatus == TaskStatus.Completed) ? 1 : t.progress;
-                const completeTimestamp = (nextStatus == TaskStatus.Completed) ? TRANSACTION_TIMESTAMP : null;
-                return sql `(${t.id}::uuid, ${t.token}::uuid, ${nextStatus}::text, ${result}::jsonb, ${progress}::numeric, ${completeTimestamp}::timestamptz)`;
+                return sql `(${t.id}::uuid, ${t.token}::uuid, ${result}::jsonb, ${t.progress}::numeric)`;
             });
             const updates = tx.pgTransaction.$with('updates').as((qb) => qb
                 .select({
                 updateId: sql `(id)::uuid`.as('update_id'),
                 updateToken: sql `(token)::uuid`.as('update_token'),
-                updateStatus: sql `(status)::text`.as('update_status'),
                 updateResult: sql `(result)::jsonb`.as('update_result'),
                 updateProgress: sql `(progress)::numeric`.as('update_progress'),
-                updateComplete: sql `(complete_timestamp)::timestamptz`.as('update_complete'),
             })
-                .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, status, result, progress, complete_timestamp)`));
+                .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, result, progress)`));
             const updated = tx.pgTransaction.$with('updated').as(() => tx.pgTransaction
                 .update(taskTable)
                 .set({
-                status: sql `${updates.updateStatus}::${taskStatus}`,
+                status: caseWhen(gt(taskTable.unresolvedCompleteDependencies, 0), enumValue(TaskStatus, taskStatus, TaskStatus.WaitingChildren)).else(enumValue(TaskStatus, taskStatus, TaskStatus.Completed)),
                 token: null,
                 result: updates.updateResult,
-                progress: sql `${updates.updateProgress}`,
-                completeTimestamp: sql `${updates.updateComplete}`,
+                progress: caseWhen(gt(taskTable.unresolvedCompleteDependencies, 0), updates.updateProgress).else(1),
+                completeTimestamp: caseWhen(gt(taskTable.unresolvedCompleteDependencies, 0), taskTable.completeTimestamp).else(TRANSACTION_TIMESTAMP),
                 visibilityDeadline: null,
             })
                 .from(updates)
-                .where(and(eq(taskTable.id, updates.updateId), eq(taskTable.token, updates.updateToken), eq(taskTable.namespace, this.#namespace)))
+                .where(and(eq(taskTable.id, updates.updateId), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`))
                 .returning({ id: taskTable.id, status: taskTable.status }));
             const updatedRows = await tx.pgTransaction
                 .with(updates, updated)
@@ -735,15 +845,13 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 if (updatedRows.some((r) => r.status == TaskStatus.Completed)) {
                     await this.#circuitBreaker.recordSuccess();
                 }
-                for (const row of updatedRows) {
-                    await this.resolveDependencies(row.id, row.status, { transaction: tx });
-                }
+                await this.resolveDependenciesMany(updatedRows.map((r) => ({ id: r.id, status: r.status })), { transaction: tx });
             }
         });
     }
     async fail(task, error, options) {
         const isRetryable = (options?.fatal != true) && (task.tries < this.maxTries);
-        const nextStatus = isRetryable ? TaskStatus.Pending : TaskStatus.Dead;
+        const nextStatus = isRetryable ? TaskStatus.Retrying : TaskStatus.Dead;
         const delay = isRetryable
             ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
             : 0;
@@ -760,13 +868,13 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 startTimestamp: null,
                 completeTimestamp: (nextStatus == TaskStatus.Dead) ? TRANSACTION_TIMESTAMP : null,
             })
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, task.id), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token), eq(taskTable.tries, task.tries)))
+                .where(and(eq(taskTable.id, task.id), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token), eq(taskTable.tries, task.tries)))
                 .returning();
             if (isUndefined(updatedRow)) {
                 return;
             }
             await this.#circuitBreaker.recordFailure();
-            await this.resolveDependencies(task.id, nextStatus, { transaction: tx });
+            await this.resolveDependencies(task.id, nextStatus, { namespace: task.namespace, transaction: tx });
         });
     }
     async failMany(tasks, errors, options) {
@@ -777,7 +885,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             const rows = tasks.map((task, index) => {
                 const error = errors[index];
                 const isRetryable = (task.tries < this.maxTries);
-                const nextStatus = isRetryable ? TaskStatus.Pending : TaskStatus.Dead;
+                const nextStatus = isRetryable ? TaskStatus.Retrying : TaskStatus.Dead;
                 const delay = isRetryable
                     ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
                     : 0;
@@ -808,148 +916,199 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 completeTimestamp: sql `${updates.updateComplete}`,
             })
                 .from(updates)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, updates.updateId), eq(taskTable.token, updates.updateToken), eq(taskTable.tries, updates.updateTries)))
+                .where(and(eq(taskTable.id, updates.updateId), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`, eq(taskTable.tries, updates.updateTries)))
                 .returning({ id: taskTable.id, status: taskTable.status }));
             const result = await tx.pgTransaction
                 .with(updates, updated)
                 .select({ id: updated.id, status: updated.status })
                 .from(updated);
             if (result.length > 0) {
-                await Promise.all(createArray(result.length, async () => await this.#circuitBreaker.recordFailure()));
-                for (const row of result) {
-                    await this.resolveDependencies(row.id, row.status, { transaction: tx });
-                }
+                await this.#circuitBreaker.recordFailures(result.length);
+                await this.resolveDependenciesMany(result.map((r) => ({ id: r.id, status: r.status })), { transaction: tx });
             }
         });
     }
     async resolveDependencies(id, status, options) {
-        this.#logger.debug(`Resolving dependencies for task ${id} with status ${status}`);
+        await this.resolveDependenciesMany([{ id, status, namespace: options?.namespace }], options);
+    }
+    async resolveDependenciesMany(tasks, options) {
+        this.#logger.debug(`Resolving dependencies for ${tasks.length} tasks`);
+        if (tasks.length == 0) {
+            return;
+        }
+        const taskStatusMap = new Map(tasks.map((t) => [t.id, t.status]));
+        const notifiedNamespaces = new Set();
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            // Find all dependents of the task that just finished
+            const taskIds = tasks.map((t) => t.id);
             const dependents = await tx.pgTransaction
                 .select({
                 taskId: taskDependencyTable.taskId,
+                dependencyTaskId: taskDependencyTable.dependencyTaskId,
                 type: taskDependencyTable.type,
                 requiredStatuses: taskDependencyTable.requiredStatuses,
             })
                 .from(taskDependencyTable)
-                .where(and(eq(taskDependencyTable.namespace, this.#namespace), eq(taskDependencyTable.dependencyTaskId, id)));
+                .where(inArray(taskDependencyTable.dependencyTaskId, taskIds));
             if (dependents.length == 0) {
                 return;
             }
+            const resolvedEdges = [];
+            const failFastTaskIds = new Set();
             for (const dep of dependents) {
+                const status = taskStatusMap.get(dep.dependencyTaskId);
                 const isMatched = dep.requiredStatuses.includes(status);
-                const isTerminal = (status == TaskStatus.Completed || status == TaskStatus.Cancelled || status == TaskStatus.Dead);
+                const isTerminal = terminalStatuses.includes(status);
                 if (isMatched || isTerminal) {
-                    // Dependency resolved (either matched or finished in a different terminal status)
-                    const deletedEdge = await tx.pgTransaction
-                        .delete(taskDependencyTable)
-                        .where(and(eq(taskDependencyTable.namespace, this.#namespace), eq(taskDependencyTable.taskId, dep.taskId), eq(taskDependencyTable.dependencyTaskId, id), eq(taskDependencyTable.type, dep.type)))
-                        .returning();
-                    if (deletedEdge.length > 0) {
-                        const [dependentTask] = await tx.pgTransaction
-                            .select({ failFast: taskTable.failFast, status: taskTable.status })
-                            .from(taskTable)
-                            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, dep.taskId)));
-                        if (isDefined(dependentTask)) {
-                            if (!isMatched && dependentTask.failFast && dependentTask.status != TaskStatus.Dead && dependentTask.status != TaskStatus.Cancelled) {
-                                // Dependency failed and failFast is enabled: fail the dependent task immediately
-                                await this.transitionTask(dep.taskId, TaskStatus.Dead, { error: { code: 'DependencyFailed', message: `Dependency ${id} failed (status: ${status}). Task failed fast because it required one of: ${dep.requiredStatuses.join(', ')}` }, transaction: tx });
-                            }
-                            else {
-                                // Dependency resolved (matched, or failed but no failFast): decrement counter
-                                const [updatedTask] = await tx.pgTransaction
-                                    .update(taskTable)
-                                    .set((dep.type == TaskDependencyType.Schedule)
-                                    ? { unresolvedScheduleDependencies: sql `${taskTable.unresolvedScheduleDependencies} - 1` }
-                                    : { unresolvedCompleteDependencies: sql `${taskTable.unresolvedCompleteDependencies} - 1` })
-                                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, dep.taskId), gt((dep.type == TaskDependencyType.Schedule) ? taskTable.unresolvedScheduleDependencies : taskTable.unresolvedCompleteDependencies, 0)))
-                                    .returning();
-                                if (isDefined(updatedTask)) {
-                                    // Check for transitions
-                                    if (updatedTask.unresolvedScheduleDependencies == 0 || updatedTask.unresolvedCompleteDependencies == 0) {
-                                        await this.evaluateTaskStatus(updatedTask.id, { transaction: tx });
-                                    }
-                                }
-                            }
-                        }
+                    resolvedEdges.push(dep);
+                    if (!isMatched) {
+                        failFastTaskIds.add(dep.taskId);
                     }
                 }
             }
-        });
-    }
-    async evaluateTaskStatus(id, options) {
-        await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const [rawTask] = await tx.pgTransaction
-                .select()
-                .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id)))
-                .for('update');
-            if (isUndefined(rawTask)) {
+            if (resolvedEdges.length == 0) {
                 return;
             }
-            const task = await this.#repository.mapToEntity(rawTask);
-            if (task.status != TaskStatus.Waiting && task.status != TaskStatus.WaitingChildren && task.status != TaskStatus.Pending) {
-                return;
-            }
-            if (task.unresolvedScheduleDependencies == 0) {
-                if (task.unresolvedCompleteDependencies == 0) {
-                    // If it hasn't started yet (startTimestamp is null), it should be Pending.
-                    // If it has already run (startTimestamp is set), it should be Completed.
-                    const nextStatus = isNull(task.startTimestamp) ? TaskStatus.Pending : TaskStatus.Completed;
-                    if (task.status != nextStatus) {
-                        await this.transitionTask(id, nextStatus, { transaction: tx });
-                    }
+            const sortedResolvedEdges = resolvedEdges.toSorted((a, b) => {
+                const idCompare = a.taskId.localeCompare(b.taskId);
+                if (idCompare != 0) {
+                    return idCompare;
                 }
-                else if (task.status == TaskStatus.Waiting && isNull(task.startTimestamp)) {
-                    await this.transitionTask(id, TaskStatus.Pending, { transaction: tx });
+                const depIdCompare = a.dependencyTaskId.localeCompare(b.dependencyTaskId);
+                if (depIdCompare != 0) {
+                    return depIdCompare;
                 }
-                else if (task.status == TaskStatus.Pending && isNotNull(task.startTimestamp)) {
-                    // This case happens if a task was somehow Pending but already has a startTimestamp and now its completion dependencies are resolved
-                    await this.transitionTask(id, TaskStatus.WaitingChildren, { transaction: tx });
+                return a.type.localeCompare(b.type);
+            });
+            const edgeValues = sortedResolvedEdges.map((e) => sql `(${e.taskId}::uuid, ${e.dependencyTaskId}::uuid, ${e.type}::text)`);
+            await tx.pgTransaction.execute(sql `
+        DELETE FROM ${taskDependencyTable}
+        WHERE (task_id, dependency_task_id, type) IN (
+          SELECT t.task_id, t.dependency_task_id, t.type::${taskDependencyType}
+          FROM (VALUES ${sql.join(edgeValues, sql `, `)}) AS t(task_id, dependency_task_id, type)
+        )
+      `);
+            const terminalTasks = [];
+            const skippedTaskIds = new Set();
+            if (failFastTaskIds.size > 0) {
+                const sortedFailFastIds = [...failFastTaskIds].toSorted();
+                const dependentTasks = await tx.pgTransaction
+                    .select({ id: taskTable.id, namespace: taskTable.namespace, failFast: taskTable.failFast, status: taskTable.status })
+                    .from(taskTable)
+                    .where(inArray(taskTable.id, sortedFailFastIds))
+                    .orderBy(asc(taskTable.id))
+                    .for('update');
+                const tasksToSkip = [];
+                for (const task of dependentTasks) {
+                    if (task.failFast && !terminalStatuses.includes(task.status)) {
+                        tasksToSkip.push(task.id);
+                        skippedTaskIds.add(task.id);
+                    }
+                }
+                if (tasksToSkip.length > 0) {
+                    const skippedRows = await tx.pgTransaction
+                        .update(taskTable)
+                        .set({
+                        status: TaskStatus.Skipped,
+                        token: null,
+                        error: jsonbBuildObject({ code: 'DependencyFailed', message: 'One or more dependencies failed and failFast is enabled' }),
+                        completeTimestamp: TRANSACTION_TIMESTAMP,
+                    })
+                        .where(inArray(taskTable.id, tasksToSkip))
+                        .returning({ id: taskTable.id, status: taskTable.status, namespace: taskTable.namespace });
+                    terminalTasks.push(...skippedRows.map((r) => ({ id: r.id, status: r.status, namespace: r.namespace })));
+                    for (const row of skippedRows) {
+                        notifiedNamespaces.add(row.namespace);
+                    }
                 }
             }
-        });
-    }
-    async transitionTask(id, status, options) {
-        this.#logger.debug(`Transitioning task ${id} to ${status}`);
-        await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const update = {
-                status,
-                completeTimestamp: ((status == TaskStatus.Completed) || (status == TaskStatus.Cancelled) || (status == TaskStatus.Dead)) ? TRANSACTION_TIMESTAMP : null,
-            };
-            if (isNotNullOrUndefined(options?.error)) {
-                update.error = options.error;
+            // 4. Group all resolved edges into decrements (for any dependent NOT skipped above)
+            const decrementsToApply = new Map();
+            for (const dep of sortedResolvedEdges) {
+                if (skippedTaskIds.has(dep.taskId)) {
+                    continue;
+                }
+                const current = decrementsToApply.get(dep.taskId) ?? { schedule: 0, complete: 0 };
+                if (dep.type == TaskDependencyType.Schedule) {
+                    current.schedule++;
+                }
+                else if (dep.type == TaskDependencyType.Complete || dep.type == TaskDependencyType.Child) {
+                    current.complete++;
+                }
+                decrementsToApply.set(dep.taskId, current);
             }
-            if (status == TaskStatus.Completed) {
-                update.progress = 1;
-                update.token = null;
+            if (decrementsToApply.size > 0) {
+                const decrementValues = [...decrementsToApply]
+                    .toSorted(([idA], [idB]) => idA.localeCompare(idB))
+                    .map(([taskId, d]) => sql `(${taskId}::uuid, ${d.schedule}::int, ${d.complete}::int)`);
+                const updates = tx.pgTransaction.$with('updates').as((qb) => qb
+                    .select({
+                    taskId: sql `(id)::uuid`.as('task_id'),
+                    scheduleDecrement: sql `(schedule)::int`.as('schedule_decrement'),
+                    completeDecrement: sql `(complete)::int`.as('complete_decrement'),
+                })
+                    .from(sql `(VALUES ${sql.join(decrementValues, sql `, `)}) AS t(id, schedule, complete)`));
+                const updatedRows = await tx.pgTransaction
+                    .with(updates)
+                    .update(taskTable)
+                    .set({
+                    unresolvedScheduleDependencies: greatest(0, sql `${taskTable.unresolvedScheduleDependencies} - ${updates.scheduleDecrement}`),
+                    unresolvedCompleteDependencies: greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`),
+                    status: caseWhen(and(eq(taskTable.status, TaskStatus.Waiting), eq(greatest(0, sql `${taskTable.unresolvedScheduleDependencies} - ${updates.scheduleDecrement}`), 0)), enumValue(TaskStatus, taskStatus, TaskStatus.Pending)).else(caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), enumValue(TaskStatus, taskStatus, TaskStatus.Completed)).else(taskTable.status)),
+                    progress: caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), 1).else(taskTable.progress),
+                    completeTimestamp: caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), TRANSACTION_TIMESTAMP).else(taskTable.completeTimestamp),
+                    token: caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), null).else(taskTable.token),
+                })
+                    .from(updates)
+                    .where(eq(taskTable.id, updates.taskId))
+                    .returning({
+                    id: taskTable.id,
+                    namespace: taskTable.namespace,
+                    status: taskTable.status,
+                });
+                for (const row of updatedRows) {
+                    if (finalizedStatuses.includes(row.status)) {
+                        terminalTasks.push({ id: row.id, status: row.status, namespace: row.namespace });
+                    }
+                    notifiedNamespaces.add(row.namespace);
+                }
             }
-            const [updatedRow] = await tx.pgTransaction
-                .update(taskTable)
-                .set(update)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id)))
-                .returning();
-            if (isDefined(updatedRow)) {
-                await this.resolveDependencies(id, status, { transaction: tx });
-                this.#messageBus.publishAndForget();
+            if (terminalTasks.length > 0) {
+                const terminalTaskIds = terminalTasks.map((t) => t.id);
+                await tx.pgTransaction
+                    .delete(taskDependencyTable)
+                    .where(inArray(taskDependencyTable.taskId, terminalTaskIds));
+                await this.resolveDependenciesMany(terminalTasks, { transaction: tx });
             }
         });
+        for (const namespace of notifiedNamespaces) {
+            this.notify(namespace);
+        }
     }
     async maintenance(options) {
-        const repository = this.#repository;
-        const archiveRepository = this.#archiveRepository;
-        // 1. Archival: Move old terminal tasks to archive
+        await Promise.allSettled([
+            this.processExpirations(options),
+            this.processZombieRetries(options),
+            this.processZombieExhaustions(options),
+            this.processHardTimeouts(options),
+            this.processPriorityAging(options),
+        ]);
+        await this.performArchival(options);
+        await this.performArchivePurge(options);
+    }
+    async performArchival(options) {
         while (true) {
-            const archivedCount = await repository.useTransaction(options?.transaction, async (tx) => {
+            const archivedCount = await this.#repository.useTransaction(options?.transaction, async (tx) => {
                 const childTaskTable = aliasedTable(taskTable, 'childTask');
                 const rowsToArchive = await tx.pgTransaction
                     .select()
                     .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, [TaskStatus.Completed, TaskStatus.Dead, TaskStatus.Cancelled]), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(tx.pgTransaction
+                    .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, finalizedStatuses), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(tx.pgTransaction
                     .select({ id: childTaskTable.id })
                     .from(childTaskTable)
-                    .where(and(eq(childTaskTable.namespace, this.#namespace), eq(childTaskTable.parentId, taskTable.id))))))
+                    .where(eq(childTaskTable.parentId, taskTable.id))), notExists(tx.pgTransaction
+                    .select({ taskId: taskDependencyTable.taskId })
+                    .from(taskDependencyTable)
+                    .where(eq(taskDependencyTable.dependencyTaskId, taskTable.id)))))
                     .limit(1000)
                     .for('update', { skipLocked: true });
                 if (rowsToArchive.length > 0) {
@@ -963,144 +1122,163 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 break;
             }
         }
-        // 2. Purge Archive: Remove very old archived tasks
+    }
+    async performArchivePurge(options) {
+        const session = options?.transaction?.pgTransaction ?? this.#database;
+        const selection = session.$with('archive_purge_selection').as((qb) => qb
+            .select({ id: taskArchiveTable.id })
+            .from(taskArchiveTable)
+            .where(and(eq(taskArchiveTable.namespace, this.#namespace), lte(taskArchiveTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.archiveRetention, 'milliseconds')}`)))
+            .limit(1000));
         while (true) {
-            const deletedArchiveCount = await archiveRepository.useTransaction(options?.transaction, async (tx) => {
-                const selection = tx.pgTransaction.$with('archive_purge_selection').as((qb) => qb
-                    .select({ id: taskArchiveTable.id })
-                    .from(taskArchiveTable)
-                    .where(and(eq(taskArchiveTable.namespace, this.#namespace), lte(taskArchiveTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.archiveRetention, 'milliseconds')}`)))
-                    .limit(1000));
-                const result = await tx.pgTransaction
-                    .with(selection)
-                    .delete(taskArchiveTable)
-                    .where(inArray(taskArchiveTable.id, tx.pgTransaction.select().from(selection)))
-                    .returning({ id: taskArchiveTable.id });
-                return result.length;
-            });
-            if (deletedArchiveCount < 1000) {
+            const result = await session
+                .with(selection)
+                .delete(taskArchiveTable)
+                .where(inArray(taskArchiveTable.id, session.select().from(selection)))
+                .returning({ id: taskArchiveTable.id });
+            if (result.length < 1000) {
                 break;
             }
         }
-        // 3. Maintenance Loop
+    }
+    async processExpirations(options) {
+        const expiredSelection = this.#database.$with('expired_selection').as((qb) => qb
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, queueableOrWaitableStatuses), lt(taskTable.timeToLive, TRANSACTION_TIMESTAMP)))
+            .limit(1000)
+            .for('update', { skipLocked: true }));
         while (true) {
-            const maintenanceCount = await repository.useTransaction(options?.transaction, async (tx) => {
-                let totalUpdated = 0;
-                // 3.1 Handle Pending Expiration
-                const expiredSelection = tx.pgTransaction.$with('expired_selection').as((qb) => qb
-                    .select({ id: taskTable.id })
-                    .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Pending), lt(taskTable.timeToLive, TRANSACTION_TIMESTAMP)))
-                    .limit(1000)
-                    .for('update', { skipLocked: true }));
+            const updatedCount = await this.#repository.useTransaction(options?.transaction, async (tx) => {
                 const expiredRows = await tx.pgTransaction
                     .with(expiredSelection)
                     .update(taskTable)
                     .set({
-                    status: TaskStatus.Dead,
+                    status: TaskStatus.Expired,
                     token: null,
                     error: { code: 'Expired', message: 'Task expired before processing' },
                     completeTimestamp: TRANSACTION_TIMESTAMP,
                 })
                     .where(inArray(taskTable.id, tx.pgTransaction.select().from(expiredSelection)))
                     .returning({ id: taskTable.id });
-                totalUpdated += expiredRows.length;
                 if (expiredRows.length > 0) {
-                    for (const row of expiredRows) {
-                        await this.resolveDependencies(row.id, TaskStatus.Dead, { transaction: tx });
-                    }
+                    await this.resolveDependenciesMany(expiredRows.map((r) => ({ id: r.id, status: TaskStatus.Expired, namespace: this.#namespace })), { transaction: tx });
                 }
-                // 3.2 Handle Zombie Tasks (Retry)
-                const zombieRetrySelection = tx.pgTransaction.$with('zombie_retry_selection').as((qb) => qb
-                    .select({ id: taskTable.id })
-                    .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), lt(taskTable.tries, this.maxTries)))
-                    .limit(1000)
-                    .for('update', { skipLocked: true }));
-                const zombieRetryRows = await tx.pgTransaction
-                    .with(zombieRetrySelection)
-                    .update(taskTable)
-                    .set({
-                    status: TaskStatus.Pending,
-                    token: null,
-                    visibilityDeadline: null,
-                    startTimestamp: null,
-                    scheduleTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.retryDelayMinimum, 'milliseconds')}`, // Simple backoff for zombies
-                    error: sql `jsonb_build_object('code', 'VisibilityTimeout', 'message', 'Worker Lost', 'last_error', ${taskTable.error})`,
-                })
-                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(zombieRetrySelection)))
-                    .returning({ id: taskTable.id });
-                totalUpdated += zombieRetryRows.length;
-                // 3.3 Handle Zombie Tasks (Exhaustion)
-                const zombieExhaustionSelection = tx.pgTransaction.$with('zombie_exhaustion_selection').as((qb) => qb
-                    .select({ id: taskTable.id })
-                    .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), gte(taskTable.tries, this.maxTries)))
-                    .limit(1000)
-                    .for('update', { skipLocked: true }));
+                return expiredRows.length;
+            });
+            if (updatedCount < 1000) {
+                break;
+            }
+        }
+    }
+    async processZombieRetries(options) {
+        const session = options?.transaction?.pgTransaction ?? this.#database;
+        const zombieRetrySelection = session.$with('zombie_retry_selection').as((qb) => qb
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), lt(taskTable.tries, this.maxTries)))
+            .limit(1000)
+            .for('update', { skipLocked: true }));
+        while (true) {
+            const zombieRetryRows = await session
+                .with(zombieRetrySelection)
+                .update(taskTable)
+                .set({
+                status: TaskStatus.Retrying,
+                token: null,
+                visibilityDeadline: null,
+                startTimestamp: null,
+                scheduleTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.retryDelayMinimum, 'milliseconds')}`, // Simple backoff for zombies
+                error: jsonbBuildObject({ code: 'VisibilityTimeout', message: 'Worker Lost', lastError: taskTable.error }),
+            })
+                .where(inArray(taskTable.id, session.select().from(zombieRetrySelection)))
+                .returning({ id: taskTable.id });
+            if (zombieRetryRows.length < 1000) {
+                break;
+            }
+        }
+    }
+    async processZombieExhaustions(options) {
+        const zombieExhaustionSelection = this.#database.$with('zombie_exhaustion_selection').as((qb) => qb
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), gte(taskTable.tries, this.maxTries)))
+            .limit(1000)
+            .for('update', { skipLocked: true }));
+        while (true) {
+            const updatedCount = await this.#repository.useTransaction(options?.transaction, async (tx) => {
                 const exhaustionRows = await tx.pgTransaction
                     .with(zombieExhaustionSelection)
                     .update(taskTable)
                     .set({
-                    status: TaskStatus.Dead,
+                    status: TaskStatus.Orphaned,
                     token: null,
                     visibilityDeadline: null,
                     completeTimestamp: TRANSACTION_TIMESTAMP,
-                    error: sql `jsonb_build_object('code', 'ZombieExhausted', 'message', 'Exceeded max retries after repeated crashes', 'last_error', ${taskTable.error})`,
+                    error: jsonbBuildObject({ code: 'ZombieExhausted', message: 'Exceeded max retries after repeated crashes', lastError: taskTable.error }),
                 })
                     .where(inArray(taskTable.id, tx.pgTransaction.select().from(zombieExhaustionSelection)))
                     .returning({ id: taskTable.id });
-                totalUpdated += exhaustionRows.length;
                 if (exhaustionRows.length > 0) {
-                    for (const row of exhaustionRows) {
-                        await this.resolveDependencies(row.id, TaskStatus.Dead, { transaction: tx });
-                    }
+                    await this.resolveDependenciesMany(exhaustionRows.map((r) => ({ id: r.id, status: TaskStatus.Orphaned, namespace: this.#namespace })), { transaction: tx });
                 }
-                // 3.4 Handle Hard Timeout
-                const timeoutSelection = tx.pgTransaction.$with('timeout_selection').as((qb) => qb
-                    .select({ id: taskTable.id })
-                    .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
-                    .limit(1000)
-                    .for('update', { skipLocked: true }));
+                return exhaustionRows.length;
+            });
+            if (updatedCount < 1000) {
+                break;
+            }
+        }
+    }
+    async processHardTimeouts(options) {
+        const timeoutSelection = this.#database.$with('timeout_selection').as((qb) => qb
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+            .limit(1000)
+            .for('update', { skipLocked: true }));
+        while (true) {
+            const updatedCount = await this.#repository.useTransaction(options?.transaction, async (tx) => {
                 const timeoutRows = await tx.pgTransaction
                     .with(timeoutSelection)
                     .update(taskTable)
                     .set({
-                    status: TaskStatus.Dead,
+                    status: TaskStatus.TimedOut,
                     token: null,
                     visibilityDeadline: null,
                     completeTimestamp: TRANSACTION_TIMESTAMP,
-                    error: sql `jsonb_build_object('code', 'MaxTimeExceeded', 'message', 'Hard Execution Timeout: Task ran longer than ' || ${this.maxExecutionTime} || 'ms', 'last_error', ${taskTable.error})`,
+                    error: jsonbBuildObject({ code: 'MaxTimeExceeded', message: sql `'Hard Execution Timeout: Task ran longer than ' || ${this.maxExecutionTime} || 'ms'`, lastError: taskTable.error }),
                 })
                     .where(inArray(taskTable.id, tx.pgTransaction.select().from(timeoutSelection)))
                     .returning({ id: taskTable.id });
-                totalUpdated += timeoutRows.length;
                 if (timeoutRows.length > 0) {
-                    for (const row of timeoutRows) {
-                        await this.resolveDependencies(row.id, TaskStatus.Dead, { transaction: tx });
-                    }
+                    await this.resolveDependenciesMany(timeoutRows.map((r) => ({ id: r.id, status: TaskStatus.TimedOut, namespace: this.#namespace })), { transaction: tx });
                 }
-                // 3.5 Promote Priority (Aging)
-                const agingSelection = tx.pgTransaction.$with('aging_selection').as((qb) => qb
-                    .select({ id: taskTable.id })
-                    .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Pending), lt(taskTable.priorityAgeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.priorityAgingInterval, 'milliseconds')}`)))
-                    .limit(1000)
-                    .for('update', { skipLocked: true }));
-                const agingRows = await tx.pgTransaction
-                    .with(agingSelection)
-                    .update(taskTable)
-                    .set({
-                    priority: sql `${taskTable.priority} - ${this.priorityAgingStep}`,
-                    priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
-                })
-                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(agingSelection)))
-                    .returning({ id: taskTable.id });
-                totalUpdated += agingRows.length;
-                return totalUpdated;
+                return timeoutRows.length;
             });
-            if (maintenanceCount == 0) {
+            if (updatedCount < 1000) {
+                break;
+            }
+        }
+    }
+    async processPriorityAging(options) {
+        const session = options?.transaction?.pgTransaction ?? this.#database;
+        const agingSelection = session.$with('aging_selection').as((qb) => qb
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, queueableStatuses), lt(taskTable.priorityAgeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.priorityAgingInterval, 'milliseconds')}`)))
+            .limit(1000)
+            .for('update', { skipLocked: true }));
+        while (true) {
+            const agingRows = await session
+                .with(agingSelection)
+                .update(taskTable)
+                .set({
+                priority: sql `${taskTable.priority} - ${this.priorityAgingStep}`,
+                priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
+            })
+                .where(inArray(taskTable.id, session.select().from(agingSelection)))
+                .returning({ id: taskTable.id });
+            if (agingRows.length < 1000) {
                 break;
             }
         }
@@ -1122,44 +1300,87 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
             state: (options?.resetState == true) ? null : undefined,
         })
-            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id), or(eq(taskTable.status, TaskStatus.Pending), eq(taskTable.status, TaskStatus.Completed), eq(taskTable.status, TaskStatus.Cancelled), eq(taskTable.status, TaskStatus.Dead), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))));
+            .where(and(eq(taskTable.id, id), or(inArray(taskTable.status, queueableStatuses), inArray(taskTable.status, finalizedStatuses), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))));
     }
-    notify() {
-        this.#messageBus.publishAndForget();
+    notify(namespace = this.#namespace) {
+        this.#messageBus.publishAndForget(namespace);
     }
     async *getConsumer(cancellationSignal, options) {
-        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        const continue$ = merge(this.#messageBus.allMessages$).pipe(filter((namespace) => namespace == this.#namespace));
+        const mergedContinue$ = merge(continue$, cancellationSignal);
         while (cancellationSignal.isUnset) {
             const task = await this.dequeue(options);
             if (isDefined(task)) {
                 yield task;
                 continue;
             }
-            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+            await cancelableTimeout(5 * millisecondsPerSecond, mergedContinue$);
+        }
+    }
+    maintenanceLoop() {
+        void this.lowFrequencyMaintenanceLoop();
+        void this.mediumFrequencyMaintenanceLoop();
+        void this.highFrequencyMaintenanceLoop();
+    }
+    async lowFrequencyMaintenanceLoop() {
+        while (this.#cancellationSignal.isUnset) {
+            try {
+                await Promise.allSettled([
+                    this.performArchival(),
+                    this.performArchivePurge(),
+                ]);
+            }
+            catch (error) {
+                this.#logger.error('Error during low frequency maintenance loop', error);
+            }
+            finally {
+                await cancelableTimeout(5 * millisecondsPerMinute, this.#cancellationSignal);
+            }
+        }
+    }
+    async mediumFrequencyMaintenanceLoop() {
+        while (this.#cancellationSignal.isUnset) {
+            try {
+                await Promise.allSettled([
+                    this.processExpirations(),
+                    this.processPriorityAging(),
+                ]);
+            }
+            catch (error) {
+                this.#logger.error('Error during medium frequency maintenance loop', error);
+            }
+            finally {
+                await cancelableTimeout(millisecondsPerMinute, this.#cancellationSignal);
+            }
         }
     }
-    async maintenanceLoop() {
+    async highFrequencyMaintenanceLoop() {
         while (this.#cancellationSignal.isUnset) {
             try {
-                await this.maintenance();
+                await Promise.allSettled([
+                    this.processZombieRetries(),
+                    this.processZombieExhaustions(),
+                    this.processHardTimeouts(),
+                ]);
             }
             catch (error) {
-                this.#logger.error('Error during maintenance loop', error);
+                this.#logger.error('Error during high frequency maintenance loop', error);
             }
             finally {
-                await cancelableTimeout(30 * millisecondsPerSecond, this.#cancellationSignal);
+                await cancelableTimeout(10 * millisecondsPerSecond, this.#cancellationSignal);
             }
         }
     }
     async *getBatchConsumer(size, cancellationSignal, options) {
-        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        const continue$ = merge(this.#messageBus.allMessages$).pipe(filter((namespace) => namespace == this.#namespace));
+        const mergedContinue$ = merge(continue$, cancellationSignal);
         while (cancellationSignal.isUnset) {
             const tasks = await this.dequeueMany(size, options);
             if (tasks.length > 0) {
                 yield tasks;
                 continue;
             }
-            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+            await cancelableTimeout(5 * millisecondsPerSecond, mergedContinue$);
         }
     }
 };