onnxruntime-node 1.21.0 → 1.22.0-dev.20250418-c19a49615b

package/script/build.js

@@ -1,49 +1,68 @@
-"use strict";
+'use strict';
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null)
+      for (var k in mod)
+        if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const fs = __importStar(require("fs-extra"));
-const minimist_1 = __importDefault(require("minimist"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
+  };
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+const child_process_1 = require('child_process');
+const fs = __importStar(require('fs-extra'));
+const minimist_1 = __importDefault(require('minimist'));
+const os = __importStar(require('os'));
+const path = __importStar(require('path'));
 // command line flags
 const buildArgs = (0, minimist_1.default)(process.argv.slice(2));
 // --config=Debug|Release|RelWithDebInfo
 const CONFIG = buildArgs.config || (os.platform() === 'win32' ? 'RelWithDebInfo' : 'Release');
 if (CONFIG !== 'Debug' && CONFIG !== 'Release' && CONFIG !== 'RelWithDebInfo') {
-    throw new Error(`unrecognized config: ${CONFIG}`);
+  throw new Error(`unrecognized config: ${CONFIG}`);
 }
 // --arch=x64|ia32|arm64|arm
 const ARCH = buildArgs.arch || os.arch();
 if (ARCH !== 'x64' && ARCH !== 'ia32' && ARCH !== 'arm64' && ARCH !== 'arm') {
-    throw new Error(`unrecognized architecture: ${ARCH}`);
+  throw new Error(`unrecognized architecture: ${ARCH}`);
 }
 // --onnxruntime-build-dir=
 const ONNXRUNTIME_BUILD_DIR = buildArgs['onnxruntime-build-dir'];
@@ -71,78 +90,82 @@ const BIN_FOLDER = path.join(ROOT_FOLDER, 'bin');
 const BUILD_FOLDER = path.join(ROOT_FOLDER, 'build');
 // if rebuild, clean up the dist folders
 if (REBUILD) {
-    fs.removeSync(BIN_FOLDER);
-    fs.removeSync(BUILD_FOLDER);
+  fs.removeSync(BIN_FOLDER);
+  fs.removeSync(BUILD_FOLDER);
 }
 const args = [
-    'cmake-js',
-    REBUILD ? 'reconfigure' : 'configure',
-    `--arch=${ARCH}`,
-    '--CDnapi_build_version=6',
-    `--CDCMAKE_BUILD_TYPE=${CONFIG}`,
+  'cmake-js',
+  REBUILD ? 'reconfigure' : 'configure',
+  `--arch=${ARCH}`,
+  '--CDnapi_build_version=6',
+  `--CDCMAKE_BUILD_TYPE=${CONFIG}`,
 ];
 if (ONNXRUNTIME_BUILD_DIR && typeof ONNXRUNTIME_BUILD_DIR === 'string') {
-    args.push(`--CDONNXRUNTIME_BUILD_DIR=${ONNXRUNTIME_BUILD_DIR}`);
+  args.push(`--CDONNXRUNTIME_BUILD_DIR=${ONNXRUNTIME_BUILD_DIR}`);
 }
 if (ONNXRUNTIME_GENERATOR && typeof ONNXRUNTIME_GENERATOR === 'string') {
-    args.push(`--CDONNXRUNTIME_GENERATOR=${ONNXRUNTIME_GENERATOR}`);
+  args.push(`--CDONNXRUNTIME_GENERATOR=${ONNXRUNTIME_GENERATOR}`);
 }
 if (USE_DML) {
-    args.push('--CDUSE_DML=ON');
+  args.push('--CDUSE_DML=ON');
 }
 if (USE_WEBGPU) {
-    args.push('--CDUSE_WEBGPU=ON');
+  args.push('--CDUSE_WEBGPU=ON');
 }
 if (USE_CUDA) {
-    args.push('--CDUSE_CUDA=ON');
+  args.push('--CDUSE_CUDA=ON');
 }
 if (USE_TENSORRT) {
-    args.push('--CDUSE_TENSORRT=ON');
+  args.push('--CDUSE_TENSORRT=ON');
 }
 if (USE_COREML) {
-    args.push('--CDUSE_COREML=ON');
+  args.push('--CDUSE_COREML=ON');
 }
 if (USE_QNN) {
-    args.push('--CDUSE_QNN=ON');
+  args.push('--CDUSE_QNN=ON');
 }
 if (DLL_DEPS) {
-    args.push(`--CDORT_NODEJS_DLL_DEPS=${DLL_DEPS}`);
+  args.push(`--CDORT_NODEJS_DLL_DEPS=${DLL_DEPS}`);
 }
 // set CMAKE_OSX_ARCHITECTURES for macOS build
 if (os.platform() === 'darwin') {
-    if (ARCH === 'x64') {
-        args.push('--CDCMAKE_OSX_ARCHITECTURES=x86_64');
-    }
-    else if (ARCH === 'arm64') {
-        args.push('--CDCMAKE_OSX_ARCHITECTURES=arm64');
-    }
-    else {
-        throw new Error(`architecture not supported for macOS build: ${ARCH}`);
-    }
+  if (ARCH === 'x64') {
+    args.push('--CDCMAKE_OSX_ARCHITECTURES=x86_64');
+  } else if (ARCH === 'arm64') {
+    args.push('--CDCMAKE_OSX_ARCHITECTURES=arm64');
+  } else {
+    throw new Error(`architecture not supported for macOS build: ${ARCH}`);
+  }
 }
 // In Windows, "npx cmake-js configure" uses a powershell script to detect the Visual Studio installation.
 // The script uses the environment variable LIB. If an invalid path is specified in LIB, the script will fail.
 // So we override the LIB environment variable to remove invalid paths.
-const envOverride = os.platform() === 'win32' && process.env.LIB
+const envOverride =
+  os.platform() === 'win32' && process.env.LIB
     ? { ...process.env, LIB: process.env.LIB.split(';').filter(fs.existsSync).join(';') }
     : process.env;
 // launch cmake-js configure
-const procCmakejs = (0, child_process_1.spawnSync)('npx', args, { shell: true, stdio: 'inherit', cwd: ROOT_FOLDER, env: envOverride });
+const procCmakejs = (0, child_process_1.spawnSync)('npx', args, {
+  shell: true,
+  stdio: 'inherit',
+  cwd: ROOT_FOLDER,
+  env: envOverride,
+});
 if (procCmakejs.status !== 0) {
-    if (procCmakejs.error) {
-        console.error(procCmakejs.error);
-    }
-    process.exit(procCmakejs.status === null ? undefined : procCmakejs.status);
+  if (procCmakejs.error) {
+    console.error(procCmakejs.error);
+  }
+  process.exit(procCmakejs.status === null ? undefined : procCmakejs.status);
 }
 // launch cmake to build
 const procCmake = (0, child_process_1.spawnSync)('cmake', ['--build', '.', '--config', CONFIG], {
-    shell: true,
-    stdio: 'inherit',
-    cwd: BUILD_FOLDER,
+  shell: true,
+  stdio: 'inherit',
+  cwd: BUILD_FOLDER,
 });
 if (procCmake.status !== 0) {
-    if (procCmake.error) {
-        console.error(procCmake.error);
-    }
-    process.exit(procCmake.status === null ? undefined : procCmake.status);
+  if (procCmake.error) {
+    console.error(procCmake.error);
+  }
+  process.exit(procCmake.status === null ? undefined : procCmake.status);
 }

package/script/install-metadata-versions.js

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// This file is generated by /js/scripts/update-version.ts
+// Do not modify file content manually.
+
+module.exports = {
+  nuget: [
+    { feed: 'nuget_nightly', version: '1.22.0-dev-20250418-1104-c19a49615b' },
+    { feed: 'nuget_nightly', version: '1.22.0-dev-20250409-0707-89f8206ba4' },
+  ],
+};

package/script/install-metadata.js

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+const metadataVersions = require('./install-metadata-versions.js');
+
+const metadata = {
+  // Requirements defines a list of manifest to install for a specific platform/architecture combination.
+  requirements: {
+    'win32/x64': [],
+    'win32/arm64': [],
+    'linux/x64': ['cuda12'],
+    'linux/arm64': [],
+    'darwin/x64': [],
+    'darwin/arm64': [],
+  },
+  // Each manifest defines a list of files to install
+  manifests: {
+    'linux/x64:cuda12': {
+      './libonnxruntime_providers_cuda.so': {
+        package: 'nuget:linux/x64:cuda12',
+        path: 'runtimes/win-x64/native/libonnxruntime_providers_cuda.so',
+      },
+      './libonnxruntime_providers_shared.so': {
+        package: 'nuget:linux/x64:cuda12',
+        path: 'runtimes/win-x64/native/libonnxruntime_providers_shared.so',
+      },
+      './libonnxruntime_providers_tensorrt.so': {
+        package: 'nuget:linux/x64:cuda12',
+        path: 'runtimes/win-x64/native/libonnxruntime_providers_tensorrt.so',
+      },
+    },
+  },
+  // Each package defines a list of package metadata. The first available package will be used.
+  packages: {
+    'nuget:win32/x64:cuda12': {
+      name: 'Microsoft.ML.OnnxRuntime.Gpu.Windows',
+      versions: metadataVersions.nuget,
+    },
+    'nuget:linux/x64:cuda12': {
+      name: 'Microsoft.ML.OnnxRuntime.Gpu.Linux',
+      versions: metadataVersions.nuget,
+    },
+  },
+  feeds: {
+    nuget: {
+      type: 'nuget',
+      index: 'https://api.nuget.org/v3/index.json',
+    },
+    nuget_nightly: {
+      type: 'nuget',
+      index: 'https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/ORT-Nightly/nuget/v3/index.json',
+    },
+  },
+};
+
+module.exports = metadata;

package/script/install-utils.js

@@ -0,0 +1,306 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+const fs = require('fs');
+const https = require('https');
+const { execFileSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const AdmZip = require('adm-zip'); // Use adm-zip instead of spawn
+
+async function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https
+      .get(url, (res) => {
+        if (res.statusCode !== 200) {
+          file.close();
+          fs.unlinkSync(dest);
+          reject(new Error(`Failed to download from ${url}. HTTP status code = ${res.statusCode}`));
+          return;
+        }
+
+        res.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+        file.on('error', (err) => {
+          fs.unlinkSync(dest);
+          reject(err);
+        });
+      })
+      .on('error', (err) => {
+        fs.unlinkSync(dest);
+        reject(err);
+      });
+  });
+}
+
+async function downloadJson(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        const { statusCode } = res;
+        const contentType = res.headers['content-type'];
+
+        if (!statusCode) {
+          reject(new Error('No response statud code from server.'));
+          return;
+        }
+        if (statusCode >= 400 && statusCode < 500) {
+          resolve(null);
+          return;
+        } else if (statusCode !== 200) {
+          reject(new Error(`Failed to download build list. HTTP status code = ${statusCode}`));
+          return;
+        }
+        if (!contentType || !/^application\/json/.test(contentType)) {
+          reject(new Error(`unexpected content type: ${contentType}`));
+          return;
+        }
+        res.setEncoding('utf8');
+        let rawData = '';
+        res.on('data', (chunk) => {
+          rawData += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(rawData));
+          } catch (e) {
+            reject(e);
+          }
+        });
+        res.on('error', (err) => {
+          reject(err);
+        });
+      })
+      .on('error', (err) => {
+        reject(err);
+      });
+  });
+}
+
+async function installPackages(packages, manifests, feeds) {
+  // Step.1: resolve packages
+  const resolvedPackages = new Map();
+  for (const packageCandidates of packages) {
+    // iterate all candidates from packagesInfo and try to find the first one that exists
+    for (const { feed, version } of packageCandidates.versions) {
+      const { type, index } = feeds[feed];
+      const pkg = await resolvePackage(type, index, packageCandidates.name, version);
+      if (pkg) {
+        resolvedPackages.set(packageCandidates, pkg);
+        break;
+      }
+    }
+    if (!resolvedPackages.has(packageCandidates)) {
+      throw new Error(`Failed to resolve package. No package exists for: ${JSON.stringify(packageCandidates)}`);
+    }
+  }
+
+  // Step.2: download packages
+  for (const [pkgInfo, pkg] of resolvedPackages) {
+    const manifestsForPackage = manifests.filter((x) => x.packagesInfo === pkgInfo);
+    await pkg.download(manifestsForPackage);
+  }
+}
+
+async function resolvePackage(type, index, packageName, version) {
+  // https://learn.microsoft.com/en-us/nuget/api/overview
+  const nugetPackageUrlResolver = async (index, packageName, version) => {
+    // STEP.1 - get Nuget package index
+    const nugetIndex = await downloadJson(index);
+    if (!nugetIndex) {
+      throw new Error(`Failed to download Nuget index from ${index}`);
+    }
+
+    // STEP.2 - get the base url of "PackageBaseAddress/3.0.0"
+    const packageBaseUrl = nugetIndex.resources.find((x) => x['@type'] === 'PackageBaseAddress/3.0.0')?.['@id'];
+    if (!packageBaseUrl) {
+      throw new Error(`Failed to find PackageBaseAddress in Nuget index`);
+    }
+
+    // STEP.3 - get the package version info
+    const packageInfo = await downloadJson(`${packageBaseUrl}${packageName.toLowerCase()}/index.json`);
+    if (!packageInfo.versions.includes(version.toLowerCase())) {
+      throw new Error(`Failed to find specific package versions for ${packageName} in ${index}`);
+    }
+
+    // STEP.4 - generate the package URL
+    const packageUrl = `${packageBaseUrl}${packageName.toLowerCase()}/${version.toLowerCase()}/${packageName.toLowerCase()}.${version.toLowerCase()}.nupkg`;
+    const packageFileName = `${packageName.toLowerCase()}.${version.toLowerCase()}.nupkg`;
+
+    return {
+      download: async (manifests) => {
+        if (manifests.length === 0) {
+          return;
+        }
+
+        // Create a temporary directory
+        const tempDir = path.join(os.tmpdir(), `onnxruntime-node-pkgs_${Date.now()}`);
+        fs.mkdirSync(tempDir, { recursive: true });
+
+        try {
+          const packageFilePath = path.join(tempDir, packageFileName);
+
+          // Download the NuGet package
+          console.log(`Downloading ${packageUrl}`);
+          await downloadFile(packageUrl, packageFilePath);
+
+          // Load the NuGet package (which is a ZIP file)
+          let zip;
+          try {
+            zip = new AdmZip(packageFilePath);
+          } catch (err) {
+            throw new Error(`Failed to open NuGet package: ${err.message}`);
+          }
+
+          // Extract only the needed files from the package
+          const extractDir = path.join(tempDir, 'extracted');
+          fs.mkdirSync(extractDir, { recursive: true });
+
+          // Process each manifest and extract/copy files to their destinations
+          for (const manifest of manifests) {
+            const { filepath, pathInPackage } = manifest;
+
+            // Create directory for the target file
+            const targetDir = path.dirname(filepath);
+            fs.mkdirSync(targetDir, { recursive: true });
+
+            // Check if the file exists directly in the zip
+            const zipEntry = zip.getEntry(pathInPackage);
+            if (!zipEntry) {
+              throw new Error(`Failed to find ${pathInPackage} in NuGet package`);
+            }
+
+            console.log(`Extracting ${pathInPackage} to ${filepath}`);
+
+            // Extract just this entry to a temporary location
+            const extractedFilePath = path.join(extractDir, path.basename(pathInPackage));
+            zip.extractEntryTo(zipEntry, extractDir, false, true);
+
+            // Copy to the final destination
+            fs.copyFileSync(extractedFilePath, filepath);
+          }
+        } finally {
+          // Clean up the temporary directory - always runs even if an error occurs
+          try {
+            fs.rmSync(tempDir, { recursive: true });
+          } catch (e) {
+            console.warn(`Failed to clean up temporary directory: ${tempDir}`, e);
+            // Don't rethrow this error as it would mask the original error
+          }
+        }
+      },
+    };
+  };
+
+  switch (type) {
+    case 'nuget':
+      return await nugetPackageUrlResolver(index, packageName, version);
+    default:
+      throw new Error(`Unsupported package type: ${type}`);
+  }
+}
+
+function tryGetCudaVersion() {
+  // Should only return 11 or 12.
+
+  // try to get the CUDA version from the system ( `nvcc --version` )
+  let ver = 12;
+  try {
+    const nvccVersion = execFileSync('nvcc', ['--version'], { encoding: 'utf8' });
+    const match = nvccVersion.match(/release (\d+)/);
+    if (match) {
+      ver = parseInt(match[1]);
+      if (ver !== 11 && ver !== 12) {
+        throw new Error(`Unsupported CUDA version: ${ver}`);
+      }
+    }
+  } catch (e) {
+    if (e?.code === 'ENOENT') {
+      console.warn('`nvcc` not found. Assuming CUDA 12.');
+    } else {
+      console.warn('Failed to detect CUDA version from `nvcc --version`:', e.message);
+    }
+  }
+
+  // assume CUDA 12 if failed to detect
+  return ver;
+}
+
+function parseInstallFlag() {
+  let flag = process.env.ONNXRUNTIME_NODE_INSTALL || process.env.npm_config_onnxruntime_node_install;
+  if (!flag) {
+    for (let i = 0; i < process.argv.length; i++) {
+      if (process.argv[i].startsWith('--onnxruntime-node-install=')) {
+        flag = process.argv[i].split('=')[1];
+        break;
+      } else if (process.argv[i] === '--onnxruntime-node-install') {
+        flag = 'true';
+      }
+    }
+  }
+  switch (flag) {
+    case 'true':
+    case '1':
+    case 'ON':
+      return true;
+    case 'skip':
+      return false;
+    case undefined: {
+      flag = parseInstallCudaFlag();
+      if (flag === 'skip') {
+        return false;
+      }
+      if (flag === 11) {
+        throw new Error('CUDA 11 is no longer supported. Please consider using CPU or upgrade to CUDA 12.');
+      }
+      if (flag === 12) {
+        return 'cuda12';
+      }
+      return undefined;
+    }
+    default:
+      if (!flag || typeof flag !== 'string') {
+        throw new Error(`Invalid value for --onnxruntime-node-install: ${flag}`);
+      }
+  }
+}
+
+function parseInstallCudaFlag() {
+  let flag = process.env.ONNXRUNTIME_NODE_INSTALL_CUDA || process.env.npm_config_onnxruntime_node_install_cuda;
+  if (!flag) {
+    for (let i = 0; i < process.argv.length; i++) {
+      if (process.argv[i].startsWith('--onnxruntime-node-install-cuda=')) {
+        flag = process.argv[i].split('=')[1];
+        break;
+      } else if (process.argv[i] === '--onnxruntime-node-install-cuda') {
+        flag = 'true';
+      }
+    }
+  }
+  switch (flag) {
+    case 'true':
+    case '1':
+    case 'ON':
+      return tryGetCudaVersion();
+    case 'v11':
+      return 11;
+    case 'v12':
+      return 12;
+    case 'skip':
+    case undefined:
+      return flag;
+    default:
+      throw new Error(`Invalid value for --onnxruntime-node-install-cuda: ${flag}`);
+  }
+}
+
+module.exports = {
+  installPackages,
+  parseInstallFlag,
+};