Release AiTable CosyVoice Vulkan runtime and native fix scripts 20261021-01

Versioned binary release plus checked source patch/application script for streaming handoff, silent resampling guard and retained native integrations. No models, private voices or full source snapshot. Retain immutable releases.

AiTable-CosyVoice-Native-Fixes-20261021-01.zip

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

AiTable-CosyVoice-Vulkan-Windows-x64-20261021-01.zip

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

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lourdle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README-20261021-01.md

@@ -0,0 +1,91 @@
+---
+license: mit
+tags:
+- cosyvoice
+- ggml
+- vulkan
+- windows
+- inference-engine
+- community-build
+---
+
+# CosyVoice.cpp — AiTable Windows Vulkan community build
+
+## 下載 / Downloads
+
+This is an **inference runtime**, not a voice/model release. 本倉庫提供我們目前使用的 CosyVoice.cpp Vulkan 後端，以及可套用修正的腳本；不含模型、私人參考音色、角色資料或 LoRA 權重。
+
+| Version | Binary runtime | Fix script bundle | Notes | Checksums |
+| --- | --- | --- | --- | --- |
+| 20261021-01 | [Runtime ZIP](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/resolve/main/AiTable-CosyVoice-Vulkan-Windows-x64-20261021-01.zip) | [Fixes ZIP](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/resolve/main/AiTable-CosyVoice-Native-Fixes-20261021-01.zip) | [Version notes](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/README-20261021-01.md) | [SHA256](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/resolve/main/SHA256SUMS-20261021-01.txt) |
+
+**舊版本保留：**每版 ZIP、腳本、patch、manifest、說明與校驗碼使用固定版本名稱，後續新增版本，不覆蓋、不刪除舊版；首頁 README 僅作可更新索引。
+
+## Upstream and provenance
+
+- Upstream: [Lourdle/cosyvoice.cpp](https://github.com/Lourdle/cosyvoice.cpp), based on **v0.2.0 / 67d45feb2f654bbc66cca25bff78464b3ec08fa1** plus local native changes. This package is not a claim to contain current upstream main.
+- This is an unofficial community build, not an official CosyVoice, Lourdle or AMD release.
+- The binary payload is copied from the installed AiTable build, not rebuilt for publication. The release manifest records each included binary's SHA256.
+- Backend: **Vulkan and CPU**. No ROCm/HIP backend is included. Windows x64; existing local deployment uses Radeon RX 9070. Other GPU/platform compatibility is not validated here.
+- Models can be obtained separately from the upstream [GGUF model repository](https://huggingface.co/Lourdle/Fun-CosyVoice3-0.5B-2512-GGUF). Follow the upstream model/frontend instructions and their separate licenses. Our private fine-tuned voices are not included.
+
+## Our native changes / 解決辦法
+
+1. **Streaming cumulative mel and quiet handoff:** retain the same job's mel history within existing context capacity, generate the cumulative HiFT prefix, and emit only samples after the committed cursor. Select a low-energy handoff within the available tail (20ms energy window, normally 20–250ms held tail); finalization emits remaining samples. Short prefixes do not invent silence. Cleanup resets per-job state. This reduces some join artifacts; it does not guarantee artifact-free speech.
+2. **Silent-token resampling guard:** a rejected sampled silent token has not advanced the logits/KV state. Check cancellation before sampling, bound consecutive rejected draws to `uint64_t(limit)+2`, reset that count on acceptance, and use the existing failure cleanup when exhausted. This is not a timeout/cancellation mechanism for an already blocked native graph, and does not prove the cause of earlier live timeouts.
+3. **Text buffer reset:** clear the per-request emoji/text output buffer before appending, avoiding stale text across requests.
+4. **Bounded stage diagnostics:** observe processing stages without including request text. A stage marker is not proof of completion or a stack trace.
+5. **Optional dynamic LoRA interface:** retains the experimental rank-4 Q/V adapter API and HTTP integration used by AiTable. No trained adapter or private voice is distributed, and normal TTS does not become ASMR merely by downloading this runtime. A compatible model, validated factors and integration are still required.
+
+The source patch contains these changes and their necessary native API/server wiring, not just the two algorithm snippets. It excludes local dependency path rewrites, build caches, full source snapshots and model weights. Rebuilding these sources is not promised to reproduce the published binary bit-for-bit.
+
+## Use the binary runtime
+
+Extract the complete ZIP. Keep all DLLs beside the EXEs in `runtime/`; do not replace these GGML DLLs with an unrelated llama.cpp build. Python and the compiler toolchain are not needed to run the binary package. A current compatible Vulkan driver and Microsoft Visual C++ x64 runtime may be required.
+
+With your own compatible CosyVoice3-2512 GGUF and pre-encoded prompt_speech:
+
+```bat
+runtime\cosyvoice-cli.exe --model "D:\Models\CosyVoice3-2512_F16.gguf" --prompt-speech "D:\Voices\prompt_speech.gguf" --mode cross-lingual --text "This is a short test." --output "test.wav" --backend vulkan0
+```
+
+For a localhost API example (not started automatically):
+
+```bat
+runtime\cosyvoice-server.exe --api --model "D:\Models\CosyVoice3-2512_F16.gguf" --voice-prompt "demo=D:\Voices\prompt_speech.gguf" --backend vulkan0 --host 127.0.0.1 --port 9880 --chunk-tokens 125 --inference-buffer-policy dedicated --simd-level auto
+```
+
+Use `--backend cpu` for CPU execution. `--help` lists this binary's supported options. With no pre-encoded prompt, obtain the frontend ONNX assets separately and follow upstream's `--frontend-only` flow. ONNX Runtime DLLs are included; tokenizer/campplus model files are not. Audio output is produced by the model; the runtime does not upscale its training sample rate into higher-fidelity speech.
+
+## Apply the fix script / 套用修正腳本
+
+Download and extract the Fixes ZIP, or download these three versioned files into one folder:
+
+- [Python application script](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/apply-cosyvoice-fixes-20261021-01.py)
+- [Native source patch](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/aitable-native-fixes-20261021-01.patch)
+- [Pinned source/hash manifest](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/fixes-manifest-20261021-01.json)
+
+Requires Python 3.9+ and Git. Obtain a **separate upstream checkout at the exact commit**, preserving LF line endings:
+
+```bat
+git -c core.autocrlf=false clone https://github.com/Lourdle/cosyvoice.cpp.git cosyvoice-patch-work
+git -C cosyvoice-patch-work checkout 67d45feb2f654bbc66cca25bff78464b3ec08fa1
+python apply-cosyvoice-fixes-20261021-01.py --source cosyvoice-patch-work
+python apply-cosyvoice-fixes-20261021-01.py --source cosyvoice-patch-work --apply
+```
+
+Default is check-only. The script verifies the patch and every affected original file, rejects a different/already-patched source, preserves backups and a restore manifest beside the checkout, then checks every output hash. It explicitly disables Git automatic newline conversion for the patch operation. Do not point it at an installed runtime or a working tree with your own modifications to affected files. This does **not** compile, download models, replace installed binaries, restart services or repair arbitrary upstream versions.
+
+To restore, consult the backup's `restore-manifest.json`: restore originals and remove only listed newly added files, after checking no later edits would be overwritten. After patching, use upstream build instructions with your own compatible GGML/ONNX/ICU/FFmpeg dependencies. This release's script application was tested; a fresh complete source rebuild was not performed for this publication.
+
+## Validation and remaining limits
+
+- This publication: packaged CLI/server/quantizer `--help` checks passed with PATH restricted to the packaged runtime and Windows System32. No model/server was launched and all checks exited. ZIP integrity and source-patch application/output hashes are checked separately.
+- Prior validation of the same silent-resampling DLL: CPU fault injection returned failure with zero KV/PCM on a forced-silent case, cancellation completed, and a subsequent synthesis on the same context succeeded. Normal CPU PCM matched the previous core in the tested case. These are limited tests, not full GPU/live validation.
+- Earlier streaming seam and loudness investigations remain unresolved in some listening cases. The package retains our local cumulative-mel/quiet-handoff approach, not an assertion that every pop, loudness jump or strange utterance is fixed. Changing chunk length reduces seam frequency but is not by itself proof of correctness.
+- Cumulative mel/HiFT work may increase time/memory versus upstream overlap-only behavior. This release adds no new RTF, first-audio latency or VRAM benchmark; performance depends on model, reference, chunking and hardware.
+- Large F32 models may exceed a single Vulkan allocation on AMD. This release does not include a multi-buffer loader fix or override that hardware limit.
+
+## Licensing
+
+CosyVoice.cpp and our native changes use the preserved MIT terms; bundled dependencies retain their own licenses. **FFmpeg components in this package identify as LGPL-3.0-or-later**, not the upstream notice's generic LGPL-2.1 default. See `THIRD_PARTY_NOTICES.md` and `licenses/` for included texts, provenance and source links. MIT repository metadata describes the core and does not relicense FFmpeg, model weights or every dependency.

README.md

@@ -1,3 +1,91 @@
----
-license: mit
----
+---
+license: mit
+tags:
+- cosyvoice
+- ggml
+- vulkan
+- windows
+- inference-engine
+- community-build
+---
+
+# CosyVoice.cpp — AiTable Windows Vulkan community build
+
+## 下載 / Downloads
+
+This is an **inference runtime**, not a voice/model release. 本倉庫提供我們目前使用的 CosyVoice.cpp Vulkan 後端，以及可套用修正的腳本；不含模型、私人參考音色、角色資料或 LoRA 權重。
+
+| Version | Binary runtime | Fix script bundle | Notes | Checksums |
+| --- | --- | --- | --- | --- |
+| 20261021-01 | [Runtime ZIP](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/resolve/main/AiTable-CosyVoice-Vulkan-Windows-x64-20261021-01.zip) | [Fixes ZIP](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/resolve/main/AiTable-CosyVoice-Native-Fixes-20261021-01.zip) | [Version notes](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/README-20261021-01.md) | [SHA256](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/resolve/main/SHA256SUMS-20261021-01.txt) |
+
+**舊版本保留：**每版 ZIP、腳本、patch、manifest、說明與校驗碼使用固定版本名稱，後續新增版本，不覆蓋、不刪除舊版；首頁 README 僅作可更新索引。
+
+## Upstream and provenance
+
+- Upstream: [Lourdle/cosyvoice.cpp](https://github.com/Lourdle/cosyvoice.cpp), based on **v0.2.0 / 67d45feb2f654bbc66cca25bff78464b3ec08fa1** plus local native changes. This package is not a claim to contain current upstream main.
+- This is an unofficial community build, not an official CosyVoice, Lourdle or AMD release.
+- The binary payload is copied from the installed AiTable build, not rebuilt for publication. The release manifest records each included binary's SHA256.
+- Backend: **Vulkan and CPU**. No ROCm/HIP backend is included. Windows x64; existing local deployment uses Radeon RX 9070. Other GPU/platform compatibility is not validated here.
+- Models can be obtained separately from the upstream [GGUF model repository](https://huggingface.co/Lourdle/Fun-CosyVoice3-0.5B-2512-GGUF). Follow the upstream model/frontend instructions and their separate licenses. Our private fine-tuned voices are not included.
+
+## Our native changes / 解決辦法
+
+1. **Streaming cumulative mel and quiet handoff:** retain the same job's mel history within existing context capacity, generate the cumulative HiFT prefix, and emit only samples after the committed cursor. Select a low-energy handoff within the available tail (20ms energy window, normally 20–250ms held tail); finalization emits remaining samples. Short prefixes do not invent silence. Cleanup resets per-job state. This reduces some join artifacts; it does not guarantee artifact-free speech.
+2. **Silent-token resampling guard:** a rejected sampled silent token has not advanced the logits/KV state. Check cancellation before sampling, bound consecutive rejected draws to `uint64_t(limit)+2`, reset that count on acceptance, and use the existing failure cleanup when exhausted. This is not a timeout/cancellation mechanism for an already blocked native graph, and does not prove the cause of earlier live timeouts.
+3. **Text buffer reset:** clear the per-request emoji/text output buffer before appending, avoiding stale text across requests.
+4. **Bounded stage diagnostics:** observe processing stages without including request text. A stage marker is not proof of completion or a stack trace.
+5. **Optional dynamic LoRA interface:** retains the experimental rank-4 Q/V adapter API and HTTP integration used by AiTable. No trained adapter or private voice is distributed, and normal TTS does not become ASMR merely by downloading this runtime. A compatible model, validated factors and integration are still required.
+
+The source patch contains these changes and their necessary native API/server wiring, not just the two algorithm snippets. It excludes local dependency path rewrites, build caches, full source snapshots and model weights. Rebuilding these sources is not promised to reproduce the published binary bit-for-bit.
+
+## Use the binary runtime
+
+Extract the complete ZIP. Keep all DLLs beside the EXEs in `runtime/`; do not replace these GGML DLLs with an unrelated llama.cpp build. Python and the compiler toolchain are not needed to run the binary package. A current compatible Vulkan driver and Microsoft Visual C++ x64 runtime may be required.
+
+With your own compatible CosyVoice3-2512 GGUF and pre-encoded prompt_speech:
+
+```bat
+runtime\cosyvoice-cli.exe --model "D:\Models\CosyVoice3-2512_F16.gguf" --prompt-speech "D:\Voices\prompt_speech.gguf" --mode cross-lingual --text "This is a short test." --output "test.wav" --backend vulkan0
+```
+
+For a localhost API example (not started automatically):
+
+```bat
+runtime\cosyvoice-server.exe --api --model "D:\Models\CosyVoice3-2512_F16.gguf" --voice-prompt "demo=D:\Voices\prompt_speech.gguf" --backend vulkan0 --host 127.0.0.1 --port 9880 --chunk-tokens 125 --inference-buffer-policy dedicated --simd-level auto
+```
+
+Use `--backend cpu` for CPU execution. `--help` lists this binary's supported options. With no pre-encoded prompt, obtain the frontend ONNX assets separately and follow upstream's `--frontend-only` flow. ONNX Runtime DLLs are included; tokenizer/campplus model files are not. Audio output is produced by the model; the runtime does not upscale its training sample rate into higher-fidelity speech.
+
+## Apply the fix script / 套用修正腳本
+
+Download and extract the Fixes ZIP, or download these three versioned files into one folder:
+
+- [Python application script](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/apply-cosyvoice-fixes-20261021-01.py)
+- [Native source patch](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/aitable-native-fixes-20261021-01.patch)
+- [Pinned source/hash manifest](https://huggingface.co/Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64/blob/main/fixes-manifest-20261021-01.json)
+
+Requires Python 3.9+ and Git. Obtain a **separate upstream checkout at the exact commit**, preserving LF line endings:
+
+```bat
+git -c core.autocrlf=false clone https://github.com/Lourdle/cosyvoice.cpp.git cosyvoice-patch-work
+git -C cosyvoice-patch-work checkout 67d45feb2f654bbc66cca25bff78464b3ec08fa1
+python apply-cosyvoice-fixes-20261021-01.py --source cosyvoice-patch-work
+python apply-cosyvoice-fixes-20261021-01.py --source cosyvoice-patch-work --apply
+```
+
+Default is check-only. The script verifies the patch and every affected original file, rejects a different/already-patched source, preserves backups and a restore manifest beside the checkout, then checks every output hash. It explicitly disables Git automatic newline conversion for the patch operation. Do not point it at an installed runtime or a working tree with your own modifications to affected files. This does **not** compile, download models, replace installed binaries, restart services or repair arbitrary upstream versions.
+
+To restore, consult the backup's `restore-manifest.json`: restore originals and remove only listed newly added files, after checking no later edits would be overwritten. After patching, use upstream build instructions with your own compatible GGML/ONNX/ICU/FFmpeg dependencies. This release's script application was tested; a fresh complete source rebuild was not performed for this publication.
+
+## Validation and remaining limits
+
+- This publication: packaged CLI/server/quantizer `--help` checks passed with PATH restricted to the packaged runtime and Windows System32. No model/server was launched and all checks exited. ZIP integrity and source-patch application/output hashes are checked separately.
+- Prior validation of the same silent-resampling DLL: CPU fault injection returned failure with zero KV/PCM on a forced-silent case, cancellation completed, and a subsequent synthesis on the same context succeeded. Normal CPU PCM matched the previous core in the tested case. These are limited tests, not full GPU/live validation.
+- Earlier streaming seam and loudness investigations remain unresolved in some listening cases. The package retains our local cumulative-mel/quiet-handoff approach, not an assertion that every pop, loudness jump or strange utterance is fixed. Changing chunk length reduces seam frequency but is not by itself proof of correctness.
+- Cumulative mel/HiFT work may increase time/memory versus upstream overlap-only behavior. This release adds no new RTF, first-audio latency or VRAM benchmark; performance depends on model, reference, chunking and hardware.
+- Large F32 models may exceed a single Vulkan allocation on AMD. This release does not include a multi-buffer loader fix or override that hardware limit.
+
+## Licensing
+
+CosyVoice.cpp and our native changes use the preserved MIT terms; bundled dependencies retain their own licenses. **FFmpeg components in this package identify as LGPL-3.0-or-later**, not the upstream notice's generic LGPL-2.1 default. See `THIRD_PARTY_NOTICES.md` and `licenses/` for included texts, provenance and source links. MIT repository metadata describes the core and does not relicense FFmpeg, model weights or every dependency.

SHA256SUMS-20261021-01.txt

@@ -0,0 +1,10 @@
+7bae74c8d7c925845fe47c8cd868099ece682f6612641c4edd0d23856021261e  AiTable-CosyVoice-Native-Fixes-20261021-01.zip
+38ee37f972d36afb0e6cfbbe16d790bd63d0a9c6e00348fe9ca21f8e272b62c3  AiTable-CosyVoice-Vulkan-Windows-x64-20261021-01.zip
+9cc2f8fe88f5704b39c80ea85a1ce67405ef01a8e3e400472c6fd045219db066  aitable-native-fixes-20261021-01.patch
+c0a0353f6fb83e3fa6f7e8b0535c606de46cbb8832bc1cecbbd47f8985fdecd1  apply-cosyvoice-fixes-20261021-01.py
+bb36c53f2d6db5810424f6adc0b8919a7c43ca829230a5fc78b642b752529863  build-manifest-20261021-01.json
+06e470aeff1db8deb42ec4a31801900ba0b8ebb35385c8e39f379be1cef9c807  fixes-manifest-20261021-01.json
+1626472fca8e6ff90fa9d1561cff421b8b67f3383d171b76ae93e7ed404a3ab2  LICENSE
+2ad119df4c4021e7cfbdf0e0ea6ff6dc4a588567f6a422a114314a8f132e78c5  README-20261021-01.md
+2ad119df4c4021e7cfbdf0e0ea6ff6dc4a588567f6a422a114314a8f132e78c5  README.md
+e92b1154b164468aaddc7f4c2fe18ef62f240f765c47e59f78e2065cc0c5aa09  THIRD_PARTY_NOTICES.md

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,9 @@
+# Binary dependency notices
+
+Core: CosyVoice.cpp, copyright 2026 Lourdle, MIT (LICENSE). AiTable native modifications retain MIT terms.
+
+Included DLL components: GGML/llama.cpp (MIT), ONNX Runtime (MIT plus third-party notices), ICU 78.1 (Unicode license), LLVM OpenMP libomp (Apache-2.0 WITH LLVM-exception), FFmpeg shared libraries (this build identifies LGPL-3.0-or-later). Static/header dependencies include PCRE2 (BSD-3-Clause with its upstream exception where applicable), cpp-httplib (MIT), nlohmann/json (MIT), KissFFT-derived FFT references (BSD-3-Clause), and SIMD math references (zlib). Texts and upstream component notices are in licenses/. The upstream notice's statement about no local GGML changes is not a certification of every binary in this community distribution.
+
+FFmpeg runtime provenance: ffmpeg executable from the same installed distribution reports n8.1.3-20260921, gcc 16.2.0, --enable-version3 --enable-shared --disable-static, with no --enable-gpl. The package contains unchanged FFmpeg shared libraries, not our own FFmpeg modifications. The executable itself and unrelated ffplay/ffprobe are omitted. Original producer and build recipes: https://github.com/BtbN/FFmpeg-Builds ; FFmpeg versioned source: https://github.com/FFmpeg/FFmpeg/tree/n8.1.3 ; source archive: https://ffmpeg.org/releases/ffmpeg-8.1.3.tar.xz ; source/build dependency recipes: https://github.com/BtbN/FFmpeg-Builds/tree/master/scripts.d . LGPL and GPL license texts are included. Preserve these notices and recipients' rights to modify/replace the dynamically linked libraries for their own use; no restriction on reverse engineering for debugging those modifications is added by this package.
+
+Other upstream sources: https://github.com/Lourdle/cosyvoice.cpp ; https://github.com/ggml-org/ggml ; https://github.com/microsoft/onnxruntime ; https://github.com/unicode-org/icu ; https://github.com/llvm/llvm-project ; https://github.com/PCRE2Project/pcre2 ; https://github.com/yhirose/cpp-httplib ; https://github.com/nlohmann/json ; https://github.com/mborgerding/kissfft ; https://zlib.net . Dependency source is not included in the native-fixes archive. This package does not include model licenses as a grant to any private model/voice.

aitable-native-fixes-20261021-01.patch

@@ -0,0 +1,739 @@
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -399,9 +399,11 @@
+ # -----------------------------------------------------------------------------
+ # Tools (Executables)
+ # -----------------------------------------------------------------------------
++# Diagnostic library build: reuse the unchanged installed server executable.
++
++# -----------------------------------------------------------------------------
++# Post-Build & Installation Rules
++# -----------------------------------------------------------------------------
++include(cmake/Install.cmake)
++
+ add_subdirectory(tools)
+-
+-# -----------------------------------------------------------------------------
+-# Post-Build & Installation Rules
+-# -----------------------------------------------------------------------------
+-include(cmake/Install.cmake)
+--- a/include/cosyvoice.h
++++ b/include/cosyvoice.h
+@@ -24,6 +24,14 @@
+ 
+ // ----------------------------------------------------------------------------
+ // Enumerations
++// AiTable fixed rank-4/alpha-8 Q/V adapter. Caller verifies the exact base and
++// factor container before this typed boundary. Status: 0 ok, 1 busy, 2 incompatible,
++// 3 malformed/not-loaded, 4 allocation failed. Loading never enables the adapter.
++// Factors: layers 0..23, q then v, A[4,896] then B[out,4], row-major FP32.
++COSYVOICE_API int cosyvoice_lora_load_f32(struct cosyvoice_context* ctx, const float* factors, size_t count);
++COSYVOICE_API int cosyvoice_lora_set_enabled(struct cosyvoice_context* ctx, bool enabled);
++// State: 0 unloaded, 1 disabled, 2 enabled. generation changes only on a mode transition.
++COSYVOICE_API int cosyvoice_lora_state(struct cosyvoice_context* ctx, uint64_t* generation, size_t* bytes);
+ // ----------------------------------------------------------------------------
+ 
+ /**
+--- /dev/null
++++ b/src/cosyvoice-diagnostics.h
+@@ -0,0 +1,28 @@
++// Content-free observed stages only. No synchronization or audio changes.
++#pragma once
++#include <cstdio>
++#include <chrono>
++namespace aitable_tts_diag {
++inline thread_local unsigned remaining = 128;
++inline void reset() noexcept { remaining = 128; }
++inline void mark(const char* stage, int count = -1, int worker = -1) noexcept {
++    if (!remaining) return;
++    --remaining;
++    const auto clock_ms = static_cast<unsigned long long>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count());
++    char line[192];
++    if (count >= 0 && worker >= 0)
++        std::snprintf(line, sizeof(line), "[AITABLE_TTS_STAGE] stage=%s count=%d worker=%d clock_ms=%llu\n", stage, count, worker, clock_ms);
++    else if (worker >= 0)
++        std::snprintf(line, sizeof(line), "[AITABLE_TTS_STAGE] stage=%s worker=%d clock_ms=%llu\n", stage, worker, clock_ms);
++    else
++        std::snprintf(line, sizeof(line), "[AITABLE_TTS_STAGE] stage=%s clock_ms=%llu\n", stage, clock_ms);
++    std::fputs(line, stderr);
++    std::fflush(stderr);
++}
++struct scope {
++    const char* end;
++    int worker;
++    scope(const char* begin, const char* end, int worker = -1) noexcept : end(end), worker(worker) { mark(begin, -1, worker); }
++    ~scope() { mark(end, -1, worker); }
++};
++}
+--- a/src/cosyvoice-graph.cpp
++++ b/src/cosyvoice-graph.cpp
+@@ -244,6 +244,9 @@
+ ggml_tensor* Linear::build_cgraph(ggml_context* ctx, ggml_tensor* x) const
+ {
+     auto out = ggml_mul_mat(ctx, weight, x);
++    if (lora_enabled && *lora_enabled)
++        out = ggml_add(ctx, out, ggml_scale(ctx,
++            ggml_mul_mat(ctx, lora_b, ggml_mul_mat(ctx, lora_a, x)), 2.f));
+     if (bias)
+         out = ggml_add(ctx, out, bias);
+     return out;
+--- a/src/cosyvoice-internal.h
++++ b/src/cosyvoice-internal.h
+@@ -1,3 +1,4 @@
++#include <shared_mutex>
+ #pragma once
+ 
+ #if defined(_WIN32) && !defined(COSYVOICE_STATIC)
+@@ -150,6 +151,9 @@
+ struct use_count_guard
+ {
+     cosyvoice_worker_context* worker;
++    void* adapter_owner = nullptr;
++    std::shared_lock<std::shared_mutex> adapter_read;
++    void protect_adapter(cosyvoice_model* model);
+ 
+     use_count_guard(cosyvoice_context* ctx);
+     use_count_guard(cosyvoice_model* model);
+--- a/src/cosyvoice-kv-cache.cpp
++++ b/src/cosyvoice-kv-cache.cpp
+@@ -251,8 +251,8 @@
+     {
+         size_t nbytes = 0;
+         auto object_size = get_offloaded_kv_cache_struct_size(layers);
+-        for (auto i = 0; i != layers; ++i)
+-            nbytes += advance_ptr(offloaded_cache, object_size)->buffer.capacity();
++        for (int i = 0; i != n_offloaded_kv_slots; ++i)
++            nbytes += advance_ptr(offloaded_cache, object_size * i)->buffer.capacity();
+         return nbytes;
+     }
+     else return 0;
+@@ -262,11 +262,13 @@
+ {
+     if (offloaded_cache)
+     {
+-        ggml_free(offloaded_cache->ctx);
+         auto object_size = get_offloaded_kv_cache_struct_size(layers);
+-        for (auto i = 0; i != layers; ++i)
+-        {
+-            auto cur = advance_ptr(offloaded_cache, object_size);
++        // Invalidate each allocated offload slot; contexts remain owned until
++        // destruction and are reused by subsequent prefill/offload operations.
++        for (int i = 0; i != n_offloaded_kv_slots; ++i)
++        {
++            auto cur = advance_ptr(offloaded_cache, object_size * i);
++            ggml_reset(cur->ctx);
+             std::vector<char>().swap(cur->buffer);
+             cur->len = 0;
+         }
+--- a/src/cosyvoice-llm-job.cpp
++++ b/src/cosyvoice-llm-job.cpp
+@@ -1,3 +1,4 @@
++#include "cosyvoice-diagnostics.h"
+ #include "cosyvoice-internal.h"
+ #include "cosyvoice-model.h"
+ 
+@@ -16,6 +17,7 @@
+ bool cosyvoice_model_3::llm_job_ext(const int* text, uint32_t text_len, cosyvoice_prompt_t prompt, uint32_t max_new_tokens, bool* final)
+ {
+     use_count_guard _guard(this);
++    aitable_tts_diag::scope diagnostic("llm_begin", "llm_end", get_worker_no());
+     const auto& params = shared->params;
+     auto& sched = worker->sched;
+     const auto& llm = cv3_shared->llm;
+@@ -144,8 +146,23 @@
+         constexpr uint32_t max_silent_token_num = 5;
+         const auto& silent_tokens = cv3_shared->silent_tokens;
+ 
++        // Rejected samples keep the current logits/KV unchanged. Bound draws
++        // on that unchanged state separately from the accepted-token budget.
++        // Use the current generation limit, widened before adding its existing
++        // two-draw termination envelope; successful acceptance resets retries.
++        const uint64_t silent_resample_limit = static_cast<uint64_t>(limit) + 2;
++        uint64_t silent_resamples = 0;
+         for (uint32_t n = llm_get_n_accepted_tokens();; ++n)
+         {
++            if (is_stop_requested())
++            {
++                worker->llm_input = nullptr;
++                cosyvoice_call_ggml_log_callback(GGML_LOG_LEVEL_INFO, "LLM generation stopped by user.\n");
++                if (params.builtin_sampler_rng_policy == COSYVOICE_BUILTIN_SAMPLER_RNG_POLICY_RESET_PER_SESSION)
++                    reset_builtin_sampler_rng();
++                return false;
++            }
++
+             llm_prepare_probs(n > min_len);
+             const auto token_id = llm_sample_token();
+             if (token_id == -1)
+@@ -161,10 +178,11 @@
+                 ++cur_silent_token_num;
+                 if (cur_silent_token_num > max_silent_token_num)
+                 {
+-                    // Drop excess silent tokens — the token is already in the
+-                    // KV cache (from llm_decode), so update cur to keep the
+-                    // model state consistent, but skip llm_accept_token so
+-                    // it does not appear in the output.
++                    // Re-sample the current logits without accepting this token.
++                    // No decode has consumed this sampled token yet. Cancellation
++                    // and a consecutive rejection budget bound this path.
++                    if (++silent_resamples >= silent_resample_limit)
++                        throw std::runtime_error("LLM consecutive silent resampling limit exceeded.\n");
+                     cur = speech_emb + token_id * speech_row_size;
+                     --n;
+                     continue;
+@@ -173,6 +191,7 @@
+             else
+                 cur_silent_token_num = 0;
+ 
++            silent_resamples = 0;
+             llm_accept_token(token_id);
+ 
+             if (is_stop_requested())
+--- /dev/null
++++ b/src/cosyvoice-lora.cpp
+@@ -0,0 +1,82 @@
++#include "cosyvoice-model.h"
++#include <algorithm>
++#include <cmath>
++#include <span>
++#include <cstdio>
++
++extern bool aitable_adapter_read_owned(void* owner);
++namespace {
++constexpr size_t factor_count = 270336;
++void invalidate(cosyvoice_model_3* model) {
++    // All workers are idle under the exclusive adapter gate. No model weights
++    // or noise state are changed; prefill and decode graphs must see the mode.
++    for (uint32_t i=0; i<model->shared->params.n_workers; ++i) {
++        auto& w=model->workers[i];
++        ggml_backend_synchronize(w.backend.get());
++        ggml_backend_sched_reset(w.sched.get());
++        w.gf=nullptr; w.llm_input=nullptr; w.llm_probs=nullptr;
++        w.prompt_crc32=0; w.llm_kv_cache.cur_len=0;
++        w.llm_kv_cache.clear_offloaded_cache();
++    }
++}
++}
++int cosyvoice_lora_load_f32(cosyvoice_context* ctx,const float* data,size_t count) {
++    auto* model=dynamic_cast<cosyvoice_model_3*>(ctx);
++    if (!model || !data || count!=factor_count) return 3;
++    auto& state=*model->cv3_shared;
++    std::unique_lock gate(model->shared->adapter_mutex,std::try_to_lock);
++    if (!gate.owns_lock()) return 1;
++    if (state.lora_buffer || state.llm.layers.size()!=24) return 2;
++    if (!std::all_of(data,data+count,[](float f){return std::isfinite(f);})) return 3;
++    for (auto& layer:state.llm.layers) {
++        auto* q=layer.self_attn.q_proj.weight;auto* v=layer.self_attn.v_proj.weight;
++        if (!q || !v || q->type!=GGML_TYPE_F16 || v->type!=GGML_TYPE_F16 ||
++            q->ne[0]!=896 || q->ne[1]!=896 || v->ne[0]!=896 || v->ne[1]!=128) return 2;
++    }
++    try {
++        ggml_context_ptr storage(ggml_init({ggml_tensor_overhead()*100, nullptr, true}));
++        if (!storage) return 4;
++        std::vector<std::pair<ggml_tensor*,ggml_tensor*>> tensors;
++        for (int i=0;i<24;++i) for(int output:{896,128}) {
++            tensors.emplace_back(ggml_new_tensor_2d(storage.get(),GGML_TYPE_F32,896,4),
++                                 ggml_new_tensor_2d(storage.get(),GGML_TYPE_F32,4,output));
++        }
++        ggml_backend_buffer_ptr buffer(ggml_backend_alloc_ctx_tensors(storage.get(),model->worker->backend.get()));
++        if (!buffer) return 4;
++        size_t offset=0;
++        for (auto [a,b]:tensors) {
++            for (auto* tensor:{a,b}) {
++                auto bytes=ggml_nbytes(tensor);
++                ggml_backend_tensor_set(tensor,data+offset,0,bytes); offset+=bytes/sizeof(float);
++            }
++        }
++        // Commit only after every tensor is allocated and uploaded.
++        state.lora_ctx=std::move(storage);state.lora_buffer=std::move(buffer);
++        size_t index=0;
++        for(auto& layer:state.llm.layers) for(auto* linear:{&layer.self_attn.q_proj,&layer.self_attn.v_proj}) {
++            auto [a,b]=tensors[index++];linear->lora_a=a;linear->lora_b=b;
++            linear->lora_enabled=&state.lora_enabled;
++        }
++        return 0;
++    } catch(const std::bad_alloc&) {return 4;}
++}
++int cosyvoice_lora_set_enabled(cosyvoice_context* ctx,bool enabled) {
++    auto* model=dynamic_cast<cosyvoice_model_3*>(ctx);if(!model)return 2;
++    std::unique_lock gate(model->shared->adapter_mutex,std::try_to_lock);
++    if(!gate.owns_lock())return 1;
++    auto& state=*model->cv3_shared;
++    if(enabled && !state.lora_buffer)return 3;
++    if(enabled==state.lora_enabled)return 0;
++    invalidate(model);
++    state.lora_enabled=enabled;++state.lora_generation;
++    return 0;
++}
++int cosyvoice_lora_state(cosyvoice_context* ctx,uint64_t* generation,size_t* bytes) {
++    auto* model=dynamic_cast<cosyvoice_model_3*>(ctx);if(!model)return -1;
++    std::shared_lock<std::shared_mutex> gate;
++    if(!aitable_adapter_read_owned(model->shared))gate=std::shared_lock(model->shared->adapter_mutex);
++    auto& state=*model->cv3_shared;
++    if(generation)*generation=state.lora_generation;
++    if(bytes)*bytes=state.lora_buffer?ggml_backend_buffer_get_size(state.lora_buffer.get()):0;
++    return !state.lora_buffer?0:state.lora_enabled?2:1;
++}
+--- a/src/cosyvoice-model.cpp
++++ b/src/cosyvoice-model.cpp
+@@ -1,3 +1,4 @@
++#include "cosyvoice-diagnostics.h"
+ #include "cosyvoice-model.h"
+ #include "common.h"
+ 
+@@ -551,19 +552,24 @@
+ 
+ void cosyvoice_model::request_stop()
+ {
++    aitable_tts_diag::reset();
+     if (worker->use_count.load(std::memory_order_acquire) == 0)
+         goto cleanup;
+ 
+     worker->stop_flag.store(true, std::memory_order_release);
+     {
+         std::unique_lock<std::mutex> lock(worker->cv_mutex);
++        aitable_tts_diag::mark("stop_wait_begin", static_cast<int>(worker->use_count.load(std::memory_order_acquire)), get_worker_no());
+         worker->cv.wait(lock, [this]() {
+             return worker->use_count.load(std::memory_order_acquire) == 0;
+         });
++        aitable_tts_diag::mark("stop_wait_end", static_cast<int>(worker->use_count.load(std::memory_order_acquire)), get_worker_no());
+     }
+ 
+ cleanup:
+     worker->offset = 0;
++    worker->flow_cache.clear();
++    worker->chunk_boundaries.clear();
+     worker->stop_flag.store(false, std::memory_order_release);
+ }
+ 
+--- a/src/cosyvoice-model.h
++++ b/src/cosyvoice-model.h
+@@ -30,6 +30,7 @@
+ 
+     std::mt19937 noise_rng;
+     std::shared_mutex noise_mutex;
++    std::shared_mutex adapter_mutex;
+     std::unique_ptr<float[]> rand_noise;
+     uint32_t rand_noise_len;
+     cosyvoice_generation_config_t config;
+@@ -153,6 +154,10 @@
+ 
+ struct cosyvoice_model_3_shared
+ {
++    ggml_context_ptr lora_ctx;
++    ggml_backend_buffer_ptr lora_buffer;
++    bool lora_enabled = false;
++    uint64_t lora_generation = 0;
+     CausalMaskedDiffWithDiT flow;
+     CausalHiFTGenerator hift;
+     CosyVoice3LM llm;
+@@ -168,6 +173,7 @@
+ 
+     ggml_context_ptr ctx1;
+     ggml_backend_buffer_ptr token2wav_buffer;
++    uint32_t committed_speech_samples = 0;
+ };
+ 
+ struct cosyvoice_model_3 : cosyvoice_model
+--- a/src/cosyvoice-modules.h
++++ b/src/cosyvoice-modules.h
+@@ -35,6 +35,10 @@
+ 
+ struct Linear : BasicModule
+ {
++    // Optional low-rank branch. Disabled means the original graph, not scale zero.
++    ggml_tensor* lora_a = nullptr;
++    ggml_tensor* lora_b = nullptr;
++    const bool* lora_enabled = nullptr;
+     ggml_tensor* build_cgraph(ggml_context* ctx, ggml_tensor* x) const;
+ };
+ 
+--- /dev/null
++++ b/src/cosyvoice-streaming-handoff.h
+@@ -0,0 +1,30 @@
++#pragma once
++#include <algorithm>
++#include <cstdint>
++#include <limits>
++#include <span>
++#include <stdexcept>
++
++namespace cosyvoice_streaming {
++// Select only from the currently available prefix. Uncommitted samples are
++// taken from the next cumulative HiFT result; finalization emits everything.
++inline uint32_t commit_end(std::span<const float> wave, uint32_t prior, uint32_t rate, bool finalize) {
++    if (wave.size() > std::numeric_limits<uint32_t>::max() || wave.size() < prior)
++        throw std::runtime_error("CosyVoice streaming prefix regressed or exceeded sample capacity");
++    const auto end = static_cast<uint32_t>(wave.size());
++    if (finalize) return end;
++    const uint32_t half = std::max(1u,rate/100), min_hold = std::max(1u,rate/50);
++    const uint32_t max_hold = std::max(1u,rate/4), stride = std::max(1u,rate/1000);
++    // Short prefixes cannot provide a complete energy window. Preserve the
++    // existing available output rather than inventing silence or dropping it.
++    if (end <= max_hold || static_cast<uint64_t>(prior)+half+min_hold > end) return end;
++    uint32_t selected = end;
++    double best = std::numeric_limits<double>::infinity();
++    for (uint32_t j = std::max(prior+half,end-max_hold); j <= end-min_hold; j+=stride) {
++        double energy=0;
++        for (uint32_t k=j-half;k<j+half;++k) { const double x=wave[k]; energy+=x*x; }
++        if (energy<best) { best=energy; selected=j; }
++    }
++    return selected;
++}
++}
+--- a/src/cosyvoice-token2wav.cpp
++++ b/src/cosyvoice-token2wav.cpp
+@@ -1,3 +1,5 @@
++#include "cosyvoice-streaming-handoff.h"
++#include "cosyvoice-diagnostics.h"
+ #include "cosyvoice-internal.h"
+ #include "cosyvoice-model.h"
+ #include "ggml-cpu-flag.h"
+@@ -223,6 +225,7 @@
+         kv_cache->cur_len = 0;
+         worker->chunk_boundaries.clear();
+         worker->flow_cache.clear();
++        cv3_worker->committed_speech_samples = 0;
+     }
+ 
+     ggml_reset(ctx0.get());
+@@ -289,6 +292,7 @@
+     else
+         full_len = seq_len;
+ 
++    aitable_tts_diag::mark("flow_begin", -1, get_worker_no());
+     float* noise_buffer = shared->noise_callback(COSYVOICE_NOISE_CALLBACK_STAGE_BEFORE_FLOW, noise_req, nullptr, shared->noise_callback_ctx);
+     ggml_backend_tensor_set_async(backend.get(), ditctx.x, noise_buffer + noise_req - noise_len, 0, ditctx.x->nb[2]);
+ 
+@@ -357,6 +361,7 @@
+     load_kv(0);
+ 
+     worker->status = ggml_backend_sched_graph_compute(sched.get(), gf);
++    aitable_tts_diag::mark("flow_first_step_end", -1, get_worker_no());
+     shared->noise_callback(COSYVOICE_NOISE_CALLBACK_STAGE_AFTER_FLOW, noise_req, noise_buffer, shared->noise_callback_ctx);
+     if (params.inference_buffer_policy != COSYVOICE_INFERENCE_BUFFER_POLICY_DEDICATED)
+         llm_set_kv_cache_len(0);
+@@ -455,6 +460,9 @@
+     // Phase 3: Copy flow output to speech_feat (persistent buffer)
+     ggml_reset(ctx1.get());
+     const auto cache_length = streaming ? static_cast<int64_t>(worker->flow_cache.size() / feat->ne[0]) : 0;
++    // The cumulative mel history is bounded by this context's existing token capacity.
++    if (streaming && feat->ne[1] + cache_length > static_cast<int64_t>(params.n_max_seq) * flow.token_mel_ratio)
++        throw std::runtime_error("CosyVoice streaming mel exceeds context capacity");
+     ggml_tensor* speech_feat = ggml_new_tensor_2d(ctx1.get(), feat->type, feat->ne[0], feat->ne[1] + cache_length);
+     if (cache_length != 0)
+     {
+@@ -478,20 +486,12 @@
+         ggml_backend_tensor_copy_async(backend.get(), backend.get(), feat, speech_feat);
+     }
+ 
+-    if (streaming && !finalize)
+-    {
+-        const auto overlap = static_cast<int64_t>(shared->hift_overlap);
+-        const auto n_feat_frames = feat->ne[1];
+-        const auto frames_to_keep = std::min(overlap, n_feat_frames);
+-        const auto elements_to_keep = static_cast<size_t>(frames_to_keep * feat->ne[0]);
+-
+-        worker->flow_cache.resize(elements_to_keep);
+-        if (frames_to_keep > 0)
+-        {
+-            const auto byte_offset = static_cast<size_t>((n_feat_frames - frames_to_keep) * feat->nb[1]);
+-            const auto byte_size = static_cast<size_t>(frames_to_keep * feat->nb[1]);
+-            ggml_backend_tensor_get_async(backend.get(), feat, worker->flow_cache.data(), byte_offset, byte_size);
+-        }
++    if (streaming && !finalize) {
++        // Complete input copies before vector growth can invalidate their source.
++        ggml_backend_synchronize(backend.get());
++        worker->flow_cache.resize(ggml_nelements(speech_feat));
++        ggml_backend_tensor_get_async(backend.get(), speech_feat, worker->flow_cache.data(), 0, speech_feat->nb[2]);
++        ggml_backend_synchronize(backend.get());
+     }
+ 
+     if (config[flow.decoder.diffusion_steps - 1].cache_kv)
+@@ -529,13 +529,24 @@
+                     hift.f0_predictor.condnet_0.output_length(speech_feat->ne[0],
+                         finalize), true), true), true), true) * hift.scale_factor * noise->ne[0]);
+     noise_req = std::max(noise_req, noise_len);
++    aitable_tts_diag::mark("flow_end", -1, get_worker_no());
++    aitable_tts_diag::mark("hift_begin", -1, get_worker_no());
+     noise_buffer = shared->noise_callback(COSYVOICE_NOISE_CALLBACK_STAGE_BEFORE_HIFT, noise_req, nullptr, shared->noise_callback_ctx);
+     ggml_backend_tensor_set_async(backend.get(), noise, noise_buffer + noise_req - noise_len, 0, noise->nb[2]);
+ 
+     result->data = reinterpret_cast<float*>(generated_speech->data);
+     result->length = static_cast<uint32_t>(generated_speech->ne[0]);
+     worker->status = ggml_backend_sched_graph_compute(sched.get(), gf);
++    aitable_tts_diag::mark("hift_end", -1, get_worker_no());
+     shared->noise_callback(COSYVOICE_NOISE_CALLBACK_STAGE_AFTER_HIFT, noise_req, noise_buffer, shared->noise_callback_ctx);
+ 
++    if (worker->status == GGML_STATUS_SUCCESS && streaming) {
++        const auto prior = cv3_worker->committed_speech_samples;
++        const auto end = cosyvoice_streaming::commit_end(std::span<const float>(result->data,result->length),prior,get_sample_rate(),finalize);
++        result->data += prior;
++        result->length = end-prior;
++        cv3_worker->committed_speech_samples = finalize ? 0 : end;
++        if (finalize) worker->flow_cache.clear();
++    }
+     return worker->status == GGML_STATUS_SUCCESS;
+ }
+--- a/src/cosyvoice-tts.cpp
++++ b/src/cosyvoice-tts.cpp
+@@ -1,4 +1,5 @@
+-#include "cosyvoice-internal.h"
++#include "cosyvoice-diagnostics.h"
++#include "cosyvoice-internal.h"
+ #include "cosyvoice-text-chunk.h"
+ 
+ #include <algorithm>
+@@ -45,6 +46,7 @@
+ 
+ static inline bool strip_emoji(std::string_view text, std::string& result)
+ {
++    result.clear();
+     result.reserve(text.size());
+     bool removed = false;
+     bool prev_emoji = false;
+@@ -103,6 +105,8 @@
+ 
+     bool tts_job(const char* text, const char* instruction, float speed, cosyvoice_inference_mode mode, cosyvoice_generated_speech_ptr result, cosyvoice_tts_audio_callback_t callback, void* user_data)
+     {
++        aitable_tts_diag::reset();
++        aitable_tts_diag::scope diagnostic("high_level_enter", "high_level_return");
+         instruction_cache.resize(prefix_len);
+         if (instruction)
+         {
+--- a/src/cosyvoice.cpp
++++ b/src/cosyvoice.cpp
+@@ -1,3 +1,4 @@
++#include "cosyvoice-diagnostics.h"
+ #include "cosyvoice-internal.h"
+ #include "cosyvoice-tokenizer.h"
+ #include "cosyvoice-model.h"
+@@ -25,8 +26,24 @@
+     return dist(gen);
+ }
+ 
++// Nested LLM/Flow guards run on the same host thread as the outer TTS guard.
++// Share its reader rather than recursively locking std::shared_mutex.
++static thread_local std::vector<void*> adapter_readers;
++bool aitable_adapter_read_owned(void* owner) { return std::find(adapter_readers.begin(),adapter_readers.end(),owner)!=adapter_readers.end(); }
++void use_count_guard::protect_adapter(cosyvoice_model* model)
++{
++    auto owner = static_cast<void*>(model->shared);
++    if (std::find(adapter_readers.begin(), adapter_readers.end(), owner) == adapter_readers.end())
++    {
++        adapter_read = std::shared_lock(model->shared->adapter_mutex);
++        adapter_readers.push_back(owner);
++        adapter_owner = owner;
++    }
++}
++
+ use_count_guard::use_count_guard(cosyvoice_model* model) : worker(model->worker)
+ {
++    protect_adapter(model);
+     worker->use_count.fetch_add(1, std::memory_order_relaxed);
+ }
+ 
+@@ -34,18 +51,22 @@
+ {
+     auto* model = dynamic_cast<cosyvoice_model*>(ctx);
+     worker = model->worker;
++    protect_adapter(model);
+     if(worker->use_count.load(std::memory_order_acquire) != 0)
+     {
+         std::unique_lock<std::mutex> lock(worker->cv_mutex);
++        aitable_tts_diag::mark("guard_wait_begin", static_cast<int>(worker->use_count.load(std::memory_order_acquire)), model->get_worker_no());
+         worker->cv.wait(lock, [this]() {
+             return worker->use_count.load(std::memory_order_acquire) == 0;
+         });
++        aitable_tts_diag::mark("guard_wait_end", static_cast<int>(worker->use_count.load(std::memory_order_acquire)), model->get_worker_no());
+     }
+     worker->use_count.fetch_add(1, std::memory_order_relaxed);
+ }
+ 
+ use_count_guard::~use_count_guard()
+ {
++    if (adapter_owner) adapter_readers.pop_back();
+     if (worker->use_count.fetch_sub(1, std::memory_order_release) == 1)
+         worker->cv.notify_all();
+ }
+@@ -480,7 +501,7 @@
+                 goto cleanup;
+ 
+             if (result.data && result.length > 0
+-                && !callback(result.data, result.length, user_data))
++                && (aitable_tts_diag::mark("pcm_callback"), !callback(result.data, result.length, user_data)))
+                 goto cleanup;
+         } while (n_tokens != ctx->llm_get_n_accepted_tokens());
+ 
+--- a/tools/server/cosyvoice-server-backend.cpp
++++ b/tools/server/cosyvoice-server-backend.cpp
+@@ -6,6 +6,9 @@
+ #endif
+ 
+ #include <cmath>
++#include <fstream>
++#include <cstdlib>
++#include <chrono>
+ #include <cstdint>
+ #include <ctime>
+ #include <limits>
+@@ -19,6 +22,16 @@
+ #endif
+ 
+ using json = nlohmann::json;
++static bool prepare_adapter(server_runtime&,cosyvoice_context_t,bool,Response&);
++// A provider may be discarded before its first callback. Keep slot ownership
++// until either execution finishes or httplib releases that provider, exactly once.
++struct adapter_stream_slot {
++    server_runtime& runtime;uint32_t slot;std::atomic<bool> active{true};
++    adapter_stream_slot(server_runtime& r,uint32_t s):runtime(r),slot(s){}
++    void release(){if(active.exchange(false))release_thread_slot(runtime,slot);}
++    ~adapter_stream_slot(){release();}
++};
++
+ 
+ struct speech_request
+ {
+@@ -29,6 +42,7 @@
+     float speed = 1.0f;
+     std::string instructions;
+     bool has_instructions = false;
++    bool asmr_adapter = false;
+ 
+     bool has_seed = false;
+     uint32_t seed = 0;
+@@ -330,6 +344,12 @@
+         request->has_chunk_tokens = true;
+     }
+ 
++    if (body.contains("asmr_adapter")) {
++        if (!body["asmr_adapter"].is_boolean()) {
++            set_openai_error(res,400,"asmr_adapter must be boolean","invalid_request_error","asmr_adapter","invalid_type");return false;
++        }
++        request->asmr_adapter=body["asmr_adapter"].get<bool>();
++    }
+     const auto it_instructions = body.find("instructions");
+     const auto it_instruction = body.find("instruction");
+     if (it_instructions != body.end())
+@@ -402,6 +422,11 @@
+             { "model", runtime.served_model_name },
+             { "voices", runtime.voice_names }
+         };
++        {
++            std::lock_guard lock(runtime.slot_mutex);
++            payload["active_synthesis_slots"]=std::count(runtime.slot_in_use.begin(),runtime.slot_in_use.end(),true);
++        }
++        payload["asmr_lora_protocol"]=1;
+         res.status = 200;
+         res.set_content(payload.dump(), "application/json");
+     });
+@@ -476,6 +501,9 @@
+             return;
+         }
+ 
++        if (request.asmr_adapter && (!request.has_instructions || request.instructions!="Please say a sentence in a very soft voice.")) {
++            set_openai_error(res,400,"ASMR requires the bound soft-voice preset","invalid_request_error","instructions","adapter_prompt_mismatch");return;
++        }
+         fill_request_log_context_from_request(&log_ctx, request);
+         log_request_details(runtime.log_level, log_ctx);
+ 
+@@ -548,6 +576,9 @@
+             return;
+         }
+ 
++        if (!prepare_adapter(runtime,model_ctx,request.asmr_adapter,res)) {
++            release_thread_slot(runtime,slot);return;
++        }
+         std::string payload;
+         std::string encoding_error;
+         std::string generation_error;
+@@ -594,6 +625,7 @@
+             // IMPORTANT: the provider runs AFTER the route handler returns, so
+             // any value captured by reference would be a dangling reference.
+             // Capture by value or via raw pointers that outlive the handler.
++            auto lease=std::make_shared<adapter_stream_slot>(runtime,slot);
+             auto& rt = runtime;
+             auto* vctx = voice_ctx;
+             auto log_ctx_copy = log_ctx;
+@@ -601,7 +633,7 @@
+             auto conn_checker = req.is_connection_closed;  // copy the socket-checker function
+ 
+             res.set_chunked_content_provider(content_type,
+-                [&rt, slot, req_copy, vctx, format, wav_header, has_wav, log_ctx_copy, applied_seed, conn_checker]
++                [&rt, slot, req_copy, vctx, format, wav_header, has_wav, log_ctx_copy, applied_seed, conn_checker, lease]
+                 (size_t /*offset*/, DataSink& sink) -> bool
+                 {
+                     auto model_ctx = get_slot_model_context(rt, slot);
+@@ -613,7 +645,7 @@
+                         if (!sink.write(wav_header.data(), wav_header.size()))
+                         {
+                             mon.join();
+-                            release_thread_slot(rt, slot);
++                            lease->release();
+                             sink.done();
+                             return true;
+                         }
+@@ -649,7 +681,7 @@
+                             req_copy.speed, stream_cb, &cb_ctx);
+ 
+                     mon.join();
+-                    release_thread_slot(rt, slot);
++                    lease->release();
+                     sink.done();
+ 
+                     if (!ok && !aborted)
+@@ -665,7 +697,7 @@
+ 
+                     return true;
+                 },
+-                [](bool /*success*/) { /* resource releaser — no-op */ });
++                [lease](bool /*success*/) { lease->release(); });
+ 
+             log_request_details(runtime.log_level, log_ctx);
+             return;
+@@ -709,6 +741,46 @@
+             log_request_done(runtime.log_level, log_ctx, request_log_status::ok, res.status, applied_seed, res.body.size(), "speech");
+         }
+     });
++}
++
++// The host verifies the exact model/container before starting this owned
++// subprocess. Only this local startup path may select an adapter file; HTTP
++// clients select a mode, never a filesystem path or arbitrary weights.
++static bool prepare_adapter(server_runtime& rt,cosyvoice_context_t ctx,bool enabled,Response& res) {
++    const auto begin=std::chrono::steady_clock::now();
++    uint64_t generation=0;size_t bytes=0;
++    int state=cosyvoice_lora_state(ctx,&generation,&bytes);
++    if (enabled && rt.concurrency!=1) {
++        set_openai_error(res,400,"Adapter requires one owned synthesis slot","invalid_request_error","asmr_adapter","adapter_concurrency_unsupported");return false;
++    }
++    if(enabled && state==0) {
++        const char* path=std::getenv("AITABLE_COSY_ASMR_F32");
++        if(!path || !*path) {
++            set_openai_error(res,400,"No verified ASMR adapter configured","invalid_request_error","asmr_adapter","adapter_unavailable");return false;
++        }
++        std::ifstream file(path,std::ios::binary|std::ios::ate);
++        constexpr size_t size=270336*sizeof(float);
++        if(!file || file.tellg()!=size) {
++            set_openai_error(res,500,"Invalid ASMR factor container","server_error","asmr_adapter","adapter_container_invalid");return false;
++        }
++        std::vector<float> data(270336);file.seekg(0);file.read(reinterpret_cast<char*>(data.data()),size);
++        int status=file?cosyvoice_lora_load_f32(ctx,data.data(),data.size()):3;
++        if(status) {
++            set_openai_error(res,500,"ASMR adapter load failed","server_error","asmr_adapter","adapter_load_failed");return false;
++        }
++    }
++    // Do not change ordinary multi-slot servers with no configured adapter.
++    if(enabled || state!=0) {
++        if(cosyvoice_lora_set_enabled(ctx,enabled)!=0) {
++            set_openai_error(res,409,"ASMR adapter is busy or unavailable","server_error","asmr_adapter","adapter_switch_failed");return false;
++        }
++    }
++    state=cosyvoice_lora_state(ctx,&generation,&bytes);
++    res.set_header("X-AiTable-LoRA-State",state==2?"enabled":state==1?"disabled":"unloaded");
++    res.set_header("X-AiTable-LoRA-Generation",std::to_string(generation));
++    res.set_header("X-AiTable-LoRA-Bytes",std::to_string(bytes));
++    res.set_header("X-AiTable-LoRA-Switch-Microseconds",std::to_string(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now()-begin).count()));
++    return true;
+ }
+ 
+ int cosyvoice_server_backend_run(server_runtime& runtime)

apply-cosyvoice-fixes-20261021-01.py

@@ -0,0 +1,67 @@
+"""Check or apply the version-pinned AiTable CosyVoice native patch. No build/start."""
+import argparse
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import shutil
+import subprocess
+import uuid
+
+
+def digest(path):
+    return hashlib.sha256(path.read_bytes()).hexdigest() if path.is_file() else None
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', required=True, type=Path, help='Separate upstream source checkout; do not target installed runtimes')
+    parser.add_argument('--apply', action='store_true', help='Apply after checks; default checks only')
+    args = parser.parse_args()
+    bundle = Path(__file__).resolve().parent
+    manifest = json.loads((bundle / 'fixes-manifest-20261021-01.json').read_text(encoding='utf-8'))
+    patch = bundle / 'aitable-native-fixes-20261021-01.patch'
+    if digest(patch) != manifest['patch_sha256']:
+        raise RuntimeError('Patch checksum mismatch')
+    source = args.source.resolve(strict=True)
+    if not source.is_dir():
+        raise RuntimeError('Source must be a directory')
+    targets = {}
+    for name, hashes in manifest['files'].items():
+        relative = PurePosixPath(name)
+        if relative.is_absolute() or '..' in relative.parts or ':' in name or '\\' in name:
+            raise RuntimeError('Unsafe manifest path: ' + name)
+        target = source.joinpath(*relative.parts)
+        if not target.resolve().is_relative_to(source) or target.is_symlink():
+            raise RuntimeError('Target escapes the source tree: ' + name)
+        if target.exists() and not target.is_file():
+            raise RuntimeError('Target is not a regular file: ' + name)
+        if digest(target) != hashes['before']:
+            raise RuntimeError('Source differs from pinned upstream (or already patched): ' + name)
+        targets[name] = target
+    git_apply = ['git', '-c', 'core.autocrlf=false', '-c', 'apply.whitespace=nowarn', 'apply']
+    subprocess.run([*git_apply, '--check', str(patch)], cwd=source, check=True, timeout=30)
+    if not args.apply:
+        print('CHECK PASSED: upstream ' + manifest['upstream_commit'] + '; no files modified')
+        return
+    backup = source.parent / (source.name + '-aitable-backup-' + uuid.uuid4().hex)
+    backup.mkdir()
+    for name, target in targets.items():
+        if target.exists():
+            saved = backup / name
+            saved.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(target, saved)
+    (backup / 'restore-manifest.json').write_text(json.dumps({
+        'source': str(source), 'files': manifest['files'],
+        'restore': 'Stop builds first. Restore saved files; remove only files whose before hash is null. Refuse to overwrite later changes unless verified.'
+    }, indent=2), encoding='utf-8')
+    print('BACKUP: ' + str(backup), flush=True)
+    # Git apply is atomic by default; never pass --reject or allow partial application.
+    subprocess.run([*git_apply, str(patch)], cwd=source, check=True, timeout=30)
+    for name, target in targets.items():
+        if digest(target) != manifest['files'][name]['after']:
+            raise RuntimeError('Post-apply checksum mismatch; inspect retained backup: ' + name)
+    print('APPLIED AND VERIFIED. No compilation, model download or service start performed.')
+
+
+if __name__ == '__main__':
+    main()

build-manifest-20261021-01.json

@@ -0,0 +1,177 @@
+{
+  "release": "20261021-01",
+  "repo": "Roland2531/cosyvoice.cpp-AiTable-Vulkan-Windows-x64",
+  "upstream": "https://github.com/Lourdle/cosyvoice.cpp",
+  "upstream_version": "0.2.0",
+  "upstream_commit": "67d45feb2f654bbc66cca25bff78464b3ec08fa1",
+  "runtime_core_sha256": "806a6c7a21a82c21c5d5c543586ec7ba48974574dc96991dc8bdc92b5180a277",
+  "backend": "Vulkan + CPU; no ROCm backend",
+  "patches": [
+    {
+      "id": "tts-wait-diagnostics-20261018",
+      "scope": "observability_only; subsequent streaming patch declared separately"
+    },
+    {
+      "id": "cosyvoice-streaming-handoff-20261018",
+      "scope": "CosyVoice3 native streaming: cumulative mel and causal quiet handoff"
+    },
+    {
+      "id": "cosy-asmr-dynamic-20261018",
+      "scope": "see release notes"
+    },
+    {
+      "id": "cosyvoice-emoji-buffer-reset-20261019",
+      "scope": "clear per-request emoji output string before appending; no model or playback changes"
+    },
+    {
+      "id": "cosyvoice-silent-resampling-20261021",
+      "scope": "bounded consecutive silent rejection; cancellation checked before sampling and after acceptance; existing failure cleanup"
+    }
+  ],
+  "files": {
+    "avcodec-62.dll": {
+      "bytes": 90163200,
+      "sha256": "13dae8e27fb521d7fe2f387ebc143a071fd1204d1b70ea21c303d292d2a4821c"
+    },
+    "avdevice-62.dll": {
+      "bytes": 4047872,
+      "sha256": "5921b7e8d06cb63db9f41dcdc7b5db85ef81126f516a43b678ef3488dab9fea9"
+    },
+    "avfilter-11.dll": {
+      "bytes": 30822912,
+      "sha256": "14210aaa0a6426c3b73a29bb81dfdd925d02f55262da9366f3cd0ee9359eb8f7"
+    },
+    "avformat-62.dll": {
+      "bytes": 22626816,
+      "sha256": "de4edb05dd144bbe3232a70052b3a6b849f2f0ffa0e59b0e0cd919a2529c5367"
+    },
+    "avutil-60.dll": {
+      "bytes": 3011584,
+      "sha256": "1c8cb40ef03d13aeae7603d1b7c21e0deb105346adbf6140edd15ae16c0b6628"
+    },
+    "cosyvoice-cli.exe": {
+      "bytes": 461824,
+      "sha256": "5bc5c3ee0fe74f367c1df1d9e3f0c032bd54d5955e8165d55627e7e5cb2718dd"
+    },
+    "cosyvoice-server.exe": {
+      "bytes": 875008,
+      "sha256": "950fa8e5bc047d32ad74b5f2f71e9f0909edc9b0c83aca83134ed6aafeec2505"
+    },
+    "cosyvoice.dll": {
+      "bytes": 1426432,
+      "sha256": "806a6c7a21a82c21c5d5c543586ec7ba48974574dc96991dc8bdc92b5180a277"
+    },
+    "ggml-base.dll": {
+      "bytes": 796672,
+      "sha256": "df7e8d4f935620e7bd6c4cc346786a7a778d6711cfcb1bdfd10c9db64d43d00f"
+    },
+    "ggml-cpu-sse42.dll": {
+      "bytes": 933376,
+      "sha256": "c71727180721f13785ffdd921c029be9f0d64b98e459d1779bfc27448f037bca"
+    },
+    "ggml-cpu-x64.dll": {
+      "bytes": 925184,
+      "sha256": "8fc299ed003cb64fec5c09e8bb02c2a9af7937e2087f7d8e8c7cee47738fbc32"
+    },
+    "ggml-cpu-zen4.dll": {
+      "bytes": 1442304,
+      "sha256": "e11cb7bd2ac684a35a27a7500a7da31ae43ce1e2a96e1c47009ca3db472ed20b"
+    },
+    "ggml-rpc.dll": {
+      "bytes": 168448,
+      "sha256": "746cba70f9a7b873ccb80870b63df2d51a90cf843e57e55f7948da894b166cf2"
+    },
+    "ggml-vulkan.dll": {
+      "bytes": 43318784,
+      "sha256": "1eefd2ca8347f0eb5fb29835d4deb596818381537a996cafe5a48b7136fcd082"
+    },
+    "ggml.dll": {
+      "bytes": 79872,
+      "sha256": "3113a27c04130a3623b308a6ce782099bf809376a4f4f025a8993b7e257ad30d"
+    },
+    "icudt78.dll": {
+      "bytes": 33110528,
+      "sha256": "b937bcec6cbcab5891029d91e2e7a2f803cc2ce258a3546970d0284a528709d5"
+    },
+    "icuin78.dll": {
+      "bytes": 3408896,
+      "sha256": "4d5ac61334757813f8ddf5c1ab5e28302ae2392d266450a187968aa66e164e7c"
+    },
+    "icuio78.dll": {
+      "bytes": 62464,
+      "sha256": "aafea4f5bd2cfefd734acb12cfccad1eef5f64f31c6854ff4048ca126d4c9005"
+    },
+    "icutu78.dll": {
+      "bytes": 391680,
+      "sha256": "0638be559795ecd358431e510e108b5c861c4a7a1f3fe6565732b4ec17e94881"
+    },
+    "icuuc78.dll": {
+      "bytes": 2576384,
+      "sha256": "2566e47efc4fe7edc5ea6a333051ae522cd1cbeaf353ece5f3ac97e056e39c9a"
+    },
+    "libomp.dll": {
+      "bytes": 768000,
+      "sha256": "a12116ba72d1d6820407cf30be23da04ce79d6bb8a71a5ee71759c5a1faa6f1c"
+    },
+    "onnxruntime.dll": {
+      "bytes": 16462648,
+      "sha256": "7e39e2bdbba836d98071ef28620735ba36a47c554cf794585269aecc50fab0da"
+    },
+    "onnxruntime_providers_shared.dll": {
+      "bytes": 21816,
+      "sha256": "b9b7ab9e2a8b08ee7ae4a7ac1c8bfd44a741f17ad8d0f764953140a57de0b796"
+    },
+    "quantize.exe": {
+      "bytes": 654848,
+      "sha256": "a208042c7dfc9153b66359f017f5e462302534314956114c4d9c7d516ce65375"
+    },
+    "swresample-6.dll": {
+      "bytes": 733696,
+      "sha256": "8dda56981dabeff97e0296d336d042e3312f5703ddef5117d5497dc1466c2cc9"
+    },
+    "swscale-9.dll": {
+      "bytes": 12823040,
+      "sha256": "1f6ba4fa84bfd5ac371b7d8699bd53c86756bd0f69895dd03bf4a7871ecbccab"
+    }
+  },
+  "models_included": false,
+  "private_voices_included": false,
+  "source_snapshot_included": false,
+  "license_download_sources": {
+    "ONNX-Runtime-MIT.txt": "https://raw.githubusercontent.com/microsoft/onnxruntime/main/LICENSE",
+    "ONNX-Runtime-ThirdPartyNotices.txt": "https://raw.githubusercontent.com/microsoft/onnxruntime/main/ThirdPartyNotices.txt",
+    "Unicode-license.txt": "https://www.unicode.org/license.txt",
+    "nlohmann-json-MIT.txt": "https://raw.githubusercontent.com/nlohmann/json/v3.12.0/LICENSE.MIT",
+    "KissFFT-BSD.txt": "https://raw.githubusercontent.com/mborgerding/kissfft/master/COPYING",
+    "LLVM-libomp.txt": "https://raw.githubusercontent.com/llvm/llvm-project/main/openmp/LICENSE.TXT",
+    "PCRE2-LICENCE.md": "https://raw.githubusercontent.com/PCRE2Project/pcre2/master/LICENCE.md",
+    "zlib.txt": "https://raw.githubusercontent.com/madler/zlib/master/LICENSE"
+  },
+  "verification": [
+    {
+      "exe": "cosyvoice-cli.exe",
+      "args": [
+        "--help"
+      ],
+      "exit": 0,
+      "waited": true
+    },
+    {
+      "exe": "cosyvoice-server.exe",
+      "args": [
+        "--help"
+      ],
+      "exit": 0,
+      "waited": true
+    },
+    {
+      "exe": "quantize.exe",
+      "args": [
+        "--help"
+      ],
+      "exit": 0,
+      "waited": true
+    }
+  ],
+  "new_model_inference": false
+}

fixes-manifest-20261021-01.json

@@ -0,0 +1,70 @@
+{
+  "upstream_commit": "67d45feb2f654bbc66cca25bff78464b3ec08fa1",
+  "patch_sha256": "9cc2f8fe88f5704b39c80ea85a1ce67405ef01a8e3e400472c6fd045219db066",
+  "files": {
+    "CMakeLists.txt": {
+      "before": "1885afffb9eb73a9dd969f918ad1c9c8baec59e6b3d7e74c2c3b8b9047990abb",
+      "after": "8b39b9dd9c8c0ad84794cd3ba55e954ab61c1d78d98431a82c095dbb21b79c1c"
+    },
+    "include/cosyvoice.h": {
+      "before": "246b3337437a0d7de5f2bc18cba48449e2cf2a3f6050c81a3a90f3068bb1f176",
+      "after": "98ed457e186e9b807073bb18dece459477fe7900a7627f0636a7683cfe480681"
+    },
+    "src/cosyvoice-diagnostics.h": {
+      "before": null,
+      "after": "7d9b188f1f967aaa2d6fe5d4f0f0d31fea98847fbd99ad488763418dbcbc0922"
+    },
+    "src/cosyvoice-graph.cpp": {
+      "before": "5225031cde4af043e4a6378ed54f018c27bbc656f61535f36ca9e464f5e723bb",
+      "after": "96a5d60c52a8d57ac7c0255669f188145722465723bd91da8be52d00c3842e27"
+    },
+    "src/cosyvoice-internal.h": {
+      "before": "be9e76b81a3bc907e12d25c456653f6208cbeb71f9a442054e60be358bce3f3b",
+      "after": "942cb468b9c59d326499ed8816cebdabe10c6f929eea20a06fc344018d38ccbe"
+    },
+    "src/cosyvoice-kv-cache.cpp": {
+      "before": "9b649cfd3fa1e218d020605513c321decf05b1f81ae9b0903886339e7fb56914",
+      "after": "d1efc94e8b7a22099494e2f83f6a392c089358f2397ddbe259a86c80f6b73f63"
+    },
+    "src/cosyvoice-llm-job.cpp": {
+      "before": "2480ddc925ce1f715d600889943c056aa5fc3afecee98c11ba264aa4af8a1d94",
+      "after": "98abc97df7eac40380c0393e0f4d53caa6cbafd97440e135e0e8899035015891"
+    },
+    "src/cosyvoice-lora.cpp": {
+      "before": null,
+      "after": "184d469d00d737e45875b6a2589c65adde8e9efdc2effb459a0a5855df339b89"
+    },
+    "src/cosyvoice-model.cpp": {
+      "before": "cd6574ad2ee0ca4ea87e2f95a961c27c6cdee423ac592dfd62e51723886e56eb",
+      "after": "aa57c3d534291b1b09d4ab4156eb9822eeb179367707dcd694fee4b2c5133e8f"
+    },
+    "src/cosyvoice-model.h": {
+      "before": "da76f096aa7c4c7b010e00411712bad1285d9815bde6472deac80c7249942dce",
+      "after": "552a5d7f4dcb104f32082f3a490d91f538a57183360e3b183bd8c7482b2f07f1"
+    },
+    "src/cosyvoice-modules.h": {
+      "before": "6fe4b0df465d264f0deb337dd1d4cda1b66b3263158c68b6c3b7d56aee7b5760",
+      "after": "bc78f7a13ea1e20e88a97374f85493b4d8344a2720afe8a6d300fe58e77e3359"
+    },
+    "src/cosyvoice-streaming-handoff.h": {
+      "before": null,
+      "after": "c217f96d7bf81fe7d9a75c1438b53716c30358cd35441f6688fcea2d5e08a597"
+    },
+    "src/cosyvoice-token2wav.cpp": {
+      "before": "6d680401c5b632bd9caaca356df0aad82a8d016e532640315d147e548b98a8f3",
+      "after": "4bd02b8817b7e5a9935ebc9db126ee496c149c37a6775e17b71b4bf6da13a2cb"
+    },
+    "src/cosyvoice-tts.cpp": {
+      "before": "aba9680e115b09a16f6c5d9d26319e43768058b2df31e1a98c0f45eb9f2826e4",
+      "after": "f2ef5c92214721ce73b14d9be2d45c6db3d16e3d6f8cfdffdbf2a337693f74ff"
+    },
+    "src/cosyvoice.cpp": {
+      "before": "5f497e30aeb5a8a464695a002f3444c4d4c82c7c6456b8eadc3cb585d6ab4131",
+      "after": "d4e20eccba1e5a5d00098fb7d84b241d051204d84b8a68c55fb0e4be9b830056"
+    },
+    "tools/server/cosyvoice-server-backend.cpp": {
+      "before": "52f55e5178aff64093da9bc0df8b0fb2d8679ed5ec42df41eb40368863e9e43a",
+      "after": "ba95d80666ff8f7eccc62155812fac8f39b7e973de611a1e978717bb1ddde462"
+    }
+  }
+}