@socketsecurity/lib 5.2.1 → 5.3.0

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.3.0](https://github.com/SocketDev/socket-lib/releases/tag/v5.3.0) - 2026-01-07
+
+### Added
+
+- **releases/socket-btm**: Exported helper functions for external use
+  - `detectLibc()`: Detect musl vs glibc on Linux systems
+  - `getBinaryAssetName()`: Get GitHub asset name for platform/arch
+  - `getBinaryName()`: Get binary filename with platform-appropriate extension
+  - `getPlatformArch()`: Get platform-arch identifier for directory structure
+
+- **releases/github**: Exported `getAuthHeaders()` for GitHub API authentication
+  - Returns headers with `Accept`, `X-GitHub-Api-Version`, and optional `Authorization`
+  - Checks `GH_TOKEN` and `GITHUB_TOKEN` environment variables
+
 ## [5.2.1](https://github.com/SocketDev/socket-lib/releases/tag/v5.2.1) - 2026-01-06
 
 ### Fixed

package/dist/bin.d.ts

@@ -1,9 +1,3 @@
-// ============================================================================
-// Private Helper Functions
-// ============================================================================
-// ============================================================================
-// Types and Interfaces
-// ============================================================================
 /**
  * Options for the which function.
  */
@@ -21,9 +15,6 @@ export interface WhichOptions {
     /** Current working directory for resolving relative paths. */
     cwd?: string | undefined;
 }
-// ============================================================================
-// Public API (alphabetically sorted)
-// ============================================================================
 /**
  * Execute a binary with the given arguments.
  */

package/dist/bin.js

@@ -42,8 +42,6 @@ __export(bin_exports, {
   whichSync: () => whichSync
 });
 module.exports = __toCommonJS(bin_exports);
-var import_node_fs = __toESM(require("node:fs"));
-var import_node_path = __toESM(require("node:path"));
 var import_home = require("./env/home");
 var import_windows = require("./env/windows");
 var import_xdg = require("./env/xdg");
@@ -52,6 +50,22 @@ var import_which = __toESM(require("./external/which"));
 var import_fs = require("./fs");
 var import_normalize = require("./paths/normalize");
 var import_spawn = require("./spawn");
+let _fs;
+// @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("fs");
+  }
+  return _fs;
+}
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 // @__NO_SIDE_EFFECTS__
 async function execBin(binPath, args, options) {
   const resolvedPath = (0, import_normalize.isPath)(binPath) ? /* @__PURE__ */ resolveRealBinSync(binPath) : await whichReal(binPath);
@@ -77,19 +91,21 @@ To resolve:
   });
 }
 function findRealBin(binName, commonPaths = []) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   for (const binPath2 of commonPaths) {
-    if (import_node_fs.default.existsSync(binPath2)) {
+    if (fs.existsSync(binPath2)) {
       return binPath2;
     }
   }
   const binPath = import_which.default.sync(binName, { nothrow: true });
   if (binPath) {
-    const binDir = import_node_path.default.dirname(binPath);
+    const binDir = path.dirname(binPath);
     if (isShadowBinPath(binDir)) {
       const allPaths = import_which.default.sync(binName, { all: true, nothrow: true }) || [];
       const pathsArray = Array.isArray(allPaths) ? allPaths : typeof allPaths === "string" ? [allPaths] : [];
       for (const altPath of pathsArray) {
-        const altDir = import_node_path.default.dirname(altPath);
+        const altDir = path.dirname(altPath);
         if (!isShadowBinPath(altDir)) {
           return altPath;
         }
@@ -100,49 +116,53 @@ function findRealBin(binName, commonPaths = []) {
   return void 0;
 }
 function findRealNpm() {
-  const nodeDir = import_node_path.default.dirname(process.execPath);
-  const npmInNodeDir = import_node_path.default.join(nodeDir, "npm");
-  if (import_node_fs.default.existsSync(npmInNodeDir)) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
+  const nodeDir = path.dirname(process.execPath);
+  const npmInNodeDir = path.join(nodeDir, "npm");
+  if (fs.existsSync(npmInNodeDir)) {
     return npmInNodeDir;
   }
   const commonPaths = ["/usr/local/bin/npm", "/usr/bin/npm"];
   const result = findRealBin("npm", commonPaths);
-  if (result && import_node_fs.default.existsSync(result)) {
+  if (result && fs.existsSync(result)) {
     return result;
   }
   const npmPath = whichRealSync("npm", { nothrow: true });
-  if (npmPath && typeof npmPath === "string" && import_node_fs.default.existsSync(npmPath)) {
+  if (npmPath && typeof npmPath === "string" && fs.existsSync(npmPath)) {
     return npmPath;
   }
   return "npm";
 }
 function findRealPnpm() {
+  const path = /* @__PURE__ */ getPath();
   const commonPaths = import_platform.WIN32 ? [
     // Windows common paths.
-    import_node_path.default.join((0, import_windows.getAppdata)(), "npm", "pnpm.cmd"),
-    import_node_path.default.join((0, import_windows.getAppdata)(), "npm", "pnpm"),
-    import_node_path.default.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm.cmd"),
-    import_node_path.default.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm"),
+    path.join((0, import_windows.getAppdata)(), "npm", "pnpm.cmd"),
+    path.join((0, import_windows.getAppdata)(), "npm", "pnpm"),
+    path.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm.cmd"),
+    path.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm"),
     "C:\\Program Files\\nodejs\\pnpm.cmd",
     "C:\\Program Files\\nodejs\\pnpm"
   ].filter(Boolean) : [
     // Unix common paths.
     "/usr/local/bin/pnpm",
     "/usr/bin/pnpm",
-    import_node_path.default.join(
+    path.join(
       (0, import_xdg.getXdgDataHome)() || `${(0, import_home.getHome)()}/.local/share`,
       "pnpm/pnpm"
     ),
-    import_node_path.default.join((0, import_home.getHome)(), ".pnpm/pnpm")
+    path.join((0, import_home.getHome)(), ".pnpm/pnpm")
   ].filter(Boolean);
   return findRealBin("pnpm", commonPaths) ?? "";
 }
 function findRealYarn() {
+  const path = /* @__PURE__ */ getPath();
   const commonPaths = [
     "/usr/local/bin/yarn",
     "/usr/bin/yarn",
-    import_node_path.default.join((0, import_home.getHome)(), ".yarn/bin/yarn"),
-    import_node_path.default.join(
+    path.join((0, import_home.getHome)(), ".yarn/bin/yarn"),
+    path.join(
       (0, import_home.getHome)(),
       ".config/yarn/global/node_modules/.bin/yarn"
     )
@@ -158,7 +178,9 @@ function isShadowBinPath(dirPath) {
 }
 // @__NO_SIDE_EFFECTS__
 function resolveRealBinSync(binPath) {
-  if (!import_node_path.default.isAbsolute(binPath)) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
+  if (!path.isAbsolute(binPath)) {
     try {
       const resolved = whichRealSync(binPath);
       if (resolved) {
@@ -171,17 +193,17 @@ function resolveRealBinSync(binPath) {
   if (binPath === ".") {
     return binPath;
   }
-  const ext = import_node_path.default.extname(binPath);
+  const ext = path.extname(binPath);
   const extLowered = ext.toLowerCase();
-  const basename = import_node_path.default.basename(binPath, ext);
+  const basename = path.basename(binPath, ext);
   const voltaIndex = basename === "node" ? -1 : /(?<=\/)\.volta\//i.exec(binPath)?.index ?? -1;
   if (voltaIndex !== -1) {
     const voltaPath = binPath.slice(0, voltaIndex);
-    const voltaToolsPath = import_node_path.default.join(voltaPath, "tools");
-    const voltaImagePath = import_node_path.default.join(voltaToolsPath, "image");
-    const voltaUserPath = import_node_path.default.join(voltaToolsPath, "user");
+    const voltaToolsPath = path.join(voltaPath, "tools");
+    const voltaImagePath = path.join(voltaToolsPath, "image");
+    const voltaUserPath = path.join(voltaToolsPath, "user");
     const voltaPlatform = (0, import_fs.readJsonSync)(
-      import_node_path.default.join(voltaUserPath, "platform.json"),
+      path.join(voltaUserPath, "platform.json"),
       { throws: false }
     );
     const voltaNodeVersion = voltaPlatform?.node?.runtime;
@@ -190,35 +212,35 @@ function resolveRealBinSync(binPath) {
     if (basename === "npm" || basename === "npx") {
       if (voltaNpmVersion) {
         const relCliPath = `bin/${basename}-cli.js`;
-        voltaBinPath = import_node_path.default.join(
+        voltaBinPath = path.join(
           voltaImagePath,
           `npm/${voltaNpmVersion}/${relCliPath}`
         );
-        if (voltaNodeVersion && !import_node_fs.default.existsSync(voltaBinPath)) {
-          voltaBinPath = import_node_path.default.join(
+        if (voltaNodeVersion && !fs.existsSync(voltaBinPath)) {
+          voltaBinPath = path.join(
             voltaImagePath,
             `node/${voltaNodeVersion}/lib/node_modules/npm/${relCliPath}`
           );
-          if (!import_node_fs.default.existsSync(voltaBinPath)) {
+          if (!fs.existsSync(voltaBinPath)) {
             voltaBinPath = "";
           }
         }
       }
     } else {
-      const voltaUserBinPath = import_node_path.default.join(voltaUserPath, "bin");
+      const voltaUserBinPath = path.join(voltaUserPath, "bin");
       const binInfo = (0, import_fs.readJsonSync)(
-        import_node_path.default.join(voltaUserBinPath, `${basename}.json`),
+        path.join(voltaUserBinPath, `${basename}.json`),
         { throws: false }
       );
       const binPackage = binInfo?.package;
       if (binPackage) {
-        voltaBinPath = import_node_path.default.join(
+        voltaBinPath = path.join(
           voltaImagePath,
           `packages/${binPackage}/bin/${basename}`
         );
-        if (!import_node_fs.default.existsSync(voltaBinPath)) {
+        if (!fs.existsSync(voltaBinPath)) {
           voltaBinPath = `${voltaBinPath}.cmd`;
-          if (!import_node_fs.default.existsSync(voltaBinPath)) {
+          if (!fs.existsSync(voltaBinPath)) {
             voltaBinPath = "";
           }
         }
@@ -226,7 +248,7 @@ function resolveRealBinSync(binPath) {
     }
     if (voltaBinPath) {
       try {
-        return (0, import_normalize.normalizePath)(import_node_fs.default.realpathSync.native(voltaBinPath));
+        return (0, import_normalize.normalizePath)(fs.realpathSync.native(voltaBinPath));
       } catch {
       }
       return voltaBinPath;
@@ -237,13 +259,13 @@ function resolveRealBinSync(binPath) {
     const isNpmOrNpx = basename === "npm" || basename === "npx";
     const isPnpmOrYarn = basename === "pnpm" || basename === "yarn";
     if (hasKnownExt && isNpmOrNpx) {
-      const quickPath = import_node_path.default.join(
-        import_node_path.default.dirname(binPath),
+      const quickPath = path.join(
+        path.dirname(binPath),
         `node_modules/npm/bin/${basename}-cli.js`
       );
-      if (import_node_fs.default.existsSync(quickPath)) {
+      if (fs.existsSync(quickPath)) {
         try {
-          return import_node_fs.default.realpathSync.native(quickPath);
+          return fs.realpathSync.native(quickPath);
         } catch {
         }
         return quickPath;
@@ -253,8 +275,8 @@ function resolveRealBinSync(binPath) {
     if (hasKnownExt && // Only parse shell scripts and batch files, not actual executables.
     // .exe files are already executables and don't need path resolution from wrapper scripts.
     extLowered !== ".exe" && // Check if file exists before attempting to read it to avoid ENOENT errors.
-    import_node_fs.default.existsSync(binPath)) {
-      const source = import_node_fs.default.readFileSync(binPath, "utf8");
+    fs.existsSync(binPath)) {
+      const source = fs.readFileSync(binPath, "utf8");
       if (isNpmOrNpx) {
         if (extLowered === ".cmd") {
           relPath = basename === "npm" ? /(?<="NPM_CLI_JS=%~dp0\\).*(?=")/.exec(source)?.[0] || "" : /(?<="NPX_CLI_JS=%~dp0\\).*(?=")/.exec(source)?.[0] || "";
@@ -301,7 +323,7 @@ function resolveRealBinSync(binPath) {
         relPath = /(?<="\$basedir\/).*(?=" $args\n)/.exec(source)?.[0] || "";
       }
       if (relPath) {
-        binPath = (0, import_normalize.normalizePath)(import_node_path.default.resolve(import_node_path.default.dirname(binPath), relPath));
+        binPath = (0, import_normalize.normalizePath)(path.resolve(path.dirname(binPath), relPath));
       }
     }
   } else {
@@ -313,10 +335,10 @@ function resolveRealBinSync(binPath) {
       if (binIndex !== -1) {
         const baseBinPath = binPath.slice(0, binIndex + "/.bin/pnpm".length);
         try {
-          const stats = import_node_fs.default.statSync(baseBinPath);
+          const stats = fs.statSync(baseBinPath);
           if (stats.isFile()) {
             binPath = (0, import_normalize.normalizePath)(baseBinPath);
-            hasNoExt = !import_node_path.default.extname(binPath);
+            hasNoExt = !path.extname(binPath);
           }
         } catch {
         }
@@ -324,8 +346,8 @@ function resolveRealBinSync(binPath) {
     }
     if (hasNoExt && (isPnpmOrYarn || isNpmOrNpx) && // For extensionless files (Unix shell scripts), verify existence before reading.
     // This prevents ENOENT errors when the bin path doesn't exist.
-    import_node_fs.default.existsSync(binPath)) {
-      const source = import_node_fs.default.readFileSync(binPath, "utf8");
+    fs.existsSync(binPath)) {
+      const source = fs.readFileSync(binPath, "utf8");
       let relPath = "";
       if (isPnpmOrYarn) {
         relPath = /(?<="\$basedir\/)\.tools\/[^"]+(?="\s+"\$@")/.exec(source)?.[0] || "";
@@ -347,12 +369,12 @@ function resolveRealBinSync(binPath) {
         relPath = basename === "npm" ? /(?<=NPM_CLI_JS="\$CLI_BASEDIR\/).*(?=")/.exec(source)?.[0] || "" : /(?<=NPX_CLI_JS="\$CLI_BASEDIR\/).*(?=")/.exec(source)?.[0] || "";
       }
       if (relPath) {
-        binPath = (0, import_normalize.normalizePath)(import_node_path.default.resolve(import_node_path.default.dirname(binPath), relPath));
+        binPath = (0, import_normalize.normalizePath)(path.resolve(path.dirname(binPath), relPath));
       }
     }
   }
   try {
-    const realPath = import_node_fs.default.realpathSync.native(binPath);
+    const realPath = fs.realpathSync.native(binPath);
     return (0, import_normalize.normalizePath)(realPath);
   } catch {
   }

package/dist/constants/agents.js

@@ -70,8 +70,8 @@ const NPM_BIN_PATH = /* @__PURE__ */ (() => {
 })();
 const NPM_REAL_EXEC_PATH = /* @__PURE__ */ (() => {
   try {
-    const { existsSync } = require("node:fs");
-    const path = require("node:path");
+    const { existsSync } = require("fs");
+    const path = require("path");
     const npmBin = import_which.default.sync("npm", { nothrow: true });
     if (!npmBin) {
       return void 0;

package/dist/constants/platform.d.ts

@@ -1,3 +1,24 @@
+/**
+ * CPU architecture type.
+ */
+export type Arch = NodeJS.Architecture;
+/**
+ * Linux libc variant.
+ */
+export type Libc = 'glibc' | 'musl';
+/**
+ * Operating system platform type.
+ */
+export type Platform = NodeJS.Platform;
+/**
+ * Get the current CPU architecture (memoized).
+ */
+export declare function getArch(): Arch;
+/**
+ * Get the current platform (memoized).
+ */
+export declare function getPlatform(): Platform;
+// Platform detection (memoized at module load).
 export declare const DARWIN: boolean;
 export declare const WIN32: boolean;
 // File permission modes.

package/dist/constants/platform.js

@@ -23,13 +23,35 @@ __export(platform_exports, {
   S_IXGRP: () => S_IXGRP,
   S_IXOTH: () => S_IXOTH,
   S_IXUSR: () => S_IXUSR,
-  WIN32: () => WIN32
+  WIN32: () => WIN32,
+  getArch: () => getArch,
+  getPlatform: () => getPlatform
 });
 module.exports = __toCommonJS(platform_exports);
-var import_os = require("os");
-const _platform = (0, import_os.platform)();
-const DARWIN = _platform === "darwin";
-const WIN32 = _platform === "win32";
+let _os;
+// @__NO_SIDE_EFFECTS__
+function getOs() {
+  if (_os === void 0) {
+    _os = require("os");
+  }
+  return _os;
+}
+let _arch;
+function getArch() {
+  if (_arch === void 0) {
+    _arch = (/* @__PURE__ */ getOs()).arch();
+  }
+  return _arch;
+}
+let _platform;
+function getPlatform() {
+  if (_platform === void 0) {
+    _platform = (/* @__PURE__ */ getOs()).platform();
+  }
+  return _platform;
+}
+const DARWIN = getPlatform() === "darwin";
+const WIN32 = getPlatform() === "win32";
 const S_IXUSR = 64;
 const S_IXGRP = 8;
 const S_IXOTH = 1;
@@ -39,5 +61,7 @@ const S_IXOTH = 1;
   S_IXGRP,
   S_IXOTH,
   S_IXUSR,
-  WIN32
+  WIN32,
+  getArch,
+  getPlatform
 });

package/dist/cover/code.js

@@ -30,7 +30,7 @@ let _path;
 // @__NO_SIDE_EFFECTS__
 function getPath() {
   if (_path === void 0) {
-    _path = require("node:path");
+    _path = require("path");
   }
   return _path;
 }

package/dist/debug.js

@@ -72,7 +72,7 @@ let _util;
 // @__NO_SIDE_EFFECTS__
 function getUtil() {
   if (_util === void 0) {
-    _util = require("node:util");
+    _util = require("util");
   }
   return _util;
 }

package/dist/dlx/binary.d.ts

@@ -1,5 +1,5 @@
-import type { SpawnExtra, SpawnOptions } from '../spawn';
 import { spawn } from '../spawn';
+import type { SpawnExtra, SpawnOptions } from '../spawn';
 export interface DlxBinaryOptions {
     /**
      * URL to download the binary from.

package/dist/dlx/binary.js

@@ -1,10 +1,8 @@
 "use strict";
 /* Socket Lib - Built with esbuild */
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -18,14 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var binary_exports = {};
 __export(binary_exports, {
@@ -37,9 +27,6 @@ __export(binary_exports, {
   listDlxCache: () => listDlxCache
 });
 module.exports = __toCommonJS(binary_exports);
-var import_crypto = require("crypto");
-var import_os = __toESM(require("os"));
-var import_path = __toESM(require("path"));
 var import_platform = require("../constants/platform");
 var import_time = require("../constants/time");
 var import_cache = require("./cache");
@@ -51,16 +38,32 @@ var import_normalize = require("../paths/normalize");
 var import_socket = require("../paths/socket");
 var import_process_lock = require("../process-lock");
 var import_spawn = require("../spawn");
+let _crypto;
+// @__NO_SIDE_EFFECTS__
+function getCrypto() {
+  if (_crypto === void 0) {
+    _crypto = require("crypto");
+  }
+  return _crypto;
+}
 let _fs;
 // @__NO_SIDE_EFFECTS__
 function getFs() {
   if (_fs === void 0) {
-    _fs = require("node:fs");
+    _fs = require("fs");
   }
   return _fs;
 }
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 function getMetadataPath(cacheEntryPath) {
-  return import_path.default.join(cacheEntryPath, ".dlx-metadata.json");
+  return (/* @__PURE__ */ getPath()).join(cacheEntryPath, ".dlx-metadata.json");
 }
 async function isCacheValid(cacheEntryPath, cacheTtl) {
   const fs = /* @__PURE__ */ getFs();
@@ -85,17 +88,19 @@ async function isCacheValid(cacheEntryPath, cacheTtl) {
   }
 }
 async function downloadBinaryFile(url, destPath, checksum) {
-  const cacheEntryDir = import_path.default.dirname(destPath);
-  const lockPath = import_path.default.join(cacheEntryDir, "concurrency.lock");
+  const crypto = /* @__PURE__ */ getCrypto();
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
+  const cacheEntryDir = path.dirname(destPath);
+  const lockPath = path.join(cacheEntryDir, "concurrency.lock");
   return await import_process_lock.processLock.withLock(
     lockPath,
     async () => {
-      const fs = /* @__PURE__ */ getFs();
       if (fs.existsSync(destPath)) {
         const stats = await fs.promises.stat(destPath);
         if (stats.size > 0) {
           const fileBuffer2 = await fs.promises.readFile(destPath);
-          const hasher2 = (0, import_crypto.createHash)("sha256");
+          const hasher2 = crypto.createHash("sha256");
           hasher2.update(fileBuffer2);
           return hasher2.digest("hex");
         }
@@ -111,7 +116,7 @@ Check your internet connection or verify the URL is accessible.`,
         );
       }
       const fileBuffer = await fs.promises.readFile(destPath);
-      const hasher = (0, import_crypto.createHash)("sha256");
+      const hasher = crypto.createHash("sha256");
       hasher.update(fileBuffer);
       const actualChecksum = hasher.digest("hex");
       if (checksum && actualChecksum !== checksum) {
@@ -140,8 +145,8 @@ async function writeMetadata(cacheEntryPath, cacheKey, url, binaryName, checksum
     timestamp: Date.now(),
     checksum,
     checksum_algorithm: "sha256",
-    platform: import_os.default.platform(),
-    arch: import_os.default.arch(),
+    platform: (0, import_platform.getPlatform)(),
+    arch: (0, import_platform.getArch)(),
     size,
     source: {
       type: "download",
@@ -154,9 +159,9 @@ async function writeMetadata(cacheEntryPath, cacheKey, url, binaryName, checksum
     const spec = `${url}:${binaryName}`;
     await import_manifest.dlxManifest.setBinaryEntry(spec, cacheKey, {
       checksum,
-      checksum_algorithm: "sha256",
-      platform: import_os.default.platform(),
-      arch: import_os.default.arch(),
+      checksum_algorithm: metadata.checksum_algorithm,
+      platform: metadata.platform,
+      arch: metadata.arch,
       size,
       source: {
         type: "download",
@@ -174,9 +179,10 @@ async function cleanDlxCache(maxAge = import_time.DLX_BINARY_CACHE_TTL) {
   }
   let cleaned = 0;
   const now = Date.now();
+  const path = /* @__PURE__ */ getPath();
   const entries = await fs.promises.readdir(cacheDir);
   for (const entry of entries) {
-    const entryPath = import_path.default.join(cacheDir, entry);
+    const entryPath = path.join(cacheDir, entry);
     const metaPath = getMetadataPath(entryPath);
     try {
       if (!await (0, import_fs.isDir)(entryPath)) {
@@ -215,14 +221,15 @@ async function dlxBinary(args, options, spawnExtra) {
     url,
     yes
   } = { __proto__: null, ...options };
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   const force = yes === true ? true : userForce;
   const cacheDir = getDlxCachePath();
-  const binaryName = name || `binary-${process.platform}-${import_os.default.arch()}`;
+  const binaryName = name || `binary-${process.platform}-${(0, import_platform.getArch)()}`;
   const spec = `${url}:${binaryName}`;
   const cacheKey = (0, import_cache.generateCacheKey)(spec);
-  const cacheEntryDir = import_path.default.join(cacheDir, cacheKey);
-  const binaryPath = (0, import_normalize.normalizePath)(import_path.default.join(cacheEntryDir, binaryName));
-  const fs = /* @__PURE__ */ getFs();
+  const cacheEntryDir = path.join(cacheDir, cacheKey);
+  const binaryPath = (0, import_normalize.normalizePath)(path.join(cacheEntryDir, binaryName));
   let downloaded = false;
   let computedChecksum = checksum;
   if (!force && fs.existsSync(cacheEntryDir) && await isCacheValid(cacheEntryDir, cacheTtl)) {
@@ -280,7 +287,7 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
     ...spawnOptions,
     env: {
       ...spawnOptions?.env,
-      PATH: `${cacheEntryDir}${import_path.default.delimiter}${process.env["PATH"] || ""}`
+      PATH: `${cacheEntryDir}${(/* @__PURE__ */ getPath()).delimiter}${process.env["PATH"] || ""}`
     },
     shell: true
   } : spawnOptions;
@@ -299,13 +306,14 @@ async function downloadBinary(options) {
     name,
     url
   } = { __proto__: null, ...options };
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   const cacheDir = getDlxCachePath();
-  const binaryName = name || `binary-${process.platform}-${import_os.default.arch()}`;
+  const binaryName = name || `binary-${process.platform}-${(0, import_platform.getArch)()}`;
   const spec = `${url}:${binaryName}`;
   const cacheKey = (0, import_cache.generateCacheKey)(spec);
-  const cacheEntryDir = import_path.default.join(cacheDir, cacheKey);
-  const binaryPath = (0, import_normalize.normalizePath)(import_path.default.join(cacheEntryDir, binaryName));
-  const fs = /* @__PURE__ */ getFs();
+  const cacheEntryDir = path.join(cacheDir, cacheKey);
+  const binaryPath = (0, import_normalize.normalizePath)(path.join(cacheEntryDir, binaryName));
   let downloaded = false;
   if (!force && fs.existsSync(cacheEntryDir) && await isCacheValid(cacheEntryDir, cacheTtl)) {
     downloaded = false;
@@ -352,12 +360,13 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
 }
 function executeBinary(binaryPath, args, spawnOptions, spawnExtra) {
   const needsShell = import_platform.WIN32 && /\.(?:bat|cmd|ps1)$/i.test(binaryPath);
-  const cacheEntryDir = import_path.default.dirname(binaryPath);
+  const path = /* @__PURE__ */ getPath();
+  const cacheEntryDir = path.dirname(binaryPath);
   const finalSpawnOptions = needsShell ? {
     ...spawnOptions,
     env: {
       ...spawnOptions?.env,
-      PATH: `${cacheEntryDir}${import_path.default.delimiter}${process.env["PATH"] || ""}`
+      PATH: `${cacheEntryDir}${path.delimiter}${process.env["PATH"] || ""}`
     },
     shell: true
   } : spawnOptions;
@@ -374,9 +383,10 @@ async function listDlxCache() {
   }
   const results = [];
   const now = Date.now();
+  const path = /* @__PURE__ */ getPath();
   const entries = await fs.promises.readdir(cacheDir);
   for (const entry of entries) {
-    const entryPath = import_path.default.join(cacheDir, entry);
+    const entryPath = path.join(cacheDir, entry);
     try {
       if (!await (0, import_fs.isDir)(entryPath)) {
         continue;
@@ -392,7 +402,7 @@ async function listDlxCache() {
       const files = await fs.promises.readdir(entryPath);
       const binaryFile = files.find((f) => !f.startsWith("."));
       if (binaryFile) {
-        const binaryPath = import_path.default.join(entryPath, binaryFile);
+        const binaryPath = path.join(entryPath, binaryFile);
         const binaryStats = await fs.promises.stat(binaryPath);
         results.push({
           age: now - (metaObj["timestamp"] || 0),