@tstdl/base 0.93.140 → 0.93.142

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

@@ -56,35 +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 { and, asc, count, eq, gt, gte, inArray, lt, lte, notInArray, or, sql, 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, interval, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP, unnest } 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, distinct, toArray } from '../../utils/array/array.js';
-import { digest } from '../../utils/cryptography.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, isNull, isString, isUndefined } from '../../utils/type-guards.js';
-import { millisecondsPerSecond } from '../../utils/units.js';
-import { defaultQueueConfig, DependencyJoinMode, TaskProcessResult, TaskQueue, TaskStatus } from '../task-queue.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, 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 {
-    #internalThis = this;
+    #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, {
@@ -111,22 +110,19 @@ 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 = {
-        id: RANDOM_UUID_V4,
         namespace: this.#namespace,
         type: sql `excluded.type`,
-        status: TaskStatus.Pending,
+        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`,
-        completeAfterTags: sql `excluded.complete_after_tags`,
-        scheduleAfterTags: sql `excluded.schedule_after_tags`,
+        unresolvedScheduleDependencies: taskTable.unresolvedScheduleDependencies,
+        unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies,
         failFast: sql `excluded.fail_fast`,
-        dependencyJoinMode: sql `excluded.dependency_join_mode`,
-        dependencyTriggerStatuses: sql `excluded.dependency_trigger_statuses`,
         tries: 0,
         creationTimestamp: TRANSACTION_TIMESTAMP,
         priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
@@ -143,8 +139,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     };
     [afterResolve]() {
         if (!this.isInTransaction) {
-            this.startSystemWorker();
-            void this.maintenanceLoop();
+            this.maintenanceLoop();
         }
     }
     async enqueue(type, data, options) {
@@ -157,76 +152,207 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (items.length == 0) {
                 return (options?.returnTasks == true) ? [] : undefined;
             }
-            const newEntities = items.map((item) => {
-                const hasDependencies = (item.completeAfterTags?.length ?? 0) > 0 || (item.scheduleAfterTags?.length ?? 0) > 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: hasDependencies ? TaskStatus.Waiting : TaskStatus.Pending,
-                    token: null,
-                    priority: item.priority ?? 1000,
-                    idempotencyKey: item.idempotencyKey ?? null,
-                    traceId: null,
-                    tags: item.tags ?? [],
-                    completeAfterTags: item.completeAfterTags ?? [],
-                    scheduleAfterTags: item.scheduleAfterTags ?? [],
-                    failFast: item.failFast ?? false,
-                    dependencyJoinMode: item.dependencyJoinMode ?? DependencyJoinMode.And,
-                    dependencyTriggerStatuses: item.dependencyTriggerStatuses ?? [TaskStatus.Completed],
-                    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.completeAfterTags?.length ?? 0) > 0) || ((item.scheduleAfterTags?.length ?? 0) > 0));
-            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 tasks = [];
+            const session = transaction?.pgTransaction ?? this.#repository.session;
+            const tasks = new Array(itemsWithDistinctDependencies.length);
+            let insertedRows = [];
+            let upsertedRows = [];
             if (itemsWithoutIdempotency.length > 0) {
-                const insertedTasks = await this.#repository.withOptionalTransaction(transaction).insertMany(itemsWithoutIdempotency);
-                tasks.push(...insertedTasks);
+                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 repository = this.#repository.withOptionalTransaction(transaction);
                 const windowCutoff = sql `${TRANSACTION_TIMESTAMP} - ${interval(this.idempotencyWindow, 'milliseconds')}`;
                 const setWhere = (options?.replace == true) ? undefined : sql `${taskTable.creationTimestamp} < ${windowCutoff}`;
-                const upsertedTasks = await repository.upsertMany(['namespace', 'idempotencyKey'], itemsWithIdempotency, this.#takeNewUpdate, { set: setWhere });
-                tasks.push(...upsertedTasks);
-                if (options?.returnTasks == true && upsertedTasks.length < itemsWithIdempotency.length) {
-                    const upsertedKeys = new Set(upsertedTasks.map((t) => t.idempotencyKey));
-                    const missingKeys = itemsWithIdempotency.map((i) => i.idempotencyKey).filter((k) => !upsertedKeys.has(k));
-                    if (missingKeys.length > 0) {
-                        const existingTasks = await repository.loadManyByQuery({
-                            namespace: this.#namespace,
-                            idempotencyKey: { $in: missingKeys },
+                upsertedRows = await session
+                    .insert(taskTable)
+                    .values(itemsWithIdempotency.map((i) => i.entity))
+                    .onConflictDoUpdate({
+                    target: [taskTable.namespace, taskTable.idempotencyKey],
+                    set: this.#takeNewUpdate,
+                    setWhere,
+                })
+                    .returning();
+                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) {
+                    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, 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 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({
+                            taskId: item.parentId,
+                            dependencyTaskId: task.id,
+                            type: TaskDependencyType.Child,
+                            requiredStatuses: [TaskStatus.Completed],
                         });
-                        tasks.push(...existingTasks);
+                    }
+                    if (isDefined(item.scheduleAfter)) {
+                        for (const dependency of item.scheduleAfter) {
+                            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({
+                                taskId: task.id,
+                                dependencyTaskId,
+                                type: TaskDependencyType.Schedule,
+                                requiredStatuses: requiredStatuses,
+                            });
+                        }
+                    }
+                    if (isDefined(item.completeAfter)) {
+                        for (const dependency of item.completeAfter) {
+                            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({
+                                taskId: task.id,
+                                dependencyTaskId,
+                                type: TaskDependencyType.Complete,
+                                requiredStatuses: requiredStatuses,
+                            });
+                        }
+                    }
+                }
+                if (dependencies.length > 0) {
+                    const inserted = await session
+                        .insert(taskDependencyTable)
+                        .values(dependencies)
+                        .onConflictDoNothing()
+                        .returning();
+                    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();
-            const anyWaiting = tasks.some((t) => t.status == TaskStatus.Waiting);
-            if (anyWaiting) {
-                const tagsToTrigger = distinct(tasks.filter((t) => t.status == TaskStatus.Waiting).flatMap((t) => [...t.completeAfterTags, ...t.scheduleAfterTags]));
-                await this.triggerTagFanIn(tagsToTrigger, { transaction });
+            if (isDefined(newTransaction) && !newTransaction.isDone) {
+                await newTransaction.commit();
             }
+            this.notify();
             if (options?.returnTasks == true) {
-                return 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;
         }
@@ -240,39 +366,105 @@ 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) {
-        return await this.#repository.withOptionalTransaction(options?.transaction).hasByQuery({ namespace: this.#namespace, id });
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const [result] = await session
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .where(eq(taskTable.id, id))
+            .limit(1);
+        return isDefined(result);
     }
     async countByTags(tags, options) {
         const tagArray = toArray(tags);
         if (tagArray.length == 0) {
             return 0;
         }
-        const [result] = await this.#repository.withOptionalTransaction(options?.transaction).session
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const [result] = await session
+            .select({ count: count() })
+            .from(taskTable)
+            .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), arrayOverlaps(taskTable.tags, tagArray)))
-            .execute();
+            .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 active = await this.#repository.withOptionalTransaction(options?.transaction).tryLoadByQuery({ namespace: this.#namespace, id });
-        if (isDefined(active)) {
-            return active;
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const [activeRow] = await session
+            .select()
+            .from(taskTable)
+            .where(eq(taskTable.id, id));
+        if (isDefined(activeRow)) {
+            return await this.#repository.mapToEntity(activeRow);
+        }
+        const [archiveRow] = await session
+            .select()
+            .from(taskArchiveTable)
+            .where(eq(taskArchiveTable.id, id));
+        if (isDefined(archiveRow)) {
+            return await this.#archiveRepository.mapToEntity(archiveRow);
         }
-        return await this.#archiveRepository.withOptionalTransaction(options?.transaction).tryLoadByQuery({ namespace: this.#namespace, id });
+        return undefined;
     }
     async getManyByTags(tags, options) {
         const tagArray = toArray(tags);
         if (tagArray.length == 0) {
             return [];
         }
-        const rows = await this.#repository.withOptionalTransaction(options?.transaction).session
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const rows = await session
             .select()
             .from(taskTable)
-            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)))
-            .execute();
-        return await this.#repository.withOptionalTransaction(options?.transaction).mapManyToEntity(rows);
+            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)));
+        return await this.#repository.mapManyToEntity(rows);
     }
     async getTree(rootId, options) {
         const ids = toArray(rootId);
@@ -280,19 +472,22 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     }
     async getTreeByQuery(query, options) {
         return await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repositoryWithTransaction = this.#repository.withTransaction(tx);
-            const roots = await repositoryWithTransaction.loadManyByQuery(query);
+            const querySql = this.#repository.convertQuery(query);
+            const roots = await tx.pgTransaction
+                .select({ id: taskTable.id })
+                .from(taskTable)
+                .where(querySql);
             if (roots.length == 0) {
                 return [];
             }
             const rootIds = roots.map((t) => t.id);
-            const rawResult = await repositoryWithTransaction.session.execute(sql `
+            const { rows } = await tx.pgTransaction.execute(sql `
         WITH RECURSIVE task_tree AS (
           SELECT *, 0 as depth
           FROM ${taskTable}
           WHERE ${inArray(taskTable.id, rootIds)}
 
-          UNION
+          UNION ALL
 
           SELECT child.*, parent.depth + 1
           FROM ${taskTable} child
@@ -301,8 +496,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         )
         SELECT * FROM task_tree
       `);
-            const rows = rawResult.rows;
-            return await repositoryWithTransaction.mapManyToEntity(rows);
+            return await this.#repository.mapManyToEntity(rows);
         });
     }
     async waitForTasks(ids, options) {
@@ -312,9 +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 continue$ = merge(this.#messageBus.allMessages$.pipe(throttleTime(50, undefined, { leading: true, trailing: true })), cancellationSignal);
+        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 };
@@ -322,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;
@@ -344,13 +540,18 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (treeIds.length == 0) {
                 return;
             }
-            await this.#repository.withTransaction(tx).updateMany(treeIds, {
+            const cancelledRows = await tx.pgTransaction
+                .update(taskTable)
+                .set({
                 status: TaskStatus.Cancelled,
                 token: null,
                 completeTimestamp: TRANSACTION_TIMESTAMP,
-            });
-            const tags = tree.flatMap((t) => t.tags);
-            await this.triggerTagFanIn(tags, { 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 });
+            }
         });
     }
     async cancelManyByTags(tags, options) {
@@ -362,17 +563,35 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     }
     async clear(options) {
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
-            const parentIds = repository.session
-                .select({ id: taskTable.id })
+            const nonFinalizedTasks = await tx.pgTransaction
+                .select({ id: taskTable.id, namespace: taskTable.namespace })
                 .from(taskTable)
-                .where(eq(taskTable.namespace, this.#namespace));
-            await repository.session
+                .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(inArray(taskTable.parentId, parentIds))
-                .execute();
-            await repository.hardDeleteManyByQuery({ namespace: this.#namespace });
+                .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));
         });
     }
     async dequeue(options) {
@@ -386,52 +605,50 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         // 1. Flow Control
         const forceDequeue = options?.forceDequeue ?? false;
         let circuitBreakerResult;
+        let rateLimitAcquired = 0;
         if (!forceDequeue) {
             circuitBreakerResult = await this.#circuitBreaker.check();
             if (!circuitBreakerResult.allowed) {
                 return [];
             }
-            const rateLimitAllowed = await this.#rateLimiter.tryAcquire(this.#namespace, count);
-            if (!rateLimitAllowed) {
+            for (let i = count; i > 0; i--) {
+                if (await this.#rateLimiter.tryAcquire(this.#namespace, i)) {
+                    rateLimitAcquired = i;
+                    break;
+                }
+            }
+            if (rateLimitAcquired == 0) {
                 return [];
             }
         }
         const tasks = await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
-            let effectiveCount = count;
+            let effectiveCount = forceDequeue ? count : rateLimitAcquired;
             if (!forceDequeue && circuitBreakerResult?.state == CircuitBreakerState.HalfOpen) {
                 if (circuitBreakerResult.isProbe != true) {
-                    const runningCount = await repository.countByQuery({ namespace: this.#namespace, status: TaskStatus.Running });
-                    if (runningCount > 0) {
+                    const [runningResult] = await tx.pgTransaction
+                        .select({ count: sqlCount() })
+                        .from(taskTable)
+                        .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running)));
+                    if ((runningResult?.count ?? 0) > 0) {
                         return [];
                     }
                 }
                 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 runningCount = await repository.countByQuery({ namespace: this.#namespace, status: TaskStatus.Running });
-                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
              * https://dba.stackexchange.com/questions/69471/postgres-update-limit-1
              */
-            const selection = repository.session.$with('selection').as((qb) => qb
+            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)
                 .for('update', { skipLocked: true }));
-            const rows = await repository.session
+            const rows = await tx.pgTransaction
                 .with(selection)
                 .update(taskTable)
                 .set({
@@ -443,13 +660,13 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 // If it was RUNNING (Zombie), previous try failed -> increment tries.
                 tries: sql `${taskTable.tries} + 1`,
             })
-                .where(inArray(taskTable.id, repository.session.select().from(selection)))
+                .where(inArray(taskTable.id, tx.pgTransaction.select().from(selection)))
                 .returning();
             return await this.#repository.mapManyToEntity(rows);
         });
         // 3. Compensation
-        if (!forceDequeue && (tasks.length < count)) {
-            const shortfall = count - tasks.length;
+        if (!forceDequeue && (tasks.length < rateLimitAcquired)) {
+            const shortfall = rateLimitAcquired - tasks.length;
             await this.#rateLimiter.refund(this.#namespace, shortfall);
         }
         return tasks;
@@ -458,35 +675,36 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         await this.rescheduleMany([id], timestamp, options);
     }
     async rescheduleMany(ids, timestamp, options) {
-        await this.#repository.withOptionalTransaction(options?.transaction).updateMany(ids, {
-            status: TaskStatus.Pending,
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        await session
+            .update(taskTable)
+            .set({
+            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(inArray(taskTable.id, ids), notInArray(taskTable.status, terminalStatuses)));
     }
     async rescheduleManyByTags(tags, timestamp, options) {
-        await this.#repository.withOptionalTransaction(options?.transaction).updateManyByQuery(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags))), {
-            status: TaskStatus.Pending,
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        await session
+            .update(taskTable)
+            .set({
+            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)), notInArray(taskTable.status, terminalStatuses)));
     }
     async touch(task, options) {
         if (isNull(task.token)) {
             return undefined;
         }
         return await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
             const update = {
                 visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`,
             };
@@ -496,34 +714,44 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (isDefined(options?.state)) {
                 update.state = options.state;
             }
-            const result = await repository.tryUpdateByQuery({
-                namespace: this.#namespace,
-                id: task.id,
-                status: TaskStatus.Running,
-                token: task.token,
-                startTimestamp: { $gt: sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}` },
-            }, update);
-            // TODO: reduce required DB roundtrips
-            if (isUndefined(result)) {
-                const existing = await repository.tryLoadByQuery({ id: task.id, namespace: this.#namespace, status: TaskStatus.Running, token: task.token });
-                if (isDefined(existing) && isNotNull(existing.startTimestamp) && (currentTimestamp() - existing.startTimestamp) > this.maxExecutionTime) {
-                    await this.fail(task, { message: 'Hard Execution Timeout' }, { fatal: true, transaction: tx });
-                }
+            const [updatedRow] = await tx.pgTransaction
+                .update(taskTable)
+                .set(update)
+                .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);
+            }
+            const [existingRow] = await tx.pgTransaction
+                .select({ startTimestamp: taskTable.startTimestamp })
+                .from(taskTable)
+                .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 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 result;
+            return undefined;
         });
     }
     async touchMany(tasks, options) {
         if (tasks.length == 0) {
             return [];
         }
-        const repository = this.#repository.withOptionalTransaction(options?.transaction);
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
         const rows = tasks.map((t, i) => {
             const progress = options?.progresses?.[i] ?? null;
             const state = options?.states?.[i] ?? null;
             return sql `(${t.id}::uuid, ${t.token}::uuid, ${progress}::numeric, ${state}::jsonb)`;
         });
-        const updates = repository.session.$with('updates').as((qb) => qb
+        const updates = session.$with('updates').as((qb) => qb
             .select({
             updateId: sql `(id)::uuid`.as('update_id'),
             updateToken: sql `(token)::uuid`.as('update_token'),
@@ -531,7 +759,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             updateState: sql `(state)::jsonb`.as('update_state'),
         })
             .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, progress, state)`));
-        const updated = repository.session.$with('updated').as(() => repository.session
+        const updated = session.$with('updated').as(() => session
             .update(taskTable)
             .set({
             visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`,
@@ -539,34 +767,44 @@ 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 repository.session
+        const result = await session
             .with(updates, updated)
             .select({ id: updated.id })
-            .from(updated)
-            .execute();
+            .from(updated);
         return result.map((r) => r.id);
     }
     async complete(task, options) {
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
-            const updatedTask = await repository.tryUpdateByQuery({
-                id: task.id,
-                token: task.token,
-            }, {
-                status: TaskStatus.Completed,
+            const [freshTask] = await tx.pgTransaction
+                .select({ unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies })
+                .from(taskTable)
+                .where(eq(taskTable.id, task.id))
+                .for('update');
+            if (isUndefined(freshTask)) {
+                return;
+            }
+            const hasActiveChildren = freshTask.unresolvedCompleteDependencies > 0;
+            const nextStatus = hasActiveChildren ? TaskStatus.WaitingChildren : TaskStatus.Completed;
+            const [updatedTask] = await tx.pgTransaction.update(taskTable)
+                .set({
+                status: nextStatus,
                 token: null,
                 result: options?.result,
-                progress: 1,
-                completeTimestamp: TRANSACTION_TIMESTAMP,
+                progress: hasActiveChildren ? task.progress : 1,
+                completeTimestamp: (nextStatus == TaskStatus.Completed) ? TRANSACTION_TIMESTAMP : null,
                 visibilityDeadline: null,
-            });
+            })
+                .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;
             }
-            await this.#circuitBreaker.recordSuccess();
-            await this.triggerTagFanIn(task.tags, { transaction: tx });
+            if (nextStatus == TaskStatus.Completed) {
+                await this.#circuitBreaker.recordSuccess();
+            }
+            await this.resolveDependencies(task.id, nextStatus, { namespace: task.namespace, transaction: tx });
         });
     }
     async completeMany(tasks, options) {
@@ -574,57 +812,54 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             return;
         }
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
             const rows = tasks.map((t, i) => {
                 const result = options?.results?.[i] ?? null;
-                return sql `(${t.id}::uuid, ${t.token}::uuid, ${result}::jsonb)`;
+                return sql `(${t.id}::uuid, ${t.token}::uuid, ${result}::jsonb, ${t.progress}::numeric)`;
             });
-            const updates = repository.session.$with('updates').as((qb) => qb
+            const updates = tx.pgTransaction.$with('updates').as((qb) => qb
                 .select({
                 updateId: sql `(id)::uuid`.as('update_id'),
                 updateToken: sql `(token)::uuid`.as('update_token'),
                 updateResult: sql `(result)::jsonb`.as('update_result'),
+                updateProgress: sql `(progress)::numeric`.as('update_progress'),
             })
-                .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, result)`));
-            const updated = repository.session.$with('updated').as(() => repository.session
+                .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: TaskStatus.Completed,
+                status: caseWhen(gt(taskTable.unresolvedCompleteDependencies, 0), enumValue(TaskStatus, taskStatus, TaskStatus.WaitingChildren)).else(enumValue(TaskStatus, taskStatus, TaskStatus.Completed)),
                 token: null,
                 result: updates.updateResult,
-                progress: 1,
-                completeTimestamp: TRANSACTION_TIMESTAMP,
+                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)))
-                .returning({ id: taskTable.id, tags: taskTable.tags }));
-            const updatedRows = await repository.session
+                .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)
-                .select({ id: updated.id, tags: updated.tags })
-                .from(updated)
-                .execute();
+                .select({ id: updated.id, status: updated.status })
+                .from(updated);
             if (updatedRows.length > 0) {
-                await this.#circuitBreaker.recordSuccess();
-                const tags = updatedRows.flatMap((t) => t.tags);
-                await this.triggerTagFanIn(tags, { transaction: tx });
+                if (updatedRows.some((r) => r.status == TaskStatus.Completed)) {
+                    await this.#circuitBreaker.recordSuccess();
+                }
+                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;
         const nextSchedule = currentTimestamp() + delay;
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const updatedTask = await this.#repository.withTransaction(tx).tryUpdateByQuery({
-                namespace: this.#namespace,
-                id: task.id,
-                token: task.token,
-                tries: task.tries,
-            }, {
+            const [updatedRow] = await tx.pgTransaction
+                .update(taskTable)
+                .set({
                 status: nextStatus,
                 token: null,
                 error: serializeError(error),
@@ -632,28 +867,14 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 scheduleTimestamp: nextSchedule,
                 startTimestamp: null,
                 completeTimestamp: (nextStatus == TaskStatus.Dead) ? TRANSACTION_TIMESTAMP : null,
-            });
-            if (isUndefined(updatedTask)) {
+            })
+                .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();
-            if (nextStatus == TaskStatus.Dead) {
-                await this.triggerTagFanIn(task.tags, { transaction: tx });
-            }
-        });
-    }
-    async triggerTagFanIn(tags, options) {
-        if (tags.length == 0) {
-            return;
-        }
-        const distinctSortedTags = distinct(tags).toSorted();
-        const hash = await digest('SHA-256', distinctSortedTags.join(',')).toHex();
-        const idempotencyKey = `Sys:FanIn:${hash}`;
-        await this.#internalThis.enqueue('[SystemWorker]:FanIn', { targetTags: distinctSortedTags }, {
-            priority: 0,
-            idempotencyKey,
-            replace: true,
-            transaction: options?.transaction,
+            await this.resolveDependencies(task.id, nextStatus, { namespace: task.namespace, transaction: tx });
         });
     }
     async failMany(tasks, errors, options) {
@@ -661,11 +882,10 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             return;
         }
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
             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;
@@ -673,7 +893,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 const completeTimestamp = (nextStatus == TaskStatus.Dead) ? new Date() : null;
                 return sql `(${task.id}::uuid, ${task.token}::uuid, ${task.tries}::int, ${nextStatus}::text, ${serializeError(error)}::jsonb, ${nextSchedule}::timestamptz, ${completeTimestamp}::timestamptz)`;
             });
-            const updates = repository.session.$with('updates').as((qb) => qb
+            const updates = tx.pgTransaction.$with('updates').as((qb) => qb
                 .select({
                 updateId: sql `(id)::uuid`.as('update_id'),
                 updateToken: sql `(token)::uuid`.as('update_token'),
@@ -684,7 +904,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 updateComplete: sql `(complete_timestamp)::timestamptz`.as('update_complete'),
             })
                 .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, tries, status, error, schedule_timestamp, complete_timestamp)`));
-            const updated = repository.session.$with('updated').as(() => repository.session
+            const updated = tx.pgTransaction.$with('updated').as(() => tx.pgTransaction
                 .update(taskTable)
                 .set({
                 status: sql `${updates.updateStatus}::${taskStatus}`,
@@ -696,304 +916,369 @@ 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)))
-                .returning({ id: taskTable.id, status: taskTable.status, tags: taskTable.tags }));
-            const result = await repository.session
+                .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()
-                .from(updated)
-                .execute();
+                .select({ id: updated.id, status: updated.status })
+                .from(updated);
             if (result.length > 0) {
-                await Promise.all(createArray(result.length, async () => await this.#circuitBreaker.recordFailure()));
-                const deadTags = result
-                    .filter((r) => r.status == TaskStatus.Dead)
-                    .flatMap((r) => r.tags);
-                await this.triggerTagFanIn(deadTags, { transaction: tx });
+                await this.#circuitBreaker.recordFailures(result.length);
+                await this.resolveDependenciesMany(result.map((r) => ({ id: r.id, status: r.status })), { transaction: tx });
             }
         });
     }
-    async resolveDependencies(targetTags) {
-        await this.#repository.transaction(async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
-            // Identify Dependents
-            const waiters = await repository.session
-                .select()
-                .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Waiting), or(arrayOverlaps(taskTable.completeAfterTags, targetTags), arrayOverlaps(taskTable.scheduleAfterTags, targetTags))))
-                .for('update', { skipLocked: true })
-                .execute();
-            const entities = await repository.mapManyToEntity(waiters);
-            if (entities.length == 0) {
-                return;
-            }
-            const allRequiredTags = distinct(entities.flatMap((t) => [...t.completeAfterTags, ...t.scheduleAfterTags]));
-            const statsRows = await repository.session
+    async resolveDependencies(id, status, options) {
+        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) => {
+            const taskIds = tasks.map((t) => t.id);
+            const dependents = await tx.pgTransaction
                 .select({
-                tag: unnest(taskTable.tags).as('tag'),
-                status: taskTable.status,
-                count: count().as('count'),
+                taskId: taskDependencyTable.taskId,
+                dependencyTaskId: taskDependencyTable.dependencyTaskId,
+                type: taskDependencyTable.type,
+                requiredStatuses: taskDependencyTable.requiredStatuses,
             })
-                .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, allRequiredTags)))
-                .groupBy(unnest(taskTable.tags), taskTable.status);
-            const tagStats = new Map();
-            for (const row of statsRows) {
-                if (!tagStats.has(row.tag)) {
-                    tagStats.set(row.tag, new Map());
-                }
-                tagStats.get(row.tag).set(row.status, row.count);
+                .from(taskDependencyTable)
+                .where(inArray(taskDependencyTable.dependencyTaskId, taskIds));
+            if (dependents.length == 0) {
+                return;
             }
-            const getCount = (tags, Statuses) => {
-                let sum = 0;
-                for (const tag of tags) {
-                    const stats = tagStats.get(tag);
-                    if (isDefined(stats)) {
-                        for (const status of Statuses) {
-                            sum += stats.get(status) ?? 0;
-                        }
-                    }
-                }
-                return sum;
-            };
-            const idsToFail = [];
-            const idsToSchedule = [];
-            const idsToComplete = [];
-            const fanInTags = [];
-            for (const waiter of entities) {
-                const requiredTags = distinct([...waiter.completeAfterTags, ...waiter.scheduleAfterTags]);
-                let isReady = false;
-                let shouldFail = false;
-                // 1. Check Fail Fast
-                if (waiter.failFast) {
-                    if (getCount(requiredTags, [TaskStatus.Dead, TaskStatus.Cancelled]) > 0) {
-                        shouldFail = true;
+            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 = terminalStatuses.includes(status);
+                if (isMatched || isTerminal) {
+                    resolvedEdges.push(dep);
+                    if (!isMatched) {
+                        failFastTaskIds.add(dep.taskId);
                     }
                 }
-                // 2. Check Trigger Conditions
-                if (!shouldFail) {
-                    if (waiter.dependencyJoinMode == DependencyJoinMode.Or) {
-                        if (getCount(requiredTags, waiter.dependencyTriggerStatuses) > 0) {
-                            isReady = true;
-                        }
-                    }
-                    else if (waiter.dependencyJoinMode == DependencyJoinMode.And) {
-                        isReady = requiredTags.every((tag) => {
-                            const stats = tagStats.get(tag);
-                            if (isUndefined(stats)) {
-                                return false;
-                            }
-                            const activeCount = (stats.get(TaskStatus.Pending) ?? 0)
-                                + (stats.get(TaskStatus.Running) ?? 0)
-                                + (stats.get(TaskStatus.Waiting) ?? 0);
-                            return activeCount == 0;
-                        });
-                    }
+            }
+            if (resolvedEdges.length == 0) {
+                return;
+            }
+            const sortedResolvedEdges = resolvedEdges.toSorted((a, b) => {
+                const idCompare = a.taskId.localeCompare(b.taskId);
+                if (idCompare != 0) {
+                    return idCompare;
                 }
-                // 3. Transition
-                if (shouldFail) {
-                    idsToFail.push(waiter.id);
+                const depIdCompare = a.dependencyTaskId.localeCompare(b.dependencyTaskId);
+                if (depIdCompare != 0) {
+                    return depIdCompare;
                 }
-                else if (isReady) {
-                    if (waiter.scheduleAfterTags.length > 0) {
-                        idsToSchedule.push(waiter.id);
-                        fanInTags.push(...waiter.tags);
+                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);
                     }
-                    else if (waiter.completeAfterTags.length > 0) {
-                        idsToComplete.push(waiter.id);
-                        fanInTags.push(...waiter.tags);
+                }
+                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);
                     }
                 }
             }
-            if (idsToFail.length > 0) {
-                const rows = await repository.updateMany(idsToFail, {
-                    status: TaskStatus.Dead,
-                    error: { code: 'DependencyFailed' },
-                    completeTimestamp: TRANSACTION_TIMESTAMP,
-                });
-                const tags = rows.flatMap((r) => r.tags);
-                await this.triggerTagFanIn(tags, { transaction: tx });
+            // 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 (idsToSchedule.length > 0) {
-                await repository.updateMany(idsToSchedule, {
-                    status: TaskStatus.Pending,
-                    scheduleTimestamp: TRANSACTION_TIMESTAMP,
+            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);
+                }
             }
-            if (idsToComplete.length > 0) {
-                await repository.updateMany(idsToComplete, {
-                    status: TaskStatus.Completed,
-                    completeTimestamp: TRANSACTION_TIMESTAMP,
-                    progress: 1,
-                    token: null,
-                });
-                await this.triggerTagFanIn(fanInTags, { transaction: tx });
+            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 repositoryWithTx = repository.withTransaction(tx);
-                const archiveRepositoryWithTx = archiveRepository.withTransaction(tx);
-                const tasksToArchive = await repositoryWithTx.loadManyByQuery({
-                    $and: [
-                        {
-                            namespace: this.#namespace,
-                            status: { $in: [TaskStatus.Completed, TaskStatus.Dead, TaskStatus.Cancelled] },
-                            completeTimestamp: { $lt: sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}` },
-                        },
-                        notInArray(taskTable.id, repositoryWithTx.session
-                            .select({ parentId: taskTable.parentId })
-                            .from(taskTable)
-                            .where(and(eq(taskTable.namespace, this.#namespace), sql `${taskTable.parentId} IS NOT NULL`))),
-                    ],
-                }, { limit: 1000, for: { mode: 'update', skipLocked: true } });
-                if (tasksToArchive.length > 0) {
-                    await archiveRepositoryWithTx.insertMany(tasksToArchive);
-                    await repositoryWithTx.hardDeleteMany(tasksToArchive.map((t) => t.id));
+            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, finalizedStatuses), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(tx.pgTransaction
+                    .select({ id: childTaskTable.id })
+                    .from(childTaskTable)
+                    .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) {
+                    const rowsToArchiveIds = getEntityIds(rowsToArchive);
+                    await tx.pgTransaction.insert(taskArchiveTable).values(rowsToArchive);
+                    await tx.pgTransaction.delete(taskTable).where(inArray(taskTable.id, rowsToArchiveIds));
                 }
-                return tasksToArchive.length;
+                return rowsToArchive.length;
             });
             if (archivedCount < 1000) {
                 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 repositoryWithTx = archiveRepository.withTransaction(tx);
-                const selection = repositoryWithTx.session.$with('archive_purge_selection').as((qb) => qb
-                    .select({ id: taskArchiveTable.id })
-                    .from(taskArchiveTable)
-                    .where(and(eq(taskArchiveTable.namespace, this.#namespace), lt(taskArchiveTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.archiveRetention, 'milliseconds')}`)))
-                    .limit(1000));
-                const result = await repositoryWithTx.session
-                    .with(selection)
-                    .delete(taskArchiveTable)
-                    .where(inArray(taskArchiveTable.id, repositoryWithTx.session.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) => {
-                const repositoryWithTx = repository.withTransaction(tx);
-                let totalUpdated = 0;
-                // 3.1 Handle Pending Expiration
-                const expiredSelection = repositoryWithTx.session.$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 expiredRows = await repositoryWithTx.session
+            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, repositoryWithTx.session.select().from(expiredSelection)))
-                    .returning({ tags: taskTable.tags });
-                totalUpdated += expiredRows.length;
+                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(expiredSelection)))
+                    .returning({ id: taskTable.id });
                 if (expiredRows.length > 0) {
-                    await this.triggerTagFanIn(expiredRows.flatMap((r) => r.tags), { 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 = repositoryWithTx.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 }));
-                const zombieRetryRows = await repositoryWithTx.session
-                    .with(zombieRetrySelection)
-                    .update(taskTable)
-                    .set({
-                    status: TaskStatus.Pending,
-                    token: null,
-                    visibilityDeadline: 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, repositoryWithTx.session.select().from(zombieRetrySelection)))
-                    .returning({ id: taskTable.id });
-                totalUpdated += zombieRetryRows.length;
-                // 3.3 Handle Zombie Tasks (Exhaustion)
-                const zombieExhaustionSelection = repositoryWithTx.session.$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 }));
-                const exhaustionRows = await repositoryWithTx.session
+                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, repositoryWithTx.session.select().from(zombieExhaustionSelection)))
-                    .returning({ tags: taskTable.tags });
-                totalUpdated += exhaustionRows.length;
+                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(zombieExhaustionSelection)))
+                    .returning({ id: taskTable.id });
                 if (exhaustionRows.length > 0) {
-                    await this.triggerTagFanIn(exhaustionRows.flatMap((r) => r.tags), { 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 = repositoryWithTx.session.$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 }));
-                const timeoutRows = await repositoryWithTx.session
+                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, repositoryWithTx.session.select().from(timeoutSelection)))
-                    .returning({ tags: taskTable.tags });
-                totalUpdated += timeoutRows.length;
+                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(timeoutSelection)))
+                    .returning({ id: taskTable.id });
                 if (timeoutRows.length > 0) {
-                    await this.triggerTagFanIn(timeoutRows.flatMap((r) => r.tags), { 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 = repositoryWithTx.session.$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 repositoryWithTx.session
-                    .with(agingSelection)
-                    .update(taskTable)
-                    .set({
-                    priority: sql `${taskTable.priority} - ${this.priorityAgingStep}`,
-                    priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
-                })
-                    .where(inArray(taskTable.id, repositoryWithTx.session.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;
             }
         }
@@ -1009,80 +1294,93 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             result: null,
             scheduleTimestamp: TRANSACTION_TIMESTAMP,
             completeTimestamp: null,
+            startTimestamp: null,
             tries: 0,
             progress: 0,
             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))))
-            .execute();
+            .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$);
         }
     }
-    async maintenanceLoop() {
+    maintenanceLoop() {
+        void this.lowFrequencyMaintenanceLoop();
+        void this.mediumFrequencyMaintenanceLoop();
+        void this.highFrequencyMaintenanceLoop();
+    }
+    async lowFrequencyMaintenanceLoop() {
         while (this.#cancellationSignal.isUnset) {
             try {
-                await this.maintenance();
+                await Promise.allSettled([
+                    this.performArchival(),
+                    this.performArchivePurge(),
+                ]);
             }
             catch (error) {
-                this.#logger.error('Error during maintenance loop', error);
+                this.#logger.error('Error during low frequency maintenance loop', error);
             }
             finally {
-                await cancelableTimeout(30 * millisecondsPerSecond, this.#cancellationSignal);
+                await cancelableTimeout(5 * millisecondsPerMinute, this.#cancellationSignal);
             }
         }
     }
-    /**
-     * @internal for internal unit test use only
-     * @param options
-     * @returns
-     */
-    async processPendingFanIn(options) {
-        let processedCount = 0;
-        while (true) {
-            const task = await this.#internalThis.dequeue({ types: ['[SystemWorker]:FanIn'], forceDequeue: true, transaction: options?.transaction });
-            if (isUndefined(task)) {
-                break;
-            }
+    async mediumFrequencyMaintenanceLoop() {
+        while (this.#cancellationSignal.isUnset) {
             try {
-                await this.resolveDependencies(task.data.targetTags);
-                await this.#internalThis.complete(task, { transaction: options?.transaction });
-                processedCount++;
+                await Promise.allSettled([
+                    this.processExpirations(),
+                    this.processPriorityAging(),
+                ]);
             }
             catch (error) {
-                await this.#internalThis.fail(task, error, { transaction: options?.transaction });
-                throw error;
+                this.#logger.error('Error during medium frequency maintenance loop', error);
+            }
+            finally {
+                await cancelableTimeout(millisecondsPerMinute, this.#cancellationSignal);
             }
         }
-        return processedCount;
     }
-    startSystemWorker() {
-        this.#internalThis.process({ concurrency: 1, cancellationSignal: this.#cancellationSignal, forceDequeue: true, types: ['[SystemWorker]:FanIn'] }, async (context) => {
-            await this.resolveDependencies(context.data.targetTags);
-            return TaskProcessResult.Complete();
-        });
+    async highFrequencyMaintenanceLoop() {
+        while (this.#cancellationSignal.isUnset) {
+            try {
+                await Promise.allSettled([
+                    this.processZombieRetries(),
+                    this.processZombieExhaustions(),
+                    this.processHardTimeouts(),
+                ]);
+            }
+            catch (error) {
+                this.#logger.error('Error during high frequency maintenance loop', error);
+            }
+            finally {
+                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$);
         }
     }
 };