@tstdl/base 0.93.181 → 0.93.183

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

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

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

@@ -1,41 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { CancellationSignal } from '../../cancellation/token.js';
-import { DeferredPromise } from '../../promise/deferred-promise.js';
-import { TaskProcessResult, TaskQueueProvider } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-describe('Graceful Worker Shutdown', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        queue = queueProvider.get(`shutdown-queue-${crypto.randomUUID()}`);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should wait for active handler to finish on disposal', async () => {
-        const cancellationSignal = injector.resolve(CancellationSignal);
-        await queue.enqueue('shutdown-test', {});
-        let handlerFinished = false;
-        const handlerStarted = new DeferredPromise();
-        queue.process({ cancellationSignal }, async () => {
-            handlerStarted.resolve();
-            await timeout(300); // simulate work
-            handlerFinished = true;
-            return TaskProcessResult.Complete();
-        });
-        queue.notify();
-        // Wait for worker to pick it up
-        await handlerStarted;
-        // Call disposal
-        const disposePromise = injector.dispose();
-        // Check that disposal waits for the handler
-        expect(handlerFinished).toBe(false);
-        await disposePromise;
-        expect(handlerFinished).toBe(true);
-        // Note: We can't call queue.getTask here because pool is closed.
-        // But handlerFinished = true and successful disposePromise already prove it waited.
-    });
-});

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

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

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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,18 +0,0 @@
-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/transactions.test.d.ts

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

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

@@ -1,47 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-describe('Task Queue Transactions', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        queue = queueProvider.get(`tx-queue-${crypto.randomUUID()}`);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should respect transaction rollbacks', async () => {
-        let taskId;
-        await queue.transaction(async (tx) => {
-            const task = await queue.enqueue('tx-task', { foo: 'bar' }, { transaction: tx });
-            taskId = task.id;
-            const hasTask = await queue.has(taskId, { transaction: tx });
-            expect(hasTask).toBe(true);
-            await tx.rollback();
-        });
-        const hasTaskAfterRollback = await queue.has(taskId);
-        expect(hasTaskAfterRollback).toBe(false);
-    });
-    it('should participate in external transaction (commit)', async () => {
-        let taskId;
-        await queue.transaction(async (tx) => {
-            const task = await queue.enqueue('tx-commit', { foo: 'bar' }, { transaction: tx });
-            taskId = task.id;
-        });
-        const hasTaskAfterCommit = await queue.has(taskId);
-        expect(hasTaskAfterCommit).toBe(true);
-    });
-    it('should handle multiple operations in one transaction', async () => {
-        await queue.transaction(async (tx) => {
-            const t1 = await queue.enqueue('t1', {}, { transaction: tx });
-            const t2 = await queue.enqueue('t2', {}, { transaction: tx });
-            await queue.cancel(t1.id, { transaction: tx });
-            const u1 = await queue.getTask(t1.id, { transaction: tx });
-            expect(u1?.status).toBe(TaskStatus.Cancelled);
-            const u2 = await queue.getTask(t2.id, { transaction: tx });
-            expect(u2?.status).toBe(TaskStatus.Pending);
-        });
-    });
-});

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

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

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

@@ -1,9 +0,0 @@
-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.d.ts

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

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

@@ -1,258 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { CancellationToken } from '../../cancellation/index.js';
-import { getRepository } from '../../orm/server/index.js';
-import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { PostgresTask } from '../../task-queue/postgres/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-describe('Worker & Base Class Tests', () => {
-    let injector;
-    let queue;
-    let token;
-    let otherQueueName;
-    let taskRepository;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-        taskRepository = injector.resolve(getRepository(PostgresTask));
-        otherQueueName = `other-queue-${crypto.randomUUID()}`;
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `worker-queue-${crypto.randomUUID()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 200, // Short visibility for testing lease loss
-        });
-        token = new CancellationToken();
-    });
-    afterEach(async () => {
-        token.set();
-        const namespace = queue.getTransactionalContextData().namespace;
-        // Clear foreign keys
-        await taskRepository.updateManyByQuery({ namespace }, { parentId: null });
-        await taskRepository.updateManyByQuery({ namespace: otherQueueName }, { parentId: null });
-        await queue.clear();
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        await queueProvider.get(otherQueueName).clear();
-        vi.restoreAllMocks();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should process tasks using process() helper', async () => {
-        const t1 = await queue.enqueue('work', { val: 1 });
-        const t2 = await queue.enqueue('work', { val: 2 });
-        const processed = [];
-        queue.process({ cancellationSignal: token }, async (context) => {
-            processed.push(context.data['val']);
-            return TaskProcessResult.Complete();
-        });
-        // Wait until 2 tasks are processed
-        for (let i = 0; i < 50; i++) {
-            if (processed.length == 2)
-                break;
-            queue.notify();
-            await timeout(20);
-        }
-        token.set(); // Stop worker
-        await queue.waitForTasks([t1.id, t2.id], { interval: 50, timeout: 1000 });
-        expect(processed).toContain(1);
-        expect(processed).toContain(2);
-        expect(processed.length).toBe(2);
-        const check1 = await queue.getTask(t1.id);
-        const check2 = await queue.getTask(t2.id);
-        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', {});
-        queue.process({ cancellationSignal: token }, async () => {
-            throw new Error('worker error');
-        });
-        // Wait until task is processed (error recorded and status is Retrying)
-        for (let i = 0; i < 50; i++) {
-            const updated = await queue.getTask(task.id);
-            if (updated?.tries == 1 && updated.status == TaskStatus.Retrying) {
-                break;
-            }
-            queue.notify();
-            await timeout(20);
-        }
-        token.set();
-        const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskStatus.Retrying); // Should retry
-        expect(updated?.tries).toBe(1);
-        expect(updated?.errors[0]?.message).toBe('worker error');
-    });
-    it('should extend lease (heartbeat) during long processing', async () => {
-        const task = await queue.enqueue('long', {});
-        let executed = false;
-        queue.process({ cancellationSignal: token }, async (_context) => {
-            // Simulate long work > visibilityTimeout (200ms)
-            await timeout(300);
-            executed = true;
-            return TaskProcessResult.Complete();
-        });
-        queue.notify();
-        await queue.waitForTasks([task.id], { timeout: 5000 });
-        token.set();
-        expect(executed).toBe(true);
-        const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskStatus.Completed);
-    });
-    it('should handle TaskResult actions (Fail, Reschedule)', async () => {
-        const tFail = await queue.enqueue('fail-action', {});
-        const tResched = await queue.enqueue('resched-action', {});
-        const processed = new Set();
-        queue.process({ cancellationSignal: token }, async (context) => {
-            processed.add(context.id);
-            if (context.id == tFail.id) {
-                return TaskProcessResult.Fail(new Error('explicit fail'));
-            }
-            if (context.id == tResched.id) {
-                return TaskProcessResult.RescheduleBy(1000);
-            }
-            return TaskProcessResult.Complete();
-        });
-        // Wait until tasks are processed (error/reschedule recorded and status is Retrying/Pending)
-        for (let i = 0; i < 50; i++) {
-            const uFail = await queue.getTask(tFail.id);
-            const uResched = await queue.getTask(tResched.id);
-            if (uFail?.tries == 1 && uFail.status == TaskStatus.Retrying && uResched?.status == TaskStatus.Pending && (uResched?.scheduleTimestamp ?? 0) > Date.now()) {
-                break;
-            }
-            queue.notify();
-            await timeout(20);
-        }
-        token.set();
-        const uFail = await queue.getTask(tFail.id);
-        expect(uFail?.status).toBe(TaskStatus.Retrying); // Retry
-        expect(uFail?.errors[0]?.message).toBe('explicit fail');
-        const uResched = await queue.getTask(tResched.id);
-        expect(uResched?.status).toBe(TaskStatus.Pending);
-        expect(uResched?.scheduleTimestamp).toBeGreaterThan(Date.now());
-    });
-    it('should exercise TaskContext methods', async () => {
-        const task = await queue.enqueue('context-test', { val: 1 });
-        let executed = false;
-        queue.process({ cancellationSignal: token, types: ['context-test'] }, async (context) => {
-            expect(context.id).toBe(task.id);
-            expect(context.data).toEqual({ val: 1 });
-            expect(context.attempt).toBe(1);
-            expect(context.triesLeft).toBeGreaterThan(0);
-            expect(context.logger).toBeDefined();
-            expect(context.signal).toBeDefined();
-            await context.checkpoint({ progress: 0.5 });
-            const child = await context.spawn('child', { c: 1 });
-            expect(child.parentId).toBe(task.id);
-            const children = await context.spawnMany([{ type: 'child', data: { c: 2 } }]);
-            expect(children[0]?.parentId).toBe(task.id);
-            // Other queue spawn
-            const otherQueue = injector.resolve(TaskQueueProvider).get(otherQueueName);
-            const otherChild = await context.spawn(otherQueue, 'other', { x: 1 });
-            expect(otherChild.namespace).toBe(otherQueueName);
-            await context.spawnMany(otherQueue, [{ type: 'other', data: { x: 2 } }]);
-            executed = true;
-            return TaskProcessResult.Complete();
-        });
-        // Complete children so parent can finalize
-        void (async () => {
-            while (!executed) {
-                await timeout(50);
-                queue.notify();
-            }
-            // At this point parent should be WaitingChildren if children are not done
-            await queue.waitForTasks([task.id], { statuses: [TaskStatus.WaitingChildren], timeout: 2000 });
-            const midTask = await queue.getTask(task.id);
-            expect(midTask?.status).toBe(TaskStatus.WaitingChildren);
-            while (true) {
-                const dChild = await queue.dequeue({ types: ['child'] });
-                if (!dChild) {
-                    // Check other-queue as well
-                    const otherQueue = injector.resolve(TaskQueueProvider).get(otherQueueName);
-                    const dOther = await otherQueue.dequeue();
-                    if (dOther) {
-                        await otherQueue.complete(dOther);
-                        continue;
-                    }
-                    break;
-                }
-                await queue.complete(dChild);
-            }
-        })();
-        queue.notify();
-        await queue.waitForTasks([task.id], { interval: 50, timeout: 2000 });
-        token.set();
-        expect(executed).toBe(true);
-        const finalTask = await queue.getTask(task.id);
-        expect(finalTask?.status).toBe(TaskStatus.Completed);
-    });
-    it('should correctly report isFinalAttempt in TaskContext', async () => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `final-try-test-${crypto.randomUUID()}`;
-        const testQueue = queueProvider.get(queueName, {
-            maxTries: 2,
-            retryDelayMinimum: 0,
-            retryDelayGrowth: 1,
-        });
-        await testQueue.enqueue('work', {});
-        testQueue.notify();
-        const finalAttemptValues = [];
-        testQueue.process({ cancellationSignal: token }, async (context) => {
-            finalAttemptValues.push(context.isFinalAttempt);
-            if (context.attempt == 1) {
-                throw new Error('fail first attempt');
-            }
-            return TaskProcessResult.Complete();
-        });
-        for (let i = 0; i < 100; i++) {
-            if (finalAttemptValues.length == 2)
-                break;
-            testQueue.notify();
-            await timeout(20);
-        }
-        token.set();
-        expect(finalAttemptValues).toEqual([false, true]);
-        await testQueue.clear();
-    });
-    it('should handle unsupported task result action', async () => {
-        const task = await queue.enqueue('unsupported-action', {});
-        const workerPromise = queue.processWorker(token, () => ({ payload: { action: 'magic' } }));
-        await expect(workerPromise).rejects.toThrow('Unsupported task result action');
-        const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskStatus.Dead); // Fatal now
-        expect(updated?.errors[0]?.message).toContain('Unsupported task result action');
-    });
-    it('should not crash worker lane if fail() throws', async () => {
-        const t1 = await queue.enqueue('task1', {});
-        const t2 = await queue.enqueue('task2', {});
-        let t1Processed = false;
-        let t2Processed = false;
-        // Mock fail to throw once
-        const failSpy = vi.spyOn(queue, 'fail').mockRejectedValueOnce(new Error('DB DOWN'));
-        queue.process({ cancellationSignal: token }, async (context) => {
-            if (context.id === t1.id) {
-                t1Processed = true;
-                throw new Error('Task 1 failed');
-            }
-            if (context.id === t2.id) {
-                t2Processed = true;
-                return TaskProcessResult.Complete();
-            }
-            return TaskProcessResult.Complete();
-        });
-        // Wait until both tasks are processed
-        // If the bug exists, the worker lane will crash after t1 and t2 will never be processed
-        for (let i = 0; i < 40; i++) {
-            if (t1Processed && t2Processed)
-                break;
-            queue.notify();
-            await timeout(50);
-        }
-        token.set();
-        expect(t1Processed).toBe(true);
-        expect(t2Processed).toBe(true);
-        expect(failSpy).toHaveBeenCalled();
-        const check2 = await queue.getTask(t2.id);
-        expect(check2?.status).toBe(TaskStatus.Completed);
-    });
-});

package/task-queue/tests/zombie-parent.test.d.ts

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

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

@@ -1,45 +0,0 @@
-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('Zombie Parent Deadlock', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `zombie-queue-${crypto.randomUUID()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should resolve parent even if child fails (abortOnDependencyFailure: false)', async () => {
-        const parent = await queue.enqueue('parent', {});
-        const dParent = await queue.dequeue();
-        // Spawn a child that will fail. Parent has abortOnDependencyFailure: false by default.
-        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, abortOnDependencyFailure: false }], { returnTasks: true });
-        await queue.complete(dParent);
-        // Parent should be WaitingChildren
-        const uParent = await queue.getTask(parent.id);
-        expect(uParent?.status).toBe(TaskStatus.WaitingChildren);
-        // Fail the child fatally
-        const dChild = await queue.dequeue();
-        await queue.fail(dChild, new Error('child failed'), { fatal: true });
-        // Verify child is Dead
-        const uChild = await queue.getTask(child.id);
-        expect(uChild?.status).toBe(TaskStatus.Dead);
-        // Wait a bit for dependency resolution
-        await timeout(200);
-        // Parent should NOT be stuck. It should transition to Completed because the child is terminal.
-        const fParent = await queue.getTask(parent.id);
-        expect(fParent?.status).toBe(TaskStatus.Completed);
-    });
-});

package/task-queue/tests/zombie-recovery.test.d.ts

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

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

@@ -1,51 +0,0 @@
-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('Zombie Recovery Race Condition', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `zombie-recovery-queue-${crypto.randomUUID()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 100, // Very short visibility timeout
-            retryDelayMinimum: 0,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should NOT prematurely complete a recovered parent when children finish', async () => {
-        // 1. Enqueue parent
-        const parent = await queue.enqueue('parent', {});
-        // 2. Dequeue parent (it is now Running, startTimestamp is set)
-        const dParent = await queue.dequeue();
-        expect(dParent?.id).toBe(parent.id);
-        expect(dParent?.startTimestamp).not.toBeNull();
-        // 3. Parent spawns a child that it waits for
-        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id }], { returnTasks: true });
-        // 4. Simulate crash: Wait for visibility timeout so it becomes a zombie
-        await timeout(200);
-        // 5. Run maintenance to recover the zombie parent
-        await queue.maintenance();
-        // Verify it was recovered to Pending
-        const recoveredParent = await queue.getTask(parent.id);
-        expect(recoveredParent?.status).toBe(TaskStatus.Retrying);
-        // If the bug exists, startTimestamp is still set here.
-        // 6. Complete the child while parent is still Pending
-        const dChild = await queue.dequeue({ types: ['child'] });
-        await queue.complete(dChild);
-        // 7. Verify parent status
-        // BUG: evaluateTaskStatus will see unresolvedCompleteDependencies=0 and startTimestamp != null,
-        // and incorrectly transition the Pending parent to Completed.
-        const finalParent = await queue.getTask(parent.id);
-        expect(finalParent?.status).toBe(TaskStatus.Retrying); // It should still be pending execution!
-    });
-});

package/utils/tests/backoff.test.d.ts

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

package/utils/tests/backoff.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { BackoffHelper } from '../backoff.js';
-describe('BackoffHelper', () => {
-    it('should support full jitter', () => {
-        const helper = new BackoffHelper({
-            initialDelay: 1000,
-            jitter: 1,
-            jitterStrategy: 'full',
-        });
-        for (let i = 0; i < 100; i++) {
-            const delay = helper.getNextDelay();
-            // Full jitter should be between 0 and the base delay (1000 for first call, then 2000, 4000, etc.)
-            expect(delay).toBeGreaterThanOrEqual(0);
-            expect(delay).toBeLessThanOrEqual(1000 * Math.pow(2, i));
-        }
-    });
-    it('should support proportional jitter (default)', () => {
-        const helper = new BackoffHelper({
-            initialDelay: 1000,
-            jitter: 0.1,
-            jitterStrategy: 'proportional',
-        });
-        for (let i = 0; i < 1; i++) {
-            const delay = helper.getNextDelay();
-            // Proportional jitter should be 1000 ± 100 (900 to 1100)
-            expect(delay).toBeGreaterThanOrEqual(900);
-            expect(delay).toBeLessThanOrEqual(1100);
-        }
-    });
-    it('should provide status emission', () => {
-        const helper = new BackoffHelper({ initialDelay: 1000 });
-        expect(helper.status.attempt).toBe(0);
-        expect(helper.status.currentDelay).toBe(1000);
-        helper.getNextDelay();
-        expect(helper.status.attempt).toBe(1);
-        expect(helper.status.currentDelay).toBe(2000);
-        helper.reset();
-        expect(helper.status.attempt).toBe(0);
-        expect(helper.status.currentDelay).toBe(1000);
-    });
-});

package/utils/tests/retry-with-backoff.test.d.ts

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

package/utils/tests/retry-with-backoff.test.js

@@ -1,49 +0,0 @@
-import { TimeoutError } from '../../errors/timeout.error.js';
-import { describe, expect, it } from 'vitest';
-import { retryWithBackoff } from '../retry-with-backoff.js';
-describe('retryWithBackoff', () => {
-    it('should return result on success', async () => {
-        const result = await retryWithBackoff(async () => 'success');
-        expect(result).toBe('success');
-    });
-    it('should retry on failure if shouldRetry returns true', async () => {
-        let attempts = 0;
-        const result = await retryWithBackoff(async () => {
-            attempts++;
-            if (attempts < 3) {
-                throw new Error('fail');
-            }
-            return 'success';
-        }, {
-            retry: {
-                shouldRetry: (_error, attempt) => attempt < 5,
-                backoff: { initialDelay: 0 },
-            },
-        });
-        expect(result).toBe('success');
-        expect(attempts).toBe(3);
-    });
-    it('should throw after max retries', async () => {
-        let attempts = 0;
-        const execute = retryWithBackoff(async () => {
-            attempts++;
-            throw new Error('fail');
-        }, {
-            retry: {
-                shouldRetry: (_error, attempt) => attempt < 2,
-                backoff: { initialDelay: 0 },
-            },
-        });
-        await expect(execute).rejects.toThrow('fail');
-        expect(attempts).toBe(3); // 0, 1, 2
-    });
-    it('should timeout if execution takes too long', async () => {
-        const execute = retryWithBackoff(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            return 'success';
-        }, {
-            timeout: 50,
-        });
-        await expect(execute).rejects.toThrow(TimeoutError);
-    });
-});