@fugood/node-whisper-wasm 1.0.21 → 1.1.0

package/README.md

@@ -4,9 +4,10 @@ Browser WASM implementation package for `@fugood/whisper.node`. Application
 code should import `@fugood/whisper.node`; this package is pulled in by the main
 package for browser builds.
 
-The package exposes the same high-level context API as the native packages, but
-model and audio file paths are fetched as URLs and copied into the Emscripten
-filesystem before inference.
+The package exposes the same high-level context API as the native packages
+(`initWhisper`, `initWhisperVad`, and `initParakeet`), but model and audio file
+paths are fetched as URLs and copied into the Emscripten filesystem before
+inference.
 
 ```js
 import { initWhisper } from '@fugood/whisper.node'

package/index.d.ts

@@ -22,6 +22,17 @@ export interface NativeVadContextOptions {
   worker?: boolean
 }
 
+export interface NativeParakeetContextOptions {
+  filePath: string
+  modelUrl?: string
+  useGpu?: boolean
+  maxModelBytes?: number
+  cacheModel?: boolean
+  modelCacheName?: string
+  modelCacheKey?: string
+  worker?: boolean
+}
+
 export interface TranscribeOptions {
   language?: string
   translate?: boolean
@@ -61,6 +72,13 @@ export interface TranscribeResult {
   isAborted: boolean
 }
 
+export interface ParakeetTranscribeOptions {
+  /** Number of threads to use during computation. */
+  maxThreads?: number
+  /** Override the model audio context size (0 uses the model default). */
+  audioCtx?: number
+}
+
 export interface VadOptions {
   threshold?: number
   minSpeechDurationMs?: number
@@ -111,6 +129,32 @@ export interface WhisperContext {
   getModelInfo(): object
 }
 
+export interface ParakeetContext {
+  transcribe(
+    filePath: string,
+    options?: ParakeetTranscribeOptions,
+  ): {
+    stop: () => Promise<void>
+    promise: Promise<TranscribeResult>
+  }
+  transcribeFile(
+    filePath: string,
+    options?: ParakeetTranscribeOptions,
+  ): {
+    stop: () => Promise<void>
+    promise: Promise<TranscribeResult>
+  }
+  transcribeData(
+    audioData: ArrayBuffer | ArrayBufferView | Float32Array,
+    options?: ParakeetTranscribeOptions,
+  ): {
+    stop: () => Promise<void>
+    promise: Promise<TranscribeResult>
+  }
+  release(): Promise<void>
+  getModelInfo(): object
+}
+
 export interface WhisperVadContext {
   detectSpeech(filePath: string, options?: VadOptions): Promise<VadSegment[]>
   detectSpeechFile(filePath: string, options?: VadOptions): Promise<VadSegment[]>
@@ -137,6 +181,13 @@ export interface Module {
       callback?: (level: string, text: string) => void,
     ): void | Promise<void>
   }
+  ParakeetContext: {
+    new (options: NativeParakeetContextOptions): Promise<ParakeetContext>
+    toggleNativeLog(
+      enable: boolean,
+      callback?: (level: string, text: string) => void,
+    ): void | Promise<void>
+  }
 }
 
 export interface WasmRuntimeOptions {
@@ -161,6 +212,7 @@ export interface WasmRuntimeOptions {
 
 export declare const WhisperContext: Module['WhisperContext']
 export declare const WhisperVadContext: Module['WhisperVadContext']
+export declare const ParakeetContext: Module['ParakeetContext']
 export declare const DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES: number
 export declare const MAX_WASM_THREADS: number
 export declare const WASM_CONFIG_PATHS: {
@@ -182,6 +234,9 @@ export declare function initWhisper(
 export declare function initWhisperVad(
   options: NativeVadContextOptions,
 ): Promise<WhisperVadContext>
+export declare function initParakeet(
+  options: NativeParakeetContextOptions,
+): Promise<ParakeetContext>
 export declare function toggleNativeLog(
   enable: boolean,
   callback?: (level: string, text: string) => void,
@@ -189,17 +244,21 @@ export declare function toggleNativeLog(
 export declare function addNativeLogListener(
   listener: (level: string, text: string) => void,
 ): { remove: () => void }
+export declare function isNativeLogEnabled(): boolean
 
 declare const _default: {
   WhisperContext: typeof WhisperContext
   WhisperVadContext: typeof WhisperVadContext
+  ParakeetContext: typeof ParakeetContext
   configureWasm: typeof configureWasm
   loadWasmModule: typeof loadWasmModule
   loadWhisperModule: typeof loadWhisperModule
   initWhisper: typeof initWhisper
   initWhisperVad: typeof initWhisperVad
+  initParakeet: typeof initParakeet
   toggleNativeLog: typeof toggleNativeLog
   addNativeLogListener: typeof addNativeLogListener
+  isNativeLogEnabled: typeof isNativeLogEnabled
   isWasmThreadsSupported: typeof isWasmThreadsSupported
   DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES: typeof DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES
   MAX_WASM_THREADS: typeof MAX_WASM_THREADS

package/index.js

@@ -152,15 +152,32 @@ const createWhisperNodeApi = function (root) {
       return options
     }
 
+    function normalizeLogLevel(level) {
+      var normalized = String(level || '').toLowerCase()
+      if (normalized === 'warning') {
+        return 'warn'
+      }
+      if (
+        normalized === 'error' ||
+        normalized === 'warn' ||
+        normalized === 'info' ||
+        normalized === 'debug'
+      ) {
+        return normalized
+      }
+      return normalized || 'info'
+    }
+
     function emitLog(level, text) {
       if (!logEnabled) {
         return
       }
+      var normalizedLevel = normalizeLogLevel(level)
       if (typeof nativeLogCallback === 'function') {
-        nativeLogCallback(level, text)
+        nativeLogCallback(normalizedLevel, text)
       }
       logListeners.slice().forEach(function (listener) {
-        listener(level, text)
+        listener(normalizedLevel, text)
       })
     }
 
@@ -229,7 +246,7 @@ const createWhisperNodeApi = function (root) {
             }
           }
           options.printErr = function (text) {
-            emitLog('ERROR', String(text))
+            emitLog('INFO', String(text))
             if (typeof userPrintErr === 'function') {
               userPrintErr(text)
             }
@@ -1038,9 +1055,18 @@ const createWhisperNodeApi = function (root) {
       return decodeAudioBuffer(buffer)
     }
 
-    function validateWebGpu(runtime, useGpu) {
+    function warnWebGpuCpuFallback(error) {
+      var reason = error && error.message ? error.message : String(error)
+      console.warn(
+        '[whisper.node] WebGPU WASM load failed (' +
+          reason +
+          '); falling back to CPU WASM',
+      )
+    }
+
+    function resolveWhisperGpu(runtime, useGpu) {
       if (!useGpu) {
-        return
+        return false
       }
 
       if (
@@ -1048,14 +1074,22 @@ const createWhisperNodeApi = function (root) {
         typeof runtime.__wasm_webgpu_enabled !== 'function' ||
         !runtime.__wasm_webgpu_enabled()
       ) {
-        throw new Error(
-          'This @fugood/node-whisper-wasm build was not compiled with GGML_WEBGPU=ON',
+        warnWebGpuCpuFallback(
+          new Error(
+            'This @fugood/node-whisper-wasm build was not compiled with GGML_WEBGPU=ON',
+          ),
         )
+        return false
       }
 
       if (!root.navigator || !root.navigator.gpu) {
-        throw new Error('WebGPU was requested, but navigator.gpu is not available')
+        warnWebGpuCpuFallback(
+          new Error('WebGPU was requested, but navigator.gpu is not available'),
+        )
+        return false
       }
+
+      return true
     }
 
     function WhisperContext(options) {
@@ -1171,24 +1205,36 @@ const createWhisperNodeApi = function (root) {
       options = options || {}
       var modelSource = options.filePath || options.modelUrl
       var runtime = await loadRuntime()
-      var useGpu = options.useGpu === true
-
-      validateWebGpu(runtime, useGpu)
+      var useGpu = resolveWhisperGpu(runtime, options.useGpu === true)
 
       var model = await ensureModel(runtime, modelSource, 'whisper', options)
-      var init = unwrapWasmResult(
-        await runtime.__wasm_init_whisper(
-          model.virtualPath,
-          useGpu,
-          options.useFlashAttn === true,
-        ),
-      )
+      var useFlashAttn = useGpu && options.useFlashAttn === true
+      var init
+      try {
+        init = unwrapWasmResult(
+          await runtime.__wasm_init_whisper(
+            model.virtualPath,
+            useGpu,
+            useFlashAttn,
+          ),
+        )
+      } catch (error) {
+        if (!useGpu) {
+          throw error
+        }
+        warnWebGpuCpuFallback(error)
+        useGpu = false
+        useFlashAttn = false
+        init = unwrapWasmResult(
+          await runtime.__wasm_init_whisper(model.virtualPath, false, false),
+        )
+      }
 
       return new WhisperContextInstance(runtime, init.id, {
         filePath: modelSource,
         wasmFilePath: model.virtualPath,
         useGpu: useGpu,
-        useFlashAttn: options.useFlashAttn === true,
+        useFlashAttn: useFlashAttn,
         bytes: model.bytes,
         cacheHit: model.cacheHit,
         cacheStored: model.cacheStored,
@@ -1294,6 +1340,244 @@ const createWhisperNodeApi = function (root) {
       return Promise.resolve()
     }
 
+    function ParakeetContext(options) {
+      if (shouldUseWorker(options || {})) {
+        return createWorkerParakeetContext(options || {})
+      }
+      return createParakeetContext(options)
+    }
+
+    ParakeetContext.toggleNativeLog = toggleNativeLog
+    ParakeetContext.loadModelInfo = function (path) {
+      return {
+        path: path,
+        type: 'parakeet',
+      }
+    }
+
+    async function createWorkerParakeetContext(options) {
+      var proxy = await getWorkerProxy()
+      if (!proxy) {
+        return createParakeetContext(options)
+      }
+
+      var created = await proxy.request('initParakeet', [options || {}])
+      created.meta.worker = true
+      return new WorkerParakeetContextInstance(proxy, created.id, created.meta)
+    }
+
+    function WorkerParakeetContextInstance(proxy, id, meta) {
+      this._proxy = proxy
+      this._id = id
+      this._meta = meta
+      this._released = false
+    }
+
+    WorkerParakeetContextInstance.prototype._assertValid = function () {
+      if (this._released) {
+        throw new Error('Invalid parakeet context')
+      }
+    }
+
+    WorkerParakeetContextInstance.prototype.getModelInfo = function () {
+      return this._meta
+    }
+
+    WorkerParakeetContextInstance.prototype._transcribeWorker = function (
+      method,
+      args,
+      transfer,
+    ) {
+      this._assertValid()
+
+      var cancelled = false
+      var operation = this._proxy.requestOperation(method, args, transfer, {})
+      var proxy = this._proxy
+
+      return {
+        _requestId: operation.id,
+        stop: function () {
+          cancelled = true
+          proxy.cancel(operation.id)
+          return Promise.resolve()
+        },
+        promise: operation.promise.then(function (result) {
+          if (cancelled) {
+            result.isAborted = true
+          }
+          return result
+        }),
+      }
+    }
+
+    WorkerParakeetContextInstance.prototype.transcribeData = function (
+      audioData,
+      options,
+    ) {
+      var audio = copyFloat32Audio(audioData)
+      return this._transcribeWorker(
+        'parakeetTranscribeData',
+        [this._id, audio, normalizeThreadOptions(options)],
+        [audio.buffer],
+      )
+    }
+
+    WorkerParakeetContextInstance.prototype.transcribeFile = function (
+      filePath,
+      options,
+    ) {
+      return this._transcribeWorker(
+        'parakeetTranscribeFile',
+        [this._id, filePath, normalizeThreadOptions(options)],
+        [],
+      )
+    }
+
+    WorkerParakeetContextInstance.prototype.transcribe =
+      WorkerParakeetContextInstance.prototype.transcribeFile
+
+    WorkerParakeetContextInstance.prototype.release = async function () {
+      if (!this._released) {
+        await this._proxy.request('releaseParakeet', [this._id])
+        this._released = true
+      }
+    }
+
+    async function createParakeetContext(options) {
+      options = options || {}
+      var modelSource = options.filePath || options.modelUrl
+      var runtime = await loadRuntime()
+      if (typeof runtime.__wasm_init_parakeet !== 'function') {
+        throw new Error(
+          'ParakeetContext is not available in this @fugood/node-whisper-wasm build, please update the package',
+        )
+      }
+      var useGpu = resolveWhisperGpu(runtime, options.useGpu === true)
+
+      var model = await ensureModel(runtime, modelSource, 'parakeet', options)
+      var init
+      try {
+        init = unwrapWasmResult(
+          await runtime.__wasm_init_parakeet(model.virtualPath, useGpu),
+        )
+      } catch (error) {
+        if (!useGpu) {
+          throw error
+        }
+        warnWebGpuCpuFallback(error)
+        useGpu = false
+        init = unwrapWasmResult(
+          await runtime.__wasm_init_parakeet(model.virtualPath, false),
+        )
+      }
+
+      return new ParakeetContextInstance(runtime, init.id, {
+        filePath: modelSource,
+        wasmFilePath: model.virtualPath,
+        useGpu: useGpu,
+        bytes: model.bytes,
+        cacheHit: model.cacheHit,
+        cacheStored: model.cacheStored,
+        cacheName: model.cacheName,
+        cacheKey: model.cacheKey,
+        wasm: true,
+      })
+    }
+
+    function ParakeetContextInstance(runtime, id, meta) {
+      this._runtime = runtime
+      this._id = id
+      this._meta = meta
+      this._released = false
+    }
+
+    ParakeetContextInstance.prototype._assertValid = function () {
+      if (this._released) {
+        throw new Error('Invalid parakeet context')
+      }
+    }
+
+    ParakeetContextInstance.prototype.getModelInfo = function () {
+      return this._meta
+    }
+
+    ParakeetContextInstance.prototype._transcribeFloat32 = function (
+      audio,
+      options,
+      isCancelled,
+    ) {
+      this._assertValid()
+
+      if (isCancelled && isCancelled()) {
+        return Promise.resolve(abortedResult())
+      }
+
+      var runtime = this._runtime
+      var id = this._id
+      return defer(async function () {
+        if (isCancelled && isCancelled()) {
+          return abortedResult()
+        }
+
+        var result = unwrapWasmResult(
+          await runtime.__wasm_transcribe_parakeet(
+            id,
+            audio,
+            normalizeThreadOptions(options, runtime),
+          ),
+        )
+        if (isCancelled && isCancelled()) {
+          result.isAborted = true
+        }
+        return result
+      })
+    }
+
+    ParakeetContextInstance.prototype.transcribeData = function (audioData, options) {
+      var cancelled = false
+      var audio = toFloat32Audio(audioData)
+      return {
+        stop: function () {
+          cancelled = true
+          return Promise.resolve()
+        },
+        promise: this._transcribeFloat32(audio, options, function () {
+          return cancelled
+        }),
+      }
+    }
+
+    ParakeetContextInstance.prototype.transcribeFile = function (filePath, options) {
+      var cancelled = false
+      var self = this
+      return {
+        stop: function () {
+          cancelled = true
+          return Promise.resolve()
+        },
+        promise: (async function () {
+          if (cancelled) {
+            return abortedResult()
+          }
+          var audio = await loadAudioUrl(filePath)
+          return self._transcribeFloat32(audio, options, function () {
+            return cancelled
+          })
+        })(),
+      }
+    }
+
+    ParakeetContextInstance.prototype.transcribe =
+      ParakeetContextInstance.prototype.transcribeFile
+
+    ParakeetContextInstance.prototype.release = function () {
+      if (!this._released) {
+        this._runtime.__wasm_free_parakeet(this._id)
+        this._released = true
+      }
+      return Promise.resolve()
+    }
+
     function WhisperVadContext(options) {
       if (shouldUseWorker(options || {})) {
         return createWorkerWhisperVadContext(options || {})
@@ -1463,16 +1747,25 @@ const createWhisperNodeApi = function (root) {
       return Promise.resolve(new WhisperVadContext(options))
     }
 
+    function initParakeet(options) {
+      return Promise.resolve(new ParakeetContext(options))
+    }
+
     var api = {
       WhisperContext: WhisperContext,
       WhisperVadContext: WhisperVadContext,
+      ParakeetContext: ParakeetContext,
       configureWasm: configureWasm,
       loadWasmModule: loadRuntime,
       loadWhisperModule: loadWhisperModule,
       initWhisper: initWhisper,
       initWhisperVad: initWhisperVad,
+      initParakeet: initParakeet,
       toggleNativeLog: toggleNativeLog,
       addNativeLogListener: addNativeLogListener,
+      isNativeLogEnabled: function () {
+        return logEnabled
+      },
       isWasmThreadsSupported: isWasmThreadsSupported,
       DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES: 1500 * MIB,
       MAX_WASM_THREADS: MAX_WASM_THREADS,
@@ -1488,6 +1781,7 @@ const api = createWhisperNodeApi(root)
 
 export const WhisperContext = api.WhisperContext
 export const WhisperVadContext = api.WhisperVadContext
+export const ParakeetContext = api.ParakeetContext
 export const DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES =
   api.DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES
 export const MAX_WASM_THREADS = api.MAX_WASM_THREADS
@@ -1496,8 +1790,10 @@ export const loadWasmModule = api.loadWasmModule
 export const loadWhisperModule = api.loadWhisperModule
 export const initWhisper = api.initWhisper
 export const initWhisperVad = api.initWhisperVad
+export const initParakeet = api.initParakeet
 export const toggleNativeLog = api.toggleNativeLog
 export const addNativeLogListener = api.addNativeLogListener
+export const isNativeLogEnabled = api.isNativeLogEnabled
 export const isWasmThreadsSupported = api.isWasmThreadsSupported
 
 if (root) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/node-whisper-wasm",
-  "version": "1.0.21",
+  "version": "1.1.0",
   "description": "Browser WASM module for whisper.node",
   "type": "module",
   "main": "index.js",