echogarden 1.4.4 → 1.6.0

package/src/alignment/SpeechAlignment.ts

@@ -1,18 +1,21 @@
-import { clip } from '../utilities/Utilities.js'
+import { clip, splitFloat32Array } from '../utilities/Utilities.js'
 
 import * as API from '../api/API.js'
 
 import { computeMFCCs, extendDefaultMfccOptions, MfccOptions } from '../dsp/MFCC.js'
 import { alignMFCC_DTW, getCostMatrixMemorySizeMB } from './DTWMfccSequenceAlignment.js'
 import { Logger } from '../utilities/Logger.js'
-import { Timeline, TimelineEntry } from '../utilities/Timeline.js'
-import { downmixToMonoAndNormalize, getEndingSilentSampleCount, getRawAudioDuration, getStartingSilentSampleCount, RawAudio } from '../audio/AudioUtilities.js'
+import { addTimeOffsetToTimeline, Timeline, TimelineEntry } from '../utilities/Timeline.js'
+import { concatAudioSegments, downmixToMonoAndNormalize, getEmptyRawAudio, getEndingSilentSampleCount, getRawAudioDuration, getStartingSilentSampleCount, RawAudio } from '../audio/AudioUtilities.js'
 import chalk from 'chalk'
 import { synthesize } from '../api/API.js'
 import { resampleAudioSpeex } from '../dsp/SpeexResampler.js'
 import { deepClone } from '../utilities/ObjectUtilities.js'
-import { zeroIfNaN } from '../math/VectorMath.js'
-import { EspeakOptions } from '../synthesis/EspeakTTS.js'
+import { cosineDistance, euclideanDistance, zeroIfNaN } from '../math/VectorMath.js'
+import { EspeakEvent, EspeakOptions } from '../synthesis/EspeakTTS.js'
+import { alignDTWWindowed } from './DTWSequenceAlignmentWindowed.js'
+import { loadPackage } from '../utilities/PackageManager.js'
+import path from 'path'
 
 export async function alignUsingDtw(
 	sourceRawAudio: RawAudio,
@@ -97,54 +100,7 @@ export async function alignUsingDtw(
 
 	logger.start('\nConvert path to timeline')
 
-	function getMappedTimelineEntry(timelineEntry: TimelineEntry, recurse = true): TimelineEntry {
-		const referenceStartFrameIndex = Math.floor(timelineEntry.startTime * framesPerSecond)
-		const referenceEndFrameIndex = Math.floor(timelineEntry.endTime * framesPerSecond)
-
-		if (referenceStartFrameIndex < 0 || referenceEndFrameIndex < 0) {
-			throw new Error('Unexpected: encountered a negative timestamp in timeline')
-		}
-
-		const mappedStartFrameIndex = getMappedFrameIndexForPath(referenceStartFrameIndex, compactedPath, 'first')
-		const mappedEndFrameIndex = getMappedFrameIndexForPath(referenceEndFrameIndex, compactedPath, 'first')
-
-		let innerTimeline: Timeline | undefined
-
-		if (recurse && timelineEntry.timeline != null) {
-			innerTimeline = timelineEntry.timeline.map((entry) => getMappedTimelineEntry(entry))
-		}
-
-		// Trim silent samples from start and end of mapped entry range
-		const sourceSamplesPerFrame = Math.floor(sourceRawAudio.sampleRate / framesPerSecond)
-
-		let startSampleIndex = mappedStartFrameIndex * sourceSamplesPerFrame
-		let endSampleIndex = mappedEndFrameIndex * sourceSamplesPerFrame
-
-		const frameSamples = sourceRawAudio.audioChannels[0].subarray(startSampleIndex, endSampleIndex)
-
-		const silenceThresholdDecibels = -40
-
-		startSampleIndex += getStartingSilentSampleCount(frameSamples, silenceThresholdDecibels)
-		endSampleIndex -= getEndingSilentSampleCount(frameSamples, silenceThresholdDecibels)
-
-		endSampleIndex = Math.max(endSampleIndex, startSampleIndex)
-
-		// Build mapped timeline entry
-		const startTime = startSampleIndex / sourceRawAudio.sampleRate
-		const endTime = endSampleIndex / sourceRawAudio.sampleRate
-
-		return {
-			type: timelineEntry.type,
-			text: timelineEntry.text,
-
-			startTime,
-			endTime,
-
-			timeline: innerTimeline
-		}
-	}
-
-	const mappedTimeline = referenceTimeline.map((timelineEntry) => getMappedTimelineEntry(timelineEntry))
+	const mappedTimeline = referenceTimeline.map(entry => getMappedTimelineEntry(entry, sourceRawAudio, framesPerSecond, compactedPath))
 
 	logger.end()
 
@@ -322,6 +278,170 @@ export async function alignUsingDtwWithRecognition(
 	return result
 }
 
+// This is experimental code. It doesn't work well enough to be usable for anything.
+// Just testing some alternative approaches.
+export async function alignUsingDtwWithEmbeddings(
+	sourceRawAudio: RawAudio,
+	referenceRawAudio: RawAudio,
+	referenceTimeline: Timeline,
+	language: string,
+	granularities: DtwGranularity[],
+	windowDurations: number[]) {
+
+	const logger = new Logger()
+
+	if (sourceRawAudio.sampleRate != 16000) {
+		throw new Error('Source audio must have a sample rate of 16000 Hz')
+	}
+
+	if (referenceRawAudio.sampleRate != 16000) {
+		throw new Error('Reference audio must have a sample rate of 16000 Hz')
+	}
+
+	const embeddingType: 'w2v-bert-2.0' | 'whisper' = 'w2v-bert-2.0'
+
+	let sourceEmbeddings: Float32Array[]
+	let referenceEmbeddings: Float32Array[]
+	let framesPerSecond: number
+
+	if (embeddingType === 'w2v-bert-2.0') {
+		const packageName = 'w2v-bert-2.0-uint8'
+		const modelDir = await loadPackage(packageName)
+		const modelFilePath = path.join(modelDir, `${packageName}.onnx`)
+
+		const { Wav2Vec2BertFeatureEmbeddings } = await import('../speech-embeddings/WavToVec2BertFeatureEmbeddings.js')
+
+		const wav2vecBert = new Wav2Vec2BertFeatureEmbeddings(
+			modelFilePath,
+			['cpu'],
+		)
+
+		logger.start(`Extract source audio embeddings using the W2V-BERT-2.0 model`)
+		sourceEmbeddings = await wav2vecBert.computeEmbeddings(sourceRawAudio)
+
+		logger.start(`Extract reference audio embeddings using the W2V-BERT-2.0 model`)
+		referenceEmbeddings = await wav2vecBert.computeEmbeddings(referenceRawAudio)
+
+		framesPerSecond = 1000 / 10 / 2
+	} else if (embeddingType === 'whisper') {
+		const sourceSamples = sourceRawAudio.audioChannels[0]
+		const referenceSamples = referenceRawAudio.audioChannels[0]
+
+		const WhisperSTT = await import(`../recognition/WhisperSTT.js`)
+
+		const { modelName, modelDir } = await WhisperSTT.loadPackagesAndGetPaths('base.en', language)
+
+		const whisper = new WhisperSTT.Whisper(modelName, modelDir, ['dml', 'cpu'], ['cpu'])
+
+		async function encodeToAudioFeatures(samples: Float32Array) {
+			const featureVectors: Float32Array[] = []
+
+			for (let i = 0; i < samples.length; i += 16000 * 30) {
+				const startSampleIndex = i
+				const endSampleIndex = Math.min(samples.length, i + 16000 * 30)
+				const partSampleCount = endSampleIndex - startSampleIndex
+
+				const audioPart = samples.subarray(startSampleIndex, endSampleIndex)
+				const rawAudioForPart = { audioChannels: [audioPart], sampleRate: 16000 } as RawAudio
+
+				const resultTensor = await whisper.encodeAudio(rawAudioForPart)
+
+				const vectorLength = resultTensor.dims[2]
+
+				let featureVectorsForPart = splitFloat32Array(resultTensor.data as Float32Array, vectorLength)
+
+				featureVectorsForPart = featureVectorsForPart.slice(0, Math.floor((partSampleCount / (16000 * 30)) * 1500))
+
+				featureVectors.push(...featureVectorsForPart)
+			}
+
+			return featureVectors
+		}
+
+		logger.start(`Extract source audio embeddings using the Whisper encoder model`)
+		sourceEmbeddings = await encodeToAudioFeatures(sourceSamples)
+
+		logger.start(`Extract reference audio embeddings using the Whisper encoder model`)
+		referenceEmbeddings = await encodeToAudioFeatures(referenceSamples)
+
+		framesPerSecond = 1500 / 30
+	} else {
+		throw new Error(`Unknown embedding type: ${embeddingType}`)
+	}
+
+	logger.start(`Align source and reference audio embeddings using DTW`)
+
+	const { path: alignmentPath } = alignDTWWindowed(
+		referenceEmbeddings,
+		sourceEmbeddings,
+		cosineDistance,
+		1000 * 1000
+	)
+
+	const compactedPath = compactPath(alignmentPath)
+
+	logger.start('\nConvert path to timeline')
+
+	const mappedTimeline = referenceTimeline.map(entry => getMappedTimelineEntry(entry, sourceRawAudio, framesPerSecond, compactedPath))
+
+	logger.end()
+
+	return mappedTimeline
+}
+
+function getMappedTimelineEntry(
+	timelineEntry: TimelineEntry,
+	sourceRawAudio: RawAudio,
+	framesPerSecond: number,
+	compactedPath: CompactedPath,
+	recurse = true): TimelineEntry {
+
+	const referenceStartFrameIndex = Math.floor(timelineEntry.startTime * framesPerSecond)
+	const referenceEndFrameIndex = Math.floor(timelineEntry.endTime * framesPerSecond)
+
+	if (referenceStartFrameIndex < 0 || referenceEndFrameIndex < 0) {
+		throw new Error('Unexpected: encountered a negative timestamp in timeline')
+	}
+
+	const mappedStartFrameIndex = getMappedFrameIndexForPath(referenceStartFrameIndex, compactedPath, 'first')
+	const mappedEndFrameIndex = getMappedFrameIndexForPath(referenceEndFrameIndex, compactedPath, 'first')
+
+	let innerTimeline: Timeline | undefined
+
+	if (recurse && timelineEntry.timeline != null) {
+		innerTimeline = timelineEntry.timeline.map((entry) => getMappedTimelineEntry(entry, sourceRawAudio, framesPerSecond, compactedPath, recurse))
+	}
+
+	// Trim silent samples from start and end of mapped entry range
+	const sourceSamplesPerFrame = Math.floor(sourceRawAudio.sampleRate / framesPerSecond)
+
+	let startSampleIndex = mappedStartFrameIndex * sourceSamplesPerFrame
+	let endSampleIndex = mappedEndFrameIndex * sourceSamplesPerFrame
+
+	const frameSamples = sourceRawAudio.audioChannels[0].subarray(startSampleIndex, endSampleIndex)
+
+	const silenceThresholdDecibels = -40
+
+	startSampleIndex += getStartingSilentSampleCount(frameSamples, silenceThresholdDecibels)
+	endSampleIndex -= getEndingSilentSampleCount(frameSamples, silenceThresholdDecibels)
+
+	endSampleIndex = Math.max(endSampleIndex, startSampleIndex)
+
+	// Build mapped timeline entry
+	const startTime = startSampleIndex / sourceRawAudio.sampleRate
+	const endTime = endSampleIndex / sourceRawAudio.sampleRate
+
+	return {
+		type: timelineEntry.type,
+		text: timelineEntry.text,
+
+		startTime,
+		endTime,
+
+		timeline: innerTimeline
+	}
+}
+
 export async function interpolatePhoneTimelines(sourceTimeline: Timeline, referenceTimeline: Timeline) {
 	const interpolatedTimeline: Timeline = []
 
@@ -460,7 +580,38 @@ export async function createAlignmentReferenceUsingEspeakForFragments(fragments:
 
 	progressLogger.start("Synthesize alignment reference with eSpeak")
 
-	const result = await Espeak.synthesizeFragments(fragments, espeakOptions)
+	const result = {
+		rawAudio: getEmptyRawAudio(1, await Espeak.getSampleRate()) as RawAudio,
+		timeline: [] as Timeline,
+		events: [] as EspeakEvent[],
+	}
+
+	// Split fragments to chunks and process each chunk individually,
+	// and incrementally merge the chunks to the final result.
+	{
+		const maxFragmentsInChunk = 1000
+
+		let timeOffset = 0
+
+		for (let startOffset = 0; startOffset < fragments.length; startOffset += maxFragmentsInChunk) {
+			const chunk = fragments.slice(startOffset, startOffset + maxFragmentsInChunk)
+
+			const chunkResult = await Espeak.synthesizeFragments(chunk, espeakOptions)
+
+			result.rawAudio = {
+				sampleRate: result.rawAudio.sampleRate,
+				audioChannels: concatAudioSegments([result.rawAudio.audioChannels, chunkResult.rawAudio.audioChannels])
+			}
+
+			const chunkTimeline = addTimeOffsetToTimeline(chunkResult.timeline, timeOffset)
+
+			result.timeline = [...result.timeline, ...chunkTimeline]
+
+			result.events = [...result.events, ...chunkResult.events]
+
+			timeOffset += getRawAudioDuration(chunkResult.rawAudio)
+		}
+	}
 
 	result.timeline = result.timeline.flatMap(clause => clause.timeline!)
 
@@ -473,7 +624,14 @@ export async function createAlignmentReferenceUsingEspeakForFragments(fragments:
 	return result
 }
 
-export async function createAlignmentReferenceUsingEspeak(transcript: string, language: string, plaintextOptions?: API.PlainTextOptions, customLexiconPaths?: string[], insertSeparators?: boolean) {
+export async function createAlignmentReferenceUsingEspeak(
+	transcript: string,
+	language: string,
+	plaintextOptions?: API.PlainTextOptions,
+	customLexiconPaths?: string[],
+	insertSeparators?: boolean,
+	useKlatt?: boolean) {
+
 	const logger = new Logger()
 
 	logger.start('Synthesize alignment reference with eSpeak')
@@ -486,7 +644,7 @@ export async function createAlignmentReferenceUsingEspeak(transcript: string, la
 		customLexiconPaths: customLexiconPaths,
 
 		espeak: {
-			useKlatt: false,
+			useKlatt,
 			insertSeparators,
 		}
 	}

package/src/api/API.ts

@@ -2,15 +2,31 @@
 
 export * from './Common.js'
 export * from './GlobalOptions.js'
+
 export * from './Synthesis.js'
+
 export * from './Recognition.js'
+
 export * from './Alignment.js'
-export * from './Translation.js'
+
+export * from './SpeechTranslation.js'
+export * from './TextTranslation.js'
+
 export * from './TranslationAlignment.js'
-export * from './LanguageDetection.js'
+export * from './TranscriptAndTranslationAlignment.js'
+export * from './TimelineTranslationAlignment.js'
+
+export * from './LanguageDetectionCommon.js'
+export * from './SpeechLanguageDetection.js'
+export * from './TextLanguageDetection.js'
+
 export * from './VoiceActivityDetection.js'
+
 export * from './Denoising.js'
+
 export * from './SourceSeparation.js'
+
 export * from '../server/Server.js'
 export * from '../server/Client.js'
+
 export { timelineToSubtitles, subtitlesToTimeline } from '../subtitles/Subtitles.js'

package/src/api/APIOptions.ts

@@ -3,18 +3,31 @@ import type { ServerOptions } from '../server/Server.js'
 import { CLIOptions } from '../cli/CLIOptions.js'
 
 export interface APIOptions {
-	VoiceListRequestOptions: API.VoiceListRequestOptions
 	SynthesisOptions: API.SynthesisOptions
+	VoiceListRequestOptions: API.VoiceListRequestOptions
+
 	RecognitionOptions: API.RecognitionOptions
+
 	AlignmentOptions: API.AlignmentOptions
+
 	TranslationAlignmentOptions: API.TranslationAlignmentOptions
+	TranscriptAndTranslationAlignmentOptions: API.TranscriptAndTranslationAlignmentOptions
+	TimelineTranslationAlignmentOptions: API.TimelineTranslationAlignmentOptions
+
 	SpeechTranslationOptions: API.SpeechTranslationOptions
+	TextTranslationOptions: API.TextTranslationOptions
+
 	SpeechLanguageDetectionOptions: API.SpeechLanguageDetectionOptions
 	TextLanguageDetectionOptions: API.TextLanguageDetectionOptions
+
 	VADOptions: API.VADOptions
+
 	DenoisingOptions: API.DenoisingOptions
+
 	SourceSeparationOptions: API.SourceSeparationOptions
+
 	ServerOptions: ServerOptions
+
 	GlobalOptions: API.GlobalOptions
 	CLIOptions: CLIOptions
 }

package/src/api/Alignment.ts

@@ -9,19 +9,14 @@ import { Timeline, addTimeOffsetToTimeline, addWordTextOffsetsToTimeline, wordTi
 import { formatLanguageCodeWithName, getDefaultDialectForLanguageCodeIfPossible, getShortLanguageCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { type WhisperAlignmentOptions } from '../recognition/WhisperSTT.js'
 import chalk from 'chalk'
-import { DtwGranularity, createAlignmentReferenceUsingEspeak } from '../alignment/SpeechAlignment.js'
+import { DtwGranularity, alignUsingDtwWithEmbeddings, createAlignmentReferenceUsingEspeak } from '../alignment/SpeechAlignment.js'
 import { type SubtitlesConfig } from '../subtitles/Subtitles.js'
 import { type EspeakOptions, defaultEspeakOptions } from '../synthesis/EspeakTTS.js'
 import { isWord } from '../nlp/Segmentation.js'
-import { alignText } from '../alignment/TextAlignment.js'
-import { translateText } from '../text-translation/NLLBTextTranslation.js'
 
 const log = logToStderr
 
 export async function align(input: AudioSourceParam, transcript: string, options: AlignmentOptions): Promise<AlignmentResult> {
-	//await alignText(transcript, transcript)
-	//await translateText(transcript, 'en', 'de')
-
 	const logger = new Logger()
 
 	const startTimestamp = logger.getTimestamp()
@@ -164,7 +159,7 @@ export async function align(input: AudioSourceParam, transcript: string, options
 			const {
 				referenceRawAudio,
 				referenceTimeline
-			} = await createAlignmentReferenceUsingEspeak(transcript, language, options.plainText, options.customLexiconPaths, false)
+			} = await createAlignmentReferenceUsingEspeak(transcript, language, options.plainText, options.customLexiconPaths, false, false)
 
 			logger.end()
 
@@ -196,7 +191,7 @@ export async function align(input: AudioSourceParam, transcript: string, options
 				referenceRawAudio,
 				referenceTimeline,
 				espeakVoice,
-			} = await createAlignmentReferenceUsingEspeak(transcript, language, options.plainText, options.customLexiconPaths, false)
+			} = await createAlignmentReferenceUsingEspeak(transcript, language, options.plainText, options.customLexiconPaths, false, false)
 
 			logger.end()
 
@@ -225,6 +220,33 @@ export async function align(input: AudioSourceParam, transcript: string, options
 			break
 		}
 
+		case 'dtw-ea': {
+			const { windowDurations, granularities } = getDtwWindowGranularitiesAndDurations()
+
+			logger.end()
+
+			logger.logTitledMessage(`Warning`, `The dtw-ea alignment engine is just an early experiment and doesn't currently perform as well as, or as efficiently as other alignment engines.`, chalk.yellow, 'warning')
+
+			const {
+				referenceRawAudio,
+				referenceTimeline
+			} = await createAlignmentReferenceUsingEspeak(transcript, language, options.plainText, options.customLexiconPaths, false, true)
+
+			logger.end()
+
+			const shortLanguageCode = getShortLanguageCode(language)
+
+			mappedTimeline = await alignUsingDtwWithEmbeddings(
+				sourceRawAudio,
+				referenceRawAudio,
+				referenceTimeline,
+				shortLanguageCode,
+				granularities,
+				windowDurations)
+
+			break
+		}
+
 		case 'whisper': {
 			const WhisperSTT = await import('../recognition/WhisperSTT.js')
 
@@ -315,7 +337,7 @@ export interface AlignmentResult {
 	backgroundRawAudio?: RawAudio
 }
 
-export type AlignmentEngine = 'dtw' | 'dtw-ra' | 'whisper'
+export type AlignmentEngine = 'dtw' | 'dtw-ra' | 'dtw-ea' | 'whisper'
 export type PhoneAlignmentMethod = 'interpolation' | 'dtw'
 
 export interface AlignmentOptions {

package/src/api/LanguageDetectionCommon.ts

@@ -0,0 +1,7 @@
+export type LanguageDetectionResults = LanguageDetectionResultsEntry[]
+
+export interface LanguageDetectionResultsEntry {
+	language: string
+	languageName: string
+	probability: number
+}

package/src/api/Recognition.ts

@@ -319,8 +319,10 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 
 export interface RecognitionResult {
 	transcript: string
+
 	timeline: Timeline
 	wordTimeline: Timeline
+	
 	language: string
 
 	inputRawAudio: RawAudio

package/src/api/{LanguageDetection.ts → SpeechLanguageDetection.ts}

@@ -13,12 +13,10 @@ import chalk from 'chalk'
 import { type WhisperCppOptions } from '../recognition/WhisperCppSTT.js'
 import { type SileroLanguageDetectionOptions } from '../speech-language-detection/SileroLanguageDetection.js'
 import { OnnxExecutionProvider } from '../utilities/OnnxUtilities.js'
+import { LanguageDetectionResults } from './LanguageDetectionCommon.js'
 
 const log = logToStderr
 
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Speech language detection
-/////////////////////////////////////////////////////////////////////////////////////////////
 export async function detectSpeechLanguage(input: AudioSourceParam, options: SpeechLanguageDetectionOptions): Promise<SpeechLanguageDetectionResult> {
 	const logger = new Logger()
 
@@ -238,107 +236,6 @@ export const defaultSpeechLanguageDetectionOptions: SpeechLanguageDetectionOptio
 	}
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Text language detection
-/////////////////////////////////////////////////////////////////////////////////////////////
-export async function detectTextLanguage(input: string, options: TextLanguageDetectionOptions): Promise<TextLanguageDetectionResult> {
-	const logger = new Logger()
-
-	options = extendDeep(defaultTextLanguageDetectionOptions, options)
-
-	const defaultLanguage = options.defaultLanguage!
-	const fallbackThresholdProbability = options.fallbackThresholdProbability!
-
-	let detectedLanguageProbabilities: LanguageDetectionResults
-
-	logger.start(`Initialize ${options.engine} module`)
-
-	switch (options.engine) {
-		case 'tinyld': {
-			const { detectLanguage } = await import('../text-language-detection/TinyLDLanguageDetection.js')
-
-			logger.start('Detect text language using tinyld')
-
-			detectedLanguageProbabilities = await detectLanguage(input)
-
-			break
-		}
-
-		case 'fasttext': {
-			const { detectLanguage } = await import('../text-language-detection/FastTextLanguageDetection.js')
-
-			logger.start('Detect text language using FastText')
-
-			detectedLanguageProbabilities = await detectLanguage(input)
-
-			break
-		}
-
-		default: {
-			throw new Error(`Engine '${options.engine}' is not supported`)
-		}
-	}
-
-	let detectedLanguage: string
-
-	if (detectedLanguageProbabilities.length == 0 ||
-		detectedLanguageProbabilities[0].probability < fallbackThresholdProbability) {
-
-		detectedLanguage = defaultLanguage
-	} else {
-		detectedLanguage = detectedLanguageProbabilities[0].language
-	}
-
-	logger.end()
-
-	return {
-		detectedLanguage,
-		detectedLanguageName: languageCodeToName(detectedLanguage),
-		detectedLanguageProbabilities
-	}
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Types
-/////////////////////////////////////////////////////////////////////////////////////////////
-
-export interface TextLanguageDetectionResult {
-	detectedLanguage: string
-	detectedLanguageName: string
-	detectedLanguageProbabilities: LanguageDetectionResults
-}
-
-export type LanguageDetectionResults = LanguageDetectionResultsEntry[]
-export interface LanguageDetectionResultsEntry {
-	language: string
-	languageName: string
-	probability: number
-}
-
-export type LanguageDetectionGroupResults = LanguageDetectionGroupResultsEntry[]
-export interface LanguageDetectionGroupResultsEntry {
-	languageGroup: string
-	probability: number
-}
-
-export type TextLanguageDetectionEngine = 'tinyld' | 'fasttext'
-
-export interface TextLanguageDetectionOptions {
-	engine?: TextLanguageDetectionEngine
-	defaultLanguage?: string
-	fallbackThresholdProbability?: number
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Constants
-/////////////////////////////////////////////////////////////////////////////////////////////
-
-export const defaultTextLanguageDetectionOptions: TextLanguageDetectionOptions = {
-	engine: 'tinyld',
-	defaultLanguage: 'en',
-	fallbackThresholdProbability: 0.05,
-}
-
 export const speechLanguageDetectionEngines: API.EngineMetadata[] = [
 	{
 		id: 'silero',
@@ -359,18 +256,3 @@ export const speechLanguageDetectionEngines: API.EngineMetadata[] = [
 		type: 'local'
 	},
 ]
-
-export const textLanguageDetectionEngines: API.EngineMetadata[] = [
-	{
-		id: 'tinyld',
-		name: 'TinyLD',
-		description: 'A simple language detection library.',
-		type: 'local'
-	},
-	{
-		id: 'fasttext',
-		name: 'FastText',
-		description: 'A library for word representations and sentence classification by Facebook research.',
-		type: 'local'
-	},
-]

package/src/api/{Translation.ts → SpeechTranslation.ts}

@@ -6,7 +6,7 @@ import { Logger } from '../utilities/Logger.js'
 
 import { Timeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
 import { type WhisperOptions } from '../recognition/WhisperSTT.js'
-import { formatLanguageCodeWithName, getShortLanguageCode, normalizeIdentifierToLangaugeCode, parseLangIdentifier } from '../utilities/Locale.js'
+import { formatLanguageCodeWithName, getShortLanguageCode, normalizeIdentifierToLanguageCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { EngineMetadata } from './Common.js'
 import { type SpeechLanguageDetectionOptions, detectSpeechLanguage } from './API.js'
 import chalk from 'chalk'
@@ -81,7 +81,7 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 		logger.logTitledMessage('Source language detected', formatLanguageCodeWithName(detectedLanguage))
 	}
 
-	options.targetLanguage = await normalizeIdentifierToLangaugeCode(options.targetLanguage!)
+	options.targetLanguage = await normalizeIdentifierToLanguageCode(options.targetLanguage!)
 
 	logger.logTitledMessage('Target language', formatLanguageCodeWithName(options.targetLanguage))