@tstdl/base 0.93.127 → 0.93.128

package/orm/tests/repository-expiration.test.js

@@ -51,7 +51,7 @@ describe('ORM Repository Expiration', () => {
     ], TtlEntity.prototype, "name", void 0);
     TtlEntity = __decorate([
         Table('ttl_entities', { schema }),
-        TimeToLive(1000, 'hard') // 1s TTL
+        TimeToLive(100, 'hard') // 100ms TTL
     ], TtlEntity);
     beforeAll(async () => {
         injector = new Injector('Test');
@@ -95,8 +95,8 @@ describe('ORM Repository Expiration', () => {
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(TtlEntity);
             const e1 = await repository.insert(Object.assign(new TtlEntity(), { name: 'Valid' }));
-            // Wait 1.1s for expiration
-            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // Wait 150ms for expiration
+            await new Promise((resolve) => setTimeout(resolve, 150));
             await repository.processExpirations();
             const all = await repository.loadAll({ withDeleted: true });
             expect(all).toHaveLength(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.127",
+  "version": "0.93.128",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/rate-limit/tests/postgres-rate-limiter.test.js

@@ -11,7 +11,7 @@ describe('PostgresRateLimiter Integration Tests', () => {
         const rateLimiterProvider = injector.resolve(RateLimiterProvider);
         rateLimiter = rateLimiterProvider.get(limiterName, {
             burstCapacity: 10,
-            refillInterval: 1000, // 10 tokens per second -> 1 token per 100ms
+            refillInterval: 500, // 10 tokens per 500ms -> 1 token per 50ms
         });
     });
     afterAll(async () => {
@@ -30,9 +30,9 @@ describe('PostgresRateLimiter Integration Tests', () => {
         const resource = 'res-2';
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        // Wait for 2 tokens (200ms)
-        await timeout(250);
-        expect(await rateLimiter.tryAcquire(resource, 2)).toBe(true);
+        // Wait for 1 token (50ms) + buffer
+        await timeout(75);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(true);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
     });
     it('should refund tokens', async () => {
@@ -55,7 +55,9 @@ describe('PostgresRateLimiter Integration Tests', () => {
         await rateLimiter.tryAcquire(resource, 0);
         const results = await Promise.all(Array.from({ length: 20 }).map(() => rateLimiter.tryAcquire(resource, 1)));
         const successCount = results.filter(Boolean).length;
-        expect(successCount).toBe(10);
+        // We expect 10, but allow up to 12 if tokens refilled during the Promise.all
+        expect(successCount).toBeGreaterThanOrEqual(10);
+        expect(successCount).toBeLessThanOrEqual(12);
     }, 15000);
     it('should always allow zero or negative cost', async () => {
         const resource = 'res-zero';
@@ -72,8 +74,8 @@ describe('PostgresRateLimiter Integration Tests', () => {
         // Drain
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        // Wait for full refill (1s) + extra
-        await timeout(1200);
+        // Wait for full refill (500ms) + extra
+        await timeout(600);
         // Should only have 10 tokens
         expect(await rateLimiter.tryAcquire(resource, 10)).toBe(true);
         // Should be empty again immediately

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

@@ -15,13 +15,13 @@ describe('Complex Queue Scenarios', () => {
         // Configure with specific settings for testing logic
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
-            priorityAgingInterval: 100, // Fast aging
+            priorityAgingInterval: 50, // Fast aging
             priorityAgingStep: 10,
             rateLimit: 5,
-            rateInterval: 500,
-            retryDelayMinimum: 100,
+            rateInterval: 50,
+            retryDelayMinimum: 50,
             retryDelayGrowth: 2,
-            retention: 100, // Fast retention for archive test
+            retention: 50, // Fast retention for archive test
         });
     });
     afterEach(async () => {
@@ -33,12 +33,12 @@ describe('Complex Queue Scenarios', () => {
         await injector?.dispose();
     });
     async function waitForStatus(id, status) {
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             const task = await queue.getTask(id);
             if (task?.status === status)
                 return;
             await queue.processPendingFanIn();
-            await timeout(50);
+            await timeout(10);
         }
     }
     describe('Complex Dependencies', () => {
@@ -62,7 +62,7 @@ describe('Complex Queue Scenarios', () => {
             // Process B
             const dB = await queue.dequeue({ types: ['B'] });
             await queue.complete(dB);
-            await timeout(100);
+            await timeout(20);
             await queue.processPendingFanIn();
             // D still waiting (needs C)
             const uD2 = await queue.getTask(taskD.id);
@@ -105,8 +105,8 @@ describe('Complex Queue Scenarios', () => {
     describe('Scheduling & Priorities', () => {
         it('should promote priority of old pending tasks (Aging)', async () => {
             const t1 = await queue.enqueue('low', {}, { priority: 2000 });
-            // Wait for aging interval (100ms)
-            await timeout(150);
+            // Wait for aging interval (50ms)
+            await timeout(60);
             await queue.maintenance();
             const updated = await queue.getTask(t1.id);
             // Default step is 10. 2000 - 10 = 1990
@@ -120,7 +120,7 @@ describe('Complex Queue Scenarios', () => {
             const u1 = await queue.getTask(task.id);
             expect(u1?.tries).toBe(1);
             const delay1 = u1.scheduleTimestamp - currentTimestamp();
-            expect(delay1).toBeGreaterThan(150); // Approx check
+            expect(delay1).toBeGreaterThan(20); // Approx check
             // Force reschedule to now
             await queue.reschedule(task.id, currentTimestamp());
             // Try 2
@@ -129,12 +129,12 @@ describe('Complex Queue Scenarios', () => {
             const u2 = await queue.getTask(task.id);
             expect(u2?.tries).toBe(2);
             const now = currentTimestamp();
-            expect(u2.scheduleTimestamp > now + 300).toBe(true);
+            expect(u2.scheduleTimestamp > now + 50).toBe(true);
         });
     });
     describe('Rate Limiting & Concurrency', () => {
         it('should limit burst dequeue rate', async () => {
-            // Rate limit 5, interval 500ms
+            // Rate limit 5, interval 100ms
             await queue.enqueueMany(Array.from({ length: 10 }, (_, i) => ({ type: 'burst', data: { i } })));
             // Request burstCapacity (5)
             const batch1 = await queue.dequeueMany(5);
@@ -143,7 +143,7 @@ describe('Complex Queue Scenarios', () => {
             const batch2 = await queue.dequeueMany(1);
             expect(batch2.length).toBe(0); // Rate limited
             // Wait for refill
-            await timeout(600);
+            await timeout(60);
             const batch3 = await queue.dequeueMany(5);
             expect(batch3.length).toBe(5); // Refilled
         });
@@ -179,8 +179,8 @@ describe('Complex Queue Scenarios', () => {
             expect(before).toBeDefined();
             expect(before?.status).toBe(TaskStatus.Completed);
             expect(before.completeTimestamp > 0).toBe(true);
-            // Wait for retention (100ms).
-            await timeout(500);
+            // Wait for retention (50ms).
+            await timeout(60);
             await archiveQueue.maintenance();
             // Should move from main table to archive
             const loaded = await archiveQueue.getTask(task.id);
@@ -189,9 +189,9 @@ describe('Complex Queue Scenarios', () => {
             await archiveQueue.clear();
         });
         it('should prune expired pending tasks', async () => {
-            // Time to live: 100ms
-            const task = await queue.enqueue('expire-me', {}, { timeToLive: currentTimestamp() + 100 });
-            await timeout(150);
+            // Time to live: 50ms
+            const task = await queue.enqueue('expire-me', {}, { timeToLive: currentTimestamp() + 50 });
+            await timeout(60);
             await queue.maintenance();
             const updated = await queue.getTask(task.id);
             expect(updated?.status).toBe(TaskStatus.Dead);
@@ -206,7 +206,7 @@ describe('Complex Queue Scenarios', () => {
             const d = await queue.dequeue();
             await queue.complete(d);
             // Force move
-            await timeout(200);
+            await timeout(60);
             await queue.maintenance();
             // Verify retrieval
             const fromArchive = await queue.getTask(task.id);
@@ -215,7 +215,7 @@ describe('Complex Queue Scenarios', () => {
         });
         it('should defer archival of parent tasks until children are archived', async () => {
             const qProvider = injector.resolve(TaskQueueProvider);
-            const treeQueue = qProvider.get(`archive-tree-${Date.now()}`, { retention: 100 });
+            const treeQueue = qProvider.get(`archive-tree-${Date.now()}`, { retention: 50 });
             const parent = await treeQueue.enqueue('parent', {});
             const child = await treeQueue.enqueue('child', {}, { parentId: parent.id });
             const d1 = await treeQueue.dequeue();
@@ -223,7 +223,7 @@ describe('Complex Queue Scenarios', () => {
             await treeQueue.complete(d1);
             await treeQueue.complete(d2);
             // Wait for retention
-            await timeout(200);
+            await timeout(60);
             // First maintenance: should archive child, but parent stays because child is still in main table (until it's deleted in the same tx maybe? No, loadMany happens before delete)
             await treeQueue.maintenance();
             const parentStillActive = await treeQueue.getTask(parent.id);
@@ -282,7 +282,7 @@ describe('Complex Queue Scenarios', () => {
             for (let i = 0; i < 5; i++) {
                 if (u?.status == TaskStatus.Waiting)
                     break;
-                await timeout(50);
+                await timeout(10);
                 u = await queue.getTask(dependent.id);
             }
             expect(u?.status).toBe(TaskStatus.Waiting); // Should still be waiting because dependency didn't Complete

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

@@ -22,6 +22,16 @@ 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)
@@ -35,7 +45,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             expect(dequeued?.id).toBe(prereq.id);
             await queue.complete(dequeued);
-            await queue.processPendingFanIn();
+            await waitForStatus(dependent.id, TaskStatus.Completed);
             const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Completed);
         });
@@ -50,7 +60,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             // 3. Complete prereq
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             await queue.complete(dequeued);
-            await queue.processPendingFanIn();
+            await waitForStatus(dependent.id, TaskStatus.Pending);
             // 5. Dependent should be Pending (ready to run)
             const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Pending);
@@ -67,16 +77,8 @@ describe('Queue Dependencies & Tree Tests', () => {
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             // Fail fatally
             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 === TaskStatus.Dead)
-                    break;
-                await queue.processPendingFanIn(); // Retry processing if it didn't catch it yet
-            }
+            await waitForStatus(dependent.id, TaskStatus.Dead);
+            const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Dead);
             expect(updatedDependent?.error?.code).toBe('DependencyFailed');
         });
@@ -90,7 +92,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.enqueue('t1', {}, { tags: ['tag-1'] });
             const d1 = await queue.dequeue({ types: ['t1'] });
             await queue.complete(d1);
-            await queue.processPendingFanIn();
+            await waitForStatus(dependent.id, TaskStatus.Pending);
             const updated = await queue.getTask(dependent.id);
             expect(updated?.status).toBe(TaskStatus.Pending);
         });

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

@@ -134,11 +134,11 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
         const queueProvider = injector.resolve(TaskQueueProvider);
         const queueName = `pg-test-queue-${Date.now()}-${Math.random()}`;
         queue = queueProvider.get(queueName, {
-            visibilityTimeout: 200, // Short timeout for testing
+            visibilityTimeout: 50, // Short timeout for testing
             retryDelayMinimum: 50,
             retryDelayGrowth: 1,
             circuitBreakerThreshold: 2,
-            circuitBreakerResetTimeout: 200,
+            circuitBreakerResetTimeout: 50,
         });
     });
     afterEach(async () => {
@@ -188,11 +188,11 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             expect((t3?.data)['foo']).toBe('low');
         });
         it('should not dequeue a task scheduled in the future', async () => {
-            const future = currentTimestamp() + 500;
+            const future = currentTimestamp() + 100;
             await queue.enqueue('foo', { foo: 'future' }, { scheduleTimestamp: future });
             const task = await queue.dequeue();
             expect(task).toBeUndefined();
-            await timeout(600);
+            await timeout(150);
             const taskLater = await queue.dequeue();
             expect(taskLater).toBeDefined();
         });
@@ -237,8 +237,8 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             ]);
             await queue.fail((await queue.dequeue()), 'err');
             await queue.fail((await queue.dequeue()), 'err');
-            // Breaker is Open. Wait for reset timeout (200ms)
-            await timeout(250);
+            // Breaker is Open. Wait for reset timeout (50ms)
+            await timeout(75);
             const probe = await queue.dequeue();
             expect(probe).toBeDefined();
             const secondAttempt = await queue.dequeue();
@@ -249,8 +249,8 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
         it('should recover "Zombie" tasks (crashed workers)', async () => {
             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);
+            // processTimeout is 50ms. Wait for it to expire.
+            await timeout(100);
             await queue.maintenance();
             const recovered = await queue.getTask(task.id);
             expect(recovered?.status).toBe(TaskStatus.Pending);
@@ -260,10 +260,10 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
         it('should fail tasks that exceed Hard Execution Timeout via prune', async () => {
             // Re-configure queue with very short execution timeout
             const queueProvider = injector.resolve(TaskQueueProvider);
-            const shortQueue = queueProvider.get(`prune-test-${Date.now()}`, { maxExecutionTime: 100 });
+            const shortQueue = queueProvider.get(`prune-test-${Date.now()}`, { maxExecutionTime: 50 });
             const task = await shortQueue.enqueue('foo', { foo: 'long-running' });
             await shortQueue.dequeue();
-            await timeout(200);
+            await timeout(75);
             await shortQueue.maintenance();
             const updated = await shortQueue.getTask(task.id);
             expect(updated?.status).toBe(TaskStatus.Dead);
@@ -274,7 +274,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const task = await queue.enqueue('foo', { foo: 'work' });
             const dequeued = await queue.dequeue();
             const initialLock = dequeued.visibilityDeadline;
-            await timeout(50);
+            await timeout(20);
             const touched = await queue.touch(dequeued);
             expect(touched?.visibilityDeadline > initialLock).toBe(true);
         });
@@ -282,8 +282,8 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             await queue.enqueue('foo', { foo: 'work' });
             const dequeued = await queue.dequeue();
             expect(dequeued).toBeDefined();
-            // processTimeout is 200ms. Wait for it to expire.
-            await timeout(300);
+            // processTimeout is 50ms. Wait for it to expire.
+            await timeout(100);
             await queue.maintenance();
             await queue.dequeue(); // Stolen by another worker (tries=2)
             // Original worker tries to touch

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

@@ -14,7 +14,7 @@ describe('Worker & Base Class Tests', () => {
         const queueProvider = injector.resolve(TaskQueueProvider);
         const queueName = `worker-queue-${Date.now()}-${Math.random()}`;
         queue = queueProvider.get(queueName, {
-            visibilityTimeout: 500, // Short visibility for testing lease loss
+            visibilityTimeout: 200, // Short visibility for testing lease loss
         });
         token = new CancellationToken();
     });
@@ -36,10 +36,10 @@ describe('Worker & Base Class Tests', () => {
             return TaskProcessResult.Complete();
         });
         // Wait until 2 tasks are processed
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             if (processed.length === 2)
                 break;
-            await timeout(100);
+            await timeout(20);
         }
         token.set(); // Stop worker
         expect(processed).toContain(1);
@@ -55,7 +55,7 @@ describe('Worker & Base Class Tests', () => {
         queue.process({ cancellationSignal: token }, async () => {
             throw new Error('worker error');
         });
-        await timeout(200);
+        await timeout(50);
         token.set();
         const updated = await queue.getTask(task.id);
         expect(updated?.status).toBe(TaskStatus.Pending); // Should retry
@@ -66,12 +66,12 @@ describe('Worker & Base Class Tests', () => {
         const task = await queue.enqueue('long', {});
         let executed = false;
         queue.process({ cancellationSignal: token }, async (_context) => {
-            // Simulate long work > visibilityTimeout (500ms)
-            await timeout(700);
+            // Simulate long work > visibilityTimeout (200ms)
+            await timeout(300);
             executed = true;
             return TaskProcessResult.Complete();
         });
-        await timeout(1000);
+        await timeout(500);
         token.set();
         expect(executed).toBe(true);
         const updated = await queue.getTask(task.id);
@@ -91,10 +91,10 @@ describe('Worker & Base Class Tests', () => {
             }
             return TaskProcessResult.Complete();
         });
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             if (processed.size === 2)
                 break;
-            await timeout(100);
+            await timeout(20);
         }
         token.set();
         const uFail = await queue.getTask(tFail.id);
@@ -129,10 +129,10 @@ describe('Worker & Base Class Tests', () => {
             executed = true;
             return TaskProcessResult.Complete();
         });
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             if (executed)
                 break;
-            await timeout(100);
+            await timeout(20);
         }
         token.set();
         expect(executed).toBe(true);
@@ -159,7 +159,7 @@ describe('Worker & Base Class Tests', () => {
             if (finalAttemptValues.length === 2)
                 break;
             testQueue.notify();
-            await timeout(100);
+            await timeout(20);
         }
         token.set();
         expect(finalAttemptValues).toEqual([false, true]);

package/testing/integration-setup.d.ts

@@ -2,6 +2,7 @@ import type { PoolConfig } from 'pg';
 import { type AuthenticationAncillaryService } from '../authentication/server/index.js';
 import { Injector } from '../injector/index.js';
 import { LogLevel } from '../logger/index.js';
+import { type S3ObjectStorageProviderConfig } from '../object-storage/s3/index.js';
 import { Database } from '../orm/server/index.js';
 import type { Type } from '../types/index.js';
 export type IntegrationTestOptions = {
@@ -13,6 +14,7 @@ export type IntegrationTestOptions = {
         baseUrl?: string;
         port?: number;
     };
+    s3?: Partial<S3ObjectStorageProviderConfig>;
     logLevels?: Record<string, LogLevel>;
     modules?: {
         api?: boolean;

package/testing/integration-setup.js

@@ -98,7 +98,11 @@ export async function setupIntegrationTest(options = {}) {
         }
         if (options.modules?.authentication) {
             configureAuthenticationServer({
-                serviceOptions: { secret: 'test-secret' },
+                serviceOptions: {
+                    secret: 'test-secret',
+                    hashIterations: 10,
+                    signingSecretsDerivationIterations: 10,
+                },
                 authenticationAncillaryService: options.authenticationAncillaryService,
                 injector,
             });
@@ -121,13 +125,15 @@ export async function setupIntegrationTest(options = {}) {
             await runInInjectionContext(injector, migrateDocumentManagementSchema);
         }
         if (options.modules?.objectStorage) {
+            const bucketPerModule = options.s3?.bucketPerModule ?? configParser.boolean('S3_BUCKET_PER_MODULE', true);
             configureS3ObjectStorage({
-                endpoint: configParser.string('S3_ENDPOINT', 'http://127.0.0.1:9000'),
-                accessKey: configParser.string('S3_ACCESS_KEY', 'tstdl-dev'),
-                secretKey: configParser.string('S3_SECRET_KEY', 'tstdl-dev'),
-                bucket: configParser.string('S3_BUCKET', 'test-bucket'),
-                region: configParser.string('S3_REGION', 'us-east-1'),
-                forcePathStyle: configParser.boolean('S3_FORCE_PATH_STYLE', true),
+                endpoint: options.s3?.endpoint ?? configParser.string('S3_ENDPOINT', 'http://127.0.0.1:9000'),
+                accessKey: options.s3?.accessKey ?? configParser.string('S3_ACCESS_KEY', 'tstdl-dev'),
+                secretKey: options.s3?.secretKey ?? configParser.string('S3_SECRET_KEY', 'tstdl-dev'),
+                bucket: bucketPerModule ? undefined : (options.s3?.bucket ?? configParser.string('S3_BUCKET', 'test-bucket')),
+                bucketPerModule,
+                region: options.s3?.region ?? configParser.string('S3_REGION', 'us-east-1'),
+                forcePathStyle: options.s3?.forcePathStyle ?? configParser.boolean('S3_FORCE_PATH_STYLE', true),
                 injector,
             });
         }

package/utils/backoff.d.ts

@@ -1,5 +1,6 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 export type BackoffStrategy = 'linear' | 'exponential';
+export type JitterStrategy = 'full' | 'proportional';
 /**
  * Configuration for the backoff behavior.
  */
@@ -11,6 +12,13 @@ export type BackoffOptions = {
      * @default 'exponential'
      */
     strategy?: BackoffStrategy;
+    /**
+     * The strategy to use for applying jitter.
+     * - `full`: Random value between 0 and the calculated delay.
+     * - `proportional`: Random value within `± jitter * delay`.
+     * @default 'proportional'
+     */
+    jitterStrategy?: JitterStrategy;
     /**
      * The initial delay in milliseconds. Must be non-negative.
      * @default 1000
@@ -32,7 +40,8 @@ export type BackoffOptions = {
     /**
      * A factor to randomize the delay, e.g., 0.1 for 10% jitter.
      * This helps prevent the "thundering herd" problem in distributed systems.
-     * The actual delay will be `delay ± delay * jitter`.
+     * For `proportional` jitter, the actual delay will be `delay ± delay * jitter`.
+     * For `full` jitter, this value is ignored.
      * Must be a value between 0 and 1.
      * @default 0.15
      */
@@ -59,14 +68,20 @@ export type BackoffLoopController = {
     /**
      * Schedules a backoff delay before the next iteration of the loop.
      * If this is not called, the backoff delay is reset for the next attempt.
+     * @param delay An optional explicit delay in milliseconds to use for the next backoff.
+     * If not provided, the backoff strategy is used.
      */
-    backoff: () => void;
+    backoff: (delay?: number) => void;
     /**
      * Immediately breaks out of the loop.
      */
     break: () => void;
 };
-export type BackoffLoopFunction = (controller: BackoffLoopController, cancellationSignal: CancellationSignal) => unknown;
+export type BackoffStatus = {
+    attempt: number;
+    currentDelay: number;
+};
+export type BackoffLoopFunction = (controller: BackoffLoopController, cancellationSignal: CancellationSignal, status: BackoffStatus) => unknown;
 /**
  * A function yielded by `backoffGenerator` to control the next iteration.
  */
@@ -82,6 +97,7 @@ export type BackoffGeneratorCallback = (options?: {
  */
 export declare const DEFAULT_BACKOFF_OPTIONS: {
     readonly strategy: "exponential";
+    readonly jitterStrategy: "proportional";
     readonly initialDelay: 1000;
     readonly increase: 2;
     readonly maximumDelay: 30000;
@@ -93,6 +109,14 @@ export declare const DEFAULT_BACKOFF_OPTIONS: {
 export declare class BackoffHelper {
     private readonly options;
     private currentDelay;
+    private attempt;
+    /**
+     * The current status of the backoff.
+     */
+    get status(): {
+        attempt: number;
+        currentDelay: number;
+    };
     /**
      * Creates a new BackoffHelper.
      * @param options Partial backoff options, which will be merged with sane defaults.