@socketsecurity/lib 3.0.1 → 3.0.3

package/dist/process-lock.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/process-lock.ts"],
   "sourcesContent": ["/**\n * @fileoverview Process locking utilities with stale detection and exit cleanup.\n * Provides cross-platform inter-process synchronization using directory-based locks.\n * Aligned with npm's npx locking strategy (5-second stale timeout, periodic touching).\n *\n * ## Why directories instead of files?\n *\n * This implementation uses `mkdir()` to create lock directories (not files) because:\n *\n * 1. **Atomic guarantee**: `mkdir()` is guaranteed atomic across ALL filesystems,\n *    including NFS. Only ONE process can successfully create the directory. If it\n *    exists, `mkdir()` fails with EEXIST instantly with no race conditions.\n *\n * 2. **File-based locking issues**:\n *    - `writeFile()` with `flag: 'wx'` - atomicity can fail on NFS\n *    - `open()` with `O_EXCL` - not guaranteed atomic on older NFS\n *    - Traditional lockfiles - can have race conditions on network filesystems\n *\n * 3. **Simplicity**: No need to write/read file content, track PIDs, or manage\n *    file descriptors. Just create/delete directory and check mtime.\n *\n * 4. **Historical precedent**: Well-known Unix locking pattern used by package\n *    managers for decades. Git uses similar approach for `.git/index.lock`.\n *\n * ## The mtime trick\n *\n * We periodically update the lock directory's mtime (modification time) by\n * \"touching\" it to signal \"I'm still actively working\". This prevents other\n * processes from treating the lock as stale and removing it.\n *\n * **The lock directory remains empty** - it's just a sentinel that signals\n * \"locked\". The mtime is the only data needed to track lock freshness.\n *\n * ## npm npx compatibility\n *\n * This implementation matches npm npx's concurrency.lock approach:\n * - Lock created via `mkdir(path.join(installDir, 'concurrency.lock'))`\n * - 5-second stale timeout (if mtime is older than 5s, lock is stale)\n * - 2-second touching interval (updates mtime every 2s to keep lock fresh)\n * - Automatic cleanup on process exit\n */\n\nimport { existsSync, mkdirSync, statSync, utimesSync } from 'fs'\n\nimport { safeDeleteSync } from './fs'\nimport { getDefaultLogger } from './logger'\nimport { pRetry } from './promises'\nimport { onExit } from './signal-exit'\n\nconst logger = getDefaultLogger()\n\n/**\n * Lock acquisition options.\n */\nexport interface ProcessLockOptions {\n  /**\n   * Maximum number of retry attempts.\n   * @default 3\n   */\n  retries?: number | undefined\n\n  /**\n   * Base delay between retries in milliseconds.\n   * @default 100\n   */\n  baseDelayMs?: number | undefined\n\n  /**\n   * Maximum delay between retries in milliseconds.\n   * @default 1000\n   */\n  maxDelayMs?: number | undefined\n\n  /**\n   * Stale lock timeout in milliseconds.\n   * Locks older than this are considered abandoned and can be reclaimed.\n   * Aligned with npm's npx locking strategy (5 seconds).\n   * @default 5000 (5 seconds)\n   */\n  staleMs?: number | undefined\n\n  /**\n   * Interval for touching lock file to keep it fresh in milliseconds.\n   * Set to 0 to disable periodic touching.\n   * @default 2000 (2 seconds)\n   */\n  touchIntervalMs?: number | undefined\n}\n\n/**\n * Process lock manager with stale detection and exit cleanup.\n * Provides cross-platform inter-process synchronization using file-system\n * based locks.\n */\nclass ProcessLockManager {\n  private activeLocks = new Set<string>()\n  private touchTimers = new Map<string, NodeJS.Timeout>()\n  private exitHandlerRegistered = false\n\n  /**\n   * Ensure process exit handler is registered for cleanup.\n   * Registers a handler that cleans up all active locks when the process exits.\n   */\n  private ensureExitHandler() {\n    if (this.exitHandlerRegistered) {\n      return\n    }\n\n    onExit(() => {\n      // Clear all touch timers.\n      for (const timer of this.touchTimers.values()) {\n        clearInterval(timer)\n      }\n      this.touchTimers.clear()\n\n      // Clean up all active locks.\n      for (const lockPath of this.activeLocks) {\n        try {\n          if (existsSync(lockPath)) {\n            safeDeleteSync(lockPath, { recursive: true })\n          }\n        } catch {\n          // Ignore cleanup errors during exit.\n        }\n      }\n    })\n\n    this.exitHandlerRegistered = true\n  }\n\n  /**\n   * Touch a lock file to update its mtime.\n   * This prevents the lock from being detected as stale during long operations.\n   *\n   * @param lockPath - Path to the lock directory\n   */\n  private touchLock(lockPath: string): void {\n    try {\n      if (existsSync(lockPath)) {\n        const now = new Date()\n        utimesSync(lockPath, now, now)\n      }\n    } catch (error) {\n      logger.warn(\n        `Failed to touch lock ${lockPath}: ${error instanceof Error ? error.message : String(error)}`,\n      )\n    }\n  }\n\n  /**\n   * Start periodic touching of a lock file.\n   * Aligned with npm npx strategy to prevent false stale detection.\n   *\n   * @param lockPath - Path to the lock directory\n   * @param intervalMs - Touch interval in milliseconds\n   */\n  private startTouchTimer(lockPath: string, intervalMs: number): void {\n    if (intervalMs <= 0 || this.touchTimers.has(lockPath)) {\n      return\n    }\n\n    const timer = setInterval(() => {\n      this.touchLock(lockPath)\n    }, intervalMs)\n\n    // Prevent timer from keeping process alive.\n    timer.unref()\n\n    this.touchTimers.set(lockPath, timer)\n  }\n\n  /**\n   * Stop periodic touching of a lock file.\n   *\n   * @param lockPath - Path to the lock directory\n   */\n  private stopTouchTimer(lockPath: string): void {\n    const timer = this.touchTimers.get(lockPath)\n    if (timer) {\n      clearInterval(timer)\n      this.touchTimers.delete(lockPath)\n    }\n  }\n\n  /**\n   * Check if a lock is stale based on mtime.\n   * Uses second-level granularity to avoid APFS floating-point precision issues.\n   * Aligned with npm's npx locking strategy.\n   *\n   * @param lockPath - Path to the lock directory\n   * @param staleMs - Stale timeout in milliseconds\n   * @returns True if lock exists and is stale\n   */\n  private isStale(lockPath: string, staleMs: number): boolean {\n    try {\n      if (!existsSync(lockPath)) {\n        return false\n      }\n\n      const stats = statSync(lockPath)\n      // Use second-level granularity to avoid APFS issues.\n      const ageSeconds = Math.floor((Date.now() - stats.mtime.getTime()) / 1000)\n      const staleSeconds = Math.floor(staleMs / 1000)\n      return ageSeconds > staleSeconds\n    } catch {\n      return false\n    }\n  }\n\n  /**\n   * Acquire a lock using mkdir for atomic operation.\n   * Handles stale locks and includes exit cleanup.\n   *\n   * This method attempts to create a lock directory atomically. If the lock\n   * already exists, it checks if it's stale and removes it before retrying.\n   * Uses exponential backoff with jitter for retry attempts.\n   *\n   * @param lockPath - Path to the lock directory\n   * @param options - Lock acquisition options\n   * @returns Release function to unlock\n   * @throws Error if lock cannot be acquired after all retries\n   *\n   * @example\n   * ```typescript\n   * const release = await processLock.acquire('/tmp/my-lock')\n   * try {\n   *   // Critical section\n   * } finally {\n   *   release()\n   * }\n   * ```\n   */\n  async acquire(\n    lockPath: string,\n    options: ProcessLockOptions = {},\n  ): Promise<() => void> {\n    const {\n      baseDelayMs = 100,\n      maxDelayMs = 1000,\n      retries = 3,\n      staleMs = 5000,\n      touchIntervalMs = 2000,\n    } = options\n\n    // Ensure exit handler is registered before any lock acquisition.\n    this.ensureExitHandler()\n\n    return await pRetry(\n      async () => {\n        try {\n          // Check for stale lock and remove if necessary.\n          if (existsSync(lockPath) && this.isStale(lockPath, staleMs)) {\n            logger.log(`Removing stale lock: ${lockPath}`)\n            try {\n              safeDeleteSync(lockPath, { recursive: true })\n            } catch {\n              // Ignore errors removing stale lock - will retry.\n            }\n          }\n\n          // Check if lock already exists before creating.\n          if (existsSync(lockPath)) {\n            throw new Error(`Lock already exists: ${lockPath}`)\n          }\n\n          // Atomic lock acquisition via mkdir with recursive to create parent dirs.\n          mkdirSync(lockPath, { recursive: true })\n\n          // Track lock for cleanup.\n          this.activeLocks.add(lockPath)\n\n          // Start periodic touching to prevent stale detection.\n          this.startTouchTimer(lockPath, touchIntervalMs)\n\n          // Return release function.\n          return () => this.release(lockPath)\n        } catch (error) {\n          const code = (error as NodeJS.ErrnoException).code\n\n          // Handle lock contention - lock already exists.\n          if (code === 'EEXIST') {\n            if (this.isStale(lockPath, staleMs)) {\n              throw new Error(`Stale lock detected: ${lockPath}`)\n            }\n            throw new Error(`Lock already exists: ${lockPath}`)\n          }\n\n          // Handle permission errors - not retryable.\n          if (code === 'EACCES' || code === 'EPERM') {\n            throw new Error(\n              `Permission denied creating lock: ${lockPath}. ` +\n                'Check directory permissions or run with appropriate access.',\n              { cause: error },\n            )\n          }\n\n          // Handle read-only filesystem - not retryable.\n          if (code === 'EROFS') {\n            throw new Error(\n              `Cannot create lock on read-only filesystem: ${lockPath}`,\n              { cause: error },\n            )\n          }\n\n          // Handle parent path issues - not retryable.\n          if (code === 'ENOTDIR') {\n            const parentDir = lockPath.slice(0, lockPath.lastIndexOf('/'))\n            throw new Error(\n              `Cannot create lock directory: ${lockPath}\\n` +\n                'A path component is a file when it should be a directory.\\n' +\n                `Parent path: ${parentDir}\\n` +\n                'To resolve:\\n' +\n                `  1. Check if \"${parentDir}\" contains a file instead of a directory\\n` +\n                '  2. Remove any conflicting files in the path\\n' +\n                '  3. Ensure the full parent directory structure exists',\n              { cause: error },\n            )\n          }\n\n          if (code === 'ENOENT') {\n            const parentDir = lockPath.slice(0, lockPath.lastIndexOf('/'))\n            throw new Error(\n              `Cannot create lock directory: ${lockPath}\\n` +\n                `Parent directory does not exist: ${parentDir}\\n` +\n                'To resolve:\\n' +\n                `  1. Ensure the parent directory \"${parentDir}\" exists\\n` +\n                `  2. Create the directory structure: mkdir -p \"${parentDir}\"\\n` +\n                '  3. Check filesystem permissions allow directory creation',\n              { cause: error },\n            )\n          }\n\n          // Re-throw other errors with context.\n          throw new Error(`Failed to acquire lock: ${lockPath}`, {\n            cause: error,\n          })\n        }\n      },\n      {\n        retries,\n        baseDelayMs,\n        maxDelayMs,\n        jitter: true,\n      },\n    )\n  }\n\n  /**\n   * Release a lock and remove from tracking.\n   * Stops periodic touching and removes the lock directory.\n   *\n   * @param lockPath - Path to the lock directory\n   *\n   * @example\n   * ```typescript\n   * processLock.release('/tmp/my-lock')\n   * ```\n   */\n  release(lockPath: string): void {\n    // Stop periodic touching.\n    this.stopTouchTimer(lockPath)\n\n    try {\n      if (existsSync(lockPath)) {\n        safeDeleteSync(lockPath, { recursive: true })\n      }\n      this.activeLocks.delete(lockPath)\n    } catch (error) {\n      logger.warn(\n        `Failed to release lock ${lockPath}: ${error instanceof Error ? error.message : String(error)}`,\n      )\n    }\n  }\n\n  /**\n   * Execute a function with exclusive lock protection.\n   * Automatically handles lock acquisition, execution, and cleanup.\n   *\n   * This is the recommended way to use process locks, as it guarantees\n   * cleanup even if the callback throws an error.\n   *\n   * @param lockPath - Path to the lock directory\n   * @param fn - Function to execute while holding the lock\n   * @param options - Lock acquisition options\n   * @returns Result of the callback function\n   * @throws Error from callback or lock acquisition failure\n   *\n   * @example\n   * ```typescript\n   * const result = await processLock.withLock('/tmp/my-lock', async () => {\n   *   // Critical section\n   *   return someValue\n   * })\n   * ```\n   */\n  async withLock<T>(\n    lockPath: string,\n    fn: () => Promise<T>,\n    options?: ProcessLockOptions,\n  ): Promise<T> {\n    const release = await this.acquire(lockPath, options)\n    try {\n      return await fn()\n    } finally {\n      release()\n    }\n  }\n}\n\n// Export singleton instance.\nexport const processLock = new ProcessLockManager()\n"],
-  "mappings": "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",
-  "names": ["process_lock_exports", "__export", "processLock", "__toCommonJS", "import_fs", "import_logger", "import_promises", "import_signal_exit", "logger", "ProcessLockManager", "timer", "lockPath", "now", "error", "intervalMs", "staleMs", "stats", "ageSeconds", "staleSeconds", "options", "baseDelayMs", "maxDelayMs", "retries", "touchIntervalMs", "code", "parentDir", "fn", "release"]
+  "mappings": "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",
+  "names": ["import_fs"]
 }

package/dist/promise-queue.js

@@ -1,3 +1,111 @@
 /* Socket Lib - Built with esbuild */
-var i=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var h=Object.prototype.hasOwnProperty;var d=(t,e)=>{for(var n in e)i(t,n,{get:e[n],enumerable:!0})},c=(t,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let u of o(e))!h.call(t,u)&&u!==n&&i(t,u,{get:()=>e[u],enumerable:!(r=a(e,u))||r.enumerable});return t};var m=t=>c(i({},"__esModule",{value:!0}),t);var l={};d(l,{PromiseQueue:()=>g});module.exports=m(l);class g{queue=[];running=0;maxConcurrency;maxQueueLength;constructor(e,n){if(this.maxConcurrency=e,this.maxQueueLength=n,e<1)throw new Error("maxConcurrency must be at least 1")}async add(e){return await new Promise((n,r)=>{const u={fn:e,resolve:n,reject:r};if(this.maxQueueLength&&this.queue.length>=this.maxQueueLength){const s=this.queue.shift();s&&s.reject(new Error("Task dropped: queue length exceeded"))}this.queue.push(u),this.runNext()})}runNext(){if(this.running>=this.maxConcurrency||this.queue.length===0)return;const e=this.queue.shift();e&&(this.running++,e.fn().then(e.resolve).catch(e.reject).finally(()=>{this.running--,this.runNext()}))}async onIdle(){return await new Promise(e=>{const n=()=>{this.running===0&&this.queue.length===0?e():setImmediate(n)};n()})}get activeCount(){return this.running}get pendingCount(){return this.queue.length}clear(){this.queue=[]}}0&&(module.exports={PromiseQueue});
+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

@@ -2,6 +2,6 @@
   "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": ";4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAWO,MAAME,CAAa,CAChB,MAAoC,CAAC,EACrC,QAAU,EAED,eACA,eAOjB,YAAYE,EAAwBC,EAAqC,CAGvE,GAFA,KAAK,eAAiBD,EACtB,KAAK,eAAiBC,EAClBD,EAAiB,EACnB,MAAM,IAAI,MAAM,mCAAmC,CAEvD,CAOA,MAAM,IAAOE,EAAkC,CAC7C,OAAO,MAAM,IAAI,QAAW,CAACC,EAASC,IAAW,CAC/C,MAAMC,EAAsB,CAAE,GAAAH,EAAI,QAAAC,EAAS,OAAAC,CAAO,EAElD,GAAI,KAAK,gBAAkB,KAAK,MAAM,QAAU,KAAK,eAAgB,CAEnE,MAAME,EAAc,KAAK,MAAM,MAAM,EACjCA,GACFA,EAAY,OAAO,IAAI,MAAM,qCAAqC,CAAC,CAEvE,CAEA,KAAK,MAAM,KAAKD,CAA2B,EAC3C,KAAK,QAAQ,CACf,CAAC,CACH,CAEQ,SAAgB,CACtB,GAAI,KAAK,SAAW,KAAK,gBAAkB,KAAK,MAAM,SAAW,EAC/D,OAGF,MAAMA,EAAO,KAAK,MAAM,MAAM,EACzBA,IAIL,KAAK,UAELA,EACG,GAAG,EACH,KAAKA,EAAK,OAAO,EACjB,MAAMA,EAAK,MAAM,EACjB,QAAQ,IAAM,CACb,KAAK,UACL,KAAK,QAAQ,CACf,CAAC,EACL,CAKA,MAAM,QAAwB,CAC5B,OAAO,MAAM,IAAI,QAAcF,GAAW,CACxC,MAAMI,EAAQ,IAAM,CACd,KAAK,UAAY,GAAK,KAAK,MAAM,SAAW,EAC9CJ,EAAQ,EAER,aAAaI,CAAK,CAEtB,EACAA,EAAM,CACR,CAAC,CACH,CAKA,IAAI,aAAsB,CACxB,OAAO,KAAK,OACd,CAKA,IAAI,cAAuB,CACzB,OAAO,KAAK,MAAM,MACpB,CAKA,OAAc,CACZ,KAAK,MAAQ,CAAC,CAChB,CACF",
-  "names": ["promise_queue_exports", "__export", "PromiseQueue", "__toCommonJS", "maxConcurrency", "maxQueueLength", "fn", "resolve", "reject", "task", "droppedTask", "check"]
+  "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.js

@@ -1,3 +1,269 @@
 /* Socket Lib - Built with esbuild */
-var T=Object.defineProperty;var F=Object.getOwnPropertyDescriptor;var S=Object.getOwnPropertyNames;var z=Object.prototype.hasOwnProperty;var I=(e,n)=>{for(var r in n)T(e,r,{get:n[r],enumerable:!0})},v=(e,n,r,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of S(n))!z.call(e,o)&&o!==r&&T(e,o,{get:()=>n[o],enumerable:!(t=F(n,o))||t.enumerable});return e};var A=e=>v(T({},"__esModule",{value:!0}),e);var K={};I(K,{normalizeIterationOptions:()=>w,normalizeRetryOptions:()=>y,pEach:()=>j,pEachChunk:()=>q,pFilter:()=>N,pFilterChunk:()=>D,pRetry:()=>R,resolveRetryOptions:()=>_});module.exports=A(K);var O=require("#constants/core"),M=require("#constants/process"),h=require("./arrays");const P=(0,M.getAbortSignal)();let k;function E(){return k===void 0&&(k=require("node:timers/promises")),k}function w(e){const n=typeof e=="number"?{concurrency:e}:e,{concurrency:r=1,retries:t,signal:o=P}={__proto__:null,...n};return{__proto__:null,concurrency:Math.max(1,r),retries:y({signal:o,..._(t)}),signal:o}}function y(e){const n=_(e),{args:r=[],backoffFactor:t=2,baseDelayMs:o=200,jitter:u=!0,maxDelayMs:i=1e4,onRetry:s,onRetryCancelOnFalse:c=!1,onRetryRethrow:d=!1,retries:f=0,signal:a=P}=n;return{args:r,backoffFactor:t,baseDelayMs:o,jitter:u,maxDelayMs:i,onRetry:s,onRetryCancelOnFalse:c,onRetryRethrow:d,retries:f,signal:a}}function _(e){const n={__proto__:null,retries:0,baseDelayMs:200,maxDelayMs:1e4,backoffFactor:2};return typeof e=="number"?{...n,retries:e}:e?{...n,...e}:n}async function j(e,n,r){const t=w(r),{concurrency:o,retries:u,signal:i}=t,s=(0,h.arrayChunk)(e,o);for(const c of s){if(i?.aborted)return;await Promise.all(c.map(d=>R((...f)=>n(f[0]),{...u,args:[d],signal:i})))}}async function N(e,n,r){const t=w(r);return(await D((0,h.arrayChunk)(e,t.concurrency),n,t.retries)).flat()}async function q(e,n,r){const{chunkSize:t=100,...o}=r||{},u=(0,h.arrayChunk)(e,t),i=y(o),{signal:s}=i;for(const c of u){if(s?.aborted)return;await R((...d)=>n(d[0]),{...i,args:[c]})}}async function D(e,n,r){const t=y(r),{signal:o}=t,{length:u}=e,i=Array(u);for(let s=0;s<u;s+=1)if(o?.aborted)i[s]=[];else{const c=e[s],d=await Promise.all(c.map(f=>R((...a)=>n(a[0]),{...t,args:[f]})));i[s]=c.filter((f,a)=>d[a])}return i}async function R(e,n){const{args:r,backoffFactor:t,baseDelayMs:o,jitter:u,maxDelayMs:i,onRetry:s,onRetryCancelOnFalse:c,onRetryRethrow:d,retries:f,signal:a}=y(n);if(a?.aborted)return;if(f===0)return await e(...r||[],{signal:a});const C=E();let g=f,p=o,b=O.UNDEFINED_TOKEN;for(;g-->=0;){if(a?.aborted)return;try{return await e(...r||[],{signal:a})}catch(x){if(b===O.UNDEFINED_TOKEN&&(b=x),g<0)break;let m=p;if(u&&(m+=Math.floor(Math.random()*p)),m=Math.min(m,i),typeof s=="function")try{const l=s(f-g,x,m);if(l===!1&&c)break;typeof l=="number"&&l>=0&&(m=Math.min(l,i))}catch(l){if(d)throw l}try{await C.setTimeout(m,void 0,{signal:a})}catch{return}if(a?.aborted)return;p=Math.min(p*t,i)}}if(b!==O.UNDEFINED_TOKEN)throw b}0&&(module.exports={normalizeIterationOptions,normalizeRetryOptions,pEach,pEachChunk,pFilter,pFilterChunk,pRetry,resolveRetryOptions});
+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 = 2,
+    // Initial delay before the first retry (in milliseconds).
+    baseDelayMs = 200,
+    // Whether to apply randomness to spread out retries.
+    jitter = true,
+    // Upper limit for any backoff delay (in milliseconds).
+    maxDelayMs = 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 = 0,
+    // AbortSignal used to support cancellation.
+    signal = abortSignal
+  } = resolved;
+  return {
+    args,
+    backoffFactor,
+    baseDelayMs,
+    jitter,
+    maxDelayMs,
+    onRetry,
+    onRetryCancelOnFalse,
+    onRetryRethrow,
+    retries,
+    signal
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function resolveRetryOptions(options) {
+  const defaults = {
+    __proto__: null,
+    retries: 0,
+    baseDelayMs: 200,
+    maxDelayMs: 1e4,
+    backoffFactor: 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;
+          }
+          if (typeof result === "number" && result >= 0) {
+            waitTime = Math.min(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 = 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

@@ -2,6 +2,6 @@
   "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\n/**\n * Configuration options for retry behavior with exponential backoff.\n *\n * Controls how failed operations are retried, including timing, backoff strategy,\n * and callback hooks for observing or modifying retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * Arguments to pass to the callback function on each attempt.\n   *\n   * @default []\n   */\n  args?: unknown[] | undefined\n\n  /**\n   * Multiplier for exponential backoff (e.g., 2 doubles delay each retry).\n   * Each retry waits `baseDelayMs * (backoffFactor ** attemptNumber)`.\n   *\n   * @default 2\n   * @example\n   * // With backoffFactor: 2, baseDelayMs: 100\n   * // Retry 1: 100ms\n   * // Retry 2: 200ms\n   * // Retry 3: 400ms\n   */\n  backoffFactor?: number | undefined\n\n  /**\n   * Initial delay before the first retry (in milliseconds).\n   * This is the base value for exponential backoff calculations.\n   *\n   * @default 200\n   */\n  baseDelayMs?: number | undefined\n\n  // REMOVED: Deprecated `factor` option\n  // Migration: Use `backoffFactor` instead\n\n  /**\n   * Whether to apply randomness to spread out retries and avoid thundering herd.\n   * When `true`, adds random delay between 0 and current delay value.\n   *\n   * @default true\n   * @example\n   * // With jitter: true, delay: 100ms\n   * // Actual wait: 100ms + random(0-100ms) = 100-200ms\n   */\n  jitter?: boolean | undefined\n\n  /**\n   * Upper limit for any backoff delay (in milliseconds).\n   * Prevents exponential backoff from growing unbounded.\n   *\n   * @default 10000\n   */\n  maxDelayMs?: number | undefined\n\n  // REMOVED: Deprecated `maxTimeout` option\n  // Migration: Use `maxDelayMs` instead\n\n  // REMOVED: Deprecated `minTimeout` option\n  // Migration: Use `baseDelayMs` instead\n\n  /**\n   * Callback invoked on each retry attempt.\n   * Can observe errors, customize delays, or cancel retries.\n   *\n   * @param attempt - The current attempt number (1-based: 1, 2, 3, ...)\n   * @param error - The error that triggered this retry\n   * @param delay - The calculated delay in milliseconds before next retry\n   * @returns `false` to cancel retries (if `onRetryCancelOnFalse` is `true`),\n   *          a number to override the delay, or `undefined` to use calculated delay\n   *\n   * @example\n   * // Log each retry\n   * onRetry: (attempt, error, delay) => {\n   *   console.log(`Retry ${attempt} after ${delay}ms: ${error}`)\n   * }\n   *\n   * @example\n   * // Cancel retries for specific errors\n   * onRetry: (attempt, error) => {\n   *   if (error instanceof ValidationError) return false\n   * }\n   *\n   * @example\n   * // Use custom delay\n   * onRetry: (attempt) => attempt * 1000 // 1s, 2s, 3s, ...\n   */\n  onRetry?:\n    | ((\n        attempt: number,\n        error: unknown,\n        delay: number,\n      ) => boolean | number | undefined)\n    | undefined\n\n  /**\n   * Whether `onRetry` can cancel retries by returning `false`.\n   * When `true`, returning `false` from `onRetry` stops retry attempts.\n   *\n   * @default false\n   */\n  onRetryCancelOnFalse?: boolean | undefined\n\n  /**\n   * Whether errors thrown by `onRetry` should propagate.\n   * When `true`, exceptions in `onRetry` terminate the retry loop.\n   * When `false`, exceptions in `onRetry` are silently caught.\n   *\n   * @default false\n   */\n  onRetryRethrow?: boolean | undefined\n\n  /**\n   * Number of retry attempts (0 = no retries, only initial attempt).\n   * The callback is executed `retries + 1` times total (initial + retries).\n   *\n   * @default 0\n   * @example\n   * // retries: 0 -> 1 total attempt (no retries)\n   * // retries: 3 -> 4 total attempts (1 initial + 3 retries)\n   */\n  retries?: number | undefined\n\n  /**\n   * AbortSignal to support cancellation of retry operations.\n   * When aborted, immediately stops retrying and returns `undefined`.\n   *\n   * @default process abort signal\n   * @example\n   * const controller = new AbortController()\n   * pRetry(fn, { signal: controller.signal })\n   * // Later: controller.abort() to cancel\n   */\n  signal?: AbortSignal | undefined\n}\n\n/**\n * Configuration options for iteration functions with concurrency control.\n *\n * Controls how array operations are parallelized and retried.\n */\nexport interface IterationOptions {\n  /**\n   * The number of concurrent executions performed at one time.\n   * Higher values increase parallelism but may overwhelm resources.\n   *\n   * @default 1\n   * @example\n   * // Process 5 items at a time\n   * await pEach(items, processItem, { concurrency: 5 })\n   */\n  concurrency?: number | undefined\n\n  /**\n   * Retry configuration as a number (retry count) or full options object.\n   * Applied to each individual item's callback execution.\n   *\n   * @default 0 (no retries)\n   * @example\n   * // Simple: retry each item up to 3 times\n   * await pEach(items, fetchItem, { retries: 3 })\n   *\n   * @example\n   * // Advanced: custom backoff for each item\n   * await pEach(items, fetchItem, {\n   *   retries: {\n   *     retries: 3,\n   *     baseDelayMs: 1000,\n   *     backoffFactor: 2\n   *   }\n   * })\n   */\n  retries?: number | RetryOptions | undefined\n\n  /**\n   * AbortSignal to support cancellation of the entire iteration.\n   * When aborted, stops processing remaining items.\n   *\n   * @default process abort signal\n   */\n  signal?: AbortSignal | undefined\n}\n\nlet _timers: typeof import('node:timers/promises') | undefined\n/**\n * Get the timers/promises module.\n * Uses lazy loading to avoid Webpack bundling issues.\n *\n * @private\n * @returns The Node.js timers/promises module\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 * Converts various option formats into a consistent structure with defaults applied.\n * Handles number shorthand for concurrency and ensures minimum values.\n *\n * @param options - Concurrency as number, or full options object, or undefined\n * @returns Normalized options with concurrency, retries, and signal\n *\n * @example\n * // Number shorthand for concurrency\n * normalizeIterationOptions(5)\n * // => { concurrency: 5, retries: {...}, signal: AbortSignal }\n *\n * @example\n * // Full options\n * normalizeIterationOptions({ concurrency: 3, retries: 2 })\n * // => { concurrency: 3, retries: {...}, signal: AbortSignal }\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function normalizeIterationOptions(\n  options?: number | IterationOptions | undefined,\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 * Converts various retry option formats into a complete configuration with all defaults.\n * Handles legacy property names (`factor`, `minTimeout`, `maxTimeout`) and merges them\n * with modern equivalents.\n *\n * @param options - Retry count as number, or full options object, or undefined\n * @returns Normalized retry options with all properties set\n *\n * @example\n * // Number shorthand\n * normalizeRetryOptions(3)\n * // => { retries: 3, baseDelayMs: 200, backoffFactor: 2, ... }\n *\n * @example\n * // Full options with defaults filled in\n * normalizeRetryOptions({ retries: 5, baseDelayMs: 500 })\n * // => { retries: 5, baseDelayMs: 500, backoffFactor: 2, jitter: true, ... }\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function normalizeRetryOptions(\n  options?: number | RetryOptions | undefined,\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 = 2,\n    // Initial delay before the first retry (in milliseconds).\n    baseDelayMs = 200,\n    // Whether to apply randomness to spread out retries.\n    jitter = true,\n    // Upper limit for any backoff delay (in milliseconds).\n    maxDelayMs = 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 = 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    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 * Converts shorthand and partial options into a base configuration that can be\n * further normalized. This is an internal helper for option processing.\n *\n * @param options - Retry count as number, or partial options object, or undefined\n * @returns Resolved retry options with defaults for basic properties\n *\n * @example\n * resolveRetryOptions(3)\n * // => { retries: 3, minTimeout: 200, maxTimeout: 10000, factor: 2 }\n *\n * @example\n * resolveRetryOptions({ retries: 5, maxTimeout: 5000 })\n * // => { retries: 5, minTimeout: 200, maxTimeout: 5000, factor: 2 }\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function resolveRetryOptions(\n  options?: number | RetryOptions | undefined,\n): RetryOptions {\n  const defaults = {\n    __proto__: null,\n    retries: 0,\n    baseDelayMs: 200,\n    maxDelayMs: 10_000,\n    backoffFactor: 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 * Processes array items in parallel batches (chunks) with configurable concurrency.\n * Each item's callback can be retried independently on failure. Similar to\n * `Promise.all(array.map(fn))` but with controlled parallelism.\n *\n * @template T - The type of array elements\n * @param array - The array to iterate over\n * @param callbackFn - Async function to execute for each item\n * @param options - Concurrency as number, or full iteration options, or undefined\n * @returns Promise that resolves when all items are processed\n *\n * @example\n * // Process items serially (concurrency: 1)\n * await pEach(urls, async (url) => {\n *   await fetch(url)\n * })\n *\n * @example\n * // Process 5 items at a time\n * await pEach(files, async (file) => {\n *   await processFile(file)\n * }, 5)\n *\n * @example\n * // With retries and cancellation\n * const controller = new AbortController()\n * await pEach(tasks, async (task) => {\n *   await executeTask(task)\n * }, {\n *   concurrency: 3,\n *   retries: 2,\n *   signal: controller.signal\n * })\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pEach<T>(\n  array: T[],\n  callbackFn: (item: T) => Promise<unknown>,\n  options?: number | IterationOptions | undefined,\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 * Tests each element with an async predicate function, processing items in parallel\n * batches. Returns a new array with only items that pass the test. Similar to\n * `array.filter()` but for async predicates with controlled concurrency.\n *\n * @template T - The type of array elements\n * @param array - The array to filter\n * @param callbackFn - Async predicate function returning true to keep item\n * @param options - Concurrency as number, or full iteration options, or undefined\n * @returns Promise resolving to filtered array\n *\n * @example\n * // Filter serially\n * const activeUsers = await pFilter(users, async (user) => {\n *   return await isUserActive(user.id)\n * })\n *\n * @example\n * // Filter with concurrency\n * const validFiles = await pFilter(filePaths, async (path) => {\n *   try {\n *     await fs.access(path)\n *     return true\n *   } catch {\n *     return false\n *   }\n * }, 10)\n *\n * @example\n * // With retries for flaky checks\n * const reachable = await pFilter(endpoints, async (url) => {\n *   const response = await fetch(url)\n *   return response.ok\n * }, {\n *   concurrency: 5,\n *   retries: 2\n * })\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pFilter<T>(\n  array: T[],\n  callbackFn: (item: T) => Promise<boolean>,\n  options?: number | IterationOptions | undefined,\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 * Divides the array into fixed-size chunks and processes each chunk sequentially\n * with the callback. Useful for batch operations like bulk database inserts or\n * API calls with payload size limits.\n *\n * @template T - The type of array elements\n * @param array - The array to process in chunks\n * @param callbackFn - Async function to execute for each chunk\n * @param options - Chunk size and retry options\n * @returns Promise that resolves when all chunks are processed\n *\n * @example\n * // Insert records in batches of 100\n * await pEachChunk(records, async (chunk) => {\n *   await db.batchInsert(chunk)\n * }, { chunkSize: 100 })\n *\n * @example\n * // Upload files in batches with retries\n * await pEachChunk(files, async (batch) => {\n *   await uploadBatch(batch)\n * }, {\n *   chunkSize: 50,\n *   retries: 3,\n *   baseDelayMs: 1000\n * })\n *\n * @example\n * // Process with cancellation support\n * const controller = new AbortController()\n * await pEachChunk(items, async (chunk) => {\n *   await processChunk(chunk)\n * }, {\n *   chunkSize: 25,\n *   signal: controller.signal\n * })\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pEachChunk<T>(\n  array: T[],\n  callbackFn: (chunk: T[]) => Promise<unknown>,\n  options?: (RetryOptions & { chunkSize?: number | undefined }) | undefined,\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 * Internal helper for `pFilter`. Processes pre-chunked arrays, applying the\n * predicate to each element within each chunk with retry support.\n *\n * @template T - The type of array elements\n * @param chunks - Pre-chunked array (array of arrays)\n * @param callbackFn - Async predicate function\n * @param options - Retry count as number, or full retry options, or undefined\n * @returns Promise resolving to array of filtered chunks\n *\n * @example\n * const chunks = [[1, 2], [3, 4], [5, 6]]\n * const filtered = await pFilterChunk(chunks, async (n) => n % 2 === 0)\n * // => [[2], [4], [6]]\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pFilterChunk<T>(\n  chunks: T[][],\n  callbackFn: (value: T) => Promise<boolean>,\n  options?: number | RetryOptions | undefined,\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 *\n * Attempts to execute a function multiple times with increasing delays between attempts.\n * Implements exponential backoff with optional jitter to prevent thundering herd problems.\n * Supports custom retry logic via `onRetry` callback.\n *\n * The delay calculation follows: `min(baseDelayMs * (backoffFactor ** attempt), maxDelayMs)`\n * With jitter: adds random value between 0 and calculated delay.\n *\n * @template T - The return type of the callback function\n * @param callbackFn - Async function to retry\n * @param options - Retry count as number, or full retry options, or undefined\n * @returns Promise resolving to callback result, or `undefined` if aborted\n *\n * @throws {Error} The last error if all retry attempts fail\n *\n * @example\n * // Simple retry: 3 attempts with default backoff\n * const data = await pRetry(async () => {\n *   return await fetchData()\n * }, 3)\n *\n * @example\n * // Custom backoff strategy\n * const result = await pRetry(async () => {\n *   return await unreliableOperation()\n * }, {\n *   retries: 5,\n *   baseDelayMs: 1000,    // Start at 1 second\n *   backoffFactor: 2,      // Double each time\n *   maxDelayMs: 30000,     // Cap at 30 seconds\n *   jitter: true           // Add randomness\n * })\n * // Delays: ~1s, ~2s, ~4s, ~8s, ~16s (each \u00B1 random jitter)\n *\n * @example\n * // With custom retry logic\n * const data = await pRetry(async () => {\n *   return await apiCall()\n * }, {\n *   retries: 3,\n *   onRetry: (attempt, error, delay) => {\n *     console.log(`Attempt ${attempt} failed: ${error}`)\n *     console.log(`Waiting ${delay}ms before retry...`)\n *\n *     // Cancel retries for client errors (4xx)\n *     if (error.statusCode >= 400 && error.statusCode < 500) {\n *       return false\n *     }\n *\n *     // Use longer delay for rate limit errors\n *     if (error.statusCode === 429) {\n *       return 60000 // Wait 1 minute\n *     }\n *   },\n *   onRetryCancelOnFalse: true\n * })\n *\n * @example\n * // With cancellation support\n * const controller = new AbortController()\n * setTimeout(() => controller.abort(), 5000) // Cancel after 5s\n *\n * const result = await pRetry(async ({ signal }) => {\n *   return await longRunningTask(signal)\n * }, {\n *   retries: 10,\n *   signal: controller.signal\n * })\n * // Returns undefined if aborted\n *\n * @example\n * // Pass arguments to callback\n * const result = await pRetry(\n *   async (url, options) => {\n *     return await fetch(url, options)\n *   },\n *   {\n *     retries: 3,\n *     args: ['https://api.example.com', { method: 'POST' }]\n *   }\n * )\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function pRetry<T>(\n  callbackFn: (...args: unknown[]) => Promise<T>,\n  options?: number | RetryOptions | undefined,\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          // If onRetry returns a number, use it as the custom delay.\n          if (typeof result === 'number' && result >= 0) {\n            waitTime = Math.min(result, maxDelayMs as number)\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": ["promises_exports", "__export", "normalizeIterationOptions", "normalizeRetryOptions", "pEach", "pEachChunk", "pFilter", "pFilterChunk", "pRetry", "resolveRetryOptions", "__toCommonJS", "import_core", "import_process", "import_arrays", "abortSignal", "_timers", "getTimers", "options", "opts", "concurrency", "retries", "signal", "resolved", "args", "backoffFactor", "baseDelayMs", "jitter", "maxDelayMs", "onRetry", "onRetryCancelOnFalse", "onRetryRethrow", "defaults", "array", "callbackFn", "iterOpts", "chunks", "chunk", "item", "chunkSize", "retryOpts", "normalizedRetryOpts", "length", "filteredChunks", "i", "predicateResults", "value", "_v", "timers", "attempts", "delay", "error", "e", "waitTime", "result"]
+  "mappings": "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",
+  "names": ["i", "e"]
 }

package/dist/prompts/index.js

@@ -1,3 +1,47 @@
 /* Socket Lib - Built with esbuild */
-var r=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var a=(e,t)=>{for(var o in t)r(e,o,{get:t[o],enumerable:!0})},d=(e,t,o,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of s(t))!m.call(e,n)&&n!==o&&r(e,n,{get:()=>t[n],enumerable:!(i=p(t,n))||i.enumerable});return e};var l=e=>d(r({},"__esModule",{value:!0}),e);var y={};a(y,{confirm:()=>u,input:()=>f,select:()=>c});module.exports=l(y);async function f(e){throw new Error("input() not yet implemented - add prompt library integration")}async function u(e){throw new Error("confirm() not yet implemented - add prompt library integration")}async function c(e){throw new Error("select() not yet implemented - add prompt library integration")}0&&(module.exports={confirm,input,select});
+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 prompts_exports = {};
+__export(prompts_exports, {
+  confirm: () => confirm,
+  input: () => input,
+  select: () => select
+});
+module.exports = __toCommonJS(prompts_exports);
+async function input(_options) {
+  throw new Error(
+    "input() not yet implemented - add prompt library integration"
+  );
+}
+async function confirm(_options) {
+  throw new Error(
+    "confirm() not yet implemented - add prompt library integration"
+  );
+}
+async function select(_options) {
+  throw new Error(
+    "select() not yet implemented - add prompt library integration"
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  confirm,
+  input,
+  select
+});
 //# sourceMappingURL=index.js.map