@tstdl/base 0.93.92 → 0.93.94

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 {};

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

@@ -0,0 +1,7 @@
+import { describe, expectTypeOf, test } from 'vitest';
+describe('TaskContext Type Definitions', () => {
+    test('TaskContext should infer types from definition map', () => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+});

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

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

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

@@ -0,0 +1,18 @@
+import { describe, expectTypeOf, test } from 'vitest';
+describe('Task Discriminated Union', () => {
+    test('Task should be a discriminated union based on definition map', () => {
+        // Should be a union
+        expectTypeOf().toBeObject();
+        // Discrimination check
+        const task = {};
+        if (task.type == 'test-task') {
+            expectTypeOf(task.data).toEqualTypeOf();
+            expectTypeOf(task.state).toEqualTypeOf();
+            expectTypeOf(task.result).toEqualTypeOf();
+        }
+        else if (task.type == 'other-task') {
+            expectTypeOf(task.data).toEqualTypeOf();
+            expectTypeOf(task.result).toEqualTypeOf();
+        }
+    });
+});

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

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

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

@@ -0,0 +1,9 @@
+import { describe, expectTypeOf, test } from 'vitest';
+describe('TaskQueue Type Definitions', () => {
+    test('TaskDefinition and TaskDefinitionMap should be defined', () => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+});

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

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
-import { TaskQueueProvider, TaskResult, TaskState } from '../../task-queue/index.js';
+import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../unit-test/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Worker & Base Class Tests', () => {
@@ -30,8 +30,8 @@ describe('Worker & Base Class Tests', () => {
         const processed = [];
         const token = new CancellationToken();
         queue.process({ cancellationSignal: token }, async (context) => {
-            processed.push(context.data.val);
-            return TaskResult.Complete();
+            processed.push(context.data['val']);
+            return TaskProcessResult.Complete();
         });
         // Wait until 2 tasks are processed
         for (let i = 0; i < 20; i++) {
@@ -45,8 +45,8 @@ describe('Worker & Base Class Tests', () => {
         expect(processed.length).toBe(2);
         const check1 = await queue.getTask(t1.id);
         const check2 = await queue.getTask(t2.id);
-        expect(check1?.status).toBe(TaskState.Completed);
-        expect(check2?.status).toBe(TaskState.Completed);
+        expect(check1?.status).toBe(TaskStatus.Completed);
+        expect(check2?.status).toBe(TaskStatus.Completed);
     });
     it('should handle errors in worker gracefully', async () => {
         const task = await queue.enqueue('fail', {});
@@ -57,7 +57,7 @@ describe('Worker & Base Class Tests', () => {
         await timeout(200);
         token.set();
         const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskState.Pending); // Should retry
+        expect(updated?.status).toBe(TaskStatus.Pending); // Should retry
         expect(updated?.tries).toBe(1);
         expect(updated?.error?.message).toBe('worker error');
     });
@@ -71,8 +71,8 @@ describe('Worker & Base Class Tests', () => {
         const token = new CancellationToken();
         queue.processBatch({ batchSize: 2, cancellationSignal: token }, async (context) => {
             expect(context.tasks.length).toBeLessThanOrEqual(2);
-            context.tasks.forEach(t => processedBatch.push(t.data.v));
-            return context.tasks.map(() => TaskResult.Complete());
+            context.tasks.forEach(t => processedBatch.push(t.data['v']));
+            return context.tasks.map(() => TaskProcessResult.Complete());
         });
         for (let i = 0; i < 20; i++) {
             if (processedBatch.length === 3)
@@ -90,13 +90,13 @@ describe('Worker & Base Class Tests', () => {
             // Simulate long work > visibilityTimeout (500ms)
             await timeout(700);
             executed = true;
-            return TaskResult.Complete();
+            return TaskProcessResult.Complete();
         });
         await timeout(1000);
         token.set();
         expect(executed).toBe(true);
         const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskState.Completed);
+        expect(updated?.status).toBe(TaskStatus.Completed);
     });
     it('should handle TaskResult actions (Fail, Reschedule)', async () => {
         const tFail = await queue.enqueue('fail-action', {});
@@ -106,12 +106,12 @@ describe('Worker & Base Class Tests', () => {
         queue.process({ cancellationSignal: token }, async (context) => {
             processed.add(context.id);
             if (context.id === tFail.id) {
-                return TaskResult.Fail(new Error('explicit fail'));
+                return TaskProcessResult.Fail(new Error('explicit fail'));
             }
             if (context.id === tResched.id) {
-                return TaskResult.RescheduleBy(1000);
+                return TaskProcessResult.RescheduleBy(1000);
             }
-            return TaskResult.Complete();
+            return TaskProcessResult.Complete();
         });
         for (let i = 0; i < 20; i++) {
             if (processed.size === 2)
@@ -120,10 +120,10 @@ describe('Worker & Base Class Tests', () => {
         }
         token.set();
         const uFail = await queue.getTask(tFail.id);
-        expect(uFail?.status).toBe(TaskState.Pending); // Retry
+        expect(uFail?.status).toBe(TaskStatus.Pending); // Retry
         expect(uFail?.error?.message).toBe('explicit fail');
         const uResched = await queue.getTask(tResched.id);
-        expect(uResched?.status).toBe(TaskState.Pending);
+        expect(uResched?.status).toBe(TaskStatus.Pending);
         expect(uResched?.scheduleTimestamp).toBeGreaterThan(Date.now());
     });
     it('should exercise TaskContext methods', async () => {
@@ -150,7 +150,7 @@ describe('Worker & Base Class Tests', () => {
             const otherChildren = await context.spawnMany(otherQueue, [{ type: 'other', data: { x: 2 } }]);
             expect(otherChildren[0]?.parentId).toBe(task.id);
             executed = true;
-            return TaskResult.Complete();
+            return TaskProcessResult.Complete();
         });
         for (let i = 0; i < 20; i++) {
             if (executed)

package/task-queue/types.d.ts

@@ -0,0 +1,48 @@
+import type { BatchTaskContext, TaskContext } from './task-context.js';
+import type { Task, TaskProcessResult } from './task-queue.js';
+export type TaskDefinition<Data = unknown, State = unknown, Result = unknown> = {
+    data: Data;
+    state: State;
+    result: Result;
+};
+export type TaskDefinitionMap<Definition extends Record<string, TaskDefinition> = Record<string, TaskDefinition>> = Definition;
+export type TaskTypes<Definitions extends TaskDefinitionMap> = Extract<keyof Definitions, string>;
+export type TaskOfType<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = string extends TaskTypes<Definitions> ? Task<Definitions> & {
+    type: Type;
+} : Extract<Task<Definitions>, {
+    type: Type;
+}>;
+export type TaskData<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = Definitions[Type]['data'];
+export type TaskState<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = Definitions[Type]['state'];
+export type TaskResult<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = Definitions[Type]['result'];
+export type TasksResults<Tasks extends Task<any>[]> = {
+    [I in keyof Tasks]: Tasks[I] extends Task<infer Definitions> ? TaskResult<Definitions, Tasks[I]['type']> : never;
+};
+export type TasksStates<Tasks extends Task<any>[]> = {
+    [I in keyof Tasks]: Tasks[I] extends Task<infer Definitions> ? TaskState<Definitions, Tasks[I]['type']> : never;
+};
+export type TaskProcessResultPayload<Result> = {
+    action: 'complete';
+    result: Result | undefined;
+} | {
+    action: 'fail';
+    error: unknown;
+    fatal: boolean;
+} | {
+    action: 'reschedule';
+    timestamp: number;
+};
+export interface ProcessWorker<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
+    /**
+     * A worker function that processes a single task.
+     * @param context The task context providing data, logger, and orchestration helpers.
+     */
+    (context: TaskContext<Definitions, Type>): TaskProcessResult<Definitions[Type]['result']> | Promise<TaskProcessResult<Definitions[Type]['result']>>;
+}
+export interface ProcessBatchWorker<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
+    /**
+     * A worker function that processes a batch of tasks.
+     * @param context The batch context providing tasks and helpers.
+     */
+    (context: BatchTaskContext<Definitions, Type>): TaskProcessResult<Definitions[Type]['result']>[] | Promise<TaskProcessResult<Definitions[Type]['result']>[]>;
+}

package/task-queue/types.js

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