@qvac/tts-ggml 0.10.1 → 0.11.0

package/index.js

@@ -62,6 +62,8 @@ const ENGINE_COSYVOICE3 = "cosyvoice3";
 const ENGINE_PARLER = "parler";
 const ENGINE_AUDIO8 = "audio8";
 const ENGINE_MOSS = "moss";
+const ENGINE_MOSS_SFX = "moss-sfx";
+const ENGINE_MOSS_SPEECH = "moss-speech";
 const ENGINE_POCKET = "pocket";
 const MIN_OUTPUT_SAMPLE_RATE = 8000;
 const MAX_OUTPUT_SAMPLE_RATE = 192000;
@@ -256,6 +258,49 @@ const MOSS_MAX_CHANNELS = 32;
 const MOSS_TERMINATION_ROWS = 2;
 const MOSS_MAX_DURATION_TOKENS = MOSS_MAX_NEW_TOKENS - (MOSS_MAX_CHANNELS - 1) - MOSS_TERMINATION_ROWS;
 const MOSS_INSTANCE_VOICE_KEYS = ["referenceAudio", "dialogueReferences"];
+const MOSS_SFX_RE = /^moss-sfx(-[a-z0-9_]+)*\.gguf$/i;
+const MOSS_SFX_NATIVE_SAMPLE_RATE = 48000;
+const MOSS_SFX_MAX_SECONDS = 30;
+const MOSS_SFX_MAX_STEPS = 1000;
+const MOSS_SFX_MAX_GUIDANCE = 50;
+const MOSS_SFX_MAX_SHIFT = 100;
+const MOSS_SFX_CALL_KEYS = [
+    "seconds",
+    "negativePrompt",
+    "steps",
+    "guidance",
+    "shift",
+];
+const MOSS_SPEECH_RE = /^moss-speech(-(?!codec)[a-z0-9_]+)?\.gguf$/i;
+const MOSS_SPEECH_CODEC_RE = /^moss-speech-codec(-[a-z0-9_]+)?\.gguf$/i;
+const MOSS_SPEECH_NATIVE_SAMPLE_RATE = 24000;
+const MOSS_SPEECH_MIN_SAMPLE_RATE = 8000;
+const MOSS_SPEECH_MAX_SAMPLE_RATE = 192000;
+const MOSS_SPEECH_MAX_NEW_TOKENS = 4096;
+const MOSS_SPEECH_MAX_REPLY_SECONDS = 3600;
+const MOSS_SPEECH_MAX_TEMPERATURE = 10;
+const MOSS_SPEECH_MAX_TOP_P = 1;
+const MOSS_SPEECH_ROLES = ["system", "user", "assistant"];
+const MOSS_SPEECH_ONLY_KEYS = [
+    "audio",
+    "sampleRate",
+    "messages",
+    "systemPrompt",
+    "replyVoice",
+    "replyVoiceSampleRate",
+    "textReply",
+    "maxReplySeconds",
+    "maxNewTokens",
+];
+const MOSS_SPEECH_CONTROL_KEYS = [
+    "textReply",
+    "maxReplySeconds",
+    "maxNewTokens",
+    "greedy",
+    "temperature",
+    "topP",
+    "topK",
+];
 /** Engines that draw tokens, and so accept temperature / topK / topP / maxFrames. */
 const SAMPLING_ENGINES = [ENGINE_PARLER, ENGINE_AUDIO8];
 // Per-engine supported subsets, mirroring controls::supported_emotions() /
@@ -270,6 +315,8 @@ const ENGINE_EMOTIONS = {
     [ENGINE_POCKET]: [],
     [ENGINE_AUDIO8]: [],
     [ENGINE_MOSS]: [],
+    [ENGINE_MOSS_SFX]: [],
+    [ENGINE_MOSS_SPEECH]: [],
 };
 const ENGINE_PACES = {
     [ENGINE_PARLER]: PACES, // rendered into the training caption
@@ -279,6 +326,8 @@ const ENGINE_PACES = {
     [ENGINE_POCKET]: [],
     [ENGINE_AUDIO8]: [], // no rate control at all
     [ENGINE_MOSS]: [],
+    [ENGINE_MOSS_SFX]: [],
+    [ENGINE_MOSS_SPEECH]: [],
 };
 // Which channels an engine can change per call. Supertonic takes its pace
 // through EngineOptions when the engine is built, and tts-cpp exposes no
@@ -296,6 +345,8 @@ const ENGINE_PER_CALL_CONDITIONING = {
     [ENGINE_POCKET]: [],
     [ENGINE_AUDIO8]: [],
     [ENGINE_MOSS]: [],
+    [ENGINE_MOSS_SFX]: [],
+    [ENGINE_MOSS_SPEECH]: [],
 };
 function normalizeError(error) {
     return typeof error === "string"
@@ -436,6 +487,171 @@ function findQuantRankedGguf(modelDir, pattern) {
     matches.sort((left, right) => ggufQuantRank(left, pattern) - ggufQuantRank(right, pattern));
     return path.join(modelDir, matches[0]);
 }
+function assertSoundEffectRange(name, value, accepts, range) {
+    if (typeof value === "number" && Number.isFinite(value) && accepts(value))
+        return;
+    throw new Error(`tts-ggml: moss-sfx ${name} must be ${range} (got ${String(value)})`);
+}
+function assertSoundEffectFields(fields) {
+    if (fields.seconds !== undefined) {
+        assertSoundEffectRange("seconds", fields.seconds, (n) => n > 0 && n <= MOSS_SFX_MAX_SECONDS, `in (0, ${MOSS_SFX_MAX_SECONDS}]`);
+    }
+    if (fields.steps !== undefined) {
+        assertSoundEffectRange("steps", fields.steps, (n) => Number.isInteger(n) && n >= 1 && n <= MOSS_SFX_MAX_STEPS, `an integer in [1, ${MOSS_SFX_MAX_STEPS}]`);
+    }
+    if (fields.guidance !== undefined) {
+        assertSoundEffectRange("guidance", fields.guidance, (n) => n >= 1 && n <= MOSS_SFX_MAX_GUIDANCE, `in [1, ${MOSS_SFX_MAX_GUIDANCE}]`);
+    }
+    if (fields.shift !== undefined) {
+        assertSoundEffectRange("shift", fields.shift, (n) => n > 0 && n <= MOSS_SFX_MAX_SHIFT, `in (0, ${MOSS_SFX_MAX_SHIFT}]`);
+    }
+    if (fields.negativePrompt !== undefined && typeof fields.negativePrompt !== "string") {
+        throw new Error("tts-ggml: moss-sfx negativePrompt must be a string");
+    }
+}
+function isSpeechPcm(value) {
+    return value instanceof Int16Array || value instanceof Float32Array;
+}
+function assertSpeechSampleRate(value, name, where) {
+    if (typeof value === "number" &&
+        Number.isInteger(value) &&
+        value >= MOSS_SPEECH_MIN_SAMPLE_RATE &&
+        value <= MOSS_SPEECH_MAX_SAMPLE_RATE) {
+        return;
+    }
+    throw new Error(`tts-ggml: ${where}: moss-speech ${name} must be an integer in ` +
+        `[${MOSS_SPEECH_MIN_SAMPLE_RATE}, ${MOSS_SPEECH_MAX_SAMPLE_RATE}] (got ${String(value)})`);
+}
+function assertSpeechAudio(audio, rate, names, where) {
+    if (!isSpeechPcm(audio) || audio.length === 0) {
+        throw new Error(`tts-ggml: ${where}: moss-speech ${names[0]} must be a non-empty Int16Array or Float32Array`);
+    }
+    assertSpeechSampleRate(rate, names[1], where);
+}
+function assertSpeechMessage(message, index, where) {
+    const label = `messages[${index}]`;
+    if (message == null || typeof message !== "object") {
+        throw new Error(`tts-ggml: ${where}: moss-speech ${label} must be an object`);
+    }
+    const turn = message;
+    if (!MOSS_SPEECH_ROLES.includes(turn.role)) {
+        throw new Error(`tts-ggml: ${where}: moss-speech ${label}.role must be one of ${MOSS_SPEECH_ROLES.join(", ")}`);
+    }
+    const hasText = typeof turn.text === "string" && turn.text.length > 0;
+    const hasAudio = turn.audio !== undefined;
+    if (hasText === hasAudio) {
+        throw new Error(`tts-ggml: ${where}: moss-speech ${label} carries exactly one of text or audio`);
+    }
+    if (hasAudio) {
+        assertSpeechAudio(turn.audio, turn.sampleRate, [`${label}.audio`, `${label}.sampleRate`], where);
+    }
+}
+function assertSpeechMessages(messages, where) {
+    if (messages === undefined)
+        return;
+    if (!Array.isArray(messages)) {
+        throw new Error(`tts-ggml: ${where}: moss-speech messages must be an array`);
+    }
+    assertEachSpeechMessage(messages, where);
+}
+function assertEachSpeechMessage(messages, where) {
+    messages.forEach((message, index) => assertSpeechMessage(message, index, where));
+}
+function assertSpeechUserTurn(fields, where) {
+    const hasText = typeof fields.input === "string" && fields.input.trim().length > 0;
+    const hasAudio = fields.audio !== undefined;
+    if (hasText && hasAudio) {
+        throw new Error(`tts-ggml: ${where}: moss-speech takes the user turn as audio or input text, not both`);
+    }
+    if (hasAudio) {
+        assertSpeechAudio(fields.audio, fields.sampleRate, ["audio", "sampleRate"], where);
+        return;
+    }
+    if (!hasText) {
+        throw new Error(`tts-ggml: ${where}: moss-speech needs the user turn as audio (with sampleRate) or input text`);
+    }
+}
+function assertSpeechRange(name, value, accepts, range, where) {
+    if (value === undefined)
+        return;
+    if (typeof value === "number" && Number.isFinite(value) && accepts(value))
+        return;
+    const got = typeof value === "number" ? String(value) : typeof value;
+    throw new Error(`tts-ggml: ${where}: moss-speech ${name} must be ${range} (got ${got})`);
+}
+function assertSpeechControls(fields, where) {
+    assertSpeechRange("maxReplySeconds", fields.maxReplySeconds, (n) => n >= 0 && n <= MOSS_SPEECH_MAX_REPLY_SECONDS, `in [0, ${MOSS_SPEECH_MAX_REPLY_SECONDS}]`, where);
+    assertSpeechRange("maxNewTokens", fields.maxNewTokens, (n) => Number.isInteger(n) && n >= 1 && n <= MOSS_SPEECH_MAX_NEW_TOKENS, `an integer in [1, ${MOSS_SPEECH_MAX_NEW_TOKENS}]`, where);
+    assertSpeechRange("temperature", fields.temperature, (n) => n > 0 && n <= MOSS_SPEECH_MAX_TEMPERATURE, `in (0, ${MOSS_SPEECH_MAX_TEMPERATURE}]`, where);
+    assertSpeechRange("topP", fields.topP, (n) => n > 0 && n <= MOSS_SPEECH_MAX_TOP_P, `in (0, ${MOSS_SPEECH_MAX_TOP_P}]`, where);
+    assertSpeechRange("topK", fields.topK, (n) => Number.isInteger(n) && n >= 0, "an integer >= 0", where);
+    assertSpeechBooleans(fields, where);
+    if (fields.systemPrompt !== undefined && typeof fields.systemPrompt !== "string") {
+        throw new Error(`tts-ggml: ${where}: moss-speech systemPrompt must be a string`);
+    }
+}
+function assertSpeechBooleans(fields, where) {
+    for (const flag of ["textReply", "greedy"]) {
+        if (fields[flag] !== undefined && typeof fields[flag] !== "boolean") {
+            throw new Error(`tts-ggml: ${where}: moss-speech ${flag} must be a boolean`);
+        }
+    }
+}
+function assertSpeechRateHasAudio(audio, rate, names, where) {
+    if (audio !== undefined || rate === undefined)
+        return;
+    throw new Error(`tts-ggml: ${where}: moss-speech ${names[1]} needs ${names[0]}`);
+}
+function assertSpeechCall(fields, where) {
+    assertSpeechUserTurn(fields, where);
+    assertSpeechRateHasAudio(fields.audio, fields.sampleRate, ["audio", "sampleRate"], where);
+    assertSpeechRateHasAudio(fields.replyVoice, fields.replyVoiceSampleRate, ["replyVoice", "replyVoiceSampleRate"], where);
+    assertSpeechMessages(fields.messages, where);
+    if (fields.replyVoice !== undefined) {
+        assertSpeechAudio(fields.replyVoice, fields.replyVoiceSampleRate, ["replyVoice", "replyVoiceSampleRate"], where);
+    }
+    assertSpeechControls(fields, where);
+}
+function speechUserTurn(fields) {
+    if (fields.audio !== undefined) {
+        return { role: "user", audio: fields.audio, sampleRate: fields.sampleRate };
+    }
+    return { role: "user", text: fields.input };
+}
+function speechMessages(fields) {
+    const system = fields.systemPrompt ? [{ role: "system", text: fields.systemPrompt }] : [];
+    return [...system, ...(fields.messages ?? []), speechUserTurn(fields)];
+}
+function speechReplyVoice(fields) {
+    if (fields.replyVoice === undefined)
+        return {};
+    return { replyVoice: fields.replyVoice, replyVoiceSampleRate: fields.replyVoiceSampleRate };
+}
+function speechControls(fields) {
+    const present = MOSS_SPEECH_CONTROL_KEYS.filter((key) => fields[key] !== undefined);
+    return Object.fromEntries(present.map((key) => [key, fields[key]]));
+}
+/** Collect the fields only MOSS-Speech reads that are present on `source`; undefined when none are set. */
+function pickSpeechFields(source) {
+    if (source == null || typeof source !== "object")
+        return undefined;
+    const present = MOSS_SPEECH_ONLY_KEYS.filter((key) => source[key] !== undefined);
+    if (present.length === 0)
+        return undefined;
+    return Object.fromEntries(present.map((key) => [key, source[key]]));
+}
+/**
+ * Collect the MOSS-SoundEffect generation controls present on `source`.
+ * Returns undefined when none are set.
+ */
+function pickSoundEffectFields(source) {
+    if (source == null || typeof source !== "object")
+        return undefined;
+    const present = MOSS_SFX_CALL_KEYS.filter((key) => source[key] !== undefined);
+    if (present.length === 0)
+        return undefined;
+    return Object.fromEntries(present.map((key) => [key, source[key]]));
+}
 /**
  * Collect the Audio8 voice-cloning properties present on `source` (a run
  * input, streaming options, or constructor options). Returns undefined when
@@ -621,6 +837,9 @@ function normalizeGgmlFiles(files) {
         mossBackbone: firstNonEmpty(files.mossBackbone, files.mossBackbonePath),
         mossCodecDecoder: firstNonEmpty(files.mossCodecDecoder, files.mossCodecDecoderPath),
         mossCodecEncoder: firstNonEmpty(files.mossCodecEncoder, files.mossCodecEncoderPath),
+        mossSoundEffect: firstNonEmpty(files.mossSoundEffect, files.mossSoundEffectPath),
+        mossSpeechModel: firstNonEmpty(files.mossSpeechModel, files.mossSpeechModelPath),
+        mossSpeechCodec: firstNonEmpty(files.mossSpeechCodec, files.mossSpeechCodecPath),
         voicesDir: firstNonEmpty(files.voicesDir),
         lavasrEnhancer: firstNonEmpty(files.lavasrEnhancer),
         lavasrDenoiser: firstNonEmpty(files.lavasrDenoiser),
@@ -635,12 +854,14 @@ function detectEngineType(engine, files) {
         engine === ENGINE_PARLER ||
         engine === ENGINE_AUDIO8 ||
         engine === ENGINE_MOSS ||
+        engine === ENGINE_MOSS_SFX ||
+        engine === ENGINE_MOSS_SPEECH ||
         engine === ENGINE_POCKET) {
         return engine;
     }
     if (engine != null && engine !== "") {
         throw new Error("tts-ggml: 'engine' option must be 'chatterbox', 'supertonic', " +
-            `'cosyvoice3', 'parler', 'audio8', 'moss' or 'pocket' (got '${String(engine)}')`);
+            `'cosyvoice3', 'parler', 'audio8', 'moss', 'moss-sfx', 'moss-speech' or 'pocket' (got '${String(engine)}')`);
     }
     if (files.pocketFlowModel || files.pocketMimiModel)
         return ENGINE_POCKET;
@@ -658,6 +879,10 @@ function detectEngineType(engine, files) {
         return ENGINE_AUDIO8;
     if (files.mossBackbone || files.mossCodecDecoder)
         return ENGINE_MOSS;
+    if (files.mossSoundEffect)
+        return ENGINE_MOSS_SFX;
+    if (files.mossSpeechModel || files.mossSpeechCodec)
+        return ENGINE_MOSS_SPEECH;
     if (files.modelDir) {
         if (dirHasCosyvoice3(files.modelDir))
             return ENGINE_COSYVOICE3;
@@ -679,6 +904,10 @@ function detectEngineType(engine, files) {
         if (findQuantRankedGguf(files.modelDir, MOSS_DIALOGUE_BACKBONE_RE)) {
             return ENGINE_MOSS;
         }
+        if (findQuantRankedGguf(files.modelDir, MOSS_SFX_RE))
+            return ENGINE_MOSS_SFX;
+        if (findQuantRankedGguf(files.modelDir, MOSS_SPEECH_RE))
+            return ENGINE_MOSS_SPEECH;
         if (fileExistsSafe(path.join(files.modelDir, "flow-lm.gguf")))
             return ENGINE_POCKET;
     }
@@ -922,6 +1151,8 @@ class TTSGgml {
     static ENGINE_PARLER = ENGINE_PARLER;
     static ENGINE_AUDIO8 = ENGINE_AUDIO8;
     static ENGINE_MOSS = ENGINE_MOSS;
+    static ENGINE_MOSS_SFX = ENGINE_MOSS_SFX;
+    static ENGINE_MOSS_SPEECH = ENGINE_MOSS_SPEECH;
     static ENGINE_POCKET = ENGINE_POCKET;
     opts;
     exclusiveRun;
@@ -1001,6 +1232,9 @@ class TTSGgml {
     _mossBackbonePath;
     _mossCodecDecoderPath;
     _mossCodecEncoderPath;
+    _mossSoundEffectPath;
+    _mossSpeechModelPath;
+    _mossSpeechCodecPath;
     _dialogueReferences;
     _durationTokens;
     _referenceText;
@@ -1106,6 +1340,15 @@ class TTSGgml {
             this._resolveMossModelPaths(files);
             return;
         }
+        if (this._engineType === ENGINE_MOSS_SFX) {
+            this._mossSoundEffectPath = firstNonEmpty(files.mossSoundEffect, findQuantRankedGguf(files.modelDir, MOSS_SFX_RE));
+            return;
+        }
+        if (this._engineType === ENGINE_MOSS_SPEECH) {
+            this._mossSpeechModelPath = firstNonEmpty(files.mossSpeechModel, findQuantRankedGguf(files.modelDir, MOSS_SPEECH_RE));
+            this._mossSpeechCodecPath = firstNonEmpty(files.mossSpeechCodec, findQuantRankedGguf(files.modelDir, MOSS_SPEECH_CODEC_RE));
+            return;
+        }
         if (files.modelDir) {
             const resolved = resolveChatterboxModelDirPaths(files.modelDir);
             this._t3ModelPath = firstNonEmpty(files.t3Model, resolved.t3);
@@ -1213,6 +1456,14 @@ class TTSGgml {
                 "utterance at a time. Use sentence-level streaming via " +
                 "runStream() / runStreaming() / run({ streamOutput: true }).");
         }
+        if ((this._engineType === ENGINE_MOSS_SFX ||
+            this._engineType === ENGINE_MOSS_SPEECH) &&
+            (this._streamChunkTokens != null ||
+                this._streamFirstChunkTokens != null)) {
+            throw new Error("tts-ggml: streamChunkTokens / streamFirstChunkTokens are not " +
+                `supported by the ${this._engineType} engine, which returns a ` +
+                "whole result at a time. Use run().");
+        }
         if (this._engineType === ENGINE_MOSS &&
             this._streamFirstChunkTokens != null) {
             throw new Error("tts-ggml: streamFirstChunkTokens is not supported by the moss " +
@@ -1227,6 +1478,8 @@ class TTSGgml {
         this._assertCosyvoiceCloneConsistent();
         this._assertAudio8OptionConsistency();
         this._assertMossOptionConsistency();
+        this._assertMossSoundEffectOptionConsistency();
+        this._assertMossSpeechOptionConsistency();
         this._assertConditioningConsistency("constructor");
         if (this._denoiserGgufPath && this._requestsChunkStreaming()) {
             throw new Error("tts-ggml: the LavaSR denoiser is not yet supported with " +
@@ -1369,6 +1622,61 @@ class TTSGgml {
                 `(engine is ${this._engineType})`);
         }
     }
+    _assertMossSoundEffectOptionConsistency() {
+        if (this._engineType !== ENGINE_MOSS_SFX)
+            return;
+        if (this._enhancerGgufPath || this._denoiserGgufPath) {
+            throw new Error("tts-ggml: the LavaSR enhancer/denoiser are not supported with " +
+                "the moss-sfx engine. Drop lavasrEnhancer / lavasrDenoiser.");
+        }
+        if (this._referenceAudio) {
+            throw new Error("tts-ggml: referenceAudio is not supported by the moss-sfx engine, " +
+                "which generates sound effects from a text prompt");
+        }
+        if (this._steps != null) {
+            throw new Error("tts-ggml: the moss-sfx engine takes steps per call " +
+                "(run({ input, steps })), not in the constructor");
+        }
+        this._assertMossSoundEffectOutputRate();
+        if (!this._mossSoundEffectPath) {
+            throw new Error("tts-ggml: the moss-sfx engine needs its GGUF: stage " +
+                "moss-sfx-*.gguf in modelDir or set files.mossSoundEffect");
+        }
+    }
+    _assertMossSpeechOptionConsistency() {
+        if (this._engineType !== ENGINE_MOSS_SPEECH)
+            return;
+        if (this._enhancerGgufPath || this._denoiserGgufPath) {
+            throw new Error("tts-ggml: the LavaSR enhancer/denoiser are not supported with " +
+                "the moss-speech engine. Drop lavasrEnhancer / lavasrDenoiser.");
+        }
+        if (this._referenceAudio) {
+            throw new Error("tts-ggml: the moss-speech engine takes its reply voice per call " +
+                "(run({ replyVoice, replyVoiceSampleRate })), not referenceAudio");
+        }
+        this._assertMossSpeechOutputRate();
+        if (!this._mossSpeechModelPath || !this._mossSpeechCodecPath) {
+            throw new Error("tts-ggml: the moss-speech engine needs its model and codec GGUFs: " +
+                "stage moss-speech-*.gguf and moss-speech-codec-*.gguf in modelDir " +
+                "or set files.mossSpeechModel and files.mossSpeechCodec");
+        }
+    }
+    _assertMossSpeechOutputRate() {
+        if (this._outputSampleRate == null ||
+            this._outputSampleRate === MOSS_SPEECH_NATIVE_SAMPLE_RATE) {
+            return;
+        }
+        throw new Error(`tts-ggml: the moss-speech engine outputs ${MOSS_SPEECH_NATIVE_SAMPLE_RATE} Hz ` +
+            `audio and cannot resample (outputSampleRate=${this._outputSampleRate})`);
+    }
+    _assertMossSoundEffectOutputRate() {
+        if (this._outputSampleRate == null ||
+            this._outputSampleRate === MOSS_SFX_NATIVE_SAMPLE_RATE) {
+            return;
+        }
+        throw new Error(`tts-ggml: the moss-sfx engine outputs ${MOSS_SFX_NATIVE_SAMPLE_RATE} Hz ` +
+            `audio and cannot resample (outputSampleRate=${this._outputSampleRate})`);
+    }
     _assertMossOptionConsistency() {
         if (this._engineType !== ENGINE_MOSS) {
             this._assertNoMossOnlyOptions();
@@ -1411,6 +1719,14 @@ class TTSGgml {
         }
     }
     _assertSentenceStreamingAllowed(where) {
+        if (this._engineType === ENGINE_MOSS_SPEECH) {
+            throw new Error(`tts-ggml: ${where}: the moss-speech engine answers one turn at a ` +
+                "time and does not stream; use run()");
+        }
+        if (this._engineType === ENGINE_MOSS_SFX) {
+            throw new Error(`tts-ggml: ${where}: the moss-sfx engine generates a whole sound ` +
+                "effect from one prompt and does not stream; use run()");
+        }
         if (this._dialogueReferences === undefined)
             return;
         throw new Error(`tts-ggml: ${where}: MOSS dialogue cannot be split into sentences, ` +
@@ -1592,22 +1908,70 @@ class TTSGgml {
         this._assertAudio8VoiceConsistent(this._mergeAudio8Voice(fields), where);
         return fields;
     }
+    _assertNoSpeechFields(source, where) {
+        const fields = pickSpeechFields(source);
+        if (!fields)
+            return;
+        throw new Error(`tts-ggml: ${where}: ${Object.keys(fields).join(", ")} are ` +
+            `moss-speech-only options (engine is ${this._engineType})`);
+    }
+    _assertNoOtherEngineFields(source, where) {
+        this._resolveConditioningJobFields(source, where, this._resolveJobInstruct(source, where));
+        this._resolveAudio8JobFields(source, where);
+        this._resolveSoundEffectJobFields(source, where);
+    }
+    /**
+     * Validate the MOSS-Speech call and fold the new user turn (spoken `audio`
+     * or text `input`) and `systemPrompt` into the native `messages` list.
+     */
+    _resolveSpeechJobFields(source, where) {
+        const fields = source ?? {};
+        assertSpeechCall(fields, where);
+        return {
+            messages: speechMessages(fields),
+            ...speechReplyVoice(fields),
+            ...speechControls(fields),
+        };
+    }
+    /**
+     * Extract + validate the per-call MOSS-SoundEffect controls from a run
+     * input. Returns undefined when none are present.
+     */
+    _resolveSoundEffectJobFields(source, where) {
+        const fields = pickSoundEffectFields(source);
+        if (!fields)
+            return undefined;
+        if (this._engineType !== ENGINE_MOSS_SFX) {
+            throw new Error(`tts-ggml: ${where}: ${Object.keys(fields).join(", ")} are ` +
+                `moss-sfx-only options (engine is ${this._engineType})`);
+        }
+        assertSoundEffectFields(fields);
+        return fields;
+    }
     /**
      * The per-call fields of whichever engine is loaded, if any are set. Parler
      * takes the full description/template surface, Audio8 its voice override,
      * and every engine the cross-engine conditioning it supports.
      */
     _resolveJobFields(source, where) {
+        if (this._engineType === ENGINE_MOSS_SPEECH) {
+            this._assertNoOtherEngineFields(source, where);
+            return this._resolveSpeechJobFields(source, where);
+        }
         const instruct = this._resolveJobInstruct(source, where);
         const engineFields = this._engineType === ENGINE_PARLER
             ? this._resolveParlerJobFields(source, where)
             : this._resolveConditioningJobFields(source, where, instruct);
         const audio8 = this._resolveAudio8JobFields(source, where);
-        if (!engineFields && !audio8 && instruct === undefined)
+        const soundEffect = this._resolveSoundEffectJobFields(source, where);
+        this._assertNoSpeechFields(source, where);
+        if (!engineFields && !audio8 && !soundEffect && instruct === undefined) {
             return undefined;
+        }
         return {
             ...(engineFields ?? {}),
             ...(audio8 ?? {}),
+            ...(soundEffect ?? {}),
             ...(instruct === undefined ? {} : { instruct }),
         };
     }
@@ -1961,6 +2325,12 @@ class TTSGgml {
         if (this._engineType === ENGINE_MOSS) {
             return this._buildMossParams();
         }
+        if (this._engineType === ENGINE_MOSS_SFX) {
+            return this._buildMossSoundEffectParams();
+        }
+        if (this._engineType === ENGINE_MOSS_SPEECH) {
+            return this._buildMossSpeechParams();
+        }
         return this._buildChatterboxParams();
     }
     _buildCosyvoiceParams() {
@@ -2254,6 +2624,25 @@ class TTSGgml {
         this._assignBackendParams(parameters);
         return parameters;
     }
+    _buildMossSoundEffectParams() {
+        this._assertMossSoundEffectOutputRate();
+        const parameters = {
+            engineType: ENGINE_MOSS_SFX,
+            mossSoundEffectPath: this._mossSoundEffectPath || "",
+        };
+        this._assignBackendParams(parameters);
+        return parameters;
+    }
+    _buildMossSpeechParams() {
+        this._assertMossSpeechOutputRate();
+        const parameters = {
+            engineType: ENGINE_MOSS_SPEECH,
+            mossSpeechModelPath: this._mossSpeechModelPath || "",
+            mossSpeechCodecPath: this._mossSpeechCodecPath || "",
+        };
+        this._assignBackendParams(parameters);
+        return parameters;
+    }
     /** The knobs every engine in SAMPLING_ENGINES reads. */
     _assignSamplingParams(parameters) {
         if (this._temperature != null) {

package/lib/fit.d.ts

@@ -69,10 +69,30 @@ export interface CosyvoiceFitRequest extends TtsFitCommon {
 export interface MossFitRequest extends TtsFitCommon {
     engineType: 'moss';
     mossBackbonePath: string;
-    mossCodecDecoderPath?: string;
+    mossCodecDecoderPath: string;
     mossCodecEncoderPath?: string;
+    /** Rows in the complete native prompt, including reference and dialogue rows. */
+    promptRows: number;
+    /** Total mono reference samples; use 0 for a voice without a reference. */
+    referenceSamples: number;
+    /** Project native chunk streaming when true, batch synthesis when false. */
+    streaming: boolean;
+    threads?: number;
+    streamChunkTokens?: number;
+    durationTokens?: number;
 }
-export type TtsFitRequest = SupertonicFitRequest | ParlerFitRequest | ChatterboxFitRequest | Audio8FitRequest | CosyvoiceFitRequest | MossFitRequest;
+export interface MossSoundEffectFitRequest extends TtsFitCommon {
+    engineType: 'moss-sfx';
+    mossSoundEffectPath: string;
+    prompt: string;
+    seconds: number;
+    negativePrompt?: string;
+    steps?: number;
+    guidance?: number;
+    shift?: number;
+    threads?: number;
+}
+export type TtsFitRequest = SupertonicFitRequest | ParlerFitRequest | ChatterboxFitRequest | Audio8FitRequest | CosyvoiceFitRequest | MossFitRequest | MossSoundEffectFitRequest;
 /** The voice engines a fit can be asked for, read off the request union. */
 export type TtsFitEngine = TtsFitRequest['engineType'];
 export type TtsFitStatus = 'fits' | 'does-not-fit' | 'error';