echogarden 0.12.2 → 1.0.1

package/docs/Technical.md

@@ -16,7 +16,7 @@ Packages are downloaded as `.tar.gz` files, and are extracted to `[data-folder]/
 * `Users/User/Library/Application Support/echogarden` on macOS
 * `/home/user/.local/share/echogarden` on Linux
 
-By using downloadable packages, the installed size is made significantly smaller and the installation faster. The total size of all available packages is currently about 16.2GB (11.4GB compressed).
+By using downloadable packages, the installed size is made significantly smaller and the installation faster. The total size of all available packages is currently about 50GB (may not be up-to-date).
 
 The packages are currently hosted and downloaded from a dedicated [Hugging Face repository](https://huggingface.co/echogarden/echogarden-packages).
 
@@ -24,14 +24,14 @@ The packages are currently hosted and downloaded from a dedicated [Hugging Face
 
 The base installed (uncompressed) size, including dependencies, is around 270MB. This is without any models or voices, which are downloaded as needed.
 
-Currently, the biggest contributors to the size are:
+Currently, the largest contributors to the size are:
 
 * `onnxruntime-node` (NAPI): 92MB
 * `kuromoji` (JavaScript) 40MB
 * `flite-wasi` (WASI): 20MB
 * `espeak-ng-emscripten` (WASM): 18MB
 
-`onnxruntime-node` is big because it bundles pre-compiled binaries for multiple platforms. `kuromoji` is large because of its dictionary files and some unessential test code it bundles. The other three packages include large WASM binaries.
+`onnxruntime-node` is large because it bundles pre-compiled binaries for multiple platforms. `kuromoji` is large because of its dictionary files and some unessential test code it bundles. The other three packages include large WASM binaries.
 
 So, yes, in the future it may be possible to reduce the core installed size by dynamically installing some of these dependencies, or using modified, "slimmed-down" versions of some packages.
 
@@ -51,7 +51,7 @@ However, it is a lot of work, and only a subset of the engines can be supported
 * Possibly lots of issues with inconsistent browser support and browser security constraints
 * Not future-proof. Due to changing restrictions of browsers, the runtime environment is not guaranteed be reliably reproducible in the future, meaning that it may need continuous maintenance to ensure it keeps working on the newest browsers
 
-It remains to be seen if this sort of work would feel justified somehow. I designed the tool to make the local installation extremely easy and issue-free. I guess it could look "impressive" to be able to run it in a browser, and may be come as a nice "toy" or "tech-demo", and could get some attention, but it may eventually turn out to be simpler and more practical to just install a local instance and connect to it from the browser via a WebSocket API.
+It remains to be seen if this sort of work would feel justified somehow. I designed the tool to make the local installation extremely easy and issue-free. I guess it could look "impressive" to be able to run it in a browser, and may become as a nice "toy" or "tech-demo", and could get some attention, but it may eventually turn out to be simpler and more practical to just install a local instance and connect to it from the browser via a WebSocket API.
 
 A TTS-only browser extension is in development. It registers Echogarden's voices on the browser's Web Speech API using the [`chrome.ttsEngine`](https://developer.chrome.com/docs/extensions/reference/ttsEngine/) extension API and communicates with it using the WebSocket API
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "echogarden",
-	"version": "0.12.2",
+	"version": "1.0.1",
 	"description": "An integrated speech toolset, providing a variety of synthesis, recognition, alignment, and other processing tools, designed to be directly accessible to end-users.",
 	"author": "Rotem Dan",
 	"license": "GPL-3.0",
@@ -24,7 +24,7 @@
 		"url": "https://github.com/echogarden-project/echogarden/issues"
 	},
 	"engines": {
-		"node": ">=16"
+		"node": ">=18"
 	},
 	"os": [
 		"win32",
@@ -54,8 +54,8 @@
 		"echogarden": "./dist/cli/CLILauncher.js"
 	},
 	"dependencies": {
-		"@aws-sdk/client-polly": "^3.535.0",
-		"@aws-sdk/client-transcribe-streaming": "^3.535.0",
+		"@aws-sdk/client-polly": "^3.554.0",
+		"@aws-sdk/client-transcribe-streaming": "^3.554.0",
 		"@echogarden/espeak-ng-emscripten": "^0.1.2",
 		"@echogarden/fasttext-wasm": "^0.1.0",
 		"@echogarden/flite-wasi": "^0.1.1",
@@ -72,10 +72,10 @@
 		"chalk": "^5.3.0",
 		"cldr-segmentation": "^2.2.0",
 		"command-exists": "^1.2.9",
-		"compromise": "^14.12.0",
+		"compromise": "^14.13.0",
 		"compromise-dates": "^3.5.0",
 		"fs-extra": "^11.2.0",
-		"gaxios": "^6.3.0",
+		"gaxios": "^6.4.0",
 		"graceful-fs": "^4.2.11",
 		"html-escaper": "^3.0.3",
 		"html-to-text": "^9.0.5",
@@ -90,9 +90,11 @@
 		"ndarray": "^1.0.19",
 		"ndarray-ops": "^1.2.2",
 		"onnxruntime-node": "^1.17.0",
+		"openai": "^4.33.0",
 		"sam-js": "^0.2.1",
 		"strip-ansi": "^7.1.0",
-		"tar": "^6.2.0",
+		"tar": "^7.0.0",
+		"tiktoken": "^1.0.13",
 		"tinyld": "^1.3.4",
 		"ws": "^8.16.0",
 		"wtf_wikipedia": "^10.3.0"
@@ -121,14 +123,11 @@
 		"@types/msgpack-lite": "^0.1.11",
 		"@types/ndarray": "^1.0.14",
 		"@types/ndarray-ops": "^1.2.7",
-		"@types/node": "^20.11.28",
+		"@types/node": "^20.12.7",
 		"@types/recursive-readdir": "^2.2.4",
-		"@types/tar": "^6.1.11",
+		"@types/tar": "^6.1.12",
 		"@types/ws": "^8.5.10",
-		"@typescript-eslint/eslint-plugin": "^7.2.0",
-		"@typescript-eslint/parser": "^7.2.0",
-		"eslint": "^8.57.0",
-		"ts-json-schema-generator": "^1.5.0",
-		"typescript": "^5.4.2"
+		"ts-json-schema-generator": "^1.5.1",
+		"typescript": "^5.4.5"
 	}
 }

package/src/alignment/DTWMfccSequenceAlignment.ts

@@ -1,21 +1,21 @@
-import { cosineDistancePrecomputedMagnitudes, createVectorForIntegerRange, eucledianDistance, magnitude } from "../math/VectorMath.js"
-import { logToStderr } from "../utilities/Utilities.js"
-import { alignDTWWindowed } from "./DTWSequenceAlignmentWindowed.js"
+import { cosineDistancePrecomputedMagnitudes, createVectorForIntegerRange, euclidianDistance, magnitude } from '../math/VectorMath.js'
+import { logToStderr } from '../utilities/Utilities.js'
+import { alignDTWWindowed } from './DTWSequenceAlignmentWindowed.js'
 
 const log = logToStderr
 
-export async function alignMFCC_DTW(mfccFrames1: number[][], mfccFrames2: number[][], windowLength: number, distanceFunction: "eucledian" | "cosine" = "eucledian", centerIndexes?: number[]) {
-	if (distanceFunction == "eucledian") {
+export async function alignMFCC_DTW(mfccFrames1: number[][], mfccFrames2: number[][], windowLength: number, distanceFunction: 'euclidian' | 'cosine' = 'euclidian', centerIndexes?: number[]) {
+	if (distanceFunction == 'euclidian') {
 		const { path } = alignDTWWindowed(
 			mfccFrames1,
 			mfccFrames2,
-			eucledianDistance,
+			euclidianDistance,
 			windowLength,
 			centerIndexes
 		)
 
 		return path
-	} else if (distanceFunction == "cosine") {
+	} else if (distanceFunction == 'cosine') {
 		const indexes1 = createVectorForIntegerRange(0, mfccFrames1.length)
 		const indexes2 = createVectorForIntegerRange(0, mfccFrames2.length)
 
@@ -32,12 +32,12 @@ export async function alignMFCC_DTW(mfccFrames1: number[][], mfccFrames2: number
 
 		return path
 	} else {
-		throw new Error("Invalid distance function")
+		throw new Error('Invalid distance function')
 	}
 }
 
 export function getCostMatrixMemorySizeMB(sequence1Length: number, sequence2Length: number, windowLength: number) {
 	const costMatrixMemorySizeMB = sequence1Length * Math.min(sequence2Length, windowLength) * 4 / 1000000
-	
+
 	return costMatrixMemorySizeMB
 }

package/src/alignment/DTWSequenceAlignment.ts

@@ -1,5 +1,5 @@
-import { logToStderr } from "../utilities/Utilities.js"
-import { AlignmentPath } from "./SpeechAlignment.js"
+import { logToStderr } from '../utilities/Utilities.js'
+import { AlignmentPath } from './SpeechAlignment.js'
 
 const log = logToStderr
 

package/src/alignment/DTWSequenceAlignmentWindowed.ts

@@ -1,11 +1,11 @@
-import { logToStderr } from "../utilities/Utilities.js"
-import { AlignmentPath } from "./SpeechAlignment.js"
+import { logToStderr } from '../utilities/Utilities.js'
+import { AlignmentPath } from './SpeechAlignment.js'
 
 const log = logToStderr
 
 export function alignDTWWindowed<T, U>(sequence1: T[], sequence2: U[], costFunction: (a: T, b: U) => number, windowMaxLength: number, centerIndexes?: number[]) {
 	if (windowMaxLength < 2) {
-		throw new Error("Window length must be greater or equal to 2")
+		throw new Error('Window length must be greater or equal to 2')
 	}
 
 	if (sequence1.length == 0 || sequence2.length == 0) {

package/src/alignment/LevenshteinSequenceAlignment.ts

@@ -1,5 +1,5 @@
-import { logToStderr } from "../utilities/Utilities.js"
-import { AlignmentPath } from "./SpeechAlignment.js"
+import { logToStderr } from '../utilities/Utilities.js'
+import { AlignmentPath } from './SpeechAlignment.js'
 
 const log = logToStderr
 

package/src/alignment/SpeechAlignment.ts

@@ -1,16 +1,26 @@
-import { clip } from "../utilities/Utilities.js"
+import { clip } 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 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'
+
+export async function alignUsingDtw(
+	sourceRawAudio: RawAudio,
+	referenceRawAudio: RawAudio,
+	referenceTimeline: Timeline,
+	granularities: DtwGranularity[],
+	windowDurations: number[]) {
 
-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 { getEndingSilentSampleCount, getRawAudioDuration, getStartingSilentSampleCount, RawAudio } from "../audio/AudioUtilities.js"
-import { type EspeakOptions } from "../synthesis/EspeakTTS.js"
-import chalk from "chalk"
-
-export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio: RawAudio, referenceTimeline: Timeline, granularities: DtwGranularity[], windowDurations: number[]) {
 	const logger = new Logger()
 
 	if (windowDurations.length == 0) {
@@ -38,11 +48,11 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 		framesPerSecond = 1 / mfccOptions.hopDuration!
 
 		// Compute reference MFCCs
-		logger.start("Compute reference MFCC features")
+		logger.start('Compute reference MFCC features')
 		const referenceMfccs = await computeMFCCs(referenceRawAudio, mfccOptions)
 
 		// Compute source MFCCs
-		logger.start("Compute source MFCC features")
+		logger.start('Compute source MFCC features')
 		const sourceMfccs = await computeMFCCs(sourceRawAudio, mfccOptions)
 		logger.end()
 
@@ -52,12 +62,12 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 		if (passIndex == 0) {
 			const minRecommendedWindowDuration = 0.2 * rawAudioDuration
 
-			if (windowDuration < minRecommendedWindowDuration ) {
+			if (windowDuration < minRecommendedWindowDuration) {
 				logger.logTitledMessage('Warning', `Maximum DTW window duration is set to ${windowDuration.toFixed(1)}s, which is smaller than 20% of the source audio duration of ${rawAudioDuration.toFixed(1)}s. This may lead to suboptimal results in some cases. Consider increasing window duration if needed.`, chalk.yellowBright)
 			}
 		}
 
-		logger.start("Align MFCC features using DTW")
+		logger.start('Align MFCC features using DTW')
 		const dtwWindowLength = Math.floor(windowDuration * framesPerSecond)
 
 		let centerIndexes: number[] | undefined
@@ -85,18 +95,18 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 		logger.end()
 	}
 
-	logger.start("\nConvert path to timeline")
+	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")
+			throw new Error('Unexpected: encountered a negative timestamp in timeline')
 		}
 
-		const mappedStartFrameIndex = getMappedFrameIndexForPath(referenceStartFrameIndex, compactedPath, "first")
-		const mappedEndFrameIndex = getMappedFrameIndexForPath(referenceEndFrameIndex, compactedPath, "first")
+		const mappedStartFrameIndex = getMappedFrameIndexForPath(referenceStartFrameIndex, compactedPath, 'first')
+		const mappedEndFrameIndex = getMappedFrameIndexForPath(referenceEndFrameIndex, compactedPath, 'first')
 
 		let innerTimeline: Timeline | undefined
 
@@ -141,7 +151,16 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 	return mappedTimeline
 }
 
-export async function alignUsingDtwWithRecognition(sourceRawAudio: RawAudio, referenceRawAudio: RawAudio, referenceTimeline: Timeline, recognitionTimeline: Timeline, granularities: DtwGranularity[], windowDurations: number[], espeakOptions: EspeakOptions, phoneAlignmentMethod: API.PhoneAlignmentMethod = "interpolation") {
+export async function alignUsingDtwWithRecognitionReference(
+	sourceRawAudio: RawAudio,
+	referenceRawAudio: RawAudio,
+	referenceTimeline: Timeline,
+	recognitionTimeline: Timeline,
+	granularities: DtwGranularity[],
+	windowDurations: number[],
+	espeakOptions: EspeakOptions,
+	phoneAlignmentMethod: API.PhoneAlignmentMethod = 'interpolation') {
+
 	const logger = new Logger()
 
 	if (recognitionTimeline.length == 0) {
@@ -167,57 +186,89 @@ export async function alignUsingDtwWithRecognition(sourceRawAudio: RawAudio, ref
 	logger.start("Synthesize recognized transcript with eSpeak")
 	const recognizedWords = recognitionTimeline.map(entry => entry.text)
 
-	const { rawAudio: synthesizedRecognizedTranscriptRawAudio, timeline: synthesizedRecognitionTimeline } = await createAlignmentReferenceUsingEspeakForFragments(recognizedWords, espeakOptions)
+	const {
+		rawAudio: synthesizedRecognizedTranscriptRawAudio,
+		timeline: synthesizedRecognitionTimeline
+	} = await createAlignmentReferenceUsingEspeakForFragments(recognizedWords, espeakOptions)
 
 	let recognitionTimelineWithPhones: Timeline
 
-	if (phoneAlignmentMethod == "interpolation") {
+	if (phoneAlignmentMethod == 'interpolation') {
 		// Add phone timelines by interpolating from reference words
-		logger.start("Interpolate phone timing")
+		logger.start('Interpolate phone timing')
 
-		recognitionTimelineWithPhones = await interpolatePhoneTimelines(recognitionTimeline, synthesizedRecognitionTimeline)
-	} else if (phoneAlignmentMethod == "dtw") {
-		logger.start("Align phone timing")
+		recognitionTimelineWithPhones = await interpolatePhoneTimelines(
+			recognitionTimeline,
+			synthesizedRecognitionTimeline
+		)
+	} else if (phoneAlignmentMethod == 'dtw') {
+		logger.start('Align phone timing')
 
 		// Add phone timelines by aligning each individual recognized word with the corresponding word
 		// in the reference timeline
-		recognitionTimelineWithPhones = await alignPhoneTimelines(sourceRawAudio, recognitionTimeline, synthesizedRecognizedTranscriptRawAudio, synthesizedRecognitionTimeline)
-	} else if (phoneAlignmentMethod == "dtw-knn") {
-		logger.start("Align phone timing")
-		throw new Error("Not implemented")
+		recognitionTimelineWithPhones = await alignPhoneTimelines(
+			sourceRawAudio,
+			recognitionTimeline,
+			synthesizedRecognizedTranscriptRawAudio,
+			synthesizedRecognitionTimeline,
+			60)
 	} else {
 		throw new Error(`Unknown phone alignment method: ${phoneAlignmentMethod}`)
 	}
 
-	logger.start("Map from the synthesized recognized timeline to the recognized timeline")
 	// Create a mapping from the synthesized recognized timeline to the recognized timeline
+	logger.start("Map from the synthesized recognized timeline to the recognized timeline")
+
+	type SynthesizedToRecognizedTimeMappingEntry = {
+		synthesized: number
+		recognized: number
+	}
+
 	type SynthesizedToRecognizedTimeMapping = SynthesizedToRecognizedTimeMappingEntry[]
-	type SynthesizedToRecognizedTimeMappingEntry = { synthesized: number, recognized: number }
 
 	const synthesizedToRecognizedTimeMapping: SynthesizedToRecognizedTimeMapping = []
 
-	for (let i = 0; i < synthesizedRecognitionTimeline.length; i++) {
-		const synthesizedTimelineEntry = synthesizedRecognitionTimeline[i]
-		const recognitionTimelineEntry = recognitionTimelineWithPhones[i]
+	for (let wordEntryIndex = 0; wordEntryIndex < synthesizedRecognitionTimeline.length; wordEntryIndex++) {
+		const synthesizedTimelineEntry = synthesizedRecognitionTimeline[wordEntryIndex]
+		const recognitionTimelineEntry = recognitionTimelineWithPhones[wordEntryIndex]
 
-		synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedTimelineEntry.startTime, recognized: recognitionTimelineEntry.startTime })
+		synthesizedToRecognizedTimeMapping.push({
+			synthesized: synthesizedTimelineEntry.startTime,
+			recognized: recognitionTimelineEntry.startTime
+		})
 
 		if (synthesizedTimelineEntry.timeline) {
-			for (let j = 0; j < synthesizedTimelineEntry.timeline.length; j++) {
-				const synthesizedPhoneTimelineEntry = synthesizedTimelineEntry.timeline[j]
-				const recognitionPhoneTimelineEntry = recognitionTimelineEntry.timeline![j]
-
-				synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedPhoneTimelineEntry.startTime, recognized: recognitionPhoneTimelineEntry.startTime })
-				synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedPhoneTimelineEntry.endTime, recognized: recognitionPhoneTimelineEntry.endTime })
+			for (let tokenEntryIndex = 0; tokenEntryIndex < synthesizedTimelineEntry.timeline.length; tokenEntryIndex++) {
+				const synthesizedPhoneTimelineEntry = synthesizedTimelineEntry.timeline[tokenEntryIndex]
+				const recognitionPhoneTimelineEntry = recognitionTimelineEntry.timeline![tokenEntryIndex]
+
+				synthesizedToRecognizedTimeMapping.push({
+					synthesized: synthesizedPhoneTimelineEntry.startTime,
+					recognized: recognitionPhoneTimelineEntry.startTime
+				})
+
+				synthesizedToRecognizedTimeMapping.push({
+					synthesized: synthesizedPhoneTimelineEntry.endTime,
+					recognized: recognitionPhoneTimelineEntry.endTime
+				})
 			}
 		}
 
-		synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedTimelineEntry.endTime, recognized: recognitionTimelineEntry.endTime })
+		synthesizedToRecognizedTimeMapping.push({
+			synthesized: synthesizedTimelineEntry.endTime,
+			recognized: recognitionTimelineEntry.endTime
+		})
 	}
 
-	logger.start("Align the synthesized recognized transcript with the synthesized ground-truth transcript")
 	// Align the synthesized recognized transcript to the synthesized reference transcript
-	const alignedSynthesizedRecognitionTimeline = await alignUsingDtw(synthesizedRecognizedTranscriptRawAudio, referenceRawAudio, referenceTimeline, granularities, windowDurations)
+	logger.start("Align the synthesized recognized transcript with the synthesized ground-truth transcript")
+
+	const alignedSynthesizedRecognitionTimeline = await alignUsingDtw(
+		synthesizedRecognizedTranscriptRawAudio,
+		referenceRawAudio,
+		referenceTimeline,
+		granularities,
+		windowDurations)
 
 	let currentSynthesizedToRecognizedMappingIndex = 0
 
@@ -234,7 +285,7 @@ export async function alignUsingDtwWithRecognition(sourceRawAudio: RawAudio, ref
 			}
 
 			if (left > right) {
-				throw new Error("left is larger than right!")
+				throw new Error("Left is larger than right!")
 			}
 
 			if (Math.abs(synthesizedTime - left) < Math.abs(synthesizedTime - right)) {
@@ -273,44 +324,59 @@ export async function alignUsingDtwWithRecognition(sourceRawAudio: RawAudio, ref
 export async function interpolatePhoneTimelines(sourceTimeline: Timeline, referenceTimeline: Timeline) {
 	const interpolatedTimeline: Timeline = []
 
-	for (let i = 0; i < sourceTimeline.length; i++) {
-		const referenceEntry = referenceTimeline[i]
+	for (let wordEntryIndex = 0; wordEntryIndex < sourceTimeline.length; wordEntryIndex++) {
+		const referenceEntry = referenceTimeline[wordEntryIndex]
 
-		const interpolatedEntry = { ...sourceTimeline[i] }
+		const interpolatedEntry = deepClone(sourceTimeline[wordEntryIndex])
 		interpolatedTimeline.push(interpolatedEntry)
 
-		if (interpolatedEntry.type != "word") {
+		if (interpolatedEntry.type != 'word') {
 			continue
 		}
 
 		const interpolatedEntryDuration = interpolatedEntry.endTime - interpolatedEntry.startTime
 		const synthesisEntryDuration = referenceEntry.endTime - referenceEntry.startTime
 
-		interpolatedEntry.timeline = []
+		function mapEntry(targetEntry: TimelineEntry): TimelineEntry {
+			const targetStartTimePercentageRelativeToWord =
+				(targetEntry.startTime - referenceEntry.startTime) / synthesisEntryDuration
 
-		for (const phoneEntry of referenceEntry.timeline!) {
-			const phoneStartTimePercentageRelativeToWord =
-				(phoneEntry.startTime - referenceEntry.startTime) / synthesisEntryDuration
+			const targetEndTimePercentageRelativeToWord =
+				(targetEntry.endTime - referenceEntry.startTime) / synthesisEntryDuration
 
-			const phoneEndTimePercentageRelativeToWord =
-				(phoneEntry.endTime - referenceEntry.startTime) / synthesisEntryDuration
+			const interpolatedStartTime =
+				interpolatedEntry.startTime + (zeroIfNaN(targetStartTimePercentageRelativeToWord) * interpolatedEntryDuration)
 
-			const interpolatedPhoneStartTime = interpolatedEntry.startTime + (phoneStartTimePercentageRelativeToWord * interpolatedEntryDuration)
-			const interpolatedPhoneEndTime = interpolatedEntry.startTime + (phoneEndTimePercentageRelativeToWord * interpolatedEntryDuration)
+			const interpolatedEndTime =
+				interpolatedEntry.startTime + (zeroIfNaN(targetEndTimePercentageRelativeToWord) * interpolatedEntryDuration)
 
-			interpolatedEntry.timeline.push({
-				...phoneEntry,
+			return {
+				...targetEntry,
 
-				startTime: interpolatedPhoneStartTime,
-				endTime: interpolatedPhoneEndTime
-			})
+				startTime: interpolatedStartTime,
+				endTime: interpolatedEndTime
+			}
+		}
+
+		const interpolatedPhoneEntries: Timeline = []
+
+		for (const phoneEntry of (referenceEntry.timeline || [])) {
+			interpolatedPhoneEntries.push(mapEntry(phoneEntry))
 		}
+
+		interpolatedEntry.timeline = interpolatedPhoneEntries
 	}
 
 	return interpolatedTimeline
 }
 
-export async function alignPhoneTimelines(sourceRawAudio: RawAudio, sourceWordTimeline: Timeline, referenceRawAudio: RawAudio, referenceTimeline: Timeline) {
+export async function alignPhoneTimelines(
+	sourceRawAudio: RawAudio,
+	sourceWordTimeline: Timeline,
+	referenceRawAudio: RawAudio,
+	referenceTimeline: Timeline,
+	windowDuration: number) {
+
 	const mfccOptions: MfccOptions = extendDefaultMfccOptions({ zeroFirstCoefficient: true })
 
 	const framesPerSecond = 1 / mfccOptions.hopDuration!
@@ -323,10 +389,9 @@ export async function alignPhoneTimelines(sourceRawAudio: RawAudio, sourceWordTi
 	for (let i = 0; i < referenceTimeline.length; i++) {
 		const referenceWordEntry = referenceTimeline[i]
 
-		const alignedWordEntry = { ...sourceWordTimeline[i] }
-		alignedWordTimeline.push(alignedWordEntry)
+		const alignedWordEntry = deepClone(sourceWordTimeline[i])
 
-		if (alignedWordEntry.type != "word") {
+		if (alignedWordEntry.type != 'word') {
 			continue
 		}
 
@@ -351,27 +416,36 @@ export async function alignPhoneTimelines(sourceRawAudio: RawAudio, sourceWordTi
 		const sourceWordMfccs = sourceMfccs.slice(alignedWordStartFrameIndex, alignedWordEndFrameIndex)
 
 		// Compute DTW path
-		const rawPath = await alignMFCC_DTW(referenceWordMfccs, sourceWordMfccs, 60)
+		const rawPath = await alignMFCC_DTW(referenceWordMfccs, sourceWordMfccs, windowDuration * framesPerSecond)
 		const compactedPath = compactPath(rawPath)
 
-		// Add phone timeline using the mapped time information
-		alignedWordEntry.timeline = []
+		function mapEntry(referenceEntry: TimelineEntry): TimelineEntry {
+			const referenceStartFrameOffset = Math.floor((referenceEntry.startTime - referenceWordEntry.startTime) * framesPerSecond)
+			const alignedStartFrameOffset = getMappedFrameIndexForPath(referenceStartFrameOffset, compactedPath)
+			const alignedStartTime = alignedWordEntry.startTime + (alignedStartFrameOffset / framesPerSecond)
 
-		for (const referencePhoneEntry of referenceWordEntry.timeline!) {
-			const referencePhoneStartFrameOffset = Math.floor((referencePhoneEntry.startTime - referenceWordEntry.startTime) * framesPerSecond)
-			const alignedPhoneStartFrameOffset = getMappedFrameIndexForPath(referencePhoneStartFrameOffset, compactedPath)
-			const alignedPhoneStartTime = alignedWordEntry.startTime + (alignedPhoneStartFrameOffset / framesPerSecond)
+			const referenceEndFrameOffset = Math.floor((referenceEntry.endTime - referenceWordEntry.startTime) * framesPerSecond)
+			const alignedEndFrameOffset = getMappedFrameIndexForPath(referenceEndFrameOffset, compactedPath)
+			const alignedEndTime = alignedWordEntry.startTime + (alignedEndFrameOffset / framesPerSecond)
 
-			const referencePhoneEndFrameOffset = Math.floor((referencePhoneEntry.endTime - referenceWordEntry.startTime) * framesPerSecond)
-			const alignedPhoneEndFrameOffset = getMappedFrameIndexForPath(referencePhoneEndFrameOffset, compactedPath)
-			const alignedPhoneEndTime = alignedWordEntry.startTime + (alignedPhoneEndFrameOffset / framesPerSecond)
+			return {
+				...referenceEntry,
 
-			alignedWordEntry.timeline.push({
-				...referencePhoneEntry,
-				startTime: alignedPhoneStartTime,
-				endTime: alignedPhoneEndTime
-			})
+				startTime: alignedStartTime,
+				endTime: alignedEndTime
+			}
 		}
+
+		// Add phone timeline using the mapped time information
+		const alignedPhoneTimeline: Timeline = []
+
+		for (const referencePhoneEntry of (referenceWordEntry.timeline || [])) {
+			alignedPhoneTimeline.push(mapEntry(referencePhoneEntry))
+		}
+
+		alignedWordEntry.timeline = alignedPhoneTimeline
+
+		alignedWordTimeline.push(alignedWordEntry)
 	}
 
 	return alignedWordTimeline
@@ -385,7 +459,7 @@ export async function createAlignmentReferenceUsingEspeakForFragments(fragments:
 
 	progressLogger.start("Create alignment reference with eSpeak")
 
-	const result = await Espeak.synthesizeFragments(fragments, espeakOptions, insertSeparators)
+	const result = await Espeak.synthesizeFragments(fragments, espeakOptions)
 
 	result.timeline = result.timeline.flatMap(clause => clause.timeline!)
 
@@ -398,6 +472,41 @@ export async function createAlignmentReferenceUsingEspeakForFragments(fragments:
 	return result
 }
 
+export async function createAlignmentReferenceUsingEspeak(transcript: string, language: string, plaintextOptions?: API.PlainTextOptions, customLexiconPaths?: string[], insertSeparators?: boolean) {
+	const logger = new Logger()
+
+	logger.start('Create alignment reference with eSpeak')
+
+	const synthesisOptions: API.SynthesisOptions = {
+		engine: 'espeak',
+		language,
+
+		plainText: plaintextOptions,
+		customLexiconPaths: customLexiconPaths,
+
+		espeak: {
+			useKlatt: false,
+			insertSeparators,
+		}
+	}
+
+	let {
+		audio: referenceRawAudio,
+		timeline: segmentTimeline,
+		voice: espeakVoice
+	} = await synthesize(transcript, synthesisOptions)
+
+	const sentenceTimeline = segmentTimeline.flatMap(entry => entry.timeline!)
+	const wordTimeline = sentenceTimeline.flatMap(entry => entry.timeline!)
+
+	referenceRawAudio = await resampleAudioSpeex(referenceRawAudio as RawAudio, 16000)
+	referenceRawAudio = downmixToMonoAndNormalize(referenceRawAudio)
+
+	logger.end()
+
+	return { referenceRawAudio, referenceTimeline: wordTimeline, espeakVoice }
+}
+
 function compactPath(path: AlignmentPath) {
 	const compactedPath: CompactedPath = []
 
@@ -414,7 +523,7 @@ function compactPath(path: AlignmentPath) {
 	return compactedPath
 }
 
-function getMappedFrameIndexForPath(referenceFrameIndex: number, compactedPath: CompactedPath, mappingKind: "first" | "last" = "first") {
+function getMappedFrameIndexForPath(referenceFrameIndex: number, compactedPath: CompactedPath, mappingKind: 'first' | 'last' = 'first') {
 	if (compactedPath.length == 0) {
 		return 0
 	}
@@ -425,7 +534,7 @@ function getMappedFrameIndexForPath(referenceFrameIndex: number, compactedPath:
 
 	let mappedFrameIndex: number
 
-	if (mappingKind == "first") {
+	if (mappingKind == 'first') {
 		mappedFrameIndex = compactedPathEntry.first
 	} else {
 		mappedFrameIndex = compactedPathEntry.last