import { Queue } from "@corvid-agent/queue";

const queue = new Queue({ concurrency: 3 });

// Add tasks — returns a promise with the result
const result = await queue.add(async () => {
  const res = await fetch("/api/data");
  return res.json();
});

// Add multiple tasks at once
const results = await queue.addAll([
  () => fetchUser(1),
  () => fetchUser(2),
  () => fetchUser(3),
]);

const queue = new Queue({ concurrency: 1 });

queue.add(() => lowPriorityWork());                    // priority: 0 (default)
queue.add(() => urgentWork(), { priority: 10 });       // runs first
queue.add(() => mediumWork(), { priority: 5 });        // runs second

const queue = new Queue({ concurrency: 2, maxSize: 100 });

try {
  await queue.add(() => work());
} catch (err) {
  // QueueFullError when queue exceeds maxSize
}

const queue = new Queue({ autoStart: false }); // starts paused

queue.add(() => task1());
queue.add(() => task2());

queue.resume();  // start processing
queue.pause();   // stop starting new tasks (running tasks finish)
queue.resume();  // continue

const controller = new AbortController();

const promise = queue.add(() => fetchData(), {
  signal: controller.signal,
});

controller.abort(); // removes from queue, rejects with TaskAbortedError

import { TaskTimeoutError } from "@corvid-agent/queue";

try {
  await queue.add(() => slowOperation(), { timeout: 5000 });
} catch (err) {
  if (err instanceof TaskTimeoutError) {
    console.log(`Timed out after ${err.timeout}ms`);
  }
}

// Constant delay between retries
await queue.add(() => flakeyApi(), {
  retries: 3,
  retryDelay: 1000,
});

// Exponential backoff: 100ms, 200ms, 400ms
await queue.add(() => flakeyApi(), {
  retries: 3,
  retryDelay: (attempt) => 100 * Math.pow(2, attempt - 1),
});

const queue = new Queue({ concurrency: 5 });

// ... process tasks ...

console.log(queue.stats);
// { processed: 100, succeeded: 95, failed: 5, retries: 12, timedOut: 2 }

queue.resetStats(); // reset all counters

const queue = new Queue({ concurrency: 5 });

queue.on("active", () => console.log(`Task started. Active: ${queue.active}`));
queue.on("completed", (result) => console.log("Task done:", result));
queue.on("error", (err) => console.error("Task failed:", err));
queue.on("idle", () => console.log("All done"));
queue.on("empty", () => console.log("Pending queue empty"));

// Wait for specific states
await queue.onIdle();    // all tasks completed
await queue.onEmpty();   // pending queue empty
await queue.onDrained(); // everything processed

import { map, each, filter } from "@corvid-agent/queue";

// Concurrent map — preserves order
const users = await map(userIds, (id) => fetchUser(id), { concurrency: 5 });

// Concurrent side effects
await each(emails, (email) => sendNotification(email), { concurrency: 10 });

// Concurrent filter
const alive = await filter(servers, async (server) => {
  const res = await fetch(server.healthUrl);
  return res.ok;
}, { concurrency: 20 });