@remotion/whisper-webgpu 4.0.526 → 4.0.528

package/dist/download-whisper-model.d.ts

@@ -0,0 +1,16 @@
+import { type WhisperWebGpuModel } from './models';
+export type WhisperModelDownloadProgress = {
+    file: string | null;
+    progress: number;
+    loadedBytes: number;
+    totalBytes: number;
+};
+export type DownloadWhisperModelOptions = {
+    model: WhisperWebGpuModel;
+    onProgress?: (progress: WhisperModelDownloadProgress) => void;
+    signal?: AbortSignal;
+};
+export type DownloadWhisperModelResult = {
+    alreadyDownloaded: boolean;
+};
+export declare const downloadWhisperModel: ({ model, onProgress, signal, }: DownloadWhisperModelOptions) => Promise<DownloadWhisperModelResult>;

package/dist/esm/index.mjs

@@ -14,6 +14,16 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -22,6 +32,159 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/import-node-module.ts
+var importNodeModule = (specifier) => {
+  const dynamicImport = new Function("specifier", "return import(specifier)");
+  return dynamicImport(specifier);
+};
+
+// src/probe-node-webgpu.ts
+var exports_probe_node_webgpu = {};
+__export(exports_probe_node_webgpu, {
+  probeNodeWebGpu: () => probeNodeWebGpu
+});
+var webGpuProbeModel, probeNodeWebGpu = async () => {
+  const { InferenceSession } = await importNodeModule("onnxruntime-node");
+  const session = await InferenceSession.create(webGpuProbeModel, {
+    executionProviders: ["webgpu"]
+  });
+  await session.release();
+};
+var init_probe_node_webgpu = __esm(() => {
+  webGpuProbeModel = new Uint8Array([
+    8,
+    3,
+    18,
+    6,
+    99,
+    104,
+    101,
+    110,
+    116,
+    97,
+    58,
+    112,
+    10,
+    21,
+    10,
+    1,
+    88,
+    10,
+    1,
+    87,
+    18,
+    1,
+    89,
+    26,
+    5,
+    109,
+    117,
+    108,
+    95,
+    49,
+    34,
+    3,
+    77,
+    117,
+    108,
+    18,
+    8,
+    109,
+    117,
+    108,
+    32,
+    116,
+    101,
+    115,
+    116,
+    42,
+    35,
+    8,
+    3,
+    8,
+    2,
+    16,
+    1,
+    34,
+    24,
+    0,
+    0,
+    128,
+    63,
+    0,
+    0,
+    0,
+    64,
+    0,
+    0,
+    64,
+    64,
+    0,
+    0,
+    128,
+    64,
+    0,
+    0,
+    160,
+    64,
+    0,
+    0,
+    192,
+    64,
+    66,
+    1,
+    87,
+    90,
+    19,
+    10,
+    1,
+    88,
+    18,
+    14,
+    10,
+    12,
+    8,
+    1,
+    18,
+    8,
+    10,
+    2,
+    8,
+    3,
+    10,
+    2,
+    8,
+    2,
+    98,
+    19,
+    10,
+    1,
+    89,
+    18,
+    14,
+    10,
+    12,
+    8,
+    1,
+    18,
+    8,
+    10,
+    2,
+    8,
+    3,
+    10,
+    2,
+    8,
+    2,
+    66,
+    4,
+    10,
+    0,
+    16,
+    7
+  ]);
+});
+
 // src/can-use-whisper-webgpu.ts
 var WhisperWebGpuUnsupportedReason;
 ((WhisperWebGpuUnsupportedReason2) => {
@@ -31,10 +194,24 @@ var WhisperWebGpuUnsupportedReason;
 })(WhisperWebGpuUnsupportedReason ||= {});
 var canUseWhisperWebGpu = async () => {
   if (typeof window === "undefined") {
+    if (typeof process !== "undefined" && process.release?.name === "node") {
+      try {
+        const { probeNodeWebGpu: probeNodeWebGpu2 } = await Promise.resolve().then(() => (init_probe_node_webgpu(), exports_probe_node_webgpu));
+        await probeNodeWebGpu2();
+        return { supported: true };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          supported: false,
+          reason: "webgpu-unavailable" /* WebGpuUnavailable */,
+          detailedReason: `ONNX Runtime could not initialize WebGPU: ${message}`
+        };
+      }
+    }
     return {
       supported: false,
       reason: "window-undefined" /* WindowUndefined */,
-      detailedReason: "`window` is not defined. @remotion/whisper-webgpu is intended for browser environments."
+      detailedReason: "WebGPU is not available in this environment."
     };
   }
   if (typeof navigator === "undefined" || !("gpu" in navigator)) {
@@ -253,6 +430,140 @@ var withRemotionModelHost = async (operation) => {
   }
 };
 
+// src/download-whisper-model.ts
+var downloadWhisperModel = async ({
+  model,
+  onProgress,
+  signal
+}) => {
+  signal?.throwIfAborted();
+  const totalBytes = getModelInfo(model).webGpuDownloadSize;
+  const hostedModelId = getHostedModelId(model);
+  const result = await withRemotionModelHost(async ({ env, ModelRegistry }) => {
+    signal?.throwIfAborted();
+    const cache = env.useCustomCache ? env.customCache : env.useBrowserCache && typeof caches !== "undefined" ? await caches.open(env.cacheKey) : null;
+    const useFileCache = cache === null && env.useFSCache;
+    if (cache === null && !useFileCache) {
+      throw new Error("A Transformers.js model cache is required to download a Whisper model.");
+    }
+    const registryOptions = {
+      device: "webgpu",
+      dtype: getWhisperWebGpuDtype(model)
+    };
+    const cacheStatus = await ModelRegistry.is_pipeline_cached_files("automatic-speech-recognition", hostedModelId, registryOptions);
+    signal?.throwIfAborted();
+    if (cacheStatus.allCached) {
+      onProgress?.({
+        file: null,
+        progress: 1,
+        loadedBytes: totalBytes,
+        totalBytes
+      });
+      return { alreadyDownloaded: true };
+    }
+    let loadedBytes = 0;
+    const emitProgress = (file) => {
+      onProgress?.({
+        file,
+        progress: Math.min(loadedBytes / totalBytes, 0.99),
+        loadedBytes,
+        totalBytes
+      });
+    };
+    emitProgress(null);
+    for (const { file, cached } of cacheStatus.files) {
+      signal?.throwIfAborted();
+      if (cached) {
+        continue;
+      }
+      const url = `${env.remoteHost}${env.remotePathTemplate.replace("{model}", hostedModelId)}${file}`;
+      const cacheKey = cache === null ? `${hostedModelId}/${file}` : url;
+      const response = await env.fetch(url, { signal });
+      if (!response.ok || response.body === null) {
+        throw new Error(`Could not download ${url}: HTTP ${response.status}.`);
+      }
+      const reader = response.body.getReader();
+      try {
+        if (cache !== null) {
+          const stream = new ReadableStream({
+            async pull(controller) {
+              try {
+                signal?.throwIfAborted();
+                const { done, value } = await reader.read();
+                signal?.throwIfAborted();
+                if (done) {
+                  controller.close();
+                  return;
+                }
+                loadedBytes += value.byteLength;
+                emitProgress(file);
+                signal?.throwIfAborted();
+                controller.enqueue(value);
+              } catch (error) {
+                controller.error(error);
+              }
+            },
+            cancel: () => reader.cancel()
+          });
+          await cache.put(cacheKey, new Response(stream, { headers: response.headers }));
+        } else {
+          const [{ mkdir, open, rename, unlink }, { join, dirname }, { randomUUID }] = await Promise.all([
+            importNodeModule("node:fs/promises"),
+            importNodeModule("node:path"),
+            importNodeModule("node:crypto")
+          ]);
+          if (env.cacheDir === null) {
+            throw new Error("Transformers.js env.cacheDir must be set.");
+          }
+          const destination = join(env.cacheDir, cacheKey);
+          const temporary = `${destination}.tmp.${randomUUID()}`;
+          await mkdir(dirname(destination), { recursive: true });
+          const handle = await open(temporary, "wx");
+          try {
+            while (true) {
+              signal?.throwIfAborted();
+              const { done, value } = await reader.read();
+              signal?.throwIfAborted();
+              if (done) {
+                break;
+              }
+              await handle.writeFile(value);
+              loadedBytes += value.byteLength;
+              emitProgress(file);
+            }
+            await handle.close();
+            signal?.throwIfAborted();
+            await rename(temporary, destination);
+          } catch (error) {
+            await handle.close();
+            await unlink(temporary);
+            throw error;
+          }
+        }
+      } finally {
+        await reader.cancel().catch(() => {});
+        reader.releaseLock();
+      }
+    }
+    signal?.throwIfAborted();
+    if (!await ModelRegistry.is_pipeline_cached("automatic-speech-recognition", hostedModelId, registryOptions)) {
+      throw new Error(`The Whisper model "${model}" was not fully cached.`);
+    }
+    signal?.throwIfAborted();
+    onProgress?.({
+      file: null,
+      progress: 1,
+      loadedBytes: totalBytes,
+      totalBytes
+    });
+    return { alreadyDownloaded: false };
+  }).catch((error) => {
+    signal?.throwIfAborted();
+    throw error;
+  });
+  signal?.throwIfAborted();
+  return result;
+};
 // src/is-whisper-model-cached.ts
 var isWhisperModelCached = ({
   model
@@ -264,14 +575,22 @@ var isWhisperModelCached = ({
     });
   });
 };
+// src/symbol-async-dispose.ts
+if (typeof Symbol.asyncDispose !== "symbol") {
+  Object.defineProperty(Symbol, "asyncDispose", {
+    value: Symbol.for("asyncDispose")
+  });
+}
+
 // src/load-whisper-model.ts
 var pipelines = new Map;
 var getOrCreateWhisperPipeline = ({
   model,
   onProgress
 }) => {
-  const modelInfo = getModelInfo(model);
-  const totalBytes = modelInfo.webGpuDownloadSize;
+  if (!getModelInfo(model)) {
+    throw new Error(`Unsupported Whisper model "${model}".`);
+  }
   const existing = pipelines.get(model);
   if (existing) {
     if (onProgress) {
@@ -299,7 +618,8 @@ var getOrCreateWhisperPipeline = ({
     activeTranscriptions: 0,
     onIdle: [],
     progressListeners,
-    latestProgress: null
+    latestProgress: null,
+    retainedLoadHandles: 0
   };
   const emitProgress = (progress) => {
     state.latestProgress = progress;
@@ -308,43 +628,30 @@ var getOrCreateWhisperPipeline = ({
     }
   };
   const loading = Promise.resolve().then(() => {
-    return withRemotionModelHost(({ pipeline }) => {
+    return withRemotionModelHost(async ({ ModelRegistry, pipeline }) => {
+      const hostedModelId = getHostedModelId(model);
+      if (!await ModelRegistry.is_pipeline_cached("automatic-speech-recognition", hostedModelId, { device: "webgpu", dtype: getWhisperWebGpuDtype(model) })) {
+        throw new Error(`The Whisper model "${model}" is not downloaded. Call downloadWhisperModel() first.`);
+      }
       emitProgress({
-        status: "loading",
+        status: "initializing",
         file: null,
-        progress: 0,
-        loadedBytes: 0,
-        totalBytes
+        progress: null,
+        loadedBytes: null,
+        totalBytes: null
       });
-      const hostedModelId = getHostedModelId(model);
-      const loadedByFile = new Map;
-      let lastProgress = 0;
-      let lastLoadedBytes = 0;
       return pipeline("automatic-speech-recognition", hostedModelId, {
         device: "webgpu",
         dtype: getWhisperWebGpuDtype(model),
         progress_callback: (event) => {
           const record = event;
-          if (record.status === "progress" && typeof record.file === "string" && typeof record.loaded === "number" && Number.isFinite(record.loaded)) {
-            loadedByFile.set(record.file, Math.max(loadedByFile.get(record.file) ?? 0, record.loaded));
-            const loadedBytes = [...loadedByFile.values()].reduce((sum, loaded) => sum + loaded, 0);
-            lastProgress = Math.max(lastProgress, Math.min(loadedBytes / totalBytes, 0.99));
-            lastLoadedBytes = Math.max(lastLoadedBytes, loadedBytes);
-            emitProgress({
-              status: "loading",
-              file: null,
-              progress: lastProgress,
-              loadedBytes: lastLoadedBytes,
-              totalBytes
-            });
-          }
           if (record.status === "ready") {
             emitProgress({
               status: "ready",
               file: null,
               progress: 1,
-              loadedBytes: Math.max(lastLoadedBytes, totalBytes),
-              totalBytes
+              loadedBytes: null,
+              totalBytes: null
             });
           }
         }
@@ -368,26 +675,77 @@ var getOrCreateWhisperPipeline = ({
     }
   };
 };
+var disposeWhisperPipelineState = async ({
+  model,
+  state
+}) => {
+  if (pipelines.get(model) !== state) {
+    return;
+  }
+  pipelines.delete(model);
+  const loadedPipeline = await state.loading;
+  if (state.activeTranscriptions > 0) {
+    await new Promise((resolve) => {
+      state.onIdle.push(resolve);
+    });
+  }
+  await loadedPipeline.dispose();
+};
 var loadWhisperModel = async ({
   model,
-  onProgress
+  onProgress,
+  signal
 }) => {
+  signal?.throwIfAborted();
   const { state, alreadyLoaded, unsubscribe } = getOrCreateWhisperPipeline({
     model,
-    onProgress
+    onProgress: (progress) => {
+      if (!signal?.aborted) {
+        onProgress?.(progress);
+      }
+    }
   });
+  state.retainedLoadHandles++;
   try {
     await state.loading;
+    signal?.throwIfAborted();
+  } catch (error) {
+    state.retainedLoadHandles--;
+    if (state.retainedLoadHandles === 0 && state.activeTranscriptions === 0) {
+      await disposeWhisperPipelineState({ model, state }).catch((disposeError) => {
+        signal?.throwIfAborted();
+        throw disposeError;
+      });
+    }
+    signal?.throwIfAborted();
+    throw error;
   } finally {
     unsubscribe();
   }
-  return { alreadyLoaded };
+  let released = false;
+  const result = { alreadyLoaded };
+  Object.defineProperty(result, Symbol.asyncDispose, {
+    enumerable: false,
+    value: async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      state.retainedLoadHandles--;
+      if (state.retainedLoadHandles === 0) {
+        await disposeWhisperPipelineState({ model, state });
+      }
+    }
+  });
+  return result;
 };
 var withLoadedWhisperPipeline = async ({
   model,
   onProgress,
+  signal,
   run
 }) => {
+  signal?.throwIfAborted();
   const { state, unsubscribe } = getOrCreateWhisperPipeline({
     model,
     onProgress
@@ -396,7 +754,11 @@ var withLoadedWhisperPipeline = async ({
   try {
     const loaded = await state.loading;
     unsubscribe();
+    signal?.throwIfAborted();
     return await run(loaded);
+  } catch (error) {
+    signal?.throwIfAborted();
+    throw error;
   } finally {
     unsubscribe();
     state.activeTranscriptions--;
@@ -404,6 +766,11 @@ var withLoadedWhisperPipeline = async ({
       for (const resolve of state.onIdle.splice(0)) {
         resolve();
       }
+      if (signal?.aborted && state.retainedLoadHandles === 0) {
+        await disposeWhisperPipelineState({ model, state }).catch(() => {
+          signal.throwIfAborted();
+        });
+      }
     }
   }
 };
@@ -413,19 +780,8 @@ var disposeWhisperModel = async ({
   const matching = [...pipelines.entries()].filter(([loadedModel]) => {
     return model === undefined || loadedModel === model;
   });
-  for (const [key, state] of matching) {
-    if (pipelines.get(key) === state) {
-      pipelines.delete(key);
-    }
-  }
-  await Promise.all(matching.map(async ([, state]) => {
-    const loadedPipeline = await state.loading;
-    if (state.activeTranscriptions > 0) {
-      await new Promise((resolve) => {
-        state.onIdle.push(resolve);
-      });
-    }
-    await loadedPipeline.dispose();
+  await Promise.all(matching.map(([key, state]) => {
+    return disposeWhisperPipelineState({ model: key, state });
   }));
 };
 // src/remove-whisper-model.ts
@@ -497,8 +853,10 @@ var transcribe = async ({
   topK = 50,
   repetitionPenalty = 1,
   noRepeatNgramSize = 0,
-  onModelLoadProgress
+  onModelLoadProgress,
+  signal
 }) => {
+  signal?.throwIfAborted();
   if (channelWaveform.length === 0) {
     throw new Error("The audio waveform is empty.");
   }
@@ -542,7 +900,22 @@ var transcribe = async ({
   const output = await withLoadedWhisperPipeline({
     model,
     onProgress: onModelLoadProgress,
+    signal: signal ?? null,
     run: async (transcriber) => {
+      let logitsProcessor = null;
+      if (signal) {
+        const { LogitsProcessor, LogitsProcessorList } = await import("@huggingface/transformers");
+
+        class AbortLogitsProcessor extends LogitsProcessor {
+          _call(_inputIds, logits) {
+            signal?.throwIfAborted();
+            return logits;
+          }
+        }
+        logitsProcessor = new LogitsProcessorList;
+        logitsProcessor.push(new AbortLogitsProcessor);
+      }
+      signal?.throwIfAborted();
       return await transcriber(channelWaveform, {
         return_timestamps: "word",
         chunk_length_s: chunkLengthInSeconds,
@@ -553,10 +926,12 @@ var transcribe = async ({
         top_k: topK,
         repetition_penalty: repetitionPenalty,
         no_repeat_ngram_size: noRepeatNgramSize,
+        ...logitsProcessor ? { logits_processor: logitsProcessor } : {},
         ...multilingual ? { language, task } : {}
       });
     }
   });
+  signal?.throwIfAborted();
   if (!output.chunks) {
     throw new Error("The model did not return word-level timestamps. Use one of the timestamped models returned by getAvailableModels().");
   }
@@ -594,6 +969,7 @@ export {
   loadWhisperModel,
   isWhisperModelCached,
   getAvailableModels,
+  downloadWhisperModel,
   disposeWhisperModel,
   clearStaleModels,
   canUseWhisperWebGpu,

package/dist/import-node-module.d.ts

@@ -0,0 +1 @@
+export declare const importNodeModule: <T>(specifier: string) => Promise<T>;

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { WhisperWebGpuUnsupportedReason, canUseWhisperWebGpu, } from './can-use-whisper-webgpu';
 export type { CanUseWhisperWebGpuResult } from './can-use-whisper-webgpu';
 export { clearStaleModels } from './clear-stale-models';
+export { downloadWhisperModel } from './download-whisper-model';
+export type { DownloadWhisperModelOptions, DownloadWhisperModelResult, WhisperModelDownloadProgress, } from './download-whisper-model';
 export { isWhisperModelCached } from './is-whisper-model-cached';
 export type { IsWhisperModelCachedOptions } from './is-whisper-model-cached';
 export { disposeWhisperModel, loadWhisperModel } from './load-whisper-model';

package/dist/load-whisper-model.d.ts

@@ -1,3 +1,4 @@
+import './symbol-async-dispose';
 import { type WhisperWebGpuModel } from './models';
 export type WhisperWebGpuModelLoadProgress = {
     status: string;
@@ -14,14 +15,16 @@ type LoadedWhisperPipeline = {
 export type LoadWhisperModelOptions = {
     model: WhisperWebGpuModel;
     onProgress?: OnWhisperWebGpuModelLoadProgress;
+    signal?: AbortSignal;
 };
-export type LoadWhisperModelResult = {
+export type LoadWhisperModelResult = AsyncDisposable & {
     alreadyLoaded: boolean;
 };
-export declare const loadWhisperModel: ({ model, onProgress, }: LoadWhisperModelOptions) => Promise<LoadWhisperModelResult>;
-export declare const withLoadedWhisperPipeline: <ReturnValue>({ model, onProgress, run, }: {
+export declare const loadWhisperModel: ({ model, onProgress, signal, }: LoadWhisperModelOptions) => Promise<LoadWhisperModelResult>;
+export declare const withLoadedWhisperPipeline: <ReturnValue>({ model, onProgress, signal, run, }: {
     model: "base" | "base.en" | "large-v3-turbo" | "medium" | "medium.en" | "small" | "small.en" | "tiny" | "tiny.en";
     onProgress?: OnWhisperWebGpuModelLoadProgress | undefined;
+    signal: AbortSignal | null;
     run: (pipeline: LoadedWhisperPipeline) => Promise<ReturnValue>;
 }) => Promise<ReturnValue>;
 export type DisposeWhisperModelOptions = {

package/dist/probe-node-webgpu.d.ts

@@ -0,0 +1 @@
+export declare const probeNodeWebGpu: () => Promise<void>;

package/dist/transcribe.d.ts

@@ -25,5 +25,6 @@ export type TranscribeOptions = {
     repetitionPenalty?: number;
     noRepeatNgramSize?: number;
     onModelLoadProgress?: OnWhisperWebGpuModelLoadProgress;
+    signal?: AbortSignal;
 };
-export declare const transcribe: ({ channelWaveform, model, language, task, chunkLengthInSeconds, strideLengthInSeconds, forceFullSequences, doSample, temperature, topK, repetitionPenalty, noRepeatNgramSize, onModelLoadProgress, }: TranscribeOptions) => Promise<WhisperWebGpuTranscription>;
+export declare const transcribe: ({ channelWaveform, model, language, task, chunkLengthInSeconds, strideLengthInSeconds, forceFullSequences, doSample, temperature, topK, repetitionPenalty, noRepeatNgramSize, onModelLoadProgress, signal, }: TranscribeOptions) => Promise<WhisperWebGpuTranscription>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/whisper-webgpu",
-	"version": "4.0.526",
+	"version": "4.0.528",
 	"description": "Transcribe audio in the browser using Whisper and WebGPU",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -24,10 +24,11 @@
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
 	"dependencies": {
-		"@remotion/captions": "4.0.526"
+		"@remotion/captions": "4.0.528",
+		"onnxruntime-node": "1.24.3"
 	},
 	"peerDependencies": {
-		"@huggingface/transformers": "4.3.0"
+		"@huggingface/transformers": "4.2.0"
 	},
 	"exports": {
 		".": {
@@ -38,8 +39,8 @@
 		"./package.json": "./package.json"
 	},
 	"devDependencies": {
-		"@huggingface/transformers": "4.3.0",
-		"@remotion/eslint-config-internal": "4.0.526",
+		"@huggingface/transformers": "4.2.0",
+		"@remotion/eslint-config-internal": "4.0.528",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1",
 		"eslint": "9.19.0"
 	},