flowx-control 1.0.0

package/dist/pipeline.d.mts

@@ -0,0 +1,42 @@
+/** A step in the pipeline */
+type PipelineStep<TIn, TOut> = (input: TIn) => TOut | Promise<TOut>;
+/**
+ * Compose multiple async functions into a single pipeline.
+ *
+ * @example
+ * ```ts
+ * const process = pipeline(
+ *   (x: number) => x * 2,
+ *   (x: number) => x + 1,
+ *   (x: number) => String(x),
+ * );
+ * const result = await process(5); // "11"
+ * ```
+ */
+declare function pipeline<A, B>(s1: PipelineStep<A, B>): (input: A) => Promise<B>;
+declare function pipeline<A, B, C>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>): (input: A) => Promise<C>;
+declare function pipeline<A, B, C, D>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>): (input: A) => Promise<D>;
+declare function pipeline<A, B, C, D, E>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>): (input: A) => Promise<E>;
+declare function pipeline<A, B, C, D, E, F>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>, s5: PipelineStep<E, F>): (input: A) => Promise<F>;
+declare function pipeline(...steps: Array<PipelineStep<any, any>>): (input: any) => Promise<any>;
+/**
+ * Execute a value through a series of async transformation steps.
+ *
+ * @example
+ * ```ts
+ * const result = await pipe(
+ *   5,
+ *   (x) => x * 2,
+ *   (x) => x + 1,
+ *   (x) => String(x),
+ * ); // "11"
+ * ```
+ */
+declare function pipe<A, B>(input: A, s1: PipelineStep<A, B>): Promise<B>;
+declare function pipe<A, B, C>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>): Promise<C>;
+declare function pipe<A, B, C, D>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>): Promise<D>;
+declare function pipe<A, B, C, D, E>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>): Promise<E>;
+declare function pipe<A, B, C, D, E, F>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>, s5: PipelineStep<E, F>): Promise<F>;
+declare function pipe(input: any, ...steps: Array<PipelineStep<any, any>>): Promise<any>;
+
+export { type PipelineStep, pipe, pipeline };

package/dist/pipeline.d.ts

@@ -0,0 +1,42 @@
+/** A step in the pipeline */
+type PipelineStep<TIn, TOut> = (input: TIn) => TOut | Promise<TOut>;
+/**
+ * Compose multiple async functions into a single pipeline.
+ *
+ * @example
+ * ```ts
+ * const process = pipeline(
+ *   (x: number) => x * 2,
+ *   (x: number) => x + 1,
+ *   (x: number) => String(x),
+ * );
+ * const result = await process(5); // "11"
+ * ```
+ */
+declare function pipeline<A, B>(s1: PipelineStep<A, B>): (input: A) => Promise<B>;
+declare function pipeline<A, B, C>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>): (input: A) => Promise<C>;
+declare function pipeline<A, B, C, D>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>): (input: A) => Promise<D>;
+declare function pipeline<A, B, C, D, E>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>): (input: A) => Promise<E>;
+declare function pipeline<A, B, C, D, E, F>(s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>, s5: PipelineStep<E, F>): (input: A) => Promise<F>;
+declare function pipeline(...steps: Array<PipelineStep<any, any>>): (input: any) => Promise<any>;
+/**
+ * Execute a value through a series of async transformation steps.
+ *
+ * @example
+ * ```ts
+ * const result = await pipe(
+ *   5,
+ *   (x) => x * 2,
+ *   (x) => x + 1,
+ *   (x) => String(x),
+ * ); // "11"
+ * ```
+ */
+declare function pipe<A, B>(input: A, s1: PipelineStep<A, B>): Promise<B>;
+declare function pipe<A, B, C>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>): Promise<C>;
+declare function pipe<A, B, C, D>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>): Promise<D>;
+declare function pipe<A, B, C, D, E>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>): Promise<E>;
+declare function pipe<A, B, C, D, E, F>(input: A, s1: PipelineStep<A, B>, s2: PipelineStep<B, C>, s3: PipelineStep<C, D>, s4: PipelineStep<D, E>, s5: PipelineStep<E, F>): Promise<F>;
+declare function pipe(input: any, ...steps: Array<PipelineStep<any, any>>): Promise<any>;
+
+export { type PipelineStep, pipe, pipeline };

package/dist/pipeline.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// 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;
+}
+
+exports.pipe = pipe;
+exports.pipeline = pipeline;
+//# sourceMappingURL=pipeline.js.map
+//# sourceMappingURL=pipeline.js.map

package/dist/pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pipeline.ts"],"names":[],"mappings":";;;AA4CO,SAAS,YAAY,KAAA,EAAoE;AAC9F,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACtB,IAAA,MAAM,IAAI,MAAM,qCAAqC,CAAA;AAAA,EACvD;AAEA,EAAA,OAAO,OAAO,KAAA,KAAe;AAC3B,IAAA,IAAI,OAAA,GAAU,KAAA;AACd,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,OAAA,GAAU,MAAM,KAAK,OAAO,CAAA;AAAA,IAC9B;AACA,IAAA,OAAO,OAAA;AAAA,EACT,CAAA;AACF;AA2CA,eAAsB,IAAA,CAAK,UAAe,KAAA,EAAoD;AAC5F,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACtB,IAAA,MAAM,IAAI,MAAM,iCAAiC,CAAA;AAAA,EACnD;AAEA,EAAA,IAAI,OAAA,GAAU,KAAA;AACd,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,OAAA,GAAU,MAAM,KAAK,OAAO,CAAA;AAAA,EAC9B;AACA,EAAA,OAAO,OAAA;AACT","file":"pipeline.js","sourcesContent":["// ============================================================================\n// FlowX — Async Pipeline Composition\n// ============================================================================\n\n/** A step in the pipeline */\nexport type PipelineStep<TIn, TOut> = (input: TIn) => TOut | Promise<TOut>;\n\n/**\n * Compose multiple async functions into a single pipeline.\n *\n * @example\n * ```ts\n * const process = pipeline(\n *   (x: number) => x * 2,\n *   (x: number) => x + 1,\n *   (x: number) => String(x),\n * );\n * const result = await process(5); // \"11\"\n * ```\n */\nexport function pipeline<A, B>(s1: PipelineStep<A, B>): (input: A) => Promise<B>;\nexport function pipeline<A, B, C>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n): (input: A) => Promise<C>;\nexport function pipeline<A, B, C, D>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n): (input: A) => Promise<D>;\nexport function pipeline<A, B, C, D, E>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n): (input: A) => Promise<E>;\nexport function pipeline<A, B, C, D, E, F>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n  s5: PipelineStep<E, F>,\n): (input: A) => Promise<F>;\nexport function pipeline(...steps: Array<PipelineStep<any, any>>): (input: any) => Promise<any>;\nexport function pipeline(...steps: Array<PipelineStep<any, any>>): (input: any) => Promise<any> {\n  if (steps.length === 0) {\n    throw new Error('pipeline requires at least one step');\n  }\n\n  return async (input: any) => {\n    let current = input;\n    for (const step of steps) {\n      current = await step(current);\n    }\n    return current;\n  };\n}\n\n/**\n * Execute a value through a series of async transformation steps.\n *\n * @example\n * ```ts\n * const result = await pipe(\n *   5,\n *   (x) => x * 2,\n *   (x) => x + 1,\n *   (x) => String(x),\n * ); // \"11\"\n * ```\n */\nexport async function pipe<A, B>(input: A, s1: PipelineStep<A, B>): Promise<B>;\nexport async function pipe<A, B, C>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n): Promise<C>;\nexport async function pipe<A, B, C, D>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n): Promise<D>;\nexport async function pipe<A, B, C, D, E>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n): Promise<E>;\nexport async function pipe<A, B, C, D, E, F>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n  s5: PipelineStep<E, F>,\n): Promise<F>;\nexport async function pipe(input: any, ...steps: Array<PipelineStep<any, any>>): Promise<any>;\nexport async function pipe(input: any, ...steps: Array<PipelineStep<any, any>>): Promise<any> {\n  if (steps.length === 0) {\n    throw new Error('pipe requires at least one step');\n  }\n\n  let current = input;\n  for (const step of steps) {\n    current = await step(current);\n  }\n  return current;\n}\n"]}

package/dist/pipeline.mjs

@@ -0,0 +1,27 @@
+// 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;
+}
+
+export { pipe, pipeline };
+//# sourceMappingURL=pipeline.mjs.map
+//# sourceMappingURL=pipeline.mjs.map

package/dist/pipeline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pipeline.ts"],"names":[],"mappings":";AA4CO,SAAS,YAAY,KAAA,EAAoE;AAC9F,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACtB,IAAA,MAAM,IAAI,MAAM,qCAAqC,CAAA;AAAA,EACvD;AAEA,EAAA,OAAO,OAAO,KAAA,KAAe;AAC3B,IAAA,IAAI,OAAA,GAAU,KAAA;AACd,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,OAAA,GAAU,MAAM,KAAK,OAAO,CAAA;AAAA,IAC9B;AACA,IAAA,OAAO,OAAA;AAAA,EACT,CAAA;AACF;AA2CA,eAAsB,IAAA,CAAK,UAAe,KAAA,EAAoD;AAC5F,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACtB,IAAA,MAAM,IAAI,MAAM,iCAAiC,CAAA;AAAA,EACnD;AAEA,EAAA,IAAI,OAAA,GAAU,KAAA;AACd,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,OAAA,GAAU,MAAM,KAAK,OAAO,CAAA;AAAA,EAC9B;AACA,EAAA,OAAO,OAAA;AACT","file":"pipeline.mjs","sourcesContent":["// ============================================================================\n// FlowX — Async Pipeline Composition\n// ============================================================================\n\n/** A step in the pipeline */\nexport type PipelineStep<TIn, TOut> = (input: TIn) => TOut | Promise<TOut>;\n\n/**\n * Compose multiple async functions into a single pipeline.\n *\n * @example\n * ```ts\n * const process = pipeline(\n *   (x: number) => x * 2,\n *   (x: number) => x + 1,\n *   (x: number) => String(x),\n * );\n * const result = await process(5); // \"11\"\n * ```\n */\nexport function pipeline<A, B>(s1: PipelineStep<A, B>): (input: A) => Promise<B>;\nexport function pipeline<A, B, C>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n): (input: A) => Promise<C>;\nexport function pipeline<A, B, C, D>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n): (input: A) => Promise<D>;\nexport function pipeline<A, B, C, D, E>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n): (input: A) => Promise<E>;\nexport function pipeline<A, B, C, D, E, F>(\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n  s5: PipelineStep<E, F>,\n): (input: A) => Promise<F>;\nexport function pipeline(...steps: Array<PipelineStep<any, any>>): (input: any) => Promise<any>;\nexport function pipeline(...steps: Array<PipelineStep<any, any>>): (input: any) => Promise<any> {\n  if (steps.length === 0) {\n    throw new Error('pipeline requires at least one step');\n  }\n\n  return async (input: any) => {\n    let current = input;\n    for (const step of steps) {\n      current = await step(current);\n    }\n    return current;\n  };\n}\n\n/**\n * Execute a value through a series of async transformation steps.\n *\n * @example\n * ```ts\n * const result = await pipe(\n *   5,\n *   (x) => x * 2,\n *   (x) => x + 1,\n *   (x) => String(x),\n * ); // \"11\"\n * ```\n */\nexport async function pipe<A, B>(input: A, s1: PipelineStep<A, B>): Promise<B>;\nexport async function pipe<A, B, C>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n): Promise<C>;\nexport async function pipe<A, B, C, D>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n): Promise<D>;\nexport async function pipe<A, B, C, D, E>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n): Promise<E>;\nexport async function pipe<A, B, C, D, E, F>(\n  input: A,\n  s1: PipelineStep<A, B>,\n  s2: PipelineStep<B, C>,\n  s3: PipelineStep<C, D>,\n  s4: PipelineStep<D, E>,\n  s5: PipelineStep<E, F>,\n): Promise<F>;\nexport async function pipe(input: any, ...steps: Array<PipelineStep<any, any>>): Promise<any>;\nexport async function pipe(input: any, ...steps: Array<PipelineStep<any, any>>): Promise<any> {\n  if (steps.length === 0) {\n    throw new Error('pipe requires at least one step');\n  }\n\n  let current = input;\n  for (const step of steps) {\n    current = await step(current);\n  }\n  return current;\n}\n"]}

package/dist/poll.d.mts

@@ -0,0 +1,35 @@
+import { B as BackoffStrategy } from './types-BsCO2J40.mjs';
+
+interface PollOptions<T> {
+    /** Polling interval in ms (default: 1000) */
+    interval?: number;
+    /** Condition to stop polling — return true to resolve */
+    until?: (result: T) => boolean;
+    /** Maximum number of poll attempts (default: Infinity) */
+    maxAttempts?: number;
+    /** Backoff strategy for interval (default: 'fixed') */
+    backoff?: BackoffStrategy;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+interface PollController<T> {
+    /** Promise that resolves with the final result */
+    result: Promise<T>;
+    /** Stop polling early */
+    stop: () => void;
+}
+/**
+ * Poll an async function until a condition is met.
+ *
+ * @example
+ * ```ts
+ * const { result } = poll(
+ *   () => checkJobStatus(jobId),
+ *   { until: (status) => status === 'done', interval: 2000 },
+ * );
+ * const finalStatus = await result;
+ * ```
+ */
+declare function poll<T>(fn: () => T | Promise<T>, options?: PollOptions<T>): PollController<T>;
+
+export { type PollController, type PollOptions, poll };

package/dist/poll.d.ts

@@ -0,0 +1,35 @@
+import { B as BackoffStrategy } from './types-BsCO2J40.js';
+
+interface PollOptions<T> {
+    /** Polling interval in ms (default: 1000) */
+    interval?: number;
+    /** Condition to stop polling — return true to resolve */
+    until?: (result: T) => boolean;
+    /** Maximum number of poll attempts (default: Infinity) */
+    maxAttempts?: number;
+    /** Backoff strategy for interval (default: 'fixed') */
+    backoff?: BackoffStrategy;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+interface PollController<T> {
+    /** Promise that resolves with the final result */
+    result: Promise<T>;
+    /** Stop polling early */
+    stop: () => void;
+}
+/**
+ * Poll an async function until a condition is met.
+ *
+ * @example
+ * ```ts
+ * const { result } = poll(
+ *   () => checkJobStatus(jobId),
+ *   { until: (status) => status === 'done', interval: 2000 },
+ * );
+ * const finalStatus = await result;
+ * ```
+ */
+declare function poll<T>(fn: () => T | Promise<T>, options?: PollOptions<T>): PollController<T>;
+
+export { type PollController, type PollOptions, poll };

package/dist/poll.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// 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 AbortError = class extends FlowXError {
+  constructor(message = "Operation aborted") {
+    super(message, "ERR_ABORTED");
+    this.name = "AbortError";
+  }
+};
+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/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
+  };
+}
+
+exports.poll = poll;
+//# sourceMappingURL=poll.js.map
+//# sourceMappingURL=poll.js.map

package/dist/poll.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/poll.ts"],"names":[],"mappings":"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","file":"poll.js","sourcesContent":["// ============================================================================\n// FlowX — Types & Error Hierarchy\n// ============================================================================\n\n/** Generic async function signature */\nexport type AsyncFn<TArgs extends any[] = any[], TReturn = any> = (\n  ...args: TArgs\n) => Promise<TReturn>;\n\n/** Backoff strategy for retry/poll operations */\nexport type BackoffStrategy =\n  | 'fixed'\n  | 'linear'\n  | 'exponential'\n  | ((attempt: number, delay: number) => number);\n\n// ── Error Classes ───────────────────────────────────────────────────────────\n\n/** Base error class for all FlowX errors */\nexport class FlowXError extends Error {\n  public readonly code: string;\n  constructor(message: string, code: string) {\n    super(message);\n    this.name = 'FlowXError';\n    this.code = code;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\n/** Thrown when a promise exceeds its timeout */\nexport class TimeoutError extends FlowXError {\n  constructor(message = 'Operation timed out') {\n    super(message, 'ERR_TIMEOUT');\n    this.name = 'TimeoutError';\n  }\n}\n\n/** Thrown when a circuit breaker is open */\nexport class CircuitBreakerError extends FlowXError {\n  constructor(message = 'Circuit breaker is open') {\n    super(message, 'ERR_CIRCUIT_OPEN');\n    this.name = 'CircuitBreakerError';\n  }\n}\n\n/** Thrown when a bulkhead rejects due to capacity */\nexport class BulkheadError extends FlowXError {\n  constructor(message = 'Bulkhead capacity exceeded') {\n    super(message, 'ERR_BULKHEAD_FULL');\n    this.name = 'BulkheadError';\n  }\n}\n\n/** Thrown when an operation is aborted */\nexport class AbortError extends FlowXError {\n  constructor(message = 'Operation aborted') {\n    super(message, 'ERR_ABORTED');\n    this.name = 'AbortError';\n  }\n}\n\n/** Thrown when rate limit is exceeded */\nexport class RateLimitError extends FlowXError {\n  constructor(message = 'Rate limit exceeded') {\n    super(message, 'ERR_RATE_LIMIT');\n    this.name = 'RateLimitError';\n  }\n}\n\n// ── Utility Helpers ─────────────────────────────────────────────────────────\n\n/** Sleep for the specified duration, respecting AbortSignal */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(new AbortError());\n      return;\n    }\n\n    let onAbort: (() => void) | undefined;\n\n    const timer = setTimeout(() => {\n      if (signal && onAbort) {\n        signal.removeEventListener('abort', onAbort);\n      }\n      resolve();\n    }, ms);\n\n    if (signal) {\n      onAbort = () => {\n        clearTimeout(timer);\n        reject(new AbortError());\n      };\n      signal.addEventListener('abort', onAbort, { once: true });\n    }\n  });\n}\n\n/** Calculate delay based on backoff strategy */\nexport function calculateDelay(\n  attempt: number,\n  baseDelay: number,\n  strategy: BackoffStrategy,\n  jitter: boolean | number = false,\n): number {\n  let delay: number;\n\n  if (typeof strategy === 'function') {\n    delay = strategy(attempt, baseDelay);\n  } else {\n    switch (strategy) {\n      case 'fixed':\n        delay = baseDelay;\n        break;\n      case 'linear':\n        delay = baseDelay * attempt;\n        break;\n      case 'exponential':\n        delay = baseDelay * Math.pow(2, attempt - 1);\n        break;\n    }\n  }\n\n  if (jitter) {\n    const factor = typeof jitter === 'number' ? jitter : 1;\n    delay = delay * (1 - factor * 0.5 + Math.random() * factor);\n  }\n\n  return Math.max(0, Math.floor(delay));\n}\n","// ============================================================================\n// FlowX — Polling with Backoff\n// ============================================================================\nimport { AbortError, BackoffStrategy, calculateDelay, sleep } from './types';\n\nexport interface PollOptions<T> {\n  /** Polling interval in ms (default: 1000) */\n  interval?: number;\n  /** Condition to stop polling — return true to resolve */\n  until?: (result: T) => boolean;\n  /** Maximum number of poll attempts (default: Infinity) */\n  maxAttempts?: number;\n  /** Backoff strategy for interval (default: 'fixed') */\n  backoff?: BackoffStrategy;\n  /** AbortSignal for cancellation */\n  signal?: AbortSignal;\n}\n\nexport interface PollController<T> {\n  /** Promise that resolves with the final result */\n  result: Promise<T>;\n  /** Stop polling early */\n  stop: () => void;\n}\n\n/**\n * Poll an async function until a condition is met.\n *\n * @example\n * ```ts\n * const { result } = poll(\n *   () => checkJobStatus(jobId),\n *   { until: (status) => status === 'done', interval: 2000 },\n * );\n * const finalStatus = await result;\n * ```\n */\nexport function poll<T>(fn: () => T | Promise<T>, options?: PollOptions<T>): PollController<T> {\n  const {\n    interval = 1000,\n    until,\n    maxAttempts = Infinity,\n    backoff = 'fixed',\n    signal,\n  } = options ?? {};\n\n  if (interval < 0) throw new RangeError('interval must be >= 0');\n\n  let stopped = false;\n  let rejectFn: ((error: Error) => void) | null = null;\n\n  const result = (async (): Promise<T> => {\n    for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n      if (stopped || signal?.aborted) {\n        throw new AbortError('Polling stopped');\n      }\n\n      const value = await fn();\n\n      if (until ? until(value) : true) {\n        return value;\n      }\n\n      if (attempt < maxAttempts) {\n        const waitTime = calculateDelay(attempt, interval, backoff);\n        await sleep(waitTime, signal).catch((err) => {\n          /* istanbul ignore if -- stop() doesn't abort sleep; this is a defensive guard */\n          if (stopped) throw new AbortError('Polling stopped');\n          throw err;\n        });\n      }\n    }\n\n    throw new Error('Polling exceeded maximum attempts');\n  })();\n\n  // Capture the reject function for external stopping\n  const wrappedResult = new Promise<T>((resolve, reject) => {\n    rejectFn = reject;\n    result.then(resolve, reject);\n  });\n\n  function stop(): void {\n    stopped = true;\n    rejectFn?.(new AbortError('Polling stopped'));\n  }\n\n  return {\n    result: wrappedResult,\n    stop,\n  };\n}\n"]}

package/dist/poll.mjs

@@ -0,0 +1,109 @@
+// 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 AbortError = class extends FlowXError {
+  constructor(message = "Operation aborted") {
+    super(message, "ERR_ABORTED");
+    this.name = "AbortError";
+  }
+};
+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/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
+  };
+}
+
+export { poll };
+//# sourceMappingURL=poll.mjs.map
+//# sourceMappingURL=poll.mjs.map

package/dist/poll.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/poll.ts"],"names":[],"mappings":"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","file":"poll.mjs","sourcesContent":["// ============================================================================\n// FlowX — Types & Error Hierarchy\n// ============================================================================\n\n/** Generic async function signature */\nexport type AsyncFn<TArgs extends any[] = any[], TReturn = any> = (\n  ...args: TArgs\n) => Promise<TReturn>;\n\n/** Backoff strategy for retry/poll operations */\nexport type BackoffStrategy =\n  | 'fixed'\n  | 'linear'\n  | 'exponential'\n  | ((attempt: number, delay: number) => number);\n\n// ── Error Classes ───────────────────────────────────────────────────────────\n\n/** Base error class for all FlowX errors */\nexport class FlowXError extends Error {\n  public readonly code: string;\n  constructor(message: string, code: string) {\n    super(message);\n    this.name = 'FlowXError';\n    this.code = code;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\n/** Thrown when a promise exceeds its timeout */\nexport class TimeoutError extends FlowXError {\n  constructor(message = 'Operation timed out') {\n    super(message, 'ERR_TIMEOUT');\n    this.name = 'TimeoutError';\n  }\n}\n\n/** Thrown when a circuit breaker is open */\nexport class CircuitBreakerError extends FlowXError {\n  constructor(message = 'Circuit breaker is open') {\n    super(message, 'ERR_CIRCUIT_OPEN');\n    this.name = 'CircuitBreakerError';\n  }\n}\n\n/** Thrown when a bulkhead rejects due to capacity */\nexport class BulkheadError extends FlowXError {\n  constructor(message = 'Bulkhead capacity exceeded') {\n    super(message, 'ERR_BULKHEAD_FULL');\n    this.name = 'BulkheadError';\n  }\n}\n\n/** Thrown when an operation is aborted */\nexport class AbortError extends FlowXError {\n  constructor(message = 'Operation aborted') {\n    super(message, 'ERR_ABORTED');\n    this.name = 'AbortError';\n  }\n}\n\n/** Thrown when rate limit is exceeded */\nexport class RateLimitError extends FlowXError {\n  constructor(message = 'Rate limit exceeded') {\n    super(message, 'ERR_RATE_LIMIT');\n    this.name = 'RateLimitError';\n  }\n}\n\n// ── Utility Helpers ─────────────────────────────────────────────────────────\n\n/** Sleep for the specified duration, respecting AbortSignal */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(new AbortError());\n      return;\n    }\n\n    let onAbort: (() => void) | undefined;\n\n    const timer = setTimeout(() => {\n      if (signal && onAbort) {\n        signal.removeEventListener('abort', onAbort);\n      }\n      resolve();\n    }, ms);\n\n    if (signal) {\n      onAbort = () => {\n        clearTimeout(timer);\n        reject(new AbortError());\n      };\n      signal.addEventListener('abort', onAbort, { once: true });\n    }\n  });\n}\n\n/** Calculate delay based on backoff strategy */\nexport function calculateDelay(\n  attempt: number,\n  baseDelay: number,\n  strategy: BackoffStrategy,\n  jitter: boolean | number = false,\n): number {\n  let delay: number;\n\n  if (typeof strategy === 'function') {\n    delay = strategy(attempt, baseDelay);\n  } else {\n    switch (strategy) {\n      case 'fixed':\n        delay = baseDelay;\n        break;\n      case 'linear':\n        delay = baseDelay * attempt;\n        break;\n      case 'exponential':\n        delay = baseDelay * Math.pow(2, attempt - 1);\n        break;\n    }\n  }\n\n  if (jitter) {\n    const factor = typeof jitter === 'number' ? jitter : 1;\n    delay = delay * (1 - factor * 0.5 + Math.random() * factor);\n  }\n\n  return Math.max(0, Math.floor(delay));\n}\n","// ============================================================================\n// FlowX — Polling with Backoff\n// ============================================================================\nimport { AbortError, BackoffStrategy, calculateDelay, sleep } from './types';\n\nexport interface PollOptions<T> {\n  /** Polling interval in ms (default: 1000) */\n  interval?: number;\n  /** Condition to stop polling — return true to resolve */\n  until?: (result: T) => boolean;\n  /** Maximum number of poll attempts (default: Infinity) */\n  maxAttempts?: number;\n  /** Backoff strategy for interval (default: 'fixed') */\n  backoff?: BackoffStrategy;\n  /** AbortSignal for cancellation */\n  signal?: AbortSignal;\n}\n\nexport interface PollController<T> {\n  /** Promise that resolves with the final result */\n  result: Promise<T>;\n  /** Stop polling early */\n  stop: () => void;\n}\n\n/**\n * Poll an async function until a condition is met.\n *\n * @example\n * ```ts\n * const { result } = poll(\n *   () => checkJobStatus(jobId),\n *   { until: (status) => status === 'done', interval: 2000 },\n * );\n * const finalStatus = await result;\n * ```\n */\nexport function poll<T>(fn: () => T | Promise<T>, options?: PollOptions<T>): PollController<T> {\n  const {\n    interval = 1000,\n    until,\n    maxAttempts = Infinity,\n    backoff = 'fixed',\n    signal,\n  } = options ?? {};\n\n  if (interval < 0) throw new RangeError('interval must be >= 0');\n\n  let stopped = false;\n  let rejectFn: ((error: Error) => void) | null = null;\n\n  const result = (async (): Promise<T> => {\n    for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n      if (stopped || signal?.aborted) {\n        throw new AbortError('Polling stopped');\n      }\n\n      const value = await fn();\n\n      if (until ? until(value) : true) {\n        return value;\n      }\n\n      if (attempt < maxAttempts) {\n        const waitTime = calculateDelay(attempt, interval, backoff);\n        await sleep(waitTime, signal).catch((err) => {\n          /* istanbul ignore if -- stop() doesn't abort sleep; this is a defensive guard */\n          if (stopped) throw new AbortError('Polling stopped');\n          throw err;\n        });\n      }\n    }\n\n    throw new Error('Polling exceeded maximum attempts');\n  })();\n\n  // Capture the reject function for external stopping\n  const wrappedResult = new Promise<T>((resolve, reject) => {\n    rejectFn = reject;\n    result.then(resolve, reject);\n  });\n\n  function stop(): void {\n    stopped = true;\n    rejectFn?.(new AbortError('Polling stopped'));\n  }\n\n  return {\n    result: wrappedResult,\n    stop,\n  };\n}\n"]}

package/dist/queue.d.mts

@@ -0,0 +1,47 @@
+interface QueueOptions {
+    /** Maximum concurrent tasks (default: 1) */
+    concurrency?: number;
+    /** Start processing immediately (default: true) */
+    autoStart?: boolean;
+    /** Per-task timeout in ms (0 = no timeout) */
+    timeout?: number;
+}
+interface QueueAddOptions {
+    /** Task priority — lower number = higher priority (default: 0) */
+    priority?: number;
+}
+interface AsyncQueue {
+    /** Add a task to the queue */
+    add: <T>(fn: () => Promise<T>, options?: QueueAddOptions) => Promise<T>;
+    /** Add multiple tasks and return all results */
+    addAll: <T>(fns: Array<() => Promise<T>>, options?: QueueAddOptions) => Promise<T[]>;
+    /** Pause processing */
+    pause: () => void;
+    /** Resume processing */
+    resume: () => void;
+    /** Clear all pending tasks */
+    clear: () => void;
+    /** Wait until the queue is empty */
+    onEmpty: () => Promise<void>;
+    /** Wait until the queue is idle (empty + no active tasks) */
+    onIdle: () => Promise<void>;
+    /** Number of pending tasks */
+    readonly size: number;
+    /** Number of active tasks */
+    readonly pending: number;
+    /** Whether the queue is paused */
+    readonly isPaused: boolean;
+}
+/**
+ * Create a priority async queue with concurrency control.
+ *
+ * @example
+ * ```ts
+ * const queue = createQueue({ concurrency: 3 });
+ * const result = await queue.add(() => fetch('/api'), { priority: 1 });
+ * await queue.onIdle();
+ * ```
+ */
+declare function createQueue(options?: QueueOptions): AsyncQueue;
+
+export { type AsyncQueue, type QueueAddOptions, type QueueOptions, createQueue };

package/dist/queue.d.ts

@@ -0,0 +1,47 @@
+interface QueueOptions {
+    /** Maximum concurrent tasks (default: 1) */
+    concurrency?: number;
+    /** Start processing immediately (default: true) */
+    autoStart?: boolean;
+    /** Per-task timeout in ms (0 = no timeout) */
+    timeout?: number;
+}
+interface QueueAddOptions {
+    /** Task priority — lower number = higher priority (default: 0) */
+    priority?: number;
+}
+interface AsyncQueue {
+    /** Add a task to the queue */
+    add: <T>(fn: () => Promise<T>, options?: QueueAddOptions) => Promise<T>;
+    /** Add multiple tasks and return all results */
+    addAll: <T>(fns: Array<() => Promise<T>>, options?: QueueAddOptions) => Promise<T[]>;
+    /** Pause processing */
+    pause: () => void;
+    /** Resume processing */
+    resume: () => void;
+    /** Clear all pending tasks */
+    clear: () => void;
+    /** Wait until the queue is empty */
+    onEmpty: () => Promise<void>;
+    /** Wait until the queue is idle (empty + no active tasks) */
+    onIdle: () => Promise<void>;
+    /** Number of pending tasks */
+    readonly size: number;
+    /** Number of active tasks */
+    readonly pending: number;
+    /** Whether the queue is paused */
+    readonly isPaused: boolean;
+}
+/**
+ * Create a priority async queue with concurrency control.
+ *
+ * @example
+ * ```ts
+ * const queue = createQueue({ concurrency: 3 });
+ * const result = await queue.add(() => fetch('/api'), { priority: 1 });
+ * await queue.onIdle();
+ * ```
+ */
+declare function createQueue(options?: QueueOptions): AsyncQueue;
+
+export { type AsyncQueue, type QueueAddOptions, type QueueOptions, createQueue };