@spader/node-whisper-cpp 0.0.1 → 0.0.8

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+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;
+export declare class Context {
+    private readonly native;
+    constructor(options: ContextOptions);
+    transcribe(options: TranscribeOptions): Promise<Segment[]>;
+    free(): void;
+}

package/dist/index.js

@@ -0,0 +1,23 @@
+import { loadAddon } from "./loader.js";
+export * as platform from "./platform.js";
+export function version() {
+    return loadAddon().version();
+}
+export function systemInfo() {
+    return loadAddon().systemInfo();
+}
+export function createContext(options) {
+    return new Context(options);
+}
+export class Context {
+    native;
+    constructor(options) {
+        this.native = new (loadAddon().WhisperContext)(options);
+    }
+    transcribe(options) {
+        return this.native.transcribe(options);
+    }
+    free() {
+        this.native.free();
+    }
+}

package/dist/loader.d.ts

@@ -0,0 +1,2 @@
+import type { NativeAddon } from "./types.js";
+export declare function loadAddon(): NativeAddon;

package/dist/loader.js

@@ -0,0 +1,29 @@
+import { createRequire } from "node:module";
+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));
+function resolvePlatformPackageDir(name) {
+    try {
+        const entry = require.resolve(name);
+        return join(dirname(entry), "..");
+    }
+    catch {
+        const prefix = "@spader/node-whisper-cpp-";
+        return join(currentDir, "..", "packages", "platform", name.slice(prefix.length));
+    }
+}
+let store = {
+    addon: null
+};
+export function loadAddon() {
+    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/dist/types.d.ts

@@ -0,0 +1,26 @@
+export interface ContextOptions {
+    model: string;
+    use_gpu?: boolean;
+    flash_attn?: boolean;
+    gpu_device?: number;
+}
+export interface Segment {
+    t0: number;
+    t1: number;
+    text: string;
+}
+export interface TranscribeOptions {
+    pcm: Float32Array;
+    language?: string;
+    threads?: number;
+    onSegment?: (segment: Segment) => void;
+}
+export interface NativeContext {
+    transcribe(options: TranscribeOptions): Promise<Segment[]>;
+    free(): void;
+}
+export interface NativeAddon {
+    WhisperContext: new (options: ContextOptions) => NativeContext;
+    version(): string;
+    systemInfo(): string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@spader/node-whisper-cpp",
-  "version": "0.0.1",
-  "description": "placeholder",
-  "publishConfig": { "access": "public" }
+  "version": "0.0.8",
+  "type": "module",
+  "packageManager": "bun@1.3.9",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "imports": {
+    "#tools/build": "./tools/build.ts"
+  },
+  "files": [
+    "dist/",
+    "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 all",
+    "install:ci": "bun run ./tools/ci.ts install",
+    "test": "bun test ./test/smoke.test.ts",
+    "clean": "bun run ./tools/clean.ts"
+  },
+  "optionalDependencies": {
+    "@spader/node-whisper-cpp-arm64-darwin-metal": "0.0.8",
+    "@spader/node-whisper-cpp-arm64-darwin-cpu": "0.0.8",
+    "@spader/node-whisper-cpp-x64-linux-cpu-gnu": "0.0.8",
+    "@spader/node-whisper-cpp-x64-linux-cuda-gnu": "0.0.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tspader/node-whisper-cpp"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "node-addon-api": "^8.3.1"
+  },
+  "devDependencies": {
+    "@clack/prompts": "^1.0.0",
+    "@types/bun": "^1.2.21",
+    "@types/node": "^24.3.0",
+    "@types/yargs": "^17.0.35",
+    "cmake-js": "^7.3.0",
+    "typescript": "^5.9.3",
+    "yargs": "^18.0.0"
+  }
 }