@socketsecurity/lib 6.0.6 → 6.0.8

package/dist/process/spawn/child.js

@@ -52,8 +52,8 @@ function spawn(cmd, args, options, extra) {
 	const { env, shell, stdio, stdioString = true } = spawnOptions;
 	const cwd = spawnOptions.cwd ? String(spawnOptions.cwd) : void 0;
 	let actualCmd = cmd;
-	if (!/* @__PURE__ */ require_paths_predicates.isPath(cmd)) {
-		const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	if (!require_paths_predicates.isPath(cmd)) {
+		const fs = require_node_fs.getNodeFs();
 		const cached = require_process_spawn__internal.spawnBinPathCache.get(cmd);
 		/* c8 ignore start */
 		if (cached) if (fs.existsSync(cached)) actualCmd = cached;
@@ -72,9 +72,12 @@ function spawn(cmd, args, options, extra) {
 	/* c8 ignore start - Windows-only cmd.exe extension stripping for
 	.cmd/.bat/.ps1 shell-true execution. Tested on Windows runners. */
 	if (node_process.default.platform === "win32" && shell && require_primordials_regexp.RegExpPrototypeTest(require_process_spawn__internal.windowsScriptExtRegExp, actualCmd)) {
-		if (!/* @__PURE__ */ require_paths_predicates.isPath(actualCmd)) actualCmd = (/* @__PURE__ */ require_node_path.getNodePath()).basename(actualCmd, (/* @__PURE__ */ require_node_path.getNodePath()).extname(actualCmd));
+		if (!require_paths_predicates.isPath(actualCmd)) {
+			const path = require_node_path.getNodePath();
+			actualCmd = path.basename(actualCmd, path.extname(actualCmd));
+		}
 	}
-	const shouldStopSpinner = !!spinnerInstance?.isSpinning && !/* @__PURE__ */ require_process_spawn_stdio.isStdioType(stdio, "ignore") && !/* @__PURE__ */ require_process_spawn_stdio.isStdioType(stdio, "pipe");
+	const shouldStopSpinner = !!spinnerInstance?.isSpinning && !require_process_spawn_stdio.isStdioType(stdio, "ignore") && !require_process_spawn_stdio.isStdioType(stdio, "pipe");
 	const shouldRestartSpinner = shouldStopSpinner;
 	if (shouldStopSpinner) spinnerInstance.stop();
 	const envToUse = env ? {
@@ -95,18 +98,18 @@ function spawn(cmd, args, options, extra) {
 		uid: spawnOptions.uid,
 		gid: spawnOptions.gid
 	};
-	const spawnPromise = (/* @__PURE__ */ require_process_spawn__internal.getNpmCliPromiseSpawn())(actualCmd, args ? [...args] : [], promiseSpawnOpts, extra);
+	const spawnPromise = require_process_spawn__internal.getNpmCliPromiseSpawn()(actualCmd, args ? [...args] : [], promiseSpawnOpts, extra);
 	/* c8 ignore stop */
 	const oldSpawnPromise = spawnPromise;
 	/* c8 ignore start */
 	let newSpawnPromise;
 	if (shouldStripAnsi && stdioString) newSpawnPromise = (async () => {
 		try {
-			const strippedResult = /* @__PURE__ */ require_process_spawn__internal.stripAnsiFromSpawnResult(await spawnPromise);
+			const strippedResult = require_process_spawn__internal.stripAnsiFromSpawnResult(await spawnPromise);
 			if ("code" in strippedResult) strippedResult.exitCode = strippedResult.code;
 			return strippedResult;
 		} catch (error) {
-			throw /* @__PURE__ */ require_process_spawn_errors.enhanceSpawnError(/* @__PURE__ */ require_process_spawn__internal.stripAnsiFromSpawnResult(error));
+			throw require_process_spawn_errors.enhanceSpawnError(require_process_spawn__internal.stripAnsiFromSpawnResult(error));
 		}
 	})();
 	else newSpawnPromise = (async () => {
@@ -119,7 +122,7 @@ function spawn(cmd, args, options, extra) {
 			}
 			return result;
 		} catch (error) {
-			throw /* @__PURE__ */ require_process_spawn_errors.enhanceSpawnError(error);
+			throw require_process_spawn_errors.enhanceSpawnError(error);
 		}
 	})();
 	/* c8 ignore stop */
@@ -139,18 +142,21 @@ function spawn(cmd, args, options, extra) {
 }
 function spawnSync(cmd, args, options) {
 	let actualCmd = cmd;
-	if (!/* @__PURE__ */ require_paths_predicates.isPath(cmd)) {
+	if (!require_paths_predicates.isPath(cmd)) {
 		const resolved = require_bin_which.whichSync(cmd, {
-			cwd: /* @__PURE__ */ require_objects_inspect.getOwn(options, "cwd"),
+			cwd: require_objects_inspect.getOwn(options, "cwd"),
 			nothrow: true
 		});
 		if (resolved && typeof resolved === "string") actualCmd = resolved;
 	}
-	const shell = /* @__PURE__ */ require_objects_inspect.getOwn(options, "shell");
+	const shell = require_objects_inspect.getOwn(options, "shell");
 	/* c8 ignore start - Windows-only cmd.exe extension stripping for
 	.cmd/.bat/.ps1 shell-true execution. Tested on Windows runners. */
 	if (node_process.default.platform === "win32" && shell && require_primordials_regexp.RegExpPrototypeTest(require_process_spawn__internal.windowsScriptExtRegExp, actualCmd)) {
-		if (!/* @__PURE__ */ require_paths_predicates.isPath(actualCmd)) actualCmd = (/* @__PURE__ */ require_node_path.getNodePath()).basename(actualCmd, (/* @__PURE__ */ require_node_path.getNodePath()).extname(actualCmd));
+		if (!require_paths_predicates.isPath(actualCmd)) {
+			const path = require_node_path.getNodePath();
+			actualCmd = path.basename(actualCmd, path.extname(actualCmd));
+		}
 	}
 	/* c8 ignore stop */
 	const { stripAnsi: shouldStripAnsi = true, ...rawSpawnOptions } = {
@@ -163,13 +169,13 @@ function spawnSync(cmd, args, options) {
 		...rawSpawnOptions
 	};
 	const stdioString = spawnOptions.encoding !== "buffer";
-	const result = (/* @__PURE__ */ require_node_child_process.getNodeChildProcess()).spawnSync(actualCmd, args, spawnOptions);
+	const result = require_node_child_process.getNodeChildProcess().spawnSync(actualCmd, args, spawnOptions);
 	if (stdioString) {
 		const { stderr, stdout } = result;
 		if (stdout) result.stdout = stdout.toString().trim();
 		if (stderr) result.stderr = stderr.toString().trim();
 	}
-	return shouldStripAnsi && stdioString ? /* @__PURE__ */ require_process_spawn__internal.stripAnsiFromSpawnResult(result) : result;
+	return shouldStripAnsi && stdioString ? require_process_spawn__internal.stripAnsiFromSpawnResult(result) : result;
 }
 
 //#endregion

package/dist/process/spawn/errors.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_primordials_error = require('../../primordials/error.js');
 const require_primordials_object = require('../../primordials/object.js');
-const require_primordials_reflect = require('../../primordials/reflect.js');
 const require_objects_predicates = require('../../objects/predicates.js');
+const require_primordials_reflect = require('../../primordials/reflect.js');
 const require_process_spawn__internal = require('./_internal.js');
 let src_external_pony_cause = require("../../external/pony-cause");
 
@@ -34,10 +34,9 @@ let src_external_pony_cause = require("../../external/pony-cause");
 *   }
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function enhanceSpawnError(error) {
 	if (error === null || typeof error !== "object") return error;
-	if (!/* @__PURE__ */ isSpawnError(error)) return error;
+	if (!isSpawnError(error)) return error;
 	const err = error;
 	const { args, cmd, code, signal, stderr } = err;
 	const stderrText = typeof stderr === "string" ? stderr : stderr?.toString() ?? "";
@@ -109,11 +108,10 @@ function enhanceSpawnError(error) {
 *
 * @returns {boolean} `true` if the value has spawn error properties
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isSpawnError(value) {
 	if (value === null || typeof value !== "object") return false;
 	const err = value;
-	return /* @__PURE__ */ require_objects_predicates.hasOwn(err, "code") && typeof err["code"] !== "undefined" || /* @__PURE__ */ require_objects_predicates.hasOwn(err, "errno") && typeof err["errno"] !== "undefined" || /* @__PURE__ */ require_objects_predicates.hasOwn(err, "syscall") && typeof err["syscall"] === "string";
+	return require_objects_predicates.hasOwn(err, "code") && typeof err["code"] !== "undefined" || require_objects_predicates.hasOwn(err, "errno") && typeof err["errno"] !== "undefined" || require_objects_predicates.hasOwn(err, "syscall") && typeof err["syscall"] === "string";
 }
 
 //#endregion

package/dist/process/spawn/kill-tree.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @file Cross-platform process-tree termination. A spawned package manager,
+ *   proxy, or build tool spawns its own children; killing only the direct child
+ *   orphans them (they reparent to init on POSIX and run forever). These
+ *   helpers kill the whole tree:
+ *
+ *   - POSIX: when the child was spawned `detached: true` it leads its own process
+ *     group, so `process.kill(-pid, signal)` signals every member at once. Pass
+ *     `{ detached: true }` (the default) for that behavior; pass `{ detached:
+ *     false }` to signal only the single pid.
+ *   - Windows: there are no POSIX process groups, so we shell out to `taskkill /T
+ *     /F /pid <pid>`, which walks and terminates the descendant tree. The
+ *     `signal` argument is ignored on Windows (taskkill is always a forceful
+ *     terminate). Both helpers are best-effort and never throw: a process that
+ *     already exited (ESRCH) or that we lack permission to signal (EPERM) is
+ *     treated as "nothing to do", because a cleanup kill must not mask the
+ *     caller's original control flow. `killProcessTree` returns `true` if a
+ *     kill was attempted, `false` if the pid was invalid or already gone.
+ */
+import type { ChildProcess } from 'node:child_process';
+export interface KillProcessTreeOptions {
+    /**
+     * POSIX only. When `true` (default), signal the child's entire process group
+     * via the negative pid — requires the child to have been spawned `detached:
+     * true`. When `false`, signal only the single pid. Ignored on Windows
+     * (taskkill always kills the tree).
+     */
+    detached?: boolean | undefined;
+    /**
+     * POSIX signal to send (default `'SIGTERM'`). Ignored on Windows, where
+     * taskkill performs a forceful terminate.
+     */
+    signal?: NodeJS.Signals | number | undefined;
+}
+/**
+ * Probe whether a pid is still alive. Uses signal 0, which performs the
+ * permission/existence check without delivering a signal. Returns `false` for
+ * pid <= 1 (kernel/init) so callers don't mistake those for a live child.
+ */
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Kill a process and its descendants. See the file header for the
+ * POSIX-process-group vs. Windows-taskkill strategy. Best-effort: never throws.
+ * Returns `true` if a kill was attempted, `false` if the pid was invalid or the
+ * process had already exited.
+ */
+export declare function killProcessTree(target: number | ChildProcess, options?: KillProcessTreeOptions | undefined): boolean;
+/**
+ * Resolve a pid from either a raw number or a spawned ChildProcess. Returns
+ * `undefined` for a missing/invalid pid or a process that already exited.
+ * Exported for direct testing.
+ */
+export declare function resolvePid(target: number | ChildProcess): number | undefined;

package/dist/process/spawn/kill-tree.js

@@ -0,0 +1,85 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_platform = require('../../constants/platform.js');
+const require_node_child_process = require('../../node/child-process.js');
+
+//#region src/process/spawn/kill-tree.ts
+/**
+* @file Cross-platform process-tree termination. A spawned package manager,
+*   proxy, or build tool spawns its own children; killing only the direct child
+*   orphans them (they reparent to init on POSIX and run forever). These
+*   helpers kill the whole tree:
+*
+*   - POSIX: when the child was spawned `detached: true` it leads its own process
+*     group, so `process.kill(-pid, signal)` signals every member at once. Pass
+*     `{ detached: true }` (the default) for that behavior; pass `{ detached:
+*     false }` to signal only the single pid.
+*   - Windows: there are no POSIX process groups, so we shell out to `taskkill /T
+*     /F /pid <pid>`, which walks and terminates the descendant tree. The
+*     `signal` argument is ignored on Windows (taskkill is always a forceful
+*     terminate). Both helpers are best-effort and never throw: a process that
+*     already exited (ESRCH) or that we lack permission to signal (EPERM) is
+*     treated as "nothing to do", because a cleanup kill must not mask the
+*     caller's original control flow. `killProcessTree` returns `true` if a
+*     kill was attempted, `false` if the pid was invalid or already gone.
+*/
+/**
+* Probe whether a pid is still alive. Uses signal 0, which performs the
+* permission/existence check without delivering a signal. Returns `false` for
+* pid <= 1 (kernel/init) so callers don't mistake those for a live child.
+*/
+function isProcessAlive(pid) {
+	if (!Number.isInteger(pid) || pid <= 1) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Kill a process and its descendants. See the file header for the
+* POSIX-process-group vs. Windows-taskkill strategy. Best-effort: never throws.
+* Returns `true` if a kill was attempted, `false` if the pid was invalid or the
+* process had already exited.
+*/
+function killProcessTree(target, options) {
+	const pid = resolvePid(target);
+	if (pid === void 0) return false;
+	const opts = {
+		__proto__: null,
+		...options
+	};
+	const detached = opts.detached !== false;
+	const signal = opts.signal ?? "SIGTERM";
+	try {
+		if (require_constants_platform.WIN32) return require_node_child_process.getNodeChildProcess().spawnSync("taskkill", [
+			"/T",
+			"/F",
+			"/pid",
+			String(pid)
+		], { stdio: "ignore" }).status === 0;
+		if (detached) process.kill(-pid, signal);
+		else process.kill(pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve a pid from either a raw number or a spawned ChildProcess. Returns
+* `undefined` for a missing/invalid pid or a process that already exited.
+* Exported for direct testing.
+*/
+function resolvePid(target) {
+	if (typeof target === "number") return Number.isInteger(target) && target > 1 ? target : void 0;
+	if (target.exitCode !== null || target.signalCode !== null) return;
+	const { pid } = target;
+	return typeof pid === "number" && pid > 1 ? pid : void 0;
+}
+
+//#endregion
+exports.isProcessAlive = isProcessAlive;
+exports.killProcessTree = killProcessTree;
+exports.resolvePid = resolvePid;

package/dist/process/spawn/stdio.js

@@ -39,7 +39,6 @@ const require_arrays_predicates = require('../../arrays/predicates.js');
 *
 * @returns {boolean} `true` if stdio matches the type or is valid
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isStdioType(stdio, type) {
 	if (arguments.length === 1) return typeof stdio === "string" && [
 		"pipe",

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

@@ -218,7 +218,7 @@ export interface ChildProcess extends EventEmitter {
     stdin: NodeJS.WritableStream | null;
     stdout: NodeJS.ReadableStream | null;
     stderr: NodeJS.ReadableStream | null;
-    readonly channel?: unknown;
+    readonly channel?: unknown | undefined;
     readonly stdio: [
         NodeJS.WritableStream | null,
         NodeJS.ReadableStream | null,
@@ -285,8 +285,8 @@ export interface WritableStreamType {
  */
 export type SpawnOptions = Remap<NodeSpawnOptions & {
     spinner?: SpinnerInstance | undefined;
-    stdioString?: boolean;
-    stripAnsi?: boolean;
+    stdioString?: boolean | undefined;
+    stripAnsi?: boolean | undefined;
 }>;
 export type SpawnResult<T = string | Buffer> = PromiseSpawnResult<T>;
 /**
@@ -320,6 +320,6 @@ export type SpawnStdioResult = {
  * field is excluded (not applicable for synchronous execution).
  */
 export type SpawnSyncOptions = Remap<NodeSpawnSyncOptions & {
-    stdioString?: boolean;
-    stripAnsi?: boolean;
+    stdioString?: boolean | undefined;
+    stripAnsi?: boolean | undefined;
 }>;

package/dist/process/transient.js

@@ -32,9 +32,9 @@ node_process = require_runtime.__toESM(node_process);
 function isTransientProcess(cwd = node_process.default.cwd()) {
 	const userAgent = node_process.default.env["npm_config_user_agent"];
 	if (userAgent?.includes("exec") || userAgent?.includes("npx") || userAgent?.includes("dlx")) return true;
-	const normalizedCwd = /* @__PURE__ */ require_paths_normalize.normalizePath(cwd);
+	const normalizedCwd = require_paths_normalize.normalizePath(cwd);
 	const npmCache = node_process.default.env["npm_config_cache"];
-	if (npmCache && normalizedCwd.includes(/* @__PURE__ */ require_paths_normalize.normalizePath(npmCache))) return true;
+	if (npmCache && normalizedCwd.includes(require_paths_normalize.normalizePath(npmCache))) return true;
 	const tempPatterns = [
 		"_npx",
 		".pnpm-store",

package/dist/promises/_internal.d.ts

@@ -3,6 +3,7 @@
  *   `node:timers/promises` accessor + the shared abort signal. Underscore
  *   prefix excludes from public exports.
  */
+import type timersPromises from 'node:timers/promises';
 export declare const abortSignal: AbortSignal;
 /**
  * Get the timers/promises module. Lazy `require` (not a top-level import) to
@@ -18,4 +19,4 @@ export declare const abortSignal: AbortSignal;
  *
  * @returns The Node.js timers/promises module
  */
-export declare function getTimers(): typeof import('node:timers/promises');
+export declare function getTimers(): typeof timersPromises;

package/dist/promises/_internal.js

@@ -1,14 +1,10 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_runtime = require('../constants/runtime.js');
 const require_process_abort = require('../process/abort.js');
 
 //#region src/promises/_internal.ts
-/**
-* @file Private internals for `promises/*` modules — the lazy
-*   `node:timers/promises` accessor + the shared abort signal. Underscore
-*   prefix excludes from public exports.
-*/
 const abortSignal = require_process_abort.getAbortSignal();
 /**
 * Get the timers/promises module. Lazy `require` (not a top-level import) to
@@ -24,8 +20,8 @@ const abortSignal = require_process_abort.getAbortSignal();
 *
 * @returns The Node.js timers/promises module
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getTimers() {
+	if (!require_constants_runtime.IS_NODE) return;
 	return require("node:timers/promises");
 }
 

package/dist/promises/iterate.js

@@ -67,13 +67,12 @@ const require_arrays_chunk = require('../arrays/chunk.js');
 *
 * @returns Promise that resolves when all items are processed
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function pEach(array, callbackFn, options) {
-	const { concurrency, retries, signal } = /* @__PURE__ */ require_promises_options.normalizeIterationOptions(options);
-	const chunks = /* @__PURE__ */ require_arrays_chunk.arrayChunk(array, concurrency);
+	const { concurrency, retries, signal } = require_promises_options.normalizeIterationOptions(options);
+	const chunks = require_arrays_chunk.arrayChunk(array, concurrency);
 	for (const chunk of chunks) {
 		if (signal?.aborted) return;
-		await require_primordials_promise.PromiseAllSettled(chunk.map((item) => /* @__PURE__ */ require_promises_retry.pRetry((...args) => callbackFn(args[0]), {
+		await require_primordials_promise.PromiseAllSettled(chunk.map((item) => require_promises_retry.pRetry((...args) => callbackFn(args[0]), {
 			...retries,
 			args: [item],
 			signal
@@ -133,15 +132,14 @@ async function pEach(array, callbackFn, options) {
 *
 * @returns Promise that resolves when all chunks are processed
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function pEachChunk(array, callbackFn, options) {
 	const { chunkSize = 100, ...retryOpts } = options || {};
-	const chunks = /* @__PURE__ */ require_arrays_chunk.arrayChunk(array, chunkSize);
-	const normalizedRetryOpts = /* @__PURE__ */ require_promises_options.normalizeRetryOptions(retryOpts);
+	const chunks = require_arrays_chunk.arrayChunk(array, chunkSize);
+	const normalizedRetryOpts = require_promises_options.normalizeRetryOptions(retryOpts);
 	const { signal } = normalizedRetryOpts;
 	for (const chunk of chunks) {
 		if (signal?.aborted) return;
-		await /* @__PURE__ */ require_promises_retry.pRetry((...args) => callbackFn(args[0]), {
+		await require_promises_retry.pRetry((...args) => callbackFn(args[0]), {
 			...normalizedRetryOpts,
 			args: [chunk]
 		});
@@ -194,10 +192,9 @@ async function pEachChunk(array, callbackFn, options) {
 *
 * @returns Promise resolving to filtered array
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function pFilter(array, callbackFn, options) {
-	const iterOpts = /* @__PURE__ */ require_promises_options.normalizeIterationOptions(options);
-	return (await /* @__PURE__ */ pFilterChunk(/* @__PURE__ */ require_arrays_chunk.arrayChunk(array, iterOpts.concurrency), callbackFn, iterOpts.retries)).flat();
+	const iterOpts = require_promises_options.normalizeIterationOptions(options);
+	return (await pFilterChunk(require_arrays_chunk.arrayChunk(array, iterOpts.concurrency), callbackFn, iterOpts.retries)).flat();
 }
 /**
 * Filter chunked arrays with an async predicate.
@@ -222,20 +219,19 @@ async function pFilter(array, callbackFn, options) {
 *
 * @returns Promise resolving to array of filtered chunks
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function pFilterChunk(chunks, callbackFn, options) {
-	const retryOpts = /* @__PURE__ */ require_promises_options.normalizeRetryOptions(options);
+	const retryOpts = require_promises_options.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 require_primordials_promise.PromiseAllSettled(chunk.map((value) => /* @__PURE__ */ require_promises_retry.pRetry((...args) => callbackFn(args[0]), {
+		const predicateResults = (await require_primordials_promise.PromiseAllSettled(chunk.map((value) => require_promises_retry.pRetry((...args) => callbackFn(args[0]), {
 			...retryOpts,
 			args: [value]
 		})))).map((r) => r.status === "fulfilled" ? r.value : false);
-		filteredChunks[i] = chunk.filter((_v, i) => predicateResults[i]);
+		filteredChunks[i] = chunk.filter((_value, index) => predicateResults[index]);
 	}
 	return filteredChunks;
 }

package/dist/promises/options.js

@@ -33,7 +33,6 @@ const require_promises__internal = require('./_internal.js');
 *
 * @returns Normalized options with concurrency, retries, and signal
 */
-/*@__NO_SIDE_EFFECTS__*/
 function normalizeIterationOptions(options) {
 	const { concurrency = 1, retries, signal = require_promises__internal.abortSignal } = {
 		__proto__: null,
@@ -42,9 +41,9 @@ function normalizeIterationOptions(options) {
 	return {
 		__proto__: null,
 		concurrency: require_primordials_math.MathMax(1, concurrency),
-		retries: /* @__PURE__ */ normalizeRetryOptions({
+		retries: normalizeRetryOptions({
 			signal,
-			.../* @__PURE__ */ resolveRetryOptions(retries)
+			...resolveRetryOptions(retries)
 		}),
 		signal
 	};
@@ -70,9 +69,8 @@ function normalizeIterationOptions(options) {
 *
 * @returns Normalized retry options with all properties set
 */
-/*@__NO_SIDE_EFFECTS__*/
 function normalizeRetryOptions(options) {
-	const { args = [], backoffFactor = 2, baseDelayMs = 200, jitter = true, maxDelayMs = 1e4, onRetry, onRetryCancelOnFalse = false, onRetryRethrow = false, retries = 0, signal = require_promises__internal.abortSignal } = /* @__PURE__ */ resolveRetryOptions(options);
+	const { args = [], backoffFactor = 2, baseDelayMs = 200, jitter = true, maxDelayMs = 1e4, onRetry, onRetryCancelOnFalse = false, onRetryRethrow = false, retries = 0, signal = require_promises__internal.abortSignal } = resolveRetryOptions(options);
 	return {
 		args,
 		backoffFactor,
@@ -105,7 +103,6 @@ function normalizeRetryOptions(options) {
 *
 * @returns Resolved retry options with defaults for basic properties
 */
-/*@__NO_SIDE_EFFECTS__*/
 function resolveRetryOptions(options) {
 	const defaults = {
 		__proto__: null,

package/dist/promises/retry.js

@@ -110,12 +110,11 @@ const require_promises_options = require('./options.js');
 *
 * @throws {Error} The last error if all retry attempts fail
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function pRetry(callbackFn, options) {
-	const { args, backoffFactor, baseDelayMs, jitter, maxDelayMs, onRetry, onRetryCancelOnFalse, onRetryRethrow, retries, signal } = /* @__PURE__ */ require_promises_options.normalizeRetryOptions(options);
+	const { args, backoffFactor, baseDelayMs, jitter, maxDelayMs, onRetry, onRetryCancelOnFalse, onRetryRethrow, retries, signal } = require_promises_options.normalizeRetryOptions(options);
 	if (signal?.aborted) return;
 	if (retries === 0) return await callbackFn(...args || [], { signal });
-	const timers = /* @__PURE__ */ require_promises__internal.getTimers();
+	const timers = require_promises__internal.getTimers();
 	let attempts = retries;
 	let delay = baseDelayMs;
 	let error = void 0;
@@ -136,8 +135,8 @@ async function pRetry(callbackFn, options) {
 				const result = onRetry(retries - attempts, e, waitTime);
 				if (result === false && onRetryCancelOnFalse) break;
 				if (typeof result === "number" && result >= 0) waitTime = require_primordials_math.MathMin(result, maxDelayMs);
-			} catch (e) {
-				if (onRetryRethrow) throw e;
+			} catch (onRetryError) {
+				if (onRetryRethrow) throw onRetryError;
 			}
 			/* c8 ignore stop */
 			try {

package/dist/promises/timers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file Browser-compatible promise-based timer helpers. Uses
+ *   `globalThis.setTimeout` / `globalThis.queueMicrotask` directly so every
+ *   export works in browsers, Node.js, Deno, Bun, and Web Workers without
+ *   importing `node:timers/promises`. In Node.js test environments with
+ *   `vi.useFakeTimers()` / `clock.install()`, vitest/sinon replace
+ *   `globalThis.setTimeout` before this module loads, so fake timers advance
+ *   `sleep()` correctly — no special wiring needed. For Node-only
+ *   abort-signal-aware delays see `promises/_internal.ts`.
+ */
+/**
+ * Pause for `ms` milliseconds. Resolves with `undefined` when the timer fires.
+ * Negative values are clamped to 0.
+ *
+ * @example
+ *   await sleep(100)
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Yield to the event loop once. Resolves after the current call stack and any
+ * already-queued microtasks have completed — equivalent to `setTimeout(fn, 0)`
+ * as described in
+ * https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout#late_timeouts.
+ * Useful for flushing microtask queues in tests or giving the browser a repaint
+ * opportunity between heavy operations.
+ *
+ * @example
+ *   await yieldToEventLoop()
+ */
+export declare function yieldToEventLoop(): Promise<void>;

package/dist/promises/timers.js

@@ -0,0 +1,48 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_promise = require('../primordials/promise.js');
+
+//#region src/promises/timers.ts
+/**
+* @file Browser-compatible promise-based timer helpers. Uses
+*   `globalThis.setTimeout` / `globalThis.queueMicrotask` directly so every
+*   export works in browsers, Node.js, Deno, Bun, and Web Workers without
+*   importing `node:timers/promises`. In Node.js test environments with
+*   `vi.useFakeTimers()` / `clock.install()`, vitest/sinon replace
+*   `globalThis.setTimeout` before this module loads, so fake timers advance
+*   `sleep()` correctly — no special wiring needed. For Node-only
+*   abort-signal-aware delays see `promises/_internal.ts`.
+*/
+/**
+* Pause for `ms` milliseconds. Resolves with `undefined` when the timer fires.
+* Negative values are clamped to 0.
+*
+* @example
+*   await sleep(100)
+*/
+function sleep(ms) {
+	return new require_primordials_promise.PromiseCtor((resolve) => {
+		setTimeout(resolve, ms > 0 ? ms : 0);
+	});
+}
+/**
+* Yield to the event loop once. Resolves after the current call stack and any
+* already-queued microtasks have completed — equivalent to `setTimeout(fn, 0)`
+* as described in
+* https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout#late_timeouts.
+* Useful for flushing microtask queues in tests or giving the browser a repaint
+* opportunity between heavy operations.
+*
+* @example
+*   await yieldToEventLoop()
+*/
+function yieldToEventLoop() {
+	return new require_primordials_promise.PromiseCtor((resolve) => {
+		setTimeout(resolve, 0);
+	});
+}
+
+//#endregion
+exports.sleep = sleep;
+exports.yieldToEventLoop = yieldToEventLoop;

package/dist/regexps/spec.js

@@ -1,8 +1,8 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_primordials_string = require('../primordials/string.js');
 const require_primordials_map_set = require('../primordials/map-set.js');
+const require_primordials_string = require('../primordials/string.js');
 const require_regexps_hex = require('./hex.js');
 
 //#region src/regexps/spec.ts

package/dist/releases/github-archives.d.ts

@@ -34,10 +34,10 @@ import type { AssetPattern, RepoConfig } from './github-types';
  * @returns Path to the extraction directory
  */
 export declare function downloadAndExtractArchive(tag: string, assetPattern: string | AssetPattern, outputDir: string, repoConfig: RepoConfig, options?: {
-    cleanup?: boolean;
-    format?: ArchiveFormat;
-    quiet?: boolean;
-    strip?: number;
+    cleanup?: boolean | undefined;
+    format?: ArchiveFormat | undefined;
+    quiet?: boolean | undefined;
+    strip?: number | undefined;
 }): Promise<string>;
 /**
  * Download and extract a zip file from a GitHub release. Automatically handles
@@ -66,6 +66,6 @@ export declare function downloadAndExtractArchive(tag: string, assetPattern: str
  * @returns Path to the extraction directory
  */
 export declare function downloadAndExtractZip(tag: string, assetPattern: string | AssetPattern, outputDir: string, repoConfig: RepoConfig, options?: {
-    cleanup?: boolean;
-    quiet?: boolean;
+    cleanup?: boolean | undefined;
+    quiet?: boolean | undefined;
 }): Promise<string>;

package/dist/releases/github-archives.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_primordials_error = require('../primordials/error.js');
 const require_node_path = require('../node/path.js');
 const require_logger_default = require('../logger/default.js');
-const require_archives_detect = require('../archives/detect.js');
 const require_fs_safe = require('../fs/safe.js');
+const require_archives_detect = require('../archives/detect.js');
 const require_archives_extract = require('../archives/extract.js');
 const require_releases_github_downloads = require('./github-downloads.js');
 
@@ -46,7 +46,7 @@ const logger = require_logger_default.getDefaultLogger();
 */
 async function downloadAndExtractArchive(tag, assetPattern, outputDir, repoConfig, options = { __proto__: null }) {
 	const { cleanup = true, format, quiet = false, strip } = options;
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const path = require_node_path.getNodePath();
 	await require_fs_safe.safeMkdir(outputDir);
 	let ext = ".archive";
 	if (format) ext = format === "tar.gz" ? ".tar.gz" : `.${format}`;
@@ -104,7 +104,7 @@ async function downloadAndExtractArchive(tag, assetPattern, outputDir, repoConfi
 */
 async function downloadAndExtractZip(tag, assetPattern, outputDir, repoConfig, options = { __proto__: null }) {
 	const { cleanup = true, quiet = false } = options;
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const path = require_node_path.getNodePath();
 	await require_fs_safe.safeMkdir(outputDir);
 	const zipPath = path.join(outputDir, "__temp_download__.zip");
 	if (!quiet) logger.info(`Downloading zip asset from release ${tag}...`);