@tstdl/base 0.93.92 → 0.93.93

package/task-queue/task-queue.js

@@ -9,26 +9,26 @@ import { isDefined, isString } from '../utils/type-guards.js';
 import { millisecondsPerDay, millisecondsPerMinute, millisecondsPerSecond } from '../utils/units.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
 import { BatchTaskContext } from './task-context.js';
-export class TaskResult {
+export class TaskProcessResult {
     payload;
     constructor(payload) {
         this.payload = payload;
     }
     static Complete(result) {
-        return new TaskResult({ action: 'complete', result });
+        return new TaskProcessResult({ action: 'complete', result });
     }
     static Fail(error, fatal = false) {
-        return new TaskResult({ action: 'fail', error, fatal });
+        return new TaskProcessResult({ action: 'fail', error, fatal });
     }
     static RescheduleTo(timestamp) {
-        return new TaskResult({ action: 'reschedule', timestamp });
+        return new TaskProcessResult({ action: 'reschedule', timestamp });
     }
     static RescheduleBy(milliseconds) {
         const timestamp = currentTimestamp() + milliseconds;
         return this.RescheduleTo(timestamp);
     }
 }
-export const TaskState = defineEnum('TaskState', {
+export const TaskStatus = defineEnum('TaskStatus', {
     /**
      * The task is waiting to be processed.
      */
@@ -152,7 +152,7 @@ export class TaskQueue extends Transactional {
                         const result = results[i];
                         switch (result.payload.action) {
                             case 'complete':
-                                completions.push({ task, result: result.payload });
+                                completions.push({ task, result: result.payload.result });
                                 break;
                             case 'fail':
                                 failures.push({ task, error: result.payload.error, fatal: result.payload.fatal });
@@ -166,12 +166,12 @@ export class TaskQueue extends Transactional {
                     }
                     if (completions.length > 0) {
                         context.logger.verbose(`Completing ${completions.length} tasks`);
-                        await this.completeMany(completions.map((c) => c.task), completions.map((c) => c.result));
+                        await this.completeMany(completions.map((c) => c.task), { results: completions.map((c) => c.result) });
                     }
                     if (failures.length > 0) {
                         context.logger.verbose(`Failing ${failures.length} tasks`);
                         for (const item of failures) {
-                            await this.fail(item.task, item.error, item.fatal);
+                            await this.fail(item.task, item.error, { fatal: item.fatal });
                         }
                     }
                     if (reschedules.length > 0) {

package/task-queue/tests/complex.test.js

@@ -1,5 +1,5 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { DependencyJoinMode, TaskQueueProvider, TaskState } from '../../task-queue/index.js';
+import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../unit-test/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
@@ -50,15 +50,15 @@ describe('Complex Queue Scenarios', () => {
             const taskC = await queue.enqueue('C', {}, { tags: ['tag-c'], scheduleAfterTags: ['tag-a'] });
             // A runs first
             const taskA = await queue.enqueue('A', {}, { tags: ['tag-a'] });
-            expect(taskD.status).toBe(TaskState.Waiting);
-            expect(taskB.status).toBe(TaskState.Waiting);
-            expect(taskC.status).toBe(TaskState.Waiting);
-            expect(taskA.status).toBe(TaskState.Pending);
+            expect(taskD.status).toBe(TaskStatus.Waiting);
+            expect(taskB.status).toBe(TaskStatus.Waiting);
+            expect(taskC.status).toBe(TaskStatus.Waiting);
+            expect(taskA.status).toBe(TaskStatus.Pending);
             // Process A
             const dA = await queue.dequeue({ types: ['A'] });
             await queue.complete(dA);
-            await waitForStatus(taskB.id, TaskState.Pending);
-            await waitForStatus(taskC.id, TaskState.Pending);
+            await waitForStatus(taskB.id, TaskStatus.Pending);
+            await waitForStatus(taskC.id, TaskStatus.Pending);
             // Process B
             const dB = await queue.dequeue({ types: ['B'] });
             await queue.complete(dB);
@@ -66,14 +66,14 @@ describe('Complex Queue Scenarios', () => {
             await queue.processPendingFanIn();
             // D still waiting (needs C)
             const uD2 = await queue.getTask(taskD.id);
-            expect(uD2?.status).toBe(TaskState.Waiting);
+            expect(uD2?.status).toBe(TaskStatus.Waiting);
             // Process C
             const dC = await queue.dequeue({ types: ['C'] });
             await queue.complete(dC);
-            await waitForStatus(taskD.id, TaskState.Pending);
+            await waitForStatus(taskD.id, TaskStatus.Pending);
             // D should be Pending
             const uD3 = await queue.getTask(taskD.id);
-            expect(uD3?.status).toBe(TaskState.Pending);
+            expect(uD3?.status).toBe(TaskStatus.Pending);
         });
         it('should handle Deep Chain (A -> B -> C -> D)', async () => {
             const D = await queue.enqueue('D', {}, { scheduleAfterTags: ['C'] });
@@ -82,14 +82,14 @@ describe('Complex Queue Scenarios', () => {
             const A = await queue.enqueue('A', {}, { tags: ['A'] });
             // Run A
             await queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(B.id, TaskState.Pending);
+            await waitForStatus(B.id, TaskStatus.Pending);
             // Run B
             await queue.complete((await queue.dequeue({ types: ['B'] })));
-            await waitForStatus(C.id, TaskState.Pending);
+            await waitForStatus(C.id, TaskStatus.Pending);
             // Run C
             await queue.complete((await queue.dequeue({ types: ['C'] })));
-            await waitForStatus(D.id, TaskState.Pending);
-            expect((await queue.getTask(D.id))?.status).toBe(TaskState.Pending);
+            await waitForStatus(D.id, TaskStatus.Pending);
+            expect((await queue.getTask(D.id))?.status).toBe(TaskStatus.Pending);
         });
         it('should propagate cancellation down the dependency tree', async () => {
             // Use parentId for explicit tree structure which `cancel` supports
@@ -97,9 +97,9 @@ describe('Complex Queue Scenarios', () => {
             const child = await queue.enqueue('child', {}, { parentId: root.id });
             const grandChild = await queue.enqueue('grand', {}, { parentId: child.id });
             await queue.cancel(root.id);
-            expect((await queue.getTask(root.id))?.status).toBe(TaskState.Cancelled);
-            expect((await queue.getTask(child.id))?.status).toBe(TaskState.Cancelled);
-            expect((await queue.getTask(grandChild.id))?.status).toBe(TaskState.Cancelled);
+            expect((await queue.getTask(root.id))?.status).toBe(TaskStatus.Cancelled);
+            expect((await queue.getTask(child.id))?.status).toBe(TaskStatus.Cancelled);
+            expect((await queue.getTask(grandChild.id))?.status).toBe(TaskStatus.Cancelled);
         });
     });
     describe('Scheduling & Priorities', () => {
@@ -129,7 +129,7 @@ describe('Complex Queue Scenarios', () => {
             const u2 = await queue.getTask(task.id);
             expect(u2?.tries).toBe(2);
             const now = currentTimestamp();
-            expect(u2.scheduleTimestamp).toBeGreaterThan(now + 300);
+            expect(u2.scheduleTimestamp > now + 300).toBe(true);
         });
     });
     describe('Rate Limiting & Concurrency', () => {
@@ -177,15 +177,15 @@ describe('Complex Queue Scenarios', () => {
             // Verify it is in main table
             const before = await archiveQueue.getTask(task.id);
             expect(before).toBeDefined();
-            expect(before?.status).toBe(TaskState.Completed);
-            expect(before?.completeTimestamp).toBeGreaterThan(0);
+            expect(before?.status).toBe(TaskStatus.Completed);
+            expect(before.completeTimestamp > 0).toBe(true);
             // Wait for retention (100ms).
             await timeout(500);
             await archiveQueue.maintenance();
             // Should move from main table to archive
             const loaded = await archiveQueue.getTask(task.id);
             expect(loaded).toBeDefined();
-            expect(loaded?.status).toBe(TaskState.Completed);
+            expect(loaded?.status).toBe(TaskStatus.Completed);
             await archiveQueue.clear();
         });
         it('should prune expired pending tasks', async () => {
@@ -194,8 +194,8 @@ describe('Complex Queue Scenarios', () => {
             await timeout(150);
             await queue.maintenance();
             const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskState.Dead);
-            expect(updated?.error?.code).toBe('Expired');
+            expect(updated?.status).toBe(TaskStatus.Dead);
+            expect((updated?.error)['code']).toBe('Expired');
         });
         it('should retrieve task from archive', async () => {
             // Manually insert into archive? We can't access archiveRepository directly.
@@ -211,7 +211,7 @@ describe('Complex Queue Scenarios', () => {
             // Verify retrieval
             const fromArchive = await queue.getTask(task.id);
             expect(fromArchive).toBeDefined();
-            expect(fromArchive?.status).toBe(TaskState.Completed);
+            expect(fromArchive?.status).toBe(TaskStatus.Completed);
         });
         it('should defer archival of parent tasks until children are archived', async () => {
             const qProvider = injector.resolve(TaskQueueProvider);
@@ -267,7 +267,7 @@ describe('Complex Queue Scenarios', () => {
             expect(t1.id).toBe(t2.id); // Deduplicated
             const t3 = await queue.enqueue('t', { v: 3 }, { idempotencyKey: key, replace: true });
             expect(t3.id).not.toBe(t1.id); // Replaced
-            expect(t3.data.v).toBe(3);
+            expect(t3.data['v']).toBe(3);
         });
     });
     describe('Edge Cases', () => {
@@ -277,8 +277,15 @@ describe('Complex Queue Scenarios', () => {
             const d = await queue.dequeue({ types: ['pre'] });
             await queue.fail(d, new Error('fail'));
             await queue.processPendingFanIn();
-            const u = await queue.getTask(dependent.id);
-            expect(u?.status).toBe(TaskState.Waiting); // Should still be waiting because dependency didn't Complete
+            // Retry check because fan-in might be processed by background worker asynchronously
+            let u = await queue.getTask(dependent.id);
+            for (let i = 0; i < 5; i++) {
+                if (u?.status == TaskStatus.Waiting)
+                    break;
+                await timeout(50);
+                u = await queue.getTask(dependent.id);
+            }
+            expect(u?.status).toBe(TaskStatus.Waiting); // Should still be waiting because dependency didn't Complete
         });
         it('should handle mixed AND/OR dependencies', async () => {
             const dep = await queue.enqueue('dep', {}, {
@@ -287,8 +294,8 @@ describe('Complex Queue Scenarios', () => {
             });
             const A = await queue.enqueue('A', {}, { tags: ['A'] });
             await queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(dep.id, TaskState.Pending);
-            expect((await queue.getTask(dep.id))?.status).toBe(TaskState.Pending);
+            await waitForStatus(dep.id, TaskStatus.Pending);
+            expect((await queue.getTask(dep.id))?.status).toBe(TaskStatus.Pending);
         });
         it('should not reschedule if task is not running', async () => {
             const task = await queue.enqueue('t', {});

package/task-queue/tests/dependencies.test.js

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
-import { DependencyJoinMode, TaskQueueProvider, TaskState } from '../../task-queue/index.js';
+import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../unit-test/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Queue Dependencies & Tree Tests', () => {
@@ -28,7 +28,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
                 completeAfterTags: ['tag-a'],
             });
-            expect(dependent.status).toBe(TaskState.Waiting);
+            expect(dependent.status).toBe(TaskStatus.Waiting);
             // 2. Create the prerequisite task
             const prereq = await queue.enqueue('prereq', { val: 1 }, { tags: ['tag-a'] });
             // 3. Complete prereq
@@ -37,14 +37,14 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.complete(dequeued);
             await queue.processPendingFanIn();
             const updatedDependent = await queue.getTask(dependent.id);
-            expect(updatedDependent?.status).toBe(TaskState.Completed);
+            expect(updatedDependent?.status).toBe(TaskStatus.Completed);
         });
         it('should schedule a task to run after dependency completes (scheduleAfterTags)', async () => {
             // 1. Dependent task
             const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
                 scheduleAfterTags: ['tag-b'],
             });
-            expect(dependent.status).toBe(TaskState.Waiting);
+            expect(dependent.status).toBe(TaskStatus.Waiting);
             // 2. Prereq
             const prereq = await queue.enqueue('prereq', {}, { tags: ['tag-b'] });
             // 3. Complete prereq
@@ -53,7 +53,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.processPendingFanIn();
             // 5. Dependent should be Pending (ready to run)
             const updatedDependent = await queue.getTask(dependent.id);
-            expect(updatedDependent?.status).toBe(TaskState.Pending);
+            expect(updatedDependent?.status).toBe(TaskStatus.Pending);
             // 6. Should be dequeueable
             const d2 = await queue.dequeue({ types: ['dependent'] });
             expect(d2?.id).toBe(dependent.id);
@@ -66,18 +66,18 @@ describe('Queue Dependencies & Tree Tests', () => {
             const prereq = await queue.enqueue('prereq', {}, { tags: ['tag-fail'] });
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             // Fail fatally
-            await queue.fail(dequeued, new Error('boom'), true);
+            await queue.fail(dequeued, new Error('boom'), { fatal: true });
             // Trigger resolution
             await queue.processPendingFanIn();
             let updatedDependent;
             for (let i = 0; i < 20; i++) {
                 await timeout(100);
                 updatedDependent = await queue.getTask(dependent.id);
-                if (updatedDependent?.status === TaskState.Dead)
+                if (updatedDependent?.status === TaskStatus.Dead)
                     break;
                 await queue.processPendingFanIn(); // Retry processing if it didn't catch it yet
             }
-            expect(updatedDependent?.status).toBe(TaskState.Dead);
+            expect(updatedDependent?.status).toBe(TaskStatus.Dead);
             expect(updatedDependent?.error?.code).toBe('DependencyFailed');
         });
         it('should respect DependencyJoinMode.Or', async () => {
@@ -92,7 +92,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.complete(d1);
             await queue.processPendingFanIn();
             const updated = await queue.getTask(dependent.id);
-            expect(updated?.status).toBe(TaskState.Pending);
+            expect(updated?.status).toBe(TaskStatus.Pending);
         });
     });
     describe('Tree Operations & Cancellation', () => {
@@ -106,16 +106,16 @@ describe('Queue Dependencies & Tree Tests', () => {
             // Get Tree
             const tree = await queue.getTree(root.id);
             expect(tree.length).toBe(3);
-            expect(tree.map(t => t.id)).toContain(grandchild.id);
+            expect(tree.map((t) => t.id)).toContain(grandchild.id);
             // Cancel Root
             await queue.cancel(root.id);
             // Verify all cancelled
             const tRoot = await queue.getTask(root.id);
             const tChild = await queue.getTask(child.id);
             const tGrand = await queue.getTask(grandchild.id);
-            expect(tRoot?.status).toBe(TaskState.Cancelled);
-            expect(tChild?.status).toBe(TaskState.Cancelled);
-            expect(tGrand?.status).toBe(TaskState.Cancelled);
+            expect(tRoot?.status).toBe(TaskStatus.Cancelled);
+            expect(tChild?.status).toBe(TaskStatus.Cancelled);
+            expect(tGrand?.status).toBe(TaskStatus.Cancelled);
         });
         it('should cancel many by tags', async () => {
             await queue.enqueue('t1', {}, { tags: ['group-a'] });
@@ -125,19 +125,19 @@ describe('Queue Dependencies & Tree Tests', () => {
             // Check status
             const tasks = await queue.getManyByTags('group-a');
             expect(tasks.length).toBe(2);
-            expect(tasks.every(t => t.status === TaskState.Cancelled)).toBe(true);
+            expect(tasks.every((t) => t.status === TaskStatus.Cancelled)).toBe(true);
             const tasksB = await queue.getManyByTags('group-b');
-            expect(tasksB[0]?.status).toBe(TaskState.Pending);
+            expect(tasksB[0]?.status).toBe(TaskStatus.Pending);
         });
     });
     describe('Restart & Consumers', () => {
         it('should restart a dead/cancelled task', async () => {
             const task = await queue.enqueue('restart-test', {});
             const d = await queue.dequeue({ types: ['restart-test'] });
-            await queue.fail(d, new Error('fatal'), true); // Dead
+            await queue.fail(d, new Error('fatal'), { fatal: true }); // Dead
             await queue.restart(task.id);
             const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskState.Pending);
+            expect(updated?.status).toBe(TaskStatus.Pending);
             expect(updated?.tries).toBe(0);
             expect(updated?.error).toBeNull();
         });

package/task-queue/tests/enqueue-item.test.d.ts

@@ -0,0 +1 @@
+export {};

package/task-queue/tests/enqueue-item.test.js

@@ -0,0 +1,12 @@
+import { describe, expectTypeOf, test } from 'vitest';
+describe('EnqueueManyItem Type Definitions', () => {
+    test('EnqueueManyItem should be a discriminated union', () => {
+        const item = {};
+        if (item.type == 'test-task') {
+            expectTypeOf(item.data).toEqualTypeOf();
+        }
+        else if (item.type == 'other-task') {
+            expectTypeOf(item.data).toEqualTypeOf();
+        }
+    });
+});

package/task-queue/tests/queue-generic.test.d.ts

@@ -0,0 +1 @@
+export {};

package/task-queue/tests/queue-generic.test.js

@@ -0,0 +1,8 @@
+import { describe, test, expectTypeOf } from 'vitest';
+describe('TaskQueue Class Generic', () => {
+    test('TaskQueue should accept TaskDefinitionMap', () => {
+        // If it compiles, it's good. But we can inspect the generic constraints.
+        // For now, simple existence check.
+        expectTypeOf().toBeObject();
+    });
+});

package/task-queue/tests/queue.test.js

@@ -1,5 +1,5 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { TaskQueueProvider, TaskState } from '../../task-queue/index.js';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../unit-test/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
@@ -8,7 +8,7 @@ describe('Queue Integration Tests', () => {
     let queue;
     const queueName = `test-queue-${Date.now()}`;
     // Helper to verify state in DB
-    async function assertTaskState(id, state, message) {
+    async function assertTaskStatus(id, state, message) {
         const task = await queue.getTask(id);
         expect(task?.status, message).toBe(state);
     }
@@ -46,12 +46,12 @@ describe('Queue Integration Tests', () => {
         const t2 = await queue.enqueue('test', { value: 'second' });
         const d1 = await queue.dequeue();
         expect(d1?.id).toBe(t1.id);
-        expect(d1?.data.value).toBe('first');
-        await queue.complete(d1, { success: true });
-        await assertTaskState(t1.id, TaskState.Completed, 'Task 1 completed');
+        expect((d1?.data)['value']).toBe('first');
+        await queue.complete(d1, { result: { success: true } });
+        await assertTaskStatus(t1.id, TaskStatus.Completed, 'Task 1 completed');
         const d2 = await queue.dequeue();
         expect(d2?.id).toBe(t2.id);
-        await queue.complete(d2, { success: true });
+        await queue.complete(d2, { result: { success: true } });
     });
     it('Priorities', async () => {
         // Priority 1000 (default)
@@ -73,13 +73,13 @@ describe('Queue Integration Tests', () => {
         const t2 = await queue.enqueue('test', { value: 'ignored' }, { idempotencyKey: key });
         expect(t2.id, 'Same ID if not replaced').toBe(t1.id);
         const check1 = await queue.getTask(t1.id);
-        expect(check1?.data.value).toBe('original');
+        expect((check1?.data)['value']).toBe('original');
         // 3. Replace Strategy: Should replace existing task with new data AND new ID
         const t3 = await queue.enqueueMany([{ type: 'test', data: { value: 'updated' }, idempotencyKey: key }], { replace: true, returnTasks: true });
         expect(t3[0].id, 'New ID if replaced').not.toBe(t1.id);
         // New task should have new data
         const checkNew = await queue.getTask(t3[0].id);
-        expect(checkNew?.data.value).toBe('updated');
+        expect((checkNew?.data)['value']).toBe('updated');
         expect(checkNew?.tries).toBe(0);
     });
     it('Retries and Failures', async () => {
@@ -89,14 +89,14 @@ describe('Queue Integration Tests', () => {
         expect(attempt1?.id).toBe(task.id);
         await queue.fail(attempt1, { message: 'oops' });
         // Force reschedule to now to bypass retryDelay
-        await queue.reschedule(task.id, Date.now());
+        await queue.reschedule(task.id, currentTimestamp());
         // Try 2
         const attempt2 = await queue.dequeue();
         expect(attempt2?.id).toBe(task.id);
         expect(attempt2?.tries).toBe(2);
         // Fail fatally
-        await queue.fail(attempt2, { message: 'fatal error' }, true);
-        await assertTaskState(task.id, TaskState.Dead, 'Task is Dead after fatal error');
+        await queue.fail(attempt2, { message: 'fatal error' }, { fatal: true });
+        await assertTaskStatus(task.id, TaskStatus.Dead, 'Task is Dead after fatal error');
     });
     it('Hierarchy (Parent/Child)', async () => {
         // A. Create Parent
@@ -108,14 +108,14 @@ describe('Queue Integration Tests', () => {
         const child = await queue.enqueue('test', { value: 'child-manual' }, { parentId: p.id });
         // D. "Finish" Parent execution.
         await queue.complete(pTask);
-        // await assertTaskState(p.id, TaskState.Waiting, 'Parent entered WAITING state'); // Depends on implementation details of auto-waiting
+        // await assertTaskStatus(p.id, TaskStatus.Waiting, 'Parent entered WAITING state'); // Depends on implementation details of auto-waiting
     });
     it('Batching', async () => {
         const batch = queue.batch();
         for (let i = 0; i < 5; i++) {
             batch.add('test', { value: `batch-${i}` });
         }
-        const tasks = await batch.enqueue(true);
+        const tasks = await batch.enqueue({ returnTasks: true });
         expect(tasks.length).toBe(5);
         const dequeuedBatch = await queue.dequeueMany(5);
         expect(dequeuedBatch.length).toBe(5);
@@ -149,47 +149,47 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
     });
     describe('Basic Lifecycle', () => {
         it('should enqueue and dequeue a task', async () => {
-            await queue.enqueue('test', { foo: 'bar' });
+            await queue.enqueue('foo', { foo: 'bar' });
             const task = await queue.dequeue();
             expect(task).toBeDefined();
             expect(task?.data).toEqual({ foo: 'bar' });
-            expect(task?.status).toBe(TaskState.Running);
+            expect(task?.status).toBe(TaskStatus.Running);
             expect(task?.tries).toBe(1);
         });
         it('should complete a task successfully', async () => {
-            const task = await queue.enqueue('test', { foo: 'bar' });
+            const task = await queue.enqueue('foo', { foo: 'bar' });
             const dequeued = await queue.dequeue();
-            await queue.complete(dequeued, { result: true });
+            await queue.complete(dequeued, { result: { result: true } });
             const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskState.Completed);
+            expect(updated?.status).toBe(TaskStatus.Completed);
             expect(updated?.result).toEqual({ result: true });
-            expect(updated?.completeTimestamp).toBeGreaterThan(0);
+            expect(updated.completeTimestamp > 0).toBe(true);
         });
         it('should fail a task and increment tries', async () => {
-            const task = await queue.enqueue('test', { foo: 'bar' });
+            const task = await queue.enqueue('foo', { foo: 'bar' });
             const dequeued = await queue.dequeue();
             await queue.fail(dequeued, new Error('temp failure'));
             const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskState.Pending);
+            expect(updated?.status).toBe(TaskStatus.Pending);
             expect(updated?.tries).toBe(1);
             expect(updated?.error).toBeDefined();
         });
     });
     describe('Priority and Scheduling', () => {
         it('should dequeue tasks in priority order (lower number first)', async () => {
-            await queue.enqueue('test', { foo: 'low' }, { priority: 2000 });
-            await queue.enqueue('test', { foo: 'high' }, { priority: 10 });
-            await queue.enqueue('test', { foo: 'mid' }, { priority: 1000 });
+            await queue.enqueue('foo', { foo: 'low' }, { priority: 2000 });
+            await queue.enqueue('foo', { foo: 'high' }, { priority: 10 });
+            await queue.enqueue('foo', { foo: 'mid' }, { priority: 1000 });
             const t1 = await queue.dequeue();
             const t2 = await queue.dequeue();
             const t3 = await queue.dequeue();
-            expect(t1?.data?.foo).toBe('high');
-            expect(t2?.data?.foo).toBe('mid');
-            expect(t3?.data?.foo).toBe('low');
+            expect((t1?.data)['foo']).toBe('high');
+            expect((t2?.data)['foo']).toBe('mid');
+            expect((t3?.data)['foo']).toBe('low');
         });
         it('should not dequeue a task scheduled in the future', async () => {
             const future = currentTimestamp() + 500;
-            await queue.enqueue('test', { foo: 'future' }, { scheduleTimestamp: future });
+            await queue.enqueue('foo', { foo: 'future' }, { scheduleTimestamp: future });
             const task = await queue.dequeue();
             expect(task).toBeUndefined();
             await timeout(600);
@@ -202,9 +202,9 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const queueProvider = injector.resolve(TaskQueueProvider);
             const limitedQueue = queueProvider.get(`limit-test-${Date.now()}`, { globalConcurrency: 2 });
             await limitedQueue.enqueueMany([
-                { type: 'test', data: { foo: '1' } },
-                { type: 'test', data: { foo: '2' } },
-                { type: 'test', data: { foo: '3' } },
+                { type: 'foo', data: { foo: '1' } },
+                { type: 'foo', data: { foo: '2' } },
+                { type: 'foo', data: { foo: '3' } },
             ]);
             const t1 = await limitedQueue.dequeue();
             const t2 = await limitedQueue.dequeue();
@@ -221,9 +221,9 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
     describe('Circuit Breaker', () => {
         it('should trip the breaker after threshold failures', async () => {
             // Config: circuitBreakerThreshold: 2 (set in beforeEach)
-            await queue.enqueue('test', { foo: '1' });
-            await queue.enqueue('test', { foo: '2' });
-            await queue.enqueue('test', { foo: '3' });
+            await queue.enqueue('foo', { foo: '1' });
+            await queue.enqueue('foo', { foo: '2' });
+            await queue.enqueue('foo', { foo: '3' });
             await queue.fail((await queue.dequeue()), 'err');
             await queue.fail((await queue.dequeue()), 'err');
             // Breaker should be Open
@@ -232,8 +232,8 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
         });
         it('should allow a single probe in Half-Open state', async () => {
             await queue.enqueueMany([
-                { type: 'test', data: { foo: '1' } },
-                { type: 'test', data: { foo: '2' } },
+                { type: 'foo', data: { foo: '1' } },
+                { type: 'foo', data: { foo: '2' } },
             ]);
             await queue.fail((await queue.dequeue()), 'err');
             await queue.fail((await queue.dequeue()), 'err');
@@ -247,13 +247,13 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
     });
     describe('Timeouts and Maintenance (Pruning)', () => {
         it('should recover "Zombie" tasks (crashed workers)', async () => {
-            const task = await queue.enqueue('test', { foo: 'zombie' });
+            const task = await queue.enqueue('foo', { foo: 'zombie' });
             await queue.dequeue(); // Task is now Running with a token
             // processTimeout is 200ms. Wait for it to expire.
             await timeout(300);
             await queue.maintenance();
             const recovered = await queue.getTask(task.id);
-            expect(recovered?.status).toBe(TaskState.Pending);
+            expect(recovered?.status).toBe(TaskStatus.Pending);
             expect(recovered?.tries).toBe(1);
             expect(recovered?.token).toBeNull();
         });
@@ -261,25 +261,25 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             // Re-configure queue with very short execution timeout
             const queueProvider = injector.resolve(TaskQueueProvider);
             const shortQueue = queueProvider.get(`prune-test-${Date.now()}`, { maxExecutionTime: 100 });
-            const task = await shortQueue.enqueue('test', { foo: 'long-running' });
+            const task = await shortQueue.enqueue('foo', { foo: 'long-running' });
             await shortQueue.dequeue();
             await timeout(200);
             await shortQueue.maintenance();
             const updated = await shortQueue.getTask(task.id);
-            expect(updated?.status).toBe(TaskState.Dead);
+            expect(updated?.status).toBe(TaskStatus.Dead);
             expect(updated?.error?.message).toContain('Hard Execution Timeout');
             await shortQueue.clear();
         });
         it('should touch a task to extend token', async () => {
-            const task = await queue.enqueue('test', { foo: 'work' });
+            const task = await queue.enqueue('foo', { foo: 'work' });
             const dequeued = await queue.dequeue();
             const initialLock = dequeued.visibilityDeadline;
             await timeout(50);
             const touched = await queue.touch(dequeued);
-            expect(touched?.visibilityDeadline).toBeGreaterThan(initialLock);
+            expect(touched?.visibilityDeadline > initialLock).toBe(true);
         });
         it('should prevent touching if token is lost (stolen by another worker)', async () => {
-            await queue.enqueue('test', { foo: 'work' });
+            await queue.enqueue('foo', { foo: 'work' });
             const dequeued = await queue.dequeue();
             expect(dequeued).toBeDefined();
             // processTimeout is 200ms. Wait for it to expire.
@@ -294,34 +294,34 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
     describe('Batch Operations', () => {
         it('should complete many tasks efficiently', async () => {
             const tasks = await queue.enqueueMany([
-                { type: 'test', data: { foo: '1' } },
-                { type: 'test', data: { foo: '2' } },
+                { type: 'foo', data: { foo: '1' } },
+                { type: 'foo', data: { foo: '2' } },
             ], { returnTasks: true });
             const d1 = await queue.dequeue();
             const d2 = await queue.dequeue();
             await queue.completeMany([d1, d2]);
             const t1 = await queue.getTask(tasks[0].id);
             const t2 = await queue.getTask(tasks[1].id);
-            expect(t1?.status).toBe(TaskState.Completed);
-            expect(t2?.status).toBe(TaskState.Completed);
+            expect(t1?.status).toBe(TaskStatus.Completed);
+            expect(t2?.status).toBe(TaskStatus.Completed);
         });
     });
     describe('Rescheduling', () => {
         it('should reschedule and refund tries if running', async () => {
-            const task = await queue.enqueue('test', { foo: 'reschedule-me' });
+            const task = await queue.enqueue('foo', { foo: 'reschedule-me' });
             const dequeued = await queue.dequeue();
             expect(dequeued?.tries).toBe(1);
             const inFuture = currentTimestamp() + 1000;
             await queue.reschedule(dequeued.id, inFuture);
             const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskState.Pending);
+            expect(updated?.status).toBe(TaskStatus.Pending);
             expect(updated?.tries).toBe(0); // Refunded
             expect(updated?.scheduleTimestamp).toBe(inFuture);
         });
     });
     describe('TaskContext (Worker DX)', () => {
         it('checkpoint() should update progress and handle token loss', async () => {
-            const task = await queue.enqueue('test', { foo: 'progress' });
+            const task = await queue.enqueue('foo', { foo: 'progress' });
             const dequeued = await queue.dequeue();
             // In real scenarios TaskContext wraps the queue logic.
             // Here we just verify touch/checkpoint effects on the DB.

package/task-queue/tests/task-context.test.d.ts

@@ -0,0 +1 @@
+export {};