@tstdl/base 0.93.140 → 0.93.142

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

@@ -0,0 +1,188 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+import { timeout } from '../../utils/timing.js';
+describe('Extensive Task Queue Dependency Tests', () => {
+    let injector;
+    let queue;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `extensive-dep-queue-${crypto.randomUUID()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 1000,
+        });
+    });
+    afterEach(async () => {
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    async function completeTask(type) {
+        const dequeued = await queue.dequeue({ types: [type] });
+        if (!dequeued)
+            throw new Error(`Could not dequeue task of type ${type}`);
+        await queue.complete(dequeued);
+    }
+    it('should handle complex mixed chain: A -> (B -> D, C -> E) -> F', async () => {
+        // A is the root
+        const taskA = await queue.enqueue('A', {});
+        // B and C depend on A
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id] });
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskA.id] });
+        // D depends on B, E depends on C
+        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskB.id] });
+        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskC.id] });
+        // F depends on D and E
+        const taskF = await queue.enqueue('F', {}, { scheduleAfter: [taskD.id, taskE.id] });
+        expect(taskA.status).toBe(TaskStatus.Pending);
+        expect(taskB.status).toBe(TaskStatus.Waiting);
+        expect(taskC.status).toBe(TaskStatus.Waiting);
+        expect(taskD.status).toBe(TaskStatus.Waiting);
+        expect(taskE.status).toBe(TaskStatus.Waiting);
+        expect(taskF.status).toBe(TaskStatus.Waiting);
+        // 1. Complete A
+        await completeTask('A');
+        await queue.waitForTasks([taskB.id, taskC.id], { statuses: [TaskStatus.Pending] });
+        // 2. Complete B
+        await completeTask('B');
+        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
+        // 3. Complete C
+        await completeTask('C');
+        await queue.waitForTasks([taskE.id], { statuses: [TaskStatus.Pending] });
+        // F should still be waiting
+        const uF = await queue.getTask(taskF.id);
+        expect(uF?.status).toBe(TaskStatus.Waiting);
+        // 4. Complete D
+        await completeTask('D');
+        // F still waiting for E
+        expect((await queue.getTask(taskF.id))?.status).toBe(TaskStatus.Waiting);
+        // 5. Complete E
+        await completeTask('E');
+        await queue.waitForTasks([taskF.id], { statuses: [TaskStatus.Pending] });
+    });
+    it('should respect failFast = false (continue other branches)', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], failFast: false });
+        const taskC = await queue.enqueue('C', {}); // Independent
+        const dA = await queue.dequeue({ types: ['A'] });
+        await queue.fail(dA, new Error('fatal'), { fatal: true });
+        // taskB should stay Waiting (default requiredStatus is Completed)
+        // If failFast is false, it should transition to Pending once the dependency is terminal, even if it failed.
+        await timeout(100);
+        const uB = await queue.getTask(taskB.id);
+        expect(uB?.status).toBe(TaskStatus.Pending);
+        const dC = await queue.dequeue({ types: ['C'] });
+        expect(dC?.id).toBe(taskC.id);
+    });
+    it('should handle priority aging', async () => {
+        const agingQueue = injector.resolve(TaskQueueProvider).get(`aging-${crypto.randomUUID()}`, {
+            priorityAgingInterval: 50,
+            priorityAgingStep: 10,
+        });
+        const t1 = await agingQueue.enqueue('low', {}, { priority: 2000 });
+        const t2 = await agingQueue.enqueue('high', {}, { priority: 1000 });
+        // Wait for aging to trigger
+        await timeout(100);
+        await agingQueue.maintenance();
+        const u1 = await agingQueue.getTask(t1.id);
+        const u2 = await agingQueue.getTask(t2.id);
+        expect(u1.priority).toBeLessThan(2000);
+        expect(u2.priority).toBeLessThan(1000);
+    });
+    it('should handle rate limiting', async () => {
+        const rateQueue = injector.resolve(TaskQueueProvider).get(`rate-${crypto.randomUUID()}`, {
+            rateLimit: 5,
+            rateInterval: 200,
+        });
+        // Limit is 5 per 200ms
+        for (let i = 0; i < 10; i++) {
+            await rateQueue.enqueue('task', { i });
+        }
+        const batch1 = await rateQueue.dequeueMany(10);
+        expect(batch1.length).toBe(5);
+        await timeout(500);
+        const batch2 = await rateQueue.dequeueMany(10);
+        expect(batch2.length).toBe(5);
+    });
+    it('should handle Diamond Dependency (A -> B, A -> C, (B&C) -> D)', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id] });
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskA.id] });
+        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskB.id, taskC.id] });
+        await completeTask('A');
+        await queue.waitForTasks([taskB.id, taskC.id], { statuses: [TaskStatus.Pending] });
+        await completeTask('B');
+        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
+        await completeTask('C');
+        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
+    });
+    it('should handle Deep Chain (A -> B -> C -> D)', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id] });
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB.id] });
+        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskC.id] });
+        await completeTask('A');
+        await queue.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending] });
+        await completeTask('B');
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
+        await completeTask('C');
+        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
+    });
+    it('should handle wide fan-out (A -> [B1...B50] -> C)', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const bTasks = await queue.enqueueMany(Array.from({ length: 50 }, (_, i) => ({ type: `B${i}`, data: {}, scheduleAfter: [taskA.id] })), { returnTasks: true });
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: bTasks.map(t => t.id) });
+        await completeTask('A');
+        for (let i = 0; i < 49; i++) {
+            await completeTask(`B${i}`);
+            expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
+        }
+        await completeTask('B49');
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
+    });
+    it('should handle deep tree with branching and merging', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const taskB1 = await queue.enqueue('B1', {}, { scheduleAfter: [taskA.id] });
+        const taskB2 = await queue.enqueue('B2', {}, { scheduleAfter: [taskA.id] });
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB1.id, taskB2.id] });
+        const taskD1 = await queue.enqueue('D1', {}, { scheduleAfter: [taskC.id] });
+        const taskD2 = await queue.enqueue('D2', {}, { scheduleAfter: [taskC.id] });
+        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskD1.id, taskD2.id] });
+        await completeTask('A');
+        await completeTask('B1');
+        await completeTask('B2');
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
+        await completeTask('C');
+        await queue.waitForTasks([taskD1.id], { statuses: [TaskStatus.Pending] });
+        await queue.waitForTasks([taskD2.id], { statuses: [TaskStatus.Pending] });
+        await completeTask('D1');
+        await completeTask('D2');
+        await queue.waitForTasks([taskE.id], { statuses: [TaskStatus.Pending] });
+    });
+    it('should handle fail-fast cascade', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], failFast: true });
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB.id], failFast: true });
+        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskA.id], failFast: true });
+        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskC.id, taskD.id], failFast: true });
+        const dA = await queue.dequeue({ types: ['A'] });
+        await queue.fail(dA, new Error('fatal'), { fatal: true });
+        await queue.waitForTasks([taskB.id, taskC.id, taskD.id, taskE.id], { statuses: [TaskStatus.Skipped] });
+    });
+    it('should NOT schedule if only one of two dependencies is met (AND logic)', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const taskB = await queue.enqueue('B', {});
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskA.id, taskB.id] });
+        await completeTask('A');
+        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
+        // Still waiting even after some time
+        await timeout(100);
+        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
+        await completeTask('B');
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
+    });
+});

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

@@ -1,8 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
-import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
 describe('Queue Dependencies & Tree Tests', () => {
     let injector;
     let queue;
@@ -11,7 +10,7 @@ describe('Queue Dependencies & Tree Tests', () => {
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `dep-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `dep-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
         });
@@ -22,46 +21,39 @@ describe('Queue Dependencies & Tree Tests', () => {
     afterAll(async () => {
         await injector?.dispose();
     });
-    async function waitForStatus(id, status) {
-        for (let i = 0; i < 20; i++) {
-            const task = await queue.getTask(id);
-            if (task?.status == status) {
-                return;
-            }
-            await queue.processPendingFanIn();
-            await timeout(50);
-        }
-    }
-    describe('Dependencies (Fan-In)', () => {
-        it('should schedule a task only after dependency completes (completeAfterTags)', async () => {
-            // 1. Create a dependent task (Waiting)
+    describe('Dependencies (DAG)', () => {
+        it('should schedule a task only after dependency completes (completeAfter)', async () => {
+            // 1. Prereq
+            const prereq = await queue.enqueue('prereq', { val: 1 });
+            // 2. Dependent (Waiting)
             const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
-                completeAfterTags: ['tag-a'],
+                completeAfter: [prereq.id],
             });
-            expect(dependent.status).toBe(TaskStatus.Waiting);
-            // 2. Create the prerequisite task
-            const prereq = await queue.enqueue('prereq', { val: 1 }, { tags: ['tag-a'] });
+            expect(dependent.status).toBe(TaskStatus.Pending);
             // 3. Complete prereq
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             expect(dequeued?.id).toBe(prereq.id);
             await queue.complete(dequeued);
-            await queue.processPendingFanIn();
+            // Complete dependent too so it reaches finalized state for waitForTasks
+            const dDependent = await queue.dequeue({ types: ['dependent'] });
+            expect(dDependent?.id).toBe(dependent.id);
+            await queue.complete(dDependent);
             await queue.waitForTasks([dependent.id]);
             const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Completed);
         });
-        it('should schedule a task to run after dependency completes (scheduleAfterTags)', async () => {
-            // 1. Dependent task
+        it('should schedule a task to run after dependency completes (scheduleAfter)', async () => {
+            // 1. Prereq
+            const prereq = await queue.enqueue('prereq', {});
+            // 2. Dependent task
             const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
-                scheduleAfterTags: ['tag-b'],
+                scheduleAfter: [prereq.id],
             });
             expect(dependent.status).toBe(TaskStatus.Waiting);
-            // 2. Prereq
-            const prereq = await queue.enqueue('prereq', {}, { tags: ['tag-b'] });
             // 3. Complete prereq
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             await queue.complete(dequeued);
-            await waitForStatus(dependent.id, TaskStatus.Pending);
+            await queue.waitForTasks([dependent.id], { statuses: [TaskStatus.Pending] });
             // 5. Dependent should be Pending (ready to run)
             const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Pending);
@@ -70,57 +62,164 @@ describe('Queue Dependencies & Tree Tests', () => {
             expect(d2?.id).toBe(dependent.id);
         });
         it('should fail-fast if dependency fails', async () => {
+            const prereq = await queue.enqueue('prereq', {});
             const dependent = await queue.enqueue('dependent', {}, {
-                scheduleAfterTags: ['tag-fail'],
+                scheduleAfter: [prereq.id],
                 failFast: true
             });
-            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'), { fatal: true });
-            await queue.processPendingFanIn();
             await queue.waitForTasks([dependent.id]);
             const updatedDependent = await queue.getTask(dependent.id);
-            expect(updatedDependent?.status).toBe(TaskStatus.Dead);
+            expect(updatedDependent?.status).toBe(TaskStatus.Skipped);
             expect(updatedDependent?.error?.code).toBe('DependencyFailed');
         });
-        it('should respect DependencyJoinMode.Or', async () => {
-            // Wait for tag-1 OR tag-2
+        it('should NOT overwrite terminal states during cancellation (failFast + complete)', async () => {
+            const dep = await queue.enqueue('dep', {});
+            // completeAfter allows 'main' to be Running while 'dep' is not finished
+            const main = await queue.enqueue('main', {}, { completeAfter: [dep.id], failFast: true });
+            const runningDep = await queue.dequeue();
+            expect(runningDep?.id).toBe(dep.id);
+            const runningMain = await queue.dequeue();
+            expect(runningMain?.id).toBe(main.id);
+            expect(runningMain?.status).toBe(TaskStatus.Running);
+            // Fail 'dep' -> this should make 'main' Skipped
+            await queue.fail(runningDep, new Error('Dependency failed'), { fatal: true });
+            const skippedMain = await queue.getTask(main.id);
+            expect(skippedMain?.status).toBe(TaskStatus.Skipped);
+            expect(skippedMain?.token).toBeNull();
+            // Call complete() on the old task reference (which still has the token)
+            await queue.complete(runningMain);
+            const finalMain = await queue.getTask(main.id);
+            expect(finalMain?.status).toBe(TaskStatus.Skipped);
+        });
+        it('should resolve dependencies across namespaces', async () => {
+            const queueProvider = injector.resolve(TaskQueueProvider);
+            const queueA = queueProvider.get(`QueueA-${crypto.randomUUID()}`);
+            const queueB = queueProvider.get(`QueueB-${crypto.randomUUID()}`);
+            const taskA = await queueA.enqueue('test', { value: 'A' });
+            const taskB = await queueB.enqueue('test', { value: 'B' }, { scheduleAfter: [{ id: taskA.id }] });
+            expect(taskB.status).toBe(TaskStatus.Waiting);
+            const dequeuedA = await queueA.dequeue();
+            await queueA.complete(dequeuedA);
+            queueB.notify();
+            await queueB.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending], timeout: 10000 });
+            const updatedB = await queueB.getTask(taskB.id);
+            expect(updatedB?.status).toBe(TaskStatus.Pending);
+            await queueA.clear();
+            await queueB.clear();
+        });
+        it('should correctly skip dependent tasks across namespaces when failFast is triggered', async () => {
+            const queueProvider = injector.resolve(TaskQueueProvider);
+            const queueA = queueProvider.get(`QueueA-${crypto.randomUUID()}`);
+            const queueB = queueProvider.get(`QueueB-${crypto.randomUUID()}`);
+            const taskA = await queueA.enqueue('test', { value: 'A' });
+            const taskB = await queueB.enqueue('test', { value: 'B' }, {
+                failFast: true,
+                scheduleAfter: [{ id: taskA.id }],
+            });
+            const dequeuedA = await queueA.dequeue();
+            await queueA.fail(dequeuedA, new Error('Failed'), { fatal: true });
+            queueB.notify();
+            await queueB.waitForTasks([taskB.id], { statuses: [TaskStatus.Skipped], timeout: 10000 });
+            const updatedB = await queueB.getTask(taskB.id);
+            expect(updatedB?.status).toBe(TaskStatus.Skipped);
+            await queueA.clear();
+            await queueB.clear();
+        });
+        it('should respect requiredStatuses', async () => {
+            const prereq = await queue.enqueue('prereq', {});
+            // Wait for prereq to be Dead or Completed
             const dependent = await queue.enqueue('dependent', {}, {
-                scheduleAfterTags: ['tag-1', 'tag-2'],
-                dependencyJoinMode: DependencyJoinMode.Or
+                scheduleAfter: [{ id: prereq.id, requiredStatuses: [TaskStatus.Dead, TaskStatus.Completed] }]
             });
-            // Complete tag-1 only
-            await queue.enqueue('t1', {}, { tags: ['tag-1'] });
-            const d1 = await queue.dequeue({ types: ['t1'] });
-            await queue.complete(d1);
-            await waitForStatus(dependent.id, TaskStatus.Pending);
+            // Fail fatally -> Dead
+            const d1 = await queue.dequeue({ types: ['prereq'] });
+            await queue.fail(d1, new Error('boom'), { fatal: true });
+            await queue.waitForTasks([dependent.id], { statuses: [TaskStatus.Pending] });
             const updated = await queue.getTask(dependent.id);
             expect(updated?.status).toBe(TaskStatus.Pending);
         });
+        it('should schedule a task immediately if dependency is already completed (Bug 1)', async () => {
+            // 1. Enqueue and complete task A
+            const taskA = await queue.enqueue('taskA', {});
+            const dequeuedA = await queue.dequeue({ types: ['taskA'] });
+            await queue.complete(dequeuedA);
+            const finishedA = await queue.getTask(taskA.id);
+            expect(finishedA?.status).toBe(TaskStatus.Completed);
+            // 2. Enqueue task B with scheduleAfter: [A.id]
+            const taskB = await queue.enqueue('taskB', {}, {
+                scheduleAfter: [taskA.id],
+            });
+            // Wait for proactive resolution to trigger
+            await queue.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending] });
+            const updatedB = await queue.getTask(taskB.id);
+            expect(updatedB?.status).toBe(TaskStatus.Pending);
+        });
+        it('should transition to Pending even if duplicate dependencies are specified (Bug 2)', async () => {
+            // 1. Enqueue task A
+            const taskA = await queue.enqueue('taskA', {});
+            // 2. Enqueue task B with duplicate scheduleAfter: [A.id, A.id]
+            const taskB = await queue.enqueue('taskB', {}, {
+                scheduleAfter: [taskA.id, taskA.id],
+            });
+            expect(taskB.status).toBe(TaskStatus.Waiting);
+            // 3. Complete task A
+            const dequeuedA = await queue.dequeue({ types: ['taskA'] });
+            await queue.complete(dequeuedA);
+            await queue.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending] });
+            const updatedB = await queue.getTask(taskB.id);
+            expect(updatedB?.status).toBe(TaskStatus.Pending);
+        });
+        it('should NOT resurrect terminal tasks when calling rescheduleMany (Issue 1)', async () => {
+            const task = await queue.enqueue('test', { val: 1 });
+            const dequeued = await queue.dequeue();
+            await queue.complete(dequeued);
+            const completedTask = await queue.getTask(task.id);
+            expect(completedTask?.status).toBe(TaskStatus.Completed);
+            // Attempt to reschedule
+            await queue.rescheduleMany([task.id], Date.now());
+            const stillCompletedTask = await queue.getTask(task.id);
+            expect(stillCompletedTask?.status).toBe(TaskStatus.Completed);
+            expect(stillCompletedTask?.completeTimestamp).toBeDefined();
+        });
     });
     describe('Tree Operations & Cancellation', () => {
-        it('should retrieve task tree and cancel hierarchy', async () => {
+        it('should retrieve task tree and cancel hierarchy (multiple children)', async () => {
             // Root
             const root = await queue.enqueue('root', {});
-            // Child
-            const child = await queue.enqueue('child', {}, { parentId: root.id });
+            // Children
+            const child1 = await queue.enqueue('child1', {}, { parentId: root.id });
+            const child2 = await queue.enqueue('child2', {}, { parentId: root.id });
             // Grandchild
-            const grandchild = await queue.enqueue('grandchild', {}, { parentId: child.id });
+            const grandchild = await queue.enqueue('grandchild', {}, { parentId: child1.id });
             // Get Tree
             const tree = await queue.getTree(root.id);
-            expect(tree.length).toBe(3);
+            expect(tree.length).toBe(4);
             expect(tree.map((t) => t.id)).toContain(grandchild.id);
+            expect(tree.map((t) => t.id)).toContain(child2.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 tChild1 = await queue.getTask(child1.id);
+            const tChild2 = await queue.getTask(child2.id);
             const tGrand = await queue.getTask(grandchild.id);
             expect(tRoot?.status).toBe(TaskStatus.Cancelled);
-            expect(tChild?.status).toBe(TaskStatus.Cancelled);
+            expect(tChild1?.status).toBe(TaskStatus.Cancelled);
+            expect(tChild2?.status).toBe(TaskStatus.Cancelled);
             expect(tGrand?.status).toBe(TaskStatus.Cancelled);
         });
+        it('should retrieve subtree via getTreeByQuery', async () => {
+            const root = await queue.enqueue('root', { val: 'root' });
+            const child = await queue.enqueue('child', { val: 'child' }, { parentId: root.id });
+            await queue.enqueue('other', { val: 'other' });
+            const tree = await queue.getTreeByQuery({ id: root.id });
+            expect(tree.length).toBe(2);
+            expect(tree.map(t => t.id)).toContain(root.id);
+            expect(tree.map(t => t.id)).toContain(child.id);
+        });
         it('should cancel many by tags', async () => {
             await queue.enqueue('t1', {}, { tags: ['group-a'] });
             await queue.enqueue('t2', {}, { tags: ['group-a'] });
@@ -133,6 +232,25 @@ describe('Queue Dependencies & Tree Tests', () => {
             const tasksB = await queue.getManyByTags('group-b');
             expect(tasksB[0]?.status).toBe(TaskStatus.Pending);
         });
+        it('should NOT resolve completed tasks as Cancelled when calling cancelMany (Issue 3)', async () => {
+            const taskA = await queue.enqueue('test', { name: 'A' });
+            const taskB = await queue.enqueue('test', { name: 'B' }, { scheduleAfter: [taskA.id], failFast: true });
+            const dequeuedA = await queue.dequeue();
+            await queue.complete(dequeuedA);
+            // B should have unresolvedScheduleDependencies = 0 and be Pending because A completed
+            const freshB = await queue.getTask(taskB.id);
+            expect(freshB?.unresolvedScheduleDependencies).toBe(0);
+            expect(freshB?.status).toBe(TaskStatus.Pending);
+            // Cancel A. Since A is Completed, it shouldn't be touched in DB.
+            // Importantly, it shouldn't trigger dependency resolution for B as 'Cancelled'.
+            // In the old code, this would have caused B to be transitioned to 'Skipped' because A was resolved as 'Cancelled' but B required 'Completed' (and failFast is true).
+            await queue.cancelMany([taskA.id]);
+            const stillFreshA = await queue.getTask(taskA.id);
+            expect(stillFreshA?.status).toBe(TaskStatus.Completed);
+            const stillFreshB = await queue.getTask(taskB.id);
+            expect(stillFreshB?.status).toBe(TaskStatus.Pending); // Should STILL be Pending
+            expect(stillFreshB?.unresolvedScheduleDependencies).toBe(0);
+        });
     });
     describe('Restart & Consumers', () => {
         it('should restart a dead/cancelled task', async () => {

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

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

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

@@ -0,0 +1,125 @@
+import { eq, inArray } from 'drizzle-orm';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { Database } from '../../orm/server/index.js';
+import { TaskQueueEnqueueBatch } from '../../task-queue/enqueue-batch.js';
+import { TaskQueueProvider } from '../../task-queue/index.js';
+import { taskDependency as taskDependencyTable } from '../../task-queue/postgres/schemas.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+describe('TaskQueueEnqueueBatch', () => {
+    let injector;
+    let queue;
+    let database;
+    let queueProvider;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+        queueProvider = injector.resolve(TaskQueueProvider);
+        queue = queueProvider.get(`batch-queue-${crypto.randomUUID()}`);
+        database = injector.resolve(Database);
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should restore items if enqueueMany fails', async () => {
+        const batch = new TaskQueueEnqueueBatch(queue);
+        batch.add('t1', { val: 1 });
+        batch.add('t2', { val: 2 });
+        expect(batch.items.length).toBe(2);
+        // Mock enqueueMany to throw
+        vi.spyOn(queue, 'enqueueMany').mockRejectedValueOnce(new Error('db failure'));
+        await expect(batch.enqueue()).rejects.toThrow('db failure');
+        // Check items restored
+        expect(batch.items.length).toBe(2);
+        expect(batch.items[0].type).toBe('t1');
+        expect(batch.items[1].type).toBe('t2');
+        // Should work on second attempt (without mock)
+        vi.restoreAllMocks();
+        const tasks = await batch.enqueue({ returnTasks: true });
+        expect(batch.items.length).toBe(0);
+        const t1 = await queue.getTask(tasks[0].id);
+        expect(t1).toBeDefined();
+        expect(t1?.type).toBe('t1');
+    });
+    it('should work correctly with queue.batch()', async () => {
+        const batch = queue.batch();
+        batch.add('b1', { x: 1 });
+        batch.add('b2', { x: 2 });
+        const tasks = await batch.enqueue({ returnTasks: true });
+        expect(tasks.length).toBe(2);
+        expect(batch.items.length).toBe(0);
+    });
+    describe('enqueueMany Alignment and Dependencies', () => {
+        it('should correctly map dependencies when enqueuing a mix of tasks with and without idempotency keys', async () => {
+            const q = queueProvider.get(`q-${crypto.randomUUID()}`);
+            const items = [
+                { type: 'test', data: { value: '1' } },
+                { type: 'test', data: { value: '2' }, idempotencyKey: 'key-2' },
+                { type: 'test', data: { value: '3' }, scheduleAfter: [0] },
+                { type: 'test', data: { value: '4' }, idempotencyKey: 'key-4' },
+                { type: 'test', data: { value: '5' }, scheduleAfter: [0] },
+            ];
+            const tasks = await q.enqueueMany(items, { returnTasks: true });
+            expect(tasks).toHaveLength(5);
+            const task1Id = tasks[0].id;
+            const task3Id = tasks[2].id;
+            const task5Id = tasks[4].id;
+            const deps = await database
+                .select()
+                .from(taskDependencyTable)
+                .where(inArray(taskDependencyTable.taskId, [task3Id, task5Id]));
+            expect(deps).toHaveLength(2);
+            expect(deps.every(d => d.dependencyTaskId === task1Id)).toBe(true);
+        });
+        it('should correctly map dependencies when batch-enqueuing with pre-existing idempotency keys', async () => {
+            const q = queueProvider.get(`q-${crypto.randomUUID()}`);
+            const existingTask = await q.enqueue('test', { value: 'existing' }, { idempotencyKey: 'shared-key' });
+            const items = [
+                { type: 'test', data: { value: 'new' } },
+                { type: 'test', data: { value: 'duplicate' }, idempotencyKey: 'shared-key' },
+                { type: 'test', data: { value: 'dependent' }, scheduleAfter: [1] },
+            ];
+            const tasks = await q.enqueueMany(items, { returnTasks: true, replace: false });
+            expect(tasks[1].id).toBe(existingTask.id);
+            const dependentTaskId = tasks[2].id;
+            const deps = await database
+                .select()
+                .from(taskDependencyTable)
+                .where(eq(taskDependencyTable.taskId, dependentTaskId));
+            expect(deps).toHaveLength(1);
+            expect(deps[0].dependencyTaskId).toBe(existingTask.id);
+        });
+        it('should accurately increment parent unresolvedCompleteDependencies across multiple namespaces in a single batch', async () => {
+            const queueA = queueProvider.get(`QueueA-${crypto.randomUUID()}`);
+            const queueB = queueProvider.get(`QueueB-${crypto.randomUUID()}`);
+            const queueC = queueProvider.get(`QueueC-${crypto.randomUUID()}`);
+            const parentA = await queueA.enqueue('test', { value: 'parentA' });
+            const parentB = await queueB.enqueue('test', { value: 'parentB' });
+            await queueC.enqueueMany([
+                { type: 'test', data: { value: 'child1' }, parentId: parentA.id },
+                { type: 'test', data: { value: 'child2' }, parentId: parentA.id },
+                { type: 'test', data: { value: 'child3' }, parentId: parentB.id },
+            ]);
+            const upA = await queueA.getTask(parentA.id);
+            const upB = await queueB.getTask(parentB.id);
+            expect(upA?.unresolvedCompleteDependencies).toBe(2);
+            expect(upB?.unresolvedCompleteDependencies).toBe(1);
+        });
+        it('should correctly map dependencies when using object with index', async () => {
+            const q = queueProvider.get(`q-${crypto.randomUUID()}`);
+            const items = [
+                { type: 'test', data: { value: '1' } },
+                { type: 'test', data: { value: '2' }, scheduleAfter: [0] },
+                { type: 'test', data: { value: '3' }, scheduleAfter: [{ index: 0 }] },
+            ];
+            const tasks = await q.enqueueMany(items, { returnTasks: true });
+            const task1Id = tasks[0].id;
+            const task2Id = tasks[1].id;
+            const task3Id = tasks[2].id;
+            const deps = await database
+                .select()
+                .from(taskDependencyTable)
+                .where(inArray(taskDependencyTable.taskId, [task2Id, task3Id]));
+            expect(deps).toHaveLength(2);
+            expect(deps.every(d => d.dependencyTaskId === task1Id)).toBe(true);
+        });
+    });
+});

package/task-queue/tests/fan-out-spawning.test.d.ts

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