react-native-executorch 0.10.6 → 0.10.7

package/lib/module/fetcher/telemetry.js

@@ -12,7 +12,7 @@ const DOWNLOAD_EVENT_ENDPOINT = 'https://ai.swmansion.com/telemetry/downloads/ap
 // self-referencing import would need package `exports` support in the consuming
 // bundler to load at all. A wrong value here is analytics noise; a failed
 // import would break the bundle.
-const LIB_VERSION = '0.10.6';
+const LIB_VERSION = '0.10.7';
 
 // Anonymous analytics are on by default; apps opt out via setTelemetryEnabled.
 let telemetryEnabled = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-executorch",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "nativeLibsVersion": "0.10.6",
   "description": "An easy way to run AI models in React Native with ExecuTorch",
   "main": "./lib/module/index.js",

package/react-native-executorch.podspec

@@ -326,6 +326,8 @@ Pod::Spec.new do |s|
       "\"$(PODS_TARGET_SRCROOT)/third-party/include/executorch/extension/llm/tokenizers/third-party/re2\"",
       "\"$(PODS_TARGET_SRCROOT)/third-party/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp\"",
       "\"$(PODS_TARGET_SRCROOT)/third-party/common/phonemis/src\"",
+      # phonemis's vendored xsimd includes itself as `xsimd/...` (its CMakeLists adds this too).
+      "\"$(PODS_TARGET_SRCROOT)/third-party/common/phonemis/src/third-party\"",
     ].join(' '),
     "WARNING_CFLAGS" => "-Wno-documentation",
     'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'x86_64',

package/src/fetcher/telemetry.ts

@@ -10,7 +10,7 @@ const DOWNLOAD_EVENT_ENDPOINT = 'https://ai.swmansion.com/telemetry/downloads/ap
 // self-referencing import would need package `exports` support in the consuming
 // bundler to load at all. A wrong value here is analytics noise; a failed
 // import would break the bundle.
-const LIB_VERSION = '0.10.6';
+const LIB_VERSION = '0.10.7';
 
 // Anonymous analytics are on by default; apps opt out via setTelemetryEnabled.
 let telemetryEnabled = true;

package/third-party/common/phonemis/CMakeLists.txt

@@ -1,45 +1,101 @@
+# ------------------------
+# --- Project metadata ---
+# ------------------------
 cmake_minimum_required(VERSION 3.10)
 project(phonemis VERSION 1.0 LANGUAGES CXX)
 
+# ---------------------
 # --- Configuration ---
+# ---------------------
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# By default, we only build a static library.
+# Building the tests (-DBUILD_TESTS=ON) and building the sample runner (-DBUILD_RUNNER=ON) must
+# be explciitely specified as CMAKE options.
 option(BUILD_RUNNER "Build phonemis runner" OFF)
 option(BUILD_TESTS "Build tests" OFF)
 
+# Additional option to specify the usage of ExecuTorch for neural model inference.
+# To use it, you must explicitely link the package with ExecuTorch libs or
+# build it together.
+option(ET_ON "Use ExecuTorch" OFF)
+
+# ----------------
 # --- Includes ---
+# ----------------
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src/third-party)
 
+# --------------------
 # --- Source Files ---
+# --------------------
 file(GLOB_RECURSE LIB_SOURCES CONFIGURE_DEPENDS
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/phonemis/*.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/phonemis/*.cpp
 )
 # Exclude main.cpp from the static library
 list(FILTER LIB_SOURCES EXCLUDE REGEX "main\\.cpp$")
 
-# --- Targets ---
+# Exclude protophone sources when ExecuTorch is used
+if(ET_ON)
+  list(FILTER LIB_SOURCES EXCLUDE REGEX "${CMAKE_CURRENT_SOURCE_DIR}/src/phonemis/protophone/")
+endif()
 
+# ---------------
+# --- Targets ---
+# ---------------
 # Always build the static library
 add_library(phonemis STATIC ${LIB_SOURCES})
 
+if(ET_ON)
+  target_compile_definitions(phonemis PRIVATE ET_ON)
+endif()
+
+# Threading support (std::thread in the Protophone convolution stage).
+find_package(Threads REQUIRED)
+target_link_libraries(phonemis PUBLIC Threads::Threads)
+
+# SIMD architecture selection (xsimd)
+# xsimd picks its widest batch type at compile time from the enabled ISA. ARM
+# targets (Android arm64-v8a, iOS arm64) already imply NEON, so nothing is
+# needed there. For native x86_64 desktop builds we opt into AVX2 + FMA. The
+# flag is PUBLIC so every translation unit (and the tests) share the same
+# default arch, keeping xsimd's alignment/ABI consistent across the boundary.
+if(NOT ET_ON AND NOT ANDROID AND NOT CMAKE_SYSTEM_NAME STREQUAL "iOS"
+   AND CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|AMD64|amd64)")
+  include(CheckCXXCompilerFlag)
+  check_cxx_compiler_flag("-mavx2" PHONEMIS_HAS_AVX2)
+  check_cxx_compiler_flag("-mfma" PHONEMIS_HAS_FMA)
+  if(PHONEMIS_HAS_AVX2)
+    target_compile_options(phonemis PUBLIC -mavx2)
+  endif()
+  if(PHONEMIS_HAS_FMA)
+    target_compile_options(phonemis PUBLIC -mfma)
+  endif()
+endif()
+
 # Build runner if requested
 if(BUILD_RUNNER)
-    set(MAIN_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/src/phonemis/main.cpp)
-    add_executable(phonemis_runner ${MAIN_SOURCE})
-    target_link_libraries(phonemis_runner PRIVATE phonemis)
+  set(MAIN_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/src/phonemis/main.cpp)
+  add_executable(phonemis_runner ${MAIN_SOURCE})
+  target_link_libraries(phonemis_runner PRIVATE phonemis)
 endif()
 
 # Build tests if requested
 if(BUILD_TESTS)
-    file(GLOB TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/test/*.cpp)
-    
-    add_executable(phonemis_test ${TEST_SOURCES})
-    target_link_libraries(phonemis_test PRIVATE phonemis)
-    
-    target_include_directories(phonemis_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test)
-    target_include_directories(phonemis_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
-    target_compile_definitions(phonemis_test PRIVATE PHONEMIS_PROJECT_ROOT="${CMAKE_CURRENT_SOURCE_DIR}")
-    target_compile_options(phonemis_test PRIVATE -Wno-deprecated-declarations)
+  file(GLOB TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/test/*.cpp)
+  
+  add_executable(phonemis_test ${TEST_SOURCES})
+  target_link_libraries(phonemis_test PRIVATE phonemis)
+  
+  target_include_directories(phonemis_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test)
+  target_include_directories(phonemis_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+  target_compile_definitions(phonemis_test PRIVATE PHONEMIS_PROJECT_ROOT="${CMAKE_CURRENT_SOURCE_DIR}")
+  target_compile_options(phonemis_test PRIVATE -Wno-deprecated-declarations)
+
+  # Always add previously excluded Protophone sources.
+  if(ET_ON)
+    file(GLOB_RECURSE PROTOPHONE_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/phonemis/protophone/*.cpp)
+    target_sources(phonemis_test PRIVATE ${PROTOPHONE_SOURCES})
+  endif()
 endif()

package/third-party/common/phonemis/README.md

@@ -1,29 +1,54 @@
 # Phonemis
 
-![Status: In Development](https://img.shields.io/badge/status-in%20development-green)
-
 ## From Text to Sound
-Phonemis is a high-performance C++ library designed for **Grapheme-to-Phoneme (G2P)** conversion. It provides a robust pipeline for transforming raw text into *phonetic transcriptions* using the **International Phonetic Alphabet (IPA)**. The library is optimized for efficiency and portability, being pure C++ with no external dependencies, which makes it easy to implement on a wide range of systems including standard and mobile applications requiring text-to-speech frontend processing.
+
+Phonemis is a high-performance C++ library for **Grapheme-to-Phoneme (G2P)** conversion. It
+delivers universal **IPA phonemization** across many platforms with **zero external
+dependencies**, making it an ideal frontend for text-to-speech systems on desktop, mobile, and
+embedded devices.
 
 Currently supported languages:
-*   🇺🇸 English (US)
-*   🇬🇧 English (British)
 
-## The Mechanics of Pronunciation
-The phonemization pipeline consists of several distinct stages designed to maximize accuracy and context awareness:
+*  🇺🇸 English (US) — `en-us`
+*  🇬🇧 English (British) — `en-gb`
+*  🇩🇪 German — `de`
+*  🇫🇷 French — `fr`
+*  🇪🇸 Spanish — `es`
+*  🇮🇹 Italian — `it`
+*  🇵🇱 Polish — `pl`
+*  🇵🇹 Portuguese — `pt`
+*  🇮🇳 Hindi — `hi`
 
-1.  **Preprocessing**: Raw input text is normalized to handle encoding issues and standard formatting.
-2.  **Rule-based Tokenizer**: The text is segmented into tokens based on linguistic rules, separating words from punctuation and handling special cases.
-3.  **Part-of-Speech Tagging**: A Hidden Markov Model (HMM) bigram tagger is employed to assign grammatical categories to words. This model is trained on the Brown Corpus to resolve homograph ambiguities based on context.
-4.  **Viterbi Decoding**: The optimal sequence of tags is determined using the [Viterbi algorithm](https://en.wikipedia.org/wiki/Viterbi_algorithm), ensuring the most probable grammatical structure is selected.
-5.  **Lexicon-based Phonemization**: Words are converted to phonemes using extensive dictionaries, with fallback mechanisms for unknown tokens.
+## Repository Structure
 
-This library is inspired by the Python package [misaki](https://github.com/hexgrad/misaki).
+```
+phonemis/
+├── data/                          # Bundled resources (one subdirectory per language)
+├── src/
+│   ├── phonemis/
+│   │   ├── base/                  # Core API: Pipeline, IPipeline, Config, phonemizer, tokenizer
+│   │   ├── lang/                  # Language-specific modules (en/, de/, fr/, …)
+│   │   ├── protophone/            # Pure C++ neural model inference engine
+│   │   └── utils/                 # Conversions, string utilities, Unicode support
+│   └── third-party/               # Bundled header-only dependencies (xsimd)
+└── CMakeLists.txt
+```
+
+Every language folder under `data/` contains the resources needed for phonemization — a lexicon
+JSON file (word-to-phoneme dictionary), a Protophone model weights file (`.bin`) for neural
+inference, and optionally a tagger JSON file for part-of-speech disambiguation (currently
+available for English). These are the files you point to in `phonemizer::Config`.
 
 ## Installation
 
-### Building with CMake
-Phonemis uses CMake as its build system. To build the static library:
+### Requirements
+- **C++20** compiler
+- **CMake** ≥ 3.10
+- **xsimd** (bundled as a header-only library under `src/third-party/`)
+
+### Building the Library
+
+The below script builds the package as a static library:
 
 ```bash
 mkdir build
@@ -32,39 +57,164 @@ cmake ..
 make
 ```
 
+### Build Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `-DBUILD_RUNNER=ON` | OFF | Builds the `phonemis_runner` CLI tool |
+| `-DBUILD_TESTS=ON` | OFF | Builds the test suite |
+| `-DET_ON=ON` | OFF | Enables ExecuTorch inference (see below) |
+
+### ExecuTorch Integration
+
+With `ET_ON=ON`, the built-in Protophone sources are excluded and neural phonemization is
+delegated to ExecuTorch. You must link against the ExecuTorch runtime:
+
+```bash
+cmake .. -DET_ON=ON -DCMAKE_PREFIX_PATH=/path/to/executorch
+make
+```
+
+When `ET_ON` is left OFF (the default), all neural inference runs through the built-in
+Protophone model — no external runtime dependencies required.
+
+### SIMD Acceleration
+
+SIMD is configured automatically at build time:
+- **x86_64 desktop** (non-Emscripten, non-Android, non-iOS): AVX2 + FMA are enabled if the
+  compiler supports them (`-mavx2 -mfma`), accelerating Protophone's convolution and mixing
+  stages.
+- **ARM** (Android arm64-v8a, iOS arm64): NEON is implicitly available and used by xsimd with
+  no extra flags.
+
 ### Mobile Builds
-The repository includes dedicated scripts for cross-compiling the library for mobile platforms:
-*   **Android**: Use the provided Android build script to generate `.a` libraries for various ABIs (armeabi-v7a, arm64-v8a, x86, x86_64).
-*   **iOS**: Use the iOS build script to generate a universal static library or framework.
+
+Dedicated scripts are provided for cross-compiling:
+- **Android**: Produces `.a` libraries for armeabi-v7a, arm64-v8a, x86, and x86_64 ABIs.
+- **iOS**: Produces a universal static library or framework.
 
 ## Sample Usage
 
-Below is a minimalistic example demonstrating how to instantiate the pipeline and process text.
+All lexicons and trained neural model weights are bundled in the `./data/` subdirectory, organized
+by language code. The example below uses the English (US) resources:
 
 ```cpp
-#include <phonemis/pipeline.h>
-#include <phonemis/utilities/string_utils.h>
+#include <phonemis/base/pipeline.h>
+#include <phonemis/utils/conversions.h>
 #include <iostream>
 
-using namespace phonemis;
-using namespace phonemis::utilities;
-
 int main() {
-    // Paths to required data files
-    std::string tagger_path = "../data/hmm.json";
-    std::string lexicon_path = "../data/dictionaries/us_merged.json";
+    using namespace phonemis;
+
+    phonemizer::Config phon_config;
+    phon_config.lang = "en-us";
+    phon_config.lexicon_filepath = "data/en-us/lexicon_full.json";
+    phon_config.nn_model_filepath = "data/en-us/phonemizer_en_us.bin";
+
+    Config config;
+    config.lang = "en-us";
+    config.phonemizer = phon_config;
 
-    // Initialize pipeline for US English
-    Pipeline pipeline(Lang::EN_US, tagger_path, lexicon_path);
+    Pipeline pipeline(config);
 
-    // Process text
     std::string text = "I love it! This is the best day of my entire life.";
-    auto phonemes = pipeline.process(text);
+    auto phonemes = pipeline(text);
 
-    // Output result
     std::cout << "Text: " << text << "\n";
-    std::cout << "Phonemes: " << string_utils::u32string_to_utf8(phonemes) << "\n";
+    std::cout << "Phonemes: " << utils::conversions::u32_to_utf8(phonemes) << "\n";
 
     return 0;
 }
 ```
+
+The `Pipeline::operator()` accepts both `std::string_view` (UTF-8) and `std::u32string_view`
+(UTF-32), returning phonemes as `std::u32string`. Individual pipeline stages —
+`preprocess()`, `process()`, `postprocess()` — are also exposed.
+
+### Customizing preprocessing
+
+Before phonemization, the text goes through layers which read it out loud: character and
+whitespace normalization, abbreviations and web addresses, numbers, symbols, and character fixes. Each can be
+turned off, and a language's own abbreviations and symbols can be extended or overridden:
+
+```cpp
+Config config;
+config.lang = "en-us";
+config.phonemizer = phon_config;
+config.preprocessor = {
+    .symbols = false,                                    // Keep "&", "+", ... as written
+    .abbreviations = {{U"approx.", {U"approximately"}}}, // Added to the language's own
+};
+```
+
+| Field | Layer | Example |
+|---|---|---|
+| `normalize` | one form of each character | `’` → `'`, `„a“` → `"a"`, `a – b` → `a - b`, `…` → `...` |
+| `trim` | whitespace normalization | `"  a   b , c"` → `"a b, c"` |
+| `terms` | abbreviations, web addresses | `e.g.` → *for example*, `example.com` → *example dot com* |
+| `numbers` | numbers, dates, money, units, ... | `$5` → *five dollars* |
+| `symbols` | remaining symbols | `&` → *and* |
+| `sanitize` | language's character fixes, if it has any | |
+| `abbreviations`, `symbol_words` | extra table entries | `{U"™", {U"trademark"}}` |
+
+All layers are on by default, and always run in this order: normalize, trim, terms, numbers, symbols, sanitize.
+
+### CLI Runner
+
+```bash
+./build/phonemis_runner --lang en-us \
+    --lexicon data/en-us/lexicon_full.json \
+    --model data/en-us/phonemizer_en_us.bin \
+    "Hello world"
+```
+
+## The Mechanics of Pronunciation
+
+Phonemis combines three complementary phonemization strategies, selected per word to maximize
+accuracy:
+
+### Rule-based
+
+A language-aware tokenizer segments text using configurable rules for words, punctuation, and
+special characters. A number-to-word layer verbalizes digits, dates, currencies, fractions, and
+ordinals into their textual forms according to language-specific conventions (e.g., German
+"einundzwanzig" unit-before-tens order, comma decimal separator).
+
+### Lexicon (lookup-based)
+
+An O(1) dictionary lookup provides the fastest and most reliable phonemization. It is cheap, can
+be prepared offline, and handles exception words like "read" (present vs. past tense) correctly.
+Other languages can be extended simply by providing a lexicon JSON file.
+
+### Neural (Protophone)
+
+For words not found in the lexicon, a neural phonemizer takes over. **Protophone** is a pure
+C++ CTC-based model with SIMD-accelerated inference via xsimd (AVX2+FMA on x86_64, NEON on ARM).
+When built with `ET_ON=ON`, inference is delegated to **ExecuTorch** instead, enabling optimized
+on-device acceleration.
+
+These strategies are combined through a **hybrid phonemizer**: the lexicon is tried first, and
+the neural model serves as a fallback. Each level can be individually enabled or disabled via
+configuration.
+
+### Extending to a New Language
+
+Phonemis is designed to be contribution-friendly. Adding support for a new language requires
+three files under `src/phonemis/lang/XX/`:
+
+| File | Purpose | Requirement |
+|------|---------|-------------|
+| `constants.h` | Language-specific data: number words (cardinals, ordinals), currencies, units, months, symbol words, tokenizer special-character rules. | Mandatory |
+| `num2word.h` / `num2word.cpp` | Number verbalizer extending `processor::num2word::Num2WordLayer<NumberReading>`: the language's number notation, its own patterns (dates, phones, ordinal suffixes), how context decides a reading (`resolve`) and the readings themselves (`read_*`). | Mandatory |
+| `patterns.h` / `patterns.cpp` | Number patterns the generic ones do not cover (Roman ordinals, law numbers). | Optional |
+| `pipeline.h` | Pipeline class extending `IPipeline`. Orchestrates preprocessing layers (trimming, number and symbol verbalization), a tokenizer, and a `HybridPhonemizer<LexiconPhonemizer, NeuralPhonemizer>`. | Mandatory |
+| Lexicon JSON / Protophone model | Word-to-phoneme mappings **or** trained neural model (`.bin`). | At least one required |
+
+Then register the language in the factory method at `src/phonemis/base/pipeline.cpp`.
+
+## License
+
+The source code of Phonemis is released under the [MIT license](LICENSE). Some of the data in `data/` and the bundled
+libraries in `src/third-party/` come from other projects under their own licenses: see
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md). In particular, the English part-of-speech tagger (`tagger.json`)
+is derived from a corpus licensed for non-commercial use only, so leave out `Config::tagger` in commercial products.

package/third-party/common/phonemis/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,57 @@
+# Third-party notices
+
+The source code of Phonemis is licensed under the MIT license (see [LICENSE](LICENSE)). Some data files in
+[`data/`](data/) and some bundled libraries in [`src/third-party/`](src/third-party/) come from other projects and
+are distributed under their own terms, listed below. The full texts of those licenses are in
+[`licenses/`](licenses/).
+
+## Data
+
+### English lexicons
+
+- **Files:** `data/en-us/lexicon_full.json`, `data/en-us/lexicon_small.json`, `data/en-gb/lexicon_full.json`,
+  `data/en-gb/lexicon_small.json`
+- **Source:** the gold and silver pronunciation dictionaries of [misaki](https://github.com/hexgrad/misaki)
+  by hexgrad.
+- **License:** Apache License 2.0, see [`licenses/misaki-Apache-2.0.txt`](licenses/misaki-Apache-2.0.txt).
+- **Changes:** the dictionaries were modified for Phonemis:
+  - flattened, so that a word's part-of-speech variants become separate `word|TAG` entries
+    ([`scripts/tools/create_lexicon.py`](scripts/tools/create_lexicon.py));
+  - the gold and silver dictionaries were merged into one file
+    ([`scripts/tools/concatenate_lexicons.py`](scripts/tools/concatenate_lexicons.py));
+  - the small lexicons are reduced versions of the full ones.
+
+### English part-of-speech tagger
+
+- **Files:** `data/en-us/tagger.json`, `data/en-gb/tagger.json` (and the tag descriptions in `tags.json`)
+- **Source:** HMM probabilities computed by [`scripts/tools/create_tagger.py`](scripts/tools/create_tagger.py) from
+  the sentences of the [Brown Corpus](http://www.hit.uib.no/icame/brown/bcm.html) (W. N. Francis and H. Kučera, as
+  distributed with NLTK), tagged with [spaCy](https://spacy.io).
+- **License:** NLTK lists the Brown Corpus as *"May be used for non-commercial purposes."* Treat these files as
+  **not cleared for commercial use**.
+- **Commercial use:** the tagger is optional. Leave out `Config::tagger`, and English is phonemized without it,
+  with weaker handling of words whose pronunciation depends on their part of speech (*read*, *used to*). A tagger
+  trained on commercially usable text is planned.
+
+### Neural phonemizer models
+
+- **Files:** `data/*/phonemizer_*.bin`
+- **Source:** Protophone models trained by the Phonemis authors on pronunciations generated with
+  [misaki](https://github.com/hexgrad/misaki): its gold and silver dictionaries for English and, for the other
+  languages, its espeak-ng backend ([espeak-ng](https://github.com/espeak-ng/espeak-ng) is licensed under GPL-3.0).
+- **License:** MIT, as the rest of Phonemis. The models contain only weights learned from those pronunciations: no
+  code or dictionaries of misaki or espeak-ng.
+
+## Bundled libraries
+
+| Library | Location | License |
+|---|---|---|
+| [JSON for Modern C++](https://github.com/nlohmann/json) 3.12.0, by Niels Lohmann | `src/third-party/json.hpp` | MIT, see [`licenses/nlohmann-json-MIT.txt`](licenses/nlohmann-json-MIT.txt) |
+| [xsimd](https://github.com/xtensor-stack/xsimd) 14.2, by Johan Mabille, Sylvain Corlay, Wolf Vollprecht, Martin Renou, QuantStack and Serge Guelton | `src/third-party/xsimd/` | BSD 3-Clause, see [`licenses/xsimd-BSD-3-Clause.txt`](licenses/xsimd-BSD-3-Clause.txt) |
+
+## Unicode data
+
+`src/phonemis/utils/unicode_table.h` is generated by
+[`scripts/tools/generate_unicode_table.py`](scripts/tools/generate_unicode_table.py) from Python's Unicode database,
+which is derived from the Unicode Character Database. Copyright © 1991-2026 Unicode, Inc., distributed under the
+Unicode License v3, see [`licenses/Unicode-3.0.txt`](licenses/Unicode-3.0.txt).