echogarden 2.1.0 → 2.1.2

package/docs/Options.md

@@ -47,11 +47,11 @@ Applies to CLI operations: `speak`, `speak-file`, `speak-url`, `speak-wikipedia`
 
 **Kokoro**:
 * `kokoro.model`: model variant to use. Can be `82m-v1.0-fp32` or `82m-v1.0-quantized`. **Note**: the quantized model, while having lower memory usage, is significantly slower than the non-quantized (FP32) one. Defaults to `v1.0-fp32`
-* `kokoro.provider`: ONNX execution provider to use. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). **Note**: `dml` provider (DirectML) seems to currently fail on inference. The cause for this error is [still under investigation](https://github.com/hexgrad/kokoro/issues/79). Defaults to `cpu`
+* `kokoro.provider`: ONNX execution provider to use. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information). **Note**: `dml` provider (DirectML) seems to currently fail on inference. The cause for this error is [still under investigation](https://github.com/echogarden-project/echogarden/issues/94). Defaults to `cpu`
 
 **VITS**:
 * `vits.speakerId`: speaker ID, for VITS models that support multiple speakers. Defaults to `0`
-* `vits.provider`: ONNX execution provider to use. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). Using GPU acceleration for VITS may or may not be faster than CPU, depending on your hardware. Defaults to `cpu`
+* `vits.provider`: ONNX execution provider to use. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information). Using GPU acceleration for VITS may or may not be faster than CPU, depending on your hardware. Defaults to `cpu`
 
 **eSpeak**:
 * `espeak.rate`: speech rate, in eSpeak units. Overrides `speed` when set
@@ -118,9 +118,10 @@ Applies to CLI operations: `speak`, `speak-file`, `speak-url`, `speak-wikipedia`
 Applies to CLI operation: `list-voices`, API method: `requestVoiceList`
 
 **General**:
-* `language`: language code to filter by (optional)
-* `voice`: name or name pattern to filter by (optional)
-* `voiceGender`: gender to filter by (optional)
+* `engine`: engine to list voices for. Required
+* `language`: language code to filter by. Optional
+* `voice`: name or name pattern to filter by. Optional
+* `voiceGender`: gender to filter by. Optional
 
 Also accepted are the following engine-specific options that may be required in order to retrieve the voice list:
 * `googleCloud.apiKey`
@@ -134,7 +135,7 @@ Also accepted are the following engine-specific options that may be required in
 Applies to CLI operation: `transcribe`, API method: `recognize`
 
 **General**:
-* `engine`: identifier of the recognition engine to use, such as `whisper` or `vosk` (see [the full engine list](Engines.md))
+* `engine`: identifier of the recognition engine to use, can be `whisper`, `whisper.cpp`, `vosk` or `silero` (see [the full engine list](Engines.md) for more detailed information)
 * `language`: language code ([ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)) for the audio, like `en`, `fr`, `de`. Auto-detected if not set
 * `crop`: crop to active parts using voice activity detection before starting recognition. Defaults to `true`
 * `isolate`: apply source separation to isolate voice before starting recognition. Defaults to `false`
@@ -156,8 +157,8 @@ Applies to CLI operation: `transcribe`, API method: `recognize`
 * `whisper.repetitionThreshold`: minimal repetition / compressibility score to cause a part not to be auto-prompted to the next part. Defaults to `2.4`
 * `whisper.decodeTimestampTokens`: enable/disable decoding of timestamp tokens. Setting to `false` can reduce the occurrence of hallucinations and token repetition loops, possibly due to the overall reduction in the number of tokens decoded. This has no impact on the accuracy of timestamps, since they are derived independently using cross-attention weights. However, there are cases where this can cause the model to end a part prematurely, especially in singing and less speech-like voice segments, or when there are multiple speakers. Defaults to `true`
 * `whisper.timestampAccuracy`: timestamp accuracy. can be `medium` or `high`. `medium` uses a reduced subset of attention heads for alignment, `high` uses all attention heads and is thus more accurate at the word level, but slower for larger models. Defaults to `high` for the `tiny` and `base` models, and `medium` for the larger models
-* `whisper.encoderProvider`: identifier for the ONNX execution provider to use with the encoder model. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). In general, GPU-based encoding should be significantly faster. Defaults to `cpu`, or `dml` if available
-* `whisper.decoderProvider`: identifier for the ONNX execution provider to use with the decoder model. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). Using GPU acceleration for the decoder may be faster than CPU, especially for larger models, but that depends on your particular combination of CPU and GPU. Defaults to `cpu`, and on Windows, `dml` if available for larger models (`small`, `medium`, `large`)
+* `whisper.encoderProvider`: identifier for the ONNX execution provider to use with the encoder model. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information). In general, GPU-based encoding should be significantly faster. Defaults to `cpu`, or `dml` if available
+* `whisper.decoderProvider`: identifier for the ONNX execution provider to use with the decoder model. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information).. Using GPU acceleration for the decoder may be faster than CPU, especially for larger models, but that depends on your particular combination of CPU and GPU. Defaults to `cpu`, and on Windows, `dml` if available, for larger models (`small`, `medium`, `large`)
 * `whisper.seed`: provide a custom random seed for token selection when temperature is greater than 0. Uses a constant seed by default to ensure reproducibility
 
 **Whisper.cpp**:
@@ -182,7 +183,7 @@ Applies to CLI operation: `transcribe`, API method: `recognize`
 
 **Silero**:
 * `silero.modelPath`: path to a Silero model. Note that latest `en`, `de`, `fr` and `uk` models are automatically installed when needed based on the selected language. This should only be used to manually specify a different model, otherwise specify `language` instead
-* `silero.provider`: ONNX execution provider to use. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). Defaults to `cpu`, or `dml` if available
+* `silero.provider`: ONNX execution provider to use. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information). Defaults to `cpu`, or `dml` if available
 
 **Google Cloud**:
 * `googleCloud.apiKey`: Google Cloud API key (required)
@@ -244,7 +245,7 @@ Applies to the `whisper` engine only. To provide Whisper options for `dtw-ra`, u
 * `whisper.model`: Whisper model to use. Defaults to `tiny` or `tiny.en`
 * `whisper.endTokenThreshold`: minimal probability to accept an end token for a recognized part. The probability is measured via the softmax between the end token's logit and the second highest logit. You can try to adjust this threshold in cases the model is ending a part with too few, or many tokens decoded. Defaults to `0.9`. On the last audio part, it is always effectively set to `Infinity`, to ensure the remaining transcript tokens are decoded in full
 * `whisper.maxTokensPerPart`: maximum number of tokens to decode per part. Should help avoid edge cases where the model never reaches an end token for the part, which otherwise may cause the model to decode too many tokens and eventually crash. Defaults to 250
-* `whisper.timestampAccuracy`: timestamp accuracy. can be `medium` or `high`. `medium` uses a reduced subset of attention heads for alignment, `high` uses all attention heads and is thus more accurate at the word level, but slower for larger models. Defaults to `high` for the `tiny` and `base` models, and `medium` for the larger models. Note: setting `high` for model `large-v3-turbo` reverts to `medium`.
+* `whisper.timestampAccuracy`: timestamp accuracy. can be `medium` or `high`. `medium` uses a reduced subset of attention heads for alignment, `high` uses all attention heads and is thus more accurate at the word level, but slower for larger models. Defaults to `high` for the `tiny` and `base` models, and `medium` for the larger models. Note: setting `high` for model `large-v3-turbo` reverts to `medium`, due to poor results with the `high` setting for that model (possibly related to the 16-bit quantization).
 * `whisper.encoderProvider`: encoder ONNX provider. See details in recognition section above
 * `whisper.decoderProvider`: decoder ONNX provider. See details in recognition section above
 
@@ -360,7 +361,7 @@ Applies to CLI operation: `detect-speech-langauge`, API method: `detectSpeechLan
 * `whisper.decoderProvider`: decoder ONNX execution provider. See details in recognition section above
 
 **Silero**:
-* `silero.provider`: ONNX execution provider to use. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). Using GPU may be faster, but the initialization overhead is larger. **Note**: `dml` provider seems to be unstable at the moment for this model. Defaults to `cpu`
+* `silero.provider`: ONNX execution provider to use. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information). Using GPU may be faster, but the initialization overhead is larger. **Note**: `dml` provider seems to be unstable at the moment for this model. Defaults to `cpu`
 
 ### Text language detection
 
@@ -385,7 +386,7 @@ Applies to CLI operation: `detect-voice-activity`, API method: `detectVoiceActiv
 
 **Silero**:
 * `silero.frameDuration`: Silero frame duration (ms). Can be `30`, `60` or `90`. Defaults to `90`
-* `silero.provider`: ONNX provider to use. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). Using GPU is likely to be slower than CPU due to inference being independently executed on each audio frame. Defaults to `cpu` (recommended)
+* `silero.provider`: ONNX provider to use. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information). Using GPU is likely to be slower than CPU due to inference being independently executed on each audio frame. Defaults to `cpu` (recommended)
 
 ## Speech denoising
 
@@ -402,7 +403,7 @@ Applies to CLI operation: `denoise`, API method: `denoise`
 
 **NSNet2**:
 * `nsnet2.model`: can be `baseline-16khz` or `baseline-48khz`. Defaults to `baseline-48khz`
-* `nsnet2.provider`: ONNX execution provider (**Note**: `dml` provider seems to fail with these models). Defaults to `cpu`
+* `nsnet2.provider`: ONNX execution provider. Can be `cpu`, `dml` or `cuda` (**Note**: `dml` provider seems to fail with these models). Defaults to `cpu`
 * `maxAttenuation`: maximum amount of attenuation, in decibels, applied to an FFT bin when filtering the audio frames. Defaults to `30`
 
 ## Source separation
@@ -416,7 +417,7 @@ Applies to CLI operation: `isolate`, API method: `isolate`
 **MDX-NET**:
 
 * `mdxNet.model`: model to use. Currently available models are `UVR_MDXNET_1_9703`, `UVR_MDXNET_2_9682`, `UVR_MDXNET_3_9662`, `UVR_MDXNET_KARA`, and higher quality models `UVR_MDXNET_Main` and `Kim_Vocal_2`. Defaults to `UVR_MDXNET_1_9703`
-* `mdxNet.provider`: ONNX execution provider to use. Can be `cpu`, `dml` ([DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration - Windows only), or `cuda` (Linux only - requires [CUDA Toolkit 12.x](https://developer.nvidia.com/cuda-downloads) and [cuDNN 9.x](https://developer.nvidia.com/cudnn-downloads) to be installed). Defaults to `dml` if available (Windows) or `cpu` (other platforms)
+* `mdxNet.provider`: ONNX execution provider to use. Can be `cpu`, `dml` (Windows only, uses [DirectML](https://microsoft.github.io/DirectML/)-based GPU acceleration), or `cuda` (Linux only, requires system-wide installation of CUDA and cuDNN SDKs, see [this guide](./CUDA.md) for more detailed information). Defaults to `dml` if available (Windows) or `cpu` (other platforms)
 
 # Common options
 

package/docs/Tasklist.md

@@ -118,7 +118,6 @@
 * When `splitToSentences` is set to `false`, the timeline doesn't include proper sentences. Find a way to pass larger sections to the TTS, but still have proper sentences in the timeline
 
 ### Synthesis / preprocessing
-* Extend the heteronyms JSON document with additional words like "conducts", "survey", "protest", "transport", "abuse", "combat", "combats", "affect", "contest", "detail", "marked", "contrast", "construct", "constructs", "console", "recall", "permit", "permits", "prospect", "prospects", "proceed", "proceeds", "invite", "reject", "deserts", "transcript", "transcripts", "compact", "impact", "impacts", "estimate"
 * Full date normalization (e.g. `21 August 2023`, `21 Aug 2023`, `August 21, 2023`)
 * Add support for capitalized-only rules, and possibly also all uppercase / all lowercase rules
 * Add support for multiple words in `precededBy` and `succeededBy`

package/docs/Technical.md

@@ -2,36 +2,43 @@
 
 * Echogarden is written in TypeScript and targets the Node.js platform.
 * It uses ESM modules and latest ECMAScript and TypeScript features.
-* It does not depend on essential binary executables. Instead, all of its engines either use pure JavaScript, WebAssembly, WASI, or the ONNX runtime, with some exceptions: the CLI does invoke a command line `ffmpeg` tool, auto-downloaded from internal packages. Using expansion packages simplifies the installation and ensures non-buggy version are used. Since SoX `v14.4.2` is broken on Windows, it bundles `v14.4.1`.
+* It does not depend on essential binary executables. Instead, all of its engines either use pure JavaScript, WebAssembly, WASI, or the ONNX runtime, with some exceptions: the CLI does invoke a command line `ffmpeg` tool, auto-downloaded using its internal package system.
 * It does not depend on essential native node.js modules requiring install-time compilation with `node-gyp`. This greatly simplifies the installation experience for end-users (the ONNX runtime bundles precompiled NAPI modules for all supported platforms - it doesn't require any compilation during its installation).
 
 ## Package system
 
 Echogarden uses its own package system to download and install various components as needed. These components can be TTS voices, STT models, or other types of models and data.
 
-Packages are downloaded as `.tar.gz` files, and are extracted to `[data-folder]/packages/[package-name]`. Each package has its own subdirectory.
+Packages are downloaded as `.tar.gz` files, and are extracted to `[data-folder]/packages/[package-id-string]`. Each package has its own subdirectory.
 
 `[data-folder]` is located at:
 * `%AppData%\Local\echogarden` on Windows
 * `Users/User/Library/Application Support/echogarden` on macOS
 * `/home/user/.local/share/echogarden` on Linux
 
+`[package-id-string]` is formatted as:
+```
+[engine name]-[package id]-[date as yyyymmdd]
+```
+
 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).
+The packages are currently hosted and downloaded from a [dedicated Hugging Face repository](https://huggingface.co/echogarden/echogarden-packages).
 
 ## Can the base install size be made smaller?
 
-The base installed (uncompressed) size, including dependencies, is around 270MB. This is without any models or voices, which are downloaded as needed.
+The base installed (uncompressed) size, including dependencies, is around 400MB (may not be up-to-date). This is without any models or voices, which are downloaded as needed.
 
 Currently, the largest contributors to the size are:
 
-* `onnxruntime-node` (NAPI): 133MB
-* `kuromoji` (JavaScript) 40MB
-* `flite-wasi` (WASI): 20MB
-* `espeak-ng-emscripten` (WASM): 18MB
+* `onnxruntime-node` (core inference runtime, NAPI): 180MB
+* `kuromoji` (Japanese tokenizer, JavaScript) 40MB
+* `espeak-ng-emscripten` (core synthesis and phonemization engine, WASM): 23MB
+* `tiktoken` (tokenizer library, WASM): 22MB
+* `flite-wasi` (synthesis engine, WASI): 20MB
+* `jieba-wasm` (Chinese tokenizer, WASM): 14MB
 
-`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.
+`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 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.
 
@@ -44,7 +51,7 @@ However, it is a lot of work, and only a subset of the engines can be supported
 * Significantly slower inference when using CPU for ONNX models
 * No cross-domain network connectivity - can't connect to Google Cloud, Microsoft, Amazon etc. without a proxy
 * Large initial download size would make it too heavy and slow to load as part of a standard web page directly
-* Large memory requirement for the VITS models, starting at about 800MB - 1GB, which is a bit too much for a browser
+* Large memory requirements for the various ONNX models, starting at about 800MB - 1GB, which is a bit too much for a browser
 * Due to the high code complexity, data size, and memory consumption, it is unlikely that a browser extension, internally bundling some of the models, would be accepted to the Chrome and Firefox web stores
 * Will require a virtual file system to store models and make use of downloadable packages
 * Requires duplicating a lot of prior work, porting many node.js-only APIs, and increasing code complexity
@@ -71,5 +78,5 @@ Also, `option=value` is more similar to the syntax used in the configuration fil
 
 * `src`: TypeScript source code
 * `dist`: compiled JavaScript modules
-* `data`: various data files, including phonetic lexicons and language code conversion tables. `data/schemas` stores JSON schemas for all configuration options, auto-generated using [`ts-json-schema-generator`](https://github.com/vega/ts-json-schema-generator) directly from the TypeScript code, and used by the CLI to parse and validate the options provided
+* `data`: various data files, including phonetic lexicons and language code conversion tables. `data/schemas` stores JSON schemas for all configuration options, auto-generated using [`ts-json-schema-generator`](https://github.com/vega/ts-json-schema-generator) directly from the TypeScript code, and used by the CLI to parse and validate the options provided. `data/lexicons` contains phonetic lexicons used in speech synthesis and alignment
 * `docs`: documentation

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "echogarden",
-	"version": "2.1.0",
+	"version": "2.1.2",
 	"description": "An easy-to-use speech toolset. Includes tools for synthesis, recognition, alignment, speech translation, language detection, source separation and more.",
 	"author": "Rotem Dan",
 	"license": "GPL-3.0",
@@ -52,7 +52,7 @@
 		"echogarden": "./dist/cli/CLILauncher.js"
 	},
 	"dependencies": {
-		"@aws-sdk/client-polly": "^3.744.0",
+		"@aws-sdk/client-polly": "^3.747.0",
 		"@aws-sdk/client-transcribe-streaming": "^3.744.0",
 		"@echogarden/audio-io": "^0.3.0",
 		"@echogarden/espeak-ng-emscripten": "^0.3.3",
@@ -85,7 +85,7 @@
 		"microsoft-cognitiveservices-speech-sdk": "^1.42.0",
 		"msgpack-lite": "^0.1.26",
 		"onnxruntime-node": "^1.20.1",
-		"openai": "^4.83.0",
+		"openai": "^4.85.1",
 		"sam-js": "^0.3.1",
 		"strip-ansi": "^7.1.0",
 		"tar": "^7.4.3",
@@ -112,7 +112,7 @@
 		"@types/graceful-fs": "^4.1.9",
 		"@types/jsdom": "^21.1.7",
 		"@types/msgpack-lite": "^0.1.11",
-		"@types/node": "^22.13.1",
+		"@types/node": "^22.13.4",
 		"@types/tar": "^6.1.13",
 		"@types/ws": "^8.5.14",
 		"ts-json-schema-generator": "^2.3.0",

package/src/nlp/Lexicon.ts

@@ -3,9 +3,9 @@ import { getShortLanguageCode } from '../utilities/Locale.js'
 import { resolveToModuleRootDir } from '../utilities/PathUtilities.js'
 
 export function tryGetFirstLexiconSubstitution(sentenceWords: string[], wordIndex: number, lexicons: Lexicon[], languageCode: string) {
-	const reversedLexicons = [...lexicons].reverse() // Give precedence to later lexicons
+	for (let i = lexicons.length - 1; i >= 0; i--) {
+		const lexicon = lexicons[i]
 
-	for (const lexicon of reversedLexicons) {
 		const match = tryGetLexiconSubstitution(sentenceWords, wordIndex, lexicon, languageCode)
 
 		if (match) {
@@ -20,51 +20,51 @@ export function tryGetLexiconSubstitution(sentenceWords: string[], wordIndex: nu
 	let word = sentenceWords[wordIndex]
 
 	if (!word) {
-		return
+		return undefined
 	}
 
 	const shortLanguageCode = getShortLanguageCode(languageCode)
 	const lexiconForLanguage = lexicon[shortLanguageCode]
 
 	if (!lexiconForLanguage) {
-		return
+		return undefined
 	}
 
 	const lexiconEntry = lexiconForLanguage[word]
 
 	if (!lexiconEntry) {
-		return
+		return undefined
 	}
 
 	for (let i = 0; i < lexiconEntry.length; i++) {
-		const substitutionEntry = lexiconEntry[i]
+		const candidateEntry = lexiconEntry[i]
 
-		const substitutionPhonemesText = substitutionEntry?.pronunciation?.espeak?.[languageCode]
+		const pronunciationPhonemesText = candidateEntry?.pronunciation?.espeak?.[languageCode]
 
-		if (!substitutionPhonemesText) {
+		if (!pronunciationPhonemesText) {
 			continue
 		}
 
-		const precedingWord = sentenceWords[wordIndex - 1] || ''
-		const succeedingWord = sentenceWords[wordIndex + 1] || ''
+		const precedingWord = sentenceWords[wordIndex - 1] ?? ''
+		const followingWord = sentenceWords[wordIndex + 1] ?? ''
 
-		const precededBy = substitutionEntry?.precededBy || []
-		const notPrecededBy = substitutionEntry?.notPrecededBy || []
+		const precededBy = candidateEntry?.precededBy ?? []
+		const notPrecededBy = candidateEntry?.notPrecededBy ?? []
 
-		const succeededBy = substitutionEntry?.succeededBy || []
-		const notSucceededBy = substitutionEntry?.notSucceededBy || []
+		const followedBy = candidateEntry?.followedBy ?? candidateEntry?.succeededBy ?? []
+		const notFollowedBy = candidateEntry?.notFollowedBy ?? candidateEntry?.notSucceededBy ?? []
 
-		const hasNegativePattern = notPrecededBy.includes(precedingWord) || notSucceededBy.includes(succeedingWord)
-		const hasPositivePattern = precededBy.includes(precedingWord) || succeededBy.includes(succeedingWord)
+		const hasNegativePattern = notPrecededBy.includes(precedingWord) || notFollowedBy.includes(followingWord)
+		const hasPositivePattern = precededBy.includes(precedingWord) || followedBy.includes(followingWord)
 
-		if (i == lexiconEntry.length - 1 || (hasPositivePattern && !hasNegativePattern)) {
-			const substitutionPhonemes = substitutionPhonemesText.split(/ +/g)
+		if (i === lexiconEntry.length - 1 || (hasPositivePattern && !hasNegativePattern)) {
+			const substitutionPhonemes = pronunciationPhonemesText.split(/ +/g)
 
 			return substitutionPhonemes
 		}
 	}
 
-	return
+	return undefined
 }
 
 export async function loadLexiconFile(jsonFilePath: string): Promise<Lexicon> {
@@ -77,6 +77,9 @@ export async function loadLexiconsForLanguage(language: string, customLexiconPat
 	const lexicons: Lexicon[] = []
 
 	if (getShortLanguageCode(language) == 'en') {
+		const wordsLexicon = await loadLexiconFile(resolveToModuleRootDir('data/lexicons/words.en.json'))
+		lexicons.push(wordsLexicon)
+
 		const heteronymsLexicon = await loadLexiconFile(resolveToModuleRootDir('data/lexicons/heteronyms.en.json'))
 		lexicons.push(heteronymsLexicon)
 	}
@@ -112,8 +115,11 @@ export type LexiconEntry = {
 	precededBy?: string[]
 	notPrecededBy?: string[]
 
-	succeededBy?: string[]
-	notSucceededBy?: string[]
+	followedBy?: string[]
+	notFollowedBy?: string[]
+
+	succeededBy?: string[] // Deprecated. Replaced by 'followedBy'
+	notSucceededBy?: string[] // Deprecated. Replaced by 'notFollowedBy'
 
 	example?: string
 }

package/src/synthesis/EspeakTTS.ts

@@ -324,7 +324,7 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 			throw new Error('Unexpected: token timeline should exist and have at least one token')
 		}
 
-		if (tokenTimeline.length !== 1 && tokenTimeline[0].text != '') {
+		if (tokenTimeline.length !== 1 || tokenTimeline[0].text !== '') {
 			continue
 		}