echogarden 2.10.2 → 3.0.0

package/dist/recognition/WhisperSTT.js

@@ -1,26 +1,25 @@
 import chalk from 'chalk';
+import { getRawAudioDuration } from '../audio/AudioUtilities.js';
+import { formatLanguageCodeWithName, getShortLanguageCode, languageCodeToName } from '../utilities/Locale.js';
 import { Logger } from '../utilities/Logger.js';
-import { computeMelSpectrogramUsingFilterbanks } from '../dsp/MelSpectrogram.js';
-import { clip, getIntegerRange, getTopKIndexes, splitFloat32Array, yieldToEventLoop } from '../utilities/Utilities.js';
-import { indexOfMax, logOfVector, logSumExp, meanOfVector, medianOfVector, softmax, sumAndSumOfSquaresOfVector } from '../math/VectorMath.js';
-import { alignDTWWindowed } from '../alignment/DTWSequenceAlignmentWindowed.js';
 import { extendDeep } from '../utilities/ObjectUtilities.js';
-import { getRawAudioDuration, sliceRawAudio } from '../audio/AudioUtilities.js';
-import { readFileAsUtf8 } from '../utilities/FileSystem.js';
-import { logLevelGreaterOrEqualTo } from '../api/API.js';
-import { formatLanguageCodeWithName, getShortLanguageCode, languageCodeToName } from '../utilities/Locale.js';
-import { loadPackage } from '../utilities/PackageManager.js';
 import { XorShift32PRNG } from '../utilities/RandomGenerator.js';
-import { detectSpeechLanguageByParts } from '../api/SpeechLanguageDetection.js';
-import { includesPunctuation, isWhitespace, splitToWords } from '../nlp/Segmentation.js';
-import { medianOf5Filter } from '../math/MedianFilter.js';
-import { getDeflateCompressionMetricsForString } from '../utilities/Compression.js';
-import { dmlProviderAvailable, getOnnxSessionOptions, makeOnnxLikeFloat32Tensor } from '../utilities/OnnxUtilities.js';
 import { murmurHash3_int32Input } from '../utilities/Hashing.js';
+import { WhisperCppContext, WhisperAlignmentHeadsPreset, whisperModelIdToTextLayerCount, whisperModelIdToAlignmentHeadsPreset, GgmlLogLevel } from '@echogarden/whisper.cpp-binding';
+import { getDeflateCompressionMetricsForString } from '../utilities/Compression.js';
+import { indexOfMax, meanOfVector, medianOfVector, softmax, sumAndSumOfSquaresOfVector, sumVector } from '../math/VectorMath.js';
+import { loadPackage } from '../utilities/PackageManager.js';
+import { joinPath, resolvePath } from '../utilities/PathUtilities.js';
+import { readFileAsUtf8 } from '../utilities/FileSystem.js';
+import { clip, concatUint8Arrays, getIntegerRange, getTopKIndexes, yieldToEventLoop } from '../utilities/Utilities.js';
 import { containsInvalidCodepoint, getTokenRepetitionScore } from '../utilities/StringUtilities.js';
-import { joinPath } from '../utilities/PathUtilities.js';
+import { alignDTWWindowed } from '../alignment/DTWSequenceAlignmentWindowed.js';
+import { medianOf5Filter } from '../math/MedianFilter.js';
+import { includesPunctuation, isAllWhitespace, splitToWords } from '../nlp/Segmentation.js';
 import { Timer } from '../utilities/Timer.js';
-export async function recognize(sourceRawAudio, modelName, modelDir, task, sourceLanguage, options, onPart) {
+import { computeMelSpectrogramUsingFilterbank } from '../dsp/MelSpectrogram.js';
+import { detectSpeechLanguageByParts } from '../api/SpeechLanguageDetection.js';
+export async function recognize(sourceRawAudio, modelId, modelPath, libPath, task, sourceLanguage, options, callbacks) {
     options = extendDeep(defaultWhisperOptions, options);
     if (sourceRawAudio.sampleRate !== 16000) {
         throw new Error('Source audio must have a sample rate of 16000 Hz');
@@ -29,10 +28,10 @@ export async function recognize(sourceRawAudio, modelName, modelDir, task, sourc
     if (!(sourceLanguage in languageIdLookup)) {
         throw new Error(`The language ${formatLanguageCodeWithName(sourceLanguage)} is not supported by the Whisper engine.`);
     }
-    if (isEnglishOnlyModel(modelName) && sourceLanguage !== 'en') {
-        throw new Error(`The model '${modelName}' can only be used with English inputs. However, the given source language was ${languageCodeToName(sourceLanguage)}.`);
+    if (isEnglishOnlyModel(modelId) && sourceLanguage !== 'en') {
+        throw new Error(`The model '${modelId}' can only be used with English inputs. However, the given source language was ${languageCodeToName(sourceLanguage)}.`);
     }
-    if (modelName === 'large-v3-turbo' && task === 'translate') {
+    if (modelId === 'large-v3-turbo' && task === 'translate') {
         throw new Error(`The 'large-v3-turbo' model doesn't support translation tasks.`);
     }
     if (options.temperature && options.temperature < 0) {
@@ -40,19 +39,15 @@ export async function recognize(sourceRawAudio, modelName, modelDir, task, sourc
     }
     // Workaround issue with large-v3-turbo that produces invalid results when a prompt is passed to it.
     // Always disable autoprompting for that model.
-    if (options.autoPromptParts && modelName === 'large-v3-turbo') {
+    if (options.autoPromptParts && modelId === 'large-v3-turbo') {
         options.autoPromptParts = false;
     }
-    // Select encoder ONNX provider
-    const encoderProviders = options.encoderProvider ? [options.encoderProvider] : getDefaultEncoderProvidersForModel(modelName);
-    // Select decoder ONNX provider
-    const decoderProviders = options.decoderProvider ? [options.decoderProvider] : getDefaultDecoderProvidersForModel(modelName);
     const seed = options.seed;
-    const whisper = new Whisper(modelName, modelDir, encoderProviders, decoderProviders, seed);
-    const result = await whisper.recognize(sourceRawAudio, task, sourceLanguage, options, undefined, onPart);
+    const whisper = new Whisper(modelId, modelPath, libPath, seed);
+    const result = await whisper.recognize(sourceRawAudio, task, sourceLanguage, options, undefined, callbacks);
     return result;
 }
-export async function align(sourceRawAudio, transcript, modelName, modelDir, sourceLanguage, options) {
+export async function align(sourceRawAudio, transcript, modelId, modelPath, libPath, sourceLanguage, options, callbacks) {
     options = extendDeep(defaultWhisperAlignmentOptions, options);
     if (sourceRawAudio.sampleRate !== 16000) {
         throw new Error('Source audio must have a sample rate of 16000 Hz');
@@ -61,18 +56,14 @@ export async function align(sourceRawAudio, transcript, modelName, modelDir, sou
     if (!(sourceLanguage in languageIdLookup)) {
         throw new Error(`The language ${formatLanguageCodeWithName(sourceLanguage)} is not supported by the Whisper engine.`);
     }
-    if (isEnglishOnlyModel(modelName) && sourceLanguage !== 'en') {
-        throw new Error(`The model '${modelName}' can only be used with English inputs. However, the given source language was ${languageCodeToName(sourceLanguage)}.`);
+    if (isEnglishOnlyModel(modelId) && sourceLanguage !== 'en') {
+        throw new Error(`The model '${modelId}' can only be used with English inputs. However, the given source language was ${languageCodeToName(sourceLanguage)}.`);
     }
-    // Select encoder ONNX provider
-    const encoderProviders = options.encoderProvider ? [options.encoderProvider] : getDefaultEncoderProvidersForModel(modelName);
-    // Select decoder ONNX provider
-    const decoderProviders = options.decoderProvider ? [options.decoderProvider] : getDefaultDecoderProvidersForModel(modelName);
-    const whisper = new Whisper(modelName, modelDir, encoderProviders, decoderProviders);
-    const timeline = await whisper.align(sourceRawAudio, transcript, sourceLanguage, 'transcribe', options);
+    const whisper = new Whisper(modelId, modelPath, libPath);
+    const timeline = await whisper.align(sourceRawAudio, transcript, sourceLanguage, 'transcribe', options, callbacks);
     return timeline;
 }
-export async function alignEnglishTranslation(sourceRawAudio, translatedTranscript, modelName, modelDir, sourceLanguage, options) {
+export async function alignEnglishTranslation(sourceRawAudio, translatedTranscript, modelId, modelPath, libPath, sourceLanguage, options, callbacks) {
     options = extendDeep(defaultWhisperAlignmentOptions, options);
     if (sourceRawAudio.sampleRate !== 16000) {
         throw new Error('Source audio must have a sample rate of 16000 Hz');
@@ -81,133 +72,58 @@ export async function alignEnglishTranslation(sourceRawAudio, translatedTranscri
     if (!(sourceLanguage in languageIdLookup)) {
         throw new Error(`The source language ${formatLanguageCodeWithName(sourceLanguage)} is not supported by the Whisper engine.`);
     }
-    if (modelName === 'large-v3-turbo') {
+    if (modelId === 'large-v3-turbo') {
         throw new Error(`The 'large-v3-turbo' model doesn't support translation tasks, so cannot be used for translation alignment.`);
     }
-    if (isEnglishOnlyModel(modelName)) {
+    if (isEnglishOnlyModel(modelId)) {
         throw new Error(`Translation alignment can only be done with multilingual models.`);
     }
-    // Select encoder ONNX provider
-    const encoderProviders = options.encoderProvider ? [options.encoderProvider] : getDefaultEncoderProvidersForModel(modelName);
-    // Select decoder ONNX provider
-    const decoderProviders = options.decoderProvider ? [options.decoderProvider] : getDefaultDecoderProvidersForModel(modelName);
-    const whisper = new Whisper(modelName, modelDir, encoderProviders, decoderProviders);
-    const timeline = await whisper.align(sourceRawAudio, translatedTranscript, sourceLanguage, 'translate', options);
+    const whisper = new Whisper(modelId, modelPath, libPath);
+    const timeline = await whisper.align(sourceRawAudio, translatedTranscript, sourceLanguage, 'translate', options, callbacks);
     return timeline;
 }
-export async function detectLanguage(sourceRawAudio, modelName, modelDir, options) {
+export async function detectLanguage(sourceRawAudio, modelId, modelPath, libPath, options, callbacks) {
     options = extendDeep(defaultWhisperLanguageDetectionOptions, options);
     if (sourceRawAudio.sampleRate !== 16000) {
         throw new Error('Source audio must have a sample rate of 16000 Hz');
     }
-    if (!isMultilingualModel(modelName)) {
+    if (!isMultilingualModel(modelId)) {
         throw new Error(`Language detection is only supported with multilingual models.`);
     }
     if (options.temperature < 0) {
         throw new Error(`Temperature cannot be negative`);
     }
-    // Select encoder ONNX provider
-    const encoderProviders = options.encoderProvider ? [options.encoderProvider] : getDefaultEncoderProvidersForModel(modelName);
-    // Select decoder ONNX provider
-    const decoderProviders = options.decoderProvider ? [options.decoderProvider] : [];
-    const whisper = new Whisper(modelName, modelDir, encoderProviders, decoderProviders);
+    const whisper = new Whisper(modelId, modelPath, libPath);
     async function detectLanguageForPart(partAudio) {
-        const audioFeatures = await whisper.encodeAudio(partAudio);
-        const partResults = await whisper.detectLanguage(audioFeatures, options.temperature);
+        const partResults = await whisper.detectLanguage(partAudio, options, callbacks);
         return partResults;
     }
-    const results = await detectSpeechLanguageByParts(sourceRawAudio, detectLanguageForPart);
+    const results = await detectSpeechLanguageByParts(sourceRawAudio, detectLanguageForPart, undefined, undefined, callbacks);
     results.sort((entry1, entry2) => entry2.probability - entry1.probability);
     return results;
 }
-export async function detectVoiceActivity(sourceRawAudio, modelName, modelDir, options) {
-    options = extendDeep(defaultWhisperVADOptions, options);
-    if (sourceRawAudio.sampleRate !== 16000) {
-        throw new Error('Source audio must have a sample rate of 16000 Hz');
-    }
-    if (options.temperature < 0) {
-        throw new Error(`Temperature cannot be negative`);
-    }
-    const audioSamples = sourceRawAudio.audioChannels[0];
-    const partDuration = 5;
-    const maxSamplesCountForPart = sourceRawAudio.sampleRate * partDuration;
-    // Select encoder ONNX provider
-    const encoderProviders = options.encoderProvider ? [options.encoderProvider] : getDefaultEncoderProvidersForModel(modelName);
-    // Select decoder ONNX provider
-    const decoderProviders = options.decoderProvider ? [options.decoderProvider] : [];
-    const whisper = new Whisper(modelName, modelDir, encoderProviders, decoderProviders);
-    const partProbabilities = [];
-    for (let sampleOffset = 0; sampleOffset < audioSamples.length; sampleOffset += maxSamplesCountForPart) {
-        const partSamples = sliceRawAudio(sourceRawAudio, sampleOffset, sampleOffset + maxSamplesCountForPart);
-        const samplesCountForPart = partSamples.audioChannels[0].length;
-        const startTime = sampleOffset / sourceRawAudio.sampleRate;
-        const endTime = (sampleOffset + samplesCountForPart) / sourceRawAudio.sampleRate;
-        const encodedPartSamples = await whisper.encodeAudio(partSamples);
-        const probabilityForPart = await whisper.detectVoiceActivity(encodedPartSamples, options.temperature);
-        partProbabilities.push({
-            type: 'segment',
-            text: '',
-            startTime,
-            endTime,
-            confidence: probabilityForPart,
-        });
-    }
-    return { partProbabilities };
-}
 export class Whisper {
-    modelName;
-    modelDir;
-    encoderExecutionProviders;
-    decoderExecutionProviders;
+    modelId;
+    modelPath;
+    libPath;
     isMultiligualModel;
-    audioEncoder;
-    textDecoder;
     tiktoken;
-    tokenConfig;
+    context;
+    specialTokens;
     randomGen;
-    constructor(modelName, modelDir, encoderExecutionProviders, decoderExecutionProviders, prngSeed = 1234) {
-        this.modelName = modelName;
-        this.modelDir = modelDir;
-        this.encoderExecutionProviders = encoderExecutionProviders;
-        this.decoderExecutionProviders = decoderExecutionProviders;
-        this.isMultiligualModel = isMultilingualModel(this.modelName);
-        if (this.isMultiligualModel) {
-            this.tokenConfig = {
-                endOfTextToken: 50257,
-                startOfTextToken: 50258,
-                languageTokensStart: 50259,
-                languageTokensEnd: 50358,
-                translateTaskToken: 50358,
-                transcribeTaskToken: 50359,
-                startOfPromptToken: 50361,
-                nonSpeechToken: 50362,
-                noTimestampsToken: 50363,
-                timestampTokensStart: 50364,
-                timestampTokensEnd: 50364 + 1501,
-            };
-        }
-        else {
-            this.tokenConfig = {
-                endOfTextToken: 50256,
-                startOfTextToken: 50257,
-                languageTokensStart: 50258,
-                languageTokensEnd: 50358,
-                translateTaskToken: 50358,
-                transcribeTaskToken: 50359,
-                startOfPromptToken: 50360,
-                nonSpeechToken: 50361,
-                noTimestampsToken: 50362,
-                timestampTokensStart: 50363,
-                timestampTokensEnd: 50363 + 1501,
-            };
-        }
+    constructor(modelId, modelPath, libPath, prngSeed = 1234) {
+        this.modelId = modelId;
+        this.modelPath = modelPath;
+        this.libPath = libPath;
+        this.isMultiligualModel = isMultilingualModel(this.modelId);
+        this.specialTokens = this.isMultiligualModel ? multilingualSpecialTokens : englishOnlySpecialTokens;
         this.randomGen = new XorShift32PRNG(murmurHash3_int32Input(prngSeed));
     }
-    async recognize(rawAudio, task, language, options, logitFilter, onPart) {
-        await this.initializeIfNeeded();
-        const logger = new Logger();
+    async recognize(rawAudio, task, language, options, logitFilter, callbacks) {
+        await this.initializeIfNeeded(options, callbacks);
+        const logger = new Logger(callbacks.logLevel);
         options = extendDeep(defaultWhisperOptions, options);
-        options.model = this.modelName;
+        options.model = this.modelId;
         if (!options.timestampAccuracy) {
             options.timestampAccuracy = this.defaultTimestampAccuracy;
         }
@@ -230,13 +146,15 @@ export class Whisper {
             };
         }
         for (let audioOffset = 0; audioOffset < audioSamples.length;) {
+            callbacks?.abortSignal?.throwIfAborted();
             const segmentStartTime = audioOffset / sampleRate;
             await logger.startAsync(`\nPrepare audio part at time position ${segmentStartTime.toFixed(2)}`, undefined, chalk.magentaBright);
-            const audioPartSamples = audioSamples.slice(audioOffset, audioOffset + maxAudioSamplesPerPart);
+            const audioPartSamples = audioSamples.subarray(audioOffset, audioOffset + maxAudioSamplesPerPart);
             const audioPartRawAudio = { audioChannels: [audioPartSamples], sampleRate };
             const audioPartDuration = getRawAudioDuration(audioPartRawAudio);
             logger.end();
-            const audioPartFeatures = await this.encodeAudio(audioPartRawAudio);
+            await this.encodeSamples(audioPartSamples, false, options, callbacks);
+            await logger.startAsync(`Prepare prompt`);
             const isFirstPart = audioOffset === 0;
             const isFinalPart = audioOffset + maxAudioSamplesPerPart >= audioSamples.length;
             let initialTokens = [];
@@ -245,15 +163,15 @@ export class Whisper {
                 if (promptTokens.length > largestMaximumTokensPerPart) {
                     promptTokens = promptTokens.slice(promptTokens.length - largestMaximumTokensPerPart);
                 }
-                initialTokens = [this.tokenConfig.startOfPromptToken, ...promptTokens];
+                initialTokens = [this.specialTokens.startOfPromptToken, ...promptTokens];
             }
             else if (options.autoPromptParts && previousPartTextTokens.length > 0) {
-                initialTokens = [this.tokenConfig.startOfPromptToken, ...previousPartTextTokens];
+                initialTokens = [this.specialTokens.startOfPromptToken, ...previousPartTextTokens];
             }
             initialTokens = [...initialTokens, ...this.getTextStartTokens(language, task, !decodeTimestampTokens)];
             //logger.log(`Initial tokens count: ${initialTokens.length}`)
             logger.end();
-            let { decodedTokens: partTokens, decodedTokensConfidence: partTokensConfidence, decodedTokensCrossAttentionQKs: partTokensCrossAttentionQKs, decodedTokensDecodingTime: partTokensDecodingTime, decodedTokensInferenceTime: partTokensInferenceTime, decodedTokensOverheadTime: partTokensOverheadTime, } = await this.decodeTokens(audioPartFeatures, initialTokens, audioPartDuration, isFirstPart, isFinalPart, options, wrappedLogitFilter);
+            let { decodedTokens: partTokens, decodedTokensConfidence: partTokensConfidence, decodedTokensCrossAttentionQKs: partTokensCrossAttentionQKs, decodedTokensDecodingTime: partTokensDecodingTime, decodedTokensInferenceTime: partTokensInferenceTime, decodedTokensOverheadTime: partTokensOverheadTime, } = await this.decodeTokens(initialTokens, audioPartDuration, isFirstPart, isFinalPart, options, wrappedLogitFilter, callbacks);
             const lastToken = partTokens[partTokens.length - 1];
             const lastTokenIsTimestamp = this.isTimestampToken(lastToken);
             let audioEndOffset;
@@ -267,31 +185,19 @@ export class Whisper {
             const segmentEndTime = audioEndOffset / sampleRate;
             const segmentFrameCount = this.secondsRangeToFrameCount(segmentStartTime, segmentEndTime);
             await logger.startAsync(`Extract timeline for part (timestamp accuracy: ${options.timestampAccuracy})`);
-            if (partTokens.length !== partTokensCrossAttentionQKs.length) {
-                throw new Error('Unexpected: partTokens.length !== partCrossAttentionQKs.length');
-            }
             // Prepare tokens
             partTokens = partTokens.slice(initialTokens.length);
             partTokensConfidence = partTokensConfidence.slice(initialTokens.length);
             partTokensCrossAttentionQKs = partTokensCrossAttentionQKs.slice(initialTokens.length);
-            // Find alignment path
-            let alignmentHeads;
-            if (options.timestampAccuracy === 'medium' || options.model === 'large-v3-turbo') {
-                alignmentHeads = this.alignmentHeadIndexes;
-            }
-            else if (options.timestampAccuracy === 'high') {
-                alignmentHeads = undefined;
-            }
-            else {
-                throw new Error(`Unsupported timestamp accuracy '${options.timestampAccuracy}', can only be 'medium' or 'high'.`);
-            }
-            const alignmentPath = await this.findAlignmentPathFromQKs(partTokensCrossAttentionQKs, partTokens, 0, segmentFrameCount, alignmentHeads);
+            // Find alignment path using the cross attention query-key tensors
+            const alignmentHeadsIndexesToUse = undefined;
+            const alignmentPath = await this.findAlignmentPathFromCrossAttentionQKs(partTokensCrossAttentionQKs, partTokens, 0, segmentFrameCount, alignmentHeadsIndexesToUse);
             // Generate timeline from alignment path
             const partTimeline = await this.getTokenTimelineFromAlignmentPath(alignmentPath, partTokens, segmentStartTime, segmentEndTime, partTokensConfidence);
-            if (onPart) {
+            if (callbacks?.onPart) {
                 const partWordTimeline = this.tokenTimelineToWordTimeline(partTimeline, language);
                 const partTranscript = this.tokensToText(partTokens);
-                onPart(partTranscript, partTimeline, partWordTimeline);
+                callbacks.onPart(partTranscript, partTimeline, partWordTimeline);
             }
             // Add tokens to output
             allDecodedTokens.push(...partTokens);
@@ -309,12 +215,12 @@ export class Whisper {
             }
             audioOffset = audioEndOffset;
             logger.end();
-            if (logLevelGreaterOrEqualTo('trace')) {
-                const promptDecodingTime = partTokensDecodingTime[0];
+            if (logger.logLevelGreaterOrEqualTo('trace')) {
+                const promptProcessingTime = partTokensDecodingTime[0];
                 const medianTokenDecodingTime = medianOfVector(partTokensDecodingTime.slice(1));
                 const medianTokenInferenceTime = medianOfVector(partTokensInferenceTime.slice(1));
                 const medianOverheadTime = medianOfVector(partTokensOverheadTime.slice(1));
-                logger.log(`${chalk.blueBright('Context')}: ${initialTokens.length + partTokens.length} tokens (${initialTokens.length} prompt, ${partTokens.length} decoded)\n${chalk.blueBright('Prompt decode time')}: ${promptDecodingTime.toFixed(1)}ms\n${chalk.blueBright('Median token decode time')}: ${medianTokenDecodingTime.toFixed(1)}ms (${medianTokenInferenceTime.toFixed(1)}ms inference, ${medianOverheadTime.toFixed(2)}ms overhead)`, 'trace');
+                logger.log(`${chalk.blueBright('Context')}: ${initialTokens.length + partTokens.length} tokens (${initialTokens.length} prompt, ${partTokens.length} decoded)\n${chalk.blueBright('Prompt processing time')}: ${promptProcessingTime.toFixed(1)}ms\n${chalk.blueBright('Median token decode time')}: ${medianTokenDecodingTime.toFixed(1)}ms (${medianTokenInferenceTime.toFixed(1)}ms inference, ${medianOverheadTime.toFixed(2)}ms overhead)`, 'trace');
             }
         }
         // Convert token timeline to word timeline
@@ -324,8 +230,10 @@ export class Whisper {
         logger.end();
         return { transcript, timeline, allDecodedTokens };
     }
-    async align(rawAudio, transcript, sourceLanguage, task, whisperAlignmentOptions) {
-        await this.initializeTokenizerIfNeeded();
+    async align(rawAudio, transcript, sourceLanguage, task, whisperAlignmentOptions, callbacks) {
+        await this.initializeTokenizerIfNeeded(callbacks);
+        const logger = new Logger(callbacks.logLevel);
+        logger.start(`Tokenize transcript`);
         whisperAlignmentOptions = extendDeep(defaultWhisperAlignmentOptions, whisperAlignmentOptions);
         if (!whisperAlignmentOptions.timestampAccuracy) {
             whisperAlignmentOptions.timestampAccuracy = this.defaultTimestampAccuracy;
@@ -344,7 +252,7 @@ export class Whisper {
         const simplifiedTranscriptTokens = this.textToTokens(simplifiedTranscript);
         // Initialize custom logit filter that allows only the transcript tokens to be decoded
         // in order.
-        const endOfTextToken = this.tokenConfig.endOfTextToken;
+        const endOfTextToken = this.specialTokens.endOfTextToken;
         const logitFilter = (logits, decodedTokens, isFirstPart, isFinalPart) => {
             const decodedTextTokens = decodedTokens.filter(token => this.isTextToken(token));
             const nextTokenToDecode = simplifiedTranscriptTokens[decodedTextTokens.length] ?? endOfTextToken;
@@ -364,7 +272,10 @@ export class Whisper {
         };
         // Set options for alignment
         const options = {
-            model: this.modelName,
+            model: this.modelId,
+            enableGPU: whisperAlignmentOptions.enableGPU,
+            threadCount: whisperAlignmentOptions.threadCount,
+            gpuDeviceIndex: whisperAlignmentOptions.gpuDeviceIndex,
             temperature: 0.0,
             prompt: undefined,
             topCandidateCount: 1,
@@ -377,12 +288,11 @@ export class Whisper {
             endTokenThreshold: whisperAlignmentOptions.endTokenThreshold,
             includeEndTokenInCandidates: false,
             timestampAccuracy: whisperAlignmentOptions.timestampAccuracy,
-            encoderProvider: whisperAlignmentOptions.encoderProvider,
-            decoderProvider: whisperAlignmentOptions.decoderProvider,
             seed: undefined,
         };
+        logger.end();
         // Recognize
-        const { timeline, allDecodedTokens } = await this.recognize(rawAudio, task, sourceLanguage, options, logitFilter);
+        const { timeline, allDecodedTokens } = await this.recognize(rawAudio, task, sourceLanguage, options, logitFilter, callbacks);
         {
             // If not all tokens were decoded, add the remaining ones to the timeline
             const lastKnownWordStartTime = timeline.length > 0 ? timeline[timeline.length - 1].startTime : 0;
@@ -418,33 +328,28 @@ export class Whisper {
         }
         return timeline;
     }
-    async detectLanguage(audioFeatures, temperature) {
+    async detectLanguage(audioSamples, options, callbacks) {
         if (!this.isMultiligualModel) {
             throw new Error('Language detection is only supported with multilingual models');
         }
-        await this.initializeDecoderSessionIfNeeded();
+        if (audioSamples.sampleRate !== 16000) {
+            throw new Error('Sample rate must be 16000 Hz');
+        }
+        if (audioSamples.audioChannels.length !== 1) {
+            throw new Error('Audio must be mono');
+        }
+        await this.initializeContextIfNeeded(options, { logLevel: callbacks.logLevel });
         // Prepare and run decoder
-        const logger = new Logger();
+        const logger = new Logger(callbacks.logLevel);
         await logger.startAsync('Detect language with Whisper model');
-        const sotToken = this.tokenConfig.startOfTextToken;
-        const initialTokens = [sotToken];
-        const offset = 0;
-        const Onnx = await import('onnxruntime-node');
-        const initialKvDimensions = this.getKvDimensions(1, initialTokens.length);
-        const kvCacheTensor = new Onnx.Tensor('float32', new Float32Array(initialKvDimensions[0] * initialKvDimensions[1] * initialKvDimensions[2] * initialKvDimensions[3]), initialKvDimensions);
-        const tokensTensor = new Onnx.Tensor('int64', new BigInt64Array(initialTokens.map(token => BigInt(token))), [1, initialTokens.length]);
-        const offsetTensor = new Onnx.Tensor('int64', new BigInt64Array([BigInt(offset)]), []);
-        const decoderInputs = {
-            tokens: tokensTensor,
-            audio_features: audioFeatures,
-            kv_cache: kvCacheTensor,
-            offset: offsetTensor
-        };
-        const decoderOutputs = await this.textDecoder.run(decoderInputs);
-        const logitsBuffer = decoderOutputs['logits'].data;
-        const tokenConfig = this.tokenConfig;
-        const languageTokensLogits = Array.from(logitsBuffer.slice(tokenConfig.languageTokensStart, tokenConfig.languageTokensEnd));
-        const languageTokensProbabilities = softmax(languageTokensLogits, temperature);
+        logger.log(``);
+        await this.encodeSamples(audioSamples.audioChannels[0], undefined, options, callbacks);
+        const specialTokens = this.specialTokens;
+        const initialTokens = [specialTokens.startOfTextToken];
+        await this.context.decodeTokens(initialTokens, 0, options.threadCount);
+        const logits = this.context.getLogits();
+        const languageTokensLogits = logits.subarray(specialTokens.languageTokensStart, specialTokens.languageTokensEnd);
+        const languageTokensProbabilities = softmax(languageTokensLogits, options.temperature);
         const results = [];
         for (const language in languageIdLookup) {
             const langId = languageIdLookup[language];
@@ -458,58 +363,69 @@ export class Whisper {
         logger.end();
         return results;
     }
-    async detectVoiceActivity(audioFeatures, temperature) {
-        await this.initializeDecoderSessionIfNeeded();
-        // Prepare and run decoder
-        const logger = new Logger();
-        await logger.startAsync('Detect voice activity with Whisper model');
-        const sotToken = this.tokenConfig.startOfTextToken;
-        const initialTokens = [sotToken];
-        const offset = 0;
-        const Onnx = await import('onnxruntime-node');
-        const initialKvDimensions = this.getKvDimensions(1, initialTokens.length);
-        const kvCacheTensor = new Onnx.Tensor('float32', new Float32Array(initialKvDimensions[0] * initialKvDimensions[1] * initialKvDimensions[2] * initialKvDimensions[3]), initialKvDimensions);
-        const tokensTensor = new Onnx.Tensor('int64', new BigInt64Array(initialTokens.map(token => BigInt(token))), [1, initialTokens.length]);
-        const offsetTensor = new Onnx.Tensor('int64', new BigInt64Array([BigInt(offset)]), []);
-        const decoderInputs = {
-            tokens: tokensTensor,
-            audio_features: audioFeatures,
-            kv_cache: kvCacheTensor,
-            offset: offsetTensor
-        };
-        const decoderOutputs = await this.textDecoder.run(decoderInputs);
-        const logitsBuffer = decoderOutputs['logits'].data;
-        const tokenConfig = this.tokenConfig;
-        const logits = Array.from(logitsBuffer);
-        const probabilities = softmax(logits, temperature);
-        const noSpeechProbability = probabilities[tokenConfig.nonSpeechToken];
-        return 1.0 - noSpeechProbability;
+    async encodeSamples(samples, useCustomMelConverter = false, options, callbacks) {
+        const logger = new Logger(callbacks.logLevel);
+        if (useCustomMelConverter) {
+            await logger.startAsync('Extract Mel spectrogram from audio part');
+            // Compute Mel spectrogram
+            const sampleRate = 16000;
+            const rawAudio = { audioChannels: [samples], sampleRate: 16000 };
+            const fftOrder = 400;
+            const fftWindowSize = 400;
+            const fftHopLength = 160;
+            const melBandCount = this.melBandCount;
+            const melFilterbank = this.melFilterbank;
+            const maxAudioSamples = sampleRate * 30;
+            const maxFrameCount = 3000;
+            const { melSpectrogram } = await computeMelSpectrogramUsingFilterbank(rawAudio, fftOrder, fftWindowSize, fftHopLength, melFilterbank, undefined, callbacks);
+            const frameCount = Math.min(melSpectrogram.length, maxFrameCount);
+            // Flatten, transpose, apply logarithm, and normalize Mel spectrogram
+            await logger.startAsync('Process Mel spectrogram');
+            const flattenedLogMelSpectrogram = new Float32Array(frameCount * melBandCount);
+            let maxLogMel = -Infinity;
+            for (let i = 0; i < melBandCount; i++) {
+                for (let j = 0; j < frameCount; j++) {
+                    const mel = melSpectrogram[j][i];
+                    const logMel = Math.log10(Math.max(mel, 1e-10));
+                    if (logMel > maxLogMel) {
+                        maxLogMel = logMel;
+                    }
+                    flattenedLogMelSpectrogram[(i * frameCount) + j] = logMel;
+                }
+            }
+            for (let i = 0; i < flattenedLogMelSpectrogram.length; i++) {
+                const logMel = flattenedLogMelSpectrogram[i];
+                const normalizedLogMel = (Math.max(logMel, maxLogMel - 8) + 4) / 4;
+                flattenedLogMelSpectrogram[i] = normalizedLogMel;
+            }
+            await logger.startAsync('Encode Mel spectrogram');
+            await this.context.encodeLogMelSpectrogram(flattenedLogMelSpectrogram, melBandCount);
+        }
+        else {
+            await logger.startAsync('Encode samples');
+            await this.context.encodeSamples(samples, options.threadCount);
+        }
+        logger.end();
     }
     // Decode tokens using the decoder model
-    async decodeTokens(audioFeatures, initialTokens, audioDuration, isFirstPart, isFinalPart, options, logitFilter) {
-        // Initialize
-        await this.initializeTokenizerIfNeeded();
-        await this.initializeDecoderSessionIfNeeded();
-        const logger = new Logger();
+    async decodeTokens(initialTokens, audioDuration, isFirstPart, isFinalPart, options, logitFilter, callbacks) {
+        const logger = new Logger(callbacks.logLevel);
         await logger.startAsync('Decode text tokens with Whisper decoder model');
         options = extendDeep(defaultWhisperOptions, options);
-        const Onnx = await import('onnxruntime-node');
         // Get token information
-        const endOfTextToken = this.tokenConfig.endOfTextToken;
-        const timestampTokensStart = this.tokenConfig.timestampTokensStart;
+        const endOfTextToken = this.specialTokens.endOfTextToken;
+        const timestampTokensStart = this.specialTokens.timestampTokensStart;
         const suppressedTextTokens = this.getSuppressedTextTokens();
         const suppressedMetadataTokens = this.getSuppressedMetadataTokens();
         const allowedPunctuationMarks = this.getAllowedPunctuationMarks();
         const spaceToken = this.textToTokens(' ')[0];
         // Initialize variables for decoding loop
         let decodedTokens = initialTokens.slice();
-        const initialKvDimensions = this.getKvDimensions(1, decodedTokens.length);
-        let kvCacheTensor = new Onnx.Tensor('float32', new Float32Array(initialKvDimensions[0] * initialKvDimensions[1] * initialKvDimensions[2] * initialKvDimensions[3]), initialKvDimensions);
         let decodedTokensTimestampLogits = [];
         let decodedTokensConfidence = [];
         let decodedTokensCrossAttentionQKs = [];
         for (let i = 0; i < decodedTokens.length; i++) {
-            decodedTokensTimestampLogits.push(new Array(1501)); // Should the length be 1500 instead?
+            decodedTokensTimestampLogits.push(new Float32Array(1501)); // Should the length be 1500 instead?
             decodedTokensConfidence.push(1.0);
             decodedTokensCrossAttentionQKs.push(undefined);
         }
@@ -517,58 +433,40 @@ export class Whisper {
         let timestampTokenSeenCount = 0;
         let bufferedTokensToPrint = [];
         // Define method to add a token to output
-        function addToken(tokenToAdd, timestampLogits, confidence, crossAttentionQKs) {
+        const addToken = (tokenToAdd, timestampLogits, confidence, crossAttentionQKs) => {
             decodedTokens.push(tokenToAdd);
             decodedTokensTimestampLogits.push(timestampLogits);
             decodedTokensConfidence.push(confidence);
             decodedTokensCrossAttentionQKs.push(crossAttentionQKs);
-        }
+            if (callbacks?.onToken) {
+                callbacks.onToken(tokenToAdd, this.tokenToBytes(tokenToAdd));
+            }
+        };
         const maxTokensPerPart = Math.min(options.maxTokensPerPart, largestMaximumTokensPerPart);
         let decodedTokensInferenceTime = [];
         let decodedTokensDecodingTime = [];
         const tokenDecodingTimeTimer = new Timer();
         // Start decoding loop
         for (let decodedTokenCount = 0; decodedTokenCount < maxTokensPerPart; decodedTokenCount++) {
+            callbacks?.abortSignal?.throwIfAborted();
             if (decodedTokenCount > 0) {
                 decodedTokensDecodingTime.push(tokenDecodingTimeTimer.getElapsedTimeAndRestart());
             }
             const isInitialState = decodedTokens.length === initialTokens.length;
             const atLeastOneTextTokenDecoded = decodedTokens.slice(initialTokens.length).some(token => this.isTextToken(token));
-            // If not in initial state, reshape KV Cache tensor to accomodate a new output token
-            if (!isInitialState) {
-                const dims = kvCacheTensor.dims;
-                const currentKvCacheGroups = splitFloat32Array(kvCacheTensor.data, dims[2] * dims[3]);
-                const reshapedKvCacheTensor = new Onnx.Tensor('float32', new Float32Array(dims[0] * dims[1] * (decodedTokens.length) * dims[3]), [dims[0], dims[1], decodedTokens.length, dims[3]]);
-                const reshapedKvCacheGroups = splitFloat32Array(reshapedKvCacheTensor.data, decodedTokens.length * dims[3]);
-                for (let i = 0; i < dims[0]; i++) {
-                    reshapedKvCacheGroups[i].set(currentKvCacheGroups[i]);
-                }
-                kvCacheTensor = reshapedKvCacheTensor;
-            }
             // Prepare values for decoder
             const tokensToDecode = isInitialState ? decodedTokens : [decodedTokens[decodedTokens.length - 1]];
             const offset = isInitialState ? 0 : decodedTokens.length;
-            const tokensTensor = new Onnx.Tensor('int64', new BigInt64Array(tokensToDecode.map(token => BigInt(token))), [1, tokensToDecode.length]);
-            const offsetTensor = new Onnx.Tensor('int64', new BigInt64Array([BigInt(offset)]), []);
-            const decoderInputs = {
-                tokens: tokensTensor,
-                audio_features: audioFeatures,
-                kv_cache: kvCacheTensor,
-                offset: offsetTensor
-            };
-            //// Infer with ONNX decoder model
-            const tokenInferenceTimeTimer = new Timer();
-            const decoderOutputs = await this.textDecoder.run(decoderInputs);
-            decodedTokensInferenceTime.push(tokenInferenceTimeTimer.elapsedTime);
-            // Extract decoder model results
-            const logitsBuffer = decoderOutputs['logits'].data;
-            kvCacheTensor = decoderOutputs['output_kv_cache'];
-            const crossAttentionQKsForTokenOnnx = decoderOutputs['cross_attention_qks'];
-            const crossAttentionQKsForToken = makeOnnxLikeFloat32Tensor(crossAttentionQKsForTokenOnnx);
-            crossAttentionQKsForTokenOnnx.dispose();
+            //// Infer
+            const tokenInferenceTimer = new Timer();
+            await this.context.decodeTokens(tokensToDecode, offset, options.threadCount);
+            decodedTokensInferenceTime.push(tokenInferenceTimer.elapsedTime);
+            // Get cross-attention QKs
+            //const getCrossAttentionQKsTimer = new Timer()
+            const tokenCrossAttentionQKs = await this.context.getCrossAttentionQKs();
+            //getCrossAttentionQKsTimer.logAndRestart('getCrossAttentionQKs')
             // Get logits
-            const resultLogitsFloatArrays = splitFloat32Array(logitsBuffer, logitsBuffer.length / decoderOutputs['logits'].dims[1]);
-            const allTokenLogits = Array.from(resultLogitsFloatArrays[resultLogitsFloatArrays.length - 1]);
+            const allTokenLogits = this.context.getLogits();
             // Suppress metadata tokens in the suppression set
             for (const suppressedTokenIndex of suppressedMetadataTokens) {
                 allTokenLogits[suppressedTokenIndex] = -Infinity;
@@ -577,7 +475,7 @@ export class Whisper {
                 // If in initial state, suppress end-of-text token
                 allTokenLogits[endOfTextToken] = -Infinity;
             }
-            const timestampTokenLogits = allTokenLogits.slice(timestampTokensStart);
+            const timestampTokenLogits = allTokenLogits.subarray(timestampTokensStart);
             const decodeTimestampTokenIfNeeded = () => {
                 // Try to decode a timestamp token, if needed
                 // If timestamp tokens is disabled in options, don't decode a timestamp
@@ -587,7 +485,7 @@ export class Whisper {
                 // If this is the first token in the part, unconditionally decode a timestamp token
                 // for time 0.0
                 if (isInitialState) {
-                    addToken(timestampTokensStart, timestampTokenLogits, 1.0, crossAttentionQKsForToken);
+                    addToken(timestampTokensStart, timestampTokenLogits, 1.0, tokenCrossAttentionQKs);
                     return true;
                 }
                 const previousTokenWasTimestamp = this.isTimestampToken(decodedTokens[decodedTokens.length - 1]);
@@ -600,20 +498,20 @@ export class Whisper {
                 }
                 // Derive token probabilities
                 const allTokenProbabilities = softmax(allTokenLogits, 1.0);
-                const allTokenLogProbabilities = logOfVector(allTokenProbabilities);
-                const nonTimestampTokenLogProbs = allTokenLogProbabilities.slice(0, timestampTokensStart);
-                // Find highest non-timestamp token
-                const indexOfMaxNonTimestampLogProb = indexOfMax(nonTimestampTokenLogProbs);
-                const valueOfMaxNonTimestampLogProb = nonTimestampTokenLogProbs[indexOfMaxNonTimestampLogProb];
-                // Find highest timestamp token
-                const timestampTokenLogProbs = allTokenLogProbabilities.slice(timestampTokensStart);
-                const indexOfMaxTimestampLogProb = indexOfMax(timestampTokenLogProbs);
-                // Compute the log of the sum of exponentials of the log probabilities
-                // of the timestamp tokens
-                const logSumExpOfTimestampTokenLogProbs = logSumExp(timestampTokenLogProbs);
+                const nonTimestampTokenProbs = allTokenProbabilities.subarray(0, timestampTokensStart);
+                // Find highest probability non-timestamp token
+                const indexOfMaxNonTimestampProb = indexOfMax(nonTimestampTokenProbs);
+                const valueOfMaxNonTimestampProb = nonTimestampTokenProbs[indexOfMaxNonTimestampProb];
+                const valueOfMaxNonTimestampLogProb = Math.log(valueOfMaxNonTimestampProb);
+                // Find highest probability timestamp token
+                const timestampTokenProbs = allTokenProbabilities.subarray(timestampTokensStart);
+                const indexOfMaxTimestampProb = indexOfMax(timestampTokenProbs);
+                // Compute the log of the sum of probabilities of the timestamp tokens
+                const sumOfTimestampTokenProbs = sumVector(timestampTokenProbs);
+                const logSumOfTimestampTokenProbs = Math.log(sumOfTimestampTokenProbs);
                 // If the sum isn't greater than the log probability of the highest non-timestamp token,
                 // don't decode a timestamp
-                if (logSumExpOfTimestampTokenLogProbs <= valueOfMaxNonTimestampLogProb) {
+                if (logSumOfTimestampTokenProbs <= valueOfMaxNonTimestampLogProb) {
                     return false;
                 }
                 // Decode a timestamp token
@@ -623,14 +521,14 @@ export class Whisper {
                     const previousToken = decodedTokens[decodedTokens.length - 1];
                     const previousTokenTimestampLogits = decodedTokensTimestampLogits[decodedTokensTimestampLogits.length - 1];
                     const previousTokenConfidence = decodedTokensConfidence[decodedTokensConfidence.length - 1];
-                    addToken(previousToken, previousTokenTimestampLogits, previousTokenConfidence, crossAttentionQKsForToken);
+                    addToken(previousToken, previousTokenTimestampLogits, previousTokenConfidence, tokenCrossAttentionQKs);
                     lastTimestampTokenIndex = decodedTokens.length;
                 }
                 else {
                     // Otherwise decode the highest probability timestamp
-                    const timestampToken = timestampTokensStart + indexOfMaxTimestampLogProb;
+                    const timestampToken = timestampTokensStart + indexOfMaxTimestampProb;
                     const confidence = allTokenProbabilities[timestampToken];
-                    addToken(timestampToken, timestampTokenLogits, confidence, crossAttentionQKsForToken);
+                    addToken(timestampToken, timestampTokenLogits, confidence, tokenCrossAttentionQKs);
                 }
                 return true;
             };
@@ -669,7 +567,7 @@ export class Whisper {
                 }
                 // If filter caused all word token logits to be -Infinity, then there is no
                 // other token to decode. Fall back to accept end-of-text
-                if (nonTimestampTokenLogits.slice(0, endOfTextToken).every(logit => logit === -Infinity)) {
+                if (nonTimestampTokenLogits.subarray(0, endOfTextToken).every(logit => logit === -Infinity)) {
                     shouldDecodeEndfOfTextToken = true;
                 }
             }
@@ -686,7 +584,7 @@ export class Whisper {
             // If end-of-text token should be decoded, then add it and break
             // out of the loop
             if (shouldDecodeEndfOfTextToken) {
-                addToken(endOfTextToken, timestampTokenLogits, 1.0, crossAttentionQKsForToken);
+                addToken(endOfTextToken, timestampTokenLogits, 1.0, tokenCrossAttentionQKs);
                 break;
             }
             // Suppress end-of-text token if it shouldn't be included in candidates
@@ -763,7 +661,7 @@ export class Whisper {
             // Add chosen token
             const chosenToken = topCandidates[chosenCandidateRank].token;
             const chosenTokenConfidence = topCandidateProbabilities[chosenCandidateRank];
-            addToken(chosenToken, timestampTokenLogits, chosenTokenConfidence, crossAttentionQKsForToken);
+            addToken(chosenToken, timestampTokenLogits, chosenTokenConfidence, tokenCrossAttentionQKs);
             // If chosen token is the end-of-text token, break
             if (chosenToken === endOfTextToken) {
                 break;
@@ -792,8 +690,8 @@ export class Whisper {
             const sliceEndTokenIndex = lastTimestampTokenIndex;
             decodedTokens = decodedTokens.slice(0, sliceEndTokenIndex);
             decodedTokensTimestampLogits = decodedTokensTimestampLogits.slice(0, sliceEndTokenIndex);
-            decodedTokensCrossAttentionQKs = decodedTokensCrossAttentionQKs.slice(0, sliceEndTokenIndex);
             decodedTokensConfidence = decodedTokensConfidence.slice(0, sliceEndTokenIndex);
+            decodedTokensCrossAttentionQKs = decodedTokensCrossAttentionQKs.slice(0, sliceEndTokenIndex);
             decodedTokensDecodingTime = decodedTokensDecodingTime.slice(0, sliceEndTokenIndex);
             decodedTokensInferenceTime = decodedTokensInferenceTime.slice(0, sliceEndTokenIndex);
         }
@@ -811,68 +709,13 @@ export class Whisper {
             decodedTokensOverheadTime,
         };
     }
-    // Encode audio using the encoder model
-    async encodeAudio(rawAudio) {
-        await this.initializeEncoderSessionIfNeeded();
-        const Onnx = await import('onnxruntime-node');
-        const logger = new Logger();
-        const audioSamples = rawAudio.audioChannels[0];
-        const sampleRate = rawAudio.sampleRate;
-        const fftOrder = 400;
-        const fftWindowSize = 400;
-        const fftHopLength = 160;
-        const filterbankCount = this.filterbankCount;
-        const filterbanks = this.filterbanks;
-        const maxAudioSamples = sampleRate * 30;
-        const maxAudioFrames = 3000;
-        if (sampleRate !== 16000) {
-            throw new Error('Audio must have a sample rate of 16000 Hz');
-        }
-        if (audioSamples.length > maxAudioSamples) {
-            throw new Error(`Audio part is longer than 30 seconds`);
-        }
-        await logger.startAsync('Extract Mel spectrogram from audio part');
-        // Pad audio samples to ensure that have a duration of 30 seconds
-        const paddedAudioSamples = new Float32Array(maxAudioSamples);
-        paddedAudioSamples.set(audioSamples, 0);
-        const rawAudioPart = { audioChannels: [paddedAudioSamples], sampleRate };
-        // Compute Mel spectrogram
-        const { melSpectrogram } = await computeMelSpectrogramUsingFilterbanks(rawAudioPart, fftOrder, fftWindowSize, fftHopLength, filterbanks);
-        // Flatten, transpose, apply logarithm and normalize Mel spectrogram
-        await logger.startAsync('Process Mel spectrogram');
-        const flattenedLogMelSpectrogram = new Float32Array(maxAudioFrames * filterbankCount);
-        let maxLogMel = -Infinity;
-        for (let i = 0; i < filterbankCount; i++) {
-            for (let j = 0; j < maxAudioFrames; j++) {
-                const mel = melSpectrogram[j][i];
-                const logMel = Math.log10(Math.max(mel, 1e-10));
-                if (logMel > maxLogMel) {
-                    maxLogMel = logMel;
-                }
-                flattenedLogMelSpectrogram[(i * maxAudioFrames) + j] = logMel;
-            }
-        }
-        for (let i = 0; i < flattenedLogMelSpectrogram.length; i++) {
-            const logMel = flattenedLogMelSpectrogram[i];
-            const normalizedLogMel = (Math.max(logMel, maxLogMel - 8) + 4) / 4;
-            flattenedLogMelSpectrogram[i] = normalizedLogMel;
-        }
-        // Run the encoder model
-        await logger.startAsync('Encode Mel spectrogram with Whisper encoder model');
-        const inputTensor = new Onnx.Tensor('float32', flattenedLogMelSpectrogram, [1, filterbankCount, maxAudioFrames]);
-        const encoderInputs = { mel: inputTensor };
-        const encoderOutputs = await this.audioEncoder.run(encoderInputs);
-        const encodedAudioFeatures = encoderOutputs['output'];
-        logger.end();
-        return encodedAudioFeatures;
-    }
     tokenTimelineToWordTimeline(tokenTimeline, language) {
         function isSeparatorCharacter(char) {
             const nonSeparatingPunctuation = [`'`, `-`, `.`, `·`, `•`];
             if (nonSeparatingPunctuation.includes(char)) {
                 return false;
             }
-            return isWhitespace(char) || includesPunctuation(char);
+            return isAllWhitespace(char) || includesPunctuation(char);
         }
         function startsWithSeparatorCharacter(text) {
             return isSeparatorCharacter(text[0]);
@@ -973,31 +816,31 @@ export class Whisper {
         }
         return tokenTimeline;
     }
-    async findAlignmentPathFromQKs(qksTensors, tokens, segmentStartFrame, segmentEndFrame, headIndexes) {
-        const segmentFrameCount = segmentEndFrame - segmentStartFrame;
-        if (segmentFrameCount === 0 || tokens.length === 0 || qksTensors.length === 0) {
+    async findAlignmentPathFromCrossAttentionQKs(crossAttentionQKs, tokens, partStartFrameIndex, partEndFrameIndex, alignmentHeadsIndexesToUse) {
+        const partFrameCount = partEndFrameIndex - partStartFrameIndex;
+        if (partFrameCount === 0 || tokens.length === 0 || crossAttentionQKs.length === 0 || crossAttentionQKs[0].data.length === 0) {
             return [];
         }
-        const tokenCount = qksTensors.length;
-        const layerCount = qksTensors[0].dims[0];
-        const headCount = qksTensors[0].dims[2];
-        const frameCount = qksTensors[0].dims[4];
-        if (!headIndexes) {
-            headIndexes = getIntegerRange(0, layerCount * headCount);
-        }
-        // Load attention head weights from tensors
-        const attentionHeads = []; // structure: [heads, tokens, frames]
-        for (const headIndex of headIndexes) {
-            const attentionHead = []; // structure: [tokens, frames]
+        // crossAttentionQKs internal dimensions: [heads, tokens = 1, frames]
+        const tokenCount = crossAttentionQKs.length;
+        const headCount = Number(crossAttentionQKs[0].dimensions[0]);
+        const frameCount = Number(crossAttentionQKs[0].dimensions[2]);
+        if (!alignmentHeadsIndexesToUse) {
+            alignmentHeadsIndexesToUse = getIntegerRange(0, headCount);
+        }
+        // Initialize attention head arrays
+        const attentionHeads = []; // dimensions: [heads, tokens, frames]
+        for (const headIndex of alignmentHeadsIndexesToUse) {
+            const head = [];
+            const startIndexInBuffer = headIndex * frameCount;
+            const endIndexInBuffer = startIndexInBuffer + partFrameCount;
             for (let tokenIndex = 0; tokenIndex < tokenCount; tokenIndex++) {
-                const bufferOffset = headIndex * frameCount;
-                const startIndexInBuffer = bufferOffset + segmentStartFrame;
-                const endIndexInBuffer = bufferOffset + segmentEndFrame;
-                const framesForHead = qksTensors[tokenIndex].data.slice(startIndexInBuffer, endIndexInBuffer);
-                attentionHead.push(framesForHead);
+                const data = crossAttentionQKs[tokenIndex].data.subarray(startIndexInBuffer, endIndexInBuffer);
+                head.push(data);
             }
-            attentionHeads.push(attentionHead);
+            attentionHeads.push(head);
         }
+        // Initialize settings
         const applySoftmax = true;
         const normalize = true;
         const applyMedianFilter = true;
@@ -1042,11 +885,11 @@ export class Whisper {
                 }
             }
         }
-        // Compute the mean of the selected attention heads for all layers
+        // Compute the mean of the selected attention heads for each frame
         const frameMeansForToken = [];
         for (let tokenIndex = 0; tokenIndex < tokenCount; tokenIndex++) {
-            const meansForFrames = new Float32Array(segmentFrameCount);
-            for (let frameIndex = 0; frameIndex < segmentFrameCount; frameIndex++) {
+            const meansForFrames = new Float32Array(partFrameCount);
+            for (let frameIndex = 0; frameIndex < partFrameCount; frameIndex++) {
                 let sum = 0;
                 for (const head of attentionHeads) {
                     sum += head[tokenIndex][frameIndex];
@@ -1058,40 +901,90 @@ export class Whisper {
         }
         // Anchor timestamp tokens timestamps to their original values, if enabled
         if (anchorTimestampTokens) {
-            const timestampTokensStart = this.tokenConfig.timestampTokensStart;
+            const timestampTokensStart = this.specialTokens.timestampTokensStart;
             for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex++) {
                 const token = tokens[tokenIndex];
                 if (this.isTimestampToken(token)) {
                     let timestampFrame = token - timestampTokensStart;
-                    timestampFrame = clip(timestampFrame, segmentStartFrame, segmentEndFrame - 1);
+                    timestampFrame = clip(timestampFrame, partStartFrameIndex, partEndFrameIndex - 1);
                     frameMeansForToken[tokenIndex][timestampFrame] = 100;
                 }
             }
         }
         // Perform DTW to align tokens indexes to frame indexes
         const tokenIndexes = getIntegerRange(0, tokenCount);
-        const frameIndexes = getIntegerRange(0, segmentFrameCount);
+        const frameIndexes = getIntegerRange(0, partFrameCount);
         let { path } = alignDTWWindowed(tokenIndexes, frameIndexes, (tokenIndex, frameIndex) => {
             return -frameMeansForToken[tokenIndex][frameIndex];
-        }, segmentFrameCount);
-        path = path.map(entry => ({ source: entry.source, dest: segmentStartFrame + entry.dest }));
+        }, partFrameCount);
+        path = path.map(entry => ({ source: entry.source, dest: partStartFrameIndex + entry.dest }));
         return path;
     }
-    async initializeIfNeeded() {
-        await this.initializeTokenizerIfNeeded();
-        await this.initializeEncoderSessionIfNeeded();
-        await this.initializeDecoderSessionIfNeeded();
+    async initializeIfNeeded(options, callbacks) {
+        await this.initializeTokenizerIfNeeded(callbacks);
+        await this.initializeContextIfNeeded(options, callbacks);
+    }
+    async initializeContextIfNeeded(options, callbacks) {
+        if (this.context) {
+            return;
+        }
+        const logger = new Logger(callbacks.logLevel);
+        const modelId = this.modelId;
+        const modelFilePath = this.modelPath;
+        const libPath = this.libPath;
+        let libFilePath;
+        if (process.platform === 'win32') {
+            libFilePath = resolvePath(libPath, 'whisper.dll');
+        }
+        else if (process.platform === 'darwin') {
+            libFilePath = resolvePath(libPath, 'libwhisper.0.dylib');
+        }
+        else if (process.platform === 'linux') {
+            libFilePath = resolvePath(libPath, 'libwhisper.so.0');
+        }
+        else {
+            throw new Error(`Unsupported platform`);
+        }
+        await logger.startAsync(`Load whisper.cpp model '${modelId}'`);
+        this.context = new WhisperCppContext();
+        let alignmentHeadsPreset;
+        let alignmentHeadsTopCount = 0;
+        if (options.timestampAccuracy == 'high') {
+            alignmentHeadsPreset = WhisperAlignmentHeadsPreset.WHISPER_AHEADS_N_TOP_MOST;
+            alignmentHeadsTopCount = whisperModelIdToTextLayerCount[modelId];
+        }
+        else {
+            alignmentHeadsPreset = whisperModelIdToAlignmentHeadsPreset[modelId];
+        }
+        const contextOptions = {
+            libFilePath,
+            modelFilePath,
+            // Force GPU option to be enabled for all GPU and CPU builds
+            // The `enableGPU` option in `WhisperOptions` doesn't impact this
+            enableGPU: true,
+            // Flash attention must be disabled for timestamp extraction to be possible
+            // in the way it's done here
+            enableFlashAttention: false,
+            // Device index is passed. Defaults to 0
+            gpuDeviceIndex: options.gpuDeviceIndex,
+            alignmentHeadsPreset,
+            alignmentHeadsTopCount,
+            //logLevel: logger.logLevelGreaterOrEqualTo('trace') ? GgmlLogLevel.GGML_LOG_LEVEL_INFO : GgmlLogLevel.GGML_LOG_LEVEL_WARN,
+            logLevel: GgmlLogLevel.GGML_LOG_LEVEL_WARN,
+        };
+        await this.context.initialize(contextOptions);
+        logger.end();
     }
-    async initializeTokenizerIfNeeded() {
+    async initializeTokenizerIfNeeded(callbacks) {
         if (this.tiktoken) {
             return;
         }
-        const logger = new Logger();
+        const logger = new Logger(callbacks.logLevel);
         await logger.startAsync('Load tokenizer data');
-        const tiktokenModulePackagePath = await loadPackage('whisper-tiktoken-data');
+        const tiktokenModulePackagePath = await loadPackage('whisper-tiktoken-data', callbacks);
         const tiktokenDataFilePath = joinPath(tiktokenModulePackagePath, this.isMultiligualModel ? 'multilingual.tiktoken' : 'gpt2.tiktoken');
         let tiktokenData = await readFileAsUtf8(tiktokenDataFilePath);
-        const tokenConfig = this.tokenConfig;
+        const tokenConfig = this.specialTokens;
         const metadataTokens = {
             [tokenConfig.endOfTextToken]: '[EndOfText]',
             [tokenConfig.startOfTextToken]: '[StartOfText]',
@@ -1107,12 +1000,12 @@ export class Whisper {
         }
         const languageTokenCount = tokenConfig.languageTokensEnd - tokenConfig.languageTokensStart;
         for (let i = 0; i < languageTokenCount; i++) {
-            const tokenIndex = this.tokenConfig.languageTokensStart + i;
+            const tokenIndex = this.specialTokens.languageTokensStart + i;
             metadataTokens[tokenIndex] = `[Language_${i}]`;
         }
         const timestampTokensCount = 1501;
         for (let i = 0; i <= timestampTokensCount; i++) {
-            const tokenIndex = this.tokenConfig.timestampTokensStart + i;
+            const tokenIndex = this.specialTokens.timestampTokensStart + i;
             const tokenTime = this.timestampTokenToSeconds(tokenIndex);
             metadataTokens[tokenIndex] = `[Timestamp_${tokenTime.toFixed(2)}]`;
         }
@@ -1125,72 +1018,33 @@ export class Whisper {
         this.tiktoken = new Tiktoken(tiktokenData, inverseMetadataTokensLookup, patternString);
         logger.end();
     }
-    async initializeEncoderSessionIfNeeded() {
-        if (this.audioEncoder) {
-            return;
-        }
-        const logger = new Logger();
-        const onnxSessionOptions = getOnnxSessionOptions({ executionProviders: this.encoderExecutionProviders });
-        const onnxProvidersString = onnxSessionOptions.executionProviders.length > 0 ? `${onnxSessionOptions.executionProviders.join(', ')}` : `default`;
-        await logger.startAsync(`Create encoder inference session for model '${this.modelName}' (ONNX provider: ${onnxProvidersString})`);
-        const encoderFilePath = joinPath(this.modelDir, 'encoder.onnx');
-        const Onnx = await import('onnxruntime-node');
-        this.audioEncoder = await Onnx.InferenceSession.create(encoderFilePath, onnxSessionOptions);
-        logger.end();
-    }
-    async initializeDecoderSessionIfNeeded() {
-        if (this.textDecoder) {
-            return;
-        }
-        const logger = new Logger();
-        const onnxSessionOptions = getOnnxSessionOptions({ executionProviders: this.decoderExecutionProviders });
-        const onnxProvidersString = onnxSessionOptions.executionProviders.length > 0 ? `${onnxSessionOptions.executionProviders.join(', ')}` : `default`;
-        await logger.startAsync(`Create decoder inference session for model '${this.modelName}' (ONNX provider: ${onnxProvidersString})`);
-        const decoderFilePath = joinPath(this.modelDir, 'decoder.onnx');
-        const Onnx = await import('onnxruntime-node');
-        this.textDecoder = await Onnx.InferenceSession.create(decoderFilePath, onnxSessionOptions);
-        logger.end();
-    }
-    getKvDimensions(groupCount, length) {
-        const modelName = this.modelName;
-        if (modelName === 'tiny' || modelName === 'tiny.en') {
-            return [8, groupCount, length, 384];
-        }
-        else if (modelName === 'base' || modelName === 'base.en') {
-            return [12, groupCount, length, 512];
-        }
-        else if (modelName === 'small' || modelName === 'small.en') {
-            return [24, groupCount, length, 768];
-        }
-        else if (modelName === 'medium' || modelName === 'medium.en') {
-            return [48, groupCount, length, 1024];
-        }
-        else if (modelName === 'large-v1' || modelName === 'large-v2' || modelName === 'large-v3' || modelName === 'large-v3-turbo') {
-            return [64, groupCount, length, 1280];
-        }
-        else {
-            throw new Error(`Unsupported model: ${modelName}`);
-        }
-    }
     getTextStartTokens(language, task, disableTimestamps = false) {
-        const startOfTextToken = this.tokenConfig.startOfTextToken;
+        const startOfTextToken = this.specialTokens.startOfTextToken;
         let tokens;
         if (this.isMultiligualModel) {
-            const languageToken = this.tokenConfig.languageTokensStart + languageIdLookup[language];
-            const taskToken = task === 'translate' ? this.tokenConfig.translateTaskToken : this.tokenConfig.transcribeTaskToken;
+            const languageToken = this.specialTokens.languageTokensStart + languageIdLookup[language];
+            const taskToken = task === 'translate' ? this.specialTokens.translateTaskToken : this.specialTokens.transcribeTaskToken;
             tokens = [startOfTextToken, languageToken, taskToken];
         }
         else {
             tokens = [startOfTextToken];
         }
         if (disableTimestamps) {
-            tokens.push(this.tokenConfig.noTimestampsToken);
+            tokens.push(this.specialTokens.noTimestampsToken);
         }
         return tokens;
     }
     tokenToText(token, includeMetadataTokens = false) {
         return this.tokensToText([token], includeMetadataTokens);
     }
+    tokenToBytes(token) {
+        return this.tiktoken.decode_single_token_bytes(token);
+    }
+    tokensToBytes(tokens) {
+        const tokensBytes = tokens.map(token => this.tokenToBytes(token));
+        const concatenatedTokensBytes = concatUint8Arrays(tokensBytes);
+        return concatenatedTokensBytes;
+    }
     tokensToText(tokens, includeMetadataTokens = false) {
         tokens.forEach(token => this.assertIsValidToken(token));
         if (includeMetadataTokens === false) {
@@ -1199,10 +1053,10 @@ export class Whisper {
         if (tokens.length === 0) {
             return '';
         }
-        const decodedBytes = this.tiktoken.decode(new Uint32Array(tokens));
-        const textDecoder = new TextDecoder();
-        const decodedString = textDecoder.decode(decodedBytes);
         try {
+            const decodedBytes = this.tiktoken.decode(new Uint32Array(tokens));
+            const textDecoder = new TextDecoder();
+            const decodedString = textDecoder.decode(decodedBytes);
             return decodedString;
         }
         catch {
@@ -1213,32 +1067,32 @@ export class Whisper {
         return Array.from(this.tiktoken.encode(text));
     }
     isTextToken(token) {
-        return token < this.tokenConfig.endOfTextToken;
+        return token < this.specialTokens.endOfTextToken;
     }
     isMetadataToken(token) {
-        return token >= this.tokenConfig.endOfTextToken;
+        return token >= this.specialTokens.endOfTextToken;
     }
     isLanguageToken(token) {
-        return token >= this.tokenConfig.languageTokensStart && token < this.tokenConfig.languageTokensEnd;
+        return token >= this.specialTokens.languageTokensStart && token < this.specialTokens.languageTokensEnd;
     }
     isTimestampToken(token) {
-        return token >= this.tokenConfig.timestampTokensStart;
+        return token >= this.specialTokens.timestampTokensStart;
     }
     isNonTimestampToken(token) {
-        return token < this.tokenConfig.timestampTokensStart;
+        return token < this.specialTokens.timestampTokensStart;
     }
     timestampTokenToSeconds(timestampToken) {
         this.assertIsValidToken(timestampToken);
         if (this.isNonTimestampToken(timestampToken)) {
             throw new Error(`Invalid timestamp token: ${timestampToken}`);
         }
-        let seconds = (timestampToken - this.tokenConfig.timestampTokensStart) * 0.02;
+        let seconds = (timestampToken - this.specialTokens.timestampTokensStart) * 0.02;
         seconds = clip(seconds, 0.0, 30.0);
         return seconds;
     }
     isValidToken(token) {
         //return token < this.tokenConfig.timestampTokensEnd
-        return token <= this.tokenConfig.timestampTokensEnd;
+        return token <= this.specialTokens.timestampTokensEnd;
     }
     assertIsValidToken(token) {
         if (!this.isValidToken(token)) {
@@ -1258,7 +1112,7 @@ export class Whisper {
         if (!this.isLanguageToken(languageToken)) {
             throw new Error(`Invalid language token: ${languageToken}`);
         }
-        let languageIndex = languageToken - this.tokenConfig.languageTokensStart;
+        let languageIndex = languageToken - this.specialTokens.languageTokensStart;
         if (this.isEnglishOnlyModel) {
             languageIndex += 1;
         }
@@ -1266,20 +1120,17 @@ export class Whisper {
     get isEnglishOnlyModel() {
         return this.isMultiligualModel === false;
     }
-    get isLargeModel() {
-        return this.modelName.startsWith('large');
+    get isLargeV3Model() {
+        return this.modelId.startsWith('large-v3');
     }
-    get filterbankCount() {
-        return this.isLargeModel ? 128 : 80;
+    get melBandCount() {
+        return this.isLargeV3Model ? 128 : 80;
     }
-    get filterbanks() {
-        return this.isLargeModel ? filterbanks_128 : filterbanks_80;
-    }
-    get alignmentHeadIndexes() {
-        return alignmentHeadsIndexes[this.modelName];
+    get melFilterbank() {
+        return this.isLargeV3Model ? melFilterbank128 : melFilterbanks80;
     }
     get defaultTimestampAccuracy() {
-        if (this.modelName.startsWith('tiny') || this.modelName.startsWith('base')) {
+        if (this.modelId.startsWith('tiny') || this.modelId.startsWith('base')) {
             return 'high';
         }
         else {
@@ -1326,7 +1177,7 @@ export class Whisper {
     getWordTokenData() {
         const wordTokenData = [];
         const nonWordTokenData = [];
-        for (let i = 0; i < this.tokenConfig.endOfTextToken; i++) {
+        for (let i = 0; i < this.specialTokens.endOfTextToken; i++) {
             const tokenText = this.tokenToText(i, false);
             const isNonWordToken = /^[\s\p{Punctuation}\p{Symbol}]+$/u.test(tokenText);
             const containsInvalidUTF8 = containsInvalidCodepoint(tokenText);
@@ -1356,77 +1207,68 @@ export class Whisper {
         return tokensData;
     }
 }
-export async function loadPackagesAndGetPaths(modelName, languageCode) {
-    if (modelName) {
-        modelName = normalizeWhisperModelName(modelName, languageCode);
-    }
-    else {
-        if (languageCode) {
-            const shortLanguageCode = getShortLanguageCode(languageCode);
-            modelName = shortLanguageCode === 'en' ? 'tiny.en' : 'tiny';
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Utility methods
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+export function isMultilingualModel(modelId) {
+    return !isEnglishOnlyModel(modelId);
+}
+export function isEnglishOnlyModel(modelId) {
+    return modelId.endsWith('.en');
+}
+export async function loadLibraryPackages(enableGPU, callbacks) {
+    const arch = process.arch;
+    const platform = process.platform;
+    let packageName;
+    const useMacOsGpuBuildByDefault = true;
+    if (platform === 'win32' && arch === 'x64') {
+        if (enableGPU) {
+            packageName = 'whisper.cpp-lib-windows-x64-cublas-12.4.0';
         }
         else {
-            modelName = 'tiny';
+            packageName = 'whisper.cpp-lib-windows-x64-cpu';
         }
     }
-    if (modelName.startsWith('large') && modelName !== 'large-v3-turbo') {
-        throw new Error(`Models 'large-v1', 'large-v2', 'large-v3' are not currently supported by the integrated Whisper engine due to model size restrictions of onnxruntime-node. To use large models, you can either select large-v3-turbo use the whisper.cpp engine instead.`);
+    else if (platform === 'win32' && arch === 'arm64') {
+        packageName = 'whisper.cpp-lib-windows-arm64-cpu';
     }
-    const packageName = modelNameToPackageName[modelName];
-    const modelDir = await loadPackage(packageName);
-    return { modelName, modelDir };
-}
-export function normalizeWhisperModelName(modelName, languageCode) {
-    if (languageCode !== 'en' && modelName.endsWith('.en')) {
-        const originalModelName = modelName;
-        modelName = modelName.slice(0, modelName.length - 3);
-        const logger = new Logger();
-        logger.logTitledMessage(`Warning`, `The model '${originalModelName}' is English only and cannot be used to transcribe language '${languageCode}'. Using '${modelName}' instead.`, chalk.yellowBright, 'warning');
-    }
-    return modelName;
-}
-export function isMultilingualModel(modelName) {
-    return !isEnglishOnlyModel(modelName);
-}
-export function isEnglishOnlyModel(modelName) {
-    return modelName.endsWith('.en');
-}
-export function getDefaultEncoderProvidersForModel(modelName) {
-    if (dmlProviderAvailable()) {
-        return ['dml', 'cpu'];
+    else if (platform === 'darwin' && arch === 'x64') {
+        if (useMacOsGpuBuildByDefault || enableGPU) {
+            packageName = 'whisper.cpp-lib-macos-universal';
+        }
+        else {
+            packageName = 'whisper.cpp-lib-macos-universal-cpu-basic';
+        }
     }
-    else {
-        return [];
+    else if (platform === 'darwin' && arch === 'arm64') {
+        if (useMacOsGpuBuildByDefault || enableGPU) {
+            packageName = 'whisper.cpp-lib-macos-universal';
+        }
+        else {
+            packageName = 'whisper.cpp-lib-macos-universal-cpu-basic';
+        }
     }
-}
-export function getDefaultDecoderProvidersForModel(modelName) {
-    if (modelName.startsWith('small') || modelName.startsWith('medium') || modelName.startsWith('large')) {
-        if (dmlProviderAvailable()) {
-            return ['dml', 'cpu'];
+    else if (platform === 'linux' && arch === 'x64') {
+        if (enableGPU) {
+            packageName = 'whisper.cpp-lib-linux-x64-cublas-12.4.0';
         }
         else {
-            return [];
+            packageName = 'whisper.cpp-lib-linux-x64-cpu';
         }
     }
+    else if (platform === 'linux' && arch === 'arm64') {
+        packageName = 'whisper.cpp-lib-linux-arm64-cpu';
+    }
     else {
-        return [];
+        throw new Error(`The platform and architecture combination ${platform} / ${arch} is not supported by the Whisper engine`);
     }
+    const whisperCppLibPath = await loadPackage(packageName, callbacks);
+    const libPath = whisperCppLibPath;
+    return { libPath };
 }
-export const modelNameToPackageName = {
-    'tiny': 'whisper-tiny',
-    'tiny.en': 'whisper-tiny.en',
-    'base': 'whisper-base',
-    'base.en': 'whisper-base.en',
-    'small': 'whisper-small',
-    'small.en': 'whisper-small.en',
-    'medium': 'whisper-medium',
-    'medium.en': 'whisper-medium.en',
-    'large-v1': 'whisper-large-v1',
-    'large-v2': 'whisper-large-v2',
-    'large-v3': 'whisper-large-v3',
-    'large-v3-turbo': 'whisper-large-v3-turbo-fp16',
-};
-export const tokenizerPackageName = 'whisper-tokenizer';
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Tables
+////////////////////////////////////////////////////////////////////////////////////////////////////////
 const languageIdLookup = {
     'en': 0,
     'zh': 1,
@@ -1529,7 +1371,7 @@ const languageIdLookup = {
     'su': 98,
     //'yue': 99
 };
-const alignmentHeadsIndexes = {
+const alignmentHeadsIndices = {
     'tiny': [14, 18, 20, 21, 22, 23,],
     'tiny.en': [6, 12, 17, 18, 19, 20, 21, 22,],
     'base': [25, 34, 35, 39, 41, 42, 44, 46,],
@@ -1543,7 +1385,7 @@ const alignmentHeadsIndexes = {
     'large-v3': [140, 217, 258, 272, 321, 354, 391, 424, 481, 506,],
     'large-v3-turbo': [44, 51, 63, 66, 71, 74,],
 };
-const filterbanks_80 = [
+const melFilterbanks80 = [
     /* 0 */ { startIndex: 1, weights: [0.02486259490251541,] },
     /* 1 */ { startIndex: 1, weights: [0.001990821911022067, 0.022871771827340126,] },
     /* 2 */ { startIndex: 2, weights: [0.003981643822044134, 0.02088095061480999,] },
@@ -1625,7 +1467,7 @@ const filterbanks_80 = [
     /* 78 */ { startIndex: 179, weights: [0.0003849811910185963, 0.0008885387214832008, 0.001392096164636314, 0.0018956535495817661, 0.00239921105094254, 0.002902768552303314, 0.0034063260536640882, 0.003132763085886836, 0.0026481777895241976, 0.0021635922603309155, 0.0016790067311376333, 0.0011944210855290294, 0.0007098356145434082, 0.00022525011445395648,] },
     /* 79 */ { startIndex: 186, weights: [0.000366741674952209, 0.0008330700220540166, 0.0012993983691558242, 0.0017657268326729536, 0.0022320549469441175, 0.002698383294045925, 0.0031647118739783764, 0.003141313325613737, 0.002692554146051407, 0.0022437951993197203, 0.00179503601975739, 0.0013462770730257034, 0.000897518009878695, 0.0004487590049393475,] },
 ];
-const filterbanks_128 = [
+const melFilterbank128 = [
     /* 0 */ { startIndex: 1, weights: [0.012373986653983593,] },
     /* 1 */ { startIndex: 1, weights: [0.030392564833164215,] },
     /* 2 */ { startIndex: 2, weights: [0.024747973307967186,] },
@@ -1755,9 +1597,38 @@ const filterbanks_128 = [
     /* 126 */ { startIndex: 187, weights: [0.0011469805613160133, 0.002344857668504119, 0.0035427347756922245, 0.004740611650049686, 0.0049519846215844154, 0.003782647429034114, 0.002613310469314456, 0.0014439737424254417, 0.0002746368118096143,] },
     /* 127 */ { startIndex: 191, weights: [0.0004756950947921723, 0.0016171716852113605, 0.002758648479357362, 0.0039001251570880413, 0.005041601601988077, 0.004457120783627033, 0.003342840587720275, 0.0022285603918135166, 0.0011142801959067583,] },
 ];
+const multilingualSpecialTokens = {
+    endOfTextToken: 50257,
+    startOfTextToken: 50258,
+    languageTokensStart: 50259,
+    languageTokensEnd: 50358,
+    translateTaskToken: 50358,
+    transcribeTaskToken: 50359,
+    startOfPromptToken: 50361,
+    nonSpeechToken: 50362,
+    noTimestampsToken: 50363,
+    timestampTokensStart: 50364,
+    timestampTokensEnd: 50364 + 1501,
+};
+const englishOnlySpecialTokens = {
+    endOfTextToken: 50256,
+    startOfTextToken: 50257,
+    languageTokensStart: 50258,
+    languageTokensEnd: 50358,
+    translateTaskToken: 50358,
+    transcribeTaskToken: 50359,
+    startOfPromptToken: 50360,
+    nonSpeechToken: 50361,
+    noTimestampsToken: 50362,
+    timestampTokensStart: 50363,
+    timestampTokensEnd: 50363 + 1501,
+};
 const largestMaximumTokensPerPart = 220;
 export const defaultWhisperOptions = {
     model: undefined,
+    enableGPU: false,
+    threadCount: 4,
+    gpuDeviceIndex: 0,
     temperature: 0.1,
     prompt: undefined,
     topCandidateCount: 5,
@@ -1770,28 +1641,22 @@ export const defaultWhisperOptions = {
     endTokenThreshold: 0.9,
     includeEndTokenInCandidates: true,
     timestampAccuracy: undefined,
-    encoderProvider: undefined,
-    decoderProvider: undefined,
     seed: undefined,
 };
 export const defaultWhisperAlignmentOptions = {
     model: undefined,
+    enableGPU: false,
+    threadCount: 4,
+    gpuDeviceIndex: 0,
     endTokenThreshold: 0.9,
     maxTokensPerPart: largestMaximumTokensPerPart,
     timestampAccuracy: undefined,
-    encoderProvider: undefined,
-    decoderProvider: undefined,
 };
 export const defaultWhisperLanguageDetectionOptions = {
     model: undefined,
+    enableGPU: false,
+    threadCount: 4,
+    gpuDeviceIndex: 0,
     temperature: 1.0,
-    encoderProvider: undefined,
-    decoderProvider: undefined,
-};
-export const defaultWhisperVADOptions = {
-    model: undefined,
-    temperature: 1.0,
-    encoderProvider: undefined,
-    decoderProvider: undefined,
 };
 //# sourceMappingURL=WhisperSTT.js.map