@tstdl/base 0.93.86 → 0.93.89

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

@@ -0,0 +1,1054 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    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 { CancellationSignal } from '../../cancellation/index.js';
+import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/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 { RateLimiter } from '../../rate-limit/index.js';
+import { createArray, distinct, toArray } from '../../utils/array/array.js';
+import { digest } from '../../utils/cryptography.js';
+import { currentTimestamp } from '../../utils/date-time.js';
+import { serializeError } from '../../utils/format-error.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, TaskQueue, TaskResult, TaskState } from '../task-queue.js';
+import { PostgresTaskQueueModuleConfig } from './module.js';
+import { taskArchive as taskArchiveTable, taskState, task as taskTable } from './schemas.js';
+import { PostgresTask, PostgresTaskArchive } from './task.model.js';
+let PostgresQueue = class PostgresQueue extends TaskQueue {
+    #repository = injectRepository(PostgresTask);
+    #archiveRepository = injectRepository(PostgresTaskArchive);
+    #config = this.config;
+    #namespace = isString(this.#config) ? this.#config : this.#config.namespace;
+    #messageBus = inject((MessageBus), `PostgresTaskQueue:${this.#namespace}`);
+    #logger = inject(Logger, `PostgresTaskQueue:${this.#namespace}`);
+    #cancellationSignal = inject(CancellationSignal);
+    #rateLimiter = inject(RateLimiter, {
+        resource: this.#namespace,
+        burstCapacity: this.#config.rateLimit ?? defaultQueueConfig.rateLimit,
+        refillIntervalMs: this.#config.rateInterval ?? defaultQueueConfig.rateInterval,
+    });
+    #circuitBreaker = inject(CircuitBreaker, {
+        key: this.#namespace,
+        threshold: this.#config.circuitBreakerThreshold ?? defaultQueueConfig.circuitBreakerThreshold,
+        resetTimeout: this.#config.circuitBreakerResetTimeout ?? defaultQueueConfig.circuitBreakerResetTimeout,
+    });
+    visibilityTimeout = this.#config.visibilityTimeout ?? defaultQueueConfig.visibilityTimeout;
+    maxExecutionTime = this.#config.maxExecutionTime ?? defaultQueueConfig.maxExecutionTime;
+    maxTries = this.#config.maxTries ?? defaultQueueConfig.maxTries;
+    retryDelayMinimum = this.#config.retryDelayMinimum ?? defaultQueueConfig.retryDelayMinimum;
+    retryDelayMaximum = this.#config.retryDelayMaximum ?? defaultQueueConfig.retryDelayMaximum;
+    retryDelayGrowth = this.#config.retryDelayGrowth ?? defaultQueueConfig.retryDelayGrowth;
+    retention = this.#config.retention ?? defaultQueueConfig.retention;
+    archiveRetention = this.#config.archiveRetention ?? defaultQueueConfig.archiveRetention;
+    priorityAgingInterval = this.#config.priorityAgingInterval ?? defaultQueueConfig.priorityAgingInterval;
+    priorityAgingStep = this.#config.priorityAgingStep ?? defaultQueueConfig.priorityAgingStep;
+    defaultTimeToLive = this.#config.defaultTimeToLive ?? defaultQueueConfig.defaultTimeToLive;
+    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: TaskState.Pending,
+        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`,
+        failFast: sql `excluded.fail_fast`,
+        dependencyJoinMode: sql `excluded.dependency_join_mode`,
+        dependencyTriggerStates: sql `excluded.dependency_trigger_states`,
+        tries: 0,
+        creationTimestamp: TRANSACTION_TIMESTAMP,
+        priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
+        scheduleTimestamp: sql `excluded.schedule_timestamp`,
+        startTimestamp: null,
+        timeToLive: sql `excluded.time_to_live`,
+        visibilityDeadline: null,
+        completeTimestamp: null,
+        progress: 0,
+        data: sql `excluded.data`,
+        state: null,
+        error: null,
+        result: null,
+    };
+    [afterResolve]() {
+        if (!this.isInTransaction) {
+            this.startSystemWorker();
+            void this.maintenanceLoop();
+        }
+    }
+    async enqueue(type, data, options) {
+        const tasks = await this.enqueueMany([{ type, data, ...options }], { replace: options?.replace ?? false, returnTasks: true, transaction: options?.transaction });
+        return tasks[0];
+    }
+    async enqueueMany(items, options) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            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;
+                return {
+                    namespace: this.#namespace,
+                    type: item.type,
+                    status: hasDependencies ? TaskState.Waiting : TaskState.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,
+                    dependencyTriggerStates: item.dependencyTriggerStates ?? [TaskState.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,
+                };
+            });
+            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 newTransaction = __addDisposableResource(env_1, (mustUseTransaction && isUndefined(options?.transaction)) ? await this.#repository.startTransaction() : undefined, true);
+            const transaction = newTransaction ?? options?.transaction;
+            const tasks = [];
+            if (itemsWithoutIdempotency.length > 0) {
+                const insertedTasks = await this.#repository.withOptionalTransaction(transaction).insertMany(itemsWithoutIdempotency);
+                tasks.push(...insertedTasks);
+            }
+            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 },
+                        });
+                        tasks.push(...existingTasks);
+                    }
+                }
+            }
+            await newTransaction?.commit();
+            this.#messageBus.publishAndForget();
+            const anyWaiting = tasks.some((t) => t.status == TaskState.Waiting);
+            if (anyWaiting) {
+                const tagsToTrigger = distinct(tasks.filter((t) => t.status == TaskState.Waiting).flatMap((t) => [...t.completeAfterTags, ...t.scheduleAfterTags]));
+                await this.triggerTagFanIn(tagsToTrigger, transaction);
+            }
+            if (options?.returnTasks == true) {
+                return tasks;
+            }
+            return undefined;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async has(id) {
+        return await this.#repository.hasByQuery({ namespace: this.#namespace, id });
+    }
+    async countByTags(tags) {
+        const tagArray = toArray(tags);
+        if (tagArray.length == 0) {
+            return 0;
+        }
+        const [result] = await this.#repository.session
+            .select({ count: count() })
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)))
+            .execute();
+        return result?.count ?? 0;
+    }
+    async getTask(id) {
+        const active = await this.#repository.tryLoadByQuery({ namespace: this.#namespace, id });
+        if (isDefined(active)) {
+            return active;
+        }
+        return await this.#archiveRepository.tryLoadByQuery({ namespace: this.#namespace, id });
+    }
+    async getManyByTags(tags) {
+        const tagArray = toArray(tags);
+        if (tagArray.length == 0) {
+            return [];
+        }
+        const rows = await this.#repository.session
+            .select()
+            .from(taskTable)
+            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)))
+            .execute();
+        return await this.#repository.mapManyToEntity(rows);
+    }
+    async getTree(idOrIds, transaction) {
+        const ids = toArray(idOrIds);
+        return await this.getTreeByQuery({ id: { $in: ids } }, transaction);
+    }
+    async getTreeByQuery(query, transaction) {
+        return await this.#repository.useTransaction(transaction, async (tx) => {
+            const repositoryWithTransaction = this.#repository.withTransaction(tx);
+            const roots = await repositoryWithTransaction.loadManyByQuery(query);
+            if (roots.length == 0) {
+                return [];
+            }
+            const rootIds = roots.map((t) => t.id);
+            const rawResult = await repositoryWithTransaction.session.execute(sql `
+        WITH RECURSIVE task_tree AS (
+          SELECT *, 0 as depth
+          FROM ${taskTable}
+          WHERE ${inArray(taskTable.id, rootIds)}
+
+          UNION
+
+          SELECT child.*, parent.depth + 1
+          FROM ${taskTable} child
+          JOIN task_tree parent ON child.parent_id = parent.id
+          WHERE parent.depth < 10000
+        )
+        SELECT * FROM task_tree
+      `);
+            const rows = rawResult.rows ?? rawResult;
+            return await repositoryWithTransaction.mapManyToEntity(rows);
+        });
+    }
+    async cancel(id, transaction) {
+        await this.cancelMany([id], transaction);
+    }
+    async cancelMany(ids, transaction) {
+        await this.#repository.useTransaction(transaction, async (tx) => {
+            const tree = await this.getTree(ids, tx);
+            const treeIds = tree.map((task) => task.id);
+            if (treeIds.length == 0) {
+                return;
+            }
+            await this.#repository.withTransaction(tx).updateMany(treeIds, {
+                status: TaskState.Cancelled,
+                token: null,
+                completeTimestamp: TRANSACTION_TIMESTAMP,
+            });
+            const tags = tree.flatMap((t) => t.tags);
+            await this.triggerTagFanIn(tags, tx);
+        });
+    }
+    async cancelManyByTags(tags) {
+        await this.#repository.transaction(async (tx) => {
+            const tasks = await this.getManyByTags(tags);
+            const ids = tasks.map((t) => t.id);
+            await this.cancelMany(ids, tx);
+        });
+    }
+    async clear() {
+        await this.#repository.transaction(async (tx) => {
+            const repository = this.#repository.withTransaction(tx);
+            const parentIds = repository.session
+                .select({ id: taskTable.id })
+                .from(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) {
+        const tasks = await this.dequeueMany(1, options);
+        if (tasks.length == 0) {
+            return undefined;
+        }
+        return tasks[0];
+    }
+    async dequeueMany(count, options) {
+        // 1. Flow Control
+        const forceDequeue = options?.forceDequeue ?? false;
+        let circuitBreakerResult;
+        if (!forceDequeue) {
+            circuitBreakerResult = await this.#circuitBreaker.check();
+            if (!circuitBreakerResult.allowed) {
+                return [];
+            }
+            const rateLimitAllowed = await this.#rateLimiter.tryAcquire(this.#namespace, count);
+            if (!rateLimitAllowed) {
+                return [];
+            }
+        }
+        const tasks = await this.#repository.transaction(async (tx) => {
+            const repository = this.#repository.withTransaction(tx);
+            let effectiveCount = count;
+            if (!forceDequeue && circuitBreakerResult?.state == CircuitBreakerState.HalfOpen) {
+                if (circuitBreakerResult.isProbe != true) {
+                    const runningCount = await repository.countByQuery({ namespace: this.#namespace, status: TaskState.Running });
+                    if (runningCount > 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: TaskState.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
+                .select({ id: taskTable.id })
+                .from(taskTable)
+                .where(and(eq(taskTable.namespace, this.#namespace), lte(taskTable.scheduleTimestamp, TRANSACTION_TIMESTAMP), eq(taskTable.status, TaskState.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
+            ))
+                .orderBy(asc(taskTable.priority), asc(taskTable.scheduleTimestamp))
+                .limit(effectiveCount)
+                .for('update', { skipLocked: true }));
+            const rows = await repository.session
+                .with(selection)
+                .update(taskTable)
+                .set({
+                status: TaskState.Running,
+                token: RANDOM_UUID_V4,
+                visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`,
+                startTimestamp: TRANSACTION_TIMESTAMP,
+                // If it was PENDING, it's the first try (tries=0) -> tries=1.
+                // If it was RUNNING (Zombie), previous try failed -> increment tries.
+                tries: sql `${taskTable.tries} + 1`,
+            })
+                .where(inArray(taskTable.id, repository.session.select().from(selection)))
+                .returning();
+            return await this.#repository.mapManyToEntity(rows);
+        });
+        // 3. Compensation
+        if (!forceDequeue && (tasks.length < count)) {
+            const shortfall = count - tasks.length;
+            await this.#rateLimiter.refund(this.#namespace, shortfall);
+        }
+        return tasks;
+    }
+    async reschedule(id, timestamp, transaction) {
+        await this.rescheduleMany([id], timestamp, transaction);
+    }
+    async rescheduleMany(ids, timestamp, transaction) {
+        await this.#repository.withOptionalTransaction(transaction).updateMany(ids, {
+            status: TaskState.Pending,
+            token: null,
+            scheduleTimestamp: timestamp,
+            visibilityDeadline: null,
+            tries: sql `CASE
+        WHEN ${taskTable.status} = ${TaskState.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
+        ELSE ${taskTable.tries}
+      END`,
+        });
+    }
+    async rescheduleManyByTags(tags, timestamp, transaction) {
+        await this.#repository.withOptionalTransaction(transaction).updateManyByQuery(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags))), {
+            status: TaskState.Pending,
+            token: null,
+            scheduleTimestamp: timestamp,
+            visibilityDeadline: null,
+            tries: sql `CASE
+          WHEN ${taskTable.status} = ${TaskState.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
+          ELSE ${taskTable.tries}
+        END`,
+        });
+    }
+    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')}`,
+            };
+            if (isDefined(options?.progress)) {
+                update.progress = options.progress;
+            }
+            if (isDefined(options?.state)) {
+                update.state = options.state;
+            }
+            const result = await repository.tryUpdateByQuery({
+                namespace: this.#namespace,
+                id: task.id,
+                status: TaskState.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: TaskState.Running, token: task.token });
+                if (isDefined(existing) && isNotNull(existing.startTimestamp) && (currentTimestamp() - existing.startTimestamp) > this.maxExecutionTime) {
+                    await this.fail(task, { message: 'Hard Execution Timeout' }, true, tx);
+                }
+            }
+            return result;
+        });
+    }
+    async touchMany(tasks, progresses, states, transaction) {
+        if (tasks.length == 0) {
+            return [];
+        }
+        const repository = this.#repository.withOptionalTransaction(transaction);
+        const rows = tasks.map((t, i) => {
+            const progress = progresses?.[i] ?? null;
+            const state = states?.[i] ?? null;
+            return sql `(${t.id}::uuid, ${t.token}::uuid, ${progress}::numeric, ${state}::jsonb)`;
+        });
+        const updates = repository.session.$with('updates').as((qb) => qb
+            .select({
+            updateId: sql `(id)::uuid`.as('update_id'),
+            updateToken: sql `(token)::uuid`.as('update_token'),
+            updateProgress: sql `(progress)::numeric`.as('update_progress'),
+            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
+            .update(taskTable)
+            .set({
+            visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`,
+            progress: coalesce(updates.updateProgress, taskTable.progress),
+            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, TaskState.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+            .returning({ id: taskTable.id }));
+        const result = await repository.session
+            .with(updates, updated)
+            .select({ id: updated.id })
+            .from(updated)
+            .execute();
+        return result.map((r) => r.id);
+    }
+    async complete(task, result, transaction) {
+        await this.#repository.useTransaction(transaction, async (tx) => {
+            const repository = this.#repository.withTransaction(tx);
+            const updatedTask = await repository.tryUpdateByQuery({
+                id: task.id,
+                token: task.token,
+            }, {
+                status: TaskState.Completed,
+                token: null,
+                result: result,
+                progress: 1,
+                completeTimestamp: TRANSACTION_TIMESTAMP,
+                visibilityDeadline: null,
+            });
+            if (isUndefined(updatedTask)) {
+                return;
+            }
+            await this.#circuitBreaker.recordSuccess();
+            await this.triggerTagFanIn(task.tags, tx);
+        });
+    }
+    async completeMany(tasks, results, transaction) {
+        if (tasks.length == 0) {
+            return;
+        }
+        await this.#repository.useTransaction(transaction, async (tx) => {
+            const repository = this.#repository.withTransaction(tx);
+            const rows = tasks.map((t, i) => {
+                const result = isDefined(results) ? results[i] : null;
+                return sql `(${t.id}::uuid, ${t.token}::uuid, ${result}::jsonb)`;
+            });
+            const updates = repository.session.$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'),
+            })
+                .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, result)`));
+            const updated = repository.session.$with('updated').as(() => repository.session
+                .update(taskTable)
+                .set({
+                status: TaskState.Completed,
+                token: null,
+                result: updates.updateResult,
+                progress: 1,
+                completeTimestamp: 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
+                .with(updates, updated)
+                .select({ id: updated.id, tags: updated.tags })
+                .from(updated)
+                .execute();
+            if (updatedRows.length > 0) {
+                await this.#circuitBreaker.recordSuccess();
+                const tags = updatedRows.flatMap((t) => t.tags);
+                await this.triggerTagFanIn(tags, tx);
+            }
+        });
+    }
+    async fail(task, error, fatal = false, transaction) {
+        const isRetryable = !fatal && (task.tries < this.maxTries);
+        const nextStatus = isRetryable ? TaskState.Pending : TaskState.Dead;
+        const delay = isRetryable
+            ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
+            : 0;
+        const nextSchedule = currentTimestamp() + delay;
+        await this.#repository.useTransaction(transaction, async (tx) => {
+            const updatedTask = await this.#repository.withTransaction(tx).tryUpdateByQuery({
+                namespace: this.#namespace,
+                id: task.id,
+                token: task.token,
+                tries: task.tries,
+            }, {
+                status: nextStatus,
+                token: null,
+                error: serializeError(error),
+                visibilityDeadline: null,
+                scheduleTimestamp: nextSchedule,
+                startTimestamp: null,
+                completeTimestamp: (nextStatus == TaskState.Dead) ? TRANSACTION_TIMESTAMP : null,
+            });
+            if (isUndefined(updatedTask)) {
+                return;
+            }
+            await this.#circuitBreaker.recordFailure();
+            if (nextStatus == TaskState.Dead) {
+                await this.triggerTagFanIn(task.tags, tx);
+            }
+        });
+    }
+    async triggerTagFanIn(tags, transaction) {
+        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.enqueue('[SystemWorker]:FanIn', { targetTags: distinctSortedTags }, {
+            priority: 0,
+            idempotencyKey,
+            replace: true,
+            transaction,
+        });
+    }
+    async failMany(tasks, errors, transaction) {
+        if (tasks.length == 0) {
+            return;
+        }
+        await this.#repository.useTransaction(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 ? TaskState.Pending : TaskState.Dead;
+                const delay = isRetryable
+                    ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
+                    : 0;
+                const nextSchedule = new Date(currentTimestamp() + delay);
+                const completeTimestamp = (nextStatus == TaskState.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
+                .select({
+                updateId: sql `(id)::uuid`.as('update_id'),
+                updateToken: sql `(token)::uuid`.as('update_token'),
+                updateTries: sql `(tries)::int`.as('update_tries'),
+                updateStatus: sql `(status)::text`.as('update_status'),
+                updateError: sql `(error)::jsonb`.as('update_error'),
+                updateSchedule: sql `(schedule_timestamp)::timestamptz`.as('update_schedule'),
+                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
+                .update(taskTable)
+                .set({
+                status: sql `${updates.updateStatus}::${taskState}`,
+                token: null,
+                error: sql `${updates.updateError}`,
+                visibilityDeadline: null,
+                scheduleTimestamp: sql `${updates.updateSchedule}`,
+                startTimestamp: null,
+                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
+                .with(updates, updated)
+                .select()
+                .from(updated)
+                .execute();
+            if (result.length > 0) {
+                await Promise.all(createArray(result.length, async () => await this.#circuitBreaker.recordFailure()));
+                const deadTags = result
+                    .filter((r) => r.status == TaskState.Dead)
+                    .flatMap((r) => r.tags);
+                await this.triggerTagFanIn(deadTags, 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, TaskState.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
+                .select({
+                tag: unnest(taskTable.tags).as('tag'),
+                status: taskTable.status,
+                count: count().as('count'),
+            })
+                .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);
+            }
+            const getCount = (tags, states) => {
+                let sum = 0;
+                for (const tag of tags) {
+                    const stats = tagStats.get(tag);
+                    if (isDefined(stats)) {
+                        for (const state of states) {
+                            sum += stats.get(state) ?? 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, [TaskState.Dead, TaskState.Cancelled]) > 0) {
+                        shouldFail = true;
+                    }
+                }
+                // 2. Check Trigger Conditions
+                if (!shouldFail) {
+                    if (waiter.dependencyJoinMode == DependencyJoinMode.Or) {
+                        if (getCount(requiredTags, waiter.dependencyTriggerStates) > 0) {
+                            isReady = true;
+                        }
+                    }
+                    else if (waiter.dependencyJoinMode == DependencyJoinMode.And) {
+                        // For AND, we need "No active tasks".
+                        // Active = Pending, Running, Waiting.
+                        if (getCount(requiredTags, [TaskState.Pending, TaskState.Running, TaskState.Waiting]) == 0) {
+                            isReady = true;
+                        }
+                    }
+                }
+                // 3. Transition
+                if (shouldFail) {
+                    idsToFail.push(waiter.id);
+                }
+                else if (isReady) {
+                    if (waiter.scheduleAfterTags.length > 0) {
+                        idsToSchedule.push(waiter.id);
+                    }
+                    else {
+                        idsToComplete.push(waiter.id);
+                        fanInTags.push(...waiter.tags);
+                    }
+                }
+            }
+            if (idsToFail.length > 0) {
+                const rows = await repository.updateMany(idsToFail, {
+                    status: TaskState.Dead,
+                    error: { code: 'DependencyFailed' },
+                    completeTimestamp: TRANSACTION_TIMESTAMP,
+                });
+                const tags = rows.flatMap((r) => r.tags);
+                await this.triggerTagFanIn(tags, tx);
+            }
+            if (idsToSchedule.length > 0) {
+                await repository.updateMany(idsToSchedule, {
+                    status: TaskState.Pending,
+                    scheduleTimestamp: TRANSACTION_TIMESTAMP,
+                });
+            }
+            if (idsToComplete.length > 0) {
+                await repository.updateMany(idsToComplete, {
+                    status: TaskState.Completed,
+                    completeTimestamp: TRANSACTION_TIMESTAMP,
+                    progress: 1,
+                    token: null,
+                });
+                await this.triggerTagFanIn(fanInTags, tx);
+            }
+        });
+    }
+    async maintenance() {
+        const repository = this.#repository;
+        const archiveRepository = this.#archiveRepository;
+        // 1. Archival: Move old terminal tasks to archive
+        while (true) {
+            const archivedCount = await repository.transaction(async (tx) => {
+                const repositoryWithTx = repository.withTransaction(tx);
+                const archiveRepositoryWithTx = archiveRepository.withTransaction(tx);
+                const tasksToArchive = await repositoryWithTx.loadManyByQuery({
+                    $and: [
+                        {
+                            namespace: this.#namespace,
+                            status: { $in: [TaskState.Completed, TaskState.Dead, TaskState.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));
+                }
+                return tasksToArchive.length;
+            });
+            if (archivedCount < 1000) {
+                break;
+            }
+        }
+        // 2. Purge Archive: Remove very old archived tasks
+        while (true) {
+            const deletedArchiveCount = await archiveRepository.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) {
+                break;
+            }
+        }
+        // 3. Maintenance Loop
+        while (true) {
+            const maintenanceCount = await repository.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, TaskState.Pending), lt(taskTable.timeToLive, TRANSACTION_TIMESTAMP)))
+                    .limit(1000)
+                    .for('update', { skipLocked: true }));
+                const expiredRows = await repositoryWithTx.session
+                    .with(expiredSelection)
+                    .update(taskTable)
+                    .set({
+                    status: TaskState.Dead,
+                    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;
+                if (expiredRows.length > 0) {
+                    await this.triggerTagFanIn(expiredRows.flatMap((r) => r.tags), 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, TaskState.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: TaskState.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, TaskState.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), gte(taskTable.tries, this.maxTries)))
+                    .limit(1000)
+                    .for('update', { skipLocked: true }));
+                const exhaustionRows = await repositoryWithTx.session
+                    .with(zombieExhaustionSelection)
+                    .update(taskTable)
+                    .set({
+                    status: TaskState.Dead,
+                    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})`,
+                })
+                    .where(inArray(taskTable.id, repositoryWithTx.session.select().from(zombieExhaustionSelection)))
+                    .returning({ tags: taskTable.tags });
+                totalUpdated += exhaustionRows.length;
+                if (exhaustionRows.length > 0) {
+                    await this.triggerTagFanIn(exhaustionRows.flatMap((r) => r.tags), 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, TaskState.Running), lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+                    .limit(1000)
+                    .for('update', { skipLocked: true }));
+                const timeoutRows = await repositoryWithTx.session
+                    .with(timeoutSelection)
+                    .update(taskTable)
+                    .set({
+                    status: TaskState.Dead,
+                    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})`,
+                })
+                    .where(inArray(taskTable.id, repositoryWithTx.session.select().from(timeoutSelection)))
+                    .returning({ tags: taskTable.tags });
+                totalUpdated += timeoutRows.length;
+                if (timeoutRows.length > 0) {
+                    await this.triggerTagFanIn(timeoutRows.flatMap((r) => r.tags), 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, TaskState.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;
+            });
+            if (maintenanceCount == 0) {
+                break;
+            }
+        }
+    }
+    async restart(id, options) {
+        const repository = this.#repository.withOptionalTransaction(options?.transaction);
+        await repository.session
+            .update(taskTable)
+            .set({
+            status: TaskState.Pending,
+            token: null,
+            error: null,
+            result: null,
+            scheduleTimestamp: TRANSACTION_TIMESTAMP,
+            completeTimestamp: 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, TaskState.Pending), eq(taskTable.status, TaskState.Completed), eq(taskTable.status, TaskState.Cancelled), eq(taskTable.status, TaskState.Dead), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))))
+            .execute();
+    }
+    async *getConsumer(cancellationSignal, options) {
+        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        while (cancellationSignal.isUnset) {
+            const task = await this.dequeue(options);
+            if (isDefined(task)) {
+                yield task;
+                continue;
+            }
+            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+        }
+    }
+    async maintenanceLoop() {
+        while (this.#cancellationSignal.isUnset) {
+            try {
+                await this.maintenance();
+            }
+            catch (error) {
+                this.#logger.error('Error during maintenance loop', error);
+            }
+            finally {
+                await cancelableTimeout(30 * millisecondsPerSecond, this.#cancellationSignal);
+            }
+        }
+    }
+    async processPendingFanIn(transaction) {
+        let processedCount = 0;
+        while (true) {
+            const task = await this.dequeue({ types: ['[SystemWorker]:FanIn'], forceDequeue: true });
+            if (isUndefined(task)) {
+                break;
+            }
+            try {
+                const data = task.data;
+                await this.resolveDependencies(data.targetTags);
+                await this.complete(task, undefined, transaction);
+                processedCount++;
+            }
+            catch (error) {
+                await this.fail(task, error, false, transaction);
+                throw error;
+            }
+        }
+        return processedCount;
+    }
+    startSystemWorker() {
+        this.process({ concurrency: 1, cancellationSignal: this.#cancellationSignal, forceDequeue: true, types: ['[SystemWorker]:FanIn'] }, async (context) => {
+            const data = context.data;
+            await this.resolveDependencies(data.targetTags);
+            return TaskResult.Complete();
+        });
+    }
+    async *getBatchConsumer(size, cancellationSignal, options) {
+        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        while (cancellationSignal.isUnset) {
+            const tasks = await this.dequeueMany(size, options);
+            if (tasks.length > 0) {
+                yield tasks;
+                continue;
+            }
+            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+        }
+    }
+};
+PostgresQueue = __decorate([
+    Singleton({
+        argumentIdentityProvider: JSON.stringify,
+        providers: [
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresTaskQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+        ],
+    })
+], PostgresQueue);
+export { PostgresQueue };