@zapier/zapier-sdk 0.18.4 → 0.19.0

package/dist/utils/batch-utils.js

@@ -1,162 +0,0 @@
-/**
- * Batch Operation Utilities
- *
- * This module provides utilities for executing multiple async operations
- * with concurrency control and retry logic.
- */
-import { setTimeout } from "timers/promises";
-import { calculateWaitTime, MAX_CONSECUTIVE_ERRORS } from "./retry-utils";
-import { ZapierTimeoutError } from "../types/errors";
-/**
- * Default number of concurrent operations
- * Chosen to be "polite" to APIs while still providing good throughput
- */
-const DEFAULT_CONCURRENCY = 10;
-/**
- * Delay between starting each batch of concurrent operations (milliseconds)
- * This prevents burst patterns that might trigger rate limiting
- */
-const BATCH_START_DELAY_MS = 25;
-/**
- * Default timeout for entire batch operation (milliseconds)
- * Set to 3 minutes to match polling default timeout
- */
-const DEFAULT_BATCH_TIMEOUT_MS = 180000;
-/**
- * Execute multiple async operations with concurrency limiting and retry logic
- *
- * This prevents overwhelming APIs by:
- * 1. Limiting concurrent operations (worker pool pattern)
- * 2. Adding small delays between batches to avoid burst detection
- * 3. Retrying failed operations with exponential backoff
- *
- * Problem Solved:
- * - Rate limit prevention: Steady stream instead of burst requests
- * - Connection pool management: Stays within browser/Node limits (~6-8 per domain)
- * - Resilience: Transient failures are retried automatically
- * - Observability: Returns detailed success/failure info for each operation
- *
- * Example Usage:
- * ```typescript
- * // Instead of Promise.allSettled (fires all at once):
- * const results = await Promise.allSettled(
- *   actions.map(a => sdk.listInputFields(a))
- * );
- *
- * // Use batch (controlled concurrency):
- * const results = await batch(
- *   actions.map(a => () => sdk.listInputFields(a)),
- *   { concurrency: 10, retry: true }
- * );
- * ```
- *
- * @param tasks - Array of functions that return promises (NOT promises themselves!)
- * @param options - Configuration for concurrency and retry behavior
- * @returns Promise resolving to array of settled results (same as Promise.allSettled)
- */
-export async function batch(tasks, options = {}) {
-    const { concurrency = DEFAULT_CONCURRENCY, retry = true, batchDelay = BATCH_START_DELAY_MS, timeoutMs = DEFAULT_BATCH_TIMEOUT_MS, taskTimeoutMs, } = options;
-    // Validate inputs
-    if (concurrency <= 0) {
-        throw new Error("Concurrency must be greater than 0");
-    }
-    if (timeoutMs <= 0) {
-        throw new Error("Timeout must be greater than 0");
-    }
-    if (taskTimeoutMs !== undefined && taskTimeoutMs <= 0) {
-        throw new Error("Task timeout must be greater than 0");
-    }
-    if (tasks.length === 0) {
-        return [];
-    }
-    // Track overall batch timing
-    const startTime = Date.now();
-    // Pre-allocate results array to maintain input order
-    const results = new Array(tasks.length);
-    // Create task queue with retry state
-    const taskQueue = tasks.map((task, index) => ({
-        index,
-        task,
-        errorCount: 0,
-    }));
-    /**
-     * Execute a single task with retry logic and optional per-task timeout
-     */
-    async function executeTask(taskState) {
-        const { index, task, errorCount } = taskState;
-        try {
-            let result;
-            // Apply per-task timeout if specified
-            if (taskTimeoutMs !== undefined) {
-                const timeoutPromise = setTimeout(taskTimeoutMs).then(() => {
-                    throw new ZapierTimeoutError(`Task timed out after ${taskTimeoutMs}ms`);
-                });
-                result = await Promise.race([task(), timeoutPromise]);
-            }
-            else {
-                result = await task();
-            }
-            results[index] = { status: "fulfilled", value: result };
-        }
-        catch (error) {
-            const newErrorCount = errorCount + 1;
-            // Don't retry timeout errors - they're unlikely to succeed on retry
-            const isTimeout = error instanceof ZapierTimeoutError;
-            // If retry is enabled and we haven't hit max errors and it's not a timeout, retry with backoff
-            if (retry && !isTimeout && newErrorCount < MAX_CONSECUTIVE_ERRORS) {
-                // Calculate backoff delay (base 1000ms with jitter and error scaling)
-                const waitTime = calculateWaitTime(1000, newErrorCount);
-                await setTimeout(waitTime);
-                // Re-queue the task with incremented error count
-                taskQueue.push({
-                    index,
-                    task,
-                    errorCount: newErrorCount,
-                });
-            }
-            else {
-                // Max retries reached, retry disabled, or timeout error - mark as rejected
-                results[index] = { status: "rejected", reason: error };
-            }
-        }
-    }
-    /**
-     * Worker that continuously picks up and executes tasks from the queue
-     * Checks overall batch timeout before processing each task
-     */
-    async function worker() {
-        while (taskQueue.length > 0) {
-            // Check overall batch timeout before processing next task
-            const elapsedTime = Date.now() - startTime;
-            if (elapsedTime >= timeoutMs) {
-                throw new ZapierTimeoutError(`Batch operation timed out after ${Math.floor(elapsedTime / 1000)}s. ${taskQueue.length} task(s) not completed.`);
-            }
-            const taskState = taskQueue.shift();
-            if (!taskState)
-                break;
-            await executeTask(taskState);
-            // Small delay to prevent burst patterns within a worker
-            // Only delay if there are more tasks to process
-            if (taskQueue.length > 0 && batchDelay > 0) {
-                await setTimeout(batchDelay);
-            }
-        }
-    }
-    /**
-     * Start workers in small batches to avoid initial burst
-     * This helps avoid rate limit triggers when starting many workers
-     */
-    const workerCount = Math.min(concurrency, tasks.length);
-    const workers = [];
-    for (let i = 0; i < workerCount; i++) {
-        workers.push(worker());
-        // Add small delay between starting workers to stagger the initial requests
-        // Skip delay for last worker
-        if (i < workerCount - 1 && batchDelay > 0) {
-            await setTimeout(batchDelay / 10); // 10ms between worker starts
-        }
-    }
-    // Wait for all workers to complete
-    await Promise.all(workers);
-    return results;
-}

package/dist/utils/batch-utils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=batch-utils.test.d.ts.map

package/dist/utils/batch-utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch-utils.test.d.ts","sourceRoot":"","sources":["../../src/utils/batch-utils.test.ts"],"names":[],"mappings":""}

package/dist/utils/batch-utils.test.js

@@ -1,476 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { batch } from "./batch-utils";
-// Mock the timers/promises module
-vi.mock("timers/promises", () => ({
-    setTimeout: vi.fn(() => Promise.resolve()),
-}));
-// Mock retry-utils to control backoff behavior in tests
-vi.mock("./retry-utils", () => ({
-    calculateWaitTime: vi.fn(() => 0), // No delay in tests
-    MAX_CONSECUTIVE_ERRORS: 3,
-}));
-describe("batch", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("basic functionality", () => {
-        it("should execute all tasks and return settled results", async () => {
-            const tasks = [
-                () => Promise.resolve("result1"),
-                () => Promise.resolve("result2"),
-                () => Promise.resolve("result3"),
-            ];
-            const results = await batch(tasks);
-            expect(results).toEqual([
-                { status: "fulfilled", value: "result1" },
-                { status: "fulfilled", value: "result2" },
-                { status: "fulfilled", value: "result3" },
-            ]);
-        });
-        it("should handle empty task array", async () => {
-            const results = await batch([]);
-            expect(results).toEqual([]);
-        });
-        it("should handle single task", async () => {
-            const tasks = [() => Promise.resolve("single")];
-            const results = await batch(tasks);
-            expect(results).toEqual([{ status: "fulfilled", value: "single" }]);
-        });
-        it("should maintain result order matching input order", async () => {
-            // Create tasks that resolve in reverse order but should maintain input order
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("first"), 30)),
-                () => new Promise((resolve) => setTimeout(() => resolve("second"), 20)),
-                () => new Promise((resolve) => setTimeout(() => resolve("third"), 10)),
-            ];
-            const results = await batch(tasks);
-            expect(results[0]).toEqual({ status: "fulfilled", value: "first" });
-            expect(results[1]).toEqual({ status: "fulfilled", value: "second" });
-            expect(results[2]).toEqual({ status: "fulfilled", value: "third" });
-        });
-    });
-    describe("concurrency limiting", () => {
-        it("should limit concurrent execution", async () => {
-            let concurrentCount = 0;
-            let maxConcurrent = 0;
-            const createTask = () => () => {
-                concurrentCount++;
-                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
-                return new Promise((resolve) => {
-                    setTimeout(() => {
-                        concurrentCount--;
-                        resolve("done");
-                    }, 10);
-                });
-            };
-            const tasks = Array.from({ length: 20 }, createTask);
-            await batch(tasks, { concurrency: 5 });
-            // Max concurrent should not exceed limit
-            expect(maxConcurrent).toBeLessThanOrEqual(5);
-        });
-        it("should respect custom concurrency limit", async () => {
-            let concurrentCount = 0;
-            let maxConcurrent = 0;
-            const createTask = () => () => {
-                concurrentCount++;
-                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
-                return new Promise((resolve) => {
-                    setTimeout(() => {
-                        concurrentCount--;
-                        resolve("done");
-                    }, 10);
-                });
-            };
-            const tasks = Array.from({ length: 20 }, createTask);
-            await batch(tasks, { concurrency: 3 });
-            expect(maxConcurrent).toBeLessThanOrEqual(3);
-        });
-        it("should handle concurrency limit greater than task count", async () => {
-            const tasks = [() => Promise.resolve(1), () => Promise.resolve(2)];
-            const results = await batch(tasks, { concurrency: 10 });
-            expect(results).toHaveLength(2);
-        });
-    });
-    describe("error handling", () => {
-        it("should handle failing tasks without stopping batch", async () => {
-            const tasks = [
-                () => Promise.resolve("success1"),
-                () => Promise.reject(new Error("failed")),
-                () => Promise.resolve("success2"),
-            ];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0]).toEqual({ status: "fulfilled", value: "success1" });
-            expect(results[1]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(results[2]).toEqual({ status: "fulfilled", value: "success2" });
-        });
-        it("should retry failed tasks when retry is enabled", async () => {
-            let attemptCount = 0;
-            const failTwiceThenSucceed = () => {
-                attemptCount++;
-                if (attemptCount <= 2) {
-                    return Promise.reject(new Error("temporary failure"));
-                }
-                return Promise.resolve("success");
-            };
-            const tasks = [failTwiceThenSucceed];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({ status: "fulfilled", value: "success" });
-            expect(attemptCount).toBe(3); // Initial + 2 retries
-        });
-        it("should give up after MAX_CONSECUTIVE_ERRORS retries", async () => {
-            let attemptCount = 0;
-            const alwaysFail = () => {
-                attemptCount++;
-                return Promise.reject(new Error("always fails"));
-            };
-            const tasks = [alwaysFail];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(attemptCount).toBe(3); // MAX_CONSECUTIVE_ERRORS
-        });
-        it("should not retry when retry is disabled", async () => {
-            let attemptCount = 0;
-            const failTask = () => {
-                attemptCount++;
-                return Promise.reject(new Error("failed"));
-            };
-            const tasks = [failTask];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(attemptCount).toBe(1); // No retries
-        });
-    });
-    describe("options validation", () => {
-        it("should throw error for invalid concurrency", async () => {
-            const tasks = [() => Promise.resolve("test")];
-            await expect(batch(tasks, { concurrency: 0 })).rejects.toThrow("Concurrency must be greater than 0");
-            await expect(batch(tasks, { concurrency: -1 })).rejects.toThrow("Concurrency must be greater than 0");
-        });
-        it("should use default options when not provided", async () => {
-            const tasks = [() => Promise.resolve("test")];
-            const results = await batch(tasks);
-            expect(results).toEqual([{ status: "fulfilled", value: "test" }]);
-        });
-    });
-    describe("mixed success and failure scenarios", () => {
-        it("should handle alternating success and failure", async () => {
-            const tasks = [
-                () => Promise.resolve("success1"),
-                () => Promise.reject(new Error("error1")),
-                () => Promise.resolve("success2"),
-                () => Promise.reject(new Error("error2")),
-                () => Promise.resolve("success3"),
-            ];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            expect(results[2].status).toBe("fulfilled");
-            expect(results[3].status).toBe("rejected");
-            expect(results[4].status).toBe("fulfilled");
-        });
-        it("should handle some tasks succeeding after retry", async () => {
-            let task1Attempts = 0;
-            let task2Attempts = 0;
-            const task1 = () => {
-                task1Attempts++;
-                if (task1Attempts === 1) {
-                    return Promise.reject(new Error("task1 first attempt"));
-                }
-                return Promise.resolve("task1 success");
-            };
-            const task2 = () => {
-                task2Attempts++;
-                return Promise.resolve("task2 success");
-            };
-            const tasks = [task1, task2];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({
-                status: "fulfilled",
-                value: "task1 success",
-            });
-            expect(results[1]).toEqual({
-                status: "fulfilled",
-                value: "task2 success",
-            });
-            expect(task1Attempts).toBe(2); // Initial + 1 retry
-            expect(task2Attempts).toBe(1); // No retry needed
-        });
-    });
-    describe("performance characteristics", () => {
-        it("should complete faster with higher concurrency", async () => {
-            const delay = 50; // ms
-            const taskCount = 10;
-            const tasks = Array.from({ length: taskCount }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), delay)));
-            // Low concurrency (sequential-ish)
-            const start1 = Date.now();
-            await batch([...tasks], { concurrency: 1 });
-            const duration1 = Date.now() - start1;
-            // High concurrency (parallel)
-            const start2 = Date.now();
-            await batch([...tasks], { concurrency: 10 });
-            const duration2 = Date.now() - start2;
-            // High concurrency should be significantly faster
-            // Allow some margin for timing variability
-            expect(duration2).toBeLessThan(duration1 * 0.8);
-        });
-    });
-    describe("result ordering guarantees", () => {
-        it("should maintain exact order with out-of-order completion and mixed results", async () => {
-            // This is the ultimate ordering test - combining:
-            // 1. Tasks that complete in reverse order (via delays)
-            // 2. Mixed success/failure
-            // 3. High concurrency (multiple workers racing)
-            const executionLog = [];
-            const tasks = [
-                // Task 0: Slow success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task0-complete");
-                        resolve("result0");
-                    }, 100);
-                }),
-                // Task 1: Fast failure
-                () => new Promise((_, reject) => {
-                    setTimeout(() => {
-                        executionLog.push("task1-complete");
-                        reject(new Error("error1"));
-                    }, 10);
-                }),
-                // Task 2: Medium success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task2-complete");
-                        resolve("result2");
-                    }, 50);
-                }),
-                // Task 3: Instant failure
-                () => new Promise((_, reject) => {
-                    executionLog.push("task3-complete");
-                    reject(new Error("error3"));
-                }),
-                // Task 4: Medium-slow success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task4-complete");
-                        resolve("result4");
-                    }, 75);
-                }),
-            ];
-            const results = await batch(tasks, { concurrency: 5, retry: false });
-            // Verify all tasks completed
-            expect(executionLog).toHaveLength(5);
-            expect(executionLog).toContain("task0-complete");
-            expect(executionLog).toContain("task1-complete");
-            expect(executionLog).toContain("task2-complete");
-            expect(executionLog).toContain("task3-complete");
-            expect(executionLog).toContain("task4-complete");
-            // BUT results MUST maintain input order despite out-of-order completion
-            expect(results).toHaveLength(5);
-            // Task 0: position 0, slow success
-            expect(results[0]).toEqual({
-                status: "fulfilled",
-                value: "result0",
-            });
-            // Task 1: position 1, fast failure
-            expect(results[1]).toEqual({
-                status: "rejected",
-                reason: expect.objectContaining({
-                    message: "error1",
-                }),
-            });
-            // Task 2: position 2, medium success
-            expect(results[2]).toEqual({
-                status: "fulfilled",
-                value: "result2",
-            });
-            // Task 3: position 3, instant failure
-            expect(results[3]).toEqual({
-                status: "rejected",
-                reason: expect.objectContaining({
-                    message: "error3",
-                }),
-            });
-            // Task 4: position 4, medium-slow success
-            expect(results[4]).toEqual({
-                status: "fulfilled",
-                value: "result4",
-            });
-        });
-        it("should match Promise.allSettled ordering behavior exactly", async () => {
-            // This test ensures our batch function has identical ordering to Promise.allSettled
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("a"), 30)),
-                () => new Promise((_, reject) => setTimeout(() => reject(new Error("b")), 10)),
-                () => new Promise((resolve) => setTimeout(() => resolve("c"), 20)),
-            ];
-            // Run both in parallel
-            const [batchResults, settledResults] = await Promise.all([
-                batch(tasks.map((t) => t), { concurrency: 3, retry: false }),
-                Promise.allSettled(tasks.map((t) => t())),
-            ]);
-            // Results should have same structure
-            expect(batchResults).toHaveLength(settledResults.length);
-            // Compare each result
-            for (let i = 0; i < batchResults.length; i++) {
-                const batchResult = batchResults[i];
-                const settledResult = settledResults[i];
-                expect(batchResult.status).toBe(settledResult.status);
-                if (batchResult.status === "fulfilled" &&
-                    settledResult.status === "fulfilled") {
-                    expect(batchResult.value).toBe(settledResult.value);
-                }
-                if (batchResult.status === "rejected" &&
-                    settledResult.status === "rejected") {
-                    expect(batchResult.reason).toBeInstanceOf(Error);
-                    expect(settledResult.reason).toBeInstanceOf(Error);
-                }
-            }
-        });
-    });
-    describe("timeout handling", () => {
-        beforeEach(async () => {
-            // Unmock setTimeout for timeout tests to allow real timing
-            vi.unmock("timers/promises");
-            // Re-import batch to get the non-mocked version
-            vi.resetModules();
-        });
-        afterEach(() => {
-            // Restore mocks after timeout tests
-            vi.doMock("timers/promises", () => ({
-                setTimeout: vi.fn(() => Promise.resolve()),
-            }));
-        });
-        it("should throw error when overall batch timeout is exceeded", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = Array.from({ length: 10 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
-            await expect(batch(tasks, { concurrency: 2, timeoutMs: 50 })).rejects.toThrow("Batch operation timed out");
-        });
-        it("should timeout individual tasks when taskTimeoutMs is set", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("instant"), // Instant task - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow"), 500)), // Slow task - should timeout
-                () => Promise.resolve("instant2"), // Another instant task - should not timeout
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 100, // 100ms timeout
-                retry: false,
-                batchDelay: 0, // Disable batch delay for timing reliability
-            });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            if (results[1].status === "rejected") {
-                expect(results[1].reason).toBeInstanceOf(Error);
-                expect(results[1].reason.message).toContain("timed out");
-            }
-            expect(results[2].status).toBe("fulfilled");
-        });
-        it("should not retry tasks that timeout", async () => {
-            const { batch } = await import("./batch-utils");
-            let attemptCount = 0;
-            const slowTask = () => {
-                attemptCount++;
-                return new Promise((resolve) => setTimeout(() => resolve("done"), 200));
-            };
-            const results = await batch([slowTask], {
-                taskTimeoutMs: 50,
-                retry: true,
-            });
-            expect(results[0].status).toBe("rejected");
-            expect(attemptCount).toBe(1); // Should not retry timeout errors
-        });
-        it("should validate timeout parameters", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [() => Promise.resolve("test")];
-            await expect(batch(tasks, { timeoutMs: 0 })).rejects.toThrow("Timeout must be greater than 0");
-            await expect(batch(tasks, { timeoutMs: -100 })).rejects.toThrow("Timeout must be greater than 0");
-            await expect(batch(tasks, { taskTimeoutMs: 0 })).rejects.toThrow("Task timeout must be greater than 0");
-            await expect(batch(tasks, { taskTimeoutMs: -100 })).rejects.toThrow("Task timeout must be greater than 0");
-        });
-        it("should complete tasks that finish before overall timeout", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("task1"), 10)),
-                () => new Promise((resolve) => setTimeout(() => resolve("task2"), 20)),
-                () => new Promise((resolve) => setTimeout(() => resolve("task3"), 30)),
-            ];
-            const results = await batch(tasks, {
-                timeoutMs: 100,
-                concurrency: 3,
-            });
-            expect(results).toHaveLength(3);
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("fulfilled");
-            expect(results[2].status).toBe("fulfilled");
-        });
-        it("should report tasks remaining when batch timeout occurs", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = Array.from({ length: 20 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
-            try {
-                await batch(tasks, { concurrency: 2, timeoutMs: 50 });
-                expect.fail("Should have thrown timeout error");
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(Error);
-                expect(error.message).toContain("task(s) not completed");
-            }
-        });
-        it("should allow taskTimeoutMs without overall timeout affecting quick tasks", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("instant1"),
-                () => Promise.resolve("instant2"),
-                () => Promise.resolve("instant3"),
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 1000,
-                timeoutMs: 5000,
-            });
-            expect(results).toHaveLength(3);
-            expect(results.every((r) => r.status === "fulfilled")).toBe(true);
-        });
-        it("should handle mix of timed out and successful tasks", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("fast1"), // Instant - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow1"), 500)), // Slow - should timeout
-                () => Promise.resolve("fast2"), // Instant - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow2"), 500)), // Slow - should timeout
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 100,
-                retry: false,
-                concurrency: 4,
-                batchDelay: 0, // Disable batch delay for timing reliability
-            });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            expect(results[2].status).toBe("fulfilled");
-            expect(results[3].status).toBe("rejected");
-        });
-        it("should use default timeout when not specified", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("test1"),
-                () => Promise.resolve("test2"),
-            ];
-            // Should not throw with default 3-minute timeout
-            const results = await batch(tasks);
-            expect(results).toHaveLength(2);
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("fulfilled");
-        });
-    });
-});