@tstdl/base 0.93.139 → 0.93.141

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

@@ -56,29 +56,28 @@ 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 } from 'rxjs';
+import { aliasedTable, and, asc, count, eq, gt, gte, inArray, lt, lte, notExists, or, sql, count as sqlCount, isNull as sqlIsNull } from 'drizzle-orm';
+import { merge, throttleTime } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/index.js';
 import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/index.js';
-import { serializeError } from '../../errors/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 { arrayOverlaps, coalesce, getEntityIds, interval, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
 import { 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 { createArray, 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 { isDefined, isNotNull, isNotNullOrUndefined, 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 { 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 { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, taskStatus, task as taskTable } from './schemas.js';
 import { PostgresTask, PostgresTaskArchive } from './task.model.js';
 let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
-    #internalThis = this;
     #repository = injectRepository(PostgresTask);
     #archiveRepository = injectRepository(PostgresTaskArchive);
     #config = this.config;
@@ -112,20 +111,17 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     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: sql `CASE WHEN excluded.unresolved_schedule_dependencies > 0 THEN ${TaskStatus.Waiting}::${taskStatus} ELSE ${TaskStatus.Pending}::${taskStatus} END`,
         token: null,
         priority: sql `excluded.priority`,
         idempotencyKey: sql `excluded.idempotency_key`,
         traceId: sql `excluded.trace_id`,
         tags: sql `excluded.tags`,
-        completeAfterTags: sql `excluded.complete_after_tags`,
-        scheduleAfterTags: sql `excluded.schedule_after_tags`,
+        unresolvedScheduleDependencies: sql `excluded.unresolved_schedule_dependencies`,
+        unresolvedCompleteDependencies: sql `excluded.unresolved_complete_dependencies`,
         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,
@@ -142,7 +138,6 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     };
     [afterResolve]() {
         if (!this.isInTransaction) {
-            this.startSystemWorker();
             void this.maintenanceLoop();
         }
     }
@@ -157,21 +152,21 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 return (options?.returnTasks == true) ? [] : undefined;
             }
             const newEntities = items.map((item) => {
-                const hasDependencies = (item.completeAfterTags?.length ?? 0) > 0 || (item.scheduleAfterTags?.length ?? 0) > 0;
+                const scheduleAfterCount = item.scheduleAfter?.length ?? 0;
+                const completeAfterCount = item.completeAfter?.length ?? 0;
+                const isWaiting = scheduleAfterCount > 0;
                 return {
                     namespace: this.#namespace,
                     type: item.type,
-                    status: hasDependencies ? TaskStatus.Waiting : TaskStatus.Pending,
+                    status: isWaiting ? 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 ?? [],
+                    unresolvedScheduleDependencies: scheduleAfterCount,
+                    unresolvedCompleteDependencies: completeAfterCount,
                     failFast: item.failFast ?? false,
-                    dependencyJoinMode: item.dependencyJoinMode ?? DependencyJoinMode.And,
-                    dependencyTriggerStatuses: item.dependencyTriggerStatuses ?? [TaskStatus.Completed],
                     parentId: item.parentId ?? null,
                     tries: 0,
                     progress: 0,
@@ -190,42 +185,117 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             });
             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 hasDependencies = items.some((item) => ((item.scheduleAfter?.length ?? 0) > 0) || ((item.completeAfter?.length ?? 0) > 0) || (isDefined(item.parentId) && (item.waitForCompletion ?? true)));
             const mustUseTransaction = ((itemsWithoutIdempotency.length + itemsWithIdempotency.length) > 1) || hasDependencies;
             const newTransaction = __addDisposableResource(env_1, (mustUseTransaction && isUndefined(options?.transaction)) ? await this.#repository.startTransaction() : undefined, true);
             const transaction = newTransaction ?? options?.transaction;
+            const session = transaction?.pgTransaction ?? this.#repository.session;
             const tasks = [];
             if (itemsWithoutIdempotency.length > 0) {
-                const insertedTasks = await this.#repository.withOptionalTransaction(transaction).insertMany(itemsWithoutIdempotency);
-                tasks.push(...insertedTasks);
+                const insertedRows = await session.insert(taskTable).values(itemsWithoutIdempotency).returning();
+                tasks.push(...insertedRows);
             }
             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 upsertedRows = await session
+                    .insert(taskTable)
+                    .values(itemsWithIdempotency)
+                    .onConflictDoUpdate({
+                    target: [taskTable.namespace, taskTable.idempotencyKey],
+                    set: this.#takeNewUpdate,
+                    setWhere,
+                })
+                    .returning();
+                tasks.push(...upsertedRows);
+                if (options?.replace == true) {
+                    const upsertedIds = upsertedRows.map((t) => t.id);
+                    if (upsertedIds.length > 0) {
+                        await session.delete(taskDependencyTable).where(and(eq(taskDependencyTable.namespace, this.#namespace), inArray(taskDependencyTable.taskId, upsertedIds)));
+                    }
+                }
+                if (((options?.returnTasks == true) || hasDependencies) && (upsertedRows.length < itemsWithIdempotency.length)) {
+                    const upsertedKeys = new Set(upsertedRows.map((t) => t.idempotencyKey));
                     const missingKeys = itemsWithIdempotency.map((i) => i.idempotencyKey).filter((k) => !upsertedKeys.has(k));
                     if (missingKeys.length > 0) {
-                        const existingTasks = await repository.loadManyByQuery({
+                        const existingRows = await session
+                            .select()
+                            .from(taskTable)
+                            .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.idempotencyKey, missingKeys)));
+                        tasks.push(...existingRows);
+                    }
+                }
+            }
+            if (hasDependencies) {
+                const dependencies = [];
+                const parentIncrements = new Map();
+                for (const [index, item] of items.entries()) {
+                    const task = tasks[index];
+                    if (isDefined(item.parentId) && (item.waitForCompletion ?? true)) {
+                        dependencies.push({
                             namespace: this.#namespace,
-                            idempotencyKey: { $in: missingKeys },
+                            taskId: item.parentId,
+                            dependencyTaskId: task.id,
+                            type: TaskDependencyType.Complete,
+                            requiredStatuses: [TaskStatus.Completed],
                         });
-                        tasks.push(...existingTasks);
+                        parentIncrements.set(item.parentId, (parentIncrements.get(item.parentId) ?? 0) + 1);
+                    }
+                    if (isDefined(item.scheduleAfter)) {
+                        for (const dependency of item.scheduleAfter) {
+                            const dependencyTaskId = isString(dependency) ? dependency : dependency.id;
+                            const requiredStatuses = (isString(dependency) ? [TaskStatus.Completed] : (dependency.requiredStatuses ?? [TaskStatus.Completed]));
+                            dependencies.push({
+                                namespace: this.#namespace,
+                                taskId: task.id,
+                                dependencyTaskId,
+                                type: TaskDependencyType.Schedule,
+                                requiredStatuses,
+                            });
+                        }
+                    }
+                    if (isDefined(item.completeAfter)) {
+                        for (const dependency of item.completeAfter) {
+                            const dependencyTaskId = isString(dependency) ? dependency : dependency.id;
+                            const requiredStatuses = (isString(dependency) ? [TaskStatus.Completed] : (dependency.requiredStatuses ?? [TaskStatus.Completed]));
+                            dependencies.push({
+                                namespace: this.#namespace,
+                                taskId: task.id,
+                                dependencyTaskId,
+                                type: TaskDependencyType.Complete,
+                                requiredStatuses,
+                            });
+                        }
+                    }
+                }
+                if (dependencies.length > 0) {
+                    const inserted = await session
+                        .insert(taskDependencyTable)
+                        .values(dependencies)
+                        .onConflictDoNothing()
+                        .returning();
+                    if (parentIncrements.size > 0) {
+                        for (const [parentId, increment] of parentIncrements) {
+                            // We only increment for those that were actually inserted.
+                            // Since we use onConflict: 'do-nothing', inserted array only contains actually inserted ones.
+                            const actualIncrement = inserted.filter((d) => d.taskId == parentId && d.type == TaskDependencyType.Complete).length;
+                            if (actualIncrement > 0) {
+                                await session
+                                    .update(taskTable)
+                                    .set({
+                                    unresolvedCompleteDependencies: sql `${taskTable.unresolvedCompleteDependencies} + ${actualIncrement}`,
+                                })
+                                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, parentId)));
+                            }
+                        }
                     }
                 }
             }
             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 (options?.returnTasks == true) {
-                return tasks;
+                const mapped = await this.#repository.mapManyToEntity(tasks);
+                return mapped;
             }
             return undefined;
         }
@@ -240,38 +310,55 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     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(and(eq(taskTable.namespace, this.#namespace), 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)))
-            .execute();
+            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)));
         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(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id)));
+        if (isDefined(activeRow)) {
+            return await this.#repository.mapToEntity(activeRow);
+        }
+        const [archiveRow] = await session
+            .select()
+            .from(taskArchiveTable)
+            .where(and(eq(taskArchiveTable.namespace, this.#namespace), eq(taskArchiveTable.id, id)));
+        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);
@@ -279,13 +366,16 @@ 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}
@@ -300,10 +390,39 @@ 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) {
+        if (ids.length == 0) {
+            return { cancelled: false };
+        }
+        const timeout = options?.timeout ?? Infinity;
+        const interval = options?.interval ?? 1000;
+        const cancellationSignal = this.#cancellationSignal.optionallyInherit(options?.cancellationSignal);
+        const messageBus$ = this.#messageBus.allMessages$.pipe(throttleTime(500, undefined, { leading: true, trailing: true }));
+        const continue$ = merge(messageBus$, cancellationSignal);
+        const timer = Timer.startNew();
+        const finalizedStatuses = [TaskStatus.Completed, TaskStatus.Cancelled, TaskStatus.Dead];
+        while (true) {
+            if (cancellationSignal.isSet) {
+                return { cancelled: true };
+            }
+            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) {
+                return { cancelled: false };
+            }
+            const remainingTimeout = timeout - timer.milliseconds;
+            const waitTime = Math.min(interval, remainingTimeout);
+            await cancelableTimeout(waitTime, continue$);
+        }
+    }
     async cancel(id, options) {
         await this.cancelMany([id], options);
     }
@@ -314,13 +433,17 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (treeIds.length == 0) {
                 return;
             }
-            await this.#repository.withTransaction(tx).updateMany(treeIds, {
+            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(eq(taskTable.namespace, this.#namespace), inArray(taskTable.id, treeIds)));
+            for (const task of tree) {
+                await this.resolveDependencies(task.id, TaskStatus.Cancelled, { transaction: tx });
+            }
         });
     }
     async cancelManyByTags(tags, options) {
@@ -332,17 +455,9 @@ 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 })
-                .from(taskTable)
+            await tx.pgTransaction
+                .delete(taskTable)
                 .where(eq(taskTable.namespace, this.#namespace));
-            await repository.session
-                .update(taskTable)
-                .set({ parentId: null })
-                .where(inArray(taskTable.parentId, parentIds))
-                .execute();
-            await repository.hardDeleteManyByQuery({ namespace: this.#namespace });
         });
     }
     async dequeue(options) {
@@ -356,23 +471,31 @@ 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 [];
                     }
                 }
@@ -382,7 +505,11 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             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 });
+                const [runningResult] = await tx.pgTransaction
+                    .select({ count: sqlCount() })
+                    .from(taskTable)
+                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running)));
+                const runningCount = runningResult?.count ?? 0;
                 if (runningCount >= this.globalConcurrency) {
                     return [];
                 }
@@ -393,7 +520,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
              * 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
@@ -401,7 +528,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 .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({
@@ -413,13 +540,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;
@@ -428,19 +555,26 @@ 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, {
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        await session
+            .update(taskTable)
+            .set({
             status: 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`,
-        });
+          WHEN ${taskTable.status} = ${TaskStatus.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
+          ELSE ${taskTable.tries}
+        END`,
+        })
+            .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.id, ids)));
     }
     async rescheduleManyByTags(tags, timestamp, options) {
-        await this.#repository.withOptionalTransaction(options?.transaction).updateManyByQuery(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags))), {
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        await session
+            .update(taskTable)
+            .set({
             status: TaskStatus.Pending,
             token: null,
             scheduleTimestamp: timestamp,
@@ -449,14 +583,14 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
           WHEN ${taskTable.status} = ${TaskStatus.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
           ELSE ${taskTable.tries}
         END`,
-        });
+        })
+            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags))));
     }
     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')}`,
             };
@@ -466,34 +600,35 @@ 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.namespace, this.#namespace), eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+                .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.namespace, this.#namespace), eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)));
+            if (isDefined(existingRow) && isNotNull(existingRow.startTimestamp) && (currentTimestamp() - existingRow.startTimestamp) > this.maxExecutionTime) {
+                await this.fail(task, { message: 'Hard Execution Timeout' }, { fatal: true, transaction: tx });
             }
-            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'),
@@ -501,7 +636,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')}`,
@@ -511,32 +646,42 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             .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')}`)))
             .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(and(eq(taskTable.namespace, this.#namespace), 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.namespace, this.#namespace), 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, { transaction: tx });
         });
     }
     async completeMany(tasks, options) {
@@ -544,40 +689,55 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             return;
         }
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
+            const taskIds = getEntityIds(tasks);
+            const freshTasks = await tx.pgTransaction
+                .select({ id: taskTable.id, unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies })
+                .from(taskTable)
+                .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.id, taskIds)))
+                .for('update');
+            const unresolvedDependencyCountMap = new Map(freshTasks.map((task) => [task.id, task.unresolvedCompleteDependencies]));
             const rows = tasks.map((t, i) => {
                 const result = options?.results?.[i] ?? null;
-                return sql `(${t.id}::uuid, ${t.token}::uuid, ${result}::jsonb)`;
+                const unresolvedCount = unresolvedDependencyCountMap.get(t.id) ?? 0;
+                const nextStatus = (unresolvedCount > 0) ? TaskStatus.WaitingChildren : TaskStatus.Completed;
+                const progress = (nextStatus == TaskStatus.Completed) ? 1 : t.progress;
+                const completeTimestamp = (nextStatus == TaskStatus.Completed) ? TRANSACTION_TIMESTAMP : null;
+                return sql `(${t.id}::uuid, ${t.token}::uuid, ${nextStatus}::text, ${result}::jsonb, ${progress}::numeric, ${completeTimestamp}::timestamptz)`;
             });
-            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'),
+                updateStatus: sql `(status)::text`.as('update_status'),
                 updateResult: sql `(result)::jsonb`.as('update_result'),
+                updateProgress: sql `(progress)::numeric`.as('update_progress'),
+                updateComplete: sql `(complete_timestamp)::timestamptz`.as('update_complete'),
             })
-                .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, result)`));
-            const updated = repository.session.$with('updated').as(() => repository.session
+                .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, status, result, progress, complete_timestamp)`));
+            const updated = tx.pgTransaction.$with('updated').as(() => tx.pgTransaction
                 .update(taskTable)
                 .set({
-                status: TaskStatus.Completed,
+                status: sql `${updates.updateStatus}::${taskStatus}`,
                 token: null,
                 result: updates.updateResult,
-                progress: 1,
-                completeTimestamp: TRANSACTION_TIMESTAMP,
+                progress: sql `${updates.updateProgress}`,
+                completeTimestamp: sql `${updates.updateComplete}`,
                 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
+                .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();
+                }
+                for (const row of updatedRows) {
+                    await this.resolveDependencies(row.id, row.status, { transaction: tx });
+                }
             }
         });
     }
@@ -589,12 +749,9 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             : 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),
@@ -602,28 +759,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.namespace, this.#namespace), 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, { transaction: tx });
         });
     }
     async failMany(tasks, errors, options) {
@@ -631,7 +774,6 @@ 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);
@@ -643,7 +785,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'),
@@ -654,7 +796,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}`,
@@ -667,136 +809,130 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             })
                 .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
+                .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 });
+                for (const row of result) {
+                    await this.resolveDependencies(row.id, row.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) {
+        this.#logger.debug(`Resolving dependencies for task ${id} with status ${status}`);
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
+            // Find all dependents of the task that just finished
+            const dependents = await tx.pgTransaction
                 .select({
-                tag: unnest(taskTable.tags).as('tag'),
-                status: taskTable.status,
-                count: count().as('count'),
+                taskId: taskDependencyTable.taskId,
+                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(and(eq(taskDependencyTable.namespace, this.#namespace), eq(taskDependencyTable.dependencyTaskId, id)));
+            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;
+            for (const dep of dependents) {
+                const isMatched = dep.requiredStatuses.includes(status);
+                const isTerminal = (status == TaskStatus.Completed || status == TaskStatus.Cancelled || status == TaskStatus.Dead);
+                if (isMatched || isTerminal) {
+                    // Dependency resolved (either matched or finished in a different terminal status)
+                    const deletedEdge = await tx.pgTransaction
+                        .delete(taskDependencyTable)
+                        .where(and(eq(taskDependencyTable.namespace, this.#namespace), eq(taskDependencyTable.taskId, dep.taskId), eq(taskDependencyTable.dependencyTaskId, id), eq(taskDependencyTable.type, dep.type)))
+                        .returning();
+                    if (deletedEdge.length > 0) {
+                        const [dependentTask] = await tx.pgTransaction
+                            .select({ failFast: taskTable.failFast, status: taskTable.status })
+                            .from(taskTable)
+                            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, dep.taskId)));
+                        if (isDefined(dependentTask)) {
+                            if (!isMatched && dependentTask.failFast && dependentTask.status != TaskStatus.Dead && dependentTask.status != TaskStatus.Cancelled) {
+                                // Dependency failed and failFast is enabled: fail the dependent task immediately
+                                await this.transitionTask(dep.taskId, TaskStatus.Dead, { error: { code: 'DependencyFailed', message: `Dependency ${id} failed (status: ${status}). Task failed fast because it required one of: ${dep.requiredStatuses.join(', ')}` }, transaction: tx });
+                            }
+                            else {
+                                // Dependency resolved (matched, or failed but no failFast): decrement counter
+                                const [updatedTask] = await tx.pgTransaction
+                                    .update(taskTable)
+                                    .set((dep.type == TaskDependencyType.Schedule)
+                                    ? { unresolvedScheduleDependencies: sql `${taskTable.unresolvedScheduleDependencies} - 1` }
+                                    : { unresolvedCompleteDependencies: sql `${taskTable.unresolvedCompleteDependencies} - 1` })
+                                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, dep.taskId), gt((dep.type == TaskDependencyType.Schedule) ? taskTable.unresolvedScheduleDependencies : taskTable.unresolvedCompleteDependencies, 0)))
+                                    .returning();
+                                if (isDefined(updatedTask)) {
+                                    // Check for transitions
+                                    if (updatedTask.unresolvedScheduleDependencies == 0 || updatedTask.unresolvedCompleteDependencies == 0) {
+                                        await this.evaluateTaskStatus(updatedTask.id, { transaction: tx });
+                                    }
+                                }
+                            }
                         }
                     }
                 }
-                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;
-                    }
-                }
-                // 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;
-                        });
+            }
+        });
+    }
+    async evaluateTaskStatus(id, options) {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
+            const [rawTask] = await tx.pgTransaction
+                .select()
+                .from(taskTable)
+                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id)))
+                .for('update');
+            if (isUndefined(rawTask)) {
+                return;
+            }
+            const task = await this.#repository.mapToEntity(rawTask);
+            if (task.status != TaskStatus.Waiting && task.status != TaskStatus.WaitingChildren && task.status != TaskStatus.Pending) {
+                return;
+            }
+            if (task.unresolvedScheduleDependencies == 0) {
+                if (task.unresolvedCompleteDependencies == 0) {
+                    // If it hasn't started yet (startTimestamp is null), it should be Pending.
+                    // If it has already run (startTimestamp is set), it should be Completed.
+                    const nextStatus = isNull(task.startTimestamp) ? TaskStatus.Pending : TaskStatus.Completed;
+                    if (task.status != nextStatus) {
+                        await this.transitionTask(id, nextStatus, { transaction: tx });
                     }
                 }
-                // 3. Transition
-                if (shouldFail) {
-                    idsToFail.push(waiter.id);
+                else if (task.status == TaskStatus.Waiting && isNull(task.startTimestamp)) {
+                    await this.transitionTask(id, TaskStatus.Pending, { transaction: tx });
                 }
-                else if (isReady) {
-                    if (waiter.scheduleAfterTags.length > 0) {
-                        idsToSchedule.push(waiter.id);
-                        fanInTags.push(...waiter.tags);
-                    }
-                    else if (waiter.completeAfterTags.length > 0) {
-                        idsToComplete.push(waiter.id);
-                        fanInTags.push(...waiter.tags);
-                    }
+                else if (task.status == TaskStatus.Pending && isNotNull(task.startTimestamp)) {
+                    // This case happens if a task was somehow Pending but already has a startTimestamp and now its completion dependencies are resolved
+                    await this.transitionTask(id, TaskStatus.WaitingChildren, { transaction: tx });
                 }
             }
-            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 });
+        });
+    }
+    async transitionTask(id, status, options) {
+        this.#logger.debug(`Transitioning task ${id} to ${status}`);
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
+            const update = {
+                status,
+                completeTimestamp: ((status == TaskStatus.Completed) || (status == TaskStatus.Cancelled) || (status == TaskStatus.Dead)) ? TRANSACTION_TIMESTAMP : null,
+            };
+            if (isNotNullOrUndefined(options?.error)) {
+                update.error = options.error;
             }
-            if (idsToSchedule.length > 0) {
-                await repository.updateMany(idsToSchedule, {
-                    status: TaskStatus.Pending,
-                    scheduleTimestamp: TRANSACTION_TIMESTAMP,
-                });
+            if (status == TaskStatus.Completed) {
+                update.progress = 1;
+                update.token = null;
             }
-            if (idsToComplete.length > 0) {
-                await repository.updateMany(idsToComplete, {
-                    status: TaskStatus.Completed,
-                    completeTimestamp: TRANSACTION_TIMESTAMP,
-                    progress: 1,
-                    token: null,
-                });
-                await this.triggerTagFanIn(fanInTags, { transaction: tx });
+            const [updatedRow] = await tx.pgTransaction
+                .update(taskTable)
+                .set(update)
+                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id)))
+                .returning();
+            if (isDefined(updatedRow)) {
+                await this.resolveDependencies(id, status, { transaction: tx });
+                this.#messageBus.publishAndForget();
             }
         });
     }
@@ -806,26 +942,22 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         // 1. Archival: Move old terminal tasks to archive
         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 childTaskTable = aliasedTable(taskTable, 'childTask');
+                const rowsToArchive = await tx.pgTransaction
+                    .select()
+                    .from(taskTable)
+                    .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, [TaskStatus.Completed, TaskStatus.Dead, TaskStatus.Cancelled]), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(tx.pgTransaction
+                    .select({ id: childTaskTable.id })
+                    .from(childTaskTable)
+                    .where(and(eq(childTaskTable.namespace, this.#namespace), eq(childTaskTable.parentId, 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;
@@ -834,16 +966,15 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         // 2. Purge Archive: Remove very old archived tasks
         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
+                const selection = tx.pgTransaction.$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')}`)))
+                    .where(and(eq(taskArchiveTable.namespace, this.#namespace), lte(taskArchiveTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.archiveRetention, 'milliseconds')}`)))
                     .limit(1000));
-                const result = await repositoryWithTx.session
+                const result = await tx.pgTransaction
                     .with(selection)
                     .delete(taskArchiveTable)
-                    .where(inArray(taskArchiveTable.id, repositoryWithTx.session.select().from(selection)))
+                    .where(inArray(taskArchiveTable.id, tx.pgTransaction.select().from(selection)))
                     .returning({ id: taskArchiveTable.id });
                 return result.length;
             });
@@ -854,16 +985,15 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         // 3. Maintenance Loop
         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
+                const expiredSelection = tx.pgTransaction.$with('expired_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
                     .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Pending), lt(taskTable.timeToLive, TRANSACTION_TIMESTAMP)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
-                const expiredRows = await repositoryWithTx.session
+                const expiredRows = await tx.pgTransaction
                     .with(expiredSelection)
                     .update(taskTable)
                     .set({
@@ -872,40 +1002,43 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     error: { code: 'Expired', message: 'Task expired before processing' },
                     completeTimestamp: TRANSACTION_TIMESTAMP,
                 })
-                    .where(inArray(taskTable.id, repositoryWithTx.session.select().from(expiredSelection)))
-                    .returning({ tags: taskTable.tags });
+                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(expiredSelection)))
+                    .returning({ id: taskTable.id });
                 totalUpdated += expiredRows.length;
                 if (expiredRows.length > 0) {
-                    await this.triggerTagFanIn(expiredRows.flatMap((r) => r.tags), { transaction: tx });
+                    for (const row of expiredRows) {
+                        await this.resolveDependencies(row.id, TaskStatus.Dead, { transaction: tx });
+                    }
                 }
                 // 3.2 Handle Zombie Tasks (Retry)
-                const zombieRetrySelection = repositoryWithTx.session.$with('zombie_retry_selection').as((qb) => qb
+                const zombieRetrySelection = tx.pgTransaction.$with('zombie_retry_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
                     .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), lt(taskTable.tries, this.maxTries)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
-                const zombieRetryRows = await repositoryWithTx.session
+                const zombieRetryRows = await tx.pgTransaction
                     .with(zombieRetrySelection)
                     .update(taskTable)
                     .set({
                     status: TaskStatus.Pending,
                     token: null,
                     visibilityDeadline: null,
+                    startTimestamp: null,
                     scheduleTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.retryDelayMinimum, 'milliseconds')}`, // Simple backoff for zombies
                     error: sql `jsonb_build_object('code', 'VisibilityTimeout', 'message', 'Worker Lost', 'last_error', ${taskTable.error})`,
                 })
-                    .where(inArray(taskTable.id, repositoryWithTx.session.select().from(zombieRetrySelection)))
+                    .where(inArray(taskTable.id, tx.pgTransaction.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
+                const zombieExhaustionSelection = tx.pgTransaction.$with('zombie_exhaustion_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
                     .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), gte(taskTable.tries, this.maxTries)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
-                const exhaustionRows = await repositoryWithTx.session
+                const exhaustionRows = await tx.pgTransaction
                     .with(zombieExhaustionSelection)
                     .update(taskTable)
                     .set({
@@ -915,20 +1048,22 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     completeTimestamp: TRANSACTION_TIMESTAMP,
                     error: sql `jsonb_build_object('code', 'ZombieExhausted', 'message', 'Exceeded max retries after repeated crashes', 'last_error', ${taskTable.error})`,
                 })
-                    .where(inArray(taskTable.id, repositoryWithTx.session.select().from(zombieExhaustionSelection)))
-                    .returning({ tags: taskTable.tags });
+                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(zombieExhaustionSelection)))
+                    .returning({ id: taskTable.id });
                 totalUpdated += exhaustionRows.length;
                 if (exhaustionRows.length > 0) {
-                    await this.triggerTagFanIn(exhaustionRows.flatMap((r) => r.tags), { transaction: tx });
+                    for (const row of exhaustionRows) {
+                        await this.resolveDependencies(row.id, TaskStatus.Dead, { transaction: tx });
+                    }
                 }
                 // 3.4 Handle Hard Timeout
-                const timeoutSelection = repositoryWithTx.session.$with('timeout_selection').as((qb) => qb
+                const timeoutSelection = tx.pgTransaction.$with('timeout_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
                     .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
-                const timeoutRows = await repositoryWithTx.session
+                const timeoutRows = await tx.pgTransaction
                     .with(timeoutSelection)
                     .update(taskTable)
                     .set({
@@ -938,27 +1073,29 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     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})`,
                 })
-                    .where(inArray(taskTable.id, repositoryWithTx.session.select().from(timeoutSelection)))
-                    .returning({ tags: taskTable.tags });
+                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(timeoutSelection)))
+                    .returning({ id: taskTable.id });
                 totalUpdated += timeoutRows.length;
                 if (timeoutRows.length > 0) {
-                    await this.triggerTagFanIn(timeoutRows.flatMap((r) => r.tags), { transaction: tx });
+                    for (const row of timeoutRows) {
+                        await this.resolveDependencies(row.id, TaskStatus.Dead, { transaction: tx });
+                    }
                 }
                 // 3.5 Promote Priority (Aging)
-                const agingSelection = repositoryWithTx.session.$with('aging_selection').as((qb) => qb
+                const agingSelection = tx.pgTransaction.$with('aging_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
                     .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Pending), lt(taskTable.priorityAgeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.priorityAgingInterval, 'milliseconds')}`)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
-                const agingRows = await repositoryWithTx.session
+                const agingRows = await tx.pgTransaction
                     .with(agingSelection)
                     .update(taskTable)
                     .set({
                     priority: sql `${taskTable.priority} - ${this.priorityAgingStep}`,
                     priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
                 })
-                    .where(inArray(taskTable.id, repositoryWithTx.session.select().from(agingSelection)))
+                    .where(inArray(taskTable.id, tx.pgTransaction.select().from(agingSelection)))
                     .returning({ id: taskTable.id });
                 totalUpdated += agingRows.length;
                 return totalUpdated;
@@ -979,13 +1116,13 @@ 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.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))));
     }
     notify() {
         this.#messageBus.publishAndForget();
@@ -1014,36 +1151,6 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             }
         }
     }
-    /**
-     * @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;
-            }
-            try {
-                await this.resolveDependencies(task.data.targetTags);
-                await this.#internalThis.complete(task, { transaction: options?.transaction });
-                processedCount++;
-            }
-            catch (error) {
-                await this.#internalThis.fail(task, error, { transaction: options?.transaction });
-                throw error;
-            }
-        }
-        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 *getBatchConsumer(size, cancellationSignal, options) {
         const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
         while (cancellationSignal.isUnset) {