@socketsecurity/lib 6.0.3 → 6.0.5

package/dist/promises/queue.js

@@ -1,138 +1,117 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../primordials/error.js');
+const require_primordials_promise = require('../primordials/promise.js');
+
+//#region src/promises/queue.ts
+/**
+* @file Bounded concurrency promise queue. Exports the `PromiseQueue` class,
+*   which limits how many async tasks run simultaneously, supports an optional
+*   max queue length (new tasks beyond the cap are rejected with "Task dropped:
+*   queue length exceeded"), and exposes an idle-wait helper.
+*/
+var PromiseQueue = class {
+	queue = [];
+	running = 0;
+	idleResolvers = [];
+	maxConcurrency;
+	maxQueueLength;
+	/**
+	* Creates a new PromiseQueue.
+	*
+	* @param maxConcurrency - Maximum number of promises that can run
+	*   concurrently.
+	* @param maxQueueLength - Maximum queue size; submissions past the cap reject
+	*   with "Task dropped: queue length exceeded" instead of evicting a caller
+	*   that has been waiting patiently. Callers must handle this rejection or
+	*   they'll see an unhandled rejection.
+	*/
+	constructor(maxConcurrency, maxQueueLength) {
+		this.maxConcurrency = maxConcurrency;
+		this.maxQueueLength = maxQueueLength;
+		if (maxConcurrency < 1) throw new require_primordials_error.ErrorCtor("maxConcurrency must be at least 1");
+	}
+	/**
+	* Add a task to the queue.
+	*
+	* @param fn - Async function to execute.
+	*
+	* @returns Promise that resolves with the function's result, or rejects with
+	*   "Task dropped: queue length exceeded" if the queue is full.
+	*/
+	async add(fn) {
+		return await new require_primordials_promise.PromiseCtor((resolve, reject) => {
+			if (this.maxQueueLength !== void 0 && this.queue.length >= this.maxQueueLength) {
+				reject(new require_primordials_error.ErrorCtor("Task dropped: queue length exceeded"));
+				return;
+			}
+			const task = {
+				fn,
+				resolve,
+				reject
+			};
+			this.queue.push(task);
+			this.runNext();
+		});
+	}
+	runNext() {
+		if (this.running >= this.maxConcurrency || this.queue.length === 0) {
+			this.notifyIdleIfNeeded();
+			return;
+		}
+		const task = this.queue.shift();
+		if (!task) return;
+		this.running++;
+		(async () => {
+			try {
+				const result = await task.fn();
+				task.resolve(result);
+			} catch (err) {
+				task.reject(err);
+			} finally {
+				this.running--;
+				this.runNext();
+			}
+		})();
+	}
+	notifyIdleIfNeeded() {
+		if (this.running === 0 && this.queue.length === 0) {
+			for (const resolve of this.idleResolvers) resolve();
+			this.idleResolvers = [];
+		}
+	}
+	/**
+	* Wait for all queued and running tasks to complete.
+	*/
+	async onIdle() {
+		if (this.running === 0 && this.queue.length === 0) return;
+		return await new require_primordials_promise.PromiseCtor((resolve) => {
+			this.idleResolvers.push(resolve);
+		});
+	}
+	/**
+	* Get the number of tasks currently running.
+	*/
+	get activeCount() {
+		return this.running;
+	}
+	/**
+	* Get the number of tasks waiting in the queue.
+	*/
+	get pendingCount() {
+		return this.queue.length;
+	}
+	/**
+	* Clear all pending tasks from the queue (does not affect running tasks)
+	*/
+	clear() {
+		const pending = this.queue;
+		this.queue = [];
+		for (const task of pending) task.reject(new require_primordials_error.ErrorCtor("Task cancelled: queue cleared"));
+		this.notifyIdleIfNeeded();
+	}
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var queue_exports = {};
-__export(queue_exports, {
-  PromiseQueue: () => PromiseQueue
-});
-module.exports = __toCommonJS(queue_exports);
-var import_error = require("../primordials/error");
-var import_promise = require("../primordials/promise");
-class PromiseQueue {
-  queue = [];
-  running = 0;
-  idleResolvers = [];
-  maxConcurrency;
-  maxQueueLength;
-  /**
-   * Creates a new PromiseQueue.
-   *
-   * @param maxConcurrency - Maximum number of promises that can run
-   *   concurrently.
-   * @param maxQueueLength - Maximum queue size; submissions past the cap reject
-   *   with "Task dropped: queue length exceeded" instead of evicting a caller
-   *   that has been waiting patiently. Callers must handle this rejection or
-   *   they'll see an unhandled rejection.
-   */
-  constructor(maxConcurrency, maxQueueLength) {
-    this.maxConcurrency = maxConcurrency;
-    this.maxQueueLength = maxQueueLength;
-    if (maxConcurrency < 1) {
-      throw new import_error.ErrorCtor("maxConcurrency must be at least 1");
-    }
-  }
-  /**
-   * Add a task to the queue.
-   *
-   * @param fn - Async function to execute.
-   *
-   * @returns Promise that resolves with the function's result, or rejects with
-   *   "Task dropped: queue length exceeded" if the queue is full.
-   */
-  async add(fn) {
-    return await new import_promise.PromiseCtor((resolve, reject) => {
-      if (this.maxQueueLength !== void 0 && this.queue.length >= this.maxQueueLength) {
-        reject(new import_error.ErrorCtor("Task dropped: queue length exceeded"));
-        return;
-      }
-      const task = { fn, resolve, reject };
-      this.queue.push(task);
-      this.runNext();
-    });
-  }
-  runNext() {
-    if (this.running >= this.maxConcurrency || this.queue.length === 0) {
-      this.notifyIdleIfNeeded();
-      return;
-    }
-    const task = this.queue.shift();
-    if (!task) {
-      return;
-    }
-    this.running++;
-    (async () => {
-      try {
-        const result = await task.fn();
-        task.resolve(result);
-      } catch (err) {
-        task.reject(err);
-      } finally {
-        this.running--;
-        this.runNext();
-      }
-    })();
-  }
-  notifyIdleIfNeeded() {
-    if (this.running === 0 && this.queue.length === 0) {
-      for (const resolve of this.idleResolvers) {
-        resolve();
-      }
-      this.idleResolvers = [];
-    }
-  }
-  /**
-   * Wait for all queued and running tasks to complete.
-   */
-  async onIdle() {
-    if (this.running === 0 && this.queue.length === 0) {
-      return;
-    }
-    return await new import_promise.PromiseCtor((resolve) => {
-      this.idleResolvers.push(resolve);
-    });
-  }
-  /**
-   * Get the number of tasks currently running.
-   */
-  get activeCount() {
-    return this.running;
-  }
-  /**
-   * Get the number of tasks waiting in the queue.
-   */
-  get pendingCount() {
-    return this.queue.length;
-  }
-  /**
-   * Clear all pending tasks from the queue (does not affect running tasks)
-   */
-  clear() {
-    const pending = this.queue;
-    this.queue = [];
-    for (const task of pending) {
-      task.reject(new import_error.ErrorCtor("Task cancelled: queue cleared"));
-    }
-    this.notifyIdleIfNeeded();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PromiseQueue
-});
+
+//#endregion
+exports.PromiseQueue = PromiseQueue;

package/dist/promises/resolvers.js

@@ -1,49 +1,80 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var resolvers_exports = {};
-__export(resolvers_exports, {
-  fromAsync: () => fromAsync,
-  withResolvers: () => withResolvers
-});
-module.exports = __toCommonJS(resolvers_exports);
-var import_array = require("../primordials/array");
-var import_promise = require("../primordials/promise");
-const fromAsync = import_array.ArrayFromAsync !== void 0 ? import_array.ArrayFromAsync : async (source) => {
-  const out = [];
-  for await (const item of source) {
-    out.push(item);
-  }
-  return out;
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_array = require('../primordials/array.js');
+const require_primordials_promise = require('../primordials/promise.js');
+
+//#region src/promises/resolvers.ts
+/**
+* @file ECMA-262 standalone async helpers — `withResolvers`
+*   (Promise.withResolvers) and `fromAsync` (Array.fromAsync). Both prefer the
+*   captured primordial when present, with a spec-equivalent fallback for older
+*   runtimes. Why this lives separate from `retry.ts` / `iterate.ts`: these are
+*   direct mirrors of standardized JS APIs, not Socket-specific helpers. They
+*   have no retry / concurrency surface to share with the rest of the module.
+*/
+/**
+* Drain an async iterable into an array, per [TC39
+* Array.fromAsync](https://tc39.es/proposal-array-from-async/).
+*
+* Uses the `ArrayFromAsync` primordial (already bound) when available (Node
+* 22+; V8 ≥ 12.0); otherwise falls back to a `for await…of` + push loop.
+*
+* Use this instead of the manual `const out = []; for await (const x of iter)
+* out.push(x); return out` dance when collecting an async iterator's values.
+*
+* Like the native, this only handles the unary form (no `mapFn` / `thisArg`
+* overload).
+*
+* @example
+*   ;```typescript
+*   import { glob } from 'node:fs/promises'
+*   const files = await fromAsync(glob('**\/*.ts', { cwd: '/tmp/proj' }))
+*   ```
+*/
+const fromAsync = require_primordials_array.ArrayFromAsync !== void 0 ? require_primordials_array.ArrayFromAsync : async (source) => {
+	const out = [];
+	for await (const item of source) out.push(item);
+	return out;
 };
-const withResolvers = import_promise.PromiseWithResolvers !== void 0 ? import_promise.PromiseWithResolvers : () => {
-  let resolve;
-  let reject;
-  const promise = new import_promise.PromiseCtor((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
+/**
+* Create a pending promise together with its `resolve` and `reject` handles as
+* first-class values, per [ECMA-262
+* §27.2.4.9](https://tc39.es/ecma262/#sec-promise.withResolvers).
+*
+* Uses the `PromiseWithResolvers` primordial (already bound) when available
+* (Node 20.12+ / 21+ / 22+; V8 ≥ 12.0); otherwise falls back to a
+* spec-equivalent `new Promise(executor)` that captures the handles via
+* closure. The returned object always has own data properties `promise`,
+* `resolve`, `reject` on `Object.prototype` — writable, enumerable, and
+* configurable — matching the spec's `CreateDataPropertyOrThrow` steps.
+*
+* Use this instead of the manual `let resolve; const p = new Promise(r => {
+* resolve = r })` dance for deferred-resolution patterns (event-driven bridges,
+* adapter layers, handshake signaling) where the settle path lives outside the
+* executor.
+*
+* @example
+*   ;```typescript
+*   const { promise, resolve, reject } = withResolvers<string>()
+*   emitter.once('ready', () => resolve('ok'))
+*   emitter.once('error', err => reject(err))
+*   const result = await promise
+*   ```
+*/
+const withResolvers = require_primordials_promise.PromiseWithResolvers !== void 0 ? require_primordials_promise.PromiseWithResolvers : () => {
+	let resolve;
+	let reject;
+	return {
+		promise: new require_primordials_promise.PromiseCtor((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  fromAsync,
-  withResolvers
-});
+
+//#endregion
+exports.fromAsync = fromAsync;
+exports.withResolvers = withResolvers;

package/dist/promises/retry.js

@@ -1,104 +1,159 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var retry_exports = {};
-__export(retry_exports, {
-  pRetry: () => pRetry
-});
-module.exports = __toCommonJS(retry_exports);
-var import_sentinels = require("../constants/sentinels");
-var import_math = require("../primordials/math");
-var import_internal = require("./_internal");
-var import_options = require("./options");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_math = require('../primordials/math.js');
+const require_constants_sentinels = require('../constants/sentinels.js');
+const require_promises__internal = require('./_internal.js');
+const require_promises_options = require('./options.js');
+
+//#region src/promises/retry.ts
+/**
+* @file `pRetry` — exponential-backoff retry with optional jitter, abort-signal
+*   support, and an `onRetry` hook for customizing delays or canceling retries
+*   entirely. Cycles with `iterate.ts`: pRetry is called by pEach / pEachChunk
+*   / pFilter / pFilterChunk to apply per-item retry. ESM tolerates the cycle
+*   since both sides reference each other through functions only.
+*/
+/**
+* Retry an async function with exponential backoff.
+*
+* Attempts to execute a function multiple times with increasing delays between
+* attempts. Implements exponential backoff with optional jitter to prevent
+* thundering herd problems. Supports custom retry logic via `onRetry`
+* callback.
+*
+* The delay calculation follows: `min(baseDelayMs * (backoffFactor ** attempt),
+* maxDelayMs)` With jitter: adds random value between 0 and calculated delay.
+*
+* @example
+*   // Simple retry: 3 attempts with default backoff
+*   const data = await pRetry(async () => {
+*     return await fetchData()
+*   }, 3)
+*
+* @example
+*   // Custom backoff strategy
+*   const result = await pRetry(
+*     async () => {
+*       return await unreliableOperation()
+*     },
+*     {
+*       retries: 5,
+*       baseDelayMs: 1000, // Start at 1 second
+*       backoffFactor: 2, // Double each time
+*       maxDelayMs: 30000, // Cap at 30 seconds
+*       jitter: true, // Add randomness
+*     },
+*   )
+*   // Delays: ~1s, ~2s, ~4s, ~8s, ~16s (each ± random jitter)
+*
+* @example
+*   // With custom retry logic
+*   const data = await pRetry(
+*     async () => {
+*       return await apiCall()
+*     },
+*     {
+*       retries: 3,
+*       onRetry: (attempt, error, delay) => {
+*         console.log(`Attempt ${attempt} failed: ${error}`)
+*         console.log(`Waiting ${delay}ms before retry...`)
+*
+*         // Cancel retries for client errors (4xx)
+*         if (error.statusCode >= 400 && error.statusCode < 500) {
+*           return false
+*         }
+*
+*         // Use longer delay for rate limit errors
+*         if (error.statusCode === 429) {
+*           return 60000 // Wait 1 minute
+*         }
+*       },
+*       onRetryCancelOnFalse: true,
+*     },
+*   )
+*
+* @example
+*   // With cancellation support
+*   const controller = new AbortController()
+*   setTimeout(() => controller.abort(), 5000) // Cancel after 5s
+*
+*   const result = await pRetry(
+*     async ({ signal }) => {
+*       return await longRunningTask(signal)
+*     },
+*     {
+*       retries: 10,
+*       signal: controller.signal,
+*     },
+*   )
+*   // Returns undefined if aborted
+*
+* @example
+*   // Pass arguments to callback
+*   const result = await pRetry(
+*     async (url, options) => {
+*       return await fetch(url, options)
+*     },
+*     {
+*       retries: 3,
+*       args: ['https://api.example.com', { method: 'POST' }],
+*     },
+*   )
+*
+* @template T - The return type of the callback function.
+*
+* @param callbackFn - Async function to retry.
+* @param options - Retry count as number, or full retry options, or undefined.
+*
+* @returns Promise resolving to callback result, or `undefined` if aborted
+*
+* @throws {Error} The last error if all retry attempts fail
+*/
+/* @__NO_SIDE_EFFECTS__ */
 async function pRetry(callbackFn, options) {
-  const {
-    args,
-    backoffFactor,
-    baseDelayMs,
-    jitter,
-    maxDelayMs,
-    onRetry,
-    onRetryCancelOnFalse,
-    onRetryRethrow,
-    retries,
-    signal
-  } = (0, import_options.normalizeRetryOptions)(options);
-  if (signal?.aborted) {
-    return void 0;
-  }
-  if (retries === 0) {
-    return await callbackFn(...args || [], { signal });
-  }
-  const timers = (0, import_internal.getTimers)();
-  let attempts = retries;
-  let delay = baseDelayMs;
-  let error = import_sentinels.UNDEFINED_TOKEN;
-  while (attempts-- >= 0) {
-    if (signal?.aborted) {
-      return void 0;
-    }
-    try {
-      return await callbackFn(...args || [], { signal });
-    } catch (e) {
-      error = e;
-      if (attempts < 0) {
-        break;
-      }
-      let waitTime = delay;
-      if (jitter) {
-        waitTime += (0, import_math.MathFloor)((0, import_math.MathRandom)() * delay);
-      }
-      waitTime = (0, import_math.MathMin)(waitTime, maxDelayMs);
-      if (typeof onRetry === "function") {
-        try {
-          const result = onRetry(retries - attempts, e, waitTime);
-          if (result === false && onRetryCancelOnFalse) {
-            break;
-          }
-          if (typeof result === "number" && result >= 0) {
-            waitTime = (0, import_math.MathMin)(result, maxDelayMs);
-          }
-        } catch (e2) {
-          if (onRetryRethrow) {
-            throw e2;
-          }
-        }
-      }
-      try {
-        await timers.setTimeout(waitTime, void 0, { signal });
-      } catch {
-        return void 0;
-      }
-      if (signal?.aborted) {
-        return void 0;
-      }
-      delay = (0, import_math.MathMin)(delay * backoffFactor, maxDelayMs);
-    }
-  }
-  if (error !== import_sentinels.UNDEFINED_TOKEN) {
-    throw error;
-  }
-  return void 0;
+	const { args, backoffFactor, baseDelayMs, jitter, maxDelayMs, onRetry, onRetryCancelOnFalse, onRetryRethrow, retries, signal } = /* @__PURE__ */ require_promises_options.normalizeRetryOptions(options);
+	if (signal?.aborted) return;
+	if (retries === 0) return await callbackFn(...args || [], { signal });
+	const timers = /* @__PURE__ */ require_promises__internal.getTimers();
+	let attempts = retries;
+	let delay = baseDelayMs;
+	let error = void 0;
+	while (attempts-- >= 0) {
+		/* c8 ignore start */
+		if (signal?.aborted) return;
+		/* c8 ignore stop */
+		try {
+			return await callbackFn(...args || [], { signal });
+		} catch (e) {
+			error = e;
+			if (attempts < 0) break;
+			let waitTime = delay;
+			if (jitter) waitTime += require_primordials_math.MathFloor(require_primordials_math.MathRandom() * delay);
+			waitTime = require_primordials_math.MathMin(waitTime, maxDelayMs);
+			/* c8 ignore start */
+			if (typeof onRetry === "function") try {
+				const result = onRetry(retries - attempts, e, waitTime);
+				if (result === false && onRetryCancelOnFalse) break;
+				if (typeof result === "number" && result >= 0) waitTime = require_primordials_math.MathMin(result, maxDelayMs);
+			} catch (e) {
+				if (onRetryRethrow) throw e;
+			}
+			/* c8 ignore stop */
+			try {
+				await timers.setTimeout(waitTime, void 0, { signal });
+			} catch {
+				return;
+			}
+			/* c8 ignore stop */
+			/* c8 ignore start */
+			if (signal?.aborted) return;
+			/* c8 ignore stop */
+			delay = require_primordials_math.MathMin(delay * backoffFactor, maxDelayMs);
+		}
+	}
+	if (error !== void 0) throw error;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  pRetry
-});
+
+//#endregion
+exports.pRetry = pRetry;

package/dist/promises/types.js

@@ -1,18 +1,2 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+/* Socket Lib - Built with rolldown */