@socketsecurity/lib 6.0.6 → 6.0.7

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

@@ -31,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
@@ -70,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);
@@ -128,9 +128,9 @@ 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) => {
@@ -142,7 +142,7 @@ async function downloadBinaryFile(url, destPath, integrity, sha256) {
 	};
 	const verifyCachedSha256 = async (fileBuffer) => {
 		if (!sha256) return;
-		const actualSha256 = /* @__PURE__ */ require_crypto_hash.hash("sha256", fileBuffer, "hex");
+		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}`);
@@ -152,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;
@@ -163,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

package/dist/dlx/detect.d.ts

@@ -11,36 +11,13 @@
  *   - DLX cache: Check for node_modules/ directory
  *   - Local paths: Check for package.json with bin field, then file extension
  */
-export declare function packageJsonPathCacheSet(key: string, value: string | undefined): void;
 export type ExecutableType = 'package' | 'binary' | 'unknown';
 export interface ExecutableDetectionResult {
     type: ExecutableType;
     method: 'dlx-cache' | 'package-json' | 'file-extension';
-    packageJsonPath?: string;
-    inDlxCache?: boolean;
+    packageJsonPath?: string | undefined;
+    inDlxCache?: boolean | undefined;
 }
-/**
- * Find package.json in the directory containing the file or parent directories.
- * Results are cached to avoid repeated directory traversal.
- *
- * @private
- *
- * @param filePath - Path to search from.
- *
- * @returns Path to package.json if found, undefined otherwise
- */
-export declare function findPackageJson(filePath: string): string | undefined;
-/**
- * Read and parse package.json with caching. Results are cached to avoid
- * repeated file reads.
- *
- * @private
- *
- * @param packageJsonPath - Path to package.json.
- *
- * @returns Parsed package.json or null if invalid
- */
-export declare function readPackageJson(packageJsonPath: string): object | undefined;
 /**
  * Detect executable type for paths in DLX cache. Uses filesystem structure
  * (node_modules/ presence).
@@ -95,6 +72,17 @@ export declare function detectExecutableType(filePath: string): ExecutableDetect
  * @returns Detection result
  */
 export declare function detectLocalExecutableType(filePath: string): ExecutableDetectionResult;
+/**
+ * Find package.json in the directory containing the file or parent directories.
+ * Results are cached to avoid repeated directory traversal.
+ *
+ * @private
+ *
+ * @param filePath - Path to search from.
+ *
+ * @returns Path to package.json if found, undefined otherwise
+ */
+export declare function findPackageJson(filePath: string): string | undefined;
 /**
  * Check if a file path indicates a Node.js script.
  *
@@ -138,3 +126,24 @@ export declare function isNativeBinary(filePath: string): boolean;
  * @returns True if detected as Node.js package
  */
 export declare function isNodePackage(filePath: string): boolean;
+/**
+ * Set a package.json path cache entry, evicting the oldest when the LRU is
+ * full.
+ *
+ * @private
+ *
+ * @param key - Start directory used as the cache key.
+ * @param value - Resolved package.json path, or undefined for a negative entry.
+ */
+export declare function packageJsonPathCacheSet(key: string, value: string | undefined): void;
+/**
+ * Read and parse package.json with caching. Results are cached to avoid
+ * repeated file reads.
+ *
+ * @private
+ *
+ * @param packageJsonPath - Path to package.json.
+ *
+ * @returns Parsed package.json or null if invalid
+ */
+export declare function readPackageJson(packageJsonPath: string): object | undefined;