@socketsecurity/lib 6.0.5 → 6.0.7

package/dist/primordials/number.js

@@ -11,7 +11,7 @@ const require_smol_primordial = require('../smol/primordial.js');
 *   static `parseFloat` / `parseInt` use the FastOneByteString-typed bindings
 *   for ASCII inputs and fall back to stock `Number.parse*` otherwise.
 */
-const _smolPrimordial = /* @__PURE__ */ require_smol_primordial.getSmolPrimordial();
+const smolPrimordial = require_smol_primordial.getSmolPrimordial();
 const NumberCtor = Number;
 const NumberEPSILON = Number.EPSILON;
 const NumberMAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
@@ -20,14 +20,14 @@ const NumberMIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
 const NumberMIN_VALUE = Number.MIN_VALUE;
 const NumberNEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;
 const NumberPOSITIVE_INFINITY = Number.POSITIVE_INFINITY;
-const NumberIsFinite = _smolPrimordial?.numberIsFinite ?? Number.isFinite;
-const NumberIsInteger = _smolPrimordial?.numberIsInteger ?? Number.isInteger;
-const NumberIsNaN = _smolPrimordial?.numberIsNaN ?? Number.isNaN;
-const NumberIsSafeInteger = _smolPrimordial?.numberIsSafeInteger ?? Number.isSafeInteger;
-const NumberParseFloat = _smolPrimordial?.numberParseFloat ?? Number.parseFloat;
-const _smolParseInt10 = _smolPrimordial?.numberParseInt10;
-/* c8 ignore start */
-const NumberParseInt = _smolParseInt10 ? (s, radix) => radix === void 0 || radix === 10 ? _smolParseInt10(s) : Number.parseInt(s, radix) : Number.parseInt;
+const NumberIsFinite = smolPrimordial?.numberIsFinite ?? Number.isFinite;
+const NumberIsInteger = smolPrimordial?.numberIsInteger ?? Number.isInteger;
+const NumberIsNaN = smolPrimordial?.numberIsNaN ?? Number.isNaN;
+const NumberIsSafeInteger = smolPrimordial?.numberIsSafeInteger ?? Number.isSafeInteger;
+const NumberParseFloat = smolPrimordial?.numberParseFloat ?? Number.parseFloat;
+const smolParseInt10 = smolPrimordial?.numberParseInt10;
+/* c8 ignore start - smol fast-path branch only reachable on socket-btm smol Node binary */
+const NumberParseInt = smolParseInt10 ? (s, radix) => radix === void 0 || radix === 10 ? smolParseInt10(s) : Number.parseInt(s, radix) : Number.parseInt;
 /* c8 ignore stop */
 const NumberPrototypeToExponential = require_primordials_uncurry.uncurryThis(Number.prototype.toExponential);
 const NumberPrototypeToFixed = require_primordials_uncurry.uncurryThis(Number.prototype.toFixed);

package/dist/primordials/object.js

@@ -40,11 +40,11 @@ const ObjectPrototypeIsPrototypeOf = require_primordials_uncurry.uncurryThis(Obj
 const ObjectPrototypePropertyIsEnumerable = require_primordials_uncurry.uncurryThis(Object.prototype.propertyIsEnumerable);
 const ObjectPrototypeToString = require_primordials_uncurry.uncurryThis(Object.prototype.toString);
 const ObjectPrototypeValueOf = require_primordials_uncurry.uncurryThis(Object.prototype.valueOf);
-const _objectProto = Object.prototype;
-const ObjectPrototypeDefineGetter = require_primordials_uncurry.uncurryThis(_objectProto.__defineGetter__);
-const ObjectPrototypeDefineSetter = require_primordials_uncurry.uncurryThis(_objectProto.__defineSetter__);
-const ObjectPrototypeLookupGetter = require_primordials_uncurry.uncurryThis(_objectProto.__lookupGetter__);
-const ObjectPrototypeLookupSetter = require_primordials_uncurry.uncurryThis(_objectProto.__lookupSetter__);
+const objectProto = Object.prototype;
+const ObjectPrototypeDefineGetter = require_primordials_uncurry.uncurryThis(objectProto.__defineGetter__);
+const ObjectPrototypeDefineSetter = require_primordials_uncurry.uncurryThis(objectProto.__defineSetter__);
+const ObjectPrototypeLookupGetter = require_primordials_uncurry.uncurryThis(objectProto.__lookupGetter__);
+const ObjectPrototypeLookupSetter = require_primordials_uncurry.uncurryThis(objectProto.__lookupSetter__);
 
 //#endregion
 exports.ObjectAssign = ObjectAssign;

package/dist/primordials/string.d.ts

@@ -50,8 +50,8 @@ export declare const StringPrototypeNormalize: (self: unknown, form?: string | u
 export declare const StringPrototypePadEnd: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
 export declare const StringPrototypePadStart: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
 export declare const StringPrototypeRepeat: (self: unknown, count: number) => string;
-export declare const StringPrototypeReplace: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)) => string;
-export declare const StringPrototypeReplaceAll: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)) => string;
+export declare const StringPrototypeReplace: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: unknown[]) => string)) => string;
+export declare const StringPrototypeReplaceAll: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: unknown[]) => string)) => string;
 export declare const StringPrototypeSearch: (self: unknown, searcher: {
     [Symbol.search](string: string): number;
 }) => number;

package/dist/primordials/string.js

@@ -34,17 +34,17 @@ const require_smol_primordial = require('../smol/primordial.js');
 *   `src/socketsecurity/primordial/primordial_binding.cc:41-72` for the
 *   canonical design statement.
 */
-const _smolPrimordial = /* @__PURE__ */ require_smol_primordial.getSmolPrimordial();
+const smolPrimordial = require_smol_primordial.getSmolPrimordial();
 const StringCtor = String;
 const StringFromCharCode = String.fromCharCode;
 const StringFromCodePoint = String.fromCodePoint;
 const StringRaw = String.raw;
 const StringPrototypeAt = require_primordials_uncurry.uncurryThis(String.prototype.at);
 const StringPrototypeCharAt = require_primordials_uncurry.uncurryThis(String.prototype.charAt);
-const _smolCharCodeAt = _smolPrimordial?.stringCharCodeAt;
-/* c8 ignore start */
-const StringPrototypeCharCodeAt = _smolCharCodeAt ? (s, i) => {
-	const code = _smolCharCodeAt(s, i);
+const smolCharCodeAt = smolPrimordial?.stringCharCodeAt;
+/* c8 ignore start - smol Node fast path unreachable on stock Node test runner */
+const StringPrototypeCharCodeAt = smolCharCodeAt ? (s, i) => {
+	const code = smolCharCodeAt(s, i);
 	return code === -1 ? NaN : code;
 } : require_primordials_uncurry.uncurryThis(String.prototype.charCodeAt);
 /* c8 ignore stop */
@@ -53,7 +53,7 @@ const StringPrototypeConcat = require_primordials_uncurry.uncurryThis(String.pro
 const StringPrototypeEndsWith = require_primordials_uncurry.uncurryThis(String.prototype.endsWith);
 const StringPrototypeIncludes = require_primordials_uncurry.uncurryThis(String.prototype.includes);
 const StringPrototypeIndexOf = require_primordials_uncurry.uncurryThis(String.prototype.indexOf);
-const StringPrototypeIsWellFormed = _smolPrimordial?.stringIsWellFormed ?? require_primordials_uncurry.uncurryThis(String.prototype.isWellFormed);
+const StringPrototypeIsWellFormed = smolPrimordial?.stringIsWellFormed ?? require_primordials_uncurry.uncurryThis(String.prototype.isWellFormed);
 const StringPrototypeLastIndexOf = require_primordials_uncurry.uncurryThis(String.prototype.lastIndexOf);
 const StringPrototypeLocaleCompare = require_primordials_uncurry.uncurryThis(String.prototype.localeCompare);
 const StringPrototypeMatch = require_primordials_uncurry.uncurryThis(String.prototype.match);

package/dist/primordials/symbol.js

@@ -29,10 +29,10 @@ const SymbolSplit = Symbol.split;
 const SymbolToPrimitive = Symbol.toPrimitive;
 const SymbolToStringTag = Symbol.toStringTag;
 const SymbolUnscopables = Symbol.unscopables;
-const _symbolDescriptionGetter = Symbol.prototype.__lookupGetter__("description");
+const symbolDescriptionGetter = Symbol.prototype.__lookupGetter__("description");
 function SymbolPrototypeDescription(self) {
-	/* c8 ignore start */
-	return _symbolDescriptionGetter ? _symbolDescriptionGetter.call(self) : self.description;
+	/* c8 ignore start - description getter is always present in modern V8; the fallback branch is unreachable */
+	return symbolDescriptionGetter ? symbolDescriptionGetter.call(self) : self.description;
 	/* c8 ignore stop */
 }
 const SymbolPrototypeToString = require_primordials_uncurry.uncurryThis(Symbol.prototype.toString);

package/dist/primordials/uncurry.js

@@ -15,13 +15,13 @@ const require_smol_detect = require('../smol/detect.js');
 *   or `Reflect` here. tsgo has a bug that mis-transpiles destructured exports.
 *   See: https://github.com/SocketDev/socket-packageurl-js/issues/3.
 */
-const _smolUtil = /* @__PURE__ */ require_smol_detect.getSmolUtil();
+const smolUtil = require_smol_detect.getSmolUtil();
 const { apply, bind, call } = Function.prototype;
-const uncurryThis = _smolUtil?.uncurryThis ?? bind.bind(call);
-const applyBind = _smolUtil?.applyBind ?? bind.bind(apply);
-const _applyBoundForSafe = applyBind;
-const applySafe = _smolUtil?.applySafe ?? ((fn) => {
-	const apply2 = _applyBoundForSafe(fn);
+const uncurryThis = smolUtil?.uncurryThis ?? bind.bind(call);
+const applyBind = smolUtil?.applyBind ?? bind.bind(apply);
+const applyBoundForSafe = applyBind;
+const applySafe = smolUtil?.applySafe ?? ((fn) => {
+	const apply2 = applyBoundForSafe(fn);
 	return (self, args) => {
 		try {
 			return apply2(self, args);
@@ -30,9 +30,9 @@ const applySafe = _smolUtil?.applySafe ?? ((fn) => {
 		}
 	};
 });
-const _bindCallFallback = ((fn, thisArg, ...presetArgs) => Function.prototype.bind.apply(fn, [thisArg, ...presetArgs]));
-const bindCall = _smolUtil?.bindCall ?? _bindCallFallback;
-const weakRefSafe = _smolUtil?.weakRefSafe ?? ((target) => {
+const bindCallFallback = ((fn, thisArg, ...presetArgs) => Function.prototype.bind.apply(fn, [thisArg, ...presetArgs]));
+const bindCall = smolUtil?.bindCall ?? bindCallFallback;
+const weakRefSafe = smolUtil?.weakRefSafe ?? ((target) => {
 	try {
 		return new WeakRef(target);
 	} catch {

package/dist/process/abort.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *   `AbortController` and its `AbortSignal` so cooperating modules can
 *   coordinate cancellation from a single source.
 */
-let _abortController;
+let abortController;
 /**
 * Get the process-scoped shared `AbortController` singleton. Cooperating
 * modules use this to coordinate cancellation across the library.
@@ -16,8 +16,8 @@ let _abortController;
 * @returns The lazily-created shared `AbortController` instance.
 */
 function getAbortController() {
-	if (_abortController === void 0) _abortController = new AbortController();
-	return _abortController;
+	if (abortController === void 0) abortController = new AbortController();
+	return abortController;
 }
 /**
 * Get the process-scoped shared `AbortSignal` singleton. This is the `signal`

package/dist/process/lock-manager.js

@@ -72,12 +72,12 @@ var ProcessLockManager = class {
 	*/
 	ensureExitHandler() {
 		if (this.exitHandlerRegistered) return;
-		/* @__PURE__ */ require_events_exit_handler.onExit(() => {
+		require_events_exit_handler.onExit(() => {
 			/* c8 ignore start - Exit-handler body only fires on real
 			process exit. Subprocess test infra would be needed. */
 			for (const timer of this.touchTimers.values()) clearInterval(timer);
 			this.touchTimers.clear();
-			const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+			const fs = require_node_fs.getNodeFs();
 			for (const lockPath of this.activeLocks) try {
 				if (fs.existsSync(lockPath)) require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
 			} catch {}
@@ -93,7 +93,7 @@ var ProcessLockManager = class {
 	*/
 	touchLock(lockPath) {
 		try {
-			const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+			const fs = require_node_fs.getNodeFs();
 			if (fs.existsSync(lockPath)) {
 				const now = require_primordials_date.DateNow() / 1e3;
 				fs.utimesSync(lockPath, now, now);
@@ -142,7 +142,7 @@ var ProcessLockManager = class {
 	*/
 	isStale(lockPath, staleMs) {
 		try {
-			const stats = (/* @__PURE__ */ require_node_fs.getNodeFs()).statSync(lockPath, { throwIfNoEntry: false });
+			const stats = require_node_fs.getNodeFs().statSync(lockPath, { throwIfNoEntry: false });
 			if (!stats) return false;
 			return require_primordials_date.DateNow() - stats.mtime.getTime() > staleMs;
 		} catch {
@@ -178,7 +178,7 @@ var ProcessLockManager = class {
 	async acquire(lockPath, options = {}) {
 		const { baseDelayMs = 100, maxDelayMs = 1e3, retries = 3, staleMs = 5e3, touchIntervalMs = 2e3 } = options;
 		this.ensureExitHandler();
-		return await /* @__PURE__ */ require_promises_retry.pRetry(async () => {
+		return await require_promises_retry.pRetry(async () => {
 			try {
 				if (this.isStale(lockPath, staleMs)) {
 					logger.log(`Removing stale lock: ${lockPath}`);
@@ -186,8 +186,8 @@ var ProcessLockManager = class {
 						require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
 					} catch {}
 				}
-				const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-				const parent = (/* @__PURE__ */ require_node_path.getNodePath()).dirname(lockPath);
+				const fs = require_node_fs.getNodeFs();
+				const parent = require_node_path.getNodePath().dirname(lockPath);
 				if (parent && parent !== "." && parent !== lockPath) fs.mkdirSync(parent, { recursive: true });
 				fs.mkdirSync(lockPath);
 				this.activeLocks.add(lockPath);
@@ -238,7 +238,7 @@ Parent path: ${parentDir}\nTo resolve:
 	release(lockPath) {
 		this.stopTouchTimer(lockPath);
 		try {
-			if ((/* @__PURE__ */ require_node_fs.getNodeFs()).existsSync(lockPath)) require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
+			if (require_node_fs.getNodeFs().existsSync(lockPath)) require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
 			this.activeLocks.delete(lockPath);
 		} catch (e) {
 			logger.warn(`Failed to release lock ${lockPath}: ${require_errors_message.errorMessage(e)}`);

package/dist/process/spawn/_internal.js

@@ -13,17 +13,16 @@ const require_ansi_strip = require('../../ansi/strip.js');
 */
 const stackCache = new require_primordials_map_set.WeakMapCtor();
 const spawnBinPathCache = new require_primordials_map_set.MapCtor();
-const windowsScriptExtRegExp = /\.(?:cmd|bat|ps1)$/i;
-let _npmCliPromiseSpawn;
+const windowsScriptExtRegExp = /\.(?:bat|cmd|ps1)$/i;
+let npmCliPromiseSpawnCache;
 /**
 * Lazily load the `@npmcli/promise-spawn` module to avoid Webpack bundling
 * issues. Required because the upstream module uses CJS dynamic-require
 * patterns that Webpack flags.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function getNpmCliPromiseSpawn() {
-	if (_npmCliPromiseSpawn === void 0) _npmCliPromiseSpawn = /* @__PURE__ */ require("../../external/@npmcli/promise-spawn");
-	return _npmCliPromiseSpawn;
+	if (npmCliPromiseSpawnCache === void 0) npmCliPromiseSpawnCache = /*@__PURE__*/ require("../../external/@npmcli/promise-spawn");
+	return npmCliPromiseSpawnCache;
 }
 /**
 * Strip ANSI escape codes from spawn result stdout and stderr. Modifies the
@@ -33,12 +32,11 @@ function getNpmCliPromiseSpawn() {
 *
 * @returns {unknown} The modified result object
 */
-/* @__NO_SIDE_EFFECTS__ */
 function stripAnsiFromSpawnResult(result) {
 	const res = result;
 	const { stderr, stdout } = res;
-	if (typeof stdout === "string") res.stdout = /* @__PURE__ */ require_ansi_strip.stripAnsi(stdout);
-	if (typeof stderr === "string") res.stderr = /* @__PURE__ */ require_ansi_strip.stripAnsi(stderr);
+	if (typeof stdout === "string") res.stdout = require_ansi_strip.stripAnsi(stdout);
+	if (typeof stderr === "string") res.stderr = require_ansi_strip.stripAnsi(stderr);
 	return res;
 }
 

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,9 @@ 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)) actualCmd = require_node_path.getNodePath().basename(actualCmd, require_node_path.getNodePath().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 +95,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 +119,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 +139,18 @@ 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)) actualCmd = require_node_path.getNodePath().basename(actualCmd, require_node_path.getNodePath().extname(actualCmd));
 	}
 	/* c8 ignore stop */
 	const { stripAnsi: shouldStripAnsi = true, ...rawSpawnOptions } = {
@@ -163,13 +163,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

@@ -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");
 }