@spader/node-whisper-cpp 0.0.7 → 0.2.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { ContextOptions, Segment, TranscribeOptions } from "./types.js";
 export type { ContextOptions, Segment, TranscribeOptions };
+export * as platform from "./platform.js";
 export declare function version(): string;
 export declare function systemInfo(): string;
 export declare function createContext(options: ContextOptions): Context;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { loadAddon } from "./loader.js";
+export * as platform from "./platform.js";
 export function version() {
     return loadAddon().version();
 }

package/dist/loader.js

@@ -1,50 +1,29 @@
 import { createRequire } from "node:module";
-import { platform, arch } from "node:process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { detect } from "./platform.js";
 const require = createRequire(import.meta.url);
 const currentDir = dirname(fileURLToPath(import.meta.url));
-const platformPackages = {
-    "darwin-arm64": "@spader/node-whisper-cpp-mac-arm64-metal",
-    "linux-x64": "@spader/node-whisper-cpp-linux-x64-cpu",
-};
-const localPlatformDirs = {
-    "@spader/node-whisper-cpp-mac-arm64-metal": "mac-arm64-metal",
-    "@spader/node-whisper-cpp-linux-x64-cpu": "linux-x64-cpu",
-};
-function getPlatformKey() {
-    return `${platform}-${arch}`;
-}
-function resolvePlatformPackageName() {
-    const platformKey = getPlatformKey();
-    const packageName = platformPackages[platformKey];
-    if (packageName) {
-        return packageName;
-    }
-    throw new Error(`Unsupported platform ${platformKey}. Supported platforms: ${Object.keys(platformPackages).join(", ")}`);
-}
-function resolvePlatformPackageDir(packageName) {
+function resolvePlatformPackageDir(name) {
     try {
-        const entryPath = require.resolve(packageName);
-        return join(dirname(entryPath), "..");
+        const entry = require.resolve(name);
+        return join(dirname(entry), "..");
     }
     catch {
-        const packageDirName = localPlatformDirs[packageName];
-        if (packageDirName == null) {
-            throw new Error(`No local package directory mapping for ${packageName}`);
-        }
-        return join(currentDir, "..", "packages", "platform", packageDirName);
+        const prefix = "@spader/node-whisper-cpp-";
+        return join(currentDir, "..", "packages", "platform", name.slice(prefix.length));
     }
 }
-let addonCache = null;
+let store = {
+    addon: null
+};
 export function loadAddon() {
-    if (addonCache != null) {
-        return addonCache;
-    }
-    const packageName = resolvePlatformPackageName();
-    const packageDir = resolvePlatformPackageDir(packageName);
-    const binsDir = join(packageDir, "bins");
-    const addonPath = join(binsDir, "whisper-addon.node");
-    addonCache = require(addonPath);
-    return addonCache;
+    if (store.addon != null)
+        return store.addon;
+    const triple = detect();
+    const name = `@spader/node-whisper-cpp-${triple}`;
+    const dir = resolvePlatformPackageDir(name);
+    const addonPath = join(dir, "bins", "whisper-addon.node");
+    store.addon = require(addonPath);
+    return store.addon;
 }

package/dist/platform.d.ts

@@ -0,0 +1,17 @@
+export type Os = "darwin" | "linux";
+export type Architecture = "arm64" | "x64";
+export type Backend = "metal" | "cpu" | "cuda" | "vulkan";
+export type Libc = "gnu" | "musl" | "apple";
+export type Target = {
+    os: Os;
+    arch: Architecture;
+    backend: Backend;
+    libc: Libc;
+};
+declare const getPlatformId: (target: Target) => string;
+declare const getPackageName: (target: Target) => string;
+declare function detect(): string;
+declare function detectTarget(): Target;
+declare function resolve(backend?: Backend): string;
+declare function resolveTarget(backend?: Backend): Target;
+export { detect, detectTarget, resolve, resolveTarget, getPlatformId, getPackageName };

package/dist/platform.js

@@ -0,0 +1,79 @@
+import { execSync } from "node:child_process";
+import { platform as os, arch } from "node:process";
+function detectLibc() {
+    if (os == "darwin") {
+        return "apple";
+    }
+    else if (os == "linux") {
+        try {
+            const result = execSync("ldd --version 2>&1", { encoding: "utf8" });
+            return result.includes("musl") ? "musl" : "gnu";
+        }
+        catch (e) {
+            return e.stdout?.includes("musl") ? "musl" : "gnu";
+        }
+    }
+    throw new Error(`Unsupported OS: ${os}`);
+}
+const VALID_BACKENDS = ["metal", "cpu", "cuda", "vulkan"];
+function detectBackend() {
+    const env = process.env.NODE_WHISPER_CPP_BACKEND;
+    if (env) {
+        if (!VALID_BACKENDS.includes(env)) {
+            throw new Error(`Invalid NODE_WHISPER_CPP_BACKEND: ${env} (expected one of ${VALID_BACKENDS.join(", ")})`);
+        }
+        return env;
+    }
+    if (os == "darwin") {
+        return "metal";
+    }
+    else if (os == "linux") {
+        try {
+            execSync("nvidia-smi", { stdio: "ignore" });
+            return "cuda";
+        }
+        catch { }
+        try {
+            execSync("vulkaninfo", { stdio: "ignore" });
+            return "vulkan";
+        }
+        catch { }
+        return "cpu";
+    }
+    throw new Error(`Unsupported OS: ${os}`);
+}
+const getPlatformId = (target) => {
+    const parts = [target.arch, target.os, target.backend];
+    if (os === "linux") {
+        parts.push(target.libc);
+    }
+    return parts.join("-");
+};
+const getPackageName = (target) => {
+    return `node-whisper-cpp-${getPlatformId(target)}`;
+};
+function detect() {
+    const target = detectTarget();
+    return getPlatformId(target);
+}
+function detectTarget() {
+    if (os !== "linux" && os !== "darwin") {
+        throw new Error(`Unsupported OS: ${os}`);
+    }
+    if (arch !== "x64" && arch !== "arm64") {
+        throw new Error(`Unsupported architecture: ${arch}`);
+    }
+    return { os, arch, backend: detectBackend(), libc: detectLibc() };
+}
+function resolve(backend) {
+    const target = resolveTarget(backend);
+    return getPlatformId(target);
+}
+function resolveTarget(backend) {
+    const detected = detectTarget();
+    return {
+        ...detected,
+        backend: backend ?? detected.backend,
+    };
+}
+export { detect, detectTarget, resolve, resolveTarget, getPlatformId, getPackageName };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@spader/node-whisper-cpp",
-  "version": "0.0.7",
+  "version": "0.2.0",
   "type": "module",
+  "packageManager": "bun@1.3.9",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -16,21 +17,24 @@
   },
   "files": [
     "dist/",
-    "packages/platform/mac-arm64-metal/",
-    "packages/platform/linux-x64-cpu/",
+    "packages/platform/arm64-darwin-metal/",
+    "packages/platform/arm64-darwin-cpu/",
+    "packages/platform/x64-linux-cpu-gnu/",
+    "packages/platform/x64-linux-cuda-gnu/",
     "package.json"
   ],
   "scripts": {
-    "build": "bun run ./tools/build.ts system",
-    "build:mac-arm64": "bun run ./tools/build.ts all --os mac --arch arm64 --backend metal",
-    "build:linux-x64": "bun run ./tools/build.ts all --os linux --arch x64 --backend cpu",
-    "ci": "bun run ./tools/ci.ts install",
+    "build": "bun run ./tools/build.ts all",
+    "smoke": "NODE_WHISPER_CPP_BACKEND=cpu bun run ./tools/build.ts all && bun run test",
+    "smoke:cpu": "NODE_WHISPER_CPP_BACKEND=cpu bun run ./tools/build.ts all --ci && bun run test",
     "test": "bun test ./test/smoke.test.ts",
     "clean": "bun run ./tools/clean.ts"
   },
   "optionalDependencies": {
-    "@spader/node-whisper-cpp-mac-arm64-metal": "0.0.7",
-    "@spader/node-whisper-cpp-linux-x64-cpu": "0.0.7"
+    "@spader/node-whisper-cpp-arm64-darwin-metal": "0.2.0",
+    "@spader/node-whisper-cpp-arm64-darwin-cpu": "0.2.0",
+    "@spader/node-whisper-cpp-x64-linux-cpu-gnu": "0.2.0",
+    "@spader/node-whisper-cpp-x64-linux-cuda-gnu": "0.2.0"
   },
   "repository": {
     "type": "git",