echogarden 1.4.4 → 1.6.0

package/src/cli/CLI.ts

@@ -1,12 +1,12 @@
 import * as API from '../api/API.js'
 import { parseCLIArguments } from './CLIParser.js'
-import { clip, convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements, getWithDefault, logToStderr, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from '../utilities/Utilities.js'
+import { convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements, getWithDefault, logToStderr, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from '../utilities/Utilities.js'
 import { getOptionTypeFromSchema, SchemaTypeDefinition } from './CLIOptionsSchema.js'
 import { ParsedConfigFile, parseConfigFile, parseJSONConfigFile } from './CLIConfigFile.js'
 
 import chalk from 'chalk'
 import { RawAudio, applyGainDecibels, encodeRawAudioToWave, getEmptyRawAudio, getRawAudioDuration, normalizeAudioLevel, sliceRawAudioByTime } from '../audio/AudioUtilities.js'
-import { SubtitlesConfig, subtitlesToText, subtitlesToTimeline, timelineToSubtitles } from '../subtitles/Subtitles.js'
+import { SubtitlesConfig, subtitlesToText, timelineToSubtitles } from '../subtitles/Subtitles.js'
 import { Logger, resetActiveLogger } from '../utilities/Logger.js'
 import { isMainThread, parentPort } from 'node:worker_threads'
 import { encodeFromChannels, getDefaultFFMpegOptionsForSpeech } from '../codecs/FFMpegTranscoder.js'
@@ -219,19 +219,25 @@ const help = [
 	`${executableName} ${chalk.magentaBright('speak-url')} url [output files...] [options...]`,
 	`    Speak the HTML document on the given URL\n`,
 	`${executableName} ${chalk.magentaBright('speak-wikipedia')} articleName [output files...] [options...]`,
-	`    Speak the given wikipedia article, language edition can be specified by --language=<langCode>\n`,
+	`    Speak the given Wikipedia article. Language edition can be specified by --language=<langCode>\n`,
 	`${executableName} ${chalk.magentaBright('transcribe')} audioFile [output files...] [options...]`,
-	`    Transcribe audio file\n`,
-	`${executableName} ${chalk.magentaBright('align')} audioFile referenceFile [output files...] [options...]`,
-	`    Align audio file to the reference transcript file\n`,
-	`${executableName} ${chalk.magentaBright('translate-speech')} inputFile [output files...] [options...]`,
-	`    Transcribe audio file directly to a different language\n`,
-	`${executableName} ${chalk.magentaBright('align-translation')} audioFile referenceFile [output files...] [options...]`,
-	`    Align audio file to the reference translated transcript file\n`,
-	`${executableName} ${chalk.magentaBright('detect-speech-language')} audioFile [output files...] [options...]`,
-	`    Detect language of audio file\n`,
+	`    Transcribe a spoken audio file\n`,
+	`${executableName} ${chalk.magentaBright('align')} audioFile transcriptFile [output files...] [options...]`,
+	`    Align spoken audio file to its transcript\n`,
+	`${executableName} ${chalk.magentaBright('translate-text')} inputFile [output files...] [options...]`,
+	`    Translate text to a different language\n`,
+	`${executableName} ${chalk.magentaBright('translate-speech')} audioFile [output files...] [options...]`,
+	`    Transcribe spoken audio file directly to a different language\n`,
+	`${executableName} ${chalk.magentaBright('align-translation')} audioFile translatedTranscriptFile [output files...] [options...]`,
+	`    Align spoken audio file to its translated transcript\n`,
+	`${executableName} ${chalk.magentaBright('align-transcript-and-translation')} audioFile transcriptFile translatedTranscriptFile [output files...] [options...]`,
+	`    Align spoken audio file to both its transcript and its translated transcript using a two-stage approach.\n`,
+	`${executableName} ${chalk.magentaBright('align-timeline-translation')} timelineFile translatedFile [output files...] [options...]`,
+	`    Align a given timeline file to its translated text\n`,
 	`${executableName} ${chalk.magentaBright('detect-text-language')} inputFile [output files...] [options...]`,
 	`    Detect language of textual file\n`,
+	`${executableName} ${chalk.magentaBright('detect-speech-language')} audioFile [output files...] [options...]`,
+	`    Detect language of spoken audio file\n`,
 	`${executableName} ${chalk.magentaBright('detect-voice-activity')} audioFile [output files...] [options...]`,
 	`    Detect voice activity in audio file\n`,
 	`${executableName} ${chalk.magentaBright('denoise')} audioFile [output files...] [options...]`,
@@ -275,6 +281,11 @@ async function startWithArgs(operationData: CLIOperationData) {
 			break
 		}
 
+		case 'translate-text': {
+			await translateText(operationData)
+			break
+		}
+
 		case 'translate-speech': {
 			await translateSpeech(operationData)
 			break
@@ -285,6 +296,16 @@ async function startWithArgs(operationData: CLIOperationData) {
 			break
 		}
 
+		case 'align-transcript-and-translation': {
+			await alignTranscriptAndTranslation(operationData)
+			break
+		}
+
+		case 'align-timeline-translation': {
+			await alignTimelineTranslation(operationData)
+			break
+		}
+
 		case 'detect-language': {
 			await detectLanguage(operationData, 'auto')
 			break
@@ -352,7 +373,7 @@ async function startWithArgs(operationData: CLIOperationData) {
 	}
 }
 
-async function speak(operationData: CLIOperationData) {
+export async function speak(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operation, operationOptionsLookup, cliOptions } = operationData
@@ -424,8 +445,8 @@ async function speak(operationData: CLIOperationData) {
 			textSegments = splitToParagraphs(textContent, 'single', 'preserve')
 		} else if (sourceFileExtension == 'srt' || sourceFileExtension == 'vtt') {
 			const fileContent = await readFile(sourceFile, { encoding: 'utf-8' })
-			textSegments = subtitlesToTimeline(fileContent).map(entry => entry.text)
-			//textSegments = [subtitlesToText(fileContent)]
+			//textSegments = subtitlesToTimeline(fileContent).map(entry => entry.text)
+			textSegments = [subtitlesToText(fileContent)]
 		} else if (sourceFileExtension == 'xml' || sourceFileExtension == 'ssml') {
 			options.ssml = true
 			textSegments = [fileContent]
@@ -510,7 +531,7 @@ async function speak(operationData: CLIOperationData) {
 	logger.end()
 }
 
-async function transcribe(operationData: CLIOperationData) {
+export async function transcribe(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -572,7 +593,7 @@ async function transcribe(operationData: CLIOperationData) {
 	}
 }
 
-async function align(operationData: CLIOperationData) {
+export async function align(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -668,7 +689,7 @@ async function align(operationData: CLIOperationData) {
 	}
 }
 
-async function alignTranslation(operationData: CLIOperationData) {
+export async function alignTranslation(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -677,7 +698,7 @@ async function alignTranslation(operationData: CLIOperationData) {
 	const outputFilenames = operationArgs.slice(2)
 
 	if (audioFilename == undefined) {
-		throw new Error(`align-translation requires an argument containing the audio file path.`)
+		throw new Error(`align-translation requires a first argument containing the audio file path.`)
 	}
 
 	if (!existsSync(audioFilename)) {
@@ -706,7 +727,7 @@ async function alignTranslation(operationData: CLIOperationData) {
 	} else if (referenceFileExtension == 'srt' || referenceFileExtension == 'vtt') {
 		text = subtitlesToText(fileContent)
 	} else {
-		throw new Error(`align only supports reference files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
+		throw new Error(`align-translation only supports reference files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
 	}
 
 	if (cliOptions.play == null) {
@@ -721,8 +742,9 @@ async function alignTranslation(operationData: CLIOperationData) {
 	const {
 		timeline,
 		wordTimeline,
-		transcript,
-		language,
+		translatedTranscript,
+		sourceLanguage,
+		targetLanguage,
 		inputRawAudio,
 		isolatedRawAudio,
 		backgroundRawAudio } = await API.alignTranslation(audioFilename, text, options)
@@ -737,10 +759,139 @@ async function alignTranslation(operationData: CLIOperationData) {
 			const segmentAudio = sliceRawAudioByTime(inputRawAudio, segmentEntry.startTime, segmentEntry.endTime)
 			const sentenceTimeline = addTimeOffsetToTimeline(segmentEntry.timeline!, -segmentEntry.startTime)
 
-			await writeOutputFilesForSegment(outputFilenames, segmentIndex, timeline.length, segmentAudio, sentenceTimeline, segmentEntry.text, language, allowOverwrite)
+			await writeOutputFilesForSegment(outputFilenames, segmentIndex, timeline.length, segmentAudio, sentenceTimeline, segmentEntry.text, targetLanguage, allowOverwrite)
+		}
+	}
+
+	for (const outputFilename of outputFilenames) {
+		const partPatternMatch = outputFilename.match(filenamePlaceholderPattern)
+
+		if (partPatternMatch) {
+			continue
+		}
+
+		const fileSaver = getFileSaver(outputFilename, allowOverwrite)
+
+		await fileSaver(inputRawAudio, timeline, translatedTranscript, options.subtitles)
+
+		await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true)
+	}
+
+	logger.end()
+
+	if (cliOptions.play) {
+		let audioToPlay: RawAudio
+
+		if (isolatedRawAudio) {
+			audioToPlay = isolatedRawAudio
+		} else {
+			audioToPlay = inputRawAudio
+		}
+
+		const normalizedAudioToPlay = normalizeAudioLevel(audioToPlay)
+
+		await playAudioWithWordTimeline(normalizedAudioToPlay, wordTimeline, translatedTranscript)
+	}
+}
+
+export async function alignTranscriptAndTranslation(operationData: CLIOperationData) {
+	const logger = new Logger()
+
+	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
+
+	const audioFilename = operationArgs[0]
+	const outputFilenames = operationArgs.slice(3)
+
+	if (audioFilename == undefined) {
+		throw new Error(`align-transcript-and-translation requires a first argument containing the audio file path.`)
+	}
+
+	if (!existsSync(audioFilename)) {
+		throw new Error(`The given source file '${audioFilename}' was not found.`)
+	}
+
+	const nativeTranscriptFilePath = operationArgs[1]
+
+	if (nativeTranscriptFilePath == undefined) {
+		throw new Error(`align-transcript-and-translation requires a second argument containing the native language transcript file path.`)
+	}
+
+	if (!existsSync(nativeTranscriptFilePath)) {
+		throw new Error(`The given transcript file '${nativeTranscriptFilePath}' was not found.`)
+	}
+
+	const translatedTranscriptFilePath = operationArgs[2]
+
+	if (translatedTranscriptFilePath == undefined) {
+		throw new Error(`align-transcript-and-translation requires a third argument containing the translated language transcript file path.`)
+	}
+
+	if (!existsSync(translatedTranscriptFilePath)) {
+		throw new Error(`The given translated transcript file '${nativeTranscriptFilePath}' was not found.`)
+	}
+
+	let transcript: string
+
+	{
+		const nativeTranscriptFileExtension = getLowercaseFileExtension(nativeTranscriptFilePath)
+		const fileContent = await readFile(nativeTranscriptFilePath, { encoding: 'utf-8' })
+
+
+		if (nativeTranscriptFileExtension == 'txt') {
+			transcript = fileContent
+		} else if (nativeTranscriptFileExtension == 'html' || nativeTranscriptFileExtension == 'htm') {
+			transcript = await convertHtmlToText(fileContent)
+		} else if (nativeTranscriptFileExtension == 'srt' || nativeTranscriptFileExtension == 'vtt') {
+			transcript = subtitlesToText(fileContent)
+		} else {
+			throw new Error(`align-transcript-and-translation only supports transcript files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
+		}
+	}
+
+	let translatedTranscript: string
+
+	{
+		const translatedTranscriptFileExtension = getLowercaseFileExtension(translatedTranscriptFilePath)
+		const fileContent = await readFile(translatedTranscriptFilePath, { encoding: 'utf-8' })
+
+		if (translatedTranscriptFileExtension == 'txt') {
+			translatedTranscript = fileContent
+		} else if (translatedTranscriptFileExtension == 'html' || translatedTranscriptFileExtension == 'htm') {
+			translatedTranscript = await convertHtmlToText(fileContent)
+		} else if (translatedTranscriptFileExtension == 'srt' || translatedTranscriptFileExtension == 'vtt') {
+			translatedTranscript = subtitlesToText(fileContent)
+		} else {
+			throw new Error(`align-transcript-and-translation only supports transcript files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
 		}
 	}
 
+	if (cliOptions.play == null) {
+		cliOptions.play = outputFilenames.length === 0
+	}
+
+	const options = await optionsLookupToTypedObject(operationOptionsLookup, 'TranscriptAndTranslationAlignmentOptions')
+
+	const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault)
+	const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true)
+
+	const {
+		timeline,
+		wordTimeline,
+
+		translatedTimeline,
+		translatedWordTimeline,
+
+		sourceLanguage,
+		targetLanguage,
+
+		inputRawAudio,
+		isolatedRawAudio,
+		backgroundRawAudio } = await API.alignTranscriptAndTranslation(audioFilename, transcript, translatedTranscript, options)
+
+	if (outputFilenames.length > 0) {
+		logger.start('\nWrite output files')
+	}
+
 	for (const outputFilename of outputFilenames) {
 		const partPatternMatch = outputFilename.match(filenamePlaceholderPattern)
 
@@ -753,6 +904,16 @@ async function alignTranslation(operationData: CLIOperationData) {
 		await fileSaver(inputRawAudio, timeline, transcript, options.subtitles)
 
 		await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true)
+
+		const fileExtension = getLowercaseFileExtension(outputFilename)
+
+		if (['json', 'txt', 'srt', 'vtt'].includes(fileExtension)) {
+			const pathWithoutExtension = outputFilename.substring(0, outputFilename.lastIndexOf('.'))
+			const translatedOutputPath = `${pathWithoutExtension}.translated.${fileExtension}`
+
+			const translatedFileSaver = getFileSaver(translatedOutputPath, allowOverwrite)
+			await translatedFileSaver(inputRawAudio, translatedTimeline, translatedTranscript, options.subtitles)
+		}
 	}
 
 	logger.end()
@@ -768,11 +929,168 @@ async function alignTranslation(operationData: CLIOperationData) {
 
 		const normalizedAudioToPlay = normalizeAudioLevel(audioToPlay)
 
-		await playAudioWithWordTimeline(normalizedAudioToPlay, wordTimeline, transcript)
+		await playAudioWithWordTimeline(normalizedAudioToPlay, translatedWordTimeline, translatedTranscript)
 	}
 }
 
-async function translateSpeech(operationData: CLIOperationData) {
+export async function alignTimelineTranslation(operationData: CLIOperationData) {
+	const logger = new Logger()
+
+	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
+
+	const timelineFilename = operationArgs[0]
+	const outputFilenames = operationArgs.slice(2)
+
+	if (timelineFilename == undefined) {
+		throw new Error(`align-timeline-translation requires a first argument containing the timeline file path.`)
+	}
+
+	if (getLowercaseFileExtension(timelineFilename) != 'json') {
+		throw new Error(`align-timeline-translation only supports timeline files with extension 'json'`)
+	}
+
+	if (!existsSync(timelineFilename)) {
+		throw new Error(`The given timeline file '${timelineFilename}' was not found.`)
+	}
+
+	const timeline = await readAndParseJsonFile(timelineFilename) as Timeline
+
+	const translationFilePath = operationArgs[1]
+
+	if (translationFilePath == undefined) {
+		throw new Error(`align-timeline-translation requires a second argument containing the translated reference file path.`)
+	}
+
+	if (!existsSync(translationFilePath)) {
+		throw new Error(`The given reference file '${translationFilePath}' was not found.`)
+	}
+
+	const translationFileExtension = getLowercaseFileExtension(translationFilePath)
+	const translationFileContent = await readFile(translationFilePath, { encoding: 'utf-8' })
+
+	let translationText: string
+
+	if (translationFileExtension == 'txt') {
+		translationText = translationFileContent
+	} else if (translationFileExtension == 'html' || translationFileExtension == 'htm') {
+		translationText = await convertHtmlToText(translationFileContent)
+	} else if (translationFileExtension == 'srt' || translationFileExtension == 'vtt') {
+		translationText = subtitlesToText(translationFileContent)
+	} else {
+		throw new Error(`align only supports reference files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
+	}
+
+	const options = await optionsLookupToTypedObject(operationOptionsLookup, 'TimelineTranslationAlignmentOptions')
+
+	const {
+		timeline: translationTimeline,
+		wordTimeline: translationWordTimeline,
+		rawAudio
+	} = await API.alignTimelineTranslation(timeline, translationText, options)
+
+	if (outputFilenames.length > 0) {
+		logger.start('\nWrite output files')
+	}
+
+	const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault)
+
+	for (const outputFilename of outputFilenames) {
+		const partPatternMatch = outputFilename.match(filenamePlaceholderPattern)
+
+		if (partPatternMatch) {
+			continue
+		}
+
+		const fileSaver = getFileSaver(outputFilename, allowOverwrite)
+
+		await fileSaver(getEmptyRawAudio(1, 16000), translationTimeline, translationText, options.subtitles)
+	}
+
+	logger.end()
+
+	if (cliOptions.play && rawAudio) {
+		const normalizedAudioToPlay = normalizeAudioLevel(rawAudio)
+
+		let transcriptToPlay: string
+		let timelineToPlay: Timeline
+
+		transcriptToPlay = translationText
+		timelineToPlay = translationWordTimeline
+
+		await playAudioWithWordTimeline(normalizedAudioToPlay, timelineToPlay, transcriptToPlay)
+	}
+}
+
+export async function translateText(operationData: CLIOperationData) {
+	const logger = new Logger()
+
+	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
+
+	const inputFilename = operationArgs[0]
+	const outputFilenames = operationArgs.slice(1)
+
+	if (inputFilename == undefined) {
+		throw new Error(`translate-text requires an argument containing the input file path.`)
+	}
+
+	if (!existsSync(inputFilename)) {
+		throw new Error(`The given input file '${inputFilename}' was not found.`)
+	}
+
+	const inputFileExtension = getLowercaseFileExtension(inputFilename)
+	const inputFileContent = await readFile(inputFilename, { encoding: 'utf-8' })
+
+	let inputText: string
+
+	if (inputFileExtension === 'txt') {
+		inputText = inputFileContent
+	} else if (inputFileExtension === 'html' || inputFileExtension === 'htm') {
+		inputText = await convertHtmlToText(inputFileContent)
+	} else if (inputFileExtension == 'srt' || inputFileExtension == 'vtt') {
+		inputText = subtitlesToText(inputFileContent)
+	} else {
+		throw new Error(`align only supports reference files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
+	}
+
+	const options = await optionsLookupToTypedObject(operationOptionsLookup, 'TextTranslationOptions')
+
+	const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault)
+
+	await checkOutputFilenames(outputFilenames, false, true, true)
+
+	const {
+		text,
+		translatedText,
+
+		translationPairs,
+
+		sourceLanguage,
+		targetLanguage,
+	} = await API.translateText(inputFileContent, options)
+
+	if (outputFilenames.length > 0) {
+		logger.start('\nWrite output files')
+
+		for (const outputFilename of outputFilenames) {
+			const partPatternMatch = outputFilename.match(filenamePlaceholderPattern)
+
+			if (partPatternMatch) {
+				continue
+			}
+
+			const fileSaver = getFileSaver(outputFilename, allowOverwrite)
+
+			await fileSaver(getEmptyRawAudio(1, 16000), translationPairs as any as Timeline, translatedText, undefined)
+		}
+
+		logger.end()
+	} else {
+		logger.log(``)
+		logger.log(translatedText)
+	}
+}
+
+export async function translateSpeech(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -798,7 +1116,19 @@ async function translateSpeech(operationData: CLIOperationData) {
 
 	await checkOutputFilenames(outputFilenames, true, true, true)
 
-	const { transcript, timeline, wordTimeline, sourceLanguage, targetLanguage, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.translateSpeech(inputFilename, options)
+	const {
+		transcript,
+
+		timeline,
+		wordTimeline,
+
+		sourceLanguage,
+		targetLanguage,
+
+		inputRawAudio,
+		isolatedRawAudio,
+		backgroundRawAudio
+	} = await API.translateSpeech(inputFilename, options)
 
 	if (outputFilenames.length > 0) {
 		logger.start('\nWrite output files')
@@ -859,7 +1189,7 @@ async function translateSpeech(operationData: CLIOperationData) {
 	}
 }
 
-async function detectLanguage(operationData: CLIOperationData, mode: 'speech' | 'text' | 'auto') {
+export async function detectLanguage(operationData: CLIOperationData, mode: 'speech' | 'text' | 'auto') {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -936,7 +1266,7 @@ async function detectLanguage(operationData: CLIOperationData, mode: 'speech' |
 	logger.end()
 }
 
-async function detectVoiceActivity(operationData: CLIOperationData) {
+export async function detectVoiceActivity(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -1005,7 +1335,7 @@ async function detectVoiceActivity(operationData: CLIOperationData) {
 	}
 }
 
-async function denoise(operationData: CLIOperationData) {
+export async function denoise(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -1050,7 +1380,7 @@ async function denoise(operationData: CLIOperationData) {
 	}
 }
 
-async function isolate(operationData: CLIOperationData) {
+export async function isolate(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -1093,7 +1423,7 @@ async function isolate(operationData: CLIOperationData) {
 	}
 }
 
-async function listEngines(operationData: CLIOperationData) {
+export async function listEngines(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs } = operationData
@@ -1140,6 +1470,12 @@ async function listEngines(operationData: CLIOperationData) {
 			break
 		}
 
+		case 'translate-text': {
+			engines = API.textTranslationEngines
+
+			break
+		}
+
 		case 'translate-speech': {
 			engines = API.speechTranslationEngines
 
@@ -1190,7 +1526,7 @@ async function listEngines(operationData: CLIOperationData) {
 		}
 
 		default: {
-			throw new Error(`Unrecognized operation: '${targetOperation}'`)
+			throw new Error(`Unrecognized operation name: '${targetOperation}'`)
 		}
 	}
 
@@ -1206,7 +1542,7 @@ async function listEngines(operationData: CLIOperationData) {
 	}
 }
 
-async function listTTSVoices(operationData: CLIOperationData) {
+export async function listTTSVoices(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs, operationOptionsLookup, cliOptions } = operationData
@@ -1268,7 +1604,7 @@ async function listTTSVoices(operationData: CLIOperationData) {
 	logger.end()
 }
 
-async function installPackages(operationData: CLIOperationData) {
+export async function installPackages(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs } = operationData
@@ -1299,7 +1635,7 @@ async function installPackages(operationData: CLIOperationData) {
 	}
 }
 
-async function uninstallPackages(operationData: CLIOperationData) {
+export async function uninstallPackages(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const { operationArgs } = operationData
@@ -1326,7 +1662,7 @@ async function uninstallPackages(operationData: CLIOperationData) {
 	}
 }
 
-async function listPackages(operationData: CLIOperationData) {
+export async function listPackages(operationData: CLIOperationData) {
 	const logger = new Logger()
 
 	const packagesDir = await ensureAndGetPackagesDir()
@@ -1358,7 +1694,7 @@ async function listPackages(operationData: CLIOperationData) {
 	logger.log(installedPackageNamesFormatted.join('\n'))
 }
 
-async function serve(operationData: CLIOperationData) {
+export async function serve(operationData: CLIOperationData) {
 	const { operationOptionsLookup } = operationData
 
 	const options = await optionsLookupToTypedObject(operationOptionsLookup, 'ServerOptions')
@@ -1500,7 +1836,7 @@ async function optionsLookupToTypedObject<K extends keyof APIOptions>(cliOptions
 }
 
 let cachedOptionsSchema: any
-export async function getOptionsSchema() {
+async function getOptionsSchema() {
 	if (!cachedOptionsSchema) {
 		cachedOptionsSchema = await readAndParseJsonFile(resolveToModuleRootDir('data/schemas/options.json'))
 	}
@@ -1508,7 +1844,7 @@ export async function getOptionsSchema() {
 	return cachedOptionsSchema
 }
 
-export async function checkOutputFilenames(outputFilenames: string[], acceptMediaOutputs: boolean, acceptMetadataOutputs: boolean, acceptSubtitleOutputs: boolean) {
+async function checkOutputFilenames(outputFilenames: string[], acceptMediaOutputs: boolean, acceptMetadataOutputs: boolean, acceptSubtitleOutputs: boolean) {
 	const supportedFileExtensions: string[] = []
 
 	if (acceptMediaOutputs) {
@@ -1562,7 +1898,7 @@ export async function checkOutputFilenames(outputFilenames: string[], acceptMedi
 	return { includesPlaceholderPattern }
 }
 
-export async function writeOutputFilesForSegment(outputFilenames: string[], index: number, total: number, audio: RawAudio, timeline: Timeline, text: string, language: string, allowOverwrite: boolean) {
+async function writeOutputFilesForSegment(outputFilenames: string[], index: number, total: number, audio: RawAudio, timeline: Timeline, text: string, language: string, allowOverwrite: boolean) {
 	const digitCount = Math.max((total + 1).toString().length, 2)
 
 	const segmentWords = (await splitToWords(text, language)).filter(text => wordCharacterPattern.test(text))

package/src/codecs/FFMpegTranscoder.ts

@@ -7,6 +7,7 @@ import { commandExists, logToStderr } from '../utilities/Utilities.js'
 import path from 'node:path'
 import { loadPackage } from '../utilities/PackageManager.js'
 import { getGlobalOption } from '../api/GlobalOptions.js'
+import { existsSync } from '../utilities/FileSystem.js'
 
 const log = logToStderr
 
@@ -67,6 +68,11 @@ async function transcode_CLI(ffmpegCommand: string, input: string | Buffer, outp
 
 		if (Buffer.isBuffer(input)) {
 			process.stdin.end(input)
+		} else if (typeof input === 'string') {
+			if (!existsSync(input)) {
+				reject(`Audio file was not found: ${input}`)
+				return
+			}
 		}
 
 		const stdoutChunks: Buffer[] = []

package/src/dsp/FFT.ts

@@ -48,7 +48,7 @@ export async function stftr(samples: Float32Array, fftOrder: number, windowSize:
 		}
 
 		binsBufferRef.clear()
-		
+
 		m._kiss_fftr(statePtr, frameBufferRef.address, binsBufferRef.address)
 
 		const bins = binsBufferRef.view.slice(0, fftOrder + 2)
@@ -229,6 +229,12 @@ export function getWindowWeights(windowType: WindowType, windowSize: number) {
 			//weights[i] = 0.54 - (0.46 * Math.cos(2 * Math.PI * (i / (windowSize - 1))))
 			weights[i] = 0.54 - (0.46 * Math.cos(innerFactor * i))
 		}
+	} else if (windowType == 'povey') {
+		const hannWeights = getWindowWeights('hann', windowSize)
+
+		for (let i = 0; i < windowSize; i++) {
+			weights[i] = hannWeights[i] ** 0.85
+		}
 	} else {
 		throw new Error(`Unsupported window function type: ${windowType}`)
 	}
@@ -255,4 +261,4 @@ export async function testFFT1(rawAudio: RawAudio) {
 	return recoveredRawAudio
 }
 
-export type WindowType = 'hann' | 'hamming'
+export type WindowType = 'hann' | 'hamming' | 'povey'