flowx-control 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1122 @@
+// src/types.ts
+var FlowXError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "FlowXError";
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var TimeoutError = class extends FlowXError {
+  constructor(message = "Operation timed out") {
+    super(message, "ERR_TIMEOUT");
+    this.name = "TimeoutError";
+  }
+};
+var CircuitBreakerError = class extends FlowXError {
+  constructor(message = "Circuit breaker is open") {
+    super(message, "ERR_CIRCUIT_OPEN");
+    this.name = "CircuitBreakerError";
+  }
+};
+var BulkheadError = class extends FlowXError {
+  constructor(message = "Bulkhead capacity exceeded") {
+    super(message, "ERR_BULKHEAD_FULL");
+    this.name = "BulkheadError";
+  }
+};
+var AbortError = class extends FlowXError {
+  constructor(message = "Operation aborted") {
+    super(message, "ERR_ABORTED");
+    this.name = "AbortError";
+  }
+};
+var RateLimitError = class extends FlowXError {
+  constructor(message = "Rate limit exceeded") {
+    super(message, "ERR_RATE_LIMIT");
+    this.name = "RateLimitError";
+  }
+};
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new AbortError());
+      return;
+    }
+    let onAbort;
+    const timer = setTimeout(() => {
+      if (signal && onAbort) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve();
+    }, ms);
+    if (signal) {
+      onAbort = () => {
+        clearTimeout(timer);
+        reject(new AbortError());
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function calculateDelay(attempt, baseDelay, strategy, jitter = false) {
+  let delay;
+  if (typeof strategy === "function") {
+    delay = strategy(attempt, baseDelay);
+  } else {
+    switch (strategy) {
+      case "fixed":
+        delay = baseDelay;
+        break;
+      case "linear":
+        delay = baseDelay * attempt;
+        break;
+      case "exponential":
+        delay = baseDelay * Math.pow(2, attempt - 1);
+        break;
+    }
+  }
+  if (jitter) {
+    const factor = typeof jitter === "number" ? jitter : 1;
+    delay = delay * (1 - factor * 0.5 + Math.random() * factor);
+  }
+  return Math.max(0, Math.floor(delay));
+}
+
+// src/retry.ts
+async function retry(fn, options) {
+  const {
+    retries = 3,
+    delay = 1e3,
+    backoff = "exponential",
+    jitter = false,
+    maxDelay = 3e4,
+    shouldRetry,
+    onRetry,
+    signal
+  } = options ?? {};
+  if (retries < 0) {
+    throw new RangeError("retries must be >= 0");
+  }
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    if (signal?.aborted) {
+      throw new AbortError("Retry aborted");
+    }
+    try {
+      const result = await fn();
+      return result;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === retries) break;
+      if (shouldRetry) {
+        const shouldContinue = await shouldRetry(lastError, attempt + 1);
+        if (!shouldContinue) break;
+      }
+      if (onRetry) {
+        await onRetry(lastError, attempt + 1);
+      }
+      let waitTime = calculateDelay(attempt + 1, delay, backoff, jitter);
+      waitTime = Math.min(waitTime, maxDelay);
+      await sleep(waitTime, signal);
+    }
+  }
+  throw lastError;
+}
+function retryable(fn, options) {
+  return (...args) => retry(() => fn(...args), options);
+}
+
+// src/circuit-breaker.ts
+function createCircuitBreaker(fn, options) {
+  const {
+    failureThreshold = 5,
+    resetTimeout = 3e4,
+    halfOpenLimit = 1,
+    shouldTrip,
+    onStateChange,
+    successThreshold = 1
+  } = options ?? {};
+  let state = "closed";
+  let failureCount = 0;
+  let successCount = 0;
+  let halfOpenActive = 0;
+  let resetTimer = null;
+  function transition(to) {
+    if (state === to) return;
+    const from = state;
+    state = to;
+    onStateChange?.(from, to);
+  }
+  function scheduleReset() {
+    if (resetTimer) clearTimeout(resetTimer);
+    resetTimer = setTimeout(() => {
+      resetTimer = null;
+      transition("half-open");
+      halfOpenActive = 0;
+      successCount = 0;
+    }, resetTimeout);
+  }
+  function reset() {
+    if (resetTimer) {
+      clearTimeout(resetTimer);
+      resetTimer = null;
+    }
+    failureCount = 0;
+    successCount = 0;
+    halfOpenActive = 0;
+    transition("closed");
+  }
+  function manualOpen() {
+    if (resetTimer) {
+      clearTimeout(resetTimer);
+      resetTimer = null;
+    }
+    failureCount = 0;
+    successCount = 0;
+    halfOpenActive = 0;
+    transition("open");
+    scheduleReset();
+  }
+  async function fire(...args) {
+    if (state === "open") {
+      throw new CircuitBreakerError();
+    }
+    if (state === "half-open" && halfOpenActive >= halfOpenLimit) {
+      throw new CircuitBreakerError("Circuit breaker is half-open \u2014 limit reached");
+    }
+    if (state === "half-open") {
+      halfOpenActive++;
+    }
+    try {
+      const result = await fn(...args);
+      if (state === "half-open") {
+        successCount++;
+        halfOpenActive--;
+        if (successCount >= successThreshold) {
+          reset();
+        }
+      } else {
+        failureCount = 0;
+      }
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (shouldTrip && !shouldTrip(err)) {
+        if (state === "half-open") {
+          halfOpenActive--;
+        }
+        throw err;
+      }
+      if (state === "half-open") {
+        halfOpenActive--;
+        transition("open");
+        scheduleReset();
+      } else {
+        failureCount++;
+        if (failureCount >= failureThreshold) {
+          transition("open");
+          scheduleReset();
+        }
+      }
+      throw err;
+    }
+  }
+  return {
+    fire,
+    get state() {
+      return state;
+    },
+    get failureCount() {
+      return failureCount;
+    },
+    get successCount() {
+      return successCount;
+    },
+    reset,
+    open: manualOpen
+  };
+}
+
+// src/bulkhead.ts
+function createBulkhead(options) {
+  const { concurrency = 10, queueSize = 10, queueTimeout = 0 } = options ?? {};
+  if (concurrency < 1) throw new RangeError("concurrency must be >= 1");
+  if (queueSize < 0) throw new RangeError("queueSize must be >= 0");
+  let active = 0;
+  const queue = [];
+  function tryDequeue() {
+    while (queue.length > 0 && active < concurrency) {
+      const item = queue.shift();
+      if (item.timer) clearTimeout(item.timer);
+      run(item);
+    }
+  }
+  async function run(item) {
+    active++;
+    try {
+      const value = await item.fn();
+      active--;
+      tryDequeue();
+      item.resolve(value);
+    } catch (error) {
+      active--;
+      tryDequeue();
+      item.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  function execute(fn) {
+    if (active < concurrency) {
+      return new Promise((resolve, reject) => {
+        run({ fn, resolve, reject });
+      });
+    }
+    if (queue.length >= queueSize) {
+      return Promise.reject(new BulkheadError());
+    }
+    return new Promise((resolve, reject) => {
+      const item = { fn, resolve, reject };
+      if (queueTimeout > 0) {
+        item.timer = setTimeout(() => {
+          const idx = queue.indexOf(item);
+          if (idx !== -1) {
+            queue.splice(idx, 1);
+            reject(new BulkheadError("Bulkhead queue timeout exceeded"));
+          }
+        }, queueTimeout);
+      }
+      queue.push(item);
+    });
+  }
+  return {
+    execute,
+    get active() {
+      return active;
+    },
+    get queued() {
+      return queue.length;
+    },
+    get available() {
+      return Math.max(0, concurrency - active);
+    }
+  };
+}
+
+// src/fallback.ts
+async function withFallback(fn, fallback, options) {
+  try {
+    return await fn();
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    if (options?.shouldFallback && !options.shouldFallback(err)) {
+      throw err;
+    }
+    options?.onFallback?.(err, 0);
+    if (typeof fallback === "function") {
+      return await fallback();
+    }
+    return fallback;
+  }
+}
+async function fallbackChain(fns, options) {
+  if (fns.length === 0) {
+    throw new Error("fallbackChain requires at least one function");
+  }
+  let lastError;
+  for (let i = 0; i < fns.length; i++) {
+    try {
+      return await fns[i]();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (options?.shouldFallback && !options.shouldFallback(lastError)) {
+        throw lastError;
+      }
+      if (i < fns.length - 1) {
+        options?.onFallback?.(lastError, i + 1);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/hedge.ts
+function hedge(fn, options) {
+  const { delay = 500, maxHedges = 1 } = options ?? {};
+  if (delay < 0) throw new RangeError("delay must be >= 0");
+  if (maxHedges < 1) throw new RangeError("maxHedges must be >= 1");
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let completedCount = 0;
+    const totalAttempts = 1 + maxHedges;
+    const errors = [];
+    const timers = [];
+    function onResult(value) {
+      if (settled) return;
+      settled = true;
+      for (const t of timers) clearTimeout(t);
+      resolve(value);
+    }
+    function onError(error) {
+      errors.push(error);
+      completedCount++;
+      if (completedCount >= totalAttempts && !settled) {
+        settled = true;
+        reject(errors[0]);
+      }
+    }
+    fn().then(onResult, (err) => onError(err instanceof Error ? err : new Error(String(err))));
+    for (let i = 0; i < maxHedges; i++) {
+      const timer = setTimeout(
+        () => {
+          if (settled) return;
+          fn().then(
+            onResult,
+            (err) => onError(err instanceof Error ? err : new Error(String(err)))
+          );
+        },
+        delay * (i + 1)
+      );
+      timers.push(timer);
+    }
+  });
+}
+
+// src/semaphore.ts
+function createSemaphore(permits) {
+  if (permits < 1) throw new RangeError("permits must be >= 1");
+  let available = permits;
+  const waiters = [];
+  function release() {
+    available++;
+    if (waiters.length > 0) {
+      available--;
+      const next = waiters.shift();
+      next.resolve(release);
+    }
+  }
+  function acquire() {
+    if (available > 0) {
+      available--;
+      return Promise.resolve(release);
+    }
+    return new Promise((resolve) => {
+      waiters.push({ resolve });
+    });
+  }
+  async function runExclusive(fn) {
+    const releaseFn = await acquire();
+    try {
+      return await fn();
+    } finally {
+      releaseFn();
+    }
+  }
+  return {
+    acquire,
+    runExclusive,
+    get available() {
+      return available;
+    },
+    get waiting() {
+      return waiters.length;
+    }
+  };
+}
+
+// src/mutex.ts
+function createMutex() {
+  let locked = false;
+  const waitQueue = [];
+  function release() {
+    if (waitQueue.length > 0) {
+      const next = waitQueue.shift();
+      next(release);
+    } else {
+      locked = false;
+    }
+  }
+  function lock() {
+    if (!locked) {
+      locked = true;
+      return Promise.resolve(release);
+    }
+    return new Promise((resolve) => {
+      waitQueue.push(resolve);
+    });
+  }
+  async function runExclusive(fn) {
+    const releaseFn = await lock();
+    try {
+      return await fn();
+    } finally {
+      releaseFn();
+    }
+  }
+  return {
+    lock,
+    runExclusive,
+    get isLocked() {
+      return locked;
+    },
+    get waiting() {
+      return waitQueue.length;
+    }
+  };
+}
+
+// src/queue.ts
+function createQueue(options) {
+  const { concurrency = 1, autoStart = true, timeout = 0 } = options ?? {};
+  if (concurrency < 1) throw new RangeError("concurrency must be >= 1");
+  let paused = !autoStart;
+  let active = 0;
+  const entries = [];
+  const emptyCallbacks = [];
+  const idleCallbacks = [];
+  function notifyIdle() {
+    if (active === 0 && entries.length === 0) {
+      for (const cb of idleCallbacks.splice(0)) cb();
+    }
+  }
+  function notifyEmpty() {
+    if (entries.length === 0) {
+      for (const cb of emptyCallbacks.splice(0)) cb();
+    }
+  }
+  function tryRun() {
+    if (paused) return;
+    while (active < concurrency && entries.length > 0) {
+      const entry = entries.shift();
+      active++;
+      let timer;
+      const run = async () => {
+        try {
+          let result;
+          if (timeout > 0) {
+            result = await Promise.race([
+              entry.fn(),
+              new Promise((_, rej) => {
+                timer = setTimeout(() => rej(new Error("Queue task timeout")), timeout);
+              })
+            ]);
+          } else {
+            result = await entry.fn();
+          }
+          if (timer) clearTimeout(timer);
+          entry.resolve(result);
+        } catch (error) {
+          if (timer) clearTimeout(timer);
+          entry.reject(error instanceof Error ? error : new Error(String(error)));
+        } finally {
+          active--;
+          notifyEmpty();
+          tryRun();
+          notifyIdle();
+        }
+      };
+      run();
+    }
+    notifyEmpty();
+    notifyIdle();
+  }
+  function add(fn, addOptions) {
+    const priority = addOptions?.priority ?? 0;
+    return new Promise((resolve, reject) => {
+      const entry = { fn, priority, resolve, reject };
+      let inserted = false;
+      for (let i = 0; i < entries.length; i++) {
+        if (priority < entries[i].priority) {
+          entries.splice(i, 0, entry);
+          inserted = true;
+          break;
+        }
+      }
+      if (!inserted) {
+        entries.push(entry);
+      }
+      tryRun();
+    });
+  }
+  function addAll(fns, addOptions) {
+    return Promise.all(fns.map((fn) => add(fn, addOptions)));
+  }
+  function pause() {
+    paused = true;
+  }
+  function resume() {
+    paused = false;
+    tryRun();
+  }
+  function clear() {
+    for (const entry of entries.splice(0)) {
+      entry.reject(new Error("Queue cleared"));
+    }
+  }
+  function onEmpty() {
+    if (entries.length === 0) return Promise.resolve();
+    return new Promise((resolve) => emptyCallbacks.push(resolve));
+  }
+  function onIdle() {
+    if (active === 0 && entries.length === 0) return Promise.resolve();
+    return new Promise((resolve) => idleCallbacks.push(resolve));
+  }
+  return {
+    add,
+    addAll,
+    pause,
+    resume,
+    clear,
+    onEmpty,
+    onIdle,
+    get size() {
+      return entries.length;
+    },
+    get pending() {
+      return active;
+    },
+    get isPaused() {
+      return paused;
+    }
+  };
+}
+
+// src/rate-limit.ts
+function createRateLimiter(options) {
+  const { limit, interval, strategy = "queue" } = options;
+  if (limit < 1) throw new RangeError("limit must be >= 1");
+  if (interval < 1) throw new RangeError("interval must be >= 1");
+  let tokens = limit;
+  let lastRefill = Date.now();
+  const queue = [];
+  let drainTimer = null;
+  function refill() {
+    const now = Date.now();
+    const elapsed = now - lastRefill;
+    const refillCount = Math.floor(elapsed / interval) * limit;
+    if (refillCount > 0) {
+      tokens = Math.min(limit, tokens + refillCount);
+      lastRefill = now;
+    }
+  }
+  function drainQueue() {
+    refill();
+    while (queue.length > 0 && tokens > 0) {
+      tokens--;
+      const item = queue.shift();
+      item.resolve();
+    }
+    if (queue.length > 0) {
+      scheduleDrain();
+    } else {
+      drainTimer = null;
+    }
+  }
+  function scheduleDrain() {
+    if (drainTimer) return;
+    const timeToNextToken = interval / limit;
+    drainTimer = setTimeout(() => {
+      drainTimer = null;
+      drainQueue();
+    }, timeToNextToken);
+  }
+  async function execute(fn) {
+    refill();
+    if (tokens > 0) {
+      tokens--;
+      return await fn();
+    }
+    if (strategy === "reject") {
+      throw new RateLimitError();
+    }
+    await new Promise((resolve) => {
+      queue.push({ resolve });
+      scheduleDrain();
+    });
+    return await fn();
+  }
+  function reset() {
+    tokens = limit;
+    lastRefill = Date.now();
+    if (drainTimer) {
+      clearTimeout(drainTimer);
+      drainTimer = null;
+    }
+    drainQueue();
+  }
+  return {
+    execute,
+    reset,
+    get remaining() {
+      refill();
+      return tokens;
+    }
+  };
+}
+
+// src/timeout.ts
+async function withTimeout(fn, ms, options) {
+  if (ms <= 0) {
+    throw new RangeError("Timeout must be > 0");
+  }
+  if (options?.signal?.aborted) {
+    throw new AbortError();
+  }
+  const fnResult = fn();
+  return Promise.race([
+    Promise.resolve(fnResult),
+    new Promise((_, reject) => {
+      const timer = setTimeout(() => {
+        if (options?.fallback !== void 0) {
+          const fb = options.fallback;
+          if (typeof fb === "function") {
+            try {
+              const result = fb();
+              Promise.resolve(result).then(
+                (v) => reject({ __resolved: true, value: v }),
+                reject
+              );
+            } catch (err) {
+              reject(err);
+            }
+          } else {
+            reject({ __resolved: true, value: fb });
+          }
+        } else {
+          reject(new TimeoutError(options?.message));
+        }
+      }, ms);
+      if (options?.signal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          reject(new AbortError());
+        };
+        options.signal.addEventListener("abort", onAbort, { once: true });
+      }
+      Promise.resolve(fnResult).then(
+        () => clearTimeout(timer),
+        () => clearTimeout(timer)
+      );
+    })
+  ]).catch((err) => {
+    if (err && typeof err === "object" && "__resolved" in err) {
+      return err.value;
+    }
+    throw err;
+  });
+}
+
+// src/debounce.ts
+function debounce(fn, wait, options) {
+  const { leading = false, trailing = true, maxWait } = options ?? {};
+  if (wait < 0) throw new RangeError("wait must be >= 0");
+  let timer = null;
+  let maxTimer = null;
+  let lastArgs = null;
+  const pendingResolvers = [];
+  let isPending = false;
+  async function invoke() {
+    const args = lastArgs;
+    const resolvers = pendingResolvers.splice(0);
+    lastArgs = null;
+    isPending = false;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (maxTimer) {
+      clearTimeout(maxTimer);
+      maxTimer = null;
+    }
+    try {
+      const result = await fn(...args);
+      for (const r of resolvers) r.resolve(result);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      for (const r of resolvers) r.reject(err);
+    }
+  }
+  function debounced(...args) {
+    lastArgs = args;
+    return new Promise((resolve, reject) => {
+      pendingResolvers.push({ resolve, reject });
+      if (leading && !isPending) {
+        isPending = true;
+        invoke();
+        return;
+      }
+      isPending = true;
+      if (timer) clearTimeout(timer);
+      if (trailing) {
+        timer = setTimeout(() => {
+          timer = null;
+          invoke();
+        }, wait);
+      }
+      if (maxWait !== void 0 && !maxTimer) {
+        maxTimer = setTimeout(() => {
+          maxTimer = null;
+          if (timer) {
+            clearTimeout(timer);
+            timer = null;
+          }
+          invoke();
+        }, maxWait);
+      }
+    });
+  }
+  debounced.cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (maxTimer) {
+      clearTimeout(maxTimer);
+      maxTimer = null;
+    }
+    lastArgs = null;
+    isPending = false;
+    const resolvers = pendingResolvers.splice(0);
+    for (const r of resolvers) {
+      r.reject(new Error("Debounced call cancelled"));
+    }
+  };
+  debounced.flush = async () => {
+    if (!isPending) return void 0;
+    const promise = new Promise((resolve, reject) => {
+      pendingResolvers.push({ resolve, reject });
+    });
+    await invoke();
+    return promise;
+  };
+  Object.defineProperty(debounced, "pending", {
+    get() {
+      return isPending;
+    }
+  });
+  return debounced;
+}
+
+// src/throttle.ts
+function throttle(fn, wait, options) {
+  const { leading = true, trailing = true } = options ?? {};
+  if (wait < 0) throw new RangeError("wait must be >= 0");
+  let lastCallTime = null;
+  let timer = null;
+  let lastArgs = null;
+  let isPending = false;
+  const trailingResolvers = [];
+  async function invokeTrailing() {
+    const args = lastArgs;
+    const resolvers = trailingResolvers.splice(0);
+    lastArgs = null;
+    isPending = false;
+    timer = null;
+    if (!args) {
+      for (const r of resolvers) r.resolve(void 0);
+      return;
+    }
+    try {
+      const result = await fn(...args);
+      for (const r of resolvers) r.resolve(result);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      for (const r of resolvers) r.reject(err);
+    }
+  }
+  function throttled(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    const timeSinceLastCall = lastCallTime === null ? wait : now - lastCallTime;
+    const shouldCallLeading = leading && timeSinceLastCall >= wait;
+    if (shouldCallLeading) {
+      lastCallTime = now;
+      lastArgs = null;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      const prevResolvers = trailingResolvers.splice(0);
+      const resultPromise = (async () => {
+        try {
+          const result = await fn(...args);
+          for (const r of prevResolvers) r.resolve(result);
+          return result;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          for (const r of prevResolvers) r.reject(err);
+          throw err;
+        }
+      })();
+      if (trailing) {
+        timer = setTimeout(() => {
+          lastCallTime = Date.now();
+          invokeTrailing();
+        }, wait);
+      }
+      return resultPromise;
+    }
+    isPending = true;
+    return new Promise((resolve, reject) => {
+      trailingResolvers.push({ resolve, reject });
+      if (!timer && trailing) {
+        const remaining = wait - timeSinceLastCall;
+        timer = setTimeout(() => {
+          lastCallTime = Date.now();
+          invokeTrailing();
+        }, remaining);
+      }
+    });
+  }
+  throttled.cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    lastArgs = null;
+    lastCallTime = null;
+    isPending = false;
+    const resolvers = trailingResolvers.splice(0);
+    for (const r of resolvers) {
+      r.reject(new Error("Throttled call cancelled"));
+    }
+  };
+  Object.defineProperty(throttled, "pending", {
+    get() {
+      return isPending;
+    }
+  });
+  return throttled;
+}
+
+// src/batch.ts
+async function batch(items, fn, options) {
+  const { concurrency = Infinity, batchSize = 1, onProgress, signal } = options ?? {};
+  if (batchSize < 1) throw new RangeError("batchSize must be >= 1");
+  if (concurrency < 1) throw new RangeError("concurrency must be >= 1");
+  const results = new Array(items.length);
+  const errors = /* @__PURE__ */ new Map();
+  let completed = 0;
+  let succeeded = 0;
+  let failed = 0;
+  const batches = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    batches.push({
+      items: items.slice(i, i + batchSize),
+      startIndex: i
+    });
+  }
+  let batchIndex = 0;
+  async function processBatch() {
+    while (batchIndex < batches.length) {
+      if (signal?.aborted) throw new AbortError();
+      const currentBatch = batches[batchIndex++];
+      for (let i = 0; i < currentBatch.items.length; i++) {
+        if (signal?.aborted) throw new AbortError();
+        const globalIndex = currentBatch.startIndex + i;
+        try {
+          results[globalIndex] = await fn(currentBatch.items[i], globalIndex);
+          succeeded++;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          errors.set(globalIndex, err);
+          results[globalIndex] = void 0;
+          failed++;
+        }
+        completed++;
+        onProgress?.(completed, items.length);
+      }
+    }
+  }
+  const workers = [];
+  const workerCount = Math.min(concurrency, batches.length);
+  for (let i = 0; i < workerCount; i++) {
+    workers.push(processBatch());
+  }
+  await Promise.all(workers);
+  return {
+    results,
+    total: items.length,
+    succeeded,
+    failed,
+    errors
+  };
+}
+
+// src/pipeline.ts
+function pipeline(...steps) {
+  if (steps.length === 0) {
+    throw new Error("pipeline requires at least one step");
+  }
+  return async (input) => {
+    let current = input;
+    for (const step of steps) {
+      current = await step(current);
+    }
+    return current;
+  };
+}
+async function pipe(input, ...steps) {
+  if (steps.length === 0) {
+    throw new Error("pipe requires at least one step");
+  }
+  let current = input;
+  for (const step of steps) {
+    current = await step(current);
+  }
+  return current;
+}
+
+// src/poll.ts
+function poll(fn, options) {
+  const {
+    interval = 1e3,
+    until,
+    maxAttempts = Infinity,
+    backoff = "fixed",
+    signal
+  } = options ?? {};
+  if (interval < 0) throw new RangeError("interval must be >= 0");
+  let stopped = false;
+  let rejectFn = null;
+  const result = (async () => {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      if (stopped || signal?.aborted) {
+        throw new AbortError("Polling stopped");
+      }
+      const value = await fn();
+      if (until ? until(value) : true) {
+        return value;
+      }
+      if (attempt < maxAttempts) {
+        const waitTime = calculateDelay(attempt, interval, backoff);
+        await sleep(waitTime, signal).catch((err) => {
+          if (stopped) throw new AbortError("Polling stopped");
+          throw err;
+        });
+      }
+    }
+    throw new Error("Polling exceeded maximum attempts");
+  })();
+  const wrappedResult = new Promise((resolve, reject) => {
+    rejectFn = reject;
+    result.then(resolve, reject);
+  });
+  function stop() {
+    stopped = true;
+    rejectFn?.(new AbortError("Polling stopped"));
+  }
+  return {
+    result: wrappedResult,
+    stop
+  };
+}
+
+// src/deferred.ts
+function createDeferred() {
+  let isSettled = false;
+  let isResolved = false;
+  let isRejected = false;
+  let resolveFn;
+  let rejectFn;
+  const promise = new Promise((resolve, reject) => {
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+  return {
+    promise,
+    resolve: (value) => {
+      if (isSettled) return;
+      isSettled = true;
+      isResolved = true;
+      resolveFn(value);
+    },
+    reject: (reason) => {
+      if (isSettled) return;
+      isSettled = true;
+      isRejected = true;
+      rejectFn(reason);
+    },
+    get isSettled() {
+      return isSettled;
+    },
+    get isResolved() {
+      return isResolved;
+    },
+    get isRejected() {
+      return isRejected;
+    }
+  };
+}
+
+// src/memo.ts
+function memo(fn, options) {
+  const {
+    ttl = 0,
+    maxSize = 0,
+    keyFn = (...args) => JSON.stringify(args),
+    cacheErrors = false
+  } = options ?? {};
+  const cache = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  function isExpired(entry) {
+    if (ttl <= 0) return false;
+    return Date.now() - entry.timestamp > ttl;
+  }
+  function evict() {
+    if (maxSize <= 0 || cache.size < maxSize) return;
+    const firstKey = cache.keys().next().value;
+    if (firstKey !== void 0) {
+      cache.delete(firstKey);
+    }
+  }
+  async function memoized(...args) {
+    const key = keyFn(...args);
+    const cached = cache.get(key);
+    if (cached && !isExpired(cached)) {
+      cache.delete(key);
+      cache.set(key, cached);
+      if (cached.isError) {
+        throw cached.value;
+      }
+      return cached.value;
+    }
+    if (cached) {
+      cache.delete(key);
+    }
+    const inflight = pending.get(key);
+    if (inflight) return inflight;
+    const promise = fn(...args).then((value) => {
+      evict();
+      cache.set(key, { value, timestamp: Date.now(), isError: false });
+      pending.delete(key);
+      return value;
+    }).catch((error) => {
+      pending.delete(key);
+      if (cacheErrors) {
+        evict();
+        cache.set(key, { value: error, timestamp: Date.now(), isError: true });
+      }
+      throw error;
+    });
+    pending.set(key, promise);
+    return promise;
+  }
+  memoized.clear = () => {
+    cache.clear();
+    pending.clear();
+  };
+  memoized.delete = (...args) => {
+    const key = keyFn(...args);
+    return cache.delete(key);
+  };
+  Object.defineProperty(memoized, "size", {
+    get() {
+      return cache.size;
+    }
+  });
+  return memoized;
+}
+
+export { AbortError, BulkheadError, CircuitBreakerError, FlowXError, RateLimitError, TimeoutError, batch, calculateDelay, createBulkhead, createCircuitBreaker, createDeferred, createMutex, createQueue, createRateLimiter, createSemaphore, debounce, fallbackChain, hedge, memo, pipe, pipeline, poll, retry, retryable, sleep, throttle, withFallback, withTimeout };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map