@socketsecurity/lib 6.0.5 → 6.0.7

package/dist/debug/caller-info.js

@@ -16,7 +16,6 @@ const require_objects_predicates = require('../objects/predicates.js');
 *
 * @private
 */
-/* @__NO_SIDE_EFFECTS__ */
 function getCallerInfo(stackOffset = 3) {
 	let name = "";
 	const captureStackTrace = Error.captureStackTrace;
@@ -33,14 +32,14 @@ function getCallerInfo(stackOffset = 3) {
 				if (lineCount < stackOffset) lineStart = i + 1;
 				else {
 					const line = stack.slice(lineStart, i).trimStart();
-					const match = /(?<=^at\s+).*?(?=\s+\(|$)/.exec(line)?.[0];
+					const match = /(?<=^at\s+).*?(?=$|\s+\()/.exec(line)?.[0];
 					/* c8 ignore next - Defensive guard; real V8 stack frames
 					always start with 'at '. */
 					if (match) {
 						name = match.replace(/^(?:async|bound|get|new|set)\s+/, "");
 						if (require_primordials_string.StringPrototypeStartsWith(name, "Object.")) {
 							const afterDot = require_primordials_string.StringPrototypeSlice(name, 7);
-							if (!/* @__PURE__ */ require_objects_predicates.hasOwn(Object, afterDot)) name = afterDot;
+							if (!require_objects_predicates.hasOwn(Object, afterDot)) name = afterDot;
 						}
 					}
 					break;

package/dist/debug/namespace.d.ts

@@ -33,3 +33,10 @@ export declare function isDebugNs(namespaces: string | undefined): boolean;
  * @private
  */
 export declare function isEnabled(namespaces: string | undefined): boolean;
+/**
+ * Whether SOCKET_DEBUG enables debug output. A namespace value like `*` or
+ * `socket:foo` enables it (these aren't boolean literals, so `envAsBoolean`
+ * alone would wrongly read them as false); an explicit boolean-false (`0`,
+ * `false`, `no`) or an empty/unset value disables it.
+ */
+export declare function isSocketDebugEnabled(): boolean;

package/dist/debug/namespace.js

@@ -23,7 +23,6 @@ src_external_debug = require_runtime.__toESM(src_external_debug);
 *
 * @private
 */
-/* @__NO_SIDE_EFFECTS__ */
 function extractOptions(namespaces) {
 	return namespaces !== null && typeof namespaces === "object" ? {
 		__proto__: null,
@@ -38,12 +37,11 @@ function extractOptions(namespaces) {
 *
 * @private
 */
-/* @__NO_SIDE_EFFECTS__ */
 function getDebugJsInstance(namespace) {
 	let inst = require_debug__internal.debugByNamespace.get(namespace);
 	/* c8 ignore start */
 	if (inst) return inst;
-	if (!/* @__PURE__ */ require_env_debug.getDebug() && /* @__PURE__ */ require_env_socket.getSocketDebug() && (namespace === "error" || namespace === "notice")) src_external_debug.default.enable(namespace);
+	if (!require_env_debug.getDebug() && require_env_socket.getSocketDebug() && (namespace === "error" || namespace === "notice")) src_external_debug.default.enable(namespace);
 	/* c8 ignore stop */
 	/* c8 ignore next - External debug library call */
 	inst = (0, src_external_debug.default)(namespace);
@@ -54,33 +52,43 @@ function getDebugJsInstance(namespace) {
 /**
 * Check if debug mode is enabled.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function isDebug() {
-	return !!/* @__PURE__ */ require_env_socket.getSocketDebug();
+	return isSocketDebugEnabled();
 }
 /**
 * Check if debug mode is enabled.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function isDebugNs(namespaces) {
-	return !!/* @__PURE__ */ require_env_socket.getSocketDebug() && /* @__PURE__ */ isEnabled(namespaces);
+	return isSocketDebugEnabled() && isEnabled(namespaces);
 }
 /**
 * Check if debug is enabled for given namespaces.
 *
 * @private
 */
-/* @__NO_SIDE_EFFECTS__ */
 function isEnabled(namespaces) {
-	if (!/* @__PURE__ */ require_env_socket.getSocketDebug()) return false;
+	if (!require_env_socket.getSocketDebug()) return false;
 	if (typeof namespaces !== "string" || !namespaces || namespaces === "*") return true;
 	const split = namespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
 	const names = [];
 	const skips = [];
 	for (const ns of split) if (require_primordials_string.StringPrototypeStartsWith(ns, "-")) skips.push(ns.slice(1));
 	else names.push(ns);
-	if (names.length && !names.some((ns) => (/* @__PURE__ */ getDebugJsInstance(ns)).enabled)) return false;
-	return skips.every((ns) => !(/* @__PURE__ */ getDebugJsInstance(ns)).enabled);
+	if (names.length && !names.some((ns) => getDebugJsInstance(ns).enabled)) return false;
+	return skips.every((ns) => !getDebugJsInstance(ns).enabled);
+}
+/**
+* Whether SOCKET_DEBUG enables debug output. A namespace value like `*` or
+* `socket:foo` enables it (these aren't boolean literals, so `envAsBoolean`
+* alone would wrongly read them as false); an explicit boolean-false (`0`,
+* `false`, `no`) or an empty/unset value disables it.
+*/
+function isSocketDebugEnabled() {
+	const value = require_env_socket.getSocketDebug();
+	if (!value) return false;
+	const lower = value.trim().toLowerCase();
+	if (lower === "0" || lower === "false" || lower === "no") return false;
+	return true;
 }
 
 //#endregion
@@ -88,4 +96,5 @@ exports.extractOptions = extractOptions;
 exports.getDebugJsInstance = getDebugJsInstance;
 exports.isDebug = isDebug;
 exports.isDebugNs = isDebugNs;
-exports.isEnabled = isEnabled;
+exports.isEnabled = isEnabled;
+exports.isSocketDebugEnabled = isSocketDebugEnabled;

package/dist/debug/output.js

@@ -39,10 +39,9 @@ function debug(...args) {
 *   debugCache('miss', 'socket-sdk:scans:xyz', { ttl: 60000 })
 *   ```
 */
-/* @__NO_SIDE_EFFECTS__ */
 function debugCache(operation, key, meta) {
-	if (!/* @__PURE__ */ require_env_socket.getSocketDebug()) return;
-	const prefix = `[CACHE] ${/* @__PURE__ */ require_debug_caller_info.getCallerInfo(3) || "cache"} ${/* @__PURE__ */ require_debug__internal.getPointingTriangle()} ${operation}: ${key}`;
+	if (!require_env_socket.getSocketDebug()) return;
+	const prefix = `[CACHE] ${require_debug_caller_info.getCallerInfo(3) || "cache"} ${require_debug__internal.getPointingTriangle()} ${operation}: ${key}`;
 	const args = meta !== void 0 ? [prefix, meta] : [prefix];
 	require_primordials_reflect.ReflectApply(require_debug__internal.logger.info, require_debug__internal.logger, args);
 }
@@ -52,10 +51,10 @@ function debugCache(operation, key, meta) {
 * message. Optional third argument is metadata object.
 */
 function debugCacheNs(namespacesOrOpts, operation, key, meta) {
-	const options = /* @__PURE__ */ require_debug_namespace.extractOptions(namespacesOrOpts);
+	const options = require_debug_namespace.extractOptions(namespacesOrOpts);
 	const { namespaces } = options;
-	if (!/* @__PURE__ */ require_debug_namespace.isEnabled(namespaces)) return;
-	const prefix = `[CACHE] ${/* @__PURE__ */ require_debug_caller_info.getCallerInfo(4) || "cache"} ${/* @__PURE__ */ require_debug__internal.getPointingTriangle()} ${operation}: ${key}`;
+	if (!require_debug_namespace.isEnabled(namespaces)) return;
+	const prefix = `[CACHE] ${require_debug_caller_info.getCallerInfo(4) || "cache"} ${require_debug__internal.getPointingTriangle()} ${operation}: ${key}`;
 	const logArgs = meta !== void 0 ? [prefix, meta] : [prefix];
 	const spinnerInstance = options.spinner || require_spinner_default.getDefaultSpinner();
 	const wasSpinning = spinnerInstance?.isSpinning;
@@ -74,13 +73,13 @@ function debugDir(obj, inspectOpts) {
 * Debug output for object inspection with caller info.
 */
 function debugDirNs(namespacesOrOpts, obj, inspectOpts) {
-	const options = /* @__PURE__ */ require_debug_namespace.extractOptions(namespacesOrOpts);
+	const options = require_debug_namespace.extractOptions(namespacesOrOpts);
 	const { namespaces } = options;
-	if (!/* @__PURE__ */ require_debug_namespace.isEnabled(namespaces)) return;
+	if (!require_debug_namespace.isEnabled(namespaces)) return;
 	/* c8 ignore start */
-	const callerName = /* @__PURE__ */ require_debug_caller_info.getCallerInfo(4) || "anonymous";
+	const callerName = require_debug_caller_info.getCallerInfo(4) || "anonymous";
 	/* c8 ignore stop */
-	const pointingTriangle = /* @__PURE__ */ require_debug__internal.getPointingTriangle();
+	const pointingTriangle = require_debug__internal.getPointingTriangle();
 	let opts = inspectOpts;
 	/* c8 ignore start */
 	if (opts === void 0) {
@@ -109,15 +108,15 @@ function debugLog(...args) {
 * Debug logging function with caller info.
 */
 function debugLogNs(namespacesOrOpts, ...args) {
-	const options = /* @__PURE__ */ require_debug_namespace.extractOptions(namespacesOrOpts);
+	const options = require_debug_namespace.extractOptions(namespacesOrOpts);
 	const { namespaces } = options;
-	if (!/* @__PURE__ */ require_debug_namespace.isEnabled(namespaces)) return;
+	if (!require_debug_namespace.isEnabled(namespaces)) return;
 	/* c8 ignore start */
-	const callerName = /* @__PURE__ */ require_debug_caller_info.getCallerInfo(4) || "anonymous";
+	const callerName = require_debug_caller_info.getCallerInfo(4) || "anonymous";
 	/* c8 ignore stop */
-	const pointingTriangle = /* @__PURE__ */ require_debug__internal.getPointingTriangle();
+	const pointingTriangle = require_debug__internal.getPointingTriangle();
 	const text = require_primordials_array.ArrayPrototypeAt(args, 0);
-	const logArgs = typeof text === "string" ? [/* @__PURE__ */ require_strings_format.applyLinePrefix(`${callerName} ${pointingTriangle} ${text}`, { prefix: "[DEBUG] " }), ...require_primordials_array.ArrayPrototypeSlice(args, 1)] : [`[DEBUG] ${callerName} ${pointingTriangle}`, ...args];
+	const logArgs = typeof text === "string" ? [require_strings_format.applyLinePrefix(`${callerName} ${pointingTriangle} ${text}`, { prefix: "[DEBUG] " }), ...require_primordials_array.ArrayPrototypeSlice(args, 1)] : [`[DEBUG] ${callerName} ${pointingTriangle}`, ...args];
 	const spinnerInstance = options.spinner || require_spinner_default.getDefaultSpinner();
 	const wasSpinning = spinnerInstance?.isSpinning;
 	spinnerInstance?.stop();
@@ -128,15 +127,15 @@ function debugLogNs(namespacesOrOpts, ...args) {
 * Debug output with caller info.
 */
 function debugNs(namespacesOrOpts, ...args) {
-	const options = /* @__PURE__ */ require_debug_namespace.extractOptions(namespacesOrOpts);
+	const options = require_debug_namespace.extractOptions(namespacesOrOpts);
 	const { namespaces } = options;
-	if (!/* @__PURE__ */ require_debug_namespace.isEnabled(namespaces)) return;
+	if (!require_debug_namespace.isEnabled(namespaces)) return;
 	/* c8 ignore start */
-	const name = /* @__PURE__ */ require_debug_caller_info.getCallerInfo(4) || "anonymous";
+	const name = require_debug_caller_info.getCallerInfo(4) || "anonymous";
 	/* c8 ignore stop */
-	const pointingTriangle = /* @__PURE__ */ require_debug__internal.getPointingTriangle();
+	const pointingTriangle = require_debug__internal.getPointingTriangle();
 	const text = require_primordials_array.ArrayPrototypeAt(args, 0);
-	const logArgs = typeof text === "string" ? [/* @__PURE__ */ require_strings_format.applyLinePrefix(`${name} ${pointingTriangle} ${text}`, { prefix: "[DEBUG] " }), ...require_primordials_array.ArrayPrototypeSlice(args, 1)] : args;
+	const logArgs = typeof text === "string" ? [require_strings_format.applyLinePrefix(`${name} ${pointingTriangle} ${text}`, { prefix: "[DEBUG] " }), ...require_primordials_array.ArrayPrototypeSlice(args, 1)] : args;
 	const spinnerInstance = options.spinner || require_spinner_default.getDefaultSpinner();
 	const wasSpinning = spinnerInstance?.isSpinning;
 	spinnerInstance?.stop();
@@ -147,17 +146,15 @@ function debugNs(namespacesOrOpts, ...args) {
 * Create a Node.js util.debuglog compatible function. Returns a function that
 * conditionally writes debug messages to stderr.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function debuglog(section) {
-	return (/* @__PURE__ */ require_node_util.getNodeUtil()).debuglog(section);
+	return require_node_util.getNodeUtil().debuglog(section);
 }
 /**
 * Create timing functions for measuring code execution time. Returns an object
 * with start() and end() methods, plus a callable function.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function debugtime(label) {
-	const util = /* @__PURE__ */ require_node_util.getNodeUtil();
+	const util = require_node_util.getNodeUtil();
 	let startTime;
 	const impl = () => {
 		if (startTime === void 0) startTime = require_primordials_date.DateNow();

package/dist/debug/types.d.ts

@@ -5,17 +5,17 @@
  *   types, no runtime side effects.
  */
 export interface DebugOptions {
-    namespaces?: string;
+    namespaces?: string | undefined;
     spinner?: {
         isSpinning: boolean;
         stop(): void;
         start(): void;
-    };
+    } | undefined;
     [key: string]: unknown;
 }
 export type NamespacesOrOptions = string | DebugOptions;
 export interface InspectOptions {
-    depth?: number | null;
-    colors?: boolean;
+    depth?: number | null | undefined;
+    colors?: boolean | undefined;
     [key: string]: unknown;
 }

package/dist/dlx/arborist.js

@@ -6,8 +6,8 @@ const require_primordials_error = require('../primordials/error.js');
 const require_primordials_array = require('../primordials/array.js');
 const require_node_fs = require('../node/fs.js');
 const require_node_path = require('../node/path.js');
-const require_primordials_object = require('../primordials/object.js');
 const require_primordials_json = require('../primordials/json.js');
+const require_primordials_object = require('../primordials/object.js');
 const require_paths_socket = require('../paths/socket.js');
 let src_external__npmcli_arborist = require("../external/@npmcli/arborist");
 src_external__npmcli_arborist = require_runtime.__toESM(src_external__npmcli_arborist);
@@ -56,7 +56,7 @@ function getBaseArboristOptions(installPath, options) {
 * N deps did we pin?").
 */
 function readSingleDependency(packageJsonPath) {
-	const names = require_primordials_object.ObjectKeys(require_primordials_json.JSONParse((/* @__PURE__ */ require_node_fs.getNodeFs()).readFileSync(packageJsonPath, "utf8")).dependencies ?? {});
+	const names = require_primordials_object.ObjectKeys(require_primordials_json.JSONParse(require_node_fs.getNodeFs().readFileSync(packageJsonPath, "utf8")).dependencies ?? {});
 	if (names.length !== 1) throw new require_primordials_error.ErrorCtor(`safeIdealTree expects exactly one top-level dependency in ${packageJsonPath}, found ${names.length}`);
 	return names[0];
 }
@@ -95,8 +95,8 @@ function readTopLevelFromIdealTree(tree, targetName) {
 * with no `add` list skips the write.
 */
 async function safeIdealTree(options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const { before, path: installPath, quiet = true } = options;
 	const targetName = readSingleDependency(path.join(installPath, "package.json"));
 	const arb = new src_external__npmcli_arborist.default({
@@ -146,8 +146,8 @@ async function safeReify(options) {
 * pnpm-style equivalent: minimum-release-age=<minutes>
 */
 async function writeSafeNpmrc(installPath, options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const { minReleaseDays, minReleaseMins } = {
 		__proto__: null,
 		...options

package/dist/dlx/binary-cache.js

@@ -43,18 +43,18 @@ node_process = require_runtime.__toESM(node_process);
 */
 async function cleanDlxCache(maxAge = require_constants_time.DLX_BINARY_CACHE_TTL) {
 	const cacheDir = getDlxCachePath();
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	if (!fs.existsSync(cacheDir)) return 0;
 	let cleaned = 0;
 	const now = require_primordials_date.DateNow();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const path = require_node_path.getNodePath();
 	const entries = await fs.promises.readdir(cacheDir);
 	for (const entry of entries) {
 		const entryPath = path.join(cacheDir, entry);
 		const metaPath = getBinaryCacheMetadataPath(entryPath);
 		try {
 			if (!await (0, node_fs.existsSync)(entryPath)) continue;
-			const metadata = await /* @__PURE__ */ require_fs_read_json.readJson(metaPath, { throws: false });
+			const metadata = await require_fs_read_json.readJson(metaPath, { throws: false });
 			if (!metadata || typeof metadata !== "object" || require_primordials_array.ArrayIsArray(metadata)) continue;
 			const timestamp = metadata["timestamp"];
 			const age = typeof timestamp === "number" && timestamp > 0 ? now - timestamp : Number.POSITIVE_INFINITY;
@@ -86,7 +86,7 @@ async function cleanDlxCache(maxAge = require_constants_time.DLX_BINARY_CACHE_TT
 *   ```
 */
 function getBinaryCacheMetadataPath(cacheEntryPath) {
-	return (/* @__PURE__ */ require_node_path.getNodePath()).join(cacheEntryPath, ".dlx-metadata.json");
+	return require_node_path.getNodePath().join(cacheEntryPath, ".dlx-metadata.json");
 }
 /**
 * Get the DLX binary cache directory path. Alias of `getSocketDlxDir` — DLX
@@ -111,12 +111,12 @@ const getDlxCachePath = require_paths_socket.getSocketDlxDir;
 *   ```
 */
 async function isBinaryCacheValid(cacheEntryPath, cacheTtl) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		const metaPath = getBinaryCacheMetadataPath(cacheEntryPath);
 		if (!fs.existsSync(metaPath)) return false;
-		const metadata = await /* @__PURE__ */ require_fs_read_json.readJson(metaPath, { throws: false });
-		if (!/* @__PURE__ */ require_objects_predicates.isPlainObject(metadata)) return false;
+		const metadata = await require_fs_read_json.readJson(metaPath, { throws: false });
+		if (!require_objects_predicates.isPlainObject(metadata)) return false;
 		const now = require_primordials_date.DateNow();
 		const timestamp = metadata["timestamp"];
 		if (typeof timestamp !== "number" || timestamp <= 0) return false;
@@ -140,17 +140,17 @@ async function isBinaryCacheValid(cacheEntryPath, cacheTtl) {
 */
 async function listDlxCache() {
 	const cacheDir = getDlxCachePath();
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	if (!fs.existsSync(cacheDir)) return [];
 	const results = [];
 	const now = require_primordials_date.DateNow();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const path = require_node_path.getNodePath();
 	const entries = await fs.promises.readdir(cacheDir);
 	for (const entry of entries) {
 		const entryPath = path.join(cacheDir, entry);
 		try {
 			if (!await (0, node_fs.existsSync)(entryPath)) continue;
-			const metadata = await /* @__PURE__ */ require_fs_read_json.readJson(getBinaryCacheMetadataPath(entryPath), { throws: false });
+			const metadata = await require_fs_read_json.readJson(getBinaryCacheMetadataPath(entryPath), { throws: false });
 			if (!metadata || typeof metadata !== "object" || require_primordials_array.ArrayIsArray(metadata)) continue;
 			const metaObj = metadata;
 			const url = metaObj["source"]?.["url"] || metaObj["url"] || "";
@@ -185,12 +185,12 @@ async function listDlxCache() {
 *   ```
 */
 async function readBinaryCacheMetadata(cacheEntryPath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		const metaPath = getBinaryCacheMetadataPath(cacheEntryPath);
 		if (!fs.existsSync(metaPath)) return;
-		const metadata = await /* @__PURE__ */ require_fs_read_json.readJson(metaPath, { throws: false });
-		if (!/* @__PURE__ */ require_objects_predicates.isPlainObject(metadata)) return;
+		const metadata = await require_fs_read_json.readJson(metaPath, { throws: false });
+		if (!require_objects_predicates.isPlainObject(metadata)) return;
 		return metadata;
 	} catch {
 		return;
@@ -224,7 +224,7 @@ async function writeBinaryCacheMetadata(cacheEntryPath, cacheKey, url, integrity
 			url
 		}
 	};
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	const tmpPath = `${metaPath}.tmp.${node_process.default.pid}`;
 	await fs.promises.writeFile(tmpPath, require_primordials_json.JSONStringify(metadata, null, 2));
 	await fs.promises.rename(tmpPath, metaPath);

package/dist/dlx/binary-download.d.ts

@@ -9,7 +9,7 @@
 import type { DlxBinaryOptions } from './binary-types';
 /**
  * Download a binary from a URL with caching (without execution). Similar to
- * downloadPackage from dlx/package.
+ * downloadNpmPackage from dlx/package.
  *
  * Returns `{binaryPath, downloaded, integrity}`. The `integrity` field is the
  * SRI-formatted `sha512-<base64>` hash of the cached file — computed by the

package/dist/dlx/binary-download.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_node_crypto = require('../node/crypto.js');
 const require_crypto_hash = require('../crypto/hash.js');
+const require_primordials_buffer = require('../primordials/buffer.js');
 const require_primordials_error = require('../primordials/error.js');
 const require_integrity = require('../integrity.js');
 const require_constants_platform = require('../constants/platform.js');
@@ -30,7 +31,7 @@ node_process = require_runtime.__toESM(node_process);
 */
 /**
 * Download a binary from a URL with caching (without execution). Similar to
-* downloadPackage from dlx/package.
+* downloadNpmPackage from dlx/package.
 *
 * Returns `{binaryPath, downloaded, integrity}`. The `integrity` field is the
 * SRI-formatted `sha512-<base64>` hash of the cached file — computed by the
@@ -69,20 +70,20 @@ async function downloadBinary(options) {
 		if (normalized.type === "integrity") integrity = normalized.value;
 		else sha256 = normalized.value;
 	}
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const cacheDir = require_dlx_binary_cache.getDlxCachePath();
 	const binaryName = name || `binary-${node_process.default.platform}-${require_constants_platform.getArch()}`;
 	const cacheKey = require_dlx_cache.generateCacheKey(`${url}:${binaryName}`);
 	const cacheEntryDir = path.join(cacheDir, cacheKey);
-	const binaryPath = /* @__PURE__ */ require_paths_normalize.normalizePath(path.join(cacheEntryDir, binaryName));
+	const binaryPath = require_paths_normalize.normalizePath(path.join(cacheEntryDir, binaryName));
 	let downloaded = false;
 	let actualIntegrity = "";
 	if (!force && fs.existsSync(cacheEntryDir) && await require_dlx_binary_cache.isBinaryCacheValid(cacheEntryDir, cacheTtl)) {
 		downloaded = false;
 		const cachedMeta = await require_dlx_binary_cache.readBinaryCacheMetadata(cacheEntryDir);
 		if (cachedMeta?.integrity) actualIntegrity = cachedMeta.integrity;
-		else actualIntegrity = `sha512-${/* @__PURE__ */ require_crypto_hash.hash("sha512", await fs.promises.readFile(binaryPath), "base64")}`;
+		else actualIntegrity = `sha512-${require_crypto_hash.hash("sha512", await fs.promises.readFile(binaryPath), "base64")}`;
 	} else {
 		try {
 			await require_fs_safe.safeMkdir(cacheEntryDir);
@@ -127,22 +128,22 @@ async function downloadBinary(options) {
 *   ```
 */
 async function downloadBinaryFile(url, destPath, integrity, sha256) {
-	const crypto = /* @__PURE__ */ require_node_crypto.getNodeCrypto();
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const crypto = require_node_crypto.getNodeCrypto();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const cacheEntryDir = path.dirname(destPath);
 	const lockPath = path.join(cacheEntryDir, "concurrency.lock");
 	const verifyIntegrity = async (actualIntegrity) => {
 		if (!integrity) return;
-		if (!(actualIntegrity.length === integrity.length && crypto.timingSafeEqual(Buffer.from(actualIntegrity), Buffer.from(integrity)))) {
+		if (!(actualIntegrity.length === integrity.length && crypto.timingSafeEqual(require_primordials_buffer.BufferFrom(actualIntegrity), Buffer.from(integrity)))) {
 			await require_fs_safe.safeDelete(destPath);
 			throw new require_primordials_error.ErrorCtor(`Integrity mismatch: expected ${integrity}, got ${actualIntegrity}`);
 		}
 	};
 	const verifyCachedSha256 = async (fileBuffer) => {
 		if (!sha256) return;
-		const actualSha256 = /* @__PURE__ */ require_crypto_hash.hash("sha256", fileBuffer, "hex");
-		if (!(actualSha256.length === sha256.length && crypto.timingSafeEqual(Buffer.from(actualSha256), Buffer.from(sha256.toLowerCase())))) {
+		const actualSha256 = require_crypto_hash.hash("sha256", fileBuffer, "hex");
+		if (!(actualSha256.length === sha256.length && crypto.timingSafeEqual(require_primordials_buffer.BufferFrom(actualSha256), Buffer.from(sha256.toLowerCase())))) {
 			await require_fs_safe.safeDelete(destPath);
 			throw new require_primordials_error.ErrorCtor(`SHA-256 mismatch: expected ${sha256}, got ${actualSha256}`);
 		}
@@ -151,7 +152,7 @@ async function downloadBinaryFile(url, destPath, integrity, sha256) {
 		if (fs.existsSync(destPath)) {
 			if ((await fs.promises.stat(destPath)).size > 0) {
 				const fileBuffer = await fs.promises.readFile(destPath);
-				const actualIntegrity = `sha512-${/* @__PURE__ */ require_crypto_hash.hash("sha512", fileBuffer, "base64")}`;
+				const actualIntegrity = `sha512-${require_crypto_hash.hash("sha512", fileBuffer, "base64")}`;
 				await verifyIntegrity(actualIntegrity);
 				await verifyCachedSha256(fileBuffer);
 				return actualIntegrity;
@@ -162,7 +163,7 @@ async function downloadBinaryFile(url, destPath, integrity, sha256) {
 		} catch (e) {
 			throw new require_primordials_error.ErrorCtor(`Failed to download binary from ${url}\nDestination: ${destPath}\nCheck your internet connection or verify the URL is accessible.`, { cause: e });
 		}
-		const actualIntegrity = `sha512-${/* @__PURE__ */ require_crypto_hash.hash("sha512", await fs.promises.readFile(destPath), "base64")}`;
+		const actualIntegrity = `sha512-${require_crypto_hash.hash("sha512", await fs.promises.readFile(destPath), "base64")}`;
 		await verifyIntegrity(actualIntegrity);
 		if (!require_constants_platform.WIN32) await fs.promises.chmod(destPath, 493);
 		return actualIntegrity;

package/dist/dlx/binary-resolution.js

@@ -41,9 +41,9 @@ src_external_libnpmexec = require_runtime.__toESM(src_external_libnpmexec);
 *   ```
 */
 function findBinaryPath(packageDir, packageName, binaryName) {
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
-	const installedDir = /* @__PURE__ */ require_paths_normalize.normalizePath(path.join(packageDir, "node_modules", packageName));
-	const pkgJson = /* @__PURE__ */ require_fs_read_json.readJsonSync(path.join(installedDir, "package.json"));
+	const path = require_node_path.getNodePath();
+	const installedDir = require_paths_normalize.normalizePath(path.join(packageDir, "node_modules", packageName));
+	const pkgJson = require_fs_read_json.readJsonSync(path.join(installedDir, "package.json"));
 	const bin = pkgJson["bin"];
 	let binName;
 	let binPath;
@@ -82,7 +82,7 @@ function findBinaryPath(packageDir, packageName, binaryName) {
 		}
 	}
 	if (!binPath) throw new require_primordials_error.ErrorCtor(`No binary found for package "${packageName}"`);
-	return resolveBinaryPath(/* @__PURE__ */ require_paths_normalize.normalizePath(path.join(installedDir, binPath)));
+	return resolveBinaryPath(require_paths_normalize.normalizePath(path.join(installedDir, binPath)));
 }
 /**
 * Make all binaries in an installed package executable. Reads the package.json
@@ -105,12 +105,12 @@ function findBinaryPath(packageDir, packageName, binaryName) {
 */
 function makePackageBinsExecutable(packageDir, packageName) {
 	if (require_constants_platform.WIN32) return;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
-	const installedDir = /* @__PURE__ */ require_paths_normalize.normalizePath(path.join(packageDir, "node_modules", packageName));
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
+	const installedDir = require_paths_normalize.normalizePath(path.join(packageDir, "node_modules", packageName));
 	const pkgJsonPath = path.join(installedDir, "package.json");
 	try {
-		const bin = (/* @__PURE__ */ require_fs_read_json.readJsonSync(pkgJsonPath))["bin"];
+		const bin = require_fs_read_json.readJsonSync(pkgJsonPath)["bin"];
 		if (!bin) return;
 		const binPaths = [];
 		if (typeof bin === "string") binPaths.push(bin);
@@ -118,8 +118,9 @@ function makePackageBinsExecutable(packageDir, packageName) {
 			const binObj = bin;
 			binPaths.push(...require_primordials_object.ObjectValues(binObj));
 		}
-		for (const binPath of binPaths) {
-			const fullPath = /* @__PURE__ */ require_paths_normalize.normalizePath(path.join(installedDir, binPath));
+		for (let i = 0, { length } = binPaths; i < length; i += 1) {
+			const binPath = binPaths[i];
+			const fullPath = require_paths_normalize.normalizePath(path.join(installedDir, binPath));
 			if (fs.existsSync(fullPath)) try {
 				fs.chmodSync(fullPath, 493);
 			} catch {}
@@ -141,7 +142,7 @@ function makePackageBinsExecutable(packageDir, packageName) {
 */
 function resolveBinaryPath(basePath) {
 	if (!require_constants_platform.WIN32) return basePath;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	const cached = require_dlx__internal.binaryPathCache.get(basePath);
 	if (cached) {
 		if (fs.existsSync(cached)) {
@@ -150,14 +151,15 @@ function resolveBinaryPath(basePath) {
 		}
 		require_dlx__internal.binaryPathCache.delete(basePath);
 	}
-	for (const ext of [
+	const extensions = [
 		".cmd",
 		".bat",
 		".ps1",
 		".exe",
 		""
-	]) {
-		const testPath = basePath + ext;
+	];
+	for (let i = 0, { length } = extensions; i < length; i += 1) {
+		const testPath = basePath + extensions[i];
 		if (fs.existsSync(testPath)) {
 			require_dlx__internal.binaryPathCacheSet(basePath, testPath);
 			return testPath;

package/dist/dlx/binary-types.d.ts

@@ -132,13 +132,13 @@ export interface DlxMetadata {
     size: number;
     source?: {
         type: 'download' | 'extract' | 'package';
-        url?: string;
-        path?: string;
-        spec?: string;
-    };
+        url?: string | undefined;
+        path?: string | undefined;
+        spec?: string | undefined;
+    } | undefined;
     update_check?: {
         last_check: number;
         last_notification: number;
         latest_known: string;
-    };
+    } | undefined;
 }

package/dist/dlx/binary.js

@@ -59,18 +59,18 @@ async function dlxBinary(args, options, spawnExtra) {
 		if (normalized.type === "integrity") integrity = normalized.value;
 		else sha256 = normalized.value;
 	}
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const force = yes === true ? true : userForce;
 	const cacheDir = require_dlx_binary_cache.getDlxCachePath();
 	const binaryName = name || `binary-${node_process.default.platform}-${require_constants_platform.getArch()}`;
 	const cacheKey = require_dlx_cache.generateCacheKey(`${url}:${binaryName}`);
 	const cacheEntryDir = path.join(cacheDir, cacheKey);
-	const binaryPath = /* @__PURE__ */ require_paths_normalize.normalizePath(path.join(cacheEntryDir, binaryName));
+	const binaryPath = require_paths_normalize.normalizePath(path.join(cacheEntryDir, binaryName));
 	let downloaded = false;
 	let computedIntegrity = integrity;
 	if (!force && fs.existsSync(cacheEntryDir) && await require_dlx_binary_cache.isBinaryCacheValid(cacheEntryDir, cacheTtl)) try {
-		const metadata = await /* @__PURE__ */ require_fs_read_json.readJson(require_dlx_binary_cache.getBinaryCacheMetadataPath(cacheEntryDir), { throws: false });
+		const metadata = await require_fs_read_json.readJson(require_dlx_binary_cache.getBinaryCacheMetadataPath(cacheEntryDir), { throws: false });
 		if (metadata && typeof metadata === "object" && !require_primordials_array.ArrayIsArray(metadata) && typeof metadata["integrity"] === "string") {
 			computedIntegrity = metadata["integrity"];
 			if (!fs.existsSync(binaryPath)) downloaded = true;
@@ -129,7 +129,7 @@ async function dlxBinary(args, options, spawnExtra) {
 */
 function executeBinary(binaryPath, args, spawnOptions, spawnExtra) {
 	const needsShell = require_constants_platform.WIN32 && /\.(?:bat|cmd|ps1)$/i.test(binaryPath);
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const path = require_node_path.getNodePath();
 	const cacheEntryDir = path.dirname(binaryPath);
 	return require_process_spawn_child.spawn(binaryPath, args, needsShell ? {
 		...spawnOptions,

package/dist/dlx/cache.js

@@ -41,7 +41,7 @@ const require_crypto_hash = require('../crypto/hash.js');
 * hashes the package spec (name@version), not just name.
 */
 function generateCacheKey(spec) {
-	return (/* @__PURE__ */ require_crypto_hash.hash("sha512", spec, "hex")).substring(0, 16);
+	return require_crypto_hash.hash("sha512", spec, "hex").substring(0, 16);
 }
 
 //#endregion