@fugood/node-whisper-wasm 1.0.19 → 1.0.21

package/index.js

@@ -1,33 +1,35 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) {
-    module.exports = factory(function () {
-      return require('./whisper-node.js')
-    }, root)
-  } else {
-    root.WhisperNodeWasm = factory(function () {
-      return root.createWhisperNodeModule
-    }, root)
-  }
-})(
+const root =
   typeof globalThis !== 'undefined'
     ? globalThis
     : typeof self !== 'undefined'
       ? self
       : typeof window !== 'undefined'
         ? window
-        : this,
-  function (loadModuleFactory, root) {
+        : undefined
+
+export const WASM_CONFIG_PATHS = {
+  index: new URL('./index.js', import.meta.url).href,
+  js: new URL('./wasm/whisper-node.js', import.meta.url).href,
+  wasm: new URL('./wasm/whisper-node.wasm', import.meta.url).href,
+  threadsJs: new URL('./wasm/whisper-node.threads.js', import.meta.url).href,
+  threadsWasm: new URL('./wasm/whisper-node.threads.wasm', import.meta.url).href,
+  worker: new URL('./worker.js', import.meta.url).href,
+}
+
+const createWhisperNodeApi = function (root) {
     'use strict'
 
     var SAMPLE_RATE = 16000
     var MIB = 1024 * 1024
     var FIREFOX_MODEL_LIMIT_BYTES = 256 * MIB
     var MODEL_MEMORY_RATIO = 0.75
+    var MAX_WASM_THREADS = 8
+    var DEFAULT_MODEL_CACHE_NAME = 'whisper.node.wasm.models'
 
     var runtimePromise = null
     var runtimeOptions = {}
     var workerProxyPromise = null
-    var capturedScriptUrl = getCurrentScriptUrl()
+    var capturedScriptUrl = WASM_CONFIG_PATHS.index
     var modelCache = Object.create(null)
     var logEnabled = false
     var logListeners = []
@@ -40,19 +42,8 @@
       runtimeOptions = Object.assign({}, runtimeOptions, options || {})
     }
 
-    function getCurrentScriptUrl() {
-      if (
-        root.document &&
-        root.document.currentScript &&
-        root.document.currentScript.src
-      ) {
-        return root.document.currentScript.src
-      }
-      return null
-    }
-
     function isBrowserLike() {
-      return typeof root.window !== 'undefined' || typeof root.importScripts === 'function'
+      return typeof root.window !== 'undefined' || typeof root.WorkerGlobalScope !== 'undefined'
     }
 
     function isMainBrowserThread() {
@@ -79,20 +70,47 @@
       return capturedScriptUrl
     }
 
-    function getRuntimeScriptUrl(indexScriptUrl) {
-      var configured = runtimeOptions.runtimeScriptUrl
+    function isWasmThreadsSupported() {
+      if (!isBrowserLike()) {
+        return true
+      }
+      return (
+        typeof root.SharedArrayBuffer !== 'undefined' &&
+        typeof root.Atomics !== 'undefined' &&
+        typeof root.crossOriginIsolated !== 'undefined' &&
+        root.crossOriginIsolated === true
+      )
+    }
+
+    function shouldUseThreadedRuntime() {
+      if (typeof runtimeOptions.__resolvedThreads === 'boolean') {
+        return runtimeOptions.__resolvedThreads
+      }
+      return runtimeOptions.threads !== false && isWasmThreadsSupported()
+    }
+
+    function getRuntimeScriptUrl(indexScriptUrl, useThreads) {
+      var configured = runtimeOptions.jsPath || runtimeOptions.runtimeScriptUrl
       if (configured) {
         return resolveUrl(configured, indexScriptUrl)
       }
-      return indexScriptUrl ? resolveUrl('whisper-node.js', indexScriptUrl) : null
+      return useThreads ? WASM_CONFIG_PATHS.threadsJs : WASM_CONFIG_PATHS.js
+    }
+
+    function getWasmBinaryUrl(runtimeScriptUrl, useThreads) {
+      var configured = runtimeOptions.wasmPath
+      if (configured) {
+        return resolveUrl(configured, runtimeScriptUrl)
+      }
+      return useThreads ? WASM_CONFIG_PATHS.threadsWasm : WASM_CONFIG_PATHS.wasm
     }
 
     function getWorkerScriptUrl(indexScriptUrl) {
-      var configured = runtimeOptions.workerUrl
+      var configured = runtimeOptions.workerPath || runtimeOptions.workerUrl
       if (configured) {
         return resolveUrl(configured, indexScriptUrl)
       }
-      return indexScriptUrl ? resolveUrl('worker.js', indexScriptUrl) : null
+      return WASM_CONFIG_PATHS.worker
     }
 
     function shouldUseWorker(options) {
@@ -108,11 +126,18 @@
       var blocked = {
         worker: true,
         workerUrl: true,
+        workerPath: true,
         indexScriptUrl: true,
         scriptUrl: true,
         runtimeScriptUrl: true,
+        jsPath: true,
+        wasmPath: true,
+        threads: true,
+        __resolvedThreads: true,
         locateFileBaseUrl: true,
         locateFile: true,
+        moduleFactory: true,
+        moduleOptions: true,
         print: true,
         printErr: true,
         mainScriptUrlOrBlob: true,
@@ -127,14 +152,6 @@
       return options
     }
 
-    function assertThreadSupport() {
-      if (isBrowserLike() && typeof root.SharedArrayBuffer === 'undefined') {
-        throw new Error(
-          'whisper.node WASM is built with pthreads and requires SharedArrayBuffer. Serve the page with COOP/COEP headers so the browser is cross-origin isolated.',
-        )
-      }
-    }
-
     function emitLog(level, text) {
       if (!logEnabled) {
         return
@@ -149,37 +166,79 @@
 
     function loadRuntime() {
       if (!runtimePromise) {
-        assertThreadSupport()
+        runtimePromise = (async function () {
+          var indexScriptUrl = getIndexScriptUrl()
+          var useThreads = shouldUseThreadedRuntime()
+          var runtimeScriptUrl = getRuntimeScriptUrl(indexScriptUrl, useThreads)
+          var wasmUrl = getWasmBinaryUrl(runtimeScriptUrl, useThreads)
+          var moduleFactory = runtimeOptions.moduleFactory
+
+          if (!moduleFactory) {
+            var runtimeModule = await import(runtimeScriptUrl)
+            moduleFactory =
+              runtimeModule.default ||
+              runtimeModule.createWhisperNodeModule ||
+              runtimeModule
+          }
+          if (typeof moduleFactory !== 'function') {
+            throw new Error(
+              'Failed to load whisper.node WASM runtime. Make sure the selected wasm/whisper-node*.js artifact is built and included in the package.',
+            )
+          }
 
-        var moduleFactory = loadModuleFactory()
-        if (moduleFactory && moduleFactory.default) {
-          moduleFactory = moduleFactory.default
-        }
-        if (typeof moduleFactory !== 'function') {
-          throw new Error(
-            'Failed to load whisper.node WASM runtime. Make sure whisper-node.js is built and loaded before index.js.',
+          var options = Object.assign(
+            {},
+            runtimeOptions.moduleOptions || {},
+            runtimeOptions,
           )
-        }
-
-        var options = Object.assign({}, runtimeOptions)
-        var userPrint = options.print
-        var userPrintErr = options.printErr
-
-        options.noInitialRun = true
-        options.print = function (text) {
-          emitLog('INFO', String(text))
-          if (typeof userPrint === 'function') {
-            userPrint(text)
+          var userPrint = options.print
+          var userPrintErr = options.printErr
+          var userLocateFile = options.locateFile
+          var locateFileBaseUrl =
+            options.locateFileBaseUrl || resolveUrl('.', runtimeScriptUrl)
+
+          delete options.moduleFactory
+          delete options.moduleOptions
+          delete options.worker
+          delete options.workerUrl
+          delete options.workerPath
+          delete options.indexScriptUrl
+          delete options.scriptUrl
+          delete options.runtimeScriptUrl
+          delete options.jsPath
+          delete options.wasmPath
+          delete options.threads
+          delete options.__resolvedThreads
+          delete options.locateFileBaseUrl
+
+          options.noInitialRun = true
+          options.mainScriptUrlOrBlob = options.mainScriptUrlOrBlob || runtimeScriptUrl
+          options.locateFile = function (path, prefix) {
+            if (path === 'whisper-node.wasm' || path.slice(-5) === '.wasm') {
+              return wasmUrl
+            }
+            if (typeof userLocateFile === 'function') {
+              return userLocateFile(path, prefix)
+            }
+            return resolveUrl(path, locateFileBaseUrl || prefix)
           }
-        }
-        options.printErr = function (text) {
-          emitLog('ERROR', String(text))
-          if (typeof userPrintErr === 'function') {
-            userPrintErr(text)
+          options.print = function (text) {
+            emitLog('INFO', String(text))
+            if (typeof userPrint === 'function') {
+              userPrint(text)
+            }
+          }
+          options.printErr = function (text) {
+            emitLog('ERROR', String(text))
+            if (typeof userPrintErr === 'function') {
+              userPrintErr(text)
+            }
           }
-        }
 
-        runtimePromise = Promise.resolve(moduleFactory(options))
+          var runtime = await moduleFactory(options)
+          runtime.__whisperNodeWasmThreads = useThreads
+          return runtime
+        })()
       }
 
       return runtimePromise
@@ -212,7 +271,9 @@
 
     function createWorkerProxy() {
       var indexScriptUrl = getIndexScriptUrl()
-      var runtimeScriptUrl = getRuntimeScriptUrl(indexScriptUrl)
+      var useThreads = shouldUseThreadedRuntime()
+      var runtimeScriptUrl = getRuntimeScriptUrl(indexScriptUrl, useThreads)
+      var wasmUrl = getWasmBinaryUrl(runtimeScriptUrl, useThreads)
       var workerScriptUrl = getWorkerScriptUrl(indexScriptUrl)
 
       if (!indexScriptUrl || !runtimeScriptUrl || !workerScriptUrl) {
@@ -220,6 +281,7 @@
       }
 
       var worker = new root.Worker(workerScriptUrl, {
+        type: 'module',
         name: 'whisper.node.wasm',
       })
       var proxy = {
@@ -323,6 +385,8 @@
         {
           indexScriptUrl: indexScriptUrl,
           runtimeScriptUrl: runtimeScriptUrl,
+          wasmPath: wasmUrl,
+          threads: useThreads,
           runtimeOptions: getWorkerRuntimeOptions(),
           locateFileBaseUrl:
             runtimeOptions.locateFileBaseUrl || resolveUrl('.', runtimeScriptUrl),
@@ -366,6 +430,39 @@
       throw new Error('fetch is required to load models or audio by URL')
     }
 
+    function getCacheStorage() {
+      return root.caches || null
+    }
+
+    function isModelCacheEnabled(options) {
+      return !options || options.cacheModel !== false
+    }
+
+    function getModelCacheName(options) {
+      return (
+        (options && options.modelCacheName) ||
+        runtimeOptions.modelCacheName ||
+        DEFAULT_MODEL_CACHE_NAME
+      )
+    }
+
+    function getModelCacheKey(source, options) {
+      var key = (options && options.modelCacheKey) || source
+      try {
+        return new URL(key, root.location && root.location.href).href
+      } catch (_) {
+        return key
+      }
+    }
+
+    function canUseModelCache(options) {
+      return (
+        isModelCacheEnabled(options) &&
+        !!getCacheStorage() &&
+        typeof root.Response === 'function'
+      )
+    }
+
     function formatBytes(bytes) {
       if (bytes >= 1024 * MIB) {
         return (bytes / (1024 * MIB)).toFixed(2) + ' GiB'
@@ -497,6 +594,106 @@
       return buffer
     }
 
+    async function readCachedModel(source, limit, options) {
+      if (!canUseModelCache(options)) {
+        return null
+      }
+
+      var cacheName = getModelCacheName(options)
+      var cacheKey = getModelCacheKey(source, options)
+
+      try {
+        var cache = await getCacheStorage().open(cacheName)
+        var response = await cache.match(cacheKey)
+        if (!response) {
+          return null
+        }
+
+        var buffer = await response.arrayBuffer()
+        if (limit) {
+          assertModelSize(buffer.byteLength, limit, source)
+        }
+        emitLog('INFO', 'Loaded cached WASM model: ' + source)
+        return {
+          buffer: buffer,
+          cacheHit: true,
+          cacheStored: false,
+          cacheName: cacheName,
+          cacheKey: cacheKey,
+        }
+      } catch (error) {
+        emitLog(
+          'WARN',
+          'Failed to read cached WASM model ' +
+            source +
+            ': ' +
+            (error && error.message ? error.message : String(error)),
+        )
+        return null
+      }
+    }
+
+    async function writeCachedModel(source, buffer, options) {
+      if (!canUseModelCache(options)) {
+        return {
+          cacheStored: false,
+          cacheName: null,
+          cacheKey: null,
+        }
+      }
+
+      var cacheName = getModelCacheName(options)
+      var cacheKey = getModelCacheKey(source, options)
+
+      try {
+        var cache = await getCacheStorage().open(cacheName)
+        await cache.put(
+          cacheKey,
+          new root.Response(buffer.slice(0), {
+            headers: {
+              'content-type': 'application/octet-stream',
+            },
+          }),
+        )
+        emitLog('INFO', 'Cached WASM model download: ' + source)
+        return {
+          cacheStored: true,
+          cacheName: cacheName,
+          cacheKey: cacheKey,
+        }
+      } catch (error) {
+        emitLog(
+          'WARN',
+          'Failed to cache WASM model ' +
+            source +
+            ': ' +
+            (error && error.message ? error.message : String(error)),
+        )
+        return {
+          cacheStored: false,
+          cacheName: cacheName,
+          cacheKey: cacheKey,
+        }
+      }
+    }
+
+    async function fetchModelArrayBuffer(source, limit, options) {
+      var cached = await readCachedModel(source, limit, options)
+      if (cached) {
+        return cached
+      }
+
+      var buffer = await fetchArrayBuffer(source, limit)
+      var cache = await writeCachedModel(source, buffer, options)
+      return {
+        buffer: buffer,
+        cacheHit: false,
+        cacheStored: cache.cacheStored,
+        cacheName: cache.cacheName,
+        cacheKey: cache.cacheKey,
+      }
+    }
+
     async function ensureModel(runtime, source, kind, options) {
       if (!source) {
         throw new Error('Model path is required')
@@ -510,8 +707,8 @@
       if (!modelCache[cacheKey]) {
         modelCache[cacheKey] = (async function () {
           var limit = getModelSizeLimit(runtime, options)
-          var buffer = await fetchArrayBuffer(source, limit)
-          var bytes = new Uint8Array(buffer)
+          var loaded = await fetchModelArrayBuffer(source, limit, options)
+          var bytes = new Uint8Array(loaded.buffer)
           var virtualPath =
             '/models/' + kind + '-' + hashString(source) + '-' + basenameFromUrl(source)
 
@@ -521,6 +718,10 @@
           return {
             virtualPath: virtualPath,
             bytes: bytes.byteLength,
+            cacheHit: loaded.cacheHit,
+            cacheStored: loaded.cacheStored,
+            cacheName: loaded.cacheName,
+            cacheKey: loaded.cacheKey,
           }
         })()
       }
@@ -562,8 +763,31 @@
       return value
     }
 
-    function normalizeTranscribeOptions(options) {
+    function normalizeMaxThreads(value, runtime) {
+      var maxThreads =
+        runtime && runtime.__whisperNodeWasmThreads !== true
+          ? 1
+          : MAX_WASM_THREADS
+      var nThreads = Number(value)
+      if (!Number.isFinite(nThreads) || nThreads <= 0) {
+        return null
+      }
+      return Math.max(1, Math.min(maxThreads, Math.floor(nThreads)))
+    }
+
+    function normalizeThreadOptions(options, runtime) {
       var normalized = Object.assign({}, options || {})
+      var maxThreads = normalizeMaxThreads(normalized.maxThreads, runtime)
+      if (maxThreads) {
+        normalized.maxThreads = maxThreads
+      } else {
+        delete normalized.maxThreads
+      }
+      return normalized
+    }
+
+    function normalizeTranscribeOptions(options, runtime) {
+      var normalized = normalizeThreadOptions(options, runtime)
       if (typeof normalized.onProgress !== 'function') {
         delete normalized.onProgress
       }
@@ -574,7 +798,7 @@
     }
 
     function splitTranscribeOptions(options) {
-      var normalized = Object.assign({}, options || {})
+      var normalized = normalizeThreadOptions(options)
       var callbacks = {}
 
       if (typeof normalized.onProgress === 'function') {
@@ -966,6 +1190,10 @@
         useGpu: useGpu,
         useFlashAttn: options.useFlashAttn === true,
         bytes: model.bytes,
+        cacheHit: model.cacheHit,
+        cacheStored: model.cacheStored,
+        cacheName: model.cacheName,
+        cacheKey: model.cacheKey,
         wasm: true,
       })
     }
@@ -1005,7 +1233,7 @@
           await runtime.__wasm_transcribe(
             id,
             audio,
-            normalizeTranscribeOptions(options),
+            normalizeTranscribeOptions(options, runtime),
           ),
         )
         if (isCancelled && isCancelled()) {
@@ -1054,7 +1282,8 @@
 
     WhisperContextInstance.prototype.bench = async function (nThreads) {
       this._assertValid()
-      return unwrapWasmResult(await this._runtime.__wasm_bench(this._id, nThreads || 1))
+      var threads = normalizeMaxThreads(nThreads || 1, this._runtime) || 1
+      return unwrapWasmResult(await this._runtime.__wasm_bench(this._id, threads))
     }
 
     WhisperContextInstance.prototype.release = function () {
@@ -1148,7 +1377,7 @@
       var modelSource = options.filePath || options.modelUrl
       var runtime = await loadRuntime()
       var useGpu = false
-      var nThreads = options.nThreads || 1
+      var nThreads = normalizeMaxThreads(options.nThreads || 1, runtime) || 1
 
       if (options.useGpu === true) {
         emitLog(
@@ -1168,6 +1397,10 @@
         useGpu: useGpu,
         nThreads: init.nThreads,
         bytes: model.bytes,
+        cacheHit: model.cacheHit,
+        cacheStored: model.cacheStored,
+        cacheName: model.cacheName,
+        cacheKey: model.cacheKey,
         wasm: true,
       })
     }
@@ -1240,11 +1473,35 @@
       initWhisperVad: initWhisperVad,
       toggleNativeLog: toggleNativeLog,
       addNativeLogListener: addNativeLogListener,
+      isWasmThreadsSupported: isWasmThreadsSupported,
       DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES: 1500 * MIB,
+      MAX_WASM_THREADS: MAX_WASM_THREADS,
+      WASM_CONFIG_PATHS: WASM_CONFIG_PATHS,
     }
 
     api.default = api
 
     return api
-  },
-)
+  }
+
+const api = createWhisperNodeApi(root)
+
+export const WhisperContext = api.WhisperContext
+export const WhisperVadContext = api.WhisperVadContext
+export const DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES =
+  api.DEFAULT_WASM_MODEL_SIZE_LIMIT_BYTES
+export const MAX_WASM_THREADS = api.MAX_WASM_THREADS
+export const configureWasm = api.configureWasm
+export const loadWasmModule = api.loadWasmModule
+export const loadWhisperModule = api.loadWhisperModule
+export const initWhisper = api.initWhisper
+export const initWhisperVad = api.initWhisperVad
+export const toggleNativeLog = api.toggleNativeLog
+export const addNativeLogListener = api.addNativeLogListener
+export const isWasmThreadsSupported = api.isWasmThreadsSupported
+
+if (root) {
+  root.WhisperNodeWasm = api
+}
+
+export default api

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@fugood/node-whisper-wasm",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Browser WASM module for whisper.node",
+  "type": "module",
   "main": "index.js",
   "browser": "index.js",
   "types": "index.d.ts",
@@ -39,8 +40,10 @@
     "index.js",
     "index.d.ts",
     "README.md",
-    "whisper-node.js",
     "worker.js",
-    "whisper-node.wasm"
+    "wasm/whisper-node.js",
+    "wasm/whisper-node.wasm",
+    "wasm/whisper-node.threads.js",
+    "wasm/whisper-node.threads.wasm"
   ]
-}
+}