@qvac/tts-ggml 0.9.2 → 0.10.0

package/examples/supertonic-sentence-stream-tts.js

@@ -9,10 +9,10 @@
  * dispatches each `runJob` call to whichever engine the model was
  * constructed with.
  *
- * Sub-sentence native streaming (`streamChunkTokens`) is Chatterbox-
- * only at the C++ engine level; the constructor rejects those knobs
- * for Supertonic with a clear error.  Use this sentence-level path
- * for low-latency Supertonic streaming.
+ * Supertonic can also stream inside a sentence: `streamChunkTokens`
+ * makes the engine split the text into ~N-text-token chunks and emit
+ * each as it is synthesized.  This sentence-level path is the one that
+ * also works with the LavaSR enhancer / denoiser.
  *
  * Usage:
  *   bare examples/supertonic-sentence-stream-tts.js [voice]

package/index.d.ts

@@ -1,12 +1,15 @@
 import { type QvacResponse } from "@qvac/infer-base";
 import * as errorModule from "./lib/error";
 import { resolveBackendsDir as resolveBackendsDirImpl } from "./lib/backends";
+import { assessFit as assessFitImpl, type Audio8FitRequest, type MossFitRequest, type ChatterboxFitRequest, type CosyvoiceFitRequest, type ParlerFitRequest, type SupertonicFitRequest, type TtsFitEngine, type TtsFitRequest, type TtsFitResult, type TtsFitStatus } from "./lib/fit";
 import { type SentenceDelimiterPreset } from "./lib/textStreamAccumulator";
 declare const ENGINE_CHATTERBOX = "chatterbox";
 declare const ENGINE_SUPERTONIC = "supertonic";
 declare const ENGINE_COSYVOICE3 = "cosyvoice3";
 declare const ENGINE_PARLER = "parler";
 declare const ENGINE_AUDIO8 = "audio8";
+declare const ENGINE_MOSS = "moss";
+declare const ENGINE_POCKET = "pocket";
 declare const COSYVOICE_DIALECTS: {
     readonly cantonese: "广东话";
     readonly northeastern: "东北话";
@@ -54,7 +57,7 @@ declare const EMOTIONS: readonly ["command", "anger", "narration", "conversation
 declare const PACES: readonly ["slow", "moderate", "fast"];
 type Emotion = (typeof EMOTIONS)[number];
 type Pace = (typeof PACES)[number];
-type EngineType = typeof ENGINE_CHATTERBOX | typeof ENGINE_SUPERTONIC | typeof ENGINE_COSYVOICE3 | typeof ENGINE_PARLER | typeof ENGINE_AUDIO8;
+type EngineType = typeof ENGINE_CHATTERBOX | typeof ENGINE_SUPERTONIC | typeof ENGINE_COSYVOICE3 | typeof ENGINE_PARLER | typeof ENGINE_AUDIO8 | typeof ENGINE_MOSS | typeof ENGINE_POCKET;
 /**
  * Model file paths for the GGML TTS backend. Engine is auto-detected
  * from these fields (Chatterbox vs Supertonic) unless overridden via
@@ -62,6 +65,10 @@ type EngineType = typeof ENGINE_CHATTERBOX | typeof ENGINE_SUPERTONIC | typeof E
  * through to the native layer as-is.
  */
 interface TTSGgmlFiles {
+    pocketFlowModel?: string;
+    pocketMimiModel?: string;
+    pocketFrontend?: string;
+    pocketVoice?: string;
     /**
      * Bundle root. For Chatterbox, expected to contain
      * `chatterbox-t3-turbo.gguf` + `chatterbox-s3gen.gguf` (turbo) or
@@ -97,6 +104,22 @@ interface TTSGgmlFiles {
      */
     audio8CodecEncoder?: string;
     audio8CodecEncoderPath?: string;
+    /**
+     * MOSS Delay backbone GGUF path: MOSS-TTS (`moss-tts-delay-*.gguf`) or the
+     * MOSS-TTSD dialogue checkpoint (`moss-ttsd-*.gguf`). Overrides `modelDir`.
+     */
+    mossBackbone?: string;
+    mossBackbonePath?: string;
+    /** MOSS codec synthesis half (codes to 24 kHz wav). Overrides `modelDir`. */
+    mossCodecDecoder?: string;
+    mossCodecDecoderPath?: string;
+    /**
+     * MOSS codec analysis half (wav to codes). Only needed to clone a voice
+     * from `referenceAudio` or for `dialogueReferences`; a text-only deployment
+     * can leave it out.
+     */
+    mossCodecEncoder?: string;
+    mossCodecEncoderPath?: string;
     /**
      * CosyVoice3 model directory holding the sub-model GGUFs
      * (`cosyvoice3-{llm,flow,hift}-*.gguf`) plus `voice.gguf`, `vocab.json` and
@@ -122,6 +145,18 @@ interface TTSGgmlFiles {
     cosyvoiceS3tokModelPath?: string;
     cosyvoiceCampplusModel?: string;
     cosyvoiceCampplusModelPath?: string;
+    /**
+     * CosyVoice3 Qwen2 BPE text frontend (`vocab.json` + `merges.txt`) and the
+     * baked default-voice GGUF (`voice.gguf`). Each is resolved under the model
+     * dir when unset; `cosyvoiceVoiceModel` is how a different baked voice is
+     * selected without a separate model directory.
+     */
+    cosyvoiceVocab?: string;
+    cosyvoiceVocabPath?: string;
+    cosyvoiceMerges?: string;
+    cosyvoiceMergesPath?: string;
+    cosyvoiceVoiceModel?: string;
+    cosyvoiceVoiceModelPath?: string;
     /**
      * LavaSR enhancer GGUF: single-file Vocos bandwidth extension produced by
      * tts-cpp/scripts/convert-lavasr-enhancer-to-gguf.py. When supplied, output
@@ -182,6 +217,8 @@ interface TTSGgmlRuntimeConfig {
      * CosyVoice3 native chunk streaming emits at 24 kHz: a different rate is
      * only accepted there when the LavaSR enhancer is active, because the
      * enhancer's overlap-reprocess window resamples without chunk seams.
+     *
+     * MOSS emits its native 24 kHz only and rejects any other rate.
      */
     outputSampleRate?: number;
     backendsDir?: string;
@@ -266,13 +303,27 @@ interface Audio8VoiceFields {
      * re-bakes the same recording (it is forwarded to the new addon instance)
      * but cannot switch to a different one, so changing voices means a new
      * instance. Audio8: the recording to clone, with `referenceText`
-     * alongside it.
+     * alongside it. MOSS: the recording to clone, sampled at 24 kHz and
+     * fixed at construction; needs `files.mossCodecEncoder`.
      */
     referenceAudio?: string;
     /** Audio8: what `referenceAudio` says. Required when cloning. */
     referenceText?: string;
 }
+/**
+ * CosyVoice3 per-call instruction. Same values as the constructor's
+ * `instruct`; a per-call conditioning control replaces the configured one for
+ * that synthesis, and one control takes effect per synthesis.
+ */
+interface CosyvoiceJobFields {
+    instruct?: string | CosyvoiceInstruct;
+}
 interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields {
+    /** Pocket: generation/context controls; native sampling uses a portable RNG. */
+    maxTokens?: number;
+    noiseClamp?: number;
+    eosThreshold?: number;
+    framesAfterEos?: number;
     files?: TTSGgmlFiles;
     config?: TTSGgmlRuntimeConfig;
     logger?: object;
@@ -281,22 +332,28 @@ interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTS
     engine?: EngineType;
     /** Chatterbox: directory of baked voice-conditioning tensors. */
     voiceDir?: string;
-    /** RNG seed for Chatterbox CFM/SineGen or Supertonic latent generation. */
+    /**
+     * RNG seed for Chatterbox CFM/SineGen, Supertonic latent generation, or
+     * Pocket's portable sampling RNG. Pocket accepts integers from 0 to
+     * 4294967295 (inclusive).
+     */
     seed?: number;
     /**
      * Move N layers to the GPU backend. Chatterbox: pass 99 to move everything.
      * Supertonic: pass 99 to offload on GPU-capable hosts, including Android.
      * Audio8: pass 99 to use Vulkan on Linux and Windows.
+     * MOSS: any non-zero value selects the GPU backend.
      * CosyVoice3: pass 99 to offload on Metal (macOS / iOS), Vulkan (desktop
      * Linux / Windows), or OpenCL/Adreno (Android); other hosts fall back to
      * CPU by policy.
      */
     nGpuLayers?: number;
     /**
-     * Chatterbox-only cap on the T3 context length (prompt + generated speech
+     * Chatterbox: cap on the T3 context length (prompt + generated speech
      * tokens, 25 tokens ~= 1 second of audio). The KV cache is allocated up
      * front at this length, so the cap directly bounds memory. Pass 0 to use
      * the GGUF's full context; negative values are rejected.
+     * Pocket: FlowLM context capacity; accepts integers from 1 to 8192.
      */
     nCtx?: number;
     /**
@@ -309,27 +366,80 @@ interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTS
     /** Override `std::thread::hardware_concurrency()`. */
     threads?: number;
     /**
-     * Chatterbox / CosyVoice3 speech tokens per native streaming chunk.
-     * 0 disables.
+     * Native streaming chunk size; 0 disables. Chatterbox / CosyVoice3: speech
+     * tokens per chunk. MOSS: codec frames per chunk (12.5 per second).
+     * Supertonic: text tokens (Unicode code points) per chunk, about 50 for
+     * English (CJK is denser, 25-30). Supertonic native streaming cannot be
+     * combined with the LavaSR enhancer or denoiser.
      */
     streamChunkTokens?: number;
     /**
-     * Chatterbox / CosyVoice3 smaller first chunk for low first-audio-out
-     * latency.
+     * Chatterbox / CosyVoice3 / Supertonic smaller first chunk for low
+     * first-audio-out latency.
      */
     streamFirstChunkTokens?: number;
     /**
-     * CosyVoice3-only: left-context speech tokens intended to be carried into each
-     * streaming chunk. Reserved / not yet effective — the pinned tts-cpp engine
-     * accepts the value but does not read it (true low-latency token2wav streaming
-     * is still reserved), so setting it currently has no effect.
+     * Supertonic-only: boundary-snap window for clause and whitespace chunk
+     * boundaries, as a percentage of the chunk target (engine default 20).
+     */
+    streamChunkTolerancePct?: number;
+    /**
+     * Supertonic-only: floor on every streamed chunk's size in text tokens
+     * (engine default 30); shorter trailing chunks merge into the previous one.
+     */
+    streamMinChunkTokens?: number;
+    /**
+     * Chatterbox: sliding-window S3Gen for native streaming — keep only this many
+     * already-emitted speech tokens of left context per chunk, which bounds the
+     * per-chunk cost on long utterances (typical 25-50; 0 = cumulative prefix).
+     * CosyVoice3: reserved / not yet effective — the pinned tts-cpp engine
+     * accepts the value but does not read it.
      */
     streamLeftContextTokens?: number;
     /**
-     * Chatterbox-only CFM Euler step count. CosyVoice3: reserved / not yet
-     * effective — the engine runs a fixed 10-step schedule and ignores this.
+     * Chatterbox CFM Euler step count for native streaming chunks. CosyVoice3:
+     * reserved / not yet effective — the engine runs a fixed 10-step schedule
+     * and ignores this.
      */
     cfmSteps?: number;
+    /**
+     * Chatterbox-only CFM Euler step count for batch synthesis; 0 = library
+     * default (2-step meanflow on Turbo, the model's full schedule on
+     * multilingual). The multilingual engine does not floor this, so values well
+     * below its schedule under-integrate.
+     */
+    batchCfmSteps?: number;
+    /**
+     * Chatterbox-only cap on speech tokens T3 decodes per synthesis (25 tokens ~=
+     * 1 second); engine default 1000 (~40 s). Longer single-call audio also needs
+     * `nCtx` to cover prompt plus generated tokens, or use `maxSentenceChars`.
+     */
+    nPredict?: number;
+    /**
+     * Chatterbox-only sentence auto-split: run T3 + S3Gen per segment of at most
+     * this many bytes (the reference CLI uses 180; 0 = off). Bounds each T3
+     * sequence, so `nPredict` applies per segment.
+     */
+    maxSentenceChars?: number;
+    /**
+     * Chatterbox-only raised-cosine crossfade between auto-split batch segments,
+     * in milliseconds (engine default 30). Native streaming stays gapless.
+     */
+    crossfadeMs?: number;
+    /** Chatterbox-only T3 repetition penalty (engine default 1.2; 1 = off). */
+    repeatPenalty?: number;
+    /**
+     * Chatterbox multilingual only: prosody intensity, above 0 more expressive,
+     * below 0 flatter (engine default 0.5). The Turbo variant ignores it.
+     */
+    exaggeration?: number;
+    /**
+     * Chatterbox multilingual only: T3 classifier-free guidance scale (engine
+     * default 0.5; 0 disables). Separate from `cfgRate`, which steers S3Gen.
+     */
+    cfgWeight?: number;
+    /** Chatterbox multilingual only: min-p sampling threshold (0 = off). */
+    minP?: number;
     /**
      * Chatterbox-only S3Gen classifier-free-guidance rate. The diffusion loop
      * normally runs a batched conditioned + unconditioned pass combined by this
@@ -362,7 +472,32 @@ interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTS
     voice?: string;
     /** Alias for `voice` for compatibility with `@qvac/tts-onnx`. */
     voiceName?: string;
-    /** Supertonic vector-estimator CFM steps. 0 uses the GGUF default. */
+    /**
+     * Supertonic-only: external voice JSON (`{ style_ttl, style_dp }`, e.g. a
+     * cloned voice) that overrides the baked `voice` preset. The engine checks
+     * the tensor sizes against the loaded model.
+     */
+    voiceJsonPath?: string;
+    /**
+     * Supertonic-only: text synthesized once at load so GPU pipelines (and a
+     * Core ML vocoder sidecar) are ready before the first `run()`; skipped on a
+     * plain CPU run. Use a sentence of representative length. Wins over the
+     * `vulkanCacheDir` default pre-warm.
+     */
+    prewarmText?: string;
+    /**
+     * Supertonic / CosyVoice3 Vulkan adapter index, also used by their LavaSR
+     * enhancer: 0 (default) = first adapter, N = the Nth, -1 = auto-pick by free
+     * VRAM preferring a discrete adapter. Only consulted on Vulkan.
+     */
+    vulkanDevice?: number;
+    /**
+     * CosyVoice3-only: treat the baked-voice prompt frames as attention-only
+     * conditioning in the flow, for a faster flow whose output deviates slightly
+     * from the reference (engine default off).
+     */
+    flowCutPrompt?: boolean;
+    /** Supertonic CFM steps (0 uses GGUF default); Pocket sampling steps (1–64, default 1). */
     steps?: number;
     /** Alias for `steps` for compatibility with `@qvac/tts-onnx`. */
     numInferenceSteps?: number;
@@ -405,10 +540,13 @@ interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTS
     /** Chatterbox MTL Cangjie TSV path for Chinese. */
     cangjieTsvPath?: string;
     /**
-     * Parler and Audio8 sampling knobs; each unset defers to the engine's own
-     * defaults (Parler: temperature 1.0, top-k 50; Audio8: temperature 0.7,
-     * top-k 50, top-p 0.9). Audio8 filters by top-k/top-p on the raw logits and
+     * Parler, Audio8 and Chatterbox sampling knobs; each unset defers to the
+     * engine's own defaults (Parler: temperature 1.0, top-k 50; Audio8:
+     * temperature 0.7, top-k 50, top-p 0.9; Chatterbox: temperature 0.8,
+     * top-k 1000, top-p 0.95, where temperature 0 decodes greedily and top-k 0
+     * disables the cutoff). Audio8 filters by top-k/top-p on the raw logits and
      * only then applies the temperature, following its reference.
+     * Pocket: sampling temperature; accepts finite values from 0 to 10.
      */
     temperature?: number;
     topK?: number;
@@ -420,6 +558,22 @@ interface TTSGgmlOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTS
     maxFrames?: number;
     /** Audio8: take the argmax instead of sampling. */
     greedy?: boolean;
+    /**
+     * MOSS: target length in codec frames (12.5 per second), from 0 to 2015
+     * (about 161 s); 0 or unset keeps the length free. Set at construction or
+     * with `reload()`, not per call.
+     */
+    durationTokens?: number;
+    /**
+     * MOSS-TTSD dialogue: one 24 kHz reference recording per speaker, in the
+     * order the text tags them (`[S1]`, `[S2]`, ...). The model continues the
+     * references, so the input text must open with each reference's transcript
+     * under its tag, followed by the lines to generate; sentence streaming is
+     * therefore rejected (use `run()` or `streamChunkTokens`). Needs
+     * `files.mossCodecEncoder`, excludes `referenceAudio`, and is fixed for the
+     * instance. With a `modelDir`, requires a `moss-ttsd-*.gguf` backbone.
+     */
+    dialogueReferences?: string[];
     minNewTokens?: number;
     /** Parler prompt digit expansion (engine default: enabled). */
     normalizeNumbers?: boolean;
@@ -432,16 +586,19 @@ interface InferenceState {
     destroyed: boolean;
 }
 interface TTSOutputChunk {
+    chunkIndex?: number;
+    isLast?: boolean;
     /** Signed 16-bit mono PCM audio payload. */
     outputArray: Int16Array;
     /**
-     * Output sample rate. The native engine rate (24000 for Chatterbox and
-     * CosyVoice3; 44100 for Supertonic, Parler, and Audio8), or 48000 when the
-     * LavaSR enhancer is active.
+     * Output sample rate. The native engine rate (24000 for Chatterbox,
+     * CosyVoice3 and MOSS; 44100 for Supertonic, Parler, and Audio8), or 48000
+     * when the LavaSR enhancer is active.
      */
     sampleRate?: number;
 }
 interface RuntimeStats {
+    firstAudioMs?: number;
     totalTime: number;
     tokensPerSecond: number;
     realTimeFactor: number;
@@ -455,13 +612,87 @@ interface RuntimeStats {
     enhancerBackendDevice?: number;
     /** LavaSR enhancer backend code, using the same values as `backendId`. */
     enhancerBackendId?: number;
+    /** LavaSR denoiser compute device. -1 = not loaded, 0 = CPU, 1 = GPU. */
+    denoiserBackendDevice?: number;
+    /** LavaSR denoiser backend code, using the same values as `backendId`. */
+    denoiserBackendId?: number;
     /** 1 when a present GPU is unsupported by engine policy; 0 otherwise. */
     gpuUnsupported?: number;
     /**
-     * Audio8 only: codec frames generated, on a fixed 46 ms grid. This is the
-     * unit its `tokensPerSecond` counts, in batch and in streaming alike.
+     * Audio8 and MOSS only: codec frames generated (Audio8 on a fixed 46 ms
+     * grid, MOSS at 12.5 per second). This is the unit their `tokensPerSecond`
+     * counts, in batch and in streaming alike.
      */
     generatedFrames?: number;
+    /**
+     * Audio8 only, macOS / iOS: 1 while an Apple Core ML sidecar for the codec's
+     * synthesis stack is attached (a compiled `audio8-codec-decoder.mlmodelc`
+     * next to the decoder GGUF); 0 without one, or once a failing sidecar has
+     * been retired. Streams report the last chunk that supplied this field.
+     */
+    codecSidecarLoaded?: number;
+    /**
+     * Audio8 only: 1 when this synthesis ran the codec's synthesis stack on the
+     * Apple Core ML sidecar -- a compiled `audio8-codec-decoder.mlmodelc` next
+     * to the decoder GGUF on macOS / iOS -- 0 when it ran on the ggml backend
+     * `backendId` reports (which the language model always uses). A loaded
+     * sidecar that cannot serve a call falls back to ggml and reports 0 for it.
+     * Streams report the last chunk that supplied this field, not a sum.
+     */
+    codecOnCoreml?: number;
+    /** Chatterbox only: T3 decode wall time of the last synthesis, in ms. */
+    t3Ms?: number;
+    /** Chatterbox only: S3Gen + HiFT wall time of the last synthesis, in ms. */
+    s3genMs?: number;
+    /** Chatterbox only: speech tokens T3 emitted in the last synthesis. */
+    t3Tokens?: number;
+    /**
+     * CosyVoice3 / Audio8: the engine's own wall time for the last synthesis, in
+     * ms (the sum of its stages), excluding the addon's post-processing.
+     */
+    stageTotalMs?: number;
+    /** CosyVoice3 stage wall times of the last synthesis, in ms. */
+    lmPrefillMs?: number;
+    lmDecodeMs?: number;
+    flowFrontendMs?: number;
+    ditEulerMs?: number;
+    hiftF0Ms?: number;
+    hiftSourceMs?: number;
+    hiftStftMs?: number;
+    hiftDecodeMs?: number;
+    /**
+     * CosyVoice3 work counters of the last synthesis: LM decode steps, speech
+     * tokens generated, flow frames in (prompt + generated), mel frames out,
+     * text ids in the LM prefill, and prompt speech tokens the LM continued from.
+     */
+    decodeSteps?: number;
+    speechTokens?: number;
+    flowFrames?: number;
+    melFrames?: number;
+    textIds?: number;
+    promptSpeechTokens?: number;
+    /** Audio8 stage wall times of the last synthesis, in ms. */
+    voiceEncodeMs?: number;
+    promptMs?: number;
+    prefillMs?: number;
+    sampleMs?: number;
+    fastDecodeMs?: number;
+    slowDecodeMs?: number;
+    codecLatentMs?: number;
+    codecSynthMs?: number;
+    resampleMs?: number;
+}
+/**
+ * tts-cpp's canonical conditioning vocabulary and each engine's supported
+ * subset, keyed by engine type (`TTSGgml.getVoiceControls()`).
+ */
+interface VoiceControlsCatalog {
+    emotions: string[];
+    paces: string[];
+    engines: Record<string, {
+        emotions: string[];
+        paces: string[];
+    }>;
 }
 interface SentenceStreamChunkMeta {
     chunkIndex?: number;
@@ -472,13 +703,13 @@ interface SentenceStreamChunkMeta {
      */
     isLast?: boolean;
 }
-interface SentenceStreamOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields {
+interface SentenceStreamOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields, CosyvoiceJobFields {
     /** BCP-47 locale for `Intl.Segmenter` when available. */
     locale?: string;
     /** Maximum graphemes per chunk; defaults to 300, or 120 for Korean. */
     maxChunkScalars?: number;
 }
-interface RunStreamingOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields {
+interface RunStreamingOptions extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields, CosyvoiceJobFields {
     accumulateSentences?: boolean;
     sentenceDelimiter?: RegExp;
     sentenceDelimiterPreset?: SentenceDelimiterPreset;
@@ -487,7 +718,7 @@ interface RunStreamingOptions extends ParlerDescriptionFields, Audio8VoiceFields
 }
 /** Input accepted by `runStreaming`. */
 type TextStreamInput = string | string[] | Iterable<string> | AsyncIterable<string>;
-interface TTSRunInput extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields {
+interface TTSRunInput extends ParlerDescriptionFields, Audio8VoiceFields, TTSConditioningFields, CosyvoiceJobFields {
     type?: string;
     input: string;
     streamOutput?: boolean;
@@ -501,7 +732,7 @@ interface TTSRunInput extends ParlerDescriptionFields, Audio8VoiceFields, TTSCon
 }
 /**
  * GGML-backed TTS via the `tts-cpp` library. Wraps the chatterbox,
- * supertonic, parler, cosyvoice3 and audio8 engines behind a single
+ * supertonic, parler, cosyvoice3, audio8 and moss engines behind a single
  * engine-agnostic JavaScript surface. Engine type is auto-detected from
  * `files` or selected explicitly with `engine`.
  *
@@ -518,6 +749,8 @@ declare class TTSGgml {
     static readonly ENGINE_COSYVOICE3 = "cosyvoice3";
     static readonly ENGINE_PARLER = "parler";
     static readonly ENGINE_AUDIO8 = "audio8";
+    static readonly ENGINE_MOSS = "moss";
+    static readonly ENGINE_POCKET = "pocket";
     opts: object;
     exclusiveRun: boolean;
     logger: object;
@@ -528,6 +761,12 @@ declare class TTSGgml {
     private _ttsInferenceQueueWaiter;
     private _sentenceStreamCtx;
     private _config;
+    private _pocketJobPending;
+    private _pocketCancelPromise;
+    private _pocketLifecycleInProgress;
+    private _pocketParams;
+    private _pocketOptions;
+    private _pocketFiles;
     private _lazySessionLoading;
     private _outputSampleRate;
     private _engineType;
@@ -555,6 +794,23 @@ declare class TTSGgml {
     private _streamLeftContextTokens?;
     private _cfmSteps?;
     private _cfgRate?;
+    private _batchCfmSteps?;
+    private _nPredict?;
+    private _maxSentenceChars?;
+    private _crossfadeMs?;
+    private _repeatPenalty?;
+    private _exaggeration?;
+    private _cfgWeight?;
+    private _minP?;
+    private _streamChunkTolerancePct?;
+    private _streamMinChunkTokens?;
+    private _voiceJsonPath?;
+    private _prewarmText?;
+    private _vulkanDevice?;
+    private _flowCutPrompt?;
+    private _cosyvoiceVocabPath?;
+    private _cosyvoiceMergesPath?;
+    private _cosyvoiceVoiceModelPath?;
     private _promptText?;
     private _instruct?;
     private _voice?;
@@ -570,6 +826,11 @@ declare class TTSGgml {
     private _audio8LmPath?;
     private _audio8CodecDecoderPath?;
     private _audio8CodecEncoderPath?;
+    private _mossBackbonePath?;
+    private _mossCodecDecoderPath?;
+    private _mossCodecEncoderPath?;
+    private _dialogueReferences?;
+    private _durationTokens?;
     private _referenceText?;
     private _greedy?;
     private _description?;
@@ -589,12 +850,27 @@ declare class TTSGgml {
     constructor(options?: TTSGgmlOptions);
     private _resolveEngineAndModelPaths;
     private _resolveAudio8ModelPaths;
+    private _mossBackbonePatterns;
+    private _findMossBackbone;
+    private _resolveMossModelPaths;
+    private _assignMossVoiceOptions;
     private _assignSynthesisOptions;
     private _assertEngineStreamingSupport;
     private _requestsChunkStreaming;
     private _assertParlerOptionConsistency;
     private _assertSamplerOptionSupport;
+    /**
+     * Options only some engines read. Set on any other engine they would be
+     * dropped without effect, so they are rejected by name instead.
+     */
+    private _assertEngineScopedOptions;
     private _assertAudio8OptionConsistency;
+    private _assertMossOptionConsistency;
+    private _assertNoMossOnlyOptions;
+    private _assertMossDialogueReferences;
+    private _assertSentenceStreamingAllowed;
+    private _assertMossOutputRate;
+    private _assertMossVoiceConsistent;
     /**
      * A recording without its transcript is accepted by the model but degrades
      * the clone silently, and a transcript alone has nothing to attach to, so
@@ -618,6 +894,12 @@ declare class TTSGgml {
      * emotion/pace it declares support for, never Parler's template fields.
      */
     private _resolveConditioningJobFields;
+    /**
+     * CosyVoice3's per-call instruction, rendered like the constructor's. The
+     * native layer reads it next to emotion/pace, and any of the three replaces
+     * the configured conditioning for that synthesis.
+     */
+    private _resolveJobInstruct;
     /**
      * Parler's per-call surface: description/template fields, where a per-call
      * template cannot be merged with a constructor-level free-text description.
@@ -645,6 +927,7 @@ declare class TTSGgml {
     getApiDefinition(): string;
     getState(): InferenceState;
     load(..._args: unknown[]): Promise<void>;
+    private _loadModel;
     /**
      * Run text-to-speech. With `{ streamOutput: true }`, splits `input` into
      * chunks and emits PCM through `response.onUpdate` for each chunk.
@@ -672,8 +955,8 @@ declare class TTSGgml {
     private _runTextStreamOrchestrator;
     private _sentenceStreamTextIterableDrive;
     /**
-     * Audio8 reports `tokensPerSecond` as codec frames per second, so the
-     * streaming aggregate has to count frames too rather than characters.
+     * Audio8 and MOSS report `tokensPerSecond` as codec frames per second, so
+     * the streaming aggregate has to count frames too rather than characters.
      */
     private _pacesOnFrames;
     private _runStreamOrchestrator;
@@ -685,6 +968,7 @@ declare class TTSGgml {
     private _buildSupertonicParams;
     private _buildParlerParams;
     private _buildAudio8Params;
+    private _buildMossParams;
     /** The knobs every engine in SAMPLING_ENGINES reads. */
     private _assignSamplingParams;
     /**
@@ -697,6 +981,7 @@ declare class TTSGgml {
     private _assignLavasrParams;
     private _createAddon;
     unload(): Promise<void>;
+    private _unloadModel;
     destroy(): Promise<void>;
     private _runInternal;
     private _mergeSentenceStreamStats;
@@ -707,12 +992,19 @@ declare class TTSGgml {
     private _handleAddonOutput;
     private _enrichStreamChunk;
     private _handleAddonStats;
+    private _waitPocketCancel;
+    private _withPocketLifecycle;
+    private _checkPocketReload;
+    private _checkPocketRequest;
+    private _dispatchJob;
     cancel(): Promise<void>;
     private _failAndClearActiveResponse;
     /** Everything reload() may overwrite, so a rejected reload can undo itself. */
     private _captureReloadableState;
     private _restoreReloadableState;
     private _applyReloadableRuntimeConfig;
+    private _assertMossReloadKeepsVoice;
+    private _applyMossReload;
     private _applyReloadableConditioning;
     private _applyReloadableParlerConfig;
     /**
@@ -721,6 +1013,7 @@ declare class TTSGgml {
      * reload is not validated against state the caller never accepted.
      */
     private _applyReloadableConfig;
+    private _reloadPocket;
     reload(newConfig?: Record<string, unknown>): Promise<void>;
     /**
      * The voice a reload lands on. Same rule as _mergeAudio8Voice and
@@ -744,6 +1037,13 @@ declare class TTSGgml {
      */
     private _applyAudio8Reload;
     static getModelKey(_params?: unknown): string;
+    /**
+     * tts-cpp's canonical emotion / pace vocabulary and each engine's supported
+     * subset, read from the native library without loading a model. Engines are
+     * keyed by engine type, so tts-cpp's `cosyvoice` appears as `cosyvoice3`;
+     * an engine this package does not wrap keeps its tts-cpp name.
+     */
+    static getVoiceControls(): VoiceControlsCatalog;
     private _requireAddon;
     private _optionalAddon;
     private _getLogger;
@@ -762,6 +1062,17 @@ type NamespaceTextStreamInput = TextStreamInput;
 type NamespaceRunInput = TTSRunInput;
 type NamespaceInferenceState = InferenceState;
 type NamespaceCosyvoiceInstruct = CosyvoiceInstruct;
+type NamespaceVoiceControlsCatalog = VoiceControlsCatalog;
+type NamespaceFitEngine = TtsFitEngine;
+type NamespaceFitRequest = TtsFitRequest;
+type NamespaceFitResult = TtsFitResult;
+type NamespaceFitStatus = TtsFitStatus;
+type NamespaceSupertonicFit = SupertonicFitRequest;
+type NamespaceParlerFit = ParlerFitRequest;
+type NamespaceChatterboxFit = ChatterboxFitRequest;
+type NamespaceAudio8Fit = Audio8FitRequest;
+type NamespaceMossFit = MossFitRequest;
+type NamespaceCosyvoiceFit = CosyvoiceFitRequest;
 declare namespace TTSGgml {
     export import QvacErrorAddonTTSGgml = errorModule.QvacErrorAddonTTSGgml;
     export import ERR_CODES = errorModule.ERR_CODES;
@@ -779,6 +1090,18 @@ declare namespace TTSGgml {
     type TTSRunInput = NamespaceRunInput;
     type InferenceState = NamespaceInferenceState;
     type CosyvoiceInstruct = NamespaceCosyvoiceInstruct;
+    type VoiceControlsCatalog = NamespaceVoiceControlsCatalog;
+    type TtsFitEngine = NamespaceFitEngine;
+    type TtsFitRequest = NamespaceFitRequest;
+    type TtsFitResult = NamespaceFitResult;
+    type TtsFitStatus = NamespaceFitStatus;
+    type SupertonicFitRequest = NamespaceSupertonicFit;
+    type ParlerFitRequest = NamespaceParlerFit;
+    type ChatterboxFitRequest = NamespaceChatterboxFit;
+    type Audio8FitRequest = NamespaceAudio8Fit;
+    type MossFitRequest = NamespaceMossFit;
+    type CosyvoiceFitRequest = NamespaceCosyvoiceFit;
     const resolveBackendsDir: typeof resolveBackendsDirImpl;
+    const assessFit: typeof assessFitImpl;
 }
 export = TTSGgml;