Upload Kokoro LiteRT runtime preview

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.so filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.json

@@ -0,0 +1,89 @@
+{
+  "name": "kokoro-82m-litert-runtime-preview",
+  "artifact_kind": "LiteRT/TFLite Kokoro text-to-audio runtime preview",
+  "source_model": "hexgrad/Kokoro-82M",
+  "source_checkpoint": "kokoro-v1_0.pth",
+  "source_checkpoint_sha256": "496dba118d1a58f5f3db2efc88dbdc216e0483fc89fe6e47ee1f2c53f18ad1e4",
+  "generated_by_repo": "https://github.com/will-deines/robot",
+  "sample_rate_hz": 24000,
+  "runtime_shape": "text -> KPipeline G2P/tokenization -> LiteRT frontend bucket -> LiteRT decoder/vocoder -> WAV",
+  "text_frontend": {
+    "package": "kokoro",
+    "component": "KPipeline",
+    "methods": ["g2p", "en_tokenize"],
+    "loads_pytorch_model_weights": false,
+    "forbidden_in_request_path": ["KModel"]
+  },
+  "frontend": {
+    "kind": "bucketed_full_frontend",
+    "buckets": [
+      {
+        "tokens": 48,
+        "max_frames": 128,
+        "max_f0_frames": 256,
+        "path": "frontend/kokoro_full_frontend_masked_b48_f128_f0256.tflite",
+        "sha256": "d075924f0f0be81c382f4a68b2799ac3a2142e650ac0ceb730aea7f6f4f5f4da",
+        "bytes": 128007356
+      }
+    ]
+  },
+  "decoder_vocoder": {
+    "kind": "merged_decoder_source_stft",
+    "path": "kokoro_decoder_source_stft_merged.tflite",
+    "sha256": "7111687d4513189c959adee16f4436e9c48f1c6285a02db8de126011d09cb8d0",
+    "bytes": 216280440,
+    "custom_op": {
+      "name": "KokoroSourceStft",
+      "source_path": "custom_ops/kokoro_source_stft_custom_op_native.cc",
+      "source_sha256": "40a6d3ed03548fe2d5d4e8381cb66287d2dbc304a8906cf07b2711942b7f2ad6",
+      "linux_x86_64_path": "custom_ops/linux-x86_64/kokoro_source_stft_custom_op_native.so",
+      "linux_x86_64_sha256": "c2f62be3925c21cb21fb41d66f4e0a227785ad4cc4ec2d10a6770a64ebc47519",
+      "linux_aarch64_path": "custom_ops/linux-aarch64/kokoro_source_stft_custom_op_native.so",
+      "linux_aarch64_status": "pending_jetson_build"
+    }
+  },
+  "supporting_files": [
+    {
+      "path": "kokoro_litert_manifest.json",
+      "sha256": "1dd3a6f0a79e29515acdd325118c6e05771db4f325a6ad6e72719bd3284f7170",
+      "bytes": 2523,
+      "role": "robot-agent runtime manifest"
+    },
+    {
+      "path": "config.json",
+      "sha256": "5abb01e2403b072bf03d04fde160443e209d7a0dad49a423be15196b9b43c17f",
+      "bytes": 2351,
+      "role": "Kokoro vocab/config used by KPipeline token packing"
+    },
+    {
+      "path": "voices/af_heart.npz",
+      "sha256": "1e3e7efeb4d30c354eef539d13f35aebc59e599a65257fb290a1b80755500c29",
+      "bytes": 522502,
+      "role": "runtime voice style pack"
+    }
+  ],
+  "reports": [
+    {
+      "path": "reports/kokoro_bucketed_frontend_litert_parity_report.json",
+      "sha256": "5aa69b92e832dc4603774234066070ffed00918cde1a708a5d4c07b11a9bda8b",
+      "bytes": 190141
+    },
+    {
+      "path": "reports/kokoro_decoder_source_stft_merged_probe.json",
+      "sha256": "6c9f76c2bc7be2bfa688390cd870ac85902ce9adbead776d89086b04406b28ee",
+      "bytes": 5865
+    }
+  ],
+  "acceptance": {
+    "bucketed_frontend_passed": true,
+    "max_observed_frontend_float_abs_error": 0.000812530517578125,
+    "pred_dur_exact": true,
+    "alignment_exact": true,
+    "valid_frames_exact": true
+  },
+  "runtime_contract": {
+    "compile_or_export_in_request_path": false,
+    "warm_interpreters_at_boot": true,
+    "fallback_when_token_count_exceeds_buckets": "deterministic_chunking_then_repack"
+  }
+}

NOTICE

@@ -0,0 +1,20 @@
+Kokoro 82M LiteRT Decoder/Vocoder Preview
+
+This package contains a converted LiteRT/TFLite decoder-vocoder artifact derived
+from the Kokoro 82M model:
+
+  Source model: https://huggingface.co/hexgrad/Kokoro-82M
+  Source file:  kokoro-v1_0.pth
+  License:      Apache License 2.0
+
+The conversion was produced from the robot edge-runtime research repository:
+
+  Repository: https://github.com/will-deines/robot
+  Commit:     bb72dce
+
+The generated artifact contains a custom operator named KokoroSourceStft. The
+included Linux x86-64 shared object is provided for validation convenience only.
+Other platforms should rebuild the custom operator from the included C++ source.
+
+This package is not endorsed by the Kokoro authors, Hugging Face, Google,
+LiteRT, TensorFlow, or Pollen Robotics.

README.md

@@ -0,0 +1,135 @@
+---
+license: apache-2.0
+base_model: hexgrad/Kokoro-82M
+pipeline_tag: text-to-speech
+tags:
+  - kokoro
+  - tflite
+  - litert
+  - ai-edge-litert
+  - text-to-speech
+  - custom-op
+  - edge-ai
+  - experimental
+---
+
+# Kokoro 82M LiteRT Runtime Preview
+
+This repository packages the current Kokoro 82M LiteRT/TFLite runtime used by
+the Reachy edge robot-agent project.
+
+It is sourced from [`hexgrad/Kokoro-82M`](https://huggingface.co/hexgrad/Kokoro-82M)
+and contains the accepted text-to-decoder-input frontend bucket plus the accepted
+merged decoder/vocoder graph.
+
+## Runtime Shape
+
+```text
+text
+  -> Kokoro KPipeline G2P/tokenization
+  -> frontend/kokoro_full_frontend_masked_b48_f128_f0256.tflite
+  -> kokoro_decoder_source_stft_merged.tflite + KokoroSourceStft
+  -> WAV bytes
+```
+
+The runtime still uses the `kokoro` Python package for `KPipeline.g2p()` and
+`KPipeline.en_tokenize()`. It must not instantiate Kokoro `KModel` in the
+request path. Neural inference is served by the LiteRT frontend bucket and the
+LiteRT decoder/vocoder.
+
+## Included Artifacts
+
+```text
+kokoro_litert_manifest.json
+config.json
+voices/af_heart.npz
+frontend/kokoro_full_frontend_masked_b48_f128_f0256.tflite
+kokoro_decoder_source_stft_merged.tflite
+custom_ops/kokoro_source_stft_custom_op_native.cc
+custom_ops/linux-x86_64/kokoro_source_stft_custom_op_native.so
+reports/kokoro_bucketed_frontend_litert_parity_report.json
+reports/kokoro_decoder_source_stft_merged_probe.json
+```
+
+The current frontend bucket is `T=48`, with max `128` decoder frames and `256`
+F0/noise frames. Longer or multi-segment text must be deterministically chunked
+and repacked before inference.
+
+## Jetson / ARM64 Status
+
+The Linux x86-64 custom op build is included for local development. Jetson needs
+the Linux aarch64 build:
+
+```text
+custom_ops/linux-aarch64/kokoro_source_stft_custom_op_native.so
+```
+
+That file is intentionally not present in this preview package yet. Build it
+from:
+
+```text
+custom_ops/kokoro_source_stft_custom_op_native.cc
+```
+
+with equivalent floating-point flags:
+
+```bash
+g++ -std=c++17 -O2 -fPIC \
+  -fno-math-errno \
+  -fno-trapping-math \
+  -ffp-contract=fast \
+  -shared \
+  custom_ops/kokoro_source_stft_custom_op_native.cc \
+  -o custom_ops/linux-aarch64/kokoro_source_stft_custom_op_native.so
+```
+
+After building the aarch64 shared object, add its SHA-256 to
+`kokoro_litert_manifest.json` under `decoder_vocoder.custom_op`.
+
+## Validation
+
+Frontend bucket acceptance is recorded in:
+
+```text
+reports/kokoro_bucketed_frontend_litert_parity_report.json
+```
+
+The local acceptance result for this package:
+
+```text
+passed: true
+bucket: T=48
+max observed frontend float abs error: 0.000812530517578125
+pred_dur exact: true
+alignment exact: true
+valid_frames exact: true
+```
+
+Decoder/vocoder acceptance is recorded in:
+
+```text
+reports/kokoro_decoder_source_stft_merged_probe.json
+```
+
+The merged decoder is a one-interpreter graph connected through the
+`KokoroSourceStft` custom op. The custom op remains a CPU custom-op island unless
+implemented as a GPU-capable custom kernel or delegate.
+
+## Minimal Local Smoke
+
+In the Reachy robot-agent repo:
+
+```bash
+PYTHONPATH=src uv run --extra tts --extra kokoro-frontend \
+  python scripts/kokoro_litert_runtime_smoke.py \
+  --text "Hi Will." \
+  --output /tmp/robot-kokoro-litert/runtime_smoke.wav
+```
+
+Expected output is a mono 24 kHz WAV file.
+
+## License
+
+The upstream Kokoro model card lists `hexgrad/Kokoro-82M` under Apache-2.0. This
+converted runtime package is distributed under Apache-2.0 as a derived runtime
+form. See `LICENSE` and `NOTICE`.

config.json

@@ -0,0 +1,150 @@
+{
+  "istftnet": {
+    "upsample_kernel_sizes": [20, 12],
+    "upsample_rates": [10, 6],
+    "gen_istft_hop_size": 5,
+    "gen_istft_n_fft": 20,
+    "resblock_dilation_sizes": [
+      [1, 3, 5],
+      [1, 3, 5],
+      [1, 3, 5]
+    ],
+    "resblock_kernel_sizes": [3, 7, 11],
+    "upsample_initial_channel": 512
+  },
+  "dim_in": 64,
+  "dropout": 0.2,
+  "hidden_dim": 512,
+  "max_conv_dim": 512,
+  "max_dur": 50,
+  "multispeaker": true,
+  "n_layer": 3,
+  "n_mels": 80,
+  "n_token": 178,
+  "style_dim": 128,
+  "text_encoder_kernel_size": 5,
+  "plbert": {
+    "hidden_size": 768,
+    "num_attention_heads": 12,
+    "intermediate_size": 2048,
+    "max_position_embeddings": 512,
+    "num_hidden_layers": 12,
+    "dropout": 0.1
+  },
+  "vocab": {
+    ";": 1,
+    ":": 2,
+    ",": 3,
+    ".": 4,
+    "!": 5,
+    "?": 6,
+    "—": 9,
+    "…": 10,
+    "\"": 11,
+    "(": 12,
+    ")": 13,
+    "“": 14,
+    "”": 15,
+    " ": 16,
+    "\u0303": 17,
+    "ʣ": 18,
+    "ʥ": 19,
+    "ʦ": 20,
+    "ʨ": 21,
+    "ᵝ": 22,
+    "\uAB67": 23,
+    "A": 24,
+    "I": 25,
+    "O": 31,
+    "Q": 33,
+    "S": 35,
+    "T": 36,
+    "W": 39,
+    "Y": 41,
+    "ᵊ": 42,
+    "a": 43,
+    "b": 44,
+    "c": 45,
+    "d": 46,
+    "e": 47,
+    "f": 48,
+    "h": 50,
+    "i": 51,
+    "j": 52,
+    "k": 53,
+    "l": 54,
+    "m": 55,
+    "n": 56,
+    "o": 57,
+    "p": 58,
+    "q": 59,
+    "r": 60,
+    "s": 61,
+    "t": 62,
+    "u": 63,
+    "v": 64,
+    "w": 65,
+    "x": 66,
+    "y": 67,
+    "z": 68,
+    "ɑ": 69,
+    "ɐ": 70,
+    "ɒ": 71,
+    "æ": 72,
+    "β": 75,
+    "ɔ": 76,
+    "ɕ": 77,
+    "ç": 78,
+    "ɖ": 80,
+    "ð": 81,
+    "ʤ": 82,
+    "ə": 83,
+    "ɚ": 85,
+    "ɛ": 86,
+    "ɜ": 87,
+    "ɟ": 90,
+    "ɡ": 92,
+    "ɥ": 99,
+    "ɨ": 101,
+    "ɪ": 102,
+    "ʝ": 103,
+    "ɯ": 110,
+    "ɰ": 111,
+    "ŋ": 112,
+    "ɳ": 113,
+    "ɲ": 114,
+    "ɴ": 115,
+    "ø": 116,
+    "ɸ": 118,
+    "θ": 119,
+    "œ": 120,
+    "ɹ": 123,
+    "ɾ": 125,
+    "ɻ": 126,
+    "ʁ": 128,
+    "ɽ": 129,
+    "ʂ": 130,
+    "ʃ": 131,
+    "ʈ": 132,
+    "ʧ": 133,
+    "ʊ": 135,
+    "ʋ": 136,
+    "ʌ": 138,
+    "ɣ": 139,
+    "ɤ": 140,
+    "χ": 142,
+    "ʎ": 143,
+    "ʒ": 147,
+    "ʔ": 148,
+    "ˈ": 156,
+    "ˌ": 157,
+    "ː": 158,
+    "ʰ": 162,
+    "ʲ": 164,
+    "↓": 169,
+    "→": 171,
+    "↗": 172,
+    "↘": 173,
+    "ᵻ": 177
+  }
+}

custom_ops/kokoro_source_stft_custom_op_native.cc

@@ -0,0 +1,488 @@
+
+#include <algorithm>
+#include <cmath>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+extern "C" {
+
+typedef enum TfLiteStatus {
+  kTfLiteOk = 0,
+  kTfLiteError = 1,
+  kTfLiteDelegateError = 2,
+  kTfLiteApplicationError = 3,
+  kTfLiteDelegateDataNotFound = 4,
+  kTfLiteDelegateDataWriteError = 5,
+  kTfLiteDelegateDataReadError = 6,
+  kTfLiteUnresolvedOps = 7,
+  kTfLiteCancelled = 8,
+  kTfLiteOutputShapeNotKnown = 9,
+} TfLiteStatus;
+
+typedef enum {
+  kTfLiteNoType = 0,
+  kTfLiteFloat32 = 1,
+  kTfLiteInt32 = 2,
+} TfLiteType;
+
+typedef struct TfLiteQuantizationParams {
+  float scale;
+  int32_t zero_point;
+} TfLiteQuantizationParams;
+
+typedef enum TfLiteQuantizationType {
+  kTfLiteNoQuantization = 0,
+  kTfLiteAffineQuantization = 1,
+  kTfLiteBlockwiseQuantization = 2,
+} TfLiteQuantizationType;
+
+typedef struct TfLiteQuantization {
+  TfLiteQuantizationType type;
+  void* params;
+} TfLiteQuantization;
+
+typedef union TfLitePtrUnion {
+  int32_t* i32;
+  float* f;
+  char* raw;
+  const char* raw_const;
+  void* data;
+} TfLitePtrUnion;
+
+typedef enum TfLiteAllocationType {
+  kTfLiteMemNone = 0,
+  kTfLiteMmapRo,
+  kTfLiteArenaRw,
+  kTfLiteArenaRwPersistent,
+  kTfLiteDynamic,
+  kTfLitePersistentRo,
+  kTfLiteCustom,
+  kTfLiteVariantObject,
+  kTfLiteNonCpu,
+} TfLiteAllocationType;
+
+typedef int TfLiteBufferHandle;
+enum { kTfLiteNullBufferHandle = -1 };
+
+typedef struct TfLiteIntArray {
+  int size;
+  int data[];
+} TfLiteIntArray;
+
+typedef struct TfLiteSparsity TfLiteSparsity;
+typedef struct TfLiteDelegate TfLiteDelegate;
+typedef struct TfLiteExternalContext TfLiteExternalContext;
+typedef struct TfLiteOperator TfLiteOperator;
+typedef struct TfLiteAsyncKernel TfLiteAsyncKernel;
+
+typedef struct TfLiteTensor {
+  TfLiteType type;
+  TfLitePtrUnion data;
+  TfLiteIntArray* dims;
+  TfLiteQuantizationParams params;
+  TfLiteAllocationType allocation_type;
+  size_t bytes;
+  const void* allocation;
+  const char* name;
+  TfLiteDelegate* delegate;
+  TfLiteBufferHandle buffer_handle;
+  bool data_is_stale;
+  bool is_variable;
+  TfLiteQuantization quantization;
+  TfLiteSparsity* sparsity;
+  const TfLiteIntArray* dims_signature;
+} TfLiteTensor;
+
+typedef struct TfLiteNode {
+  TfLiteIntArray* inputs;
+  TfLiteIntArray* outputs;
+  TfLiteIntArray* intermediates;
+  TfLiteIntArray* temporaries;
+  void* user_data;
+  void* builtin_data;
+  const void* custom_initial_data;
+  int custom_initial_data_size;
+  TfLiteDelegate* delegate;
+  bool might_have_side_effect;
+} TfLiteNode;
+
+typedef struct TfLiteContext {
+  size_t tensors_size;
+  TfLiteStatus (*GetExecutionPlan)(struct TfLiteContext*, TfLiteIntArray**);
+  TfLiteTensor* tensors;
+  void* impl_;
+  TfLiteStatus (*ResizeTensor)(struct TfLiteContext*, TfLiteTensor*, TfLiteIntArray*);
+  void (*ReportError)(struct TfLiteContext*, const char*, ...);
+} TfLiteContext;
+
+typedef struct TfLiteRegistration {
+  void* (*init)(TfLiteContext* context, const char* buffer, size_t length);
+  void (*free)(TfLiteContext* context, void* buffer);
+  TfLiteStatus (*prepare)(TfLiteContext* context, TfLiteNode* node);
+  TfLiteStatus (*invoke)(TfLiteContext* context, TfLiteNode* node);
+  const char* (*profiling_string)(const TfLiteContext* context, const TfLiteNode* node);
+  int32_t builtin_code;
+  const char* custom_name;
+  int version;
+  TfLiteOperator* registration_external;
+  TfLiteAsyncKernel* (*async_kernel)(TfLiteContext* context, TfLiteNode* node);
+  uint64_t inplace_operator;
+} TfLiteRegistration;
+
+}  // extern "C"
+
+namespace kokoro_source_stft {
+
+constexpr int kSamples = 76800;
+constexpr int kF0Frames = 256;
+constexpr int kDim = 9;
+constexpr int kUpsampleScale = 300;
+constexpr int kNfft = 20;
+constexpr int kHop = 5;
+constexpr int kFreqBins = 11;
+constexpr int kStftFrames = 15361;
+constexpr float kSampleRate = 24000.0f;
+constexpr float kSineAmp = 0.1f;
+constexpr float kNoiseStd = 0.003f;
+constexpr float kVoicedThreshold = 10.0f;
+constexpr float kTwoPi = 6.28318530717958647692f;
+constexpr float kPi = 3.14159265358979323846f;
+
+void Report(TfLiteContext* context, const char* message) {
+  if (context != nullptr && context->ReportError != nullptr) {
+    context->ReportError(context, "%s", message);
+  }
+}
+
+TfLiteStatus CheckTensorCount(TfLiteContext* context, TfLiteNode* node) {
+  if (node == nullptr || node->inputs == nullptr || node->outputs == nullptr) {
+    Report(context, "KokoroSourceStft received a null node or tensor list");
+    return kTfLiteError;
+  }
+  if (node->inputs->size != 14 || node->outputs->size != 7) {
+    Report(context, "KokoroSourceStft expects 14 inputs and 7 outputs");
+    return kTfLiteError;
+  }
+  return kTfLiteOk;
+}
+
+inline const TfLiteTensor& InputTensor(TfLiteContext* context, TfLiteNode* node, int index) {
+  return context->tensors[node->inputs->data[index]];
+}
+
+inline TfLiteTensor& OutputTensor(TfLiteContext* context, TfLiteNode* node, int index) {
+  return context->tensors[node->outputs->data[index]];
+}
+
+inline float InterpolatePhase(
+    const float* phase_frames,
+    const int32_t* left_indices,
+    const int32_t* right_indices,
+    const float* left_weights,
+    const float* right_weights,
+    int sample,
+    int harmonic) {
+  const int left = std::min(std::max(left_indices[sample], 0), kF0Frames - 1);
+  const int right = std::min(std::max(right_indices[sample], 0), kF0Frames - 1);
+  const float left_weight = left_weights[sample];
+  const float right_weight = right_weights[sample];
+  const float left_phase = phase_frames[left * kDim + harmonic];
+  const float right_phase = phase_frames[right * kDim + harmonic];
+  return std::fmaf(left_phase, left_weight, right_phase * right_weight);
+}
+
+inline int ReflectIndex(int centered_position, int valid_samples) {
+  int source_position = centered_position;
+  if (centered_position < 0) {
+    source_position = -centered_position;
+  } else if (centered_position >= valid_samples) {
+    source_position = 2 * valid_samples - centered_position - 2;
+  }
+  if (source_position < 0) {
+    source_position = 0;
+  }
+  if (source_position >= kSamples) {
+    source_position = kSamples - 1;
+  }
+  return source_position;
+}
+
+TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+  return CheckTensorCount(context, node);
+}
+
+TfLiteStatus Invoke(TfLiteContext* context, TfLiteNode* node) {
+  if (CheckTensorCount(context, node) != kTfLiteOk) {
+    return kTfLiteError;
+  }
+  const TfLiteTensor& f0_tensor = InputTensor(context, node, 0);
+  const TfLiteTensor& sine_noise_tensor = InputTensor(context, node, 2);
+  const TfLiteTensor& valid_f0_frames_tensor = InputTensor(context, node, 3);
+  const TfLiteTensor& weight_tensor = InputTensor(context, node, 4);
+  const TfLiteTensor& bias_tensor = InputTensor(context, node, 5);
+  const TfLiteTensor& forward_real_tensor = InputTensor(context, node, 6);
+  const TfLiteTensor& forward_imag_tensor = InputTensor(context, node, 7);
+  const TfLiteTensor& branch_mask_tensor = InputTensor(context, node, 8);
+  const TfLiteTensor& branch_sign_tensor = InputTensor(context, node, 9);
+  const TfLiteTensor& interp_left_index_tensor = InputTensor(context, node, 10);
+  const TfLiteTensor& interp_right_index_tensor = InputTensor(context, node, 11);
+  const TfLiteTensor& interp_left_weight_tensor = InputTensor(context, node, 12);
+  const TfLiteTensor& interp_right_weight_tensor = InputTensor(context, node, 13);
+
+  TfLiteTensor& harmonic_tensor = OutputTensor(context, node, 0);
+  TfLiteTensor& stft_tensor = OutputTensor(context, node, 1);
+  TfLiteTensor& valid_samples_tensor = OutputTensor(context, node, 2);
+  TfLiteTensor& phase_frames_tensor = OutputTensor(context, node, 3);
+  TfLiteTensor& phase_samples_tensor = OutputTensor(context, node, 4);
+  TfLiteTensor& sine_samples_tensor = OutputTensor(context, node, 5);
+  TfLiteTensor& mixed_sine_tensor = OutputTensor(context, node, 6);
+
+  const float* f0 = f0_tensor.data.f;
+  const float* sine_noise = sine_noise_tensor.data.f;
+  const int32_t* valid_f0_frames_ptr = valid_f0_frames_tensor.data.i32;
+  const float* weight = weight_tensor.data.f;
+  const float* bias = bias_tensor.data.f;
+  const float* forward_real = forward_real_tensor.data.f;
+  const float* forward_imag = forward_imag_tensor.data.f;
+  const float* branch_mask = branch_mask_tensor.data.f;
+  const float* branch_sign = branch_sign_tensor.data.f;
+  const int32_t* interp_left_index = interp_left_index_tensor.data.i32;
+  const int32_t* interp_right_index = interp_right_index_tensor.data.i32;
+  const float* interp_left_weight = interp_left_weight_tensor.data.f;
+  const float* interp_right_weight = interp_right_weight_tensor.data.f;
+  float* harmonic = harmonic_tensor.data.f;
+  float* stft_stack = stft_tensor.data.f;
+  int32_t* valid_samples_output = valid_samples_tensor.data.i32;
+  float* debug_phase_frames = phase_frames_tensor.data.f;
+  float* debug_phase_samples = phase_samples_tensor.data.f;
+  float* debug_sine_samples = sine_samples_tensor.data.f;
+  float* debug_mixed_sine = mixed_sine_tensor.data.f;
+
+  if (f0 == nullptr || sine_noise == nullptr || valid_f0_frames_ptr == nullptr ||
+      weight == nullptr || bias == nullptr || forward_real == nullptr ||
+      forward_imag == nullptr || branch_mask == nullptr || branch_sign == nullptr ||
+      interp_left_index == nullptr || interp_right_index == nullptr ||
+      interp_left_weight == nullptr || interp_right_weight == nullptr ||
+      harmonic == nullptr || stft_stack == nullptr || valid_samples_output == nullptr ||
+      debug_phase_frames == nullptr || debug_phase_samples == nullptr ||
+      debug_sine_samples == nullptr || debug_mixed_sine == nullptr) {
+    Report(context, "KokoroSourceStft received a null tensor buffer");
+    return kTfLiteError;
+  }
+
+  const int valid_f0_frames = std::max(
+      0, std::min(kF0Frames, static_cast<int>(valid_f0_frames_ptr[0])));
+  const int valid_samples = valid_f0_frames * kUpsampleScale;
+  valid_samples_output[0] = valid_samples;
+
+  float phase_frames[kF0Frames * kDim];
+  for (int harmonic_index = 0; harmonic_index < kDim; ++harmonic_index) {
+    double cumulative = 0.0;
+    const float multiplier = static_cast<float>(harmonic_index + 1);
+    for (int frame = 0; frame < kF0Frames; ++frame) {
+      const float f0_value = frame < valid_f0_frames ? f0[frame] : 0.0f;
+      float rad = f0_value * multiplier / kSampleRate;
+      rad = rad - std::floor(rad);
+      cumulative += static_cast<double>(rad);
+      const float cumulative_float = static_cast<float>(cumulative);
+      const float phase = cumulative_float * kTwoPi;
+      phase_frames[frame * kDim + harmonic_index] = phase * kUpsampleScale;
+      debug_phase_frames[frame * kDim + harmonic_index] =
+          phase_frames[frame * kDim + harmonic_index];
+    }
+  }
+
+  for (int sample = 0; sample < kSamples; ++sample) {
+    if (sample >= valid_samples) {
+      harmonic[sample] = 0.0f;
+      for (int harmonic_index = 0; harmonic_index < kDim; ++harmonic_index) {
+        const int debug_index = sample * kDim + harmonic_index;
+        debug_phase_samples[debug_index] = 0.0f;
+        debug_sine_samples[debug_index] = 0.0f;
+        debug_mixed_sine[debug_index] = 0.0f;
+      }
+      continue;
+    }
+    const int frame = sample / kUpsampleScale;
+    const float f0_value = f0[frame];
+    const float uv = f0_value > kVoicedThreshold ? 1.0f : 0.0f;
+    const float noise_amp = uv * kNoiseStd + (1.0f - uv) * kSineAmp / 3.0f;
+    float linear = bias[0];
+    for (int harmonic_index = 0; harmonic_index < kDim; ++harmonic_index) {
+      const int debug_index = sample * kDim + harmonic_index;
+      const float phase = InterpolatePhase(
+          phase_frames,
+          interp_left_index,
+          interp_right_index,
+          interp_left_weight,
+          interp_right_weight,
+          sample,
+          harmonic_index);
+      const float sine_sample = std::sin(phase);
+      const float sine = sine_sample * kSineAmp;
+      const float sine_wave =
+          sine * uv + noise_amp * sine_noise[sample * kDim + harmonic_index];
+      debug_phase_samples[debug_index] = phase;
+      debug_sine_samples[debug_index] = sine_sample;
+      debug_mixed_sine[debug_index] = sine_wave;
+      linear += sine_wave * weight[harmonic_index];
+    }
+    harmonic[sample] = std::tanh(linear);
+  }
+
+  constexpr int plane_size = kFreqBins * kStftFrames;
+  for (int frame = 0; frame < kStftFrames; ++frame) {
+    const int window_start = frame * kHop - kNfft / 2;
+    float window[kNfft];
+    for (int offset = 0; offset < kNfft; ++offset) {
+      const int source_index = ReflectIndex(window_start + offset, valid_samples);
+      window[offset] = harmonic[source_index];
+    }
+    for (int freq = 0; freq < kFreqBins; ++freq) {
+      double real_accumulator = 0.0;
+      double imag_accumulator = 0.0;
+      for (int offset = 0; offset < kNfft; ++offset) {
+        const int filter_index = freq * kNfft + offset;
+        real_accumulator +=
+            static_cast<double>(window[offset]) * static_cast<double>(forward_real[filter_index]);
+        imag_accumulator +=
+            static_cast<double>(window[offset]) * static_cast<double>(forward_imag[filter_index]);
+      }
+      const float real = static_cast<float>(real_accumulator);
+      const float imag = static_cast<float>(imag_accumulator);
+      const float magnitude = std::sqrt(real * real + imag * imag);
+      float phase = std::atan2(imag, real);
+      const float threshold = branch_mask[freq] * 1.0e-6f;
+      if (branch_mask[freq] > 0.0f && std::fabs(imag) <= threshold && real < 0.0f) {
+        phase = branch_sign[freq] * kPi;
+      }
+      const int output_index = freq * kStftFrames + frame;
+      stft_stack[output_index] = magnitude;
+      stft_stack[plane_size + output_index] = phase;
+      stft_stack[2 * plane_size + output_index] = real;
+      stft_stack[3 * plane_size + output_index] = imag;
+    }
+  }
+
+  return kTfLiteOk;
+}
+
+TfLiteRegistration* Registration() {
+  static TfLiteRegistration registration = {};
+  registration.prepare = Prepare;
+  registration.invoke = Invoke;
+  registration.builtin_code = 32;
+  registration.custom_name = "KokoroSourceStft";
+  registration.version = 1;
+  return &registration;
+}
+
+}  // namespace kokoro_source_stft
+
+namespace tflite {
+
+enum BuiltinOperator : int32_t {
+  BuiltinOperator_CUSTOM = 32,
+};
+
+inline size_t CombineHashes(std::initializer_list<size_t> hashes) {
+  size_t result = 0;
+  for (size_t hash : hashes) {
+    result = result ^
+             (hash + 0x9e3779b97f4a7800ULL + (result << 10) + (result >> 4));
+  }
+  return result;
+}
+
+namespace op_resolver_hasher {
+template <typename V>
+struct ValueHasher {
+  size_t operator()(const V& v) const { return std::hash<V>()(v); }
+};
+
+template <>
+struct ValueHasher<tflite::BuiltinOperator> {
+  size_t operator()(const tflite::BuiltinOperator& v) const {
+    return std::hash<int>()(static_cast<int>(v));
+  }
+};
+
+template <typename T>
+struct OperatorKeyHasher {
+  size_t operator()(const T& x) const {
+    size_t a = ValueHasher<typename T::first_type>()(x.first);
+    size_t b = ValueHasher<typename T::second_type>()(x.second);
+    return CombineHashes({a, b});
+  }
+};
+}  // namespace op_resolver_hasher
+
+class OpResolverHack {
+ public:
+  using TfLiteDelegatePtrVector =
+      std::vector<std::unique_ptr<TfLiteDelegate, void (*)(TfLiteDelegate*)>>;
+  using TfLiteDelegateCreator =
+      std::function<std::unique_ptr<TfLiteDelegate, void (*)(TfLiteDelegate*)>(
+          TfLiteContext*)>;
+  using TfLiteDelegateCreators = std::vector<TfLiteDelegateCreator>;
+  using TfLiteOpaqueDelegatePtr =
+      std::unique_ptr<TfLiteDelegate, void (*)(TfLiteDelegate*)>;
+  using TfLiteOpaqueDelegateCreator = std::function<TfLiteOpaqueDelegatePtr(int)>;
+  using TfLiteOpaqueDelegateCreators = std::vector<TfLiteOpaqueDelegateCreator>;
+
+  virtual const TfLiteRegistration* FindOp(tflite::BuiltinOperator op, int version) const = 0;
+  virtual const TfLiteRegistration* FindOp(const char* op, int version) const = 0;
+  virtual TfLiteDelegatePtrVector GetDelegates(int num_threads) const { return {}; }
+  virtual TfLiteDelegateCreators GetDelegateCreators() const { return {}; }
+  virtual TfLiteOpaqueDelegateCreators GetOpaqueDelegateCreators() const { return {}; }
+  virtual ~OpResolverHack() = default;
+
+ private:
+  struct OperatorsCache;
+  mutable std::shared_ptr<OperatorsCache> registration_externals_cache_;
+};
+
+class MutableOpResolverHack : public OpResolverHack {
+ public:
+  void AddKokoroSourceStft(const TfLiteRegistration* registration) {
+    may_directly_contain_user_defined_ops_ = true;
+    TfLiteRegistration copy = *registration;
+    copy.builtin_code = BuiltinOperator_CUSTOM;
+    copy.custom_name = "KokoroSourceStft";
+    copy.version = 1;
+    custom_ops_[CustomOperatorKey("KokoroSourceStft", 1)] = copy;
+  }
+
+ protected:
+  bool may_directly_contain_user_defined_ops_ = false;
+  TfLiteDelegateCreators delegate_creators_;
+  TfLiteOpaqueDelegateCreators opaque_delegate_creators_;
+
+ private:
+  using BuiltinOperatorKey = std::pair<tflite::BuiltinOperator, int>;
+  using CustomOperatorKey = std::pair<std::string, int>;
+
+  std::unordered_map<BuiltinOperatorKey, TfLiteRegistration,
+                     op_resolver_hasher::OperatorKeyHasher<BuiltinOperatorKey>>
+      builtins_;
+  std::unordered_map<CustomOperatorKey, TfLiteRegistration,
+                     op_resolver_hasher::OperatorKeyHasher<CustomOperatorKey>>
+      custom_ops_;
+  std::vector<const OpResolverHack*> other_op_resolvers_;
+};
+
+}  // namespace tflite
+
+extern "C" __attribute__((visibility("default"))) void RegisterKokoroSourceStft(
+    uintptr_t resolver_ptr) {
+  auto* resolver = reinterpret_cast<tflite::MutableOpResolverHack*>(resolver_ptr);
+  resolver->AddKokoroSourceStft(kokoro_source_stft::Registration());
+}

examples/run_merged_decoder.py

@@ -0,0 +1,91 @@
+"""Run the merged Kokoro decoder/vocoder LiteRT artifact with custom op.
+
+The input NPZ must contain these arrays:
+
+  asr, f0_curve, noise, style, valid_frames, initial_phase, sine_noise
+
+This example is intentionally decoder-only. It does not perform Kokoro text
+normalization, phonemization, duration prediction, or frontend inference.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ctypes
+from pathlib import Path
+
+import numpy as np
+from ai_edge_litert import interpreter as litert_interpreter
+
+INPUT_NAMES = (
+    "asr",
+    "f0_curve",
+    "noise",
+    "style",
+    "valid_frames",
+    "initial_phase",
+    "sine_noise",
+)
+
+
+def register_kokoro_source_stft(shared_object: Path):
+    library = ctypes.CDLL(str(shared_object), mode=ctypes.RTLD_GLOBAL)
+    register_native = library.RegisterKokoroSourceStft
+    register_native.argtypes = [ctypes.c_uint64]
+    register_native.restype = None
+
+    def registerer(resolver_pointer: int) -> None:
+        register_native(int(resolver_pointer))
+
+    return registerer
+
+
+def parse_args() -> argparse.Namespace:
+    artifact_root = Path(__file__).resolve().parents[1]
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model",
+        type=Path,
+        default=artifact_root / "kokoro_decoder_source_stft_merged.tflite",
+    )
+    parser.add_argument(
+        "--custom-op",
+        type=Path,
+        default=artifact_root
+        / "custom_ops"
+        / "linux-x86_64"
+        / "kokoro_source_stft_custom_op_native.so",
+    )
+    parser.add_argument("--inputs", type=Path, required=True)
+    parser.add_argument("--output", type=Path, default=Path("waveform.npy"))
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    inputs = np.load(args.inputs)
+    missing = [name for name in INPUT_NAMES if name not in inputs]
+    if missing:
+        raise KeyError(f"input NPZ is missing required arrays: {missing}")
+
+    interpreter = litert_interpreter.InterpreterWithCustomOps(
+        model_path=str(args.model),
+        custom_op_registerers=[register_kokoro_source_stft(args.custom_op)],
+    )
+    interpreter.allocate_tensors()
+
+    for detail, name in zip(interpreter.get_input_details(), INPUT_NAMES, strict=True):
+        interpreter.set_tensor(detail["index"], inputs[name])
+
+    interpreter.invoke()
+    outputs = interpreter.get_output_details()
+    waveform = interpreter.get_tensor(outputs[0]["index"])
+    valid_samples = int(interpreter.get_tensor(outputs[1]["index"])[0])
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    np.save(args.output, waveform[..., :valid_samples])
+    print(f"wrote {args.output} with {valid_samples} valid samples at 24000 Hz")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

frontend/kokoro_full_frontend_masked_b48_f128_f0256.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d075924f0f0be81c382f4a68b2799ac3a2142e650ac0ceb730aea7f6f4f5f4da
+size 128007356

kokoro_decoder_source_stft_merged.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7111687d4513189c959adee16f4436e9c48f1c6285a02db8de126011d09cb8d0
+size 216280440

kokoro_litert_manifest.json

@@ -0,0 +1,86 @@
+{
+  "schema_version": 1,
+  "name": "kokoro-82m-litert-runtime-preview",
+  "source_model": {
+    "repo_id": "hexgrad/Kokoro-82M",
+    "voice": "af_heart",
+    "sample_rate_hz": 24000
+  },
+  "text_frontend": {
+    "package": "kokoro",
+    "component": "KPipeline",
+    "methods": [
+      "g2p",
+      "en_tokenize"
+    ],
+    "loads_pytorch_model_weights": false,
+    "forbidden_in_request_path": [
+      "KModel"
+    ]
+  },
+  "frontend": {
+    "kind": "bucketed_full_frontend",
+    "buckets": [
+      {
+        "tokens": 48,
+        "max_frames": 128,
+        "max_f0_frames": 256,
+        "path": "frontend/kokoro_full_frontend_masked_b48_f128_f0256.tflite",
+        "bytes": 128007356,
+        "sha256": "d075924f0f0be81c382f4a68b2799ac3a2142e650ac0ceb730aea7f6f4f5f4da"
+      }
+    ],
+    "packing": {
+      "pad_input_id": 0,
+      "text_mask_true_means_padding": true,
+      "select_bucket": "smallest_bucket_gte_token_count"
+    },
+    "outputs": {
+      "decoder_inputs": [
+        "f0_curve",
+        "noise",
+        "text_encoded",
+        "asr",
+        "valid_frames",
+        "valid_f0_frames"
+      ],
+      "debug_outputs": [
+        "bert_hidden",
+        "bert_encoder",
+        "duration_encoded",
+        "predictor_lstm",
+        "duration_logits",
+        "duration",
+        "pred_dur",
+        "alignment",
+        "prosody_en"
+      ]
+    }
+  },
+  "decoder_vocoder": {
+    "kind": "merged_decoder_source_stft",
+    "path": "kokoro_decoder_source_stft_merged.tflite",
+    "bytes": 216280440,
+    "sha256": "7111687d4513189c959adee16f4436e9c48f1c6285a02db8de126011d09cb8d0",
+    "custom_op": {
+      "name": "KokoroSourceStft",
+      "local_linux_x86_64_path": "custom_ops/linux-x86_64/kokoro_source_stft_custom_op_native.so",
+      "local_linux_x86_64_sha256": "c2f62be3925c21cb21fb41d66f4e0a227785ad4cc4ec2d10a6770a64ebc47519",
+      "linux_aarch64_path": "custom_ops/linux-aarch64/kokoro_source_stft_custom_op_native.so",
+      "linux_aarch64_status": "pending_jetson_build"
+    }
+  },
+  "acceptance": {
+    "frontend_bucketed_report": "reports/kokoro_bucketed_frontend_litert_parity_report.json",
+    "bucketed_frontend_passed": true,
+    "max_observed_frontend_float_abs_error": 0.000812530517578125,
+    "pred_dur_exact": true,
+    "alignment_exact": true,
+    "valid_frames_exact": true
+  },
+  "runtime_contract": {
+    "compile_or_export_in_request_path": false,
+    "warm_interpreters_at_boot": true,
+    "fallback_when_token_count_exceeds_buckets": "deterministic_chunking_then_repack"
+  }
+}

reports/kokoro_decoder_source_stft_merged_probe.json

@@ -0,0 +1,182 @@
+{
+  "acceptance_criteria": {
+    "all_outputs_finite": true,
+    "merged_vs_split_waveform_max_abs_error": 1e-06,
+    "tail_after_valid_max_abs": 1e-07,
+    "valid_samples_exact": true
+  },
+  "artifact": "/tmp/robot-kokoro-litert/kokoro_decoder_source_stft_merged.tflite",
+  "artifact_bytes": 216280440,
+  "candidate_acceptance": {
+    "accepted": true,
+    "failures": []
+  },
+  "fixture_results": {
+    "counting": {
+      "merged_output_finite": true,
+      "merged_tail_after_valid": 0.0,
+      "merged_vs_split_composed_waveform": {
+        "all_outputs_finite": true,
+        "candidate_rms": 0.04797517691684405,
+        "candidate_shape": [
+          1,
+          1,
+          64200
+        ],
+        "max_abs_error": 0.0,
+        "mean_abs_error": 0.0,
+        "reference_rms": 0.04797517691684405,
+        "reference_shape": [
+          1,
+          1,
+          64200
+        ],
+        "rms_error": 0.0,
+        "snr_db": Infinity
+      },
+      "merged_vs_split_valid_samples": {
+        "candidate_shape": [
+          1
+        ],
+        "max_abs_error": 0.0,
+        "mean_abs_error": 0.0,
+        "reference_shape": [
+          1
+        ]
+      },
+      "split_composition_metrics_against_pytorch": {
+        "all_outputs_finite": true,
+        "candidate_rms": 0.04797517691684405,
+        "candidate_shape": [
+          1,
+          1,
+          64200
+        ],
+        "max_abs_error": 5.751848220825195e-06,
+        "mean_abs_error": 3.035724242542549e-07,
+        "reference_rms": 0.04797517190639091,
+        "reference_shape": [
+          1,
+          1,
+          64200
+        ],
+        "rms_error": 5.925892404353504e-07,
+        "snr_db": 98.16525555604315
+      },
+      "valid_samples": 64200
+    },
+    "hi_will": {
+      "merged_output_finite": true,
+      "merged_tail_after_valid": 0.0,
+      "merged_vs_split_composed_waveform": {
+        "all_outputs_finite": true,
+        "candidate_rms": 0.04477709541035824,
+        "candidate_shape": [
+          1,
+          1,
+          36000
+        ],
+        "max_abs_error": 0.0,
+        "mean_abs_error": 0.0,
+        "reference_rms": 0.04477709541035824,
+        "reference_shape": [
+          1,
+          1,
+          36000
+        ],
+        "rms_error": 0.0,
+        "snr_db": Infinity
+      },
+      "merged_vs_split_valid_samples": {
+        "candidate_shape": [
+          1
+        ],
+        "max_abs_error": 0.0,
+        "mean_abs_error": 0.0,
+        "reference_shape": [
+          1
+        ]
+      },
+      "split_composition_metrics_against_pytorch": {
+        "all_outputs_finite": true,
+        "candidate_rms": 0.04477709541035824,
+        "candidate_shape": [
+          1,
+          1,
+          36000
+        ],
+        "max_abs_error": 6.459653377532959e-06,
+        "mean_abs_error": 2.8408125768818335e-07,
+        "reference_rms": 0.04477708741488783,
+        "reference_shape": [
+          1,
+          1,
+          36000
+        ],
+        "rms_error": 6.784404965979393e-07,
+        "snr_db": 96.39088155060315
+      },
+      "valid_samples": 36000
+    }
+  },
+  "gpu_delegate_note": "This proves one-buffer graph packaging. GPU persistence still depends on delegate partitioning; KokoroSourceStft remains a CPU custom op unless implemented as a GPU-capable delegate/kernel.",
+  "merge_summary": {
+    "buffer_count": 2571,
+    "connected_tensors": {
+      "front_f0_curve_to_source_f0_curve": [
+        "front/serving_default_args_1",
+        "front/serving_default_args_1"
+      ],
+      "front_valid_to_source_valid_f0_frames": [
+        "front/serving_default_output_4_output",
+        "front/serving_default_output_4_output"
+      ],
+      "source_stack_to_generator_stack": [
+        "source/harmonic_stft_stack",
+        "source/harmonic_stft_stack"
+      ]
+    },
+    "input_names": [
+      "front/serving_default_args_0",
+      "front/serving_default_args_1",
+      "front/serving_default_args_2",
+      "front/serving_default_args_3",
+      "front/serving_default_args_4",
+      "source/initial_phase",
+      "source/sine_noise"
+    ],
+    "opcode_count": 48,
+    "operator_count": 2087,
+    "output_names": [
+      "generator/serving_default_output_0_output",
+      "source/valid_samples",
+      "generator/serving_default_output_2_output",
+      "generator/serving_default_output_3_output",
+      "generator/serving_default_output_4_output",
+      "generator/serving_default_output_5_output",
+      "generator/serving_default_output_6_output",
+      "generator/serving_default_output_7_output",
+      "generator/serving_default_output_8_output",
+      "generator/serving_default_output_9_output",
+      "generator/serving_default_output_10_output",
+      "generator/serving_default_output_11_output",
+      "generator/serving_default_output_12_output",
+      "generator/serving_default_output_13_output",
+      "generator/serving_default_output_14_output",
+      "generator/serving_default_output_15_output",
+      "generator/serving_default_output_16_output",
+      "generator/serving_default_output_17_output",
+      "generator/serving_default_output_18_output",
+      "generator/serving_default_output_19_output"
+    ],
+    "tensor_count": 2569
+  },
+  "runtime_contract": "one TFLite FlatBuffer and one interpreter; front and generator builtins are connected through the KokoroSourceStft custom op",
+  "source_stft_custom_op_shared_object": "/tmp/robot-kokoro-litert/kokoro_source_stft_custom_op_native.so",
+  "split_artifacts": {
+    "decoder_front": "/tmp/robot-kokoro-litert/kokoro_decoder_front_masked_f128.tflite",
+    "generator_source_stft": "/tmp/robot-kokoro-litert/kokoro_generator_source_stft_f256.tflite",
+    "source_stft_custom_op_native": "/tmp/robot-kokoro-litert/kokoro_source_stft_custom_op_native.tflite",
+    "source_stft_custom_op_shared_object": "/tmp/robot-kokoro-litert/kokoro_source_stft_custom_op_native.so"
+  }
+}

upload.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_id="${1:-wdga/kokoro-82m-litert-runtime-preview}"
+root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+uv run --with huggingface_hub hf upload \
+  "${repo_id}" \
+  "${root_dir}" \
+  . \
+  --repo-type model \
+  --commit-message "Upload Kokoro LiteRT runtime preview"

voices/af_heart.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e3e7efeb4d30c354eef539d13f35aebc59e599a65257fb290a1b80755500c29
+size 522502