@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/process/spawn/types.d.ts

@@ -0,0 +1,325 @@
+/**
+ * @file Public type surface for `spawn/*` modules. Most of this is straight
+ *   Node.js child_process types duplicated so the lib doesn't carry a hard
+ *   `@types/node` requirement at the surface. The `Spawn*` types layer
+ *   Socket-specific options on top:
+ *
+ *   - `SpawnOptions.spinner` lets the caller pause an outer spinner while the
+ *     child runs (so progress output isn't smeared by the spinner's redraw
+ *     loop).
+ *   - `SpawnOptions.stripAnsi` defaults to true — most consumers want plain text
+ *     from captured output. Pass false only when the output is being forwarded
+ *     to a terminal directly.
+ *   - `SpawnOptions.stdioString` defaults to true — string output is ergonomic;
+ *     opt out for binary streams. `PromiseSpawnResult` is the upstream
+ *     `@npmcli/promise-spawn` shape: a Promise enriched with `process` +
+ *     `stdin` accessors so callers can reach into the running child without
+ *     re-spawning.
+ */
+import type { SendHandle, Serializable, StdioOptions } from 'node:child_process';
+import type { EventEmitter } from 'node:events';
+import type { Remap } from '../../objects/types';
+import type { SpinnerInstance } from '../../spinner/types';
+export type BufferEncoding = globalThis.BufferEncoding;
+/**
+ * Options for spawning a child process with promise-based completion.
+ *
+ * @property {string | undefined} cwd - Current working directory for the
+ *   process.
+ * @property {NodeJS.ProcessEnv | undefined} env - Environment variables for the
+ *   process.
+ * @property {number | undefined} gid - Group identity of the process (POSIX
+ *   only)
+ * @property {boolean | string | undefined} shell - Whether to run command in
+ *   shell, or path to shell.
+ * @property {AbortSignal | undefined} signal - Signal to abort the process.
+ * @property {StdioType | undefined} stdio - Stdio configuration (`'pipe'`,
+ *   `'ignore'`, `'inherit'`, or array)
+ * @property {boolean | undefined} stdioString - Convert stdio output to strings
+ *   (default: `true`)
+ * @property {number | undefined} timeout - Maximum time in milliseconds before
+ *   killing the process.
+ * @property {number | undefined} uid - User identity of the process (POSIX
+ *   only)
+ * @property {boolean | undefined} windowsVerbatimArguments - Don't quote or
+ *   escape arguments on Windows (requires shell: true). Use when you need exact
+ *   argument control. Default: false.
+ */
+export type PromiseSpawnOptions = {
+    cwd?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    gid?: number | undefined;
+    shell?: boolean | string | undefined;
+    signal?: AbortSignal | undefined;
+    stdio?: StdioType | undefined;
+    stdioString?: boolean | undefined;
+    timeout?: number | undefined;
+    uid?: number | undefined;
+    windowsVerbatimArguments?: boolean | undefined;
+};
+/**
+ * Result returned by {@link spawn} when the child process completes. This is a
+ * Promise that resolves with process exit information and output, with
+ * additional properties for accessing the running process and stdin stream.
+ *
+ * @example
+ *   const result = spawn('echo', ['hello'])
+ *   result.stdin?.write('additional input\n')
+ *   const { code, stdout } = await result
+ *   console.log(stdout) // 'hello'
+ *
+ * @property {ChildProcess} process - The running child process instance.
+ * @property {WritableStreamType | null} stdin - Writable stream for process
+ *   stdin, or `null` if not piped.
+ */
+export type PromiseSpawnResult<T = string | Buffer> = Promise<{
+    cmd: string;
+    args: string[] | readonly string[];
+    code: number;
+    signal: NodeJS.Signals | null;
+    stdout: T;
+    stderr: T;
+}> & {
+    process: ChildProcess;
+    stdin: WritableStreamType | null;
+};
+/**
+ * Error object thrown when a spawned process fails. Extends the standard Error
+ * with process-specific information including exit code, signal, command
+ * details, and captured output.
+ *
+ * @example
+ *   try {
+ *     await spawn('exit', ['1'])
+ *   } catch (e) {
+ *     if (isSpawnError(e)) {
+ *       console.error(`Command failed with code ${e.code}`)
+ *       console.error(`stderr: ${e.stderr}`)
+ *     }
+ *   }
+ *
+ * @property {string[]} args - Arguments passed to the command.
+ * @property {string} cmd - Command that was executed.
+ * @property {number} code - Process exit code.
+ * @property {string} name - Error name (typically `'Error'`)
+ * @property {string} message - Error message describing the failure.
+ * @property {NodeJS.Signals | null} signal - Signal that terminated the
+ *   process, if any.
+ * @property {string} stack - Stack trace of the error.
+ * @property {string | Buffer} stderr - Standard error output from the process.
+ * @property {string | Buffer} stdout - Standard output from the process.
+ */
+export type SpawnError = {
+    args: string[];
+    cmd: string;
+    code: number;
+    name: string;
+    message: string;
+    signal: NodeJS.Signals | null;
+    stack: string;
+    stderr: string | Buffer;
+    stdout: string | Buffer;
+};
+/**
+ * Spawn error variant where stdout and stderr are guaranteed to be strings.
+ * This type is used when `stdioString: true` is set in spawn options.
+ *
+ * @property {string} stdout - Standard output as a string.
+ * @property {string} stderr - Standard error as a string.
+ */
+export type SpawnErrorWithOutputString = SpawnError & {
+    stdout: string;
+    stderr: string;
+};
+/**
+ * Spawn error variant where stdout and stderr are guaranteed to be Buffers.
+ * This type is used when `stdioString: false` is set in spawn options.
+ *
+ * @property {Buffer} stdout - Standard output as a Buffer.
+ * @property {Buffer} stderr - Standard error as a Buffer.
+ */
+export type SpawnErrorWithOutputBuffer = SpawnError & {
+    stdout: Buffer;
+    stderr: Buffer;
+};
+/**
+ * Extra options passed to the underlying promise-spawn implementation. This is
+ * an open-ended object for passing additional metadata or configuration.
+ */
+export type SpawnExtra = Record<string, unknown>;
+/**
+ * Valid values for individual stdio streams. - `'pipe'` - Creates a pipe
+ * between child and parent (default) - `'ignore'` - Ignores the stream -
+ * `'inherit'` - Uses parent's stream - `'overlapped'` - Windows-specific
+ * overlapped I/O.
+ */
+export type IOType = 'pipe' | 'ignore' | 'inherit' | 'overlapped';
+/**
+ * Configuration for process stdio (stdin, stdout, stderr) streams. Can be a
+ * single value applied to all streams, or an array specifying each stream
+ * individually. - `'ipc'` - Creates an IPC channel for communication with the
+ * parent.
+ *
+ * @example
+ *   // All streams piped
+ *   stdio: 'pipe'
+ *
+ * @example
+ *   // Custom configuration per stream: [stdin, stdout, stderr]
+ *   stdio: ['ignore', 'pipe', 'pipe']
+ */
+export type StdioType = IOType | 'ipc' | Array<IOType | 'ipc'>;
+/**
+ * Result object returned by {@link spawnSync} when the child process completes
+ * synchronously.
+ *
+ * @template T - Type of stdout/stderr (string or Buffer)
+ *
+ * @property {number} pid - Process ID of the spawned child.
+ * @property {(T | null)[]} output - Array containing stdout/stderr values.
+ * @property {T} stdout - Standard output from the process.
+ * @property {T} stderr - Standard error from the process.
+ * @property {number | null} status - Exit code, or `null` if killed by signal.
+ * @property {NodeJS.Signals | null} signal - Signal that terminated the
+ *   process, or `null`
+ * @property {Error | undefined} error - Error object if the spawn failed.
+ */
+export interface SpawnSyncReturns<T> {
+    pid: number;
+    output: Array<T | null>;
+    stdout: T;
+    stderr: T;
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    error?: Error | undefined;
+}
+export interface NodeSpawnOptions {
+    cwd?: string | URL | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    argv0?: string | undefined;
+    stdio?: StdioOptions | undefined;
+    detached?: boolean | undefined;
+    uid?: number | undefined;
+    gid?: number | undefined;
+    serialization?: 'json' | 'advanced' | undefined;
+    shell?: boolean | string | undefined;
+    windowsVerbatimArguments?: boolean | undefined;
+    windowsHide?: boolean | undefined;
+    signal?: AbortSignal | undefined;
+    timeout?: number | undefined;
+    killSignal?: NodeJS.Signals | number | undefined;
+}
+export interface NodeSpawnSyncOptions extends NodeSpawnOptions {
+    input?: string | NodeJS.ArrayBufferView | undefined;
+    maxBuffer?: number | undefined;
+    encoding?: BufferEncoding | 'buffer' | null | undefined;
+}
+export interface ChildProcess extends EventEmitter {
+    stdin: NodeJS.WritableStream | null;
+    stdout: NodeJS.ReadableStream | null;
+    stderr: NodeJS.ReadableStream | null;
+    readonly channel?: unknown;
+    readonly stdio: [
+        NodeJS.WritableStream | null,
+        NodeJS.ReadableStream | null,
+        NodeJS.ReadableStream | null,
+        NodeJS.ReadableStream | NodeJS.WritableStream | null | undefined,
+        NodeJS.ReadableStream | NodeJS.WritableStream | null | undefined
+    ];
+    readonly killed: boolean;
+    readonly pid?: number | undefined;
+    readonly connected: boolean;
+    readonly exitCode: number | null;
+    readonly signalCode: NodeJS.Signals | null;
+    readonly spawnargs: string[];
+    readonly spawnfile: string;
+    kill(signal?: NodeJS.Signals | number): boolean;
+    send(message: Serializable, callback?: (error: Error | null) => void): boolean;
+    send(message: Serializable, sendHandle?: SendHandle | undefined, callback?: (error: Error | null) => void): boolean;
+    send(message: Serializable, sendHandle?: SendHandle | undefined, options?: {
+        keepOpen?: boolean | undefined;
+    } | undefined, callback?: (error: Error | null) => void): boolean;
+    disconnect(): void;
+    unref(): void;
+    ref(): void;
+}
+export interface WritableStreamType {
+    writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    writableHighWaterMark: number;
+    writableLength: number;
+    writableObjectMode: boolean;
+    writableCorked: number;
+    destroyed: boolean;
+    write(chunk: unknown, encoding?: BufferEncoding | undefined, callback?: (error?: Error | null) => void): boolean;
+    write(chunk: unknown, callback?: (error?: Error | null) => void): boolean;
+    end(cb?: () => void): this;
+    end(chunk: unknown, cb?: () => void): this;
+    end(chunk: unknown, encoding?: BufferEncoding | undefined, cb?: () => void): this;
+    cork(): void;
+    uncork(): void;
+    destroy(error?: Error | undefined): this;
+}
+/**
+ * Options for spawning a child process with {@link spawn}. Extends Node.js spawn
+ * options with additional Socket-specific functionality.
+ *
+ * @property {string | URL | undefined} cwd - Current working directory.
+ * @property {NodeJS.ProcessEnv | undefined} env - Environment variables.
+ * @property {number | undefined} gid - Group identity (POSIX)
+ * @property {boolean | string | undefined} shell - Run command in shell.
+ * @property {AbortSignal | undefined} signal - Abort signal.
+ * @property {import('../../spinner/types').SpinnerInstance | undefined} spinner -
+ *   Spinner instance to pause during execution.
+ * @property {StdioType | undefined} stdio - Stdio configuration.
+ * @property {boolean | undefined} stdioString - Convert output to strings
+ *   (default: `true`)
+ * @property {boolean | undefined} stripAnsi - Remove ANSI codes from output
+ *   (default: `true`)
+ * @property {number | undefined} timeout - Timeout in milliseconds.
+ * @property {number | undefined} uid - User identity (POSIX)
+ * @property {boolean | undefined} windowsVerbatimArguments - Don't quote or
+ *   escape arguments on Windows (requires shell: true). Use when you need exact
+ *   argument control. Default: false.
+ */
+export type SpawnOptions = Remap<NodeSpawnOptions & {
+    spinner?: SpinnerInstance | undefined;
+    stdioString?: boolean;
+    stripAnsi?: boolean;
+}>;
+export type SpawnResult<T = string | Buffer> = PromiseSpawnResult<T>;
+/**
+ * Result object returned when a spawned process completes.
+ *
+ * @property {string} cmd - Command that was executed.
+ * @property {string[] | readonly string[]} args - Arguments passed to the
+ *   command.
+ * @property {number} code - Process exit code.
+ * @property {NodeJS.Signals | null} signal - Signal that terminated the
+ *   process, if any.
+ * @property {string | Buffer} stdout - Standard output (string if `stdioString:
+ *   true`, Buffer otherwise)
+ * @property {string | Buffer} stderr - Standard error (string if `stdioString:
+ *   true`, Buffer otherwise)
+ */
+export type SpawnStdioResult = {
+    cmd: string;
+    args: string[] | readonly string[];
+    code: number;
+    signal: NodeJS.Signals | null;
+    stdout: string | Buffer;
+    stderr: string | Buffer;
+};
+/**
+ * Options for synchronously spawning a child process with {@link spawnSync}.
+ *
+ * Mirrors {@link SpawnOptions} (stdioString, stripAnsi) but builds on Node's
+ * sync option shape ({@link NodeSpawnSyncOptions}) — which adds `input`,
+ * `maxBuffer`, and `encoding` that the async API doesn't have. The `spinner`
+ * field is excluded (not applicable for synchronous execution).
+ */
+export type SpawnSyncOptions = Remap<NodeSpawnSyncOptions & {
+    stdioString?: boolean;
+    stripAnsi?: boolean;
+}>;

package/dist/process/spawn/types.js

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

package/dist/process/transient.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file Temporary package executor detection utilities for Socket ecosystem.
+ *   Identifies and handles temporary execution contexts such as npx, pnpm dlx,
+ *   and yarn dlx.
+ */
+/**
+ * Detects if the current process is running in a temporary package execution
+ * context such as npm exec, npx, pnpm dlx, or yarn dlx.
+ *
+ * When package managers run commands via exec/npx/dlx, they execute in
+ * temporary directories that are cleaned up after execution. Creating
+ * persistent shadows or modifying PATH in these contexts can break subsequent
+ * package manager commands.
+ *
+ * @example
+ *   ;```typescript
+ *   if (isTransientProcess()) {
+ *     console.log('Running in a temporary executor context')
+ *   }
+ *   ```
+ */
+export declare function isTransientProcess(cwd?: string): boolean;

package/dist/{temporary-executor.js → process/transient.js}

@@ -28,15 +28,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var temporary_executor_exports = {};
-__export(temporary_executor_exports, {
-  isRunningInTemporaryExecutor: () => isRunningInTemporaryExecutor
+var transient_exports = {};
+__export(transient_exports, {
+  isTransientProcess: () => isTransientProcess
 });
-module.exports = __toCommonJS(temporary_executor_exports);
+module.exports = __toCommonJS(transient_exports);
 var import_node_process = __toESM(require("node:process"));
-var import_platform = require("./constants/platform");
-var import_normalize = require("./paths/normalize");
-function isRunningInTemporaryExecutor(cwd = import_node_process.default.cwd()) {
+var import_platform = require("../constants/platform");
+var import_normalize = require("../paths/normalize");
+function isTransientProcess(cwd = import_node_process.default.cwd()) {
   const userAgent = import_node_process.default.env["npm_config_user_agent"];
   if (userAgent?.includes("exec") || userAgent?.includes("npx") || // # socket-hook: allow npx
   userAgent?.includes("dlx")) {
@@ -64,5 +64,5 @@ function isRunningInTemporaryExecutor(cwd = import_node_process.default.cwd()) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isRunningInTemporaryExecutor
+  isTransientProcess
 });

package/dist/promises/_internal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Private internals for `promises/*` modules — the lazy
+ *   `node:timers/promises` accessor + the shared abort signal. Underscore
+ *   prefix excludes from public exports.
+ */
+export declare const abortSignal: AbortSignal;
+/**
+ * Get the timers/promises module. Uses lazy loading to avoid Webpack bundling
+ * issues.
+ *
+ * @private
+ *
+ * @returns The Node.js timers/promises module
+ */
+export declare function getTimers(): typeof import('node:timers/promises');

package/dist/promises/_internal.js

@@ -0,0 +1,41 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  abortSignal: () => abortSignal,
+  getTimers: () => getTimers
+});
+module.exports = __toCommonJS(internal_exports);
+var import_abort = require("../process/abort");
+const abortSignal = (0, import_abort.getAbortSignal)();
+let _timers;
+// @__NO_SIDE_EFFECTS__
+function getTimers() {
+  if (_timers === void 0) {
+    _timers = require("node:timers/promises");
+  }
+  return _timers;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  abortSignal,
+  getTimers
+});

package/dist/promises/iterate.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @file Concurrency-controlled async iteration helpers: `pEach`, `pEachChunk`,
+ *   `pFilter`, `pFilterChunk`. All four use `pRetry` internally so each item's
+ *   callback can be retried independently without affecting siblings. The chunk
+ *   vs. concurrency distinction:
+ *
+ *   - `pEach` / `pFilter` use a **concurrency limit**: split the input into
+ *     chunks of size `concurrency`, process each chunk in parallel, then move
+ *     on to the next chunk.
+ *   - `pEachChunk` / `pFilterChunk` operate on **pre-chunked input**: the caller
+ *     decides chunk boundaries (e.g., bulk-insert batch size, pagination page
+ *     size). Useful when chunk size != concurrency cap.
+ */
+import type { IterationOptions, RetryOptions } from './types';
+/**
+ * Execute an async function for each array element with concurrency control.
+ *
+ * Processes array items in parallel batches (chunks) with configurable
+ * concurrency. Each item's callback can be retried independently on failure.
+ * Similar to `Promise.all(array.map(fn))` but with controlled parallelism.
+ *
+ * @example
+ *   // Process items serially (concurrency: 1)
+ *   await pEach(urls, async url => {
+ *     await fetch(url)
+ *   })
+ *
+ * @example
+ *   // Process 5 items at a time
+ *   await pEach(
+ *     files,
+ *     async file => {
+ *       await processFile(file)
+ *     },
+ *     5,
+ *   )
+ *
+ * @example
+ *   // With retries and cancellation
+ *   const controller = new AbortController()
+ *   await pEach(
+ *     tasks,
+ *     async task => {
+ *       await executeTask(task)
+ *     },
+ *     {
+ *       concurrency: 3,
+ *       retries: 2,
+ *       signal: controller.signal,
+ *     },
+ *   )
+ *
+ * @template T - The type of array elements.
+ *
+ * @param array - The array to iterate over.
+ * @param callbackFn - Async function to execute for each item.
+ * @param options - Concurrency as number, or full iteration options, or
+ *   undefined.
+ *
+ * @returns Promise that resolves when all items are processed
+ */
+export declare function pEach<T>(array: T[], callbackFn: (item: T) => Promise<unknown>, options?: number | IterationOptions | undefined): Promise<void>;
+/**
+ * Process array in chunks with an async callback.
+ *
+ * Divides the array into fixed-size chunks and processes each chunk
+ * sequentially with the callback. Useful for batch operations like bulk
+ * database inserts or API calls with payload size limits.
+ *
+ * @example
+ *   // Insert records in batches of 100
+ *   await pEachChunk(
+ *     records,
+ *     async chunk => {
+ *       await db.batchInsert(chunk)
+ *     },
+ *     { chunkSize: 100 },
+ *   )
+ *
+ * @example
+ *   // Upload files in batches with retries
+ *   await pEachChunk(
+ *     files,
+ *     async batch => {
+ *       await uploadBatch(batch)
+ *     },
+ *     {
+ *       chunkSize: 50,
+ *       retries: 3,
+ *       baseDelayMs: 1000,
+ *     },
+ *   )
+ *
+ * @example
+ *   // Process with cancellation support
+ *   const controller = new AbortController()
+ *   await pEachChunk(
+ *     items,
+ *     async chunk => {
+ *       await processChunk(chunk)
+ *     },
+ *     {
+ *       chunkSize: 25,
+ *       signal: controller.signal,
+ *     },
+ *   )
+ *
+ * @template T - The type of array elements.
+ *
+ * @param array - The array to process in chunks.
+ * @param callbackFn - Async function to execute for each chunk.
+ * @param options - Chunk size and retry options.
+ *
+ * @returns Promise that resolves when all chunks are processed
+ */
+export declare function pEachChunk<T>(array: T[], callbackFn: (chunk: T[]) => Promise<unknown>, options?: (RetryOptions & {
+    chunkSize?: number | undefined;
+}) | undefined): Promise<void>;
+/**
+ * Filter an array asynchronously with concurrency control.
+ *
+ * Tests each element with an async predicate function, processing items in
+ * parallel batches. Returns a new array with only items that pass the test.
+ * Similar to `array.filter()` but for async predicates with controlled
+ * concurrency.
+ *
+ * @example
+ *   // Filter serially
+ *   const activeUsers = await pFilter(users, async user => {
+ *     return await isUserActive(user.id)
+ *   })
+ *
+ * @example
+ *   // Filter with concurrency
+ *   const validFiles = await pFilter(
+ *     filePaths,
+ *     async path => {
+ *       return existsSync(path)
+ *     },
+ *     10,
+ *   )
+ *
+ * @example
+ *   // With retries for flaky checks
+ *   const reachable = await pFilter(
+ *     endpoints,
+ *     async url => {
+ *       const response = await fetch(url)
+ *       return response.ok
+ *     },
+ *     {
+ *       concurrency: 5,
+ *       retries: 2,
+ *     },
+ *   )
+ *
+ * @template T - The type of array elements.
+ *
+ * @param array - The array to filter.
+ * @param callbackFn - Async predicate function returning true to keep item.
+ * @param options - Concurrency as number, or full iteration options, or
+ *   undefined.
+ *
+ * @returns Promise resolving to filtered array
+ */
+export declare function pFilter<T>(array: T[], callbackFn: (item: T) => Promise<boolean>, options?: number | IterationOptions | undefined): Promise<T[]>;
+/**
+ * Filter chunked arrays with an async predicate.
+ *
+ * Internal helper for `pFilter`. Processes pre-chunked arrays, applying the
+ * predicate to each element within each chunk with retry support.
+ *
+ * @example
+ *   const chunks = [
+ *     [1, 2],
+ *     [3, 4],
+ *     [5, 6],
+ *   ]
+ *   const filtered = await pFilterChunk(chunks, async n => n % 2 === 0)
+ *   // => [[2], [4], [6]]
+ *
+ * @template T - The type of array elements.
+ *
+ * @param chunks - Pre-chunked array (array of arrays)
+ * @param callbackFn - Async predicate function.
+ * @param options - Retry count as number, or full retry options, or undefined.
+ *
+ * @returns Promise resolving to array of filtered chunks
+ */
+export declare function pFilterChunk<T>(chunks: T[][], callbackFn: (value: T) => Promise<boolean>, options?: number | RetryOptions | undefined): Promise<T[][]>;