@qvac/tts-ggml 0.13.0 → 0.14.1

package/lib/engines/mossSoundEffect.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOSS_SFX_CALL_KEYS = exports.MOSS_SFX_MAX_SHIFT = exports.MOSS_SFX_MAX_GUIDANCE = exports.MOSS_SFX_MAX_STEPS = exports.MOSS_SFX_MAX_SECONDS = exports.MOSS_SFX_NATIVE_SAMPLE_RATE = exports.MOSS_SFX_RE = void 0;
+exports.assertSoundEffectFields = assertSoundEffectFields;
+exports.pickSoundEffectFields = pickSoundEffectFields;
+exports.resolveMossSoundEffectModelPaths = resolveMossSoundEffectModelPaths;
+exports.assertMossSoundEffectOptions = assertMossSoundEffectOptions;
+exports.resolveSoundEffectJobFields = resolveSoundEffectJobFields;
+exports.buildMossSoundEffectParams = buildMossSoundEffectParams;
+const engineIds_1 = require("../engineIds");
+const modelFiles_1 = require("../modelFiles");
+const nativeParams_1 = require("../nativeParams");
+exports.MOSS_SFX_RE = /^moss-sfx(-[a-z0-9_]+)*\.gguf$/i;
+exports.MOSS_SFX_NATIVE_SAMPLE_RATE = 48000;
+exports.MOSS_SFX_MAX_SECONDS = 30;
+exports.MOSS_SFX_MAX_STEPS = 1000;
+exports.MOSS_SFX_MAX_GUIDANCE = 50;
+exports.MOSS_SFX_MAX_SHIFT = 100;
+exports.MOSS_SFX_CALL_KEYS = [
+    "seconds",
+    "negativePrompt",
+    "steps",
+    "guidance",
+    "shift",
+];
+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 <= exports.MOSS_SFX_MAX_SECONDS, `in (0, ${exports.MOSS_SFX_MAX_SECONDS}]`);
+    }
+    if (fields.steps !== undefined) {
+        assertSoundEffectRange("steps", fields.steps, (n) => Number.isInteger(n) && n >= 1 && n <= exports.MOSS_SFX_MAX_STEPS, `an integer in [1, ${exports.MOSS_SFX_MAX_STEPS}]`);
+    }
+    if (fields.guidance !== undefined) {
+        assertSoundEffectRange("guidance", fields.guidance, (n) => n >= 1 && n <= exports.MOSS_SFX_MAX_GUIDANCE, `in [1, ${exports.MOSS_SFX_MAX_GUIDANCE}]`);
+    }
+    if (fields.shift !== undefined) {
+        assertSoundEffectRange("shift", fields.shift, (n) => n > 0 && n <= exports.MOSS_SFX_MAX_SHIFT, `in (0, ${exports.MOSS_SFX_MAX_SHIFT}]`);
+    }
+    if (fields.negativePrompt !== undefined && typeof fields.negativePrompt !== "string") {
+        throw new Error("tts-ggml: moss-sfx negativePrompt must be a string");
+    }
+}
+/**
+ * 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 = exports.MOSS_SFX_CALL_KEYS.filter((key) => source[key] !== undefined);
+    if (present.length === 0)
+        return undefined;
+    return Object.fromEntries(present.map((key) => [key, source[key]]));
+}
+function resolveMossSoundEffectModelPaths(files) {
+    return {
+        mossSoundEffectPath: (0, modelFiles_1.firstNonEmpty)(files.mossSoundEffect, (0, modelFiles_1.findQuantRankedGguf)(files.modelDir, exports.MOSS_SFX_RE)),
+    };
+}
+function assertMossSoundEffectOptions(setup) {
+    if (setup.engineType !== engineIds_1.ENGINE_MOSS_SFX)
+        return;
+    if (setup.backend.enhancerGgufPath || setup.backend.denoiserGgufPath) {
+        throw new Error("tts-ggml: the LavaSR enhancer/denoiser are not supported with " +
+            "the moss-sfx engine. Drop lavasrEnhancer / lavasrDenoiser.");
+    }
+    if (setup.settings.referenceAudio) {
+        throw new Error("tts-ggml: referenceAudio is not supported by the moss-sfx engine, " +
+            "which generates sound effects from a text prompt");
+    }
+    if (setup.settings.steps != null) {
+        throw new Error("tts-ggml: the moss-sfx engine takes steps per call " +
+            "(run({ input, steps })), not in the constructor");
+    }
+    assertMossSoundEffectOutputRate(setup);
+    if (!setup.paths.mossSoundEffectPath) {
+        throw new Error("tts-ggml: the moss-sfx engine needs its GGUF: stage " +
+            "moss-sfx-*.gguf in modelDir or set files.mossSoundEffect");
+    }
+}
+function assertMossSoundEffectOutputRate(setup) {
+    if (setup.outputSampleRate == null ||
+        setup.outputSampleRate === exports.MOSS_SFX_NATIVE_SAMPLE_RATE) {
+        return;
+    }
+    throw new Error(`tts-ggml: the moss-sfx engine outputs ${exports.MOSS_SFX_NATIVE_SAMPLE_RATE} Hz ` +
+        `audio and cannot resample (outputSampleRate=${setup.outputSampleRate})`);
+}
+/**
+ * Extract + validate the per-call MOSS-SoundEffect controls from a run
+ * input. Returns undefined when none are present.
+ */
+function resolveSoundEffectJobFields(setup, source, where) {
+    const fields = pickSoundEffectFields(source);
+    if (!fields)
+        return undefined;
+    if (setup.engineType !== engineIds_1.ENGINE_MOSS_SFX) {
+        throw new Error(`tts-ggml: ${where}: ${Object.keys(fields).join(", ")} are ` +
+            `moss-sfx-only options (engine is ${setup.engineType})`);
+    }
+    assertSoundEffectFields(fields);
+    return fields;
+}
+function buildMossSoundEffectParams(setup) {
+    assertMossSoundEffectOutputRate(setup);
+    const parameters = {
+        engineType: engineIds_1.ENGINE_MOSS_SFX,
+        mossSoundEffectPath: setup.paths.mossSoundEffectPath || "",
+    };
+    (0, nativeParams_1.assignBackendParams)(setup, parameters);
+    return parameters;
+}

package/lib/engines/mossSpeech.d.ts

@@ -0,0 +1,86 @@
+import type { TTSConfigurationParams } from "../../tts";
+import type { EngineSetup, ModelPaths } from "../engineSetup";
+import { type NormalizedFiles } from "../modelFiles";
+export declare const MOSS_SPEECH_RE: RegExp;
+export declare const MOSS_SPEECH_CODEC_RE: RegExp;
+export declare const MOSS_SPEECH_NATIVE_SAMPLE_RATE = 24000;
+export declare const MOSS_SPEECH_MIN_SAMPLE_RATE = 8000;
+export declare const MOSS_SPEECH_MAX_SAMPLE_RATE = 192000;
+export declare const MOSS_SPEECH_MAX_NEW_TOKENS = 4096;
+export declare const MOSS_SPEECH_MAX_REPLY_SECONDS = 3600;
+export declare const MOSS_SPEECH_MAX_TEMPERATURE = 10;
+export declare const MOSS_SPEECH_MAX_TOP_P = 1;
+export declare const MOSS_SPEECH_ROLES: readonly ["system", "user", "assistant"];
+export declare const MOSS_SPEECH_ONLY_KEYS: readonly ["audio", "sampleRate", "messages", "systemPrompt", "replyVoice", "replyVoiceSampleRate", "textReply", "maxReplySeconds", "maxNewTokens"];
+export declare const MOSS_SPEECH_CONTROL_KEYS: readonly ["textReply", "maxReplySeconds", "maxNewTokens", "greedy", "temperature", "topP", "topK"];
+/** Mono PCM accepted by the MOSS-Speech engine: 16-bit integers or floats in [-1, 1]. */
+export type MossSpeechPcm = Int16Array | Float32Array;
+/** One conversation turn for the MOSS-Speech engine: text or audio, never both. */
+export interface MossSpeechMessage {
+    role: (typeof MOSS_SPEECH_ROLES)[number];
+    text?: string;
+    audio?: MossSpeechPcm;
+    /** Sample rate of `audio`, 8000..192000 Hz. */
+    sampleRate?: number;
+}
+/**
+ * MOSS-Speech per-call fields (moss-speech only). The user turn is `audio`
+ * (with `sampleRate`) or the run `input` text; `messages` carries the earlier
+ * conversation.
+ */
+export interface MossSpeechFields {
+    /** The user's spoken turn, mono PCM. */
+    audio?: MossSpeechPcm;
+    /** Sample rate of `audio`, 8000..192000 Hz. */
+    sampleRate?: number;
+    /** Earlier turns, oldest first; the new user turn is appended after them. */
+    messages?: MossSpeechMessage[];
+    /** A system turn placed first; replaces the model's default system prompt. */
+    systemPrompt?: string;
+    /** Reply voice prompt (up to 60 s of mono PCM); the codec's default voice otherwise. */
+    replyVoice?: MossSpeechPcm;
+    /** Sample rate of `replyVoice`, 8000..192000 Hz. */
+    replyVoiceSampleRate?: number;
+    /** Reply with text only (no audio); the text comes back as `text`. */
+    textReply?: boolean;
+    /** Cut the spoken reply after this many seconds (0 = no cut). */
+    maxReplySeconds?: number;
+    /** Explicit bound on generated rows, 1..4096; omitted uses remaining model context. */
+    maxNewTokens?: number;
+    /** Greedy decoding instead of sampling. */
+    greedy?: boolean;
+    /** Sampling temperature, (0, 10] (default 0.7). */
+    temperature?: number;
+    /** Nucleus sampling, (0, 1] (default 0.95). */
+    topP?: number;
+    /** Top-k sampling, >= 0 (default 20). */
+    topK?: number;
+}
+/** The MOSS-Speech fields sent to the native job, with the user turn folded into `messages`. */
+export interface MossSpeechJobFields {
+    messages?: MossSpeechMessage[];
+    replyVoice?: MossSpeechPcm;
+    replyVoiceSampleRate?: number;
+    textReply?: boolean;
+    maxReplySeconds?: number;
+    maxNewTokens?: number;
+    greedy?: boolean;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}
+export declare function assertSpeechCall(fields: MossSpeechFields & {
+    input?: string;
+}, where: string): void;
+/** Collect the fields only MOSS-Speech reads that are present on `source`; undefined when none are set. */
+export declare function pickSpeechFields(source: MossSpeechFields | null | undefined): Partial<MossSpeechFields> | undefined;
+export declare function resolveMossSpeechModelPaths(files: NormalizedFiles): Pick<ModelPaths, "mossSpeechModelPath" | "mossSpeechCodecPath">;
+export declare function assertMossSpeechOptions(setup: EngineSetup): void;
+/**
+ * Validate the MOSS-Speech call and fold the new user turn (spoken `audio`
+ * or text `input`) and `systemPrompt` into the native `messages` list.
+ */
+export declare function resolveSpeechJobFields(source: (MossSpeechFields & {
+    input?: string;
+}) | null | undefined, where: string): MossSpeechJobFields;
+export declare function buildMossSpeechParams(setup: EngineSetup): TTSConfigurationParams;

package/lib/engines/mossSpeech.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOSS_SPEECH_CONTROL_KEYS = exports.MOSS_SPEECH_ONLY_KEYS = exports.MOSS_SPEECH_ROLES = exports.MOSS_SPEECH_MAX_TOP_P = exports.MOSS_SPEECH_MAX_TEMPERATURE = exports.MOSS_SPEECH_MAX_REPLY_SECONDS = exports.MOSS_SPEECH_MAX_NEW_TOKENS = exports.MOSS_SPEECH_MAX_SAMPLE_RATE = exports.MOSS_SPEECH_MIN_SAMPLE_RATE = exports.MOSS_SPEECH_NATIVE_SAMPLE_RATE = exports.MOSS_SPEECH_CODEC_RE = exports.MOSS_SPEECH_RE = void 0;
+exports.assertSpeechCall = assertSpeechCall;
+exports.pickSpeechFields = pickSpeechFields;
+exports.resolveMossSpeechModelPaths = resolveMossSpeechModelPaths;
+exports.assertMossSpeechOptions = assertMossSpeechOptions;
+exports.resolveSpeechJobFields = resolveSpeechJobFields;
+exports.buildMossSpeechParams = buildMossSpeechParams;
+const engineIds_1 = require("../engineIds");
+const modelFiles_1 = require("../modelFiles");
+const nativeParams_1 = require("../nativeParams");
+exports.MOSS_SPEECH_RE = /^moss-speech(-(?!codec)[a-z0-9_]+)?\.gguf$/i;
+exports.MOSS_SPEECH_CODEC_RE = /^moss-speech-codec(-[a-z0-9_]+)?\.gguf$/i;
+exports.MOSS_SPEECH_NATIVE_SAMPLE_RATE = 24000;
+exports.MOSS_SPEECH_MIN_SAMPLE_RATE = 8000;
+exports.MOSS_SPEECH_MAX_SAMPLE_RATE = 192000;
+exports.MOSS_SPEECH_MAX_NEW_TOKENS = 4096;
+exports.MOSS_SPEECH_MAX_REPLY_SECONDS = 3600;
+exports.MOSS_SPEECH_MAX_TEMPERATURE = 10;
+exports.MOSS_SPEECH_MAX_TOP_P = 1;
+exports.MOSS_SPEECH_ROLES = ["system", "user", "assistant"];
+exports.MOSS_SPEECH_ONLY_KEYS = [
+    "audio",
+    "sampleRate",
+    "messages",
+    "systemPrompt",
+    "replyVoice",
+    "replyVoiceSampleRate",
+    "textReply",
+    "maxReplySeconds",
+    "maxNewTokens",
+];
+exports.MOSS_SPEECH_CONTROL_KEYS = [
+    "textReply",
+    "maxReplySeconds",
+    "maxNewTokens",
+    "greedy",
+    "temperature",
+    "topP",
+    "topK",
+];
+function isSpeechPcm(value) {
+    return value instanceof Int16Array || value instanceof Float32Array;
+}
+function assertSpeechSampleRate(value, name, where) {
+    if (typeof value === "number" &&
+        Number.isInteger(value) &&
+        value >= exports.MOSS_SPEECH_MIN_SAMPLE_RATE &&
+        value <= exports.MOSS_SPEECH_MAX_SAMPLE_RATE) {
+        return;
+    }
+    throw new Error(`tts-ggml: ${where}: moss-speech ${name} must be an integer in ` +
+        `[${exports.MOSS_SPEECH_MIN_SAMPLE_RATE}, ${exports.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 (!exports.MOSS_SPEECH_ROLES.includes(turn.role)) {
+        throw new Error(`tts-ggml: ${where}: moss-speech ${label}.role must be one of ${exports.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 <= exports.MOSS_SPEECH_MAX_REPLY_SECONDS, `in [0, ${exports.MOSS_SPEECH_MAX_REPLY_SECONDS}]`, where);
+    assertSpeechRange("maxNewTokens", fields.maxNewTokens, (n) => Number.isInteger(n) && n >= 1 && n <= exports.MOSS_SPEECH_MAX_NEW_TOKENS, `an integer in [1, ${exports.MOSS_SPEECH_MAX_NEW_TOKENS}]`, where);
+    assertSpeechRange("temperature", fields.temperature, (n) => n > 0 && n <= exports.MOSS_SPEECH_MAX_TEMPERATURE, `in (0, ${exports.MOSS_SPEECH_MAX_TEMPERATURE}]`, where);
+    assertSpeechRange("topP", fields.topP, (n) => n > 0 && n <= exports.MOSS_SPEECH_MAX_TOP_P, `in (0, ${exports.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 = exports.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 = exports.MOSS_SPEECH_ONLY_KEYS.filter((key) => source[key] !== undefined);
+    if (present.length === 0)
+        return undefined;
+    return Object.fromEntries(present.map((key) => [key, source[key]]));
+}
+function resolveMossSpeechModelPaths(files) {
+    return {
+        mossSpeechModelPath: (0, modelFiles_1.firstNonEmpty)(files.mossSpeechModel, (0, modelFiles_1.findQuantRankedGguf)(files.modelDir, exports.MOSS_SPEECH_RE)),
+        mossSpeechCodecPath: (0, modelFiles_1.firstNonEmpty)(files.mossSpeechCodec, (0, modelFiles_1.findQuantRankedGguf)(files.modelDir, exports.MOSS_SPEECH_CODEC_RE)),
+    };
+}
+function assertMossSpeechOptions(setup) {
+    if (setup.engineType !== engineIds_1.ENGINE_MOSS_SPEECH)
+        return;
+    if (setup.backend.enhancerGgufPath || setup.backend.denoiserGgufPath) {
+        throw new Error("tts-ggml: the LavaSR enhancer/denoiser are not supported with " +
+            "the moss-speech engine. Drop lavasrEnhancer / lavasrDenoiser.");
+    }
+    if (setup.settings.referenceAudio) {
+        throw new Error("tts-ggml: the moss-speech engine takes its reply voice per call " +
+            "(run({ replyVoice, replyVoiceSampleRate })), not referenceAudio");
+    }
+    assertMossSpeechOutputRate(setup);
+    if (!setup.paths.mossSpeechModelPath || !setup.paths.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");
+    }
+}
+function assertMossSpeechOutputRate(setup) {
+    if (setup.outputSampleRate == null ||
+        setup.outputSampleRate === exports.MOSS_SPEECH_NATIVE_SAMPLE_RATE) {
+        return;
+    }
+    throw new Error(`tts-ggml: the moss-speech engine outputs ${exports.MOSS_SPEECH_NATIVE_SAMPLE_RATE} Hz ` +
+        `audio and cannot resample (outputSampleRate=${setup.outputSampleRate})`);
+}
+/**
+ * Validate the MOSS-Speech call and fold the new user turn (spoken `audio`
+ * or text `input`) and `systemPrompt` into the native `messages` list.
+ */
+function resolveSpeechJobFields(source, where) {
+    const fields = source ?? {};
+    assertSpeechCall(fields, where);
+    return {
+        messages: speechMessages(fields),
+        ...speechReplyVoice(fields),
+        ...speechControls(fields),
+    };
+}
+function buildMossSpeechParams(setup) {
+    assertMossSpeechOutputRate(setup);
+    const parameters = {
+        engineType: engineIds_1.ENGINE_MOSS_SPEECH,
+        mossSpeechModelPath: setup.paths.mossSpeechModelPath || "",
+        mossSpeechCodecPath: setup.paths.mossSpeechCodecPath || "",
+    };
+    (0, nativeParams_1.assignBackendParams)(setup, parameters);
+    return parameters;
+}

package/lib/engines/parler.d.ts

@@ -0,0 +1,71 @@
+import type { TTSConfigurationParams } from "../../tts";
+import { type TTSConditioningFields } from "../conditioning";
+import type { EngineSetup, ModelPaths } from "../engineSetup";
+import { type NormalizedFiles } from "../modelFiles";
+export declare const PARLER_RE: RegExp;
+export declare const PARLER_VARIANT_ORDER: string[];
+export declare const PARLER_QUANT_ORDER: string[];
+export declare const PARLER_DESCRIPTION_KEYS: readonly ["description", "voiceDescription"];
+export declare const PARLER_TEMPLATE_KEYS: readonly ["voice", "emotion", "pitch", "pace", "expressivity", "noise", "reverb", "quality"];
+export declare const PARLER_ONLY_TEMPLATE_KEYS: readonly ["voice", "pitch", "expressivity", "noise", "reverb", "quality"];
+export declare const PARLER_FIELD_KEYS: readonly ["description", "voiceDescription", "voice", "emotion", "pitch", "pace", "expressivity", "noise", "reverb", "quality"];
+export declare const PARLER_ONLY_KEYS: readonly ["description", "voiceDescription", "voice", "pitch", "expressivity", "noise", "reverb", "quality"];
+export type ParlerFieldKey = (typeof PARLER_FIELD_KEYS)[number];
+export type ParlerDescFields = Partial<Record<ParlerFieldKey, string>>;
+export type ParlerJobSource = ParlerDescriptionFields & TTSConditioningFields;
+/**
+ * Parler voice-description inputs. Either a free-text `description` (alias
+ * `voiceDescription`) or the template fields, rendered natively through
+ * tts-cpp's build_description(); mixing the two at the same level is rejected.
+ * Accepted at construction, on `reload()`, and per call (Parler only).
+ * `emotion` and `pace` moved to TTSConditioningFields -- Parler still renders
+ * both, but they are no longer Parler-only at the JS surface.
+ */
+export interface ParlerDescriptionFields {
+    description?: string;
+    voiceDescription?: string;
+    /** Parler voice-template field; also Supertonic's baked voice id. */
+    voice?: string;
+    pitch?: string;
+    expressivity?: string;
+    noise?: string;
+    reverb?: string;
+    quality?: string;
+}
+/**
+ * Find a Parler GGUF in `modelDir`, ranked by variant (mini before large
+ * before indic) and, within a variant, by quant tier (q8_0 > q6_k > f16 > f32;
+ * a bare `parler-<variant>.gguf` wins as forward-compat).
+ */
+export declare function findParlerInDir(modelDir?: string): string | undefined;
+/**
+ * Collect the Parler description/template properties present on `source`
+ * (a run input, streaming options, or constructor options). Returns undefined
+ * when none are set.
+ */
+export declare function pickParlerDescFields(source: ParlerJobSource | null | undefined): ParlerDescFields | undefined;
+/**
+ * Same-level conflict check: a free-text description cannot be merged with
+ * template fields, so setting both together is an error.
+ */
+export declare function assertParlerDescFieldsConsistent(fields: ParlerDescFields | undefined, where: string): void;
+export declare function resolveParlerModelPaths(files: NormalizedFiles): Pick<ModelPaths, "parlerModelPath">;
+/**
+ * Constructor-time rules: on Parler the description and template fields are
+ * mutually exclusive; on every other engine the Parler-only options are
+ * rejected by name.
+ */
+export declare function assertParlerOptions(setup: EngineSetup): void;
+/**
+ * Parler's per-call surface: description/template fields, where a per-call
+ * template cannot be merged with a constructor-level free-text description.
+ */
+export declare function resolveParlerJobFields(setup: EngineSetup, source: ParlerJobSource | null | undefined, where: string): ParlerDescFields | undefined;
+export declare function buildParlerParams(setup: EngineSetup): TTSConfigurationParams;
+/**
+ * Parler description/template + sampling knobs are reloadable; they rebuild
+ * the engine's default description / sampler. `buildParlerParams`
+ * re-validates afterwards, so a description/template conflict introduced by a
+ * reload still throws (and the caller rolls the settings back).
+ */
+export declare function applyParlerReload(setup: EngineSetup, newConfig: Record<string, unknown>): void;