@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/promise-queue.js

@@ -0,0 +1,111 @@
+/* Socket Lib - Built with esbuild */
+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 promise_queue_exports = {};
+__export(promise_queue_exports, {
+  PromiseQueue: () => PromiseQueue
+});
+module.exports = __toCommonJS(promise_queue_exports);
+class PromiseQueue {
+  queue = [];
+  running = 0;
+  maxConcurrency;
+  maxQueueLength;
+  /**
+   * Creates a new PromiseQueue
+   * @param maxConcurrency - Maximum number of promises that can run concurrently
+   * @param maxQueueLength - Maximum queue size (older tasks are dropped if exceeded)
+   */
+  constructor(maxConcurrency, maxQueueLength) {
+    this.maxConcurrency = maxConcurrency;
+    this.maxQueueLength = maxQueueLength;
+    if (maxConcurrency < 1) {
+      throw new Error("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
+   */
+  async add(fn) {
+    return await new Promise((resolve, reject) => {
+      const task = { fn, resolve, reject };
+      if (this.maxQueueLength && this.queue.length >= this.maxQueueLength) {
+        const droppedTask = this.queue.shift();
+        if (droppedTask) {
+          droppedTask.reject(new Error("Task dropped: queue length exceeded"));
+        }
+      }
+      this.queue.push(task);
+      this.runNext();
+    });
+  }
+  runNext() {
+    if (this.running >= this.maxConcurrency || this.queue.length === 0) {
+      return;
+    }
+    const task = this.queue.shift();
+    if (!task) {
+      return;
+    }
+    this.running++;
+    task.fn().then(task.resolve).catch(task.reject).finally(() => {
+      this.running--;
+      this.runNext();
+    });
+  }
+  /**
+   * Wait for all queued and running tasks to complete
+   */
+  async onIdle() {
+    return await new Promise((resolve) => {
+      const check = () => {
+        if (this.running === 0 && this.queue.length === 0) {
+          resolve();
+        } else {
+          setImmediate(check);
+        }
+      };
+      check();
+    });
+  }
+  /**
+   * 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() {
+    this.queue = [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromiseQueue
+});
+//# sourceMappingURL=promise-queue.js.map

package/dist/promise-queue.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/promise-queue.ts"],
+  "sourcesContent": ["/**\n * A promise queue that limits concurrent execution of async tasks.\n * Based on patterns from coana-package-manager for resource-aware async operations.\n */\n\ntype QueuedTask<T> = {\n  fn: () => Promise<T>\n  resolve: (value: T) => void\n  reject: (error: unknown) => void\n}\n\nexport class PromiseQueue {\n  private queue: Array<QueuedTask<unknown>> = []\n  private running = 0\n\n  private readonly maxConcurrency: number\n  private readonly maxQueueLength: number | undefined\n\n  /**\n   * Creates a new PromiseQueue\n   * @param maxConcurrency - Maximum number of promises that can run concurrently\n   * @param maxQueueLength - Maximum queue size (older tasks are dropped if exceeded)\n   */\n  constructor(maxConcurrency: number, maxQueueLength?: number | undefined) {\n    this.maxConcurrency = maxConcurrency\n    this.maxQueueLength = maxQueueLength\n    if (maxConcurrency < 1) {\n      throw new Error('maxConcurrency must be at least 1')\n    }\n  }\n\n  /**\n   * Add a task to the queue\n   * @param fn - Async function to execute\n   * @returns Promise that resolves with the function's result\n   */\n  async add<T>(fn: () => Promise<T>): Promise<T> {\n    return await new Promise<T>((resolve, reject) => {\n      const task: QueuedTask<T> = { fn, resolve, reject }\n\n      if (this.maxQueueLength && this.queue.length >= this.maxQueueLength) {\n        // Drop oldest task to prevent memory buildup\n        const droppedTask = this.queue.shift()\n        if (droppedTask) {\n          droppedTask.reject(new Error('Task dropped: queue length exceeded'))\n        }\n      }\n\n      this.queue.push(task as QueuedTask<unknown>)\n      this.runNext()\n    })\n  }\n\n  private runNext(): void {\n    if (this.running >= this.maxConcurrency || this.queue.length === 0) {\n      return\n    }\n\n    const task = this.queue.shift()\n    if (!task) {\n      return\n    }\n\n    this.running++\n\n    task\n      .fn()\n      .then(task.resolve)\n      .catch(task.reject)\n      .finally(() => {\n        this.running--\n        this.runNext()\n      })\n  }\n\n  /**\n   * Wait for all queued and running tasks to complete\n   */\n  async onIdle(): Promise<void> {\n    return await new Promise<void>(resolve => {\n      const check = () => {\n        if (this.running === 0 && this.queue.length === 0) {\n          resolve()\n        } else {\n          setImmediate(check)\n        }\n      }\n      check()\n    })\n  }\n\n  /**\n   * Get the number of tasks currently running\n   */\n  get activeCount(): number {\n    return this.running\n  }\n\n  /**\n   * Get the number of tasks waiting in the queue\n   */\n  get pendingCount(): number {\n    return this.queue.length\n  }\n\n  /**\n   * Clear all pending tasks from the queue (does not affect running tasks)\n   */\n  clear(): void {\n    this.queue = []\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWO,MAAM,aAAa;AAAA,EAChB,QAAoC,CAAC;AAAA,EACrC,UAAU;AAAA,EAED;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOjB,YAAY,gBAAwB,gBAAqC;AACvE,SAAK,iBAAiB;AACtB,SAAK,iBAAiB;AACtB,QAAI,iBAAiB,GAAG;AACtB,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,IAAO,IAAkC;AAC7C,WAAO,MAAM,IAAI,QAAW,CAAC,SAAS,WAAW;AAC/C,YAAM,OAAsB,EAAE,IAAI,SAAS,OAAO;AAElD,UAAI,KAAK,kBAAkB,KAAK,MAAM,UAAU,KAAK,gBAAgB;AAEnE,cAAM,cAAc,KAAK,MAAM,MAAM;AACrC,YAAI,aAAa;AACf,sBAAY,OAAO,IAAI,MAAM,qCAAqC,CAAC;AAAA,QACrE;AAAA,MACF;AAEA,WAAK,MAAM,KAAK,IAA2B;AAC3C,WAAK,QAAQ;AAAA,IACf,CAAC;AAAA,EACH;AAAA,EAEQ,UAAgB;AACtB,QAAI,KAAK,WAAW,KAAK,kBAAkB,KAAK,MAAM,WAAW,GAAG;AAClE;AAAA,IACF;AAEA,UAAM,OAAO,KAAK,MAAM,MAAM;AAC9B,QAAI,CAAC,MAAM;AACT;AAAA,IACF;AAEA,SAAK;AAEL,SACG,GAAG,EACH,KAAK,KAAK,OAAO,EACjB,MAAM,KAAK,MAAM,EACjB,QAAQ,MAAM;AACb,WAAK;AACL,WAAK,QAAQ;AAAA,IACf,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,SAAwB;AAC5B,WAAO,MAAM,IAAI,QAAc,aAAW;AACxC,YAAM,QAAQ,MAAM;AAClB,YAAI,KAAK,YAAY,KAAK,KAAK,MAAM,WAAW,GAAG;AACjD,kBAAQ;AAAA,QACV,OAAO;AACL,uBAAa,KAAK;AAAA,QACpB;AAAA,MACF;AACA,YAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,cAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,eAAuB;AACzB,WAAO,KAAK,MAAM;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,QAAQ,CAAC;AAAA,EAChB;AACF;",
+  "names": []
+}

package/dist/promises.d.ts

@@ -0,0 +1,67 @@
+export interface RetryOptions {
+    args?: unknown[];
+    backoffFactor?: number;
+    baseDelayMs?: number;
+    factor?: number;
+    jitter?: boolean;
+    maxDelayMs?: number;
+    maxTimeout?: number;
+    minTimeout?: number;
+    onRetry?: (attempt: number, error: unknown, delay: number) => boolean | undefined;
+    onRetryCancelOnFalse?: boolean;
+    onRetryRethrow?: boolean;
+    retries?: number;
+    signal?: AbortSignal;
+}
+export interface IterationOptions {
+    concurrency?: number;
+    retries?: number | RetryOptions;
+    signal?: AbortSignal;
+}
+/**
+ * Normalize options for iteration functions.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function normalizeIterationOptions(options?: number | IterationOptions): {
+    concurrency: number;
+    retries: RetryOptions;
+    signal: AbortSignal;
+};
+/**
+ * Normalize options for retry functionality.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function normalizeRetryOptions(options?: number | RetryOptions): RetryOptions;
+/**
+ * Resolve retry options from various input formats.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function resolveRetryOptions(options?: number | RetryOptions): RetryOptions;
+/**
+ * Execute an async function for each array element with concurrency control.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function pEach<T>(array: T[], callbackFn: (item: T) => Promise<unknown>, options?: number | IterationOptions): Promise<void>;
+/**
+ * Filter an array asynchronously with concurrency control.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function pFilter<T>(array: T[], callbackFn: (item: T) => Promise<boolean>, options?: number | IterationOptions): Promise<T[]>;
+/**
+ * Process array in chunks with an async callback.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function pEachChunk<T>(array: T[], callbackFn: (chunk: T[]) => Promise<unknown>, options?: RetryOptions & {
+    chunkSize?: number;
+}): Promise<void>;
+/**
+ * Filter chunked arrays with an async predicate.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function pFilterChunk<T>(chunks: T[][], callbackFn: (value: T) => Promise<boolean>, options?: number | RetryOptions): Promise<T[][]>;
+/**
+ * Retry an async function with exponential backoff.
+ * @throws {Error} The last error if all retries fail.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function pRetry<T>(callbackFn: (...args: unknown[]) => Promise<T>, options?: number | RetryOptions): Promise<T | undefined>;

package/dist/promises.js

@@ -0,0 +1,268 @@
+/* Socket Lib - Built with esbuild */
+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 promises_exports = {};
+__export(promises_exports, {
+  normalizeIterationOptions: () => normalizeIterationOptions,
+  normalizeRetryOptions: () => normalizeRetryOptions,
+  pEach: () => pEach,
+  pEachChunk: () => pEachChunk,
+  pFilter: () => pFilter,
+  pFilterChunk: () => pFilterChunk,
+  pRetry: () => pRetry,
+  resolveRetryOptions: () => resolveRetryOptions
+});
+module.exports = __toCommonJS(promises_exports);
+var import_core = require("#constants/core");
+var import_process = require("#constants/process");
+var import_arrays = require("./arrays");
+const abortSignal = (0, import_process.getAbortSignal)();
+let _timers;
+// @__NO_SIDE_EFFECTS__
+function getTimers() {
+  if (_timers === void 0) {
+    _timers = require("node:timers/promises");
+  }
+  return _timers;
+}
+// @__NO_SIDE_EFFECTS__
+function normalizeIterationOptions(options) {
+  const opts = typeof options === "number" ? { concurrency: options } : options;
+  const {
+    // The number of concurrent executions performed at one time.
+    concurrency = 1,
+    // Retries as a number or options object.
+    retries,
+    // AbortSignal used to support cancellation.
+    signal = abortSignal
+  } = { __proto__: null, ...opts };
+  const normalizedConcurrency = Math.max(1, concurrency);
+  const retryOpts = /* @__PURE__ */ resolveRetryOptions(retries);
+  return {
+    __proto__: null,
+    concurrency: normalizedConcurrency,
+    retries: /* @__PURE__ */ normalizeRetryOptions({ signal, ...retryOpts }),
+    signal
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function normalizeRetryOptions(options) {
+  const resolved = /* @__PURE__ */ resolveRetryOptions(options);
+  const {
+    // Arguments to pass to the callback function.
+    args = [],
+    // Multiplier for exponential backoff (e.g., 2 doubles delay each retry).
+    backoffFactor = resolved.factor || 2,
+    // Initial delay before the first retry (in milliseconds).
+    baseDelayMs = resolved.minTimeout || 200,
+    // Whether to apply randomness to spread out retries.
+    jitter = true,
+    // Upper limit for any backoff delay (in milliseconds).
+    maxDelayMs = resolved.maxTimeout || 1e4,
+    // Optional callback invoked on each retry attempt:
+    // (attempt: number, error: unknown, delay: number) => void
+    onRetry,
+    // Whether onRetry can cancel retries by returning `false`.
+    onRetryCancelOnFalse = false,
+    // Whether onRetry will rethrow errors.
+    onRetryRethrow = false,
+    // Number of retry attempts (0 = no retries, only initial attempt).
+    retries = resolved.retries || 0,
+    // AbortSignal used to support cancellation.
+    signal = abortSignal
+  } = resolved;
+  return {
+    args,
+    backoffFactor,
+    baseDelayMs,
+    jitter,
+    maxDelayMs,
+    minTimeout: baseDelayMs,
+    maxTimeout: maxDelayMs,
+    onRetry,
+    onRetryCancelOnFalse,
+    onRetryRethrow,
+    retries,
+    signal
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function resolveRetryOptions(options) {
+  const defaults = {
+    __proto__: null,
+    retries: 0,
+    minTimeout: 200,
+    maxTimeout: 1e4,
+    factor: 2
+  };
+  if (typeof options === "number") {
+    return { ...defaults, retries: options };
+  }
+  return options ? { ...defaults, ...options } : defaults;
+}
+// @__NO_SIDE_EFFECTS__
+async function pEach(array, callbackFn, options) {
+  const iterOpts = /* @__PURE__ */ normalizeIterationOptions(options);
+  const { concurrency, retries, signal } = iterOpts;
+  const chunks = (0, import_arrays.arrayChunk)(array, concurrency);
+  for (const chunk of chunks) {
+    if (signal?.aborted) {
+      return;
+    }
+    await Promise.all(
+      chunk.map(
+        (item) => /* @__PURE__ */ pRetry((...args) => callbackFn(args[0]), {
+          ...retries,
+          args: [item],
+          signal
+        })
+      )
+    );
+  }
+}
+// @__NO_SIDE_EFFECTS__
+async function pFilter(array, callbackFn, options) {
+  const iterOpts = /* @__PURE__ */ normalizeIterationOptions(options);
+  return (await /* @__PURE__ */ pFilterChunk(
+    (0, import_arrays.arrayChunk)(array, iterOpts.concurrency),
+    callbackFn,
+    iterOpts.retries
+  )).flat();
+}
+// @__NO_SIDE_EFFECTS__
+async function pEachChunk(array, callbackFn, options) {
+  const { chunkSize = 100, ...retryOpts } = options || {};
+  const chunks = (0, import_arrays.arrayChunk)(array, chunkSize);
+  const normalizedRetryOpts = /* @__PURE__ */ normalizeRetryOptions(retryOpts);
+  const { signal } = normalizedRetryOpts;
+  for (const chunk of chunks) {
+    if (signal?.aborted) {
+      return;
+    }
+    await /* @__PURE__ */ pRetry((...args) => callbackFn(args[0]), {
+      ...normalizedRetryOpts,
+      args: [chunk]
+    });
+  }
+}
+// @__NO_SIDE_EFFECTS__
+async function pFilterChunk(chunks, callbackFn, options) {
+  const retryOpts = /* @__PURE__ */ normalizeRetryOptions(options);
+  const { signal } = retryOpts;
+  const { length } = chunks;
+  const filteredChunks = Array(length);
+  for (let i = 0; i < length; i += 1) {
+    if (signal?.aborted) {
+      filteredChunks[i] = [];
+    } else {
+      const chunk = chunks[i];
+      const predicateResults = await Promise.all(
+        chunk.map(
+          (value) => /* @__PURE__ */ pRetry((...args) => callbackFn(args[0]), {
+            ...retryOpts,
+            args: [value]
+          })
+        )
+      );
+      filteredChunks[i] = chunk.filter((_v, i2) => predicateResults[i2]);
+    }
+  }
+  return filteredChunks;
+}
+// @__NO_SIDE_EFFECTS__
+async function pRetry(callbackFn, options) {
+  const {
+    args,
+    backoffFactor,
+    baseDelayMs,
+    jitter,
+    maxDelayMs,
+    onRetry,
+    onRetryCancelOnFalse,
+    onRetryRethrow,
+    retries,
+    signal
+  } = /* @__PURE__ */ normalizeRetryOptions(options);
+  if (signal?.aborted) {
+    return void 0;
+  }
+  if (retries === 0) {
+    return await callbackFn(...args || [], { signal });
+  }
+  const timers = /* @__PURE__ */ getTimers();
+  let attempts = retries;
+  let delay = baseDelayMs;
+  let error = import_core.UNDEFINED_TOKEN;
+  while (attempts-- >= 0) {
+    if (signal?.aborted) {
+      return void 0;
+    }
+    try {
+      return await callbackFn(...args || [], { signal });
+    } catch (e) {
+      if (error === import_core.UNDEFINED_TOKEN) {
+        error = e;
+      }
+      if (attempts < 0) {
+        break;
+      }
+      let waitTime = delay;
+      if (jitter) {
+        waitTime += Math.floor(Math.random() * delay);
+      }
+      waitTime = Math.min(waitTime, maxDelayMs);
+      if (typeof onRetry === "function") {
+        try {
+          const result = onRetry(retries - attempts, e, waitTime);
+          if (result === false && onRetryCancelOnFalse) {
+            break;
+          }
+        } 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 = Math.min(delay * backoffFactor, maxDelayMs);
+    }
+  }
+  if (error !== import_core.UNDEFINED_TOKEN) {
+    throw error;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeIterationOptions,
+  normalizeRetryOptions,
+  pEach,
+  pEachChunk,
+  pFilter,
+  pFilterChunk,
+  pRetry,
+  resolveRetryOptions
+});
+//# sourceMappingURL=promises.js.map

package/dist/promises.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/promises.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Promise utilities including chunked iteration and timers.\n * Provides async control flow helpers and promise-based timing functions.\n */\n\nimport { UNDEFINED_TOKEN } from '#constants/core'\nimport { getAbortSignal } from '#constants/process'\n\nimport { arrayChunk } from './arrays'\n\nconst abortSignal = getAbortSignal()\n\nexport interface RetryOptions {\n  args?: unknown[]\n  backoffFactor?: number\n  baseDelayMs?: number\n  factor?: number\n  jitter?: boolean\n  maxDelayMs?: number\n  maxTimeout?: number\n  minTimeout?: number\n  onRetry?: (\n    attempt: number,\n    error: unknown,\n    delay: number,\n  ) => boolean | undefined\n  onRetryCancelOnFalse?: boolean\n  onRetryRethrow?: boolean\n  retries?: number\n  signal?: AbortSignal\n}\n\nexport interface IterationOptions {\n  concurrency?: number\n  retries?: number | RetryOptions\n  signal?: AbortSignal\n}\n\nlet _timers: typeof import('node:timers/promises') | undefined\n/**\n * Get the timers/promises module.\n * @private\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getTimers() {\n  if (_timers === undefined) {\n    // Use non-'node:' prefixed require to avoid Webpack errors.\n\n    _timers = /*@__PURE__*/ require('node:timers/promises')\n  }\n  return _timers as typeof import('node:timers/promises')\n}\n\n/**\n * Normalize options for iteration functions.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function normalizeIterationOptions(\n  options?: number | IterationOptions,\n): { concurrency: number; retries: RetryOptions; signal: AbortSignal } {\n  // Handle number as concurrency shorthand\n  const opts = typeof options === 'number' ? { concurrency: options } : options\n\n  const {\n    // The number of concurrent executions performed at one time.\n    concurrency = 1,\n    // Retries as a number or options object.\n    retries,\n    // AbortSignal used to support cancellation.\n    signal = abortSignal,\n  } = { __proto__: null, ...opts } as IterationOptions\n\n  // Ensure concurrency is at least 1\n  const normalizedConcurrency = Math.max(1, concurrency)\n  const retryOpts = resolveRetryOptions(retries)\n  return {\n    __proto__: null,\n    concurrency: normalizedConcurrency,\n    retries: normalizeRetryOptions({ signal, ...retryOpts }),\n    signal,\n  } as { concurrency: number; retries: RetryOptions; signal: AbortSignal }\n}\n\n/**\n * Normalize options for retry functionality.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function normalizeRetryOptions(\n  options?: number | RetryOptions,\n): RetryOptions {\n  const resolved = resolveRetryOptions(options)\n  const {\n    // Arguments to pass to the callback function.\n    args = [],\n    // Multiplier for exponential backoff (e.g., 2 doubles delay each retry).\n    backoffFactor = resolved.factor || 2,\n    // Initial delay before the first retry (in milliseconds).\n    baseDelayMs = resolved.minTimeout || 200,\n    // Whether to apply randomness to spread out retries.\n    jitter = true,\n    // Upper limit for any backoff delay (in milliseconds).\n    maxDelayMs = resolved.maxTimeout || 10_000,\n    // Optional callback invoked on each retry attempt:\n    // (attempt: number, error: unknown, delay: number) => void\n    onRetry,\n    // Whether onRetry can cancel retries by returning `false`.\n    onRetryCancelOnFalse = false,\n    // Whether onRetry will rethrow errors.\n    onRetryRethrow = false,\n    // Number of retry attempts (0 = no retries, only initial attempt).\n    retries = resolved.retries || 0,\n    // AbortSignal used to support cancellation.\n    signal = abortSignal,\n  } = resolved\n  return {\n    args,\n    backoffFactor,\n    baseDelayMs,\n    jitter,\n    maxDelayMs,\n    minTimeout: baseDelayMs,\n    maxTimeout: maxDelayMs,\n    onRetry,\n    onRetryCancelOnFalse,\n    onRetryRethrow,\n    retries,\n    signal,\n  } as RetryOptions\n}\n\n/**\n * Resolve retry options from various input formats.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function resolveRetryOptions(\n  options?: number | RetryOptions,\n): RetryOptions {\n  const defaults = {\n    __proto__: null,\n    retries: 0,\n    minTimeout: 200,\n    maxTimeout: 10_000,\n    factor: 2,\n  }\n\n  if (typeof options === 'number') {\n    return { ...defaults, retries: options }\n  }\n\n  return options ? { ...defaults, ...options } : defaults\n}\n\n/**\n * Execute an async function for each array element with concurrency control.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pEach<T>(\n  array: T[],\n  callbackFn: (item: T) => Promise<unknown>,\n  options?: number | IterationOptions,\n): Promise<void> {\n  const iterOpts = normalizeIterationOptions(options)\n  const { concurrency, retries, signal } = iterOpts\n\n  // Process items with concurrency control.\n  const chunks = arrayChunk(array, concurrency)\n  for (const chunk of chunks) {\n    if (signal?.aborted) {\n      return\n    }\n    // Process each item in the chunk concurrently.\n    // eslint-disable-next-line no-await-in-loop\n    await Promise.all(\n      chunk.map((item: T) =>\n        pRetry((...args: unknown[]) => callbackFn(args[0] as T), {\n          ...retries,\n          args: [item],\n          signal,\n        }),\n      ),\n    )\n  }\n}\n\n/**\n * Filter an array asynchronously with concurrency control.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pFilter<T>(\n  array: T[],\n  callbackFn: (item: T) => Promise<boolean>,\n  options?: number | IterationOptions,\n): Promise<T[]> {\n  const iterOpts = normalizeIterationOptions(options)\n  return (\n    await pFilterChunk(\n      arrayChunk(array, iterOpts.concurrency),\n      callbackFn,\n      iterOpts.retries,\n    )\n  ).flat()\n}\n\n/**\n * Process array in chunks with an async callback.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pEachChunk<T>(\n  array: T[],\n  callbackFn: (chunk: T[]) => Promise<unknown>,\n  options?: RetryOptions & { chunkSize?: number },\n): Promise<void> {\n  const { chunkSize = 100, ...retryOpts } = options || {}\n  const chunks = arrayChunk(array, chunkSize)\n  const normalizedRetryOpts = normalizeRetryOptions(retryOpts)\n  const { signal } = normalizedRetryOpts\n  for (const chunk of chunks) {\n    if (signal?.aborted) {\n      return\n    }\n    // eslint-disable-next-line no-await-in-loop\n    await pRetry((...args: unknown[]) => callbackFn(args[0] as T[]), {\n      ...normalizedRetryOpts,\n      args: [chunk],\n    })\n  }\n}\n\n/**\n * Filter chunked arrays with an async predicate.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pFilterChunk<T>(\n  chunks: T[][],\n  callbackFn: (value: T) => Promise<boolean>,\n  options?: number | RetryOptions,\n): Promise<T[][]> {\n  const retryOpts = normalizeRetryOptions(options)\n  const { signal } = retryOpts\n  const { length } = chunks\n  const filteredChunks = Array(length)\n  for (let i = 0; i < length; i += 1) {\n    // Process each chunk, filtering based on the callback function.\n    if (signal?.aborted) {\n      filteredChunks[i] = []\n    } else {\n      const chunk = chunks[i] as T[]\n      // eslint-disable-next-line no-await-in-loop\n      const predicateResults = await Promise.all(\n        chunk.map(value =>\n          pRetry((...args: unknown[]) => callbackFn(args[0] as T), {\n            ...retryOpts,\n            args: [value],\n          }),\n        ),\n      )\n      filteredChunks[i] = chunk.filter((_v, i) => predicateResults[i])\n    }\n  }\n  return filteredChunks\n}\n\n/**\n * Retry an async function with exponential backoff.\n * @throws {Error} The last error if all retries fail.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pRetry<T>(\n  callbackFn: (...args: unknown[]) => Promise<T>,\n  options?: number | RetryOptions,\n): Promise<T | undefined> {\n  const {\n    args,\n    backoffFactor,\n    baseDelayMs,\n    jitter,\n    maxDelayMs,\n    onRetry,\n    onRetryCancelOnFalse,\n    onRetryRethrow,\n    retries,\n    signal,\n  } = normalizeRetryOptions(options)\n  if (signal?.aborted) {\n    return undefined\n  }\n  if (retries === 0) {\n    return await callbackFn(...(args || []), { signal })\n  }\n\n  const timers = getTimers()\n\n  let attempts = retries as number\n  let delay = baseDelayMs as number\n  let error: unknown = UNDEFINED_TOKEN\n\n  while (attempts-- >= 0) {\n    // Check abort before attempt.\n    if (signal?.aborted) {\n      return undefined\n    }\n\n    try {\n      // eslint-disable-next-line no-await-in-loop\n      return await callbackFn(...(args || []), { signal })\n    } catch (e) {\n      if (error === UNDEFINED_TOKEN) {\n        error = e\n      }\n      if (attempts < 0) {\n        break\n      }\n      let waitTime = delay\n      if (jitter) {\n        // Add randomness: Pick a value between 0 and `delay`.\n        waitTime += Math.floor(Math.random() * delay)\n      }\n      // Clamp wait time to max delay.\n      waitTime = Math.min(waitTime, maxDelayMs as number)\n      if (typeof onRetry === 'function') {\n        try {\n          const result = onRetry((retries as number) - attempts, e, waitTime)\n          if (result === false && onRetryCancelOnFalse) {\n            break\n          }\n        } catch (e) {\n          if (onRetryRethrow) {\n            throw e\n          }\n        }\n      }\n\n      try {\n        // eslint-disable-next-line no-await-in-loop\n        await timers.setTimeout(waitTime, undefined, { signal })\n      } catch {\n        // setTimeout was aborted.\n        return undefined\n      }\n\n      // Check abort again after delay.\n      if (signal?.aborted) {\n        return undefined\n      }\n\n      // Exponentially increase the delay for the next attempt, capping at maxDelayMs.\n      delay = Math.min(delay * (backoffFactor as number), maxDelayMs as number)\n    }\n  }\n  if (error !== UNDEFINED_TOKEN) {\n    throw error\n  }\n  return undefined\n}\n"],
+  "mappings": "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",
+  "names": ["i", "e"]
+}

package/dist/prompts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Interactive prompt utilities for CLI applications.
+ * Re-exports commonly used prompt functions from inquirer packages.
+ */
+export { default as confirm } from '@inquirer/confirm';
+export { default as input } from '@inquirer/input';
+export { default as password } from '@inquirer/password';
+export { default as search } from '@inquirer/search';
+export { default as select } from '@inquirer/select';
+// Export types - Choice is a type interface, not a direct export
+export interface Choice<Value = unknown> {
+    value: Value;
+    name?: string;
+    description?: string;
+    short?: string;
+    disabled?: boolean | string;
+}
+// Create a Separator type that matches the expected interface
+export interface Separator {
+    type: 'separator';
+    separator?: string;
+    line?: string;
+}
+/**
+ * Create a separator for select prompts.
+ */
+export declare function createSeparator(text?: string): Separator;

package/dist/prompts.js

@@ -0,0 +1,60 @@
+/* Socket Lib - Built with esbuild */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prompts_exports = {};
+__export(prompts_exports, {
+  confirm: () => import_confirm.default,
+  createSeparator: () => createSeparator,
+  input: () => import_input.default,
+  password: () => import_password.default,
+  search: () => import_search.default,
+  select: () => import_select.default
+});
+module.exports = __toCommonJS(prompts_exports);
+var import_confirm = __toESM(require("@inquirer/confirm"));
+var import_input = __toESM(require("@inquirer/input"));
+var import_password = __toESM(require("@inquirer/password"));
+var import_search = __toESM(require("@inquirer/search"));
+var import_select = __toESM(require("@inquirer/select"));
+function createSeparator(text) {
+  return {
+    type: "separator",
+    separator: text || "\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    line: text || "\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  confirm,
+  createSeparator,
+  input,
+  password,
+  search,
+  select
+});
+//# sourceMappingURL=prompts.js.map

package/dist/prompts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/prompts.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Interactive prompt utilities for CLI applications.\n * Re-exports commonly used prompt functions from inquirer packages.\n */\n\nexport { default as confirm } from '@inquirer/confirm'\nexport { default as input } from '@inquirer/input'\nexport { default as password } from '@inquirer/password'\nexport { default as search } from '@inquirer/search'\nexport { default as select } from '@inquirer/select'\n\n// Export types - Choice is a type interface, not a direct export\nexport interface Choice<Value = unknown> {\n  value: Value\n  name?: string\n  description?: string\n  short?: string\n  disabled?: boolean | string\n}\n\n// Create a Separator type that matches the expected interface\nexport interface Separator {\n  type: 'separator'\n  separator?: string\n  line?: string\n}\n\n/**\n * Create a separator for select prompts.\n */\nexport function createSeparator(text?: string): Separator {\n  return {\n    type: 'separator',\n    separator: text || '\u2500\u2500\u2500\u2500\u2500\u2500\u2500',\n    line: text || '\u2500\u2500\u2500\u2500\u2500\u2500\u2500',\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,qBAAmC;AACnC,mBAAiC;AACjC,sBAAoC;AACpC,oBAAkC;AAClC,oBAAkC;AAqB3B,SAAS,gBAAgB,MAA0B;AACxD,SAAO;AAAA,IACL,MAAM;AAAA,IACN,WAAW,QAAQ;AAAA,IACnB,MAAM,QAAQ;AAAA,EAChB;AACF;",
+  "names": []
+}

package/dist/regexps.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Regular expression utilities including escape-string-regexp implementation.
+ * Provides regex escaping and pattern matching helpers.
+ */
+// Inlined escape-string-regexp:
+// https://socket.dev/npm/package/escape-string-regexp/overview/5.0.0
+// MIT License
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+/**
+ * Escape special characters in a string for use in a regular expression.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function escapeRegExp(str: string): string;

package/dist/regexps.js

@@ -0,0 +1,32 @@
+/* Socket Lib - Built with esbuild */
+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 regexps_exports = {};
+__export(regexps_exports, {
+  escapeRegExp: () => escapeRegExp
+});
+module.exports = __toCommonJS(regexps_exports);
+// @__NO_SIDE_EFFECTS__
+function escapeRegExp(str) {
+  return str.replace(/[\\|{}()[\]^$+*?.]/g, "\\$&");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeRegExp
+});
+//# sourceMappingURL=regexps.js.map

package/dist/regexps.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/regexps.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Regular expression utilities including escape-string-regexp implementation.\n * Provides regex escaping and pattern matching helpers.\n */\n\n// Inlined escape-string-regexp:\n// https://socket.dev/npm/package/escape-string-regexp/overview/5.0.0\n// MIT License\n// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)\n\n/**\n * Escape special characters in a string for use in a regular expression.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function escapeRegExp(str: string): string {\n  // Escape characters with special meaning either inside or outside character sets.\n  // Use a simple backslash escape when it's always valid, and a `\\xnn` escape when\n  // the simpler form would be disallowed by Unicode patterns' stricter grammar.\n  return str.replace(/[\\\\|{}()[\\]^$+*?.]/g, '\\\\$&')\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAcO,SAAS,aAAa,KAAqB;AAIhD,SAAO,IAAI,QAAQ,uBAAuB,MAAM;AAClD;",
+  "names": []
+}

package/dist/sea.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get the current SEA binary path.
+ * Only valid when running as a SEA binary.
+ */
+export declare function getSeaBinaryPath(): string | undefined;
+/**
+ * Detect if the current process is running as a SEA binary.
+ * Uses Node.js 24+ native API with caching for performance.
+ */
+export declare function isSeaBinary(): boolean;