Upload folder using huggingface_hub

README.md

@@ -21,15 +21,13 @@ tags:
 
 # Matoub-4B
 
-A 4B-parameter neural speech synthesis and voice cloning foundation model for **Kabyle** (Taqbaylit, `kab`, Latin script), trained on 384,960 curated speech pairs from Common Voice Kabyle. Given Kabyle text and a short reference recording with its transcript, it synthesises broadcast-quality **24 kHz audio** that reproduces the vocal timbre, prosodic contours, and acoustic presence of the target speaker.
+A 4B-parameter text-to-speech model for **Kabyle** (Taqbaylit, `kab`, Latin script), trained on 384,960 curated speech pairs from Common Voice Kabyle. It synthesises broadcast-quality **24 kHz audio** from Kabyle text. Voice cloning is a feature of that model: a short reference recording, with its transcript kept in the original language, sets the speaker.
 
-Matoub-4B brings zero-shot, reference-conditioned voice cloning to Kabyle, supporting both native and cross-lingual cloning out of the box. A speaker recorded in English, French, Arabic, or any other supported language can speak fluent Taqbaylit with their natural vocal identity and expressive dynamics preserved. Generating speech across an 8-codebook discrete audio representation, the model faithfully captures Kabyle's rich phonology — including spirantised, pharyngealised, emphatic, and geminated consonants.
+The reference can be Kabyle or another language. `generate()` produces one utterance at the trained adapter scale, for every reference language. An 8-codebook discrete audio representation carries Kabyle's phonology, including spirantised, pharyngealised, emphatic, and geminated consonants.
 
 ## Results
 
-Validation was conducted across 16 utterances spanning six speakers. Speaker similarity
-is evaluated using WeSpeaker 256-dimensional speaker embeddings, and transcription fidelity
-is verified using Fadhma-300M ASR.
+Validation was conducted across 16 utterances spanning six speakers. Each utterance was generated once with the packaged sampler. Speaker similarity is the cosine of WavLM embeddings (`microsoft/wavlm-base-plus-sv`), and transcription fidelity is measured with Fadhma-300M.
 
 | metric | value |
 |---|---|
@@ -83,8 +81,10 @@ sf.write("speech.wav", speech.waveform[0].numpy(), speech.sampling_rate, subtype
 - Use clear, continuous speech from one speaker, without background music, overlapping voices or heavy reverberation. No single optimal reference duration has been established for this release.
 - `reference_text`: exact transcript of the words spoken in `reference_audio` in their original language.
 - For an English or French reference, provide the exact English or French transcript; do not translate it into Kabyle.
+- `generate()` writes one utterance. It does not search candidates or download an ASR or speaker verifier.
+- A text that cannot fit in the 8,192-position context with its reference is split, then joined. Leading and trailing silence is removed, and an internal silence longer than 320 ms is shortened to 140 ms.
 - The returned waveform is a CPU float tensor sampled at 24,000 Hz.
-- The generation pipeline can verify candidate outputs for transcript accuracy (Fadhma-300M CER), speaker similarity (WeSpeaker cosine), and audio quality (TorchAudio SQUIM) before returning the final waveform. Longer texts are handled via automatic sentence segmentation. All inference and sampling parameters are configured in `model.config.inference`.
+- Sampling, decoding and the adapter scale live in `model.config.inference`.
 
 ### Generation settings and return value
 
@@ -100,19 +100,15 @@ model.config.inference["sampling"].update(
 )
 ```
 
-These are the packaged sampling defaults. `max_new_positions` limits each
-candidate's generated codec positions; it is not a waveform sample count.
-The return value is `SpeechOutput`:
+These are the packaged sampling defaults. `max_new_positions` limits generated codec positions; it is not a waveform sample count. The return value is `SpeechOutput`:
 
 | Attribute | Value |
 |---|---|
 | `.waveform` | CPU float tensor with shape `[1, N]` |
 | `.sampling_rate` | `24000` |
-| `.report` | Generation audit with segment-level candidate scores, selection and verification results |
+| `.report` | Generation audit: duration, checksum, sampler, and one trace per segment |
 
-The engine evaluates CER, speaker cosine and predicted SQUIM quality when
-selecting candidates. These checks can reject a request; they do not guarantee
-perfect pronunciation or voice identity.
+The audit records the sample that was produced. It does not select among several takes.
 
 ### 4-bit Quantization (NF4)
 
@@ -220,7 +216,7 @@ distinct same-speaker reference recordings sharing no text or audio overlap.
 
 | file | description |
 |---|---|
-| `model.safetensors` | Model weights with merged LoRA adaptation and audio codec |
+| `model.safetensors` | Model weights, the rank-32 LoRA factors at the trained scale, and the audio codec |
 | `config.json` | Model configuration and AutoClass mapping |
 | `tokenizer.json`, `tokenizer_config.json`, `chat_template.jinja` | Text tokenizer and template |
 | `modeling_speech.py` and supporting modules | Transformers model implementation |
@@ -256,6 +252,6 @@ The naming is homage; it implies no affiliation or endorsement.
 
 The model weights are distributed under the **Boson Higgs TTS 3 Research and Non-Commercial License**, inheriting the terms of the base model ([`bosonai/higgs-tts-3-4b`](https://huggingface.co/bosonai/higgs-tts-3-4b)). The weights are strictly for non-commercial research use.
 
-The training data derives from Mozilla Common Voice Kabyle (CC0-1.0, public domain). The supporting evaluation models ([Fadhma-300M](https://huggingface.co/agbalu/Fadhma-300M), [WeSpeaker](https://huggingface.co/Wespeaker/wespeaker-voxceleb-resnet34-LM)) retain their respective licences (Apache-2.0 and CC BY 4.0).
+The training data derives from Mozilla Common Voice Kabyle (CC0-1.0, public domain). Fadhma-300M, used for the transcription measurement, is Apache-2.0. The similarity figure uses WavLM (`microsoft/wavlm-base-plus-sv`).
 
 Part of [AƔBALU](https://huggingface.co/agbalu), a Kabyle and Amazigh corpus and model collection.

config.json

@@ -150,57 +150,20 @@
     "text_vocabulary": 151936
   },
   "inference": {
-    "adapter_multiplier": 1.0,
-    "candidates": 6,
-    "content_tolerance": 0.08,
-    "decoding": {
-      "alignment_strength": 0.0,
-      "plausible_tokens": 25,
-      "recover_loops": false
-    },
-    "fallback_candidates": 2,
-    "max_cer": 0.2,
-    "max_duration_ratio": 3.0,
-    "max_segment_characters": 160,
-    "min_generation_s": 10.0,
-    "min_predicted_mos": 3.5,
-    "min_voice_cosine": 0.21693290024995804,
-    "quality_tolerance": 0.25,
+    "version": 1,
     "sampling": {
-      "max_new_positions": 1500,
-      "seed": 20261102,
       "temperature": 0.8,
+      "top_p": 0.8,
       "top_k": 30,
-      "top_p": 0.8
+      "max_new_positions": 1500,
+      "seed": 20261102
     },
-    "strategies": [
-      {
-        "adapter_multiplier": 1.0,
-        "decoding": {
-          "alignment_strength": 0.0,
-          "plausible_tokens": 25,
-          "recover_loops": false
-        }
-      },
-      {
-        "adapter_multiplier": 0.65,
-        "decoding": {
-          "alignment_strength": 0.0,
-          "plausible_tokens": 25,
-          "recover_loops": false
-        }
-      },
-      {
-        "adapter_multiplier": 1.0,
-        "decoding": {
-          "alignment_strength": 1.0,
-          "plausible_tokens": 25,
-          "recover_loops": false
-        }
-      }
-    ],
-    "timeout_s": 840.0,
-    "version": 1
+    "decoding": {
+      "alignment_strength": 0,
+      "plausible_tokens": 25,
+      "recover_loops": true
+    },
+    "adapter_multiplier": 1
   },
   "model_type": "agbalu_speech",
   "sampling_rate": 24000,

export.stats.json

@@ -1 +1 @@
-{"artifact_integrity_verified": true, "config_hash": "47c6bd4e2bf8239229bd637d96bd3a2037a2555da82dbdde53b5a629707966c8", "dirty": true, "dropped_native_keys": ["tied.embedding.modality_embeddings.0.model.semantic_model.masked_spec_embed", "tied.head.modality_heads.0.weight", "tied.head.text_head.weight"], "exported_tensor_count": 1430, "files": {"LICENSE": "0382189330b87c38517530e4e5bf0c9dfeb6c7bfbe62812577ddcb73e09a60c5", "NOTICE": "b2640a3741dc4035d9eb9e0c26696142a10f8caf208d0d8d6e2600947d6fc8d7", "README.md": "47c6bd4e2bf8239229bd637d96bd3a2037a2555da82dbdde53b5a629707966c8", "STAMP.json": "0d9ae3d170c158bacb7f5c9b407d1633460cf858105b297c9a2180fb01ca68ed", "adaptation.py": "3dceb0d9450775e21f0375781b102324d22c924e0a05e6599f87bb3b631da51a", "artifacts.py": "f7a68f94e56ee3e9394bc385215cb71d7fde9f5b5c14f40cfd3189006cf8479e", "audio.py": "1ca1c4984a6d43ae9137d15b7a3a1d9f300a868aaa8fa3b9369e30ab95edffeb", "backbone.py": "e31eff44ba894c4bfd332e35040b8f84be043a8dc136c090a423ccc664276b3f", "chat_template.jinja": "44d5f08f3f72b837eaad09f13a54c1f9f4eb58d75240334548b7fd52a5437fa5", "codec.py": "b65875c630d6b6e135510bbe1f761ad93d6c2e697c857ee30ef1845c73f1f894", "config.json": "b24120cd7d375136da3cab68478649d1b74c6ee900aa2513a49be4e1ff96eb39", "configuration.py": "1c54db62d2a97c0da43c9fbcfeb0698b9550325006304ff701e8b1a26cf1e857", "dataset.py": "afcd7b2f19ef7b479e4661ec0efd56138220b466605478e93d014e60f07db6c2", "evaluation.py": "364a7049804998d4857618f1a9061493f8b644f59e79be1466244b4f0fd6b74f", "inference.py": "db80183c086f071e290ef460c957a7e2546d9ba9fe6ae95b239562cc2ffef962", "layout.py": "34b4069f74cee213209101cc0cda3fc0fc2aa2e64db722321aba7e6c883298fb", "model.safetensors": "37c391ff7178ae6331ccbe1ab18bd9cd1f1fbdb8934a3d0021ffcc586f8ca4dd", "modeling_speech.py": "70a37da485d02dc2c1b4670f9bf9e8bf159531146aa35bb6d3fb90b88c1126b0", "objective.py": "5c72520a55bc0a698decf8f316a2172668a5f505eb720957ce4789679f2729c9", "pairs.py": "bb2dfe95b555bff7cf2ccadd3d62f524927dc4e9c658507175f595a2e4218216", "partition.py": "df3fd82e96330ee139c663bf88c383b0a2e7b714cd54ff95048b1cc898cfe619", "progress.py": "9c766bb4e107c63232f3a5abfd2debabe7c8bf6dabd806e00bbe6a62eb68934e", "provenance.py": "278abb15bd21575f409b7d55dcd1a0dc12526f81a9b90e6cc6de96db7543c236", "requirements.txt": "e56142d5c4b77b45b41e16c7d1edc6046491ed5d384e82537bc0a5ba3ac6c819", "synthesis.py": "76a377e8a193e218584206fc3fbfc6a11b2e7d0113fa9687bb51420cef4e53ac", "tokenizer.json": "eb883de2de5adc5113f1f02b54830a0ea7cd6ef191cde65c41aceb3737d4d1c1", "tokenizer_config.json": "b4d632e1239569fb1829bf0bfa3c674fa54f22c42e9cb2669d77c438d4b4e02c", "verification.py": "3df87f44f13411e2f9ce1cb3ce3c6c6490ed6c31eb6a6e956d823c84e1c2f7a2", "waveforms.py": "248c58c7818c8d258ac40fd0c0e98bc8fa607603f0c62e5da5fb413177ce7460"}, "git_sha": "4c0e119b42518dafee8be80d10d8dfdb13090295", "kind": "bf16", "source_weights_sha256": "37c391ff7178ae6331ccbe1ab18bd9cd1f1fbdb8934a3d0021ffcc586f8ca4dd", "version": 1, "version_tag": null, "weights_sha256": "37c391ff7178ae6331ccbe1ab18bd9cd1f1fbdb8934a3d0021ffcc586f8ca4dd"}
+{"artifact_integrity_verified": true, "card_sha256": "1ab9d6699d43d0b3e8a239e2f099d8ddb73780e237f54ad5a24842dfed5387de", "config_hash": "1ab9d6699d43d0b3e8a239e2f099d8ddb73780e237f54ad5a24842dfed5387de", "dirty": true, "dropped_native_keys": ["tied.embedding.modality_embeddings.0.model.semantic_model.masked_spec_embed", "tied.head.modality_heads.0.weight", "tied.head.text_head.weight"], "exported_tensor_count": 1430, "files": {"LICENSE": "0382189330b87c38517530e4e5bf0c9dfeb6c7bfbe62812577ddcb73e09a60c5", "NOTICE": "b2640a3741dc4035d9eb9e0c26696142a10f8caf208d0d8d6e2600947d6fc8d7", "README.md": "1ab9d6699d43d0b3e8a239e2f099d8ddb73780e237f54ad5a24842dfed5387de", "STAMP.json": "0d9ae3d170c158bacb7f5c9b407d1633460cf858105b297c9a2180fb01ca68ed", "adaptation.py": "3dceb0d9450775e21f0375781b102324d22c924e0a05e6599f87bb3b631da51a", "artifacts.py": "f7a68f94e56ee3e9394bc385215cb71d7fde9f5b5c14f40cfd3189006cf8479e", "audio.py": "1ca1c4984a6d43ae9137d15b7a3a1d9f300a868aaa8fa3b9369e30ab95edffeb", "backbone.py": "e31eff44ba894c4bfd332e35040b8f84be043a8dc136c090a423ccc664276b3f", "chat_template.jinja": "44d5f08f3f72b837eaad09f13a54c1f9f4eb58d75240334548b7fd52a5437fa5", "codec.py": "b65875c630d6b6e135510bbe1f761ad93d6c2e697c857ee30ef1845c73f1f894", "config.json": "7bee9b7ce2e05766f82fc75c470c6f53af717696b0c30b8851a341eb21a7c651", "configuration.py": "1c54db62d2a97c0da43c9fbcfeb0698b9550325006304ff701e8b1a26cf1e857", "dataset.py": "afcd7b2f19ef7b479e4661ec0efd56138220b466605478e93d014e60f07db6c2", "evaluation.py": "364a7049804998d4857618f1a9061493f8b644f59e79be1466244b4f0fd6b74f", "inference.py": "db80183c086f071e290ef460c957a7e2546d9ba9fe6ae95b239562cc2ffef962", "layout.py": "34b4069f74cee213209101cc0cda3fc0fc2aa2e64db722321aba7e6c883298fb", "model.safetensors": "37c391ff7178ae6331ccbe1ab18bd9cd1f1fbdb8934a3d0021ffcc586f8ca4dd", "modeling_speech.py": "f0d7b63f3b8145ffc0fd3b5c6aa150ce4583618b9c172ab7ad54240b7465ac1d", "objective.py": "5c72520a55bc0a698decf8f316a2172668a5f505eb720957ce4789679f2729c9", "pairs.py": "bb2dfe95b555bff7cf2ccadd3d62f524927dc4e9c658507175f595a2e4218216", "partition.py": "df3fd82e96330ee139c663bf88c383b0a2e7b714cd54ff95048b1cc898cfe619", "progress.py": "9c766bb4e107c63232f3a5abfd2debabe7c8bf6dabd806e00bbe6a62eb68934e", "provenance.py": "278abb15bd21575f409b7d55dcd1a0dc12526f81a9b90e6cc6de96db7543c236", "requirements.txt": "e56142d5c4b77b45b41e16c7d1edc6046491ed5d384e82537bc0a5ba3ac6c819", "synthesis.py": "7d3f3404e1bc151fc7a48cdee3761b2e9f918c09f439a02cfa8237b13acab21c", "tokenizer.json": "eb883de2de5adc5113f1f02b54830a0ea7cd6ef191cde65c41aceb3737d4d1c1", "tokenizer_config.json": "b4d632e1239569fb1829bf0bfa3c674fa54f22c42e9cb2669d77c438d4b4e02c", "verification.py": "3df87f44f13411e2f9ce1cb3ce3c6c6490ed6c31eb6a6e956d823c84e1c2f7a2", "waveforms.py": "248c58c7818c8d258ac40fd0c0e98bc8fa607603f0c62e5da5fb413177ce7460"}, "git_sha": "dd4ca358066559534565438f073227cbc275f57d", "inference_config_sha256": "d60a8f5d6bbdb05963a551dd7cebaa7c3935f5c3cb3c4e186706428fc0ffbf01", "kind": "bf16", "source_weights_sha256": "37c391ff7178ae6331ccbe1ab18bd9cd1f1fbdb8934a3d0021ffcc586f8ca4dd", "version": 1, "version_tag": null, "weights_sha256": "37c391ff7178ae6331ccbe1ab18bd9cd1f1fbdb8934a3d0021ffcc586f8ca4dd"}

modeling_speech.py

@@ -13,8 +13,7 @@ from .adaptation import inject_adapter
 from .backbone import Generator
 from .codec import Codec
 from .configuration import Geometry
-from .synthesis import InferenceSettings, SpeechRequest, SpeechSynthesis, read_waveform
-from .verification import SpeechVerifier
+from .synthesis import InferenceSettings, SpeechRequest, read_waveform, render_speech
 
 def compute_weight_identity(checkpoint: str, quantization: object, has_adapter: bool) -> str:
     payload = {'checkpoint': checkpoint, 'quantization': quantization, 'has_adapter': has_adapter}
@@ -53,8 +52,6 @@ class SpeechModel(PreTrainedModel):
         if config.has_adapter:
             inject_adapter(self.generator)
         self.audio_tokenizer = HiggsAudioV2TokenizerModel(HiggsAudioV2TokenizerConfig(**config.audio_configuration))
-        self._verifier: SpeechVerifier | None = None
-        self._verifier_device: torch.device | None = None
         self.post_init()
 
     def save_pretrained(self, save_directory: str | Path, **kwargs: object) -> None:
@@ -75,15 +72,11 @@ class SpeechModel(PreTrainedModel):
             raise FileNotFoundError(message)
         settings = InferenceSettings.model_validate(self.config.inference)
         device = self.generator.audio_embedding.weight.device
-        if self._verifier is None or self._verifier_device != device:
-            self._verifier = SpeechVerifier(device)
-            self._verifier_device = device
         commit: object = getattr(self.config, '_commit_hash', None)
         tokenizer = AutoTokenizer.from_pretrained(self.config.name_or_path, revision=commit if isinstance(commit, str) else 'main', trust_remote_code=True)
-        engine = SpeechSynthesis(self.generator, Codec(self.audio_tokenizer, device), tokenizer, self._verifier, provenance_stamp=self.config.source_stamp)
         with tempfile.TemporaryDirectory(prefix='speech-') as temporary:
             destination = Path(output_path) if output_path is not None else Path(temporary) / 'speech.wav'
-            report = engine.synthesize(request, settings, destination)
+            report = render_speech(self.generator, Codec(self.audio_tokenizer, device), tokenizer, request, settings, destination, provenance_stamp=self.config.source_stamp)
             waveform = torch.from_numpy(read_waveform(destination)).unsqueeze(0)
         return SpeechOutput(waveform=waveform, sampling_rate=24000, report=report)
 SpeechConfig.register_for_auto_class()

synthesis.py

@@ -1,8 +1,7 @@
-"""Produce verified reference-conditioned speech with resumable candidate selection."""
+"""Produce one reference-conditioned utterance for any reference language."""
 from __future__ import annotations
 import hashlib
 import json
-import logging
 import math
 import re
 import time
@@ -12,6 +11,7 @@ from typing import Protocol
 import numpy as np
 import soundfile as sf
 from pydantic import Field, model_validator
+from torch import Tensor
 from .adaptation import scaled_adapter
 from .artifacts import atomic_binary, digest_file, provenance, run_lock, write_json
 from .backbone import Generator
@@ -20,7 +20,7 @@ from .configuration import Specification
 from .dataset import TextTokenizer
 from .inference import MAX_CONTEXT_POSITIONS, Decoding, GenerationError, Sampling, generate_codes
 from .layout import SPECIALS, SequenceLayout, prompt_layout
-from .verification import INSTRUMENTS, Quality, spoken_text
+from .verification import Quality, spoken_text
 from .waveforms import Waveform, measure_signal, resample_waveform
 DEFAULT_INFERENCE = Path('resources/codec_tts/inference.json')
 STEREO_AXES = 2
@@ -147,6 +147,157 @@ def save_waveform(path: Path, waveform: Waveform) -> None:
     with atomic_binary(path) as stream:
         sf.write(stream, waveform, 24000, format='WAV', subtype='FLOAT')
 
+def trim_edges(audio: Waveform) -> Waveform:
+    """Drop only the silence before the first sound and after the last."""
+    rate = 24000
+    frame = int(0.02 * rate)
+    hop = frame // 2
+    if audio.size <= frame:
+        return audio
+    count = 1 + (audio.size - frame) // hop
+    rms = np.empty(count, dtype=np.float32)
+    for index, start in enumerate(range(0, audio.size - frame + 1, hop)):
+        chunk = audio[start:start + frame]
+        rms[index] = float(np.sqrt(np.mean(np.square(chunk))))
+    threshold = max(0.005, float(np.percentile(rms, 90)) * 0.08)
+    active = np.flatnonzero(rms > threshold)
+    if active.size == 0:
+        return audio
+    margin = int(0.04 * rate)
+    first = max(0, int(active[0] * hop) - margin)
+    last = min(int(audio.size), int((active[-1] + 1) * hop + frame) + margin)
+    if last - first < frame:
+        return audio
+    return np.asarray(audio[first:last], dtype=np.float32)
+
+def close_gaps(audio: Waveform) -> Waveform:
+    """Shorten an internal silence longer than 320 ms to 140 ms."""
+    rate = 24000
+    frame = int(0.02 * rate)
+    hop = frame // 2
+    if audio.size <= frame:
+        return audio
+    count = 1 + (audio.size - frame) // hop
+    rms = np.empty(count, dtype=np.float32)
+    for index, start in enumerate(range(0, audio.size - frame + 1, hop)):
+        chunk = audio[start:start + frame]
+        rms[index] = float(np.sqrt(np.mean(np.square(chunk))))
+    threshold = max(0.005, float(np.percentile(rms, 90)) * 0.08)
+    silent = rms <= threshold
+    keep = int(0.14 * rate)
+    minimum = int(0.32 * rate)
+    spans: list[tuple[int, int]] = []
+    index = 0
+    while index < silent.size:
+        if not bool(silent[index]):
+            index += 1
+            continue
+        start_index = index
+        while index < silent.size and bool(silent[index]):
+            index += 1
+        start = int(start_index * hop)
+        end = min(int(audio.size), int((index - 1) * hop) + frame)
+        if start > hop and end < audio.size - hop and (end - start >= minimum):
+            spans.append((start, end))
+    if not spans:
+        return np.asarray(audio, dtype=np.float32)
+    pieces: list[Waveform] = []
+    cursor = 0
+    for start, end in spans:
+        pieces.append(np.asarray(audio[cursor:start], dtype=np.float32))
+        pieces.append(np.asarray(audio[start:start + keep], dtype=np.float32))
+        cursor = end
+    pieces.append(np.asarray(audio[cursor:], dtype=np.float32))
+    return join_segments(pieces)
+
+def join_segments(waves: Sequence[Waveform]) -> Waveform:
+    if not waves:
+        message = 'speech assembly received no audio'
+        raise ValueError(message)
+    fade = int(0.01 * 24000)
+    joined = np.asarray(waves[0], dtype=np.float32)
+    for nxt in waves[1:]:
+        following = np.asarray(nxt, dtype=np.float32)
+        width = min(fade, joined.size // 2, following.size // 2)
+        if width < 2:
+            joined = np.concatenate((joined, following))
+            continue
+        ramp = np.linspace(0.0, 1.0, width, dtype=np.float32)
+        mixed = joined[-width:] * (1.0 - ramp) + following[:width] * ramp
+        joined = np.concatenate((joined[:-width], mixed, following[width:]))
+    return np.asarray(joined, dtype=np.float32)
+
+def prompt_fits(tokenizer: TextTokenizer, specials: Mapping[str, int], text: str, reference_codes: Tensor, reference_ids: Sequence[int], max_new_positions: int) -> bool:
+    prompt = prompt_layout(specials, tokenizer.encode(text, add_special_tokens=False), reference_codes, reference_ids)
+    remaining = MAX_CONTEXT_POSITIONS - prompt.positions
+    return remaining >= 8 and min(max_new_positions, remaining) >= 8
+
+def partition_text(tokenizer: TextTokenizer, specials: Mapping[str, int], text: str, reference_codes: Tensor, reference_ids: Sequence[int], max_new_positions: int) -> tuple[str, ...]:
+    if prompt_fits(tokenizer, specials, text, reference_codes, reference_ids, max_new_positions):
+        return (text,)
+    parts = split_text(text, max(32, len(text) // 2))
+    if len(parts) == 1:
+        message = 'speech text does not fit the context and has no split point'
+        raise ValueError(message)
+    return tuple((piece for part in parts for piece in partition_text(tokenizer, specials, part, reference_codes, reference_ids, max_new_positions)))
+
+def speech_identity(request: SpeechRequest, settings: InferenceSettings, reference_sha256: str) -> str:
+    payload = {'request': request.model_dump(mode='json'), 'sampling': settings.sampling.model_dump(), 'decoding': settings.decoding.model_dump(), 'adapter_multiplier': settings.adapter_multiplier, 'reference_sha256': reference_sha256}
+    return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()
+
+def render_speech(model: Generator, codec: Codec, tokenizer: TextTokenizer, request: SpeechRequest, settings: InferenceSettings, output: Path, provenance_stamp: Mapping[str, object] | None=None) -> dict[str, object]:
+    """Sample one utterance. The reference language does not change the decode."""
+    started = time.monotonic()
+    spoken_text(request.reference_text)
+    specials = tokenizer.get_added_vocab()
+    for tag in re.findall('<\\|[^<>]*\\|>', request.text):
+        if tag not in specials or re.fullmatch('<\\|(?:emotion|style|prosody|sfx):[a-z_]+\\|>', tag) is None:
+            message = f'unsupported delivery tag {tag!r}'
+            raise ValueError(message)
+    reference_sha = digest_file(request.reference)
+    identity = speech_identity(request, settings, reference_sha)
+    audit = output.with_suffix('.stats.json')
+    with run_lock(output.parent):
+        if audit.is_file():
+            previous = json.loads(audit.read_bytes())
+            if previous.get('identity') == identity and previous.get('complete') is True:
+                if not output.is_file() or digest_file(output) != previous.get('output_sha256'):
+                    message = f'checksum mismatch at {output}'
+                    raise ValueError(message)
+                return dict(previous)
+            if previous.get('identity') not in (None, identity):
+                message = f'different speech request already occupies {output}'
+                raise FileExistsError(message)
+        reference = read_waveform(request.reference)
+        if measure_signal(reference, 24000).rms_dbfs is None:
+            message = f'reference audio is silent: {request.reference}'
+            raise ValueError(message)
+        reference_codes = codec.encode(reference)
+        reference_ids = tokenizer.encode(request.reference_text, add_special_tokens=False)
+        parts = partition_text(tokenizer, specials, request.text, reference_codes, reference_ids, settings.sampling.max_new_positions)
+        prefix = re.match('(?:\\s*<\\|(?:emotion|style|prosody):(?!pause\\|>|long_pause\\|>)[^<>]+\\|>)*', request.text)
+        delivery = prefix.group() if prefix else ''
+        decoding = settings.decoding.model_copy(update={'alignment_strength': 0, 'recover_loops': True})
+        waves: list[Waveform] = []
+        segments: list[dict[str, object]] = []
+        for number, text in enumerate(parts):
+            conditioning = (delivery if number else '') + text
+            prompt = prompt_layout(specials, tokenizer.encode(conditioning, add_special_tokens=False), reference_codes, reference_ids)
+            remaining = MAX_CONTEXT_POSITIONS - prompt.positions
+            positions = min(settings.sampling.max_new_positions, remaining)
+            sampling = settings.sampling.model_copy(update={'max_new_positions': positions, 'seed': settings.sampling.seed + number})
+            with scaled_adapter(model, settings.adapter_multiplier):
+                codes, trace = generate_codes(model, prompt, sampling, decoding, None)
+            waves.append(np.asarray(codec.decode(codes).numpy(), dtype=np.float32))
+            segments.append({'text': text, 'seed': sampling.seed, **trace})
+        joined = close_gaps(trim_edges(join_segments(waves)))
+        peak = measure_signal(joined, 24000).peak
+        gain = min(1.0, 0.99 / peak) if peak else 1.0
+        save_waveform(output, np.asarray(joined * gain, dtype=np.float32))
+        report: dict[str, object] = {**({**provenance_stamp, 'config_hash': identity} if provenance_stamp is not None else provenance(identity)), 'identity': identity, 'complete': True, 'segments': segments, 'samples': joined.size, 'sample_rate_hz': 24000, 'duration_s': joined.size / 24000, 'peak_gain': gain, 'output': str(output), 'output_sha256': digest_file(output), 'elapsed_s': time.monotonic() - started, 'adapter_multiplier': settings.adapter_multiplier, 'sampling': settings.sampling.model_dump(), 'decoding': decoding.model_dump()}
+        write_json(audit, report)
+    return report
+
 def contrast_layout(prompt: SequenceLayout, specials: Mapping[str, int]) -> SequenceLayout:
     keep = prompt.audio_mask.clone()
     for token in SPECIALS:
@@ -206,90 +357,4 @@ class SpeechSynthesis:
         return (value, False)
 
     def synthesize(self, request: SpeechRequest, settings: InferenceSettings, output: Path) -> dict[str, object]:
-        started = time.monotonic()
-        spoken_text(request.reference_text)
-        specials = self.tokenizer.get_added_vocab()
-        for tag in re.findall('<\\|[^<>]*\\|>', request.text):
-            if tag not in specials or re.fullmatch('<\\|(?:emotion|style|prosody|sfx):[a-z_]+\\|>', tag) is None:
-                message = f'unsupported delivery tag {tag!r}'
-                raise ValueError(message)
-        parts = split_text(request.text, settings.max_segment_characters)
-        source = {name: digest_file(Path(__file__).with_name(name)) for name in ('synthesis.py', 'inference.py', 'adaptation.py', 'verification.py', 'layout.py')}
-        identity_data = {'request': request.model_dump(mode='json'), 'settings': settings.model_dump(), 'reference_sha256': digest_file(request.reference), 'source': source}
-        identity = hashlib.sha256(json.dumps(identity_data, sort_keys=True).encode()).hexdigest()
-        root, audit = (output.with_suffix('.candidates'), output.with_suffix('.stats.json'))
-        with run_lock(root):
-            marker = root / 'request.json'
-            if marker.exists() and json.loads(marker.read_bytes()).get('sha256') != identity:
-                message = f'different speech request already occupies {root}'
-                raise FileExistsError(message)
-            if not marker.exists() and (output.exists() or audit.exists()):
-                message = f'refusing to replace existing speech output {output}'
-                raise FileExistsError(message)
-            write_json(marker, {'sha256': identity})
-            reference = read_waveform(request.reference)
-            if measure_signal(reference, 24000).rms_dbfs is None:
-                message = f'reference audio is silent: {request.reference}'
-                raise ValueError(message)
-            ref_codes = self.codec.encode(reference)
-            ref_ids = self.tokenizer.encode(request.reference_text, add_special_tokens=False)
-            report: dict[str, object] = {**({**self.provenance_stamp, 'config_hash': identity} if self.provenance_stamp is not None else provenance(identity)), **identity_data, 'complete': False, 'attempts_this_run': 0, 'cached_attempts_this_run': 0, 'segments': [], 'instruments': INSTRUMENTS, 'output': str(output), 'audit': str(audit)}
-            segment_reports: list[dict[str, object]] = []
-            report['segments'] = segment_reports
-            write_json(audit, report)
-            waves: list[Waveform] = []
-            generated, cached, offset = (0, 0, 0)
-            prefix = re.match('(?:\\s*<\\|(?:emotion|style|prosody):(?!pause\\|>|long_pause\\|>)[^<>]+\\|>)*', request.text)
-            delivery = prefix.group() if prefix else ''
-            for number, text in enumerate(parts):
-                conditioning = (delivery if number else '') + text
-                prompt = prompt_layout(specials, self.tokenizer.encode(conditioning, add_special_tokens=False), ref_codes, ref_ids)
-                budget = MAX_CONTEXT_POSITIONS - prompt.positions
-                if settings.sampling.max_new_positions > budget:
-                    message = f'reference/text exceeds context budget at character={offset}'
-                    message += f': remaining={budget}'
-                    raise ValueError(message)
-                values: list[Candidate] = []
-                paths: list[Path] = []
-                segment: dict[str, object] = {'text': text, 'char_start': offset, 'char_end': offset + len(text), 'candidates': [], 'selected': None}
-                segment_reports.append(segment)
-                for index in range(settings.candidates + settings.fallback_candidates):
-                    if index >= settings.candidates and choose_candidate(values, settings) is not None:
-                        break
-                    active = candidate_settings(settings, text, reference.size / 24000, len(spoken_text(request.reference_text)), index)
-                    initial = values[:len(settings.strategies)]
-                    if settings.strategies and len(initial) == len(settings.strategies) and all((value.trace.get('terminated') is False for value in initial)):
-                        active = active.model_copy(update={'decoding': Decoding(recover_loops=True)})
-                    seed_index = index // max(1, len(settings.strategies))
-                    seed = settings.sampling.seed + number * (settings.candidates + settings.fallback_candidates) + seed_index
-                    path = root / f'segment-{number:04d}-candidate-{index:02d}.wav'
-                    report.update(active_candidate=str(path), attempts_this_run=generated, cached_attempts_this_run=cached)
-                    write_json(audit, report)
-                    value, reused = self.candidate(text, prompt, reference, active, seed, path, identity, started + settings.timeout_s)
-                    cached += int(reused)
-                    generated += int(not reused)
-                    logging.getLogger(__name__).info(json.dumps({'event': 'speech_candidate', 'segment': number, 'candidate': index, 'cached': reused, 'adapter_multiplier': active.adapter_multiplier, 'alignment_strength': active.decoding.alignment_strength, 'recover_loops': active.decoding.recover_loops, 'quality': value.quality.model_dump() if value.quality else None, 'error': value.error, 'elapsed_s': time.monotonic() - started}))
-                    values.append(value)
-                    paths.append(path)
-                    segment['candidates'] = [{**item.model_dump(mode='json'), 'rejected': rejection_reasons(item.quality, settings) if item.quality else ()} for item in values]
-                    report.update(attempts_this_run=generated, cached_attempts_this_run=cached)
-                    write_json(audit, report)
-                chosen = choose_candidate(values, settings)
-                segment['selected'] = chosen
-                write_json(audit, report)
-                if chosen is None:
-                    message = f'no candidate passed content, voice and quality limits at segment={number}'
-                    message += f'; see {audit}'
-                    raise RuntimeError(message)
-                waves.append(read_waveform(paths[chosen]))
-                offset += len(text)
-            joined = np.concatenate(waves).astype(np.float32)
-            if offset != len(request.text) or joined.size != sum((wave.size for wave in waves)):
-                message = 'speech text/sample conservation failed during assembly'
-                raise AssertionError(message)
-            peak = measure_signal(joined, 24000).peak
-            gain = min(1.0, 0.99 / peak) if peak else 1.0
-            save_waveform(output, np.asarray(joined * gain, dtype=np.float32))
-            report.update(complete=True, active_candidate=None, samples=joined.size, sample_rate_hz=24000, duration_s=joined.size / 24000, peak_gain=gain, output_sha256=digest_file(output), elapsed_s=time.monotonic() - started, naturalness='predicted quality only; no human rating')
-            write_json(audit, report)
-        return report
+        return render_speech(self.model, self.codec, self.tokenizer, request, settings, output, provenance_stamp=self.provenance_stamp)